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