Skip to main content

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