objectiveai_sdk/cli/command/daemon/config/
mod.rs

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

objectiveai_sdk/cli/command/daemon/config/
mod.rs
