aprender-orchestrate 0.31.2

Sovereign AI orchestration: autonomous agents, ML serving, code analysis, and transpilation pipelines
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

//! Agent Loop Guard Demo
//!
//! Demonstrates the LoopGuard (Jidoka pattern):
//! - Iteration limit enforcement
//! - Ping-pong detection (FxHash duplicate tool call tracking)
//! - Cost budget enforcement (Muda: prevent runaway spend)
//! - Token budget enforcement
//! - MaxTokens truncation tracking
//!
//! Run with: `cargo run --example agent_guard --features agents`

#[cfg(feature = "agents")]
fn main() {
    use batuta::agent::guard::{LoopGuard, LoopVerdict};
    use batuta::agent::result::TokenUsage;

    println!("Agent Loop Guard Demo (Jidoka)");
    println!("==============================");
    println!();

    // --- Iteration limit ---
    println!("--- Iteration Limit (INV-001) ---");
    let mut guard = LoopGuard::new(5, 100, 0.0);
    for i in 1..=6 {
        let verdict = guard.check_iteration();
        let label = match &verdict {
            LoopVerdict::Allow => "Allow",
            LoopVerdict::Warn(_) => "Warn",
            LoopVerdict::Block(_) => "Block",
            LoopVerdict::CircuitBreak(_) => "CircuitBreak",
        };
        println!("  Iteration {i}: {label}");
        if let LoopVerdict::CircuitBreak(msg) = &verdict {
            println!("    -> {msg}");
        }
    }
    println!();

    // --- Ping-pong detection (INV-004) ---
    println!("--- Ping-Pong Detection (INV-004) ---");
    let mut guard = LoopGuard::new(100, 100, 0.0);
    let input = serde_json::json!({"query": "same question"});
    for i in 1..=4 {
        let verdict = guard.check_tool_call("search", &input);
        let label = match &verdict {
            LoopVerdict::Allow => "Allow",
            LoopVerdict::Block(msg) => {
                println!("  Call {i}: Block -> {msg}");
                "Block"
            }
            _ => "Other",
        };
        if label != "Block" {
            println!("  Call {i}: {label}");
        }
    }
    // Different input resets detection
    let different = serde_json::json!({"query": "new question"});
    let v = guard.check_tool_call("search", &different);
    println!(
        "  Different input: {}",
        if matches!(v, LoopVerdict::Allow) { "Allow" } else { "Not Allow" }
    );
    println!();

    // --- Cost budget (INV-005, Muda) ---
    println!("--- Cost Budget Enforcement (INV-005) ---");
    let mut guard = LoopGuard::new(100, 100, 0.10); // $0.10 budget
    for cents in [3, 3, 3, 5] {
        let cost = f64::from(cents) / 100.0;
        let verdict = guard.record_cost(cost);
        let label = match &verdict {
            LoopVerdict::Allow => "Allow".to_string(),
            LoopVerdict::CircuitBreak(msg) => {
                format!("CircuitBreak -> {msg}")
            }
            _ => format!("{verdict:?}"),
        };
        println!("  +${cost:.2}: {label}");
    }
    println!();

    // --- Token budget (INV-016) ---
    println!("--- Token Budget Enforcement (INV-016) ---");
    let mut guard = LoopGuard::new(100, 100, 0.0).with_token_budget(Some(1000));
    let usages = [
        TokenUsage { input_tokens: 200, output_tokens: 100 },
        TokenUsage { input_tokens: 300, output_tokens: 200 },
        TokenUsage { input_tokens: 100, output_tokens: 200 },
    ];
    let mut cumulative = 0u64;
    for usage in &usages {
        cumulative += usage.input_tokens + usage.output_tokens;
        let verdict = guard.record_usage(usage);
        let label = match &verdict {
            LoopVerdict::Allow => "Allow".to_string(),
            LoopVerdict::Warn(msg) => format!("Warn -> {msg}"),
            LoopVerdict::CircuitBreak(msg) => {
                format!("CircuitBreak -> {msg}")
            }
            _ => format!("{verdict:?}"),
        };
        println!(
            "  +{}in/{}out (total={cumulative}): {label}",
            usage.input_tokens, usage.output_tokens,
        );
    }
    println!();

    // --- MaxTokens truncation (INV-006) ---
    println!("--- MaxTokens Circuit Break (INV-006) ---");
    let mut guard = LoopGuard::new(100, 100, 0.0);
    for i in 1..=6 {
        let verdict = guard.record_max_tokens();
        let label = match &verdict {
            LoopVerdict::Allow => "Allow",
            LoopVerdict::CircuitBreak(_) => "CircuitBreak",
            _ => "Other",
        };
        println!("  Consecutive MaxTokens {i}: {label}");
    }
    println!("  Reset (ToolUse received)...");
    guard.reset_max_tokens();
    let after_reset = guard.record_max_tokens();
    println!(
        "  After reset, MaxTokens 1: {}",
        if matches!(after_reset, LoopVerdict::Allow) { "Allow" } else { "Not Allow" }
    );
    println!();

    println!("All guard demos completed.");
}

#[cfg(not(feature = "agents"))]
fn main() {
    eprintln!(
        "Enable `agents` feature: \
         cargo run --example agent_guard --features agents"
    );
    std::process::exit(1);
}