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