Skip to main content

objectiveai_sdk/cli/command/development/plugins/mcp/
mod.rs

1//! `development plugins mcp` — point a plugin's MCP half at a local
2//! directory instead of its git tag, for the edit-run loop. Leaves:
3//!
4//! - `create` — register a directory for a plugin's coordinates.
5//! - `list` — every registration.
6//! - `delete` — drop one, restoring the git-tag fetch.
7//! - `reset` — drop the built image so the next run rebuilds.
8
9use 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    /// Register a local directory for a plugin's coordinates.
19    Create(create::Command),
20    /// List the plugins registered for development.
21    List(list::Command),
22    /// Drop a registration, restoring the git-tag fetch.
23    Delete(delete::Command),
24    /// Drop the built image so the next run rebuilds it.
25    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// Exempt from json-schema coverage: tier aggregate (see the root
59// `ResponseItem` in command.rs - TS7056).
60#[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/// `/listen` mirror of [`Request`]. See [`crate::daemon::command_listener`].
322#[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}