vv-agent 0.6.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

use std::collections::BTreeMap;
use std::sync::Arc;

use serde_json::json;

use crate::tools::{ToolContext, ToolExecutor, ToolRunContext};
use crate::types::{ToolCall, ToolDirective, ToolExecutionResult, ToolResultStatus};

#[derive(Clone, Default)]
pub struct ToolRunOptions {
    allowed_tools: Option<Vec<String>>,
    disallowed_tools: Vec<String>,
}

impl ToolRunOptions {
    pub fn allow_only(mut self, tools: impl IntoIterator<Item = impl Into<String>>) -> Self {
        self.allowed_tools = Some(tools.into_iter().map(Into::into).collect());
        self
    }

    pub fn disallow(mut self, tool: impl Into<String>) -> Self {
        self.disallowed_tools.push(tool.into());
        self
    }
}

#[derive(Clone, Default)]
pub struct ToolOrchestrator {
    tools: BTreeMap<String, Arc<dyn ToolExecutor>>,
}

impl ToolOrchestrator {
    pub fn from_tools(tools: Vec<Arc<dyn ToolExecutor>>) -> Self {
        let tools = tools
            .into_iter()
            .map(|tool| (tool.name().to_string(), tool))
            .collect();
        Self { tools }
    }

    pub async fn run_one(
        &self,
        call: ToolCall,
        context: &mut ToolContext,
        options: ToolRunOptions,
    ) -> Result<ToolExecutionResult, crate::tools::ToolError> {
        if let Some(allowed) = options.allowed_tools.as_ref() {
            if !allowed.iter().any(|tool| tool == &call.name) {
                return Ok(tool_error(
                    &call,
                    "tool_not_allowed",
                    "Tool is not in the allowed tool list.",
                ));
            }
        }
        if options
            .disallowed_tools
            .iter()
            .any(|tool| tool == &call.name)
        {
            return Ok(tool_error(
                &call,
                "tool_disallowed",
                "Tool is disallowed by policy.",
            ));
        }

        let Some(tool) = self.tools.get(&call.name) else {
            return Ok(tool_error(
                &call,
                "tool_not_found",
                format!("Unknown tool: {}", call.name),
            ));
        };

        let mut result = tool.run(call.clone(), ToolRunContext::new(context)).await?;
        if result.tool_call_id.trim().is_empty() || result.tool_call_id == "pending" {
            result.tool_call_id = call.id;
        }
        Ok(result)
    }
}

fn tool_error(
    call: &ToolCall,
    error_code: &str,
    message: impl Into<String>,
) -> ToolExecutionResult {
    let error_code = error_code.to_string();
    ToolExecutionResult {
        tool_call_id: call.id.clone(),
        content: json!({
            "ok": false,
            "error": message.into(),
            "error_code": error_code,
            "tool_name": call.name,
        })
        .to_string(),
        status: ToolResultStatus::Error,
        directive: ToolDirective::Continue,
        error_code: Some(error_code),
        metadata: BTreeMap::new(),
        image_url: None,
        image_path: None,
    }
}