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