vv-agent 0.2.0

VectorVein agent runtime, SDK, CLI, tools, and workspace backends
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

use serde_json::Value;

use crate::events::{RunEvent, ToolStatus};
use crate::result::RunResult;

pub struct RunEventStream {
    events: std::vec::IntoIter<Result<RunEvent, String>>,
    result: Option<RunResult>,
}

impl RunEventStream {
    pub(super) fn from_events(result: RunResult, events: Vec<RunEvent>) -> Self {
        let events = events.into_iter().map(Ok).collect::<Vec<_>>().into_iter();
        Self {
            events,
            result: Some(result),
        }
    }

    pub async fn next(&mut self) -> Option<Result<RunEvent, String>> {
        self.events.next()
    }

    pub async fn into_result(mut self) -> Result<RunResult, String> {
        self.result
            .take()
            .ok_or_else(|| "stream result already taken".to_string())
    }
}

pub(super) fn map_runtime_event(
    event: &str,
    payload: &std::collections::BTreeMap<String, Value>,
) -> Option<RunEvent> {
    let run_id = payload
        .get("task_id")
        .and_then(Value::as_str)
        .or_else(|| payload.get("run_id").and_then(Value::as_str))
        .unwrap_or("run")
        .to_string();
    match event {
        "run_started" => Some(RunEvent::RunStarted {
            run_id,
            agent_name: payload
                .get("agent_name")
                .and_then(Value::as_str)
                .unwrap_or("agent")
                .to_string(),
        }),
        "cycle_started" => Some(RunEvent::AgentStarted {
            run_id,
            agent_name: payload
                .get("agent_name")
                .and_then(Value::as_str)
                .unwrap_or("agent")
                .to_string(),
            cycle_index: payload
                .get("cycle")
                .and_then(Value::as_u64)
                .unwrap_or_default() as u32,
        }),
        "cycle_llm_response" => {
            let cycle_index = payload
                .get("cycle")
                .and_then(Value::as_u64)
                .unwrap_or_default() as u32;
            payload
                .get("assistant_message")
                .and_then(Value::as_str)
                .filter(|delta| !delta.is_empty())
                .map(|delta| RunEvent::AssistantDelta {
                    run_id,
                    delta: delta.to_string(),
                    cycle_index,
                })
        }
        "tool_result" => {
            let metadata = payload.get("metadata").and_then(Value::as_object);
            if let Some(interruption_id) = metadata
                .and_then(|metadata| metadata.get("approval_interruption_id"))
                .and_then(Value::as_str)
            {
                return Some(RunEvent::ToolApprovalRequested {
                    run_id,
                    interruption_id: interruption_id.to_string(),
                    tool_name: payload
                        .get("tool_name")
                        .and_then(Value::as_str)
                        .unwrap_or_default()
                        .to_string(),
                });
            }
            let status = match payload
                .get("status")
                .and_then(Value::as_str)
                .unwrap_or_default()
            {
                "error" | "ERROR" => ToolStatus::Error,
                "wait_response" | "WAIT_RESPONSE" => ToolStatus::WaitResponse,
                _ => ToolStatus::Success,
            };
            Some(RunEvent::ToolFinished {
                run_id,
                tool_call_id: payload
                    .get("tool_call_id")
                    .and_then(Value::as_str)
                    .unwrap_or_default()
                    .to_string(),
                tool_name: payload
                    .get("tool_name")
                    .and_then(Value::as_str)
                    .unwrap_or_default()
                    .to_string(),
                status,
            })
        }
        "run_completed" => Some(RunEvent::RunCompleted {
            run_id,
            status: crate::types::AgentStatus::Completed,
        }),
        "run_wait_user" => Some(RunEvent::RunCompleted {
            run_id,
            status: crate::types::AgentStatus::WaitUser,
        }),
        "run_max_cycles" => Some(RunEvent::RunCompleted {
            run_id,
            status: crate::types::AgentStatus::MaxCycles,
        }),
        "cycle_failed" => Some(RunEvent::RunFailed {
            run_id,
            error: crate::events::AgentErrorPayload::new(
                payload
                    .get("error")
                    .and_then(Value::as_str)
                    .unwrap_or("cycle failed"),
            ),
        }),
        _ => None,
    }
}