objectiveai_sdk/cli/command/agents/
mod.rs

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

objectiveai_sdk/cli/command/agents/
mod.rs
