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