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