smol-workflow-engine 0.2.1

Rust implementation of the smol-workflows engine.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use serde_json::json;
use smol_workflow_engine::agent_providers::{
    generate_debug_value_from_schema, AgentProvider, AgentProviderContext, AgentProviderRunInput,
    AgentProviderSchemaMode, AgentProviderUsageMode, DebugAgentProvider,
};

#[tokio::test(flavor = "current_thread")]
async fn debug_provider_echoes_text_when_schema_is_omitted() {
    let provider = DebugAgentProvider::new();
    let result = provider
        .run(AgentProviderRunInput {
            prompt: "hello".to_string(),
            options: None,
            context: AgentProviderContext::default(),
        })
        .await
        .expect("debug provider should run");

    assert_eq!(provider.name(), "debug");
    assert_eq!(provider.schema_mode(), AgentProviderSchemaMode::Builtin);
    assert_eq!(provider.usage_mode(), AgentProviderUsageMode::Builtin);
    assert_eq!(result.output, json!("echo: hello"));
    assert_eq!(
        result.usage.as_ref().and_then(|usage| usage.input_tokens),
        Some(2)
    );
    assert!(result
        .usage
        .as_ref()
        .and_then(|usage| usage.output_tokens)
        .is_some());
}

#[tokio::test(flavor = "current_thread")]
async fn debug_provider_generates_structured_output_from_json_schema() {
    let provider = DebugAgentProvider::new();
    let schema = json!({
        "type": "object",
        "properties": {
            "name": { "type": "string" },
            "count": { "type": "integer" },
            "score": { "type": "number" },
            "ok": { "type": "boolean" },
            "nothing": { "type": "null" },
            "tags": { "type": "array", "items": { "type": "string" } },
            "nested": {
                "type": "object",
                "properties": {
                    "value": { "enum": ["first", "second"] }
                },
                "required": ["value"]
            }
        },
        "required": ["name", "count", "score", "ok", "nothing", "tags", "nested"]
    });

    let result = provider
        .run(AgentProviderRunInput {
            prompt: "structured".to_string(),
            options: Some(json!({ "schema": schema })),
            context: AgentProviderContext::default(),
        })
        .await
        .expect("debug provider should run");

    assert_eq!(
        result.output,
        json!({
            "name": "debug-string",
            "count": 0,
            "score": 0,
            "ok": true,
            "nothing": null,
            "tags": ["debug-string"],
            "nested": { "value": "first" }
        })
    );
}

#[tokio::test(flavor = "current_thread")]
async fn schema_generation_handles_const_formats_tuples_and_all_of() {
    assert_eq!(
        generate_debug_value_from_schema(&json!({ "const": "fixed" })),
        json!("fixed")
    );
    assert_eq!(
        generate_debug_value_from_schema(&json!({ "type": "string", "format": "email" })),
        json!("debug@example.com")
    );
    assert_eq!(
        generate_debug_value_from_schema(&json!({
            "type": "array",
            "prefixItems": [{ "type": "string" }, { "type": "boolean" }]
        })),
        json!(["debug-string", true])
    );
    assert_eq!(
        generate_debug_value_from_schema(&json!({
            "allOf": [
                { "type": "object", "properties": { "a": { "type": "string" } }, "required": ["a"] },
                { "type": "object", "properties": { "b": { "type": "number" } }, "required": ["b"] }
            ]
        })),
        json!({ "a": "debug-string", "b": 0 })
    );
}