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