objectiveai_sdk/cli/command/tasks/
mod.rs1use crate::cli::command::CommandRequest;
13
14pub mod create;
15pub mod delete;
16pub mod list;
17
18#[derive(clap::Subcommand)]
19pub enum Command {
20 Create(create::Command),
22 List(list::Command),
24 Delete(delete::Command),
26}
27
28#[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#[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#[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}