objectiveai_sdk/cli/command/tools/
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.tools.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.tools.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            }
104            Command::List(cmd) => match cmd.schema {
105                None => Ok(Request::List(list::Request::try_from(cmd.args)?)),
106                Some(list::Schema::RequestSchema(args)) =>
107                    Ok(Request::ListRequestSchema(list::request_schema::Request::try_from(args)?)),
108                Some(list::Schema::ResponseSchema(args)) =>
109                    Ok(Request::ListResponseSchema(list::response_schema::Request::try_from(args)?)),
110            },
111            Command::Run(cmd) => match cmd.schema {
112                None => Ok(Request::Run(run::Request::try_from(cmd.args)?)),
113                Some(run::Schema::RequestSchema(args)) =>
114                    Ok(Request::RunRequestSchema(run::request_schema::Request::try_from(args)?)),
115                Some(run::Schema::ResponseSchema(args)) =>
116                    Ok(Request::RunResponseSchema(run::response_schema::Request::try_from(args)?)),
117            },
118        }
119    }
120}
121
122impl crate::cli::command::CommandRequest for Request {
123    fn request_base(&self) -> &crate::cli::command::RequestBase {
124        match self {
125            Request::Get(inner) => inner.request_base(),
126            Request::GetRequestSchema(inner) => inner.request_base(),
127            Request::GetResponseSchema(inner) => inner.request_base(),
128            Request::Install(inner) => inner.request_base(),
129            Request::List(inner) => inner.request_base(),
130            Request::ListRequestSchema(inner) => inner.request_base(),
131            Request::ListResponseSchema(inner) => inner.request_base(),
132            Request::Run(inner) => inner.request_base(),
133            Request::RunRequestSchema(inner) => inner.request_base(),
134            Request::RunResponseSchema(inner) => inner.request_base(),
135        }
136    }
137
138    fn request_base_mut(&mut self) -> Option<&mut crate::cli::command::RequestBase> {
139        match self {
140            Request::Get(inner) => inner.request_base_mut(),
141            Request::GetRequestSchema(inner) => inner.request_base_mut(),
142            Request::GetResponseSchema(inner) => inner.request_base_mut(),
143            Request::Install(inner) => inner.request_base_mut(),
144            Request::List(inner) => inner.request_base_mut(),
145            Request::ListRequestSchema(inner) => inner.request_base_mut(),
146            Request::ListResponseSchema(inner) => inner.request_base_mut(),
147            Request::Run(inner) => inner.request_base_mut(),
148            Request::RunRequestSchema(inner) => inner.request_base_mut(),
149            Request::RunResponseSchema(inner) => inner.request_base_mut(),
150        }
151    }
152}
153
154#[cfg(feature = "cli-executor")]
155pub async fn execute<E: crate::cli::command::CommandExecutor>(
156    executor: &E,
157    request: Request,
158
159        agent_arguments: Option<&crate::cli::command::AgentArguments>,
160    ) -> Result<
161    std::pin::Pin<Box<dyn futures::Stream<Item = Result<ResponseItem, E::Error>> + Send>>,
162    E::Error,
163> {
164    use futures::StreamExt;
165    let stream: std::pin::Pin<Box<dyn futures::Stream<Item = Result<ResponseItem, E::Error>> + Send>> =
166        match request {
167            Request::Get(req) => {
168                let value = get::execute(executor, req, agent_arguments).await?;
169                Box::pin(crate::cli::command::StreamOnce::new(Ok(
170                    ResponseItem::Get(value),
171                )))
172            }
173            Request::GetRequestSchema(req) => {
174                let value = get::request_schema::execute(executor, req, agent_arguments).await?;
175                Box::pin(crate::cli::command::StreamOnce::new(Ok(
176                    ResponseItem::GetRequestSchema(value),
177                )))
178            }
179            Request::GetResponseSchema(req) => {
180                let value = get::response_schema::execute(executor, req, agent_arguments).await?;
181                Box::pin(crate::cli::command::StreamOnce::new(Ok(
182                    ResponseItem::GetResponseSchema(value),
183                )))
184            }
185            Request::Install(req) => {
186                let inner = install::execute(executor, req, agent_arguments).await?;
187                Box::pin(inner.map(|r| r.map(ResponseItem::Install)))
188            }
189            Request::List(req) => {
190                let inner = list::execute(executor, req, agent_arguments).await?;
191                Box::pin(inner.map(|r| r.map(ResponseItem::List)))
192            }
193            Request::ListRequestSchema(req) => {
194                let value = list::request_schema::execute(executor, req, agent_arguments).await?;
195                Box::pin(crate::cli::command::StreamOnce::new(Ok(
196                    ResponseItem::ListRequestSchema(value),
197                )))
198            }
199            Request::ListResponseSchema(req) => {
200                let value = list::response_schema::execute(executor, req, agent_arguments).await?;
201                Box::pin(crate::cli::command::StreamOnce::new(Ok(
202                    ResponseItem::ListResponseSchema(value),
203                )))
204            }
205            Request::Run(req) => {
206                let inner = run::execute(executor, req, agent_arguments).await?;
207                Box::pin(inner.map(|r| r.map(ResponseItem::Run)))
208            }
209            Request::RunRequestSchema(req) => {
210                let value = run::request_schema::execute(executor, req, agent_arguments).await?;
211                Box::pin(crate::cli::command::StreamOnce::new(Ok(
212                    ResponseItem::RunRequestSchema(value),
213                )))
214            }
215            Request::RunResponseSchema(req) => {
216                let value = run::response_schema::execute(executor, req, agent_arguments).await?;
217                Box::pin(crate::cli::command::StreamOnce::new(Ok(
218                    ResponseItem::RunResponseSchema(value),
219                )))
220            }
221        };
222    Ok(stream)
223}
224
225#[cfg(feature = "cli-executor")]
226pub async fn execute_transform<E: crate::cli::command::CommandExecutor>(
227    executor: &E,
228    request: Request,
229    transform: crate::cli::command::Transform,
230
231        agent_arguments: Option<&crate::cli::command::AgentArguments>,
232    ) -> Result<
233    std::pin::Pin<Box<dyn futures::Stream<Item = Result<serde_json::Value, E::Error>> + Send>>,
234    E::Error,
235> {
236    let stream: std::pin::Pin<Box<dyn futures::Stream<Item = Result<serde_json::Value, E::Error>> + Send>> =
237        match request {
238            Request::Get(req) => {
239                let value = get::execute_transform(executor, req, transform, agent_arguments).await?;
240                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
241            }
242            Request::GetRequestSchema(req) => {
243                let value = get::request_schema::execute_transform(executor, req, transform, agent_arguments).await?;
244                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
245            }
246            Request::GetResponseSchema(req) => {
247                let value = get::response_schema::execute_transform(executor, req, transform, agent_arguments).await?;
248                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
249            }
250            Request::Install(req) => {
251                let inner = install::execute_transform(executor, req, transform, agent_arguments).await?;
252                Box::pin(inner)
253            }
254            Request::List(req) => {
255                let inner = list::execute_transform(executor, req, transform, agent_arguments).await?;
256                Box::pin(inner)
257            }
258            Request::ListRequestSchema(req) => {
259                let value = list::request_schema::execute_transform(executor, req, transform, agent_arguments).await?;
260                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
261            }
262            Request::ListResponseSchema(req) => {
263                let value = list::response_schema::execute_transform(executor, req, transform, agent_arguments).await?;
264                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
265            }
266            Request::Run(req) => {
267                let inner = run::execute_transform(executor, req, transform, agent_arguments).await?;
268                Box::pin(inner)
269            }
270            Request::RunRequestSchema(req) => {
271                let value = run::request_schema::execute_transform(executor, req, transform, agent_arguments).await?;
272                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
273            }
274            Request::RunResponseSchema(req) => {
275                let value = run::response_schema::execute_transform(executor, req, transform, agent_arguments).await?;
276                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
277            }
278        };
279    Ok(stream)
280}
objectiveai_sdk/cli/command/tools/mod.rs

objectiveai_sdk/cli/command/tools/
mod.rs
