objectiveai_sdk/cli/command/plugins/
mod.rs

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

objectiveai_sdk/cli/command/plugins/
mod.rs
