objectiveai_sdk/cli/command/plugins/
mod.rs

1pub mod get;
2pub mod install;
3pub mod list;
4pub mod logs;
5pub mod run;
6
7#[derive(clap::Subcommand)]
8pub enum Command {
9    Get(get::Command),
10    Install {
11        #[command(subcommand)]
12        command: install::Command,
13    },
14    List(list::Command),
15    Logs {
16        #[command(subcommand)]
17        command: logs::Command,
18    },
19    Run(run::Command),
20}
21
22#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
23#[serde(untagged)]
24#[schemars(rename = "cli.command.plugins.Request")]
25pub enum Request {
26    #[schemars(title = "Get")]
27    Get(get::Request),
28    #[schemars(title = "GetRequestSchema")]
29    GetRequestSchema(get::request_schema::Request),
30    #[schemars(title = "GetResponseSchema")]
31    GetResponseSchema(get::response_schema::Request),
32    #[schemars(title = "Install")]
33    Install(install::Request),
34    #[schemars(title = "List")]
35    List(list::Request),
36    #[schemars(title = "ListRequestSchema")]
37    ListRequestSchema(list::request_schema::Request),
38    #[schemars(title = "ListResponseSchema")]
39    ListResponseSchema(list::response_schema::Request),
40    #[schemars(title = "Logs")]
41    Logs(logs::Request),
42    #[schemars(title = "Run")]
43    Run(run::Request),
44    #[schemars(title = "RunRequestSchema")]
45    RunRequestSchema(run::request_schema::Request),
46    #[schemars(title = "RunResponseSchema")]
47    RunResponseSchema(run::response_schema::Request),
48}
49
50// Exempt from json-schema coverage: tier aggregate (see the root
51// `ResponseItem` in command.rs - TS7056).
52#[objectiveai_sdk_macros::json_schema_ignore]
53#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
54#[schemars(rename = "cli.command.plugins.ResponseItem")]
55#[serde(untagged)]
56pub enum ResponseItem {
57    #[schemars(title = "Get")]
58    Get(get::Response),
59    #[schemars(title = "GetRequestSchema")]
60    GetRequestSchema(get::request_schema::Response),
61    #[schemars(title = "GetResponseSchema")]
62    GetResponseSchema(get::response_schema::Response),
63    #[schemars(title = "Install")]
64    Install(install::Response),
65    #[schemars(title = "List")]
66    List(list::ResponseItem),
67    #[schemars(title = "ListRequestSchema")]
68    ListRequestSchema(list::request_schema::Response),
69    #[schemars(title = "ListResponseSchema")]
70    ListResponseSchema(list::response_schema::Response),
71    #[schemars(title = "Logs")]
72    Logs(logs::ResponseItem),
73    #[schemars(title = "Run")]
74    Run(run::ResponseItem),
75    #[schemars(title = "RunRequestSchema")]
76    RunRequestSchema(run::request_schema::Response),
77    #[schemars(title = "RunResponseSchema")]
78    RunResponseSchema(run::response_schema::Response),
79}
80
81#[cfg(feature = "mcp")]
82impl crate::cli::command::CommandResponse for ResponseItem {
83    fn into_mcp(self) -> crate::cli::command::McpResponseItem {
84        match self {
85            ResponseItem::Get(v) => v.into_mcp(),
86            ResponseItem::GetRequestSchema(v) => v.into_mcp(),
87            ResponseItem::GetResponseSchema(v) => v.into_mcp(),
88            ResponseItem::Install(v) => v.into_mcp(),
89            ResponseItem::List(v) => v.into_mcp(),
90            ResponseItem::ListRequestSchema(v) => v.into_mcp(),
91            ResponseItem::ListResponseSchema(v) => v.into_mcp(),
92            ResponseItem::Logs(v) => v.into_mcp(),
93            ResponseItem::Run(v) => v.into_mcp(),
94            ResponseItem::RunRequestSchema(v) => v.into_mcp(),
95            ResponseItem::RunResponseSchema(v) => v.into_mcp(),
96        }
97    }
98}
99
100impl TryFrom<Command> for Request {
101    type Error = crate::cli::command::FromArgsError;
102    fn try_from(command: Command) -> Result<Self, Self::Error> {
103        match command {
104            Command::Get(cmd) => match cmd.schema {
105                None => Ok(Request::Get(get::Request::try_from(cmd.args)?)),
106                Some(get::Schema::RequestSchema(args)) =>
107                    Ok(Request::GetRequestSchema(get::request_schema::Request::try_from(args)?)),
108                Some(get::Schema::ResponseSchema(args)) =>
109                    Ok(Request::GetResponseSchema(get::response_schema::Request::try_from(args)?)),
110            },
111            Command::Install { command } =>
112                Ok(Request::Install(install::Request::try_from(command)?)),
113            Command::Logs { command } =>
114                Ok(Request::Logs(logs::Request::try_from(command)?)),
115            Command::List(cmd) => match cmd.schema {
116                None => Ok(Request::List(list::Request::try_from(cmd.args)?)),
117                Some(list::Schema::RequestSchema(args)) =>
118                    Ok(Request::ListRequestSchema(list::request_schema::Request::try_from(args)?)),
119                Some(list::Schema::ResponseSchema(args)) =>
120                    Ok(Request::ListResponseSchema(list::response_schema::Request::try_from(args)?)),
121            },
122            Command::Run(cmd) => match cmd.schema {
123                None => Ok(Request::Run(run::Request::try_from(cmd.args)?)),
124                Some(run::Schema::RequestSchema(args)) =>
125                    Ok(Request::RunRequestSchema(run::request_schema::Request::try_from(args)?)),
126                Some(run::Schema::ResponseSchema(args)) =>
127                    Ok(Request::RunResponseSchema(run::response_schema::Request::try_from(args)?)),
128            },
129        }
130    }
131}
132
133impl crate::cli::command::CommandRequest for Request {
134    fn request_base(&self) -> &crate::cli::command::RequestBase {
135        match self {
136            Request::Get(inner) => inner.request_base(),
137            Request::GetRequestSchema(inner) => inner.request_base(),
138            Request::GetResponseSchema(inner) => inner.request_base(),
139            Request::Install(inner) => inner.request_base(),
140            Request::List(inner) => inner.request_base(),
141            Request::ListRequestSchema(inner) => inner.request_base(),
142            Request::ListResponseSchema(inner) => inner.request_base(),
143            Request::Logs(inner) => inner.request_base(),
144            Request::Run(inner) => inner.request_base(),
145            Request::RunRequestSchema(inner) => inner.request_base(),
146            Request::RunResponseSchema(inner) => inner.request_base(),
147        }
148    }
149
150    fn request_base_mut(&mut self) -> Option<&mut crate::cli::command::RequestBase> {
151        match self {
152            Request::Get(inner) => inner.request_base_mut(),
153            Request::GetRequestSchema(inner) => inner.request_base_mut(),
154            Request::GetResponseSchema(inner) => inner.request_base_mut(),
155            Request::Install(inner) => inner.request_base_mut(),
156            Request::List(inner) => inner.request_base_mut(),
157            Request::ListRequestSchema(inner) => inner.request_base_mut(),
158            Request::ListResponseSchema(inner) => inner.request_base_mut(),
159            Request::Logs(inner) => inner.request_base_mut(),
160            Request::Run(inner) => inner.request_base_mut(),
161            Request::RunRequestSchema(inner) => inner.request_base_mut(),
162            Request::RunResponseSchema(inner) => inner.request_base_mut(),
163        }
164    }
165}
166
167#[cfg(feature = "cli-executor")]
168pub async fn execute<E: crate::cli::command::CommandExecutor>(
169    executor: &E,
170    request: Request,
171
172        agent_arguments: Option<&crate::cli::command::AgentArguments>,
173    ) -> Result<
174    std::pin::Pin<Box<dyn futures::Stream<Item = Result<ResponseItem, E::Error>> + Send>>,
175    E::Error,
176> {
177    use futures::StreamExt;
178    let stream: std::pin::Pin<Box<dyn futures::Stream<Item = Result<ResponseItem, E::Error>> + Send>> =
179        match request {
180            Request::Get(req) => {
181                let value = get::execute(executor, req, agent_arguments).await?;
182                Box::pin(crate::cli::command::StreamOnce::new(Ok(
183                    ResponseItem::Get(value),
184                )))
185            }
186            Request::GetRequestSchema(req) => {
187                let value = get::request_schema::execute(executor, req, agent_arguments).await?;
188                Box::pin(crate::cli::command::StreamOnce::new(Ok(
189                    ResponseItem::GetRequestSchema(value),
190                )))
191            }
192            Request::GetResponseSchema(req) => {
193                let value = get::response_schema::execute(executor, req, agent_arguments).await?;
194                Box::pin(crate::cli::command::StreamOnce::new(Ok(
195                    ResponseItem::GetResponseSchema(value),
196                )))
197            }
198            Request::Install(req) => {
199                let inner = install::execute(executor, req, agent_arguments).await?;
200                Box::pin(inner.map(|r| r.map(ResponseItem::Install)))
201            }
202            Request::List(req) => {
203                let inner = list::execute(executor, req, agent_arguments).await?;
204                Box::pin(inner.map(|r| r.map(ResponseItem::List)))
205            }
206            Request::ListRequestSchema(req) => {
207                let value = list::request_schema::execute(executor, req, agent_arguments).await?;
208                Box::pin(crate::cli::command::StreamOnce::new(Ok(
209                    ResponseItem::ListRequestSchema(value),
210                )))
211            }
212            Request::ListResponseSchema(req) => {
213                let value = list::response_schema::execute(executor, req, agent_arguments).await?;
214                Box::pin(crate::cli::command::StreamOnce::new(Ok(
215                    ResponseItem::ListResponseSchema(value),
216                )))
217            }
218            Request::Logs(req) => {
219                let inner = logs::execute(executor, req, agent_arguments).await?;
220                Box::pin(inner.map(|r| r.map(ResponseItem::Logs)))
221            }
222            Request::Run(req) => {
223                let inner = run::execute(executor, req, agent_arguments).await?;
224                Box::pin(inner.map(|r| r.map(ResponseItem::Run)))
225            }
226            Request::RunRequestSchema(req) => {
227                let value = run::request_schema::execute(executor, req, agent_arguments).await?;
228                Box::pin(crate::cli::command::StreamOnce::new(Ok(
229                    ResponseItem::RunRequestSchema(value),
230                )))
231            }
232            Request::RunResponseSchema(req) => {
233                let value = run::response_schema::execute(executor, req, agent_arguments).await?;
234                Box::pin(crate::cli::command::StreamOnce::new(Ok(
235                    ResponseItem::RunResponseSchema(value),
236                )))
237            }
238        };
239    Ok(stream)
240}
241
242#[cfg(feature = "cli-executor")]
243pub async fn execute_transform<E: crate::cli::command::CommandExecutor>(
244    executor: &E,
245    request: Request,
246    transform: crate::cli::command::Transform,
247
248        agent_arguments: Option<&crate::cli::command::AgentArguments>,
249    ) -> Result<
250    std::pin::Pin<Box<dyn futures::Stream<Item = Result<serde_json::Value, E::Error>> + Send>>,
251    E::Error,
252> {
253    let stream: std::pin::Pin<Box<dyn futures::Stream<Item = Result<serde_json::Value, E::Error>> + Send>> =
254        match request {
255            Request::Get(req) => {
256                let value = get::execute_transform(executor, req, transform, agent_arguments).await?;
257                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
258            }
259            Request::GetRequestSchema(req) => {
260                let value = get::request_schema::execute_transform(executor, req, transform, agent_arguments).await?;
261                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
262            }
263            Request::GetResponseSchema(req) => {
264                let value = get::response_schema::execute_transform(executor, req, transform, agent_arguments).await?;
265                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
266            }
267            Request::Install(req) => {
268                let inner = install::execute_transform(executor, req, transform, agent_arguments).await?;
269                Box::pin(inner)
270            }
271            Request::List(req) => {
272                let inner = list::execute_transform(executor, req, transform, agent_arguments).await?;
273                Box::pin(inner)
274            }
275            Request::ListRequestSchema(req) => {
276                let value = list::request_schema::execute_transform(executor, req, transform, agent_arguments).await?;
277                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
278            }
279            Request::ListResponseSchema(req) => {
280                let value = list::response_schema::execute_transform(executor, req, transform, agent_arguments).await?;
281                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
282            }
283            Request::Logs(req) => {
284                let inner = logs::execute_transform(executor, req, transform, agent_arguments).await?;
285                Box::pin(inner)
286            }
287            Request::Run(req) => {
288                let inner = run::execute_transform(executor, req, transform, agent_arguments).await?;
289                Box::pin(inner)
290            }
291            Request::RunRequestSchema(req) => {
292                let value = run::request_schema::execute_transform(executor, req, transform, agent_arguments).await?;
293                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
294            }
295            Request::RunResponseSchema(req) => {
296                let value = run::response_schema::execute_transform(executor, req, transform, agent_arguments).await?;
297                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
298            }
299        };
300    Ok(stream)
301}
302
303/// `/listen` mirror of [`Request`]: one variant per child, wrapping
304/// its `ListenerExecution`. See [`crate::cli::websocket_listener`].
305#[cfg(feature = "cli-listener")]
306pub enum ListenerExecution {
307    Get(get::ListenerExecution),
308    GetRequestSchema(get::request_schema::ListenerExecution),
309    GetResponseSchema(get::response_schema::ListenerExecution),
310    Install(install::ListenerExecution),
311    List(list::ListenerExecution),
312    ListRequestSchema(list::request_schema::ListenerExecution),
313    ListResponseSchema(list::response_schema::ListenerExecution),
314    Logs(logs::ListenerExecution),
315    Run(run::ListenerExecution),
316    RunRequestSchema(run::request_schema::ListenerExecution),
317    RunResponseSchema(run::response_schema::ListenerExecution),
318}
objectiveai_sdk/cli/command/plugins/mod.rs

objectiveai_sdk/cli/command/plugins/
mod.rs
