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