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