1use 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(attach::Command),
27 Config {
29 #[command(subcommand)]
30 command: config::Command,
31 },
32 Create(create::Command),
34 Delete(delete::Command),
36 Detach(detach::Command),
38 Kill(kill::Command),
40 List(list::Command),
42 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#[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#[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}