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

use std::path::PathBuf;
use std::sync::Arc;

use serde_json::Value;

use crate::execution_mode::ExecutionMode;
use crate::model::{ModelProvider, ModelRef};
use crate::model_settings::ModelSettings;
use crate::runtime::backends::RuntimeExecutionBackend;
use crate::runtime::{CancellationToken, RuntimeHook};
use crate::sessions::Session;
use crate::tools::ToolPolicy;
use crate::tracing::TraceSink;
use crate::types::Metadata;
use crate::workspace::WorkspaceBackend;

#[derive(Clone, Default)]
pub struct RunConfig {
    pub model: Option<ModelRef>,
    pub model_provider: Option<Arc<dyn ModelProvider>>,
    pub model_settings: Option<ModelSettings>,
    pub workspace: Option<PathBuf>,
    pub workspace_backend: Option<Arc<dyn WorkspaceBackend>>,
    pub session: Option<Arc<dyn Session>>,
    pub max_cycles: Option<u32>,
    pub tool_policy: ToolPolicy,
    pub execution_backend: Option<RuntimeExecutionBackend>,
    pub cancellation_token: Option<CancellationToken>,
    pub hooks: Vec<Arc<dyn RuntimeHook>>,
    pub trace_sink: Option<Arc<dyn TraceSink>>,
    pub app_state: Option<Arc<dyn std::any::Any + Send + Sync>>,
    pub metadata: Metadata,
}

impl RunConfig {
    pub fn builder() -> RunConfigBuilder {
        RunConfigBuilder::default()
    }
}

#[derive(Default)]
pub struct RunConfigBuilder {
    config: RunConfig,
}

impl RunConfigBuilder {
    pub fn model(mut self, model: ModelRef) -> Self {
        self.config.model = Some(model);
        self
    }

    pub fn model_provider(mut self, provider: impl ModelProvider + 'static) -> Self {
        self.config.model_provider = Some(Arc::new(provider));
        self
    }

    pub fn model_provider_arc(mut self, provider: Arc<dyn ModelProvider>) -> Self {
        self.config.model_provider = Some(provider);
        self
    }

    pub fn model_settings(mut self, settings: ModelSettings) -> Self {
        self.config.model_settings = Some(settings);
        self
    }

    pub fn workspace(mut self, workspace: impl Into<PathBuf>) -> Self {
        self.config.workspace = Some(workspace.into());
        self
    }

    pub fn workspace_backend(mut self, backend: Arc<dyn WorkspaceBackend>) -> Self {
        self.config.workspace_backend = Some(backend);
        self
    }

    pub fn session(mut self, session: impl Session + 'static) -> Self {
        self.config.session = Some(Arc::new(session));
        self
    }

    pub fn session_arc(mut self, session: Arc<dyn Session>) -> Self {
        self.config.session = Some(session);
        self
    }

    pub fn max_cycles(mut self, max_cycles: u32) -> Self {
        self.config.max_cycles = Some(max_cycles);
        self
    }

    pub fn tool_policy(mut self, tool_policy: ToolPolicy) -> Self {
        self.config.tool_policy = tool_policy;
        self
    }

    pub fn execution_backend(mut self, execution_backend: RuntimeExecutionBackend) -> Self {
        self.config.execution_backend = Some(execution_backend);
        self
    }

    pub fn execution_mode(mut self, execution_mode: ExecutionMode) -> Self {
        self.config.execution_backend = Some(execution_mode.into());
        self
    }

    pub fn cancellation_token(mut self, cancellation_token: CancellationToken) -> Self {
        self.config.cancellation_token = Some(cancellation_token);
        self
    }

    pub fn hook(mut self, hook: Arc<dyn RuntimeHook>) -> Self {
        self.config.hooks.push(hook);
        self
    }

    pub fn trace_sink(mut self, sink: Arc<dyn TraceSink>) -> Self {
        self.config.trace_sink = Some(sink);
        self
    }

    pub fn metadata(mut self, key: impl Into<String>, value: Value) -> Self {
        self.config.metadata.insert(key.into(), value);
        self
    }

    pub fn build(self) -> RunConfig {
        self.config
    }
}