ironflow-core 2.8.0

Rust workflow engine with Claude Code native agent support
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! Tests for Shell-centric workflows: basic, parallel, failure, timeout.

use ironflow_core::prelude::*;

use crate::helpers::*;

#[tokio::test]
async fn shell_then_agent_with_tracker() {
    let (fixtures_dir, _guard) = temp_fixtures_dir("shell-agent");

    let shell_output = Shell::new("echo 'file1.rs file2.rs file3.rs'")
        .await
        .unwrap();
    assert_eq!(shell_output.stdout(), "file1.rs file2.rs file3.rs");

    let prompt = format!("Summarize these files:\n\n{}", shell_output.stdout());
    let config = make_config(&prompt, Some("You are a concise assistant."), None);
    let agent_output = make_output(
        serde_json::json!(
            "The directory contains 3 Rust source files: file1.rs, file2.rs, and file3.rs."
        ),
        0.005,
        1000,
        50,
    );
    write_fixture(&fixtures_dir, &config, &agent_output);

    let provider = ironflow_core::providers::record_replay::RecordReplayProvider::replay(
        ClaudeCodeProvider::new(),
        &fixtures_dir,
    );

    let result = Agent::new()
        .system_prompt("You are a concise assistant.")
        .prompt(&prompt)
        .model(Model::HAIKU)
        .max_turns(1)
        .max_budget_usd(0.10)
        .run(&provider)
        .await
        .unwrap();

    assert!(result.text().contains("3 Rust source files"));
    assert_eq!(result.cost_usd(), Some(0.005));

    let mut tracker = WorkflowTracker::new("file-summary");
    tracker.record_shell("ls", &shell_output);
    tracker.record_agent("summarize", &result);

    assert_eq!(tracker.step_count(), 2);
    assert_eq!(tracker.total_cost_usd(), 0.005);
    assert_eq!(tracker.total_input_tokens(), 1000);
    assert_eq!(tracker.total_output_tokens(), 50);
    tracker.summary();
}

#[tokio::test]
async fn multi_shell_then_agent() {
    let (fixtures_dir, _guard) = temp_fixtures_dir("multi-shell");

    let uname = Shell::new("echo 'Linux test-host 6.1'").await.unwrap();
    let disk = Shell::new("echo 'Filesystem Size Used Avail Use%'")
        .await
        .unwrap();

    let prompt = format!(
        "System info:\nOS: {}\nDisk: {}\nSummarize in one line.",
        uname.stdout(),
        disk.stdout()
    );
    let config = make_config(&prompt, None, None);
    let agent_output = make_output(
        serde_json::json!("Linux test-host 6.1 with disk usage information available."),
        0.003,
        800,
        30,
    );
    write_fixture(&fixtures_dir, &config, &agent_output);

    let provider = ironflow_core::providers::record_replay::RecordReplayProvider::replay(
        ClaudeCodeProvider::new(),
        &fixtures_dir,
    );

    let result = Agent::new()
        .prompt(&prompt)
        .model(Model::HAIKU)
        .max_turns(1)
        .max_budget_usd(0.10)
        .run(&provider)
        .await
        .unwrap();

    assert!(result.text().contains("Linux"));

    let mut tracker = WorkflowTracker::new("system-report");
    tracker.record_shell("uname", &uname);
    tracker.record_shell("disk", &disk);
    tracker.record_agent("summarize", &result);

    assert_eq!(tracker.step_count(), 3);
    assert_eq!(tracker.total_cost_usd(), 0.003);
}

#[tokio::test]
async fn parallel_shells_then_agent() {
    let (fixtures_dir, _guard) = temp_fixtures_dir("parallel");

    let (cpu, mem) = tokio::join!(Shell::new("echo '4 cores'"), Shell::new("echo '16GB RAM'"),);
    let cpu = cpu.unwrap();
    let mem = mem.unwrap();

    assert_eq!(cpu.stdout(), "4 cores");
    assert_eq!(mem.stdout(), "16GB RAM");

    let prompt = format!(
        "CPU: {}\nMemory: {}\nSummarize.",
        cpu.stdout(),
        mem.stdout()
    );
    let config = make_config(&prompt, None, None);
    let agent_output = make_output(
        serde_json::json!("System has 4 CPU cores and 16GB of RAM."),
        0.004,
        900,
        35,
    );
    write_fixture(&fixtures_dir, &config, &agent_output);

    let provider = ironflow_core::providers::record_replay::RecordReplayProvider::replay(
        ClaudeCodeProvider::new(),
        &fixtures_dir,
    );

    let result = Agent::new()
        .prompt(&prompt)
        .model(Model::HAIKU)
        .max_turns(1)
        .max_budget_usd(0.10)
        .run(&provider)
        .await
        .unwrap();

    assert!(result.text().contains("4 CPU cores"));
    assert!(result.text().contains("16GB"));
}