wesichain-agent 0.2.1

Rust-native LLM agents & chains with resumable ReAct workflows
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

use wesichain_agent::{
    AgentError, AgentRuntime, Idle, LoopTransition, PolicyDecision, PolicyEngine, RepromptStrategy,
};
use wesichain_core::{LlmResponse, ToolCall, Value};

#[derive(Debug)]
struct AlwaysReprompt;

impl PolicyEngine for AlwaysReprompt {
    fn on_model_error(_error: &AgentError) -> PolicyDecision {
        PolicyDecision::reprompt(RepromptStrategy::OnceWithToolCatalog)
    }
}

#[derive(Debug)]
struct RepromptOnToolError;

impl PolicyEngine for RepromptOnToolError {
    fn on_tool_error(_error: &AgentError) -> PolicyDecision {
        PolicyDecision::reprompt(RepromptStrategy::N { n: 3 })
    }
}

#[test]
fn reprompt_consumes_budget_by_default_and_reaches_budget_exceeded() {
    let allowed_tools = vec!["calculator".to_string()];
    let invalid_response = LlmResponse {
        content: String::new(),
        tool_calls: vec![ToolCall {
            id: "call-1".to_string(),
            name: "weather_lookup".to_string(),
            args: Value::String("{\"city\":\"Berlin\"}".to_string()),
        }],
    };

    let runtime = AgentRuntime::<(), (), AlwaysReprompt, Idle>::with_budget(1).think();
    let runtime = match runtime.on_model_response(1, invalid_response.clone(), &allowed_tools) {
        Ok(LoopTransition::Thinking {
            runtime,
            reprompt_strategy,
        }) => {
            assert_eq!(
                reprompt_strategy,
                Some(RepromptStrategy::OnceWithToolCatalog)
            );
            runtime
        }
        other => panic!("expected reprompt back into thinking, got {other:?}"),
    };

    let second = runtime.on_model_response(2, invalid_response, &allowed_tools);
    match second {
        Err(AgentError::BudgetExceeded) => {}
        other => panic!("expected BudgetExceeded, got {other:?}"),
    }
}

#[test]
fn final_answer_transitions_to_completed_terminal_state() {
    let allowed_tools = vec!["calculator".to_string()];
    let response = LlmResponse {
        content: "42".to_string(),
        tool_calls: vec![],
    };

    let runtime = AgentRuntime::<(), (), AlwaysReprompt, Idle>::with_budget(2).think();
    let result = runtime.on_model_response(1, response, &allowed_tools);

    match result {
        Ok(LoopTransition::Completed(_runtime)) => {}
        other => panic!("expected completed transition, got {other:?}"),
    }
}

#[test]
fn model_error_reprompt_transition_preserves_strategy_metadata() {
    let allowed_tools = vec!["calculator".to_string()];
    let invalid_response = LlmResponse {
        content: String::new(),
        tool_calls: vec![ToolCall {
            id: "call-1".to_string(),
            name: "weather_lookup".to_string(),
            args: Value::String("{\"city\":\"Berlin\"}".to_string()),
        }],
    };

    let runtime = AgentRuntime::<(), (), AlwaysReprompt, Idle>::with_budget(2).think();
    let transition = runtime.on_model_response(1, invalid_response, &allowed_tools);

    match transition {
        Ok(LoopTransition::Thinking {
            reprompt_strategy, ..
        }) => {
            assert_eq!(
                reprompt_strategy,
                Some(RepromptStrategy::OnceWithToolCatalog)
            );
        }
        other => panic!("expected reprompt transition, got {other:?}"),
    }
}

#[test]
fn tool_error_reprompt_transition_preserves_strategy_metadata() {
    let runtime = AgentRuntime::<(), (), RepromptOnToolError, Idle>::with_budget(2)
        .think()
        .act();

    let transition = runtime.on_tool_error(AgentError::ToolDispatch);

    match transition {
        Ok(LoopTransition::Thinking {
            reprompt_strategy, ..
        }) => {
            assert_eq!(reprompt_strategy, Some(RepromptStrategy::N { n: 3 }));
        }
        other => panic!("expected reprompt transition, got {other:?}"),
    }
}

#[test]
fn evented_tool_success_transitions_to_observing_phase() {
    let acting = AgentRuntime::<(), (), AlwaysReprompt, Idle>::with_budget(2)
        .think()
        .act();

    let (transition, events) = acting.on_tool_success_with_events(3);

    match transition {
        LoopTransition::Observing(runtime) => {
            assert_eq!(runtime.remaining_budget(), 2);
        }
        other => panic!("expected observing transition, got {other:?}"),
    }

    assert_eq!(events.len(), 1);
    assert!(matches!(
        events[0],
        wesichain_agent::AgentEvent::ToolCompleted { step_id: 3 }
    ));
}