Skip to main content

steer_core/tools/
factory.rs

1use std::sync::Arc;
2
3use crate::api::Client as ApiClient;
4use crate::app::domain::session::EventStore;
5use crate::app::validation::ValidatorRegistry;
6use crate::model_registry::ModelRegistry;
7use crate::workspace::{RepoManager, Workspace, WorkspaceManager};
8
9use super::BackendRegistry;
10use super::agent_spawner_impl::DefaultAgentSpawner;
11use super::executor::ToolExecutor;
12use super::model_caller_impl::DefaultModelCaller;
13use super::registry::ToolRegistry;
14use super::services::ToolServices;
15use super::static_tools::{
16    AstGrepTool, BashTool, DispatchAgentTool, EditTool, FetchTool, GlobTool, GrepTool, LsTool,
17    MultiEditTool, ReplaceTool, TodoReadTool, TodoWriteTool, ViewTool,
18};
19
20pub struct ToolSystemBuilder {
21    workspace: Arc<dyn Workspace>,
22    event_store: Arc<dyn EventStore>,
23    api_client: Arc<ApiClient>,
24    model_registry: Arc<ModelRegistry>,
25    backend_registry: Arc<BackendRegistry>,
26    validators: Arc<ValidatorRegistry>,
27    workspace_manager: Option<Arc<dyn WorkspaceManager>>,
28    repo_manager: Option<Arc<dyn RepoManager>>,
29}
30
31impl ToolSystemBuilder {
32    pub fn new(
33        workspace: Arc<dyn Workspace>,
34        event_store: Arc<dyn EventStore>,
35        api_client: Arc<ApiClient>,
36        model_registry: Arc<ModelRegistry>,
37    ) -> Self {
38        Self {
39            workspace,
40            event_store,
41            api_client,
42            model_registry,
43            backend_registry: Arc::new(BackendRegistry::new()),
44            validators: Arc::new(ValidatorRegistry::new()),
45            workspace_manager: None,
46            repo_manager: None,
47        }
48    }
49
50    pub fn with_backend_registry(mut self, registry: Arc<BackendRegistry>) -> Self {
51        self.backend_registry = registry;
52        self
53    }
54
55    pub fn with_validators(mut self, validators: Arc<ValidatorRegistry>) -> Self {
56        self.validators = validators;
57        self
58    }
59
60    pub fn with_workspace_manager(mut self, manager: Arc<dyn WorkspaceManager>) -> Self {
61        self.workspace_manager = Some(manager);
62        self
63    }
64
65    pub fn with_repo_manager(mut self, manager: Arc<dyn RepoManager>) -> Self {
66        self.repo_manager = Some(manager);
67        self
68    }
69
70    pub fn build(self) -> Arc<ToolExecutor> {
71        let base_executor = ToolExecutor::with_components(self.backend_registry, self.validators);
72
73        let agent_spawner = Arc::new(DefaultAgentSpawner::new(
74            self.event_store.clone(),
75            self.api_client.clone(),
76            self.workspace.clone(),
77            self.model_registry,
78            self.workspace_manager.clone(),
79            self.repo_manager.clone(),
80        ));
81
82        let model_caller = Arc::new(DefaultModelCaller::new(self.api_client.clone()));
83
84        let mut services =
85            ToolServices::new(self.workspace.clone(), self.event_store, self.api_client)
86                .with_agent_spawner(agent_spawner)
87                .with_model_caller(model_caller)
88                .with_network();
89        if let Some(manager) = self.workspace_manager {
90            services = services.with_workspace_manager(manager);
91        }
92        if let Some(manager) = self.repo_manager {
93            services = services.with_repo_manager(manager);
94        }
95        let services = Arc::new(services);
96
97        let mut registry = ToolRegistry::new();
98
99        registry.register_static(GrepTool);
100        registry.register_static(GlobTool);
101        registry.register_static(LsTool);
102        registry.register_static(ViewTool);
103        registry.register_static(BashTool);
104        registry.register_static(EditTool);
105        registry.register_static(MultiEditTool);
106        registry.register_static(ReplaceTool);
107        registry.register_static(AstGrepTool);
108        registry.register_static(TodoReadTool);
109        registry.register_static(TodoWriteTool);
110        registry.register_static(DispatchAgentTool);
111        registry.register_static(FetchTool);
112
113        Arc::new(base_executor.with_static_tools(Arc::new(registry), services))
114    }
115}