1use std::path::PathBuf;
2use std::sync::Arc;
3
4use serde_json::Value;
5
6use crate::execution_mode::ExecutionMode;
7use crate::model::{ModelProvider, ModelRef};
8use crate::model_settings::ModelSettings;
9use crate::runtime::backends::RuntimeExecutionBackend;
10use crate::runtime::{CancellationToken, RuntimeHook};
11use crate::sessions::Session;
12use crate::tools::ToolPolicy;
13use crate::tracing::TraceSink;
14use crate::types::Metadata;
15use crate::workspace::WorkspaceBackend;
16
17#[derive(Clone, Default)]
18pub struct RunConfig {
19 pub model: Option<ModelRef>,
20 pub model_provider: Option<Arc<dyn ModelProvider>>,
21 pub model_settings: Option<ModelSettings>,
22 pub workspace: Option<PathBuf>,
23 pub workspace_backend: Option<Arc<dyn WorkspaceBackend>>,
24 pub session: Option<Arc<dyn Session>>,
25 pub max_cycles: Option<u32>,
26 pub tool_policy: ToolPolicy,
27 pub execution_backend: Option<RuntimeExecutionBackend>,
28 pub cancellation_token: Option<CancellationToken>,
29 pub hooks: Vec<Arc<dyn RuntimeHook>>,
30 pub trace_sink: Option<Arc<dyn TraceSink>>,
31 pub app_state: Option<Arc<dyn std::any::Any + Send + Sync>>,
32 pub metadata: Metadata,
33}
34
35impl RunConfig {
36 pub fn builder() -> RunConfigBuilder {
37 RunConfigBuilder::default()
38 }
39}
40
41#[derive(Default)]
42pub struct RunConfigBuilder {
43 config: RunConfig,
44}
45
46impl RunConfigBuilder {
47 pub fn model(mut self, model: ModelRef) -> Self {
48 self.config.model = Some(model);
49 self
50 }
51
52 pub fn model_provider(mut self, provider: impl ModelProvider + 'static) -> Self {
53 self.config.model_provider = Some(Arc::new(provider));
54 self
55 }
56
57 pub fn model_provider_arc(mut self, provider: Arc<dyn ModelProvider>) -> Self {
58 self.config.model_provider = Some(provider);
59 self
60 }
61
62 pub fn model_settings(mut self, settings: ModelSettings) -> Self {
63 self.config.model_settings = Some(settings);
64 self
65 }
66
67 pub fn workspace(mut self, workspace: impl Into<PathBuf>) -> Self {
68 self.config.workspace = Some(workspace.into());
69 self
70 }
71
72 pub fn workspace_backend(mut self, backend: Arc<dyn WorkspaceBackend>) -> Self {
73 self.config.workspace_backend = Some(backend);
74 self
75 }
76
77 pub fn session(mut self, session: impl Session + 'static) -> Self {
78 self.config.session = Some(Arc::new(session));
79 self
80 }
81
82 pub fn session_arc(mut self, session: Arc<dyn Session>) -> Self {
83 self.config.session = Some(session);
84 self
85 }
86
87 pub fn max_cycles(mut self, max_cycles: u32) -> Self {
88 self.config.max_cycles = Some(max_cycles);
89 self
90 }
91
92 pub fn tool_policy(mut self, tool_policy: ToolPolicy) -> Self {
93 self.config.tool_policy = tool_policy;
94 self
95 }
96
97 pub fn execution_backend(mut self, execution_backend: RuntimeExecutionBackend) -> Self {
98 self.config.execution_backend = Some(execution_backend);
99 self
100 }
101
102 pub fn execution_mode(mut self, execution_mode: ExecutionMode) -> Self {
103 self.config.execution_backend = Some(execution_mode.into());
104 self
105 }
106
107 pub fn cancellation_token(mut self, cancellation_token: CancellationToken) -> Self {
108 self.config.cancellation_token = Some(cancellation_token);
109 self
110 }
111
112 pub fn hook(mut self, hook: Arc<dyn RuntimeHook>) -> Self {
113 self.config.hooks.push(hook);
114 self
115 }
116
117 pub fn trace_sink(mut self, sink: Arc<dyn TraceSink>) -> Self {
118 self.config.trace_sink = Some(sink);
119 self
120 }
121
122 pub fn metadata(mut self, key: impl Into<String>, value: Value) -> Self {
123 self.config.metadata.insert(key.into(), value);
124 self
125 }
126
127 pub fn build(self) -> RunConfig {
128 self.config
129 }
130}