objectiveai_sdk/cli/command/laboratories/
mod.rs

1//! `laboratories` — top-level group for laboratory containers (podman
2//! containers the conduit dials as client-side MCP servers), sibling to
3//! `agents`/`swarms`. `create` creates + starts a laboratory container;
4//! `list` streams the laboratory containers created in this state;
5//! `attach`/`detach` record/remove a laboratory id on an agent target
6//! (a tag, or an instance hierarchy). Read attachments back via
7//! `agents instances get` (the `laboratories` field). `spawn`/`kill`
8//! manage the machine's resident laboratory HOST process; `config`
9//! holds the addresses it connects to (+ the `local` toggle).
10
11use crate::cli::command::CommandRequest;
12
13pub mod attach;
14pub mod config;
15pub mod create;
16pub mod delete;
17pub mod detach;
18pub mod kill;
19pub mod list;
20pub mod spawn;
21
22#[derive(clap::Subcommand)]
23pub enum Command {
24    /// Attach a laboratory id to an agent target.
25    Attach(attach::Command),
26    /// Configure the resident laboratory host (addresses, local).
27    Config {
28        #[command(subcommand)]
29        command: config::Command,
30    },
31    /// Create + start a laboratory container.
32    Create(create::Command),
33    /// Delete (remove) a laboratory container, reclaiming disk.
34    Delete(delete::Command),
35    /// Detach a laboratory id from an agent target.
36    Detach(detach::Command),
37    /// Kill the resident laboratory host process.
38    Kill(kill::Command),
39    /// List the laboratory containers created in this state.
40    List(list::Command),
41    /// Spawn the resident laboratory host process.
42    Spawn(spawn::Command),
43}
44
45#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
46#[serde(untagged)]
47#[schemars(rename = "cli.command.laboratories.Request")]
48pub enum Request {
49    #[schemars(title = "Attach")]
50    Attach(attach::Request),
51    #[schemars(title = "AttachRequestSchema")]
52    AttachRequestSchema(attach::request_schema::Request),
53    #[schemars(title = "AttachResponseSchema")]
54    AttachResponseSchema(attach::response_schema::Request),
55    #[schemars(title = "Config")]
56    Config(config::Request),
57    #[schemars(title = "Create")]
58    Create(create::Request),
59    #[schemars(title = "CreateRequestSchema")]
60    CreateRequestSchema(create::request_schema::Request),
61    #[schemars(title = "CreateResponseSchema")]
62    CreateResponseSchema(create::response_schema::Request),
63    #[schemars(title = "Delete")]
64    Delete(delete::Request),
65    #[schemars(title = "DeleteRequestSchema")]
66    DeleteRequestSchema(delete::request_schema::Request),
67    #[schemars(title = "DeleteResponseSchema")]
68    DeleteResponseSchema(delete::response_schema::Request),
69    #[schemars(title = "Detach")]
70    Detach(detach::Request),
71    #[schemars(title = "DetachRequestSchema")]
72    DetachRequestSchema(detach::request_schema::Request),
73    #[schemars(title = "DetachResponseSchema")]
74    DetachResponseSchema(detach::response_schema::Request),
75    #[schemars(title = "Kill")]
76    Kill(kill::Request),
77    #[schemars(title = "KillRequestSchema")]
78    KillRequestSchema(kill::request_schema::Request),
79    #[schemars(title = "KillResponseSchema")]
80    KillResponseSchema(kill::response_schema::Request),
81    #[schemars(title = "List")]
82    List(list::Request),
83    #[schemars(title = "ListRequestSchema")]
84    ListRequestSchema(list::request_schema::Request),
85    #[schemars(title = "ListResponseSchema")]
86    ListResponseSchema(list::response_schema::Request),
87    #[schemars(title = "Spawn")]
88    Spawn(spawn::Request),
89    #[schemars(title = "SpawnRequestSchema")]
90    SpawnRequestSchema(spawn::request_schema::Request),
91    #[schemars(title = "SpawnResponseSchema")]
92    SpawnResponseSchema(spawn::response_schema::Request),
93}
94
95// Exempt from json-schema coverage: tier aggregate (see the root
96// `ResponseItem` in command.rs - TS7056).
97#[objectiveai_sdk_macros::json_schema_ignore]
98#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
99#[schemars(rename = "cli.command.laboratories.ResponseItem")]
100#[serde(untagged)]
101pub enum ResponseItem {
102    #[schemars(title = "Attach")]
103    Attach(attach::Response),
104    #[schemars(title = "AttachRequestSchema")]
105    AttachRequestSchema(attach::request_schema::Response),
106    #[schemars(title = "AttachResponseSchema")]
107    AttachResponseSchema(attach::response_schema::Response),
108    #[schemars(title = "Config")]
109    Config(config::Response),
110    #[schemars(title = "Create")]
111    Create(create::Response),
112    #[schemars(title = "CreateRequestSchema")]
113    CreateRequestSchema(create::request_schema::Response),
114    #[schemars(title = "CreateResponseSchema")]
115    CreateResponseSchema(create::response_schema::Response),
116    #[schemars(title = "Delete")]
117    Delete(delete::Response),
118    #[schemars(title = "DeleteRequestSchema")]
119    DeleteRequestSchema(delete::request_schema::Response),
120    #[schemars(title = "DeleteResponseSchema")]
121    DeleteResponseSchema(delete::response_schema::Response),
122    #[schemars(title = "Detach")]
123    Detach(detach::Response),
124    #[schemars(title = "DetachRequestSchema")]
125    DetachRequestSchema(detach::request_schema::Response),
126    #[schemars(title = "DetachResponseSchema")]
127    DetachResponseSchema(detach::response_schema::Response),
128    #[schemars(title = "Kill")]
129    Kill(kill::Response),
130    #[schemars(title = "KillRequestSchema")]
131    KillRequestSchema(kill::request_schema::Response),
132    #[schemars(title = "KillResponseSchema")]
133    KillResponseSchema(kill::response_schema::Response),
134    #[schemars(title = "List")]
135    List(list::ResponseItem),
136    #[schemars(title = "ListRequestSchema")]
137    ListRequestSchema(list::request_schema::Response),
138    #[schemars(title = "ListResponseSchema")]
139    ListResponseSchema(list::response_schema::Response),
140    #[schemars(title = "Spawn")]
141    Spawn(spawn::Response),
142    #[schemars(title = "SpawnRequestSchema")]
143    SpawnRequestSchema(spawn::request_schema::Response),
144    #[schemars(title = "SpawnResponseSchema")]
145    SpawnResponseSchema(spawn::response_schema::Response),
146}
147
148#[cfg(feature = "mcp")]
149impl crate::cli::command::CommandResponse for ResponseItem {
150    fn into_mcp(self) -> crate::cli::command::McpResponseItem {
151        match self {
152            ResponseItem::Attach(v) => v.into_mcp(),
153            ResponseItem::AttachRequestSchema(v) => v.into_mcp(),
154            ResponseItem::AttachResponseSchema(v) => v.into_mcp(),
155            ResponseItem::Config(v) => v.into_mcp(),
156            ResponseItem::Create(v) => v.into_mcp(),
157            ResponseItem::CreateRequestSchema(v) => v.into_mcp(),
158            ResponseItem::CreateResponseSchema(v) => v.into_mcp(),
159            ResponseItem::Delete(v) => v.into_mcp(),
160            ResponseItem::DeleteRequestSchema(v) => v.into_mcp(),
161            ResponseItem::DeleteResponseSchema(v) => v.into_mcp(),
162            ResponseItem::Detach(v) => v.into_mcp(),
163            ResponseItem::DetachRequestSchema(v) => v.into_mcp(),
164            ResponseItem::DetachResponseSchema(v) => v.into_mcp(),
165            ResponseItem::Kill(v) => v.into_mcp(),
166            ResponseItem::KillRequestSchema(v) => v.into_mcp(),
167            ResponseItem::KillResponseSchema(v) => v.into_mcp(),
168            ResponseItem::List(v) => v.into_mcp(),
169            ResponseItem::ListRequestSchema(v) => v.into_mcp(),
170            ResponseItem::ListResponseSchema(v) => v.into_mcp(),
171            ResponseItem::Spawn(v) => v.into_mcp(),
172            ResponseItem::SpawnRequestSchema(v) => v.into_mcp(),
173            ResponseItem::SpawnResponseSchema(v) => v.into_mcp(),
174        }
175    }
176}
177
178impl TryFrom<Command> for Request {
179    type Error = crate::cli::command::FromArgsError;
180    fn try_from(command: Command) -> Result<Self, Self::Error> {
181        match command {
182            Command::Attach(cmd) => match cmd.schema {
183                None => Ok(Request::Attach(attach::Request::try_from(cmd.args)?)),
184                Some(attach::Schema::RequestSchema(args)) => Ok(Request::AttachRequestSchema(
185                    attach::request_schema::Request::try_from(args)?,
186                )),
187                Some(attach::Schema::ResponseSchema(args)) => Ok(Request::AttachResponseSchema(
188                    attach::response_schema::Request::try_from(args)?,
189                )),
190            },
191            Command::Config { command } => {
192                Ok(Request::Config(config::Request::try_from(command)?))
193            }
194            Command::Create(cmd) => match cmd.schema {
195                None => Ok(Request::Create(create::Request::try_from(cmd.args)?)),
196                Some(create::Schema::RequestSchema(args)) => Ok(Request::CreateRequestSchema(
197                    create::request_schema::Request::try_from(args)?,
198                )),
199                Some(create::Schema::ResponseSchema(args)) => Ok(Request::CreateResponseSchema(
200                    create::response_schema::Request::try_from(args)?,
201                )),
202            },
203            Command::Delete(cmd) => match cmd.schema {
204                None => Ok(Request::Delete(delete::Request::try_from(cmd.args)?)),
205                Some(delete::Schema::RequestSchema(args)) => Ok(Request::DeleteRequestSchema(
206                    delete::request_schema::Request::try_from(args)?,
207                )),
208                Some(delete::Schema::ResponseSchema(args)) => Ok(Request::DeleteResponseSchema(
209                    delete::response_schema::Request::try_from(args)?,
210                )),
211            },
212            Command::Detach(cmd) => match cmd.schema {
213                None => Ok(Request::Detach(detach::Request::try_from(cmd.args)?)),
214                Some(detach::Schema::RequestSchema(args)) => Ok(Request::DetachRequestSchema(
215                    detach::request_schema::Request::try_from(args)?,
216                )),
217                Some(detach::Schema::ResponseSchema(args)) => Ok(Request::DetachResponseSchema(
218                    detach::response_schema::Request::try_from(args)?,
219                )),
220            },
221            Command::Kill(cmd) => match cmd.schema {
222                None => Ok(Request::Kill(kill::Request::try_from(cmd.args)?)),
223                Some(kill::Schema::RequestSchema(args)) => Ok(Request::KillRequestSchema(
224                    kill::request_schema::Request::try_from(args)?,
225                )),
226                Some(kill::Schema::ResponseSchema(args)) => Ok(Request::KillResponseSchema(
227                    kill::response_schema::Request::try_from(args)?,
228                )),
229            },
230            Command::Spawn(cmd) => match cmd.schema {
231                None => Ok(Request::Spawn(spawn::Request::try_from(cmd.args)?)),
232                Some(spawn::Schema::RequestSchema(args)) => Ok(Request::SpawnRequestSchema(
233                    spawn::request_schema::Request::try_from(args)?,
234                )),
235                Some(spawn::Schema::ResponseSchema(args)) => Ok(Request::SpawnResponseSchema(
236                    spawn::response_schema::Request::try_from(args)?,
237                )),
238            },
239            Command::List(cmd) => match cmd.schema {
240                None => Ok(Request::List(list::Request::try_from(cmd.args)?)),
241                Some(list::Schema::RequestSchema(args)) => Ok(Request::ListRequestSchema(
242                    list::request_schema::Request::try_from(args)?,
243                )),
244                Some(list::Schema::ResponseSchema(args)) => Ok(Request::ListResponseSchema(
245                    list::response_schema::Request::try_from(args)?,
246                )),
247            },
248        }
249    }
250}
251
252impl CommandRequest for Request {
253    fn request_base(&self) -> &crate::cli::command::RequestBase {
254        match self {
255            Request::Attach(inner) => inner.request_base(),
256            Request::AttachRequestSchema(inner) => inner.request_base(),
257            Request::AttachResponseSchema(inner) => inner.request_base(),
258            Request::Config(inner) => inner.request_base(),
259            Request::Kill(inner) => inner.request_base(),
260            Request::KillRequestSchema(inner) => inner.request_base(),
261            Request::KillResponseSchema(inner) => inner.request_base(),
262            Request::Spawn(inner) => inner.request_base(),
263            Request::SpawnRequestSchema(inner) => inner.request_base(),
264            Request::SpawnResponseSchema(inner) => inner.request_base(),
265            Request::Create(inner) => inner.request_base(),
266            Request::CreateRequestSchema(inner) => inner.request_base(),
267            Request::CreateResponseSchema(inner) => inner.request_base(),
268            Request::Delete(inner) => inner.request_base(),
269            Request::DeleteRequestSchema(inner) => inner.request_base(),
270            Request::DeleteResponseSchema(inner) => inner.request_base(),
271            Request::Detach(inner) => inner.request_base(),
272            Request::DetachRequestSchema(inner) => inner.request_base(),
273            Request::DetachResponseSchema(inner) => inner.request_base(),
274            Request::List(inner) => inner.request_base(),
275            Request::ListRequestSchema(inner) => inner.request_base(),
276            Request::ListResponseSchema(inner) => inner.request_base(),
277        }
278    }
279
280    fn request_base_mut(&mut self) -> Option<&mut crate::cli::command::RequestBase> {
281        match self {
282            Request::Attach(inner) => inner.request_base_mut(),
283            Request::AttachRequestSchema(inner) => inner.request_base_mut(),
284            Request::AttachResponseSchema(inner) => inner.request_base_mut(),
285            Request::Config(inner) => inner.request_base_mut(),
286            Request::Kill(inner) => inner.request_base_mut(),
287            Request::KillRequestSchema(inner) => inner.request_base_mut(),
288            Request::KillResponseSchema(inner) => inner.request_base_mut(),
289            Request::Spawn(inner) => inner.request_base_mut(),
290            Request::SpawnRequestSchema(inner) => inner.request_base_mut(),
291            Request::SpawnResponseSchema(inner) => inner.request_base_mut(),
292            Request::Create(inner) => inner.request_base_mut(),
293            Request::CreateRequestSchema(inner) => inner.request_base_mut(),
294            Request::CreateResponseSchema(inner) => inner.request_base_mut(),
295            Request::Delete(inner) => inner.request_base_mut(),
296            Request::DeleteRequestSchema(inner) => inner.request_base_mut(),
297            Request::DeleteResponseSchema(inner) => inner.request_base_mut(),
298            Request::Detach(inner) => inner.request_base_mut(),
299            Request::DetachRequestSchema(inner) => inner.request_base_mut(),
300            Request::DetachResponseSchema(inner) => inner.request_base_mut(),
301            Request::List(inner) => inner.request_base_mut(),
302            Request::ListRequestSchema(inner) => inner.request_base_mut(),
303            Request::ListResponseSchema(inner) => inner.request_base_mut(),
304        }
305    }
306}
307
308#[cfg(feature = "cli-executor")]
309pub async fn execute<E: crate::cli::command::CommandExecutor>(
310    executor: &E,
311    request: Request,
312    agent_arguments: Option<&crate::cli::command::AgentArguments>,
313) -> Result<
314    std::pin::Pin<Box<dyn futures::Stream<Item = Result<ResponseItem, E::Error>> + Send>>,
315    E::Error,
316> {
317    use futures::StreamExt as _;
318    let stream: std::pin::Pin<
319        Box<dyn futures::Stream<Item = Result<ResponseItem, E::Error>> + Send>,
320    > = match request {
321        Request::Attach(req) => {
322            let value = attach::execute(executor, req, agent_arguments).await?;
323            Box::pin(crate::cli::command::StreamOnce::new(Ok(
324                ResponseItem::Attach(value),
325            )))
326        }
327        Request::AttachRequestSchema(req) => {
328            let value = attach::request_schema::execute(executor, req, agent_arguments).await?;
329            Box::pin(crate::cli::command::StreamOnce::new(Ok(
330                ResponseItem::AttachRequestSchema(value),
331            )))
332        }
333        Request::AttachResponseSchema(req) => {
334            let value = attach::response_schema::execute(executor, req, agent_arguments).await?;
335            Box::pin(crate::cli::command::StreamOnce::new(Ok(
336                ResponseItem::AttachResponseSchema(value),
337            )))
338        }
339        Request::Config(req) => {
340            let inner = config::execute(executor, req, agent_arguments).await?;
341            Box::pin(inner.map(|r| r.map(ResponseItem::Config)))
342        }
343        Request::Kill(req) => {
344            let value = kill::execute(executor, req, agent_arguments).await?;
345            Box::pin(crate::cli::command::StreamOnce::new(Ok(
346                ResponseItem::Kill(value),
347            )))
348        }
349        Request::KillRequestSchema(req) => {
350            let value = kill::request_schema::execute(executor, req, agent_arguments).await?;
351            Box::pin(crate::cli::command::StreamOnce::new(Ok(
352                ResponseItem::KillRequestSchema(value),
353            )))
354        }
355        Request::KillResponseSchema(req) => {
356            let value = kill::response_schema::execute(executor, req, agent_arguments).await?;
357            Box::pin(crate::cli::command::StreamOnce::new(Ok(
358                ResponseItem::KillResponseSchema(value),
359            )))
360        }
361        Request::Spawn(req) => {
362            let value = spawn::execute(executor, req, agent_arguments).await?;
363            Box::pin(crate::cli::command::StreamOnce::new(Ok(
364                ResponseItem::Spawn(value),
365            )))
366        }
367        Request::SpawnRequestSchema(req) => {
368            let value = spawn::request_schema::execute(executor, req, agent_arguments).await?;
369            Box::pin(crate::cli::command::StreamOnce::new(Ok(
370                ResponseItem::SpawnRequestSchema(value),
371            )))
372        }
373        Request::SpawnResponseSchema(req) => {
374            let value = spawn::response_schema::execute(executor, req, agent_arguments).await?;
375            Box::pin(crate::cli::command::StreamOnce::new(Ok(
376                ResponseItem::SpawnResponseSchema(value),
377            )))
378        }
379        Request::Create(req) => {
380            let value = create::execute(executor, req, agent_arguments).await?;
381            Box::pin(crate::cli::command::StreamOnce::new(Ok(
382                ResponseItem::Create(value),
383            )))
384        }
385        Request::CreateRequestSchema(req) => {
386            let value = create::request_schema::execute(executor, req, agent_arguments).await?;
387            Box::pin(crate::cli::command::StreamOnce::new(Ok(
388                ResponseItem::CreateRequestSchema(value),
389            )))
390        }
391        Request::CreateResponseSchema(req) => {
392            let value = create::response_schema::execute(executor, req, agent_arguments).await?;
393            Box::pin(crate::cli::command::StreamOnce::new(Ok(
394                ResponseItem::CreateResponseSchema(value),
395            )))
396        }
397        Request::Delete(req) => {
398            let value = delete::execute(executor, req, agent_arguments).await?;
399            Box::pin(crate::cli::command::StreamOnce::new(Ok(
400                ResponseItem::Delete(value),
401            )))
402        }
403        Request::DeleteRequestSchema(req) => {
404            let value = delete::request_schema::execute(executor, req, agent_arguments).await?;
405            Box::pin(crate::cli::command::StreamOnce::new(Ok(
406                ResponseItem::DeleteRequestSchema(value),
407            )))
408        }
409        Request::DeleteResponseSchema(req) => {
410            let value = delete::response_schema::execute(executor, req, agent_arguments).await?;
411            Box::pin(crate::cli::command::StreamOnce::new(Ok(
412                ResponseItem::DeleteResponseSchema(value),
413            )))
414        }
415        Request::Detach(req) => {
416            let value = detach::execute(executor, req, agent_arguments).await?;
417            Box::pin(crate::cli::command::StreamOnce::new(Ok(
418                ResponseItem::Detach(value),
419            )))
420        }
421        Request::DetachRequestSchema(req) => {
422            let value = detach::request_schema::execute(executor, req, agent_arguments).await?;
423            Box::pin(crate::cli::command::StreamOnce::new(Ok(
424                ResponseItem::DetachRequestSchema(value),
425            )))
426        }
427        Request::DetachResponseSchema(req) => {
428            let value = detach::response_schema::execute(executor, req, agent_arguments).await?;
429            Box::pin(crate::cli::command::StreamOnce::new(Ok(
430                ResponseItem::DetachResponseSchema(value),
431            )))
432        }
433        Request::List(req) => {
434            let inner = list::execute(executor, req, agent_arguments).await?;
435            Box::pin(inner.map(|r| r.map(ResponseItem::List)))
436        }
437        Request::ListRequestSchema(req) => {
438            let value = list::request_schema::execute(executor, req, agent_arguments).await?;
439            Box::pin(crate::cli::command::StreamOnce::new(Ok(
440                ResponseItem::ListRequestSchema(value),
441            )))
442        }
443        Request::ListResponseSchema(req) => {
444            let value = list::response_schema::execute(executor, req, agent_arguments).await?;
445            Box::pin(crate::cli::command::StreamOnce::new(Ok(
446                ResponseItem::ListResponseSchema(value),
447            )))
448        }
449    };
450    Ok(stream)
451}
452
453#[cfg(feature = "cli-executor")]
454pub async fn execute_transform<E: crate::cli::command::CommandExecutor>(
455    executor: &E,
456    request: Request,
457    transform: crate::cli::command::Transform,
458    agent_arguments: Option<&crate::cli::command::AgentArguments>,
459) -> Result<
460    std::pin::Pin<Box<dyn futures::Stream<Item = Result<serde_json::Value, E::Error>> + Send>>,
461    E::Error,
462> {
463    let stream: std::pin::Pin<
464        Box<dyn futures::Stream<Item = Result<serde_json::Value, E::Error>> + Send>,
465    > = match request {
466        Request::Attach(req) => {
467            let value = attach::execute_transform(executor, req, transform, agent_arguments).await?;
468            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
469        }
470        Request::AttachRequestSchema(req) => {
471            let value = attach::request_schema::execute_transform(
472                executor,
473                req,
474                transform,
475                agent_arguments,
476            )
477            .await?;
478            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
479        }
480        Request::AttachResponseSchema(req) => {
481            let value = attach::response_schema::execute_transform(
482                executor,
483                req,
484                transform,
485                agent_arguments,
486            )
487            .await?;
488            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
489        }
490        Request::Config(req) => {
491            let inner = config::execute_transform(executor, req, transform, agent_arguments).await?;
492            Box::pin(inner)
493        }
494        Request::Kill(req) => {
495            let value = kill::execute_transform(executor, req, transform, agent_arguments).await?;
496            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
497        }
498        Request::KillRequestSchema(req) => {
499            let value = kill::request_schema::execute_transform(
500                executor,
501                req,
502                transform,
503                agent_arguments,
504            )
505            .await?;
506            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
507        }
508        Request::KillResponseSchema(req) => {
509            let value = kill::response_schema::execute_transform(
510                executor,
511                req,
512                transform,
513                agent_arguments,
514            )
515            .await?;
516            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
517        }
518        Request::Spawn(req) => {
519            let value = spawn::execute_transform(executor, req, transform, agent_arguments).await?;
520            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
521        }
522        Request::SpawnRequestSchema(req) => {
523            let value = spawn::request_schema::execute_transform(
524                executor,
525                req,
526                transform,
527                agent_arguments,
528            )
529            .await?;
530            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
531        }
532        Request::SpawnResponseSchema(req) => {
533            let value = spawn::response_schema::execute_transform(
534                executor,
535                req,
536                transform,
537                agent_arguments,
538            )
539            .await?;
540            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
541        }
542        Request::Create(req) => {
543            let value = create::execute_transform(executor, req, transform, agent_arguments).await?;
544            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
545        }
546        Request::CreateRequestSchema(req) => {
547            let value = create::request_schema::execute_transform(
548                executor,
549                req,
550                transform,
551                agent_arguments,
552            )
553            .await?;
554            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
555        }
556        Request::CreateResponseSchema(req) => {
557            let value = create::response_schema::execute_transform(
558                executor,
559                req,
560                transform,
561                agent_arguments,
562            )
563            .await?;
564            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
565        }
566        Request::Delete(req) => {
567            let value = delete::execute_transform(executor, req, transform, agent_arguments).await?;
568            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
569        }
570        Request::DeleteRequestSchema(req) => {
571            let value = delete::request_schema::execute_transform(
572                executor,
573                req,
574                transform,
575                agent_arguments,
576            )
577            .await?;
578            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
579        }
580        Request::DeleteResponseSchema(req) => {
581            let value = delete::response_schema::execute_transform(
582                executor,
583                req,
584                transform,
585                agent_arguments,
586            )
587            .await?;
588            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
589        }
590        Request::Detach(req) => {
591            let value = detach::execute_transform(executor, req, transform, agent_arguments).await?;
592            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
593        }
594        Request::DetachRequestSchema(req) => {
595            let value = detach::request_schema::execute_transform(
596                executor,
597                req,
598                transform,
599                agent_arguments,
600            )
601            .await?;
602            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
603        }
604        Request::DetachResponseSchema(req) => {
605            let value = detach::response_schema::execute_transform(
606                executor,
607                req,
608                transform,
609                agent_arguments,
610            )
611            .await?;
612            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
613        }
614        Request::List(req) => {
615            let inner = list::execute_transform(executor, req, transform, agent_arguments).await?;
616            Box::pin(inner)
617        }
618        Request::ListRequestSchema(req) => {
619            let value = list::request_schema::execute_transform(
620                executor,
621                req,
622                transform,
623                agent_arguments,
624            )
625            .await?;
626            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
627        }
628        Request::ListResponseSchema(req) => {
629            let value = list::response_schema::execute_transform(
630                executor,
631                req,
632                transform,
633                agent_arguments,
634            )
635            .await?;
636            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
637        }
638    };
639    Ok(stream)
640}
641
642/// `/listen` mirror of [`Request`]: one variant per child, wrapping
643/// its `ListenerExecution`. See [`crate::cli::broadcast_listener`].
644#[cfg(feature = "cli-listener")]
645pub enum ListenerExecution {
646    Attach(attach::ListenerExecution),
647    AttachRequestSchema(attach::request_schema::ListenerExecution),
648    AttachResponseSchema(attach::response_schema::ListenerExecution),
649    Config(config::ListenerExecution),
650    Kill(kill::ListenerExecution),
651    KillRequestSchema(kill::request_schema::ListenerExecution),
652    KillResponseSchema(kill::response_schema::ListenerExecution),
653    Spawn(spawn::ListenerExecution),
654    SpawnRequestSchema(spawn::request_schema::ListenerExecution),
655    SpawnResponseSchema(spawn::response_schema::ListenerExecution),
656    Create(create::ListenerExecution),
657    CreateRequestSchema(create::request_schema::ListenerExecution),
658    CreateResponseSchema(create::response_schema::ListenerExecution),
659    Delete(delete::ListenerExecution),
660    DeleteRequestSchema(delete::request_schema::ListenerExecution),
661    DeleteResponseSchema(delete::response_schema::ListenerExecution),
662    Detach(detach::ListenerExecution),
663    DetachRequestSchema(detach::request_schema::ListenerExecution),
664    DetachResponseSchema(detach::response_schema::ListenerExecution),
665    List(list::ListenerExecution),
666    ListRequestSchema(list::request_schema::ListenerExecution),
667    ListResponseSchema(list::response_schema::ListenerExecution),
668}
objectiveai_sdk/cli/command/laboratories/mod.rs

objectiveai_sdk/cli/command/laboratories/
mod.rs
