1use serde::{Deserialize, Serialize};
6
7#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
13#[serde(rename_all = "lowercase")]
14#[derive(Default)]
15pub enum RuntimeType {
16 #[default]
17 Local,
18 Remote,
19}
20
21#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
23pub struct VolumeMount {
24 pub host_path: String,
26 pub container_path: String,
28 #[serde(default)]
30 pub read_only: bool,
31}
32
33#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
35pub struct PortMapping {
36 pub host_port: u16,
38 pub container_port: u16,
40 #[serde(default = "default_protocol")]
42 pub protocol: String,
43}
44
45fn default_protocol() -> String {
46 "tcp".into()
47}
48
49#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
51#[serde(rename_all = "lowercase")]
52#[derive(Default)]
53pub enum ContainerStatus {
54 Created,
55 Running,
56 Paused,
57 Stopped,
58 Removing,
59 #[default]
60 Unknown,
61}
62
63#[derive(Debug, Clone, Serialize, Deserialize)]
65pub struct ContainerSpec {
66 pub image: String,
68 #[serde(default = "default_memory")]
70 pub memory: String,
71 #[serde(default = "default_cpus")]
73 pub cpus: String,
74 #[serde(default = "default_network")]
76 pub network_mode: String,
77 #[serde(default)]
79 pub volumes: Vec<VolumeMount>,
80 #[serde(default)]
82 pub ports: Vec<PortMapping>,
83 #[serde(default)]
85 pub environment: std::collections::HashMap<String, String>,
86 pub entrypoint: Option<String>,
88 pub command: Option<Vec<String>>,
90}
91
92fn default_memory() -> String {
93 "4g".into()
94}
95fn default_cpus() -> String {
96 "4".into()
97}
98fn default_network() -> String {
99 "bridge".into()
100}
101
102#[derive(Debug, Clone, Serialize, Deserialize)]
104pub struct DockerConfig {
105 #[serde(default = "default_image")]
107 pub image: String,
108 #[serde(default = "default_memory")]
110 pub memory: String,
111 #[serde(default = "default_cpus")]
113 pub cpus: String,
114 #[serde(default = "default_network")]
116 pub network_mode: String,
117 #[serde(default = "default_startup_timeout")]
119 pub startup_timeout: f64,
120 #[serde(default = "default_pull_policy")]
122 pub pull_policy: String,
123 #[serde(default = "default_server_port")]
125 pub server_port: u16,
126 #[serde(default)]
128 pub environment: std::collections::HashMap<String, String>,
129 #[serde(default)]
131 pub shell_init: String,
132 #[serde(default)]
134 pub volumes: Vec<VolumeMount>,
135 #[serde(default)]
137 pub runtime_type: RuntimeType,
138 pub remote_host: Option<String>,
140 pub remote_user: Option<String>,
142 pub ssh_key_path: Option<String>,
144}
145
146fn default_image() -> String {
147 "python:3.11".into()
148}
149fn default_startup_timeout() -> f64 {
150 120.0
151}
152fn default_pull_policy() -> String {
153 "if-not-present".into()
154}
155fn default_server_port() -> u16 {
156 8000
157}
158
159impl Default for DockerConfig {
160 fn default() -> Self {
161 Self {
162 image: default_image(),
163 memory: default_memory(),
164 cpus: default_cpus(),
165 network_mode: default_network(),
166 startup_timeout: default_startup_timeout(),
167 pull_policy: default_pull_policy(),
168 server_port: default_server_port(),
169 environment: Default::default(),
170 shell_init: String::new(),
171 volumes: Vec::new(),
172 runtime_type: RuntimeType::default(),
173 remote_host: None,
174 remote_user: None,
175 ssh_key_path: None,
176 }
177 }
178}
179
180#[derive(Debug, Clone, Serialize, Deserialize)]
186pub struct CreateSessionRequest {
187 #[serde(default = "default_session_name")]
188 pub session: String,
189 #[serde(default = "default_startup_timeout_session")]
190 pub startup_timeout: f64,
191}
192
193fn default_session_name() -> String {
194 "default".into()
195}
196fn default_startup_timeout_session() -> f64 {
197 10.0
198}
199
200impl Default for CreateSessionRequest {
201 fn default() -> Self {
202 Self {
203 session: default_session_name(),
204 startup_timeout: default_startup_timeout_session(),
205 }
206 }
207}
208
209#[derive(Debug, Clone, Serialize, Deserialize)]
211pub struct CreateSessionResponse {
212 pub success: bool,
213 pub session: String,
214 #[serde(default)]
215 pub message: String,
216}
217
218#[derive(Debug, Clone, Serialize, Deserialize)]
220pub struct CloseSessionRequest {
221 #[serde(default = "default_session_name")]
222 pub session: String,
223}
224
225impl Default for CloseSessionRequest {
226 fn default() -> Self {
227 Self {
228 session: default_session_name(),
229 }
230 }
231}
232
233#[derive(Debug, Clone, Serialize, Deserialize)]
235pub struct CloseSessionResponse {
236 pub success: bool,
237 #[serde(default)]
238 pub message: String,
239}
240
241#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
247#[serde(rename_all = "lowercase")]
248#[derive(Default)]
249pub enum CheckMode {
250 Raise,
252 #[default]
254 Silent,
255 Ignore,
257}
258
259#[derive(Debug, Clone, Serialize, Deserialize)]
261pub struct BashAction {
262 pub command: String,
263 #[serde(default = "default_session_name")]
264 pub session: String,
265 #[serde(default = "default_timeout")]
266 pub timeout: f64,
267 #[serde(default)]
268 pub check: CheckMode,
269}
270
271fn default_timeout() -> f64 {
272 120.0
273}
274
275#[derive(Debug, Clone, Serialize, Deserialize)]
277pub struct BashObservation {
278 #[serde(default)]
279 pub output: String,
280 pub exit_code: Option<i32>,
281 pub failure_reason: Option<String>,
282}
283
284#[derive(Debug, Clone, Serialize, Deserialize)]
290pub struct ReadFileRequest {
291 pub path: String,
292}
293
294#[derive(Debug, Clone, Serialize, Deserialize)]
296pub struct ReadFileResponse {
297 pub success: bool,
298 #[serde(default)]
299 pub content: String,
300 pub error: Option<String>,
301}
302
303#[derive(Debug, Clone, Serialize, Deserialize)]
305pub struct WriteFileRequest {
306 pub path: String,
307 pub content: String,
308}
309
310#[derive(Debug, Clone, Serialize, Deserialize)]
312pub struct WriteFileResponse {
313 pub success: bool,
314 pub error: Option<String>,
315}
316
317#[derive(Debug, Clone, Serialize, Deserialize)]
323pub struct IsAliveResponse {
324 #[serde(default = "default_status_ok")]
325 pub status: String,
326 #[serde(default)]
327 pub message: String,
328}
329
330fn default_status_ok() -> String {
331 "ok".into()
332}
333
334impl Default for IsAliveResponse {
335 fn default() -> Self {
336 Self {
337 status: default_status_ok(),
338 message: String::new(),
339 }
340 }
341}
342
343#[derive(Debug, Clone, Serialize, Deserialize)]
345pub struct ExceptionTransfer {
346 pub message: String,
347 pub class_name: String,
348 pub module: String,
349 #[serde(default)]
350 pub traceback: String,
351 #[serde(default)]
352 pub extra: std::collections::HashMap<String, serde_json::Value>,
353}
354
355#[derive(Debug, Clone, Serialize, Deserialize)]
361pub struct ToolResult {
362 pub success: bool,
363 pub output: Option<String>,
364 pub error: Option<String>,
365 pub exit_code: Option<i32>,
366}
367
368#[cfg(test)]
369#[path = "models_tests.rs"]
370mod tests;