Skip to main content

objectiveai_sdk/cli/command/tasks/
mod.rs

1//! `tasks` — durable scheduled commands. A task is an ObjectiveAI
2//! command plus a schedule; the daemon's resident scheduler fires it
3//! with the identity it was CREATED with (agent arguments + plugin
4//! trio) and marks the run with the daemon-authored `task` identity
5//! flag. Leaves:
6//!
7//! - `create` — schedule a command (`--delay-secs`, optional
8//!   `--repeat` / `--repeat-count`).
9//! - `list` — every task with its run/error counters and last result.
10//! - `delete` — remove a task by id.
11
12use crate::cli::command::CommandRequest;
13
14pub mod create;
15pub mod delete;
16pub mod list;
17
18#[derive(clap::Subcommand)]
19pub enum Command {
20    /// Schedule an ObjectiveAI command.
21    Create(create::Command),
22    /// List every task with its run counters and last result.
23    List(list::Command),
24    /// Remove a task by id.
25    Delete(delete::Command),
26}
27
28// No `PartialEq`: `create::Request` embeds the root request enum,
29// which doesn't derive it.
30#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
31#[serde(untagged)]
32#[schemars(rename = "cli.command.tasks.Request")]
33pub enum Request {
34    #[schemars(title = "Create")]
35    Create(create::Request),
36    #[schemars(title = "CreateRequestSchema")]
37    CreateRequestSchema(create::request_schema::Request),
38    #[schemars(title = "CreateResponseSchema")]
39    CreateResponseSchema(create::response_schema::Request),
40    #[schemars(title = "List")]
41    List(list::Request),
42    #[schemars(title = "ListRequestSchema")]
43    ListRequestSchema(list::request_schema::Request),
44    #[schemars(title = "ListResponseSchema")]
45    ListResponseSchema(list::response_schema::Request),
46    #[schemars(title = "Delete")]
47    Delete(delete::Request),
48    #[schemars(title = "DeleteRequestSchema")]
49    DeleteRequestSchema(delete::request_schema::Request),
50    #[schemars(title = "DeleteResponseSchema")]
51    DeleteResponseSchema(delete::response_schema::Request),
52}
53
54// Exempt from json-schema coverage: tier aggregate (see the root
55// `ResponseItem` in command.rs - TS7056).
56#[objectiveai_sdk_macros::json_schema_ignore]
57#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
58#[schemars(rename = "cli.command.tasks.ResponseItem")]
59#[serde(untagged)]
60pub enum ResponseItem {
61    #[schemars(title = "Create")]
62    Create(create::Response),
63    #[schemars(title = "CreateRequestSchema")]
64    CreateRequestSchema(create::request_schema::Response),
65    #[schemars(title = "CreateResponseSchema")]
66    CreateResponseSchema(create::response_schema::Response),
67    #[schemars(title = "List")]
68    List(list::ResponseItem),
69    #[schemars(title = "ListRequestSchema")]
70    ListRequestSchema(list::request_schema::Response),
71    #[schemars(title = "ListResponseSchema")]
72    ListResponseSchema(list::response_schema::Response),
73    #[schemars(title = "Delete")]
74    Delete(delete::Response),
75    #[schemars(title = "DeleteRequestSchema")]
76    DeleteRequestSchema(delete::request_schema::Response),
77    #[schemars(title = "DeleteResponseSchema")]
78    DeleteResponseSchema(delete::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::Create(v) => v.into_mcp(),
86            ResponseItem::CreateRequestSchema(v) => v.into_mcp(),
87            ResponseItem::CreateResponseSchema(v) => v.into_mcp(),
88            ResponseItem::List(v) => v.into_mcp(),
89            ResponseItem::ListRequestSchema(v) => v.into_mcp(),
90            ResponseItem::ListResponseSchema(v) => v.into_mcp(),
91            ResponseItem::Delete(v) => v.into_mcp(),
92            ResponseItem::DeleteRequestSchema(v) => v.into_mcp(),
93            ResponseItem::DeleteResponseSchema(v) => v.into_mcp(),
94        }
95    }
96}
97
98impl TryFrom<Command> for Request {
99    type Error = crate::cli::command::FromArgsError;
100    fn try_from(command: Command) -> Result<Self, Self::Error> {
101        match command {
102            Command::Create(cmd) => match cmd.schema {
103                None => Ok(Request::Create(create::Request::try_from(cmd.args)?)),
104                Some(create::Schema::RequestSchema(args)) => Ok(
105                    Request::CreateRequestSchema(create::request_schema::Request::try_from(args)?),
106                ),
107                Some(create::Schema::ResponseSchema(args)) => Ok(
108                    Request::CreateResponseSchema(create::response_schema::Request::try_from(args)?),
109                ),
110            },
111            Command::List(cmd) => match cmd.schema {
112                None => Ok(Request::List(list::Request::try_from(cmd.args)?)),
113                Some(list::Schema::RequestSchema(args)) => Ok(
114                    Request::ListRequestSchema(list::request_schema::Request::try_from(args)?),
115                ),
116                Some(list::Schema::ResponseSchema(args)) => Ok(
117                    Request::ListResponseSchema(list::response_schema::Request::try_from(args)?),
118                ),
119            },
120            Command::Delete(cmd) => match cmd.schema {
121                None => Ok(Request::Delete(delete::Request::try_from(cmd.args)?)),
122                Some(delete::Schema::RequestSchema(args)) => Ok(
123                    Request::DeleteRequestSchema(delete::request_schema::Request::try_from(args)?),
124                ),
125                Some(delete::Schema::ResponseSchema(args)) => Ok(
126                    Request::DeleteResponseSchema(delete::response_schema::Request::try_from(args)?),
127                ),
128            },
129        }
130    }
131}
132
133impl CommandRequest for Request {
134    fn request_base(&self) -> &crate::cli::command::RequestBase {
135        match self {
136            Request::Create(inner) => inner.request_base(),
137            Request::CreateRequestSchema(inner) => inner.request_base(),
138            Request::CreateResponseSchema(inner) => inner.request_base(),
139            Request::List(inner) => inner.request_base(),
140            Request::ListRequestSchema(inner) => inner.request_base(),
141            Request::ListResponseSchema(inner) => inner.request_base(),
142            Request::Delete(inner) => inner.request_base(),
143            Request::DeleteRequestSchema(inner) => inner.request_base(),
144            Request::DeleteResponseSchema(inner) => inner.request_base(),
145        }
146    }
147
148    fn request_base_mut(&mut self) -> Option<&mut crate::cli::command::RequestBase> {
149        match self {
150            Request::Create(inner) => inner.request_base_mut(),
151            Request::CreateRequestSchema(inner) => inner.request_base_mut(),
152            Request::CreateResponseSchema(inner) => inner.request_base_mut(),
153            Request::List(inner) => inner.request_base_mut(),
154            Request::ListRequestSchema(inner) => inner.request_base_mut(),
155            Request::ListResponseSchema(inner) => inner.request_base_mut(),
156            Request::Delete(inner) => inner.request_base_mut(),
157            Request::DeleteRequestSchema(inner) => inner.request_base_mut(),
158            Request::DeleteResponseSchema(inner) => inner.request_base_mut(),
159        }
160    }
161}
162
163#[cfg(feature = "cli-executor")]
164pub async fn execute<E: crate::cli::command::CommandExecutor>(
165    executor: &E,
166    request: Request,
167    identity: Option<&crate::identity::Identity>,
168) -> Result<
169    std::pin::Pin<Box<dyn futures::Stream<Item = Result<ResponseItem, E::Error>> + Send>>,
170    E::Error,
171> {
172    use futures::StreamExt;
173    let stream: std::pin::Pin<
174        Box<dyn futures::Stream<Item = Result<ResponseItem, E::Error>> + Send>,
175    > = match request {
176        Request::Create(req) => {
177            let value = create::execute(executor, req, identity).await?;
178            Box::pin(crate::cli::command::StreamOnce::new(Ok(ResponseItem::Create(value))))
179        }
180        Request::CreateRequestSchema(req) => {
181            let value = create::request_schema::execute(executor, req, identity).await?;
182            Box::pin(crate::cli::command::StreamOnce::new(Ok(ResponseItem::CreateRequestSchema(value))))
183        }
184        Request::CreateResponseSchema(req) => {
185            let value = create::response_schema::execute(executor, req, identity).await?;
186            Box::pin(crate::cli::command::StreamOnce::new(Ok(ResponseItem::CreateResponseSchema(value))))
187        }
188        Request::List(req) => {
189            let inner = list::execute(executor, req, identity).await?;
190            Box::pin(inner.map(|r| r.map(ResponseItem::List)))
191        }
192        Request::ListRequestSchema(req) => {
193            let value = list::request_schema::execute(executor, req, identity).await?;
194            Box::pin(crate::cli::command::StreamOnce::new(Ok(ResponseItem::ListRequestSchema(value))))
195        }
196        Request::ListResponseSchema(req) => {
197            let value = list::response_schema::execute(executor, req, identity).await?;
198            Box::pin(crate::cli::command::StreamOnce::new(Ok(ResponseItem::ListResponseSchema(value))))
199        }
200        Request::Delete(req) => {
201            let value = delete::execute(executor, req, identity).await?;
202            Box::pin(crate::cli::command::StreamOnce::new(Ok(ResponseItem::Delete(value))))
203        }
204        Request::DeleteRequestSchema(req) => {
205            let value = delete::request_schema::execute(executor, req, identity).await?;
206            Box::pin(crate::cli::command::StreamOnce::new(Ok(ResponseItem::DeleteRequestSchema(value))))
207        }
208        Request::DeleteResponseSchema(req) => {
209            let value = delete::response_schema::execute(executor, req, identity).await?;
210            Box::pin(crate::cli::command::StreamOnce::new(Ok(ResponseItem::DeleteResponseSchema(value))))
211        }
212    };
213    Ok(stream)
214}
215
216#[cfg(feature = "cli-executor")]
217pub async fn execute_transform<E: crate::cli::command::CommandExecutor>(
218    executor: &E,
219    request: Request,
220    transform: crate::cli::command::Transform,
221    identity: Option<&crate::identity::Identity>,
222) -> Result<
223    std::pin::Pin<Box<dyn futures::Stream<Item = Result<serde_json::Value, E::Error>> + Send>>,
224    E::Error,
225> {
226    let stream: std::pin::Pin<
227        Box<dyn futures::Stream<Item = Result<serde_json::Value, E::Error>> + Send>,
228    > = match request {
229        Request::Create(req) => {
230            let value = create::execute_transform(executor, req, transform, identity).await?;
231            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
232        }
233        Request::CreateRequestSchema(req) => {
234            let value = create::request_schema::execute_transform(executor, req, transform, identity).await?;
235            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
236        }
237        Request::CreateResponseSchema(req) => {
238            let value = create::response_schema::execute_transform(executor, req, transform, identity).await?;
239            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
240        }
241        Request::List(req) => {
242            let inner = list::execute_transform(executor, req, transform, identity).await?;
243            Box::pin(inner)
244        }
245        Request::ListRequestSchema(req) => {
246            let value = list::request_schema::execute_transform(executor, req, transform, identity).await?;
247            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
248        }
249        Request::ListResponseSchema(req) => {
250            let value = list::response_schema::execute_transform(executor, req, transform, identity).await?;
251            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
252        }
253        Request::Delete(req) => {
254            let value = delete::execute_transform(executor, req, transform, identity).await?;
255            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
256        }
257        Request::DeleteRequestSchema(req) => {
258            let value = delete::request_schema::execute_transform(executor, req, transform, identity).await?;
259            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
260        }
261        Request::DeleteResponseSchema(req) => {
262            let value = delete::response_schema::execute_transform(executor, req, transform, identity).await?;
263            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
264        }
265    };
266    Ok(stream)
267}
268
269/// `/listen` mirror of [`Request`]. See [`crate::daemon::command_listener`].
270#[cfg(all(feature = "cli", feature = "daemon"))]
271pub enum ListenerExecution {
272    Create(create::ListenerExecution),
273    CreateRequestSchema(create::request_schema::ListenerExecution),
274    CreateResponseSchema(create::response_schema::ListenerExecution),
275    List(list::ListenerExecution),
276    ListRequestSchema(list::request_schema::ListenerExecution),
277    ListResponseSchema(list::response_schema::ListenerExecution),
278    Delete(delete::ListenerExecution),
279    DeleteRequestSchema(delete::request_schema::ListenerExecution),
280    DeleteResponseSchema(delete::response_schema::ListenerExecution),
281}