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
156#[cfg(feature = "cli-executor")]
157pub async fn execute<E: crate::cli::command::CommandExecutor>(
158    executor: &E,
159    request: Request,
160
161        agent_arguments: Option<&crate::cli::command::AgentArguments>,
162    ) -> Result<
163    std::pin::Pin<Box<dyn futures::Stream<Item = Result<ResponseItem, E::Error>> + Send>>,
164    E::Error,
165> {
166    use futures::StreamExt;
167    let stream: std::pin::Pin<Box<dyn futures::Stream<Item = Result<ResponseItem, E::Error>> + Send>> =
168        match request {
169            Request::All(req) => {
170                let inner = all::execute(executor, req, agent_arguments).await?;
171                Box::pin(inner.map(|r| r.map(ResponseItem::All)))
172            }
173            Request::AllRequestSchema(req) => {
174                let value = all::request_schema::execute(executor, req, agent_arguments).await?;
175                Box::pin(crate::cli::command::StreamOnce::new(Ok(
176                    ResponseItem::AllRequestSchema(value),
177                )))
178            }
179            Request::AllResponseSchema(req) => {
180                let value = all::response_schema::execute(executor, req, agent_arguments).await?;
181                Box::pin(crate::cli::command::StreamOnce::new(Ok(
182                    ResponseItem::AllResponseSchema(value),
183                )))
184            }
185            Request::Id(req) => {
186                let value = id::execute(executor, req, agent_arguments).await?;
187                Box::pin(crate::cli::command::StreamOnce::new(Ok(
188                    ResponseItem::Id(value),
189                )))
190            }
191            Request::IdRequestSchema(req) => {
192                let value = id::request_schema::execute(executor, req, agent_arguments).await?;
193                Box::pin(crate::cli::command::StreamOnce::new(Ok(
194                    ResponseItem::IdRequestSchema(value),
195                )))
196            }
197            Request::IdResponseSchema(req) => {
198                let value = id::response_schema::execute(executor, req, agent_arguments).await?;
199                Box::pin(crate::cli::command::StreamOnce::new(Ok(
200                    ResponseItem::IdResponseSchema(value),
201                )))
202            }
203            Request::Pending(req) => {
204                let inner = pending::execute(executor, req, agent_arguments).await?;
205                Box::pin(inner.map(|r| r.map(ResponseItem::Pending)))
206            }
207            Request::PendingRequestSchema(req) => {
208                let value = pending::request_schema::execute(executor, req, agent_arguments).await?;
209                Box::pin(crate::cli::command::StreamOnce::new(Ok(
210                    ResponseItem::PendingRequestSchema(value),
211                )))
212            }
213            Request::PendingResponseSchema(req) => {
214                let value = pending::response_schema::execute(executor, req, agent_arguments).await?;
215                Box::pin(crate::cli::command::StreamOnce::new(Ok(
216                    ResponseItem::PendingResponseSchema(value),
217                )))
218            }
219            Request::Subscribe(req) => {
220                let inner = subscribe::execute(executor, req, agent_arguments).await?;
221                Box::pin(inner.map(|r| r.map(ResponseItem::Subscribe)))
222            }
223            Request::SubscribeRequestSchema(req) => {
224                let value = subscribe::request_schema::execute(executor, req, agent_arguments).await?;
225                Box::pin(crate::cli::command::StreamOnce::new(Ok(
226                    ResponseItem::SubscribeRequestSchema(value),
227                )))
228            }
229            Request::SubscribeResponseSchema(req) => {
230                let value = subscribe::response_schema::execute(executor, req, agent_arguments).await?;
231                Box::pin(crate::cli::command::StreamOnce::new(Ok(
232                    ResponseItem::SubscribeResponseSchema(value),
233                )))
234            }
235        };
236    Ok(stream)
237}
238
239#[cfg(feature = "cli-executor")]
240pub async fn execute_jq<E: crate::cli::command::CommandExecutor>(
241    executor: &E,
242    request: Request,
243    jq: String,
244
245        agent_arguments: Option<&crate::cli::command::AgentArguments>,
246    ) -> Result<
247    std::pin::Pin<Box<dyn futures::Stream<Item = Result<serde_json::Value, E::Error>> + Send>>,
248    E::Error,
249> {
250    let stream: std::pin::Pin<Box<dyn futures::Stream<Item = Result<serde_json::Value, E::Error>> + Send>> =
251        match request {
252            Request::All(req) => {
253                let inner = all::execute_jq(executor, req, jq, agent_arguments).await?;
254                Box::pin(inner)
255            }
256            Request::AllRequestSchema(req) => {
257                let value = all::request_schema::execute_jq(executor, req, jq, agent_arguments).await?;
258                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
259            }
260            Request::AllResponseSchema(req) => {
261                let value = all::response_schema::execute_jq(executor, req, jq, agent_arguments).await?;
262                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
263            }
264            Request::Id(req) => {
265                let value = id::execute_jq(executor, req, jq, agent_arguments).await?;
266                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
267            }
268            Request::IdRequestSchema(req) => {
269                let value = id::request_schema::execute_jq(executor, req, jq, agent_arguments).await?;
270                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
271            }
272            Request::IdResponseSchema(req) => {
273                let value = id::response_schema::execute_jq(executor, req, jq, agent_arguments).await?;
274                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
275            }
276            Request::Pending(req) => {
277                let inner = pending::execute_jq(executor, req, jq, agent_arguments).await?;
278                Box::pin(inner)
279            }
280            Request::PendingRequestSchema(req) => {
281                let value = pending::request_schema::execute_jq(executor, req, jq, agent_arguments).await?;
282                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
283            }
284            Request::PendingResponseSchema(req) => {
285                let value = pending::response_schema::execute_jq(executor, req, jq, agent_arguments).await?;
286                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
287            }
288            Request::Subscribe(req) => {
289                let inner = subscribe::execute_jq(executor, req, jq, agent_arguments).await?;
290                Box::pin(inner)
291            }
292            Request::SubscribeRequestSchema(req) => {
293                let value = subscribe::request_schema::execute_jq(executor, req, jq, agent_arguments).await?;
294                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
295            }
296            Request::SubscribeResponseSchema(req) => {
297                let value = subscribe::response_schema::execute_jq(executor, req, jq, agent_arguments).await?;
298                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
299            }
300        };
301    Ok(stream)
302}
objectiveai_sdk/cli/command/agents/logs/read/mod.rs

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