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
152#[cfg(feature = "cli-executor")]
153pub async fn execute<E: crate::cli::command::CommandExecutor>(
154 executor: &E,
155 request: Request,
156
157 agent_arguments: Option<&crate::cli::command::AgentArguments>,
158 ) -> Result<
159 std::pin::Pin<Box<dyn futures::Stream<Item = Result<ResponseItem, E::Error>> + Send>>,
160 E::Error,
161> {
162 use futures::StreamExt;
163 let stream: std::pin::Pin<Box<dyn futures::Stream<Item = Result<ResponseItem, E::Error>> + Send>> =
164 match request {
165 Request::Get(req) => {
166 let value = get::execute(executor, req, agent_arguments).await?;
167 Box::pin(crate::cli::command::StreamOnce::new(Ok(
168 ResponseItem::Get(value),
169 )))
170 }
171 Request::GetRequestSchema(req) => {
172 let value = get::request_schema::execute(executor, req, agent_arguments).await?;
173 Box::pin(crate::cli::command::StreamOnce::new(Ok(
174 ResponseItem::GetRequestSchema(value),
175 )))
176 }
177 Request::GetResponseSchema(req) => {
178 let value = get::response_schema::execute(executor, req, agent_arguments).await?;
179 Box::pin(crate::cli::command::StreamOnce::new(Ok(
180 ResponseItem::GetResponseSchema(value),
181 )))
182 }
183 Request::Install(req) => {
184 let value = install::execute(executor, req, agent_arguments).await?;
185 Box::pin(crate::cli::command::StreamOnce::new(Ok(
186 ResponseItem::Install(value),
187 )))
188 }
189 Request::InstallRequestSchema(req) => {
190 let value = install::request_schema::execute(executor, req, agent_arguments).await?;
191 Box::pin(crate::cli::command::StreamOnce::new(Ok(
192 ResponseItem::InstallRequestSchema(value),
193 )))
194 }
195 Request::InstallResponseSchema(req) => {
196 let value = install::response_schema::execute(executor, req, agent_arguments).await?;
197 Box::pin(crate::cli::command::StreamOnce::new(Ok(
198 ResponseItem::InstallResponseSchema(value),
199 )))
200 }
201 Request::List(req) => {
202 let inner = list::execute(executor, req, agent_arguments).await?;
203 Box::pin(inner.map(|r| r.map(ResponseItem::List)))
204 }
205 Request::ListRequestSchema(req) => {
206 let value = list::request_schema::execute(executor, req, agent_arguments).await?;
207 Box::pin(crate::cli::command::StreamOnce::new(Ok(
208 ResponseItem::ListRequestSchema(value),
209 )))
210 }
211 Request::ListResponseSchema(req) => {
212 let value = list::response_schema::execute(executor, req, agent_arguments).await?;
213 Box::pin(crate::cli::command::StreamOnce::new(Ok(
214 ResponseItem::ListResponseSchema(value),
215 )))
216 }
217 Request::Run(req) => {
218 let inner = run::execute(executor, req, agent_arguments).await?;
219 Box::pin(inner.map(|r| r.map(ResponseItem::Run)))
220 }
221 Request::RunRequestSchema(req) => {
222 let value = run::request_schema::execute(executor, req, agent_arguments).await?;
223 Box::pin(crate::cli::command::StreamOnce::new(Ok(
224 ResponseItem::RunRequestSchema(value),
225 )))
226 }
227 Request::RunResponseSchema(req) => {
228 let value = run::response_schema::execute(executor, req, agent_arguments).await?;
229 Box::pin(crate::cli::command::StreamOnce::new(Ok(
230 ResponseItem::RunResponseSchema(value),
231 )))
232 }
233 };
234 Ok(stream)
235}
236
237#[cfg(feature = "cli-executor")]
238pub async fn execute_jq<E: crate::cli::command::CommandExecutor>(
239 executor: &E,
240 request: Request,
241 jq: String,
242
243 agent_arguments: Option<&crate::cli::command::AgentArguments>,
244 ) -> Result<
245 std::pin::Pin<Box<dyn futures::Stream<Item = Result<serde_json::Value, E::Error>> + Send>>,
246 E::Error,
247> {
248 let stream: std::pin::Pin<Box<dyn futures::Stream<Item = Result<serde_json::Value, E::Error>> + Send>> =
249 match request {
250 Request::Get(req) => {
251 let value = get::execute_jq(executor, req, jq, agent_arguments).await?;
252 Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
253 }
254 Request::GetRequestSchema(req) => {
255 let value = get::request_schema::execute_jq(executor, req, jq, agent_arguments).await?;
256 Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
257 }
258 Request::GetResponseSchema(req) => {
259 let value = get::response_schema::execute_jq(executor, req, jq, agent_arguments).await?;
260 Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
261 }
262 Request::Install(req) => {
263 let value = install::execute_jq(executor, req, jq, agent_arguments).await?;
264 Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
265 }
266 Request::InstallRequestSchema(req) => {
267 let value = install::request_schema::execute_jq(executor, req, jq, agent_arguments).await?;
268 Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
269 }
270 Request::InstallResponseSchema(req) => {
271 let value = install::response_schema::execute_jq(executor, req, jq, agent_arguments).await?;
272 Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
273 }
274 Request::List(req) => {
275 let inner = list::execute_jq(executor, req, jq, agent_arguments).await?;
276 Box::pin(inner)
277 }
278 Request::ListRequestSchema(req) => {
279 let value = list::request_schema::execute_jq(executor, req, jq, agent_arguments).await?;
280 Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
281 }
282 Request::ListResponseSchema(req) => {
283 let value = list::response_schema::execute_jq(executor, req, jq, agent_arguments).await?;
284 Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
285 }
286 Request::Run(req) => {
287 let inner = run::execute_jq(executor, req, jq, agent_arguments).await?;
288 Box::pin(inner)
289 }
290 Request::RunRequestSchema(req) => {
291 let value = run::request_schema::execute_jq(executor, req, jq, agent_arguments).await?;
292 Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
293 }
294 Request::RunResponseSchema(req) => {
295 let value = run::response_schema::execute_jq(executor, req, jq, agent_arguments).await?;
296 Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
297 }
298 };
299 Ok(stream)
300}