objectiveai_sdk/cli/command/agents/
mod.rs

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

objectiveai_sdk/cli/command/agents/
mod.rs
