vv-agent 0.6.1

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

use std::path::Path;
use std::sync::{Arc, Mutex};

use super::endpoints::EndpointChatClient;
use super::{EndpointClientSpec, NamedEndpointClientSpec, VvLlmClient};

impl VvLlmClient {
    pub fn new(
        backend: impl Into<String>,
        selected_model: impl Into<String>,
        model_id: impl Into<String>,
        chat_client: Box<dyn vv_llm::ChatClient>,
        timeout_seconds: f64,
    ) -> Self {
        let model_id = model_id.into();
        Self::new_with_named_endpoint_clients(
            backend,
            selected_model,
            model_id.clone(),
            vec![(model_id.clone(), model_id, chat_client)],
            timeout_seconds,
        )
    }

    pub fn new_with_endpoint_clients(
        backend: impl Into<String>,
        selected_model: impl Into<String>,
        model_id: impl Into<String>,
        endpoint_clients: Vec<EndpointClientSpec>,
        timeout_seconds: f64,
    ) -> Self {
        Self::new_with_named_endpoint_clients(
            backend,
            selected_model,
            model_id,
            endpoint_clients
                .into_iter()
                .map(|(model_id, chat_client)| (model_id.clone(), model_id, chat_client))
                .collect(),
            timeout_seconds,
        )
    }

    pub fn new_with_named_endpoint_clients(
        backend: impl Into<String>,
        selected_model: impl Into<String>,
        model_id: impl Into<String>,
        endpoint_clients: Vec<NamedEndpointClientSpec>,
        timeout_seconds: f64,
    ) -> Self {
        Self {
            backend: backend.into(),
            selected_model: selected_model.into(),
            model_id: model_id.into(),
            timeout_seconds,
            debug_dump_dir: None,
            max_retries_per_endpoint: 3,
            backoff_seconds: 2.0,
            randomize_endpoints: true,
            request_counter: Arc::new(Mutex::new(0)),
            endpoint_order_counter: Arc::new(Mutex::new(0)),
            preferred_endpoint_id: Arc::new(Mutex::new(None)),
            endpoint_clients: endpoint_clients
                .into_iter()
                .map(|(endpoint_id, model_id, chat_client)| {
                    EndpointChatClient::new(endpoint_id, model_id, chat_client)
                })
                .collect(),
        }
    }

    pub fn provider_name(&self) -> &'static str {
        self.endpoint_clients
            .first()
            .map(|endpoint| endpoint.chat_client.provider_name())
            .unwrap_or("unknown")
    }

    pub fn model_id(&self) -> &str {
        &self.model_id
    }

    pub fn endpoint_count(&self) -> usize {
        self.endpoint_clients.len()
    }

    pub fn randomize_endpoints(&self) -> bool {
        self.randomize_endpoints
    }

    pub fn with_randomize_endpoints(mut self, randomize_endpoints: bool) -> Self {
        self.randomize_endpoints = randomize_endpoints;
        self
    }

    pub fn with_debug_dump_dir(mut self, debug_dump_dir: impl AsRef<Path>) -> Self {
        self.debug_dump_dir = Some(debug_dump_dir.as_ref().to_path_buf());
        self
    }

    pub fn with_retry_policy(
        mut self,
        max_retries_per_endpoint: usize,
        backoff_seconds: f64,
    ) -> Self {
        self.max_retries_per_endpoint = max_retries_per_endpoint.max(1);
        self.backoff_seconds = backoff_seconds.max(0.0);
        self
    }
}