objectiveai_sdk/cli/command/agents/logs/read/
mod.rs

1pub mod all;
2pub mod id;
3pub mod pending;
4pub mod subscribe;
5
6#[derive(clap::Subcommand)]
7pub enum Command {
8    /// Read all items from each agent_instance_hierarchy.
9    All(all::Command),
10    /// Read a single item by its row id.
11    Id(id::Command),
12    /// Read pending items only.
13    Pending(pending::Command),
14    /// Subscribe to live updates for the given agents.
15    Subscribe(subscribe::Command),
16}
17
18#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
19#[serde(untagged)]
20#[schemars(rename = "cli.command.agents.logs.read.Request")]
21pub enum Request {
22    #[schemars(title = "All")]
23    All(all::Request),
24    #[schemars(title = "AllRequestSchema")]
25    AllRequestSchema(all::request_schema::Request),
26    #[schemars(title = "AllResponseSchema")]
27    AllResponseSchema(all::response_schema::Request),
28    #[schemars(title = "Id")]
29    Id(id::Request),
30    #[schemars(title = "IdRequestSchema")]
31    IdRequestSchema(id::request_schema::Request),
32    #[schemars(title = "IdResponseSchema")]
33    IdResponseSchema(id::response_schema::Request),
34    #[schemars(title = "Pending")]
35    Pending(pending::Request),
36    #[schemars(title = "PendingRequestSchema")]
37    PendingRequestSchema(pending::request_schema::Request),
38    #[schemars(title = "PendingResponseSchema")]
39    PendingResponseSchema(pending::response_schema::Request),
40    #[schemars(title = "Subscribe")]
41    Subscribe(subscribe::Request),
42    #[schemars(title = "SubscribeRequestSchema")]
43    SubscribeRequestSchema(subscribe::request_schema::Request),
44    #[schemars(title = "SubscribeResponseSchema")]
45    SubscribeResponseSchema(subscribe::response_schema::Request),
46}
47
48// Exempt from json-schema coverage: tier aggregate (see the root
49// `ResponseItem` in command.rs - TS7056).
50#[objectiveai_sdk_macros::json_schema_ignore]
51#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
52#[schemars(rename = "cli.command.agents.logs.read.ResponseItem")]
53#[serde(untagged)]
54pub enum ResponseItem {
55    #[schemars(title = "All")]
56    All(all::ResponseItem),
57    #[schemars(title = "AllRequestSchema")]
58    AllRequestSchema(all::request_schema::Response),
59    #[schemars(title = "AllResponseSchema")]
60    AllResponseSchema(all::response_schema::Response),
61    #[schemars(title = "Id")]
62    Id(id::Response),
63    #[schemars(title = "IdRequestSchema")]
64    IdRequestSchema(id::request_schema::Response),
65    #[schemars(title = "IdResponseSchema")]
66    IdResponseSchema(id::response_schema::Response),
67    #[schemars(title = "Pending")]
68    Pending(pending::ResponseItem),
69    #[schemars(title = "PendingRequestSchema")]
70    PendingRequestSchema(pending::request_schema::Response),
71    #[schemars(title = "PendingResponseSchema")]
72    PendingResponseSchema(pending::response_schema::Response),
73    #[schemars(title = "Subscribe")]
74    Subscribe(subscribe::ResponseItem),
75    #[schemars(title = "SubscribeRequestSchema")]
76    SubscribeRequestSchema(subscribe::request_schema::Response),
77    #[schemars(title = "SubscribeResponseSchema")]
78    SubscribeResponseSchema(subscribe::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::All(v) => v.into_mcp(),
86            ResponseItem::AllRequestSchema(v) => v.into_mcp(),
87            ResponseItem::AllResponseSchema(v) => v.into_mcp(),
88            ResponseItem::Id(v) => v.into_mcp(),
89            ResponseItem::IdRequestSchema(v) => v.into_mcp(),
90            ResponseItem::IdResponseSchema(v) => v.into_mcp(),
91            ResponseItem::Pending(v) => v.into_mcp(),
92            ResponseItem::PendingRequestSchema(v) => v.into_mcp(),
93            ResponseItem::PendingResponseSchema(v) => v.into_mcp(),
94            ResponseItem::Subscribe(v) => v.into_mcp(),
95            ResponseItem::SubscribeRequestSchema(v) => v.into_mcp(),
96            ResponseItem::SubscribeResponseSchema(v) => v.into_mcp(),
97        }
98    }
99}
100
101impl TryFrom<Command> for Request {
102    type Error = crate::cli::command::FromArgsError;
103    fn try_from(command: Command) -> Result<Self, Self::Error> {
104        match command {
105            Command::All(cmd) => match cmd.schema {
106                None => Ok(Request::All(all::Request::try_from(cmd.args)?)),
107                Some(all::Schema::RequestSchema(args)) =>
108                    Ok(Request::AllRequestSchema(all::request_schema::Request::try_from(args)?)),
109                Some(all::Schema::ResponseSchema(args)) =>
110                    Ok(Request::AllResponseSchema(all::response_schema::Request::try_from(args)?)),
111            },
112            Command::Id(cmd) => match cmd.schema {
113                None => Ok(Request::Id(id::Request::try_from(cmd.args)?)),
114                Some(id::Schema::RequestSchema(args)) =>
115                    Ok(Request::IdRequestSchema(id::request_schema::Request::try_from(args)?)),
116                Some(id::Schema::ResponseSchema(args)) =>
117                    Ok(Request::IdResponseSchema(id::response_schema::Request::try_from(args)?)),
118            },
119            Command::Pending(cmd) => match cmd.schema {
120                None => Ok(Request::Pending(pending::Request::try_from(cmd.args)?)),
121                Some(pending::Schema::RequestSchema(args)) =>
122                    Ok(Request::PendingRequestSchema(pending::request_schema::Request::try_from(args)?)),
123                Some(pending::Schema::ResponseSchema(args)) =>
124                    Ok(Request::PendingResponseSchema(pending::response_schema::Request::try_from(args)?)),
125            },
126            Command::Subscribe(cmd) => match cmd.schema {
127                None => Ok(Request::Subscribe(subscribe::Request::try_from(cmd.args)?)),
128                Some(subscribe::Schema::RequestSchema(args)) =>
129                    Ok(Request::SubscribeRequestSchema(subscribe::request_schema::Request::try_from(args)?)),
130                Some(subscribe::Schema::ResponseSchema(args)) =>
131                    Ok(Request::SubscribeResponseSchema(subscribe::response_schema::Request::try_from(args)?)),
132            },
133        }
134    }
135}
136
137impl crate::cli::command::CommandRequest for Request {
138    fn into_command(&self) -> Vec<String> {
139        match self {
140            Request::All(inner) => inner.into_command(),
141            Request::AllRequestSchema(inner) => inner.into_command(),
142            Request::AllResponseSchema(inner) => inner.into_command(),
143            Request::Id(inner) => inner.into_command(),
144            Request::IdRequestSchema(inner) => inner.into_command(),
145            Request::IdResponseSchema(inner) => inner.into_command(),
146            Request::Pending(inner) => inner.into_command(),
147            Request::PendingRequestSchema(inner) => inner.into_command(),
148            Request::PendingResponseSchema(inner) => inner.into_command(),
149            Request::Subscribe(inner) => inner.into_command(),
150            Request::SubscribeRequestSchema(inner) => inner.into_command(),
151            Request::SubscribeResponseSchema(inner) => inner.into_command(),
152        }
153    }
154
155    fn request_base(&self) -> &crate::cli::command::RequestBase {
156        match self {
157            Request::All(inner) => inner.request_base(),
158            Request::AllRequestSchema(inner) => inner.request_base(),
159            Request::AllResponseSchema(inner) => inner.request_base(),
160            Request::Id(inner) => inner.request_base(),
161            Request::IdRequestSchema(inner) => inner.request_base(),
162            Request::IdResponseSchema(inner) => inner.request_base(),
163            Request::Pending(inner) => inner.request_base(),
164            Request::PendingRequestSchema(inner) => inner.request_base(),
165            Request::PendingResponseSchema(inner) => inner.request_base(),
166            Request::Subscribe(inner) => inner.request_base(),
167            Request::SubscribeRequestSchema(inner) => inner.request_base(),
168            Request::SubscribeResponseSchema(inner) => inner.request_base(),
169        }
170    }
171
172    fn request_base_mut(&mut self) -> Option<&mut crate::cli::command::RequestBase> {
173        match self {
174            Request::All(inner) => inner.request_base_mut(),
175            Request::AllRequestSchema(inner) => inner.request_base_mut(),
176            Request::AllResponseSchema(inner) => inner.request_base_mut(),
177            Request::Id(inner) => inner.request_base_mut(),
178            Request::IdRequestSchema(inner) => inner.request_base_mut(),
179            Request::IdResponseSchema(inner) => inner.request_base_mut(),
180            Request::Pending(inner) => inner.request_base_mut(),
181            Request::PendingRequestSchema(inner) => inner.request_base_mut(),
182            Request::PendingResponseSchema(inner) => inner.request_base_mut(),
183            Request::Subscribe(inner) => inner.request_base_mut(),
184            Request::SubscribeRequestSchema(inner) => inner.request_base_mut(),
185            Request::SubscribeResponseSchema(inner) => inner.request_base_mut(),
186        }
187    }
188}
189
190#[cfg(feature = "cli-executor")]
191pub async fn execute<E: crate::cli::command::CommandExecutor>(
192    executor: &E,
193    request: Request,
194
195        agent_arguments: Option<&crate::cli::command::AgentArguments>,
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<Box<dyn futures::Stream<Item = Result<ResponseItem, E::Error>> + Send>> =
202        match request {
203            Request::All(req) => {
204                let inner = all::execute(executor, req, agent_arguments).await?;
205                Box::pin(inner.map(|r| r.map(ResponseItem::All)))
206            }
207            Request::AllRequestSchema(req) => {
208                let value = all::request_schema::execute(executor, req, agent_arguments).await?;
209                Box::pin(crate::cli::command::StreamOnce::new(Ok(
210                    ResponseItem::AllRequestSchema(value),
211                )))
212            }
213            Request::AllResponseSchema(req) => {
214                let value = all::response_schema::execute(executor, req, agent_arguments).await?;
215                Box::pin(crate::cli::command::StreamOnce::new(Ok(
216                    ResponseItem::AllResponseSchema(value),
217                )))
218            }
219            Request::Id(req) => {
220                let value = id::execute(executor, req, agent_arguments).await?;
221                Box::pin(crate::cli::command::StreamOnce::new(Ok(
222                    ResponseItem::Id(value),
223                )))
224            }
225            Request::IdRequestSchema(req) => {
226                let value = id::request_schema::execute(executor, req, agent_arguments).await?;
227                Box::pin(crate::cli::command::StreamOnce::new(Ok(
228                    ResponseItem::IdRequestSchema(value),
229                )))
230            }
231            Request::IdResponseSchema(req) => {
232                let value = id::response_schema::execute(executor, req, agent_arguments).await?;
233                Box::pin(crate::cli::command::StreamOnce::new(Ok(
234                    ResponseItem::IdResponseSchema(value),
235                )))
236            }
237            Request::Pending(req) => {
238                let inner = pending::execute(executor, req, agent_arguments).await?;
239                Box::pin(inner.map(|r| r.map(ResponseItem::Pending)))
240            }
241            Request::PendingRequestSchema(req) => {
242                let value = pending::request_schema::execute(executor, req, agent_arguments).await?;
243                Box::pin(crate::cli::command::StreamOnce::new(Ok(
244                    ResponseItem::PendingRequestSchema(value),
245                )))
246            }
247            Request::PendingResponseSchema(req) => {
248                let value = pending::response_schema::execute(executor, req, agent_arguments).await?;
249                Box::pin(crate::cli::command::StreamOnce::new(Ok(
250                    ResponseItem::PendingResponseSchema(value),
251                )))
252            }
253            Request::Subscribe(req) => {
254                let inner = subscribe::execute(executor, req, agent_arguments).await?;
255                Box::pin(inner.map(|r| r.map(ResponseItem::Subscribe)))
256            }
257            Request::SubscribeRequestSchema(req) => {
258                let value = subscribe::request_schema::execute(executor, req, agent_arguments).await?;
259                Box::pin(crate::cli::command::StreamOnce::new(Ok(
260                    ResponseItem::SubscribeRequestSchema(value),
261                )))
262            }
263            Request::SubscribeResponseSchema(req) => {
264                let value = subscribe::response_schema::execute(executor, req, agent_arguments).await?;
265                Box::pin(crate::cli::command::StreamOnce::new(Ok(
266                    ResponseItem::SubscribeResponseSchema(value),
267                )))
268            }
269        };
270    Ok(stream)
271}
272
273#[cfg(feature = "cli-executor")]
274pub async fn execute_transform<E: crate::cli::command::CommandExecutor>(
275    executor: &E,
276    request: Request,
277    transform: crate::cli::command::Transform,
278
279        agent_arguments: Option<&crate::cli::command::AgentArguments>,
280    ) -> Result<
281    std::pin::Pin<Box<dyn futures::Stream<Item = Result<serde_json::Value, E::Error>> + Send>>,
282    E::Error,
283> {
284    let stream: std::pin::Pin<Box<dyn futures::Stream<Item = Result<serde_json::Value, E::Error>> + Send>> =
285        match request {
286            Request::All(req) => {
287                let inner = all::execute_transform(executor, req, transform, agent_arguments).await?;
288                Box::pin(inner)
289            }
290            Request::AllRequestSchema(req) => {
291                let value = all::request_schema::execute_transform(executor, req, transform, agent_arguments).await?;
292                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
293            }
294            Request::AllResponseSchema(req) => {
295                let value = all::response_schema::execute_transform(executor, req, transform, agent_arguments).await?;
296                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
297            }
298            Request::Id(req) => {
299                let value = id::execute_transform(executor, req, transform, agent_arguments).await?;
300                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
301            }
302            Request::IdRequestSchema(req) => {
303                let value = id::request_schema::execute_transform(executor, req, transform, agent_arguments).await?;
304                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
305            }
306            Request::IdResponseSchema(req) => {
307                let value = id::response_schema::execute_transform(executor, req, transform, agent_arguments).await?;
308                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
309            }
310            Request::Pending(req) => {
311                let inner = pending::execute_transform(executor, req, transform, agent_arguments).await?;
312                Box::pin(inner)
313            }
314            Request::PendingRequestSchema(req) => {
315                let value = pending::request_schema::execute_transform(executor, req, transform, agent_arguments).await?;
316                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
317            }
318            Request::PendingResponseSchema(req) => {
319                let value = pending::response_schema::execute_transform(executor, req, transform, agent_arguments).await?;
320                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
321            }
322            Request::Subscribe(req) => {
323                let inner = subscribe::execute_transform(executor, req, transform, agent_arguments).await?;
324                Box::pin(inner)
325            }
326            Request::SubscribeRequestSchema(req) => {
327                let value = subscribe::request_schema::execute_transform(executor, req, transform, agent_arguments).await?;
328                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
329            }
330            Request::SubscribeResponseSchema(req) => {
331                let value = subscribe::response_schema::execute_transform(executor, req, transform, agent_arguments).await?;
332                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
333            }
334        };
335    Ok(stream)
336}
objectiveai_sdk/cli/command/agents/logs/read/mod.rs

objectiveai_sdk/cli/command/agents/logs/read/
mod.rs
