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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use serde_json::Value;

pub(super) fn vv_llm_message_to_cache_json(message: &vv_llm::Message) -> Value {
    let mut object = serde_json::Map::new();
    object.insert(
        "role".to_string(),
        Value::String(message.role.as_str().to_string()),
    );
    object.insert(
        "content".to_string(),
        Value::Array(
            message
                .content
                .iter()
                .map(vv_llm_content_to_cache_json)
                .collect(),
        ),
    );
    if let Some(name) = message.name.as_ref().filter(|name| !name.is_empty()) {
        object.insert("name".to_string(), Value::String(name.clone()));
    }
    if let Some(tool_call_id) = message
        .tool_call_id
        .as_ref()
        .filter(|tool_call_id| !tool_call_id.is_empty())
    {
        object.insert(
            "tool_call_id".to_string(),
            Value::String(tool_call_id.clone()),
        );
    }
    if let Some(reasoning_content) = message
        .reasoning_content
        .as_ref()
        .filter(|reasoning_content| !reasoning_content.is_empty())
    {
        object.insert(
            "reasoning_content".to_string(),
            Value::String(reasoning_content.clone()),
        );
    }
    if !message.tool_calls.is_empty() {
        let tool_calls = message
            .tool_calls
            .iter()
            .map(vv_llm_tool_call_to_openai_json)
            .collect::<Vec<_>>();
        object.insert("tool_calls".to_string(), Value::Array(tool_calls));
        let content = object
            .entry("content".to_string())
            .or_insert_with(|| Value::Array(Vec::new()));
        if let Some(blocks) = content.as_array_mut() {
            blocks.extend(
                message
                    .tool_calls
                    .iter()
                    .map(vv_llm_tool_call_to_anthropic_cache_json),
            );
        }
    }
    Value::Object(object)
}

fn vv_llm_content_to_cache_json(content: &vv_llm::MessageContent) -> Value {
    match content {
        vv_llm::MessageContent::Text {
            text,
            cache_control,
        } => {
            let mut object = serde_json::Map::new();
            object.insert("type".to_string(), Value::String("text".to_string()));
            object.insert("text".to_string(), Value::String(text.clone()));
            if let Some(cache_control) = cache_control {
                object.insert("cache_control".to_string(), cache_control.clone());
            }
            Value::Object(object)
        }
        vv_llm::MessageContent::ImageUrl { url } => serde_json::json!({
            "type": "image_url",
            "image_url": {"url": url},
        }),
    }
}

fn vv_llm_tool_call_to_openai_json(tool_call: &vv_llm::ToolCall) -> Value {
    serde_json::json!({
        "id": tool_call.id,
        "type": "function",
        "function": {
            "name": tool_call.name,
            "arguments": tool_call.arguments,
        },
    })
}

fn vv_llm_tool_call_to_anthropic_cache_json(tool_call: &vv_llm::ToolCall) -> Value {
    let input = serde_json::from_str::<Value>(&tool_call.arguments)
        .unwrap_or_else(|_| Value::String(tool_call.arguments.clone()));
    serde_json::json!({
        "type": "tool_use",
        "id": tool_call.id,
        "name": tool_call.name,
        "input": input,
    })
}

pub(super) fn vv_llm_tool_to_cache_json(tool: &vv_llm::ChatTool) -> Value {
    let mut object = serde_json::Map::new();
    object.insert("type".to_string(), Value::String("function".to_string()));
    object.insert(
        "function".to_string(),
        serde_json::json!({
            "name": tool.name,
            "description": tool.description.clone().unwrap_or_default(),
            "parameters": tool.parameters,
        }),
    );
    if let Some(cache_control) = &tool.cache_control {
        object.insert("cache_control".to_string(), cache_control.clone());
    }
    Value::Object(object)
}