vv-agent 0.7.2

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

use std::collections::BTreeMap;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
use std::time::Duration;

use serde_json::{json, Value};

use vv_agent::{
    build_default_registry, Agent, AgentStatus, ApprovalBroker, ApprovalDecision, ApprovalFuture,
    ApprovalProvider, ApprovalRequest, FunctionTool, LLMResponse, LlmRequest, MemorySession,
    Message, ModelRef, RunHandleStatus, Runner, ScriptStep, ScriptedModelProvider, Session,
    SessionItem, StaticTool, ToolCall, ToolOutput, ToolRegistry, ToolResultStatus,
};
use vv_agent::{
    InteractiveAgentClient, InteractiveSessionError, InteractiveSessionEvent,
    InteractiveSessionOptions,
};

struct DeferredApprovalProvider {
    requests: Arc<AtomicUsize>,
    request_ids: std::sync::mpsc::Sender<String>,
}

struct SynchronouslyResolvedApprovalProvider {
    broker: ApprovalBroker,
}

impl ApprovalProvider for SynchronouslyResolvedApprovalProvider {
    fn should_request(&self, request: &ApprovalRequest) -> bool {
        request.tool_name == "dangerous"
    }

    fn decide(&self, request: &ApprovalRequest) -> ApprovalFuture<Option<ApprovalDecision>> {
        let result = self
            .broker
            .resolve(&request.request_id, ApprovalDecision::allow());
        Box::pin(async move { result.map(|()| None) })
    }
}

impl ApprovalProvider for DeferredApprovalProvider {
    fn should_request(&self, request: &ApprovalRequest) -> bool {
        if request.tool_name != "dangerous" {
            return false;
        }
        self.requests.fetch_add(1, Ordering::SeqCst);
        true
    }

    fn decide(&self, request: &ApprovalRequest) -> ApprovalFuture<Option<ApprovalDecision>> {
        self.request_ids
            .send(request.request_id.clone())
            .expect("send approval request id");
        Box::pin(async { Ok(None) })
    }
}

include!("interactive_session/session_basics.rs");
include!("interactive_session/steering.rs");
include!("interactive_session/events_and_follow_ups.rs");
include!("interactive_session/lifecycle.rs");

fn scripted_runner(responses: Vec<LLMResponse>) -> Runner {
    Runner::builder()
        .model_provider(ScriptedModelProvider::new(
            "scripted",
            "demo-model",
            responses,
        ))
        .workspace(".")
        .build()
        .expect("runner")
}

fn scripted_agent() -> Agent {
    Agent::builder("assistant")
        .instructions("Finish with a concise answer.")
        .model(ModelRef::named("demo-model"))
        .build()
        .expect("agent")
}

fn finish_response(message: &str) -> LLMResponse {
    LLMResponse::with_tool_calls(
        "",
        vec![ToolCall::from_raw_arguments(
            "finish",
            "task_finish",
            json!({"message": message}),
        )],
    )
}

fn drain_events(
    receiver: &mut vv_agent::interactive::InteractiveSessionSubscription,
) -> Vec<InteractiveSessionEvent> {
    let mut events = Vec::new();
    while let Ok(event) = receiver.try_recv() {
        events.push(event);
    }
    events
}