crabmate 0.4.0

Rust AI agent: OpenAI-compatible chat/completions, function calling, HTTP serve, ops CLI
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

//! workflow_reflection 控制器金样回归：`fixtures/workflow_reflection_regression.jsonl`。

use serde::Deserialize;
use std::fs;
use std::path::PathBuf;

use crate::agent::workflow_reflection_controller::WorkflowReflectionController;

#[derive(Debug, Deserialize)]
struct GoldenLine {
    id: String,
    default_max_rounds: usize,
    #[serde(default)]
    pre_calls: Vec<String>,
    call: String,
    expect: GoldenExpect,
}

#[derive(Debug, Deserialize)]
struct GoldenExpect {
    execute: bool,
    inject_instruction_type: Option<String>,
    stop_instruction_type: Option<String>,
    validate_only: Option<bool>,
    stage_round: Option<usize>,
}

#[test]
fn golden_workflow_reflection_regression_matches_controller() {
    let root = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    let path = root.join("fixtures/workflow_reflection_regression.jsonl");
    let raw = fs::read_to_string(&path).unwrap_or_else(|e| panic!("read {}: {e}", path.display()));

    for (line_no, line) in raw.lines().enumerate() {
        let t = line.trim();
        if t.is_empty() || t.starts_with('#') {
            continue;
        }
        let row: GoldenLine = serde_json::from_str(t).unwrap_or_else(|e| {
            panic!("{}:{}: invalid json: {e}\n{t}", path.display(), line_no + 1)
        });

        let mut c = WorkflowReflectionController::new(row.default_max_rounds);
        for call in &row.pre_calls {
            let _ = c.decide(call);
        }
        let got = c.decide(&row.call);

        assert_eq!(
            got.execute,
            row.expect.execute,
            "{}:{} ({}) execute mismatch",
            path.display(),
            line_no + 1,
            row.id
        );

        let got_inject = got
            .inject_instruction
            .as_ref()
            .and_then(|v| v.get("instruction_type"))
            .and_then(|v| v.as_str())
            .map(str::to_string);
        assert_eq!(
            got_inject,
            row.expect.inject_instruction_type,
            "{}:{} ({}) inject instruction_type mismatch",
            path.display(),
            line_no + 1,
            row.id
        );

        let got_stop = got
            .stop_output
            .as_ref()
            .and_then(|v| v.get("instruction_type"))
            .and_then(|v| v.as_str())
            .map(str::to_string);
        assert_eq!(
            got_stop,
            row.expect.stop_instruction_type,
            "{}:{} ({}) stop instruction_type mismatch",
            path.display(),
            line_no + 1,
            row.id
        );

        let got_validate_only = got
            .workflow_args_patch
            .as_ref()
            .and_then(|v| v.get("validate_only"))
            .and_then(|v| v.as_bool());
        assert_eq!(
            got_validate_only,
            row.expect.validate_only,
            "{}:{} ({}) validate_only mismatch",
            path.display(),
            line_no + 1,
            row.id
        );

        if let Some(want_round) = row.expect.stage_round {
            assert_eq!(
                c.stage_round(),
                want_round,
                "{}:{} ({}) stage_round mismatch",
                path.display(),
                line_no + 1,
                row.id
            );
        }
    }
}