Skip to main content

vv_agent/runner/
builder.rs

1use std::path::PathBuf;
2use std::sync::Arc;
3
4use crate::model::{ModelProvider, VvLlmModelProvider};
5use crate::run_config::RunConfig;
6use crate::tools::ToolRegistry;
7
8use super::Runner;
9
10#[derive(Default)]
11pub struct RunnerBuilder {
12    model_provider: Option<Arc<dyn ModelProvider>>,
13    settings_file: Option<PathBuf>,
14    default_backend: Option<String>,
15    workspace: Option<PathBuf>,
16    tool_registry: Option<ToolRegistry>,
17    default_run_config: RunConfig,
18}
19
20impl RunnerBuilder {
21    pub fn model_provider(mut self, provider: impl ModelProvider + 'static) -> Self {
22        self.model_provider = Some(Arc::new(provider));
23        self
24    }
25
26    pub fn model_provider_arc(mut self, provider: Arc<dyn ModelProvider>) -> Self {
27        self.model_provider = Some(provider);
28        self
29    }
30
31    pub fn settings_file(mut self, settings_file: impl Into<PathBuf>) -> Self {
32        self.settings_file = Some(settings_file.into());
33        self
34    }
35
36    pub fn default_backend(mut self, default_backend: impl Into<String>) -> Self {
37        self.default_backend = Some(default_backend.into());
38        self
39    }
40
41    pub fn workspace(mut self, workspace: impl Into<PathBuf>) -> Self {
42        self.workspace = Some(workspace.into());
43        self
44    }
45
46    pub fn tool_registry(mut self, registry: ToolRegistry) -> Self {
47        self.tool_registry = Some(registry);
48        self
49    }
50
51    pub fn default_run_config(mut self, config: RunConfig) -> Self {
52        self.default_run_config = config;
53        self
54    }
55
56    pub fn build(self) -> Result<Runner, String> {
57        let model_provider = if let Some(provider) = self.model_provider {
58            provider
59        } else {
60            let settings_file = self
61                .settings_file
62                .unwrap_or_else(|| PathBuf::from("local_settings.json"));
63            let mut provider = VvLlmModelProvider::from_settings_file(settings_file);
64            if let Some(default_backend) = self.default_backend {
65                provider = provider.with_default_backend(default_backend);
66            }
67            Arc::new(provider)
68        };
69        Ok(Runner {
70            model_provider,
71            workspace: self
72                .workspace
73                .unwrap_or_else(|| PathBuf::from("./workspace")),
74            tool_registry: self
75                .tool_registry
76                .unwrap_or_else(crate::tools::build_default_registry),
77            default_run_config: self.default_run_config,
78        })
79    }
80}