starweaver-runtime 0.0.2

Agent-loop graph and runtime executor primitives for Starweaver
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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

#![allow(missing_docs, clippy::unwrap_used)]

use starweaver_core::{ConversationId, RunId};
use starweaver_model::{message::ToolCallPart, ModelResponse, ModelResponsePart, ToolReturnPart};
use starweaver_runtime::{
    inspect_graph, inspect_next_node, next_node, AgentNode, AgentRunState, RunStatus,
};

fn state() -> AgentRunState {
    AgentRunState::new(
        RunId::from_string("run_test"),
        ConversationId::from_string("conv_test"),
    )
}

#[test]
fn transitions_final_text_path() {
    let mut state = state();
    assert_eq!(
        next_node(AgentNode::StartRun, &state, 8).unwrap().next,
        AgentNode::PrepareRequest
    );
    assert_eq!(
        next_node(AgentNode::PrepareRequest, &state, 8)
            .unwrap()
            .next,
        AgentNode::DrainMessages
    );
    assert_eq!(
        next_node(AgentNode::DrainMessages, &state, 8).unwrap().next,
        AgentNode::ModelRequest
    );

    state.apply_model_response(ModelResponse::text("done"));
    assert_eq!(
        next_node(AgentNode::ModelRequest, &state, 8).unwrap().next,
        AgentNode::HandleResponse
    );

    state.output = Some("done".to_string());
    assert_eq!(
        next_node(AgentNode::HandleResponse, &state, 8)
            .unwrap()
            .next,
        AgentNode::FinalizeRun
    );
    assert_eq!(
        next_node(AgentNode::FinalizeRun, &state, 8).unwrap().next,
        AgentNode::DrainIdleMessages
    );
    assert_eq!(
        next_node(AgentNode::DrainIdleMessages, &state, 8)
            .unwrap()
            .next,
        AgentNode::Complete
    );
}

#[test]
fn transitions_tool_call_path() {
    let mut state = state();
    state.apply_model_response(ModelResponse {
        parts: vec![ModelResponsePart::ToolCall(ToolCallPart {
            id: "call_1".to_string(),
            name: "lookup".to_string(),
            arguments: serde_json::json!({"query": "x"}).into(),
        })],
        ..ModelResponse::text("")
    });
    state.pending_tool_calls = state.latest_response.as_ref().unwrap().tool_calls();

    assert_eq!(
        next_node(AgentNode::HandleResponse, &state, 8)
            .unwrap()
            .next,
        AgentNode::ExecuteTools
    );

    state.pending_tool_returns.push(ToolReturnPart::new(
        "call_1",
        "lookup",
        serde_json::json!({"value": "x"}),
    ));
    assert_eq!(
        next_node(AgentNode::ExecuteTools, &state, 8).unwrap().next,
        AgentNode::PrepareRequest
    );
}

#[test]
fn transitions_retry_path() {
    let mut state = state();
    state.pending_tool_returns.push(
        ToolReturnPart::new(
            "retry",
            "output_validation",
            serde_json::json!({"error": "invalid"}),
        )
        .with_error(true),
    );

    assert_eq!(
        next_node(AgentNode::HandleResponse, &state, 8)
            .unwrap()
            .next,
        AgentNode::PrepareRequest
    );
}

#[test]
fn transitions_idle_message_redirect_path() {
    let mut state = state();
    state.output = Some("done".to_string());
    state.idle_messages.push("continue".to_string());

    assert_eq!(
        next_node(AgentNode::DrainIdleMessages, &state, 8)
            .unwrap()
            .next,
        AgentNode::PrepareRequest
    );
}

#[test]
fn transitions_max_step_path_to_finalize() {
    let mut state = state();
    state.run_step = 8;
    state.status = RunStatus::Running;

    assert_eq!(
        next_node(AgentNode::PrepareRequest, &state, 8)
            .unwrap()
            .next,
        AgentNode::FinalizeRun
    );
}

#[test]
fn inspect_next_node_returns_graph_step_evidence() {
    let state = state();
    let step = inspect_next_node(AgentNode::StartRun, &state, 8).unwrap();

    assert_eq!(step.index, 0);
    assert_eq!(step.current, AgentNode::StartRun);
    assert_eq!(step.decision.next, AgentNode::PrepareRequest);
    assert!(step.decision.checkpoint);
    assert_eq!(step.run_step, 0);
}

#[test]
fn inspect_graph_returns_compact_trace() {
    let mut state = state();
    state.output = Some("done".to_string());

    let trace = inspect_graph(AgentNode::FinalizeRun, &state, 8, 4).unwrap();

    assert_eq!(trace.steps().len(), 2);
    assert!(trace.is_complete());
    assert_eq!(trace.steps()[0].current, AgentNode::FinalizeRun);
    assert_eq!(trace.terminal, AgentNode::Complete);
}