crabmate 0.5.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
114
115
116
117
118
119

//! 节点输出占位符注入（`{{node.output}}` 等）。

use std::collections::HashMap;

use super::types::{NodeRunResult, NodeRunStatus};

pub(crate) fn inject_placeholders(
    value: &serde_json::Value,
    completed: &HashMap<String, NodeRunResult>,
    max_chars: usize,
) -> serde_json::Value {
    match value {
        serde_json::Value::String(s) => {
            serde_json::Value::String(inject_string(s, completed, max_chars))
        }
        serde_json::Value::Array(arr) => serde_json::Value::Array(
            arr.iter()
                .map(|v| inject_placeholders(v, completed, max_chars))
                .collect(),
        ),
        serde_json::Value::Object(map) => serde_json::Value::Object(
            map.iter()
                .map(|(k, v)| (k.clone(), inject_placeholders(v, completed, max_chars)))
                .collect(),
        ),
        other => other.clone(),
    }
}

fn inject_string(s: &str, completed: &HashMap<String, NodeRunResult>, max_chars: usize) -> String {
    let mut out = String::new();
    let mut rest = s;
    loop {
        let start = match rest.find("{{") {
            Some(i) => i,
            None => {
                out.push_str(rest);
                break;
            }
        };
        let (prefix, tail) = rest.split_at(start);
        out.push_str(prefix);
        let end = match tail.find("}}") {
            Some(i) => i,
            None => {
                // 没有闭合，直接把剩余内容追加
                out.push_str(tail);
                break;
            }
        };
        let inner = tail[2..end].trim(); // skip {{
        let replacement = resolve_placeholder(inner, completed, max_chars);
        out.push_str(&replacement);
        // move past }}
        rest = &tail[end + 2..];
    }
    out
}

fn resolve_placeholder(
    inner: &str,
    completed: &HashMap<String, NodeRunResult>,
    max_chars: usize,
) -> String {
    // 支持：
    // - {{node_id.output}}
    // - {{node_id.status}}
    // - {{node_id.stdout_first_line}}
    // 未来可扩展更多字段。
    let parts: Vec<&str> = inner.split('.').collect();
    if parts.len() != 2 && parts.len() != 3 {
        return String::new();
    }

    let node_id = parts[0];
    if let Some(r) = completed.get(node_id) {
        let field = if parts.len() == 2 { parts[1] } else { parts[2] };
        match field {
            "output" => truncate_for_injection(&r.output, max_chars),
            "status" => match r.status {
                NodeRunStatus::Passed => "passed".to_string(),
                NodeRunStatus::Failed => "failed".to_string(),
                NodeRunStatus::Skipped => "skipped".to_string(),
            },
            "stdout_first_line" => r
                .output
                .lines()
                .next()
                .unwrap_or("")
                .trim()
                .chars()
                .take(max_chars)
                .collect::<String>(),
            "stdout_first_token" => r
                .output
                .lines()
                .next()
                .unwrap_or("")
                .split_whitespace()
                .next()
                .unwrap_or("")
                .chars()
                .take(max_chars)
                .collect::<String>(),
            _ => String::new(),
        }
    } else {
        String::new()
    }
}

fn truncate_for_injection(s: &str, max_chars: usize) -> String {
    let prefix: String = s.chars().take(max_chars).collect();
    if prefix.chars().count() == s.chars().count() {
        prefix
    } else {
        format!("{}... (截断)", prefix)
    }
}