1pub mod execute;
2pub mod get;
3pub mod list;
4pub mod profiles;
5pub mod publish;
6
7#[derive(clap::Subcommand)]
8pub enum Command {
9 Execute {
10 #[command(subcommand)]
11 command: execute::Command,
12 },
13 Get(get::Command),
14 List(list::Command),
15 Profiles {
16 #[command(subcommand)]
17 command: profiles::Command,
18 },
19 Publish(publish::Command),
20}
21
22#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
23#[serde(untagged)]
24#[schemars(rename = "cli.command.functions.Request")]
25pub enum Request {
26 #[schemars(title = "Execute")]
27 Execute(execute::Request),
28 #[schemars(title = "Get")]
29 Get(get::Request),
30 #[schemars(title = "GetRequestSchema")]
31 GetRequestSchema(get::request_schema::Request),
32 #[schemars(title = "GetResponseSchema")]
33 GetResponseSchema(get::response_schema::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 = "Profiles")]
41 Profiles(profiles::Request),
42 #[schemars(title = "Publish")]
43 Publish(publish::Request),
44 #[schemars(title = "PublishRequestSchema")]
45 PublishRequestSchema(publish::request_schema::Request),
46 #[schemars(title = "PublishResponseSchema")]
47 PublishResponseSchema(publish::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.functions.ResponseItem")]
55#[serde(untagged)]
56pub enum ResponseItem {
57 #[schemars(title = "Execute")]
58 Execute(execute::ResponseItem),
59 #[schemars(title = "Get")]
60 Get(get::Response),
61 #[schemars(title = "GetRequestSchema")]
62 GetRequestSchema(get::request_schema::Response),
63 #[schemars(title = "GetResponseSchema")]
64 GetResponseSchema(get::response_schema::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 = "Profiles")]
72 Profiles(profiles::ResponseItem),
73 #[schemars(title = "Publish")]
74 Publish(publish::Response),
75 #[schemars(title = "PublishRequestSchema")]
76 PublishRequestSchema(publish::request_schema::Response),
77 #[schemars(title = "PublishResponseSchema")]
78 PublishResponseSchema(publish::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::Execute(v) => v.into_mcp(),
86 ResponseItem::Get(v) => v.into_mcp(),
87 ResponseItem::GetRequestSchema(v) => v.into_mcp(),
88 ResponseItem::GetResponseSchema(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::Profiles(v) => v.into_mcp(),
93 ResponseItem::Publish(v) => v.into_mcp(),
94 ResponseItem::PublishRequestSchema(v) => v.into_mcp(),
95 ResponseItem::PublishResponseSchema(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::Execute { command } =>
105 Ok(Request::Execute(execute::Request::try_from(command)?)),
106 Command::Get(cmd) => match cmd.schema {
107 None => Ok(Request::Get(get::Request::try_from(cmd.args)?)),
108 Some(get::Schema::RequestSchema(args)) =>
109 Ok(Request::GetRequestSchema(get::request_schema::Request::try_from(args)?)),
110 Some(get::Schema::ResponseSchema(args)) =>
111 Ok(Request::GetResponseSchema(get::response_schema::Request::try_from(args)?)),
112 },
113 Command::List(cmd) => match cmd.schema {
114 None => Ok(Request::List(list::Request::try_from(cmd.args)?)),
115 Some(list::Schema::RequestSchema(args)) =>
116 Ok(Request::ListRequestSchema(list::request_schema::Request::try_from(args)?)),
117 Some(list::Schema::ResponseSchema(args)) =>
118 Ok(Request::ListResponseSchema(list::response_schema::Request::try_from(args)?)),
119 },
120 Command::Profiles { command } =>
121 Ok(Request::Profiles(profiles::Request::try_from(command)?)),
122 Command::Publish(cmd) => match cmd.schema {
123 None => Ok(Request::Publish(publish::Request::try_from(cmd.args)?)),
124 Some(publish::Schema::RequestSchema(args)) =>
125 Ok(Request::PublishRequestSchema(publish::request_schema::Request::try_from(args)?)),
126 Some(publish::Schema::ResponseSchema(args)) =>
127 Ok(Request::PublishResponseSchema(publish::response_schema::Request::try_from(args)?)),
128 },
129 }
130 }
131}
132
133impl crate::cli::command::CommandRequest for Request {
134 fn into_command(&self) -> Vec<String> {
135 match self {
136 Request::Execute(inner) => inner.into_command(),
137 Request::Get(inner) => inner.into_command(),
138 Request::GetRequestSchema(inner) => inner.into_command(),
139 Request::GetResponseSchema(inner) => inner.into_command(),
140 Request::List(inner) => inner.into_command(),
141 Request::ListRequestSchema(inner) => inner.into_command(),
142 Request::ListResponseSchema(inner) => inner.into_command(),
143 Request::Profiles(inner) => inner.into_command(),
144 Request::Publish(inner) => inner.into_command(),
145 Request::PublishRequestSchema(inner) => inner.into_command(),
146 Request::PublishResponseSchema(inner) => inner.into_command(),
147 }
148 }
149
150 fn request_base(&self) -> &crate::cli::command::RequestBase {
151 match self {
152 Request::Execute(inner) => inner.request_base(),
153 Request::Get(inner) => inner.request_base(),
154 Request::GetRequestSchema(inner) => inner.request_base(),
155 Request::GetResponseSchema(inner) => inner.request_base(),
156 Request::List(inner) => inner.request_base(),
157 Request::ListRequestSchema(inner) => inner.request_base(),
158 Request::ListResponseSchema(inner) => inner.request_base(),
159 Request::Profiles(inner) => inner.request_base(),
160 Request::Publish(inner) => inner.request_base(),
161 Request::PublishRequestSchema(inner) => inner.request_base(),
162 Request::PublishResponseSchema(inner) => inner.request_base(),
163 }
164 }
165
166 fn request_base_mut(&mut self) -> Option<&mut crate::cli::command::RequestBase> {
167 match self {
168 Request::Execute(inner) => inner.request_base_mut(),
169 Request::Get(inner) => inner.request_base_mut(),
170 Request::GetRequestSchema(inner) => inner.request_base_mut(),
171 Request::GetResponseSchema(inner) => inner.request_base_mut(),
172 Request::List(inner) => inner.request_base_mut(),
173 Request::ListRequestSchema(inner) => inner.request_base_mut(),
174 Request::ListResponseSchema(inner) => inner.request_base_mut(),
175 Request::Profiles(inner) => inner.request_base_mut(),
176 Request::Publish(inner) => inner.request_base_mut(),
177 Request::PublishRequestSchema(inner) => inner.request_base_mut(),
178 Request::PublishResponseSchema(inner) => inner.request_base_mut(),
179 }
180 }
181}
182
183#[cfg(feature = "cli-executor")]
184pub async fn execute<E: crate::cli::command::CommandExecutor>(
185 executor: &E,
186 request: Request,
187
188 agent_arguments: Option<&crate::cli::command::AgentArguments>,
189 ) -> Result<
190 std::pin::Pin<Box<dyn futures::Stream<Item = Result<ResponseItem, E::Error>> + Send>>,
191 E::Error,
192> {
193 use futures::StreamExt;
194 let stream: std::pin::Pin<Box<dyn futures::Stream<Item = Result<ResponseItem, E::Error>> + Send>> =
195 match request {
196 Request::Execute(req) => {
197 let inner = execute::execute(executor, req, agent_arguments).await?;
198 Box::pin(inner.map(|r| r.map(ResponseItem::Execute)))
199 }
200 Request::Get(req) => {
201 let value = get::execute(executor, req, agent_arguments).await?;
202 Box::pin(crate::cli::command::StreamOnce::new(Ok(
203 ResponseItem::Get(value),
204 )))
205 }
206 Request::GetRequestSchema(req) => {
207 let value = get::request_schema::execute(executor, req, agent_arguments).await?;
208 Box::pin(crate::cli::command::StreamOnce::new(Ok(
209 ResponseItem::GetRequestSchema(value),
210 )))
211 }
212 Request::GetResponseSchema(req) => {
213 let value = get::response_schema::execute(executor, req, agent_arguments).await?;
214 Box::pin(crate::cli::command::StreamOnce::new(Ok(
215 ResponseItem::GetResponseSchema(value),
216 )))
217 }
218 Request::List(req) => {
219 let inner = list::execute(executor, req, agent_arguments).await?;
220 Box::pin(inner.map(|r| r.map(ResponseItem::List)))
221 }
222 Request::ListRequestSchema(req) => {
223 let value = list::request_schema::execute(executor, req, agent_arguments).await?;
224 Box::pin(crate::cli::command::StreamOnce::new(Ok(
225 ResponseItem::ListRequestSchema(value),
226 )))
227 }
228 Request::ListResponseSchema(req) => {
229 let value = list::response_schema::execute(executor, req, agent_arguments).await?;
230 Box::pin(crate::cli::command::StreamOnce::new(Ok(
231 ResponseItem::ListResponseSchema(value),
232 )))
233 }
234 Request::Profiles(req) => {
235 let inner = profiles::execute(executor, req, agent_arguments).await?;
236 Box::pin(inner.map(|r| r.map(ResponseItem::Profiles)))
237 }
238 Request::Publish(req) => {
239 let value = publish::execute(executor, req, agent_arguments).await?;
240 Box::pin(crate::cli::command::StreamOnce::new(Ok(
241 ResponseItem::Publish(value),
242 )))
243 }
244 Request::PublishRequestSchema(req) => {
245 let value = publish::request_schema::execute(executor, req, agent_arguments).await?;
246 Box::pin(crate::cli::command::StreamOnce::new(Ok(
247 ResponseItem::PublishRequestSchema(value),
248 )))
249 }
250 Request::PublishResponseSchema(req) => {
251 let value = publish::response_schema::execute(executor, req, agent_arguments).await?;
252 Box::pin(crate::cli::command::StreamOnce::new(Ok(
253 ResponseItem::PublishResponseSchema(value),
254 )))
255 }
256 };
257 Ok(stream)
258}
259
260#[cfg(feature = "cli-executor")]
261pub async fn execute_transform<E: crate::cli::command::CommandExecutor>(
262 executor: &E,
263 request: Request,
264 transform: crate::cli::command::Transform,
265
266 agent_arguments: Option<&crate::cli::command::AgentArguments>,
267 ) -> Result<
268 std::pin::Pin<Box<dyn futures::Stream<Item = Result<serde_json::Value, E::Error>> + Send>>,
269 E::Error,
270> {
271 let stream: std::pin::Pin<Box<dyn futures::Stream<Item = Result<serde_json::Value, E::Error>> + Send>> =
272 match request {
273 Request::Execute(req) => {
274 let inner = execute::execute_transform(executor, req, transform, agent_arguments).await?;
275 Box::pin(inner)
276 }
277 Request::Get(req) => {
278 let value = get::execute_transform(executor, req, transform, agent_arguments).await?;
279 Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
280 }
281 Request::GetRequestSchema(req) => {
282 let value = get::request_schema::execute_transform(executor, req, transform, agent_arguments).await?;
283 Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
284 }
285 Request::GetResponseSchema(req) => {
286 let value = get::response_schema::execute_transform(executor, req, transform, agent_arguments).await?;
287 Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
288 }
289 Request::List(req) => {
290 let inner = list::execute_transform(executor, req, transform, agent_arguments).await?;
291 Box::pin(inner)
292 }
293 Request::ListRequestSchema(req) => {
294 let value = list::request_schema::execute_transform(executor, req, transform, agent_arguments).await?;
295 Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
296 }
297 Request::ListResponseSchema(req) => {
298 let value = list::response_schema::execute_transform(executor, req, transform, agent_arguments).await?;
299 Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
300 }
301 Request::Profiles(req) => {
302 let inner = profiles::execute_transform(executor, req, transform, agent_arguments).await?;
303 Box::pin(inner)
304 }
305 Request::Publish(req) => {
306 let value = publish::execute_transform(executor, req, transform, agent_arguments).await?;
307 Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
308 }
309 Request::PublishRequestSchema(req) => {
310 let value = publish::request_schema::execute_transform(executor, req, transform, agent_arguments).await?;
311 Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
312 }
313 Request::PublishResponseSchema(req) => {
314 let value = publish::response_schema::execute_transform(executor, req, transform, agent_arguments).await?;
315 Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
316 }
317 };
318 Ok(stream)
319}