Skip to main content

agent_client_protocol/schema/
v2_impls.rs

1//! JSON-RPC trait implementations for the experimental schema v2 namespace.
2
3use crate::v2::schema as v2;
4use crate::{JsonRpcMessage, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, UntypedMessage};
5
6macro_rules! impl_v2_jsonrpc_request {
7    ($req:ty, $resp:ty, $method:literal) => {
8        impl JsonRpcMessage for $req {
9            fn matches_method(method: &str) -> bool {
10                method == $method
11            }
12
13            fn method(&self) -> &str {
14                $method
15            }
16
17            fn to_untyped_message(&self) -> Result<UntypedMessage, crate::Error> {
18                UntypedMessage::new($method, self)
19            }
20
21            fn parse_message(
22                method: &str,
23                params: &serde_json::Value,
24            ) -> Result<Self, crate::Error> {
25                if method != $method {
26                    return Err(crate::Error::method_not_found());
27                }
28                crate::util::json_cast_params(params)
29            }
30        }
31
32        impl JsonRpcRequest for $req {
33            type Response = $resp;
34        }
35
36        impl JsonRpcResponse for $resp {
37            fn into_json(self, _method: &str) -> Result<serde_json::Value, crate::Error> {
38                serde_json::to_value(self).map_err(crate::Error::into_internal_error)
39            }
40
41            fn from_json(_method: &str, value: serde_json::Value) -> Result<Self, crate::Error> {
42                crate::util::json_cast(value)
43            }
44        }
45    };
46}
47
48macro_rules! impl_v2_jsonrpc_notification {
49    ($notif:ty, $method:literal) => {
50        impl JsonRpcMessage for $notif {
51            fn matches_method(method: &str) -> bool {
52                method == $method
53            }
54
55            fn method(&self) -> &str {
56                $method
57            }
58
59            fn to_untyped_message(&self) -> Result<UntypedMessage, crate::Error> {
60                UntypedMessage::new($method, self)
61            }
62
63            fn parse_message(
64                method: &str,
65                params: &serde_json::Value,
66            ) -> Result<Self, crate::Error> {
67                if method != $method {
68                    return Err(crate::Error::method_not_found());
69                }
70                crate::util::json_cast_params(params)
71            }
72        }
73
74        impl JsonRpcNotification for $notif {}
75    };
76}
77
78macro_rules! impl_v2_jsonrpc_request_enum {
79    ($enum:ty {
80        $( $(#[$meta:meta])* $variant:ident => $method:literal, )*
81        [ext] $ext_variant:ident,
82    }) => {
83        impl JsonRpcMessage for $enum {
84            fn matches_method(_method: &str) -> bool {
85                true
86            }
87
88            fn method(&self) -> &str {
89                // The schema enum's inherent `method()` (path syntax prefers
90                // inherent items) covers every variant, including ones this
91                // macro does not list.
92                <$enum>::method(self)
93            }
94
95            fn to_untyped_message(&self) -> Result<UntypedMessage, crate::Error> {
96                UntypedMessage::new(self.method(), self)
97            }
98
99            fn parse_message(
100                method: &str,
101                params: &serde_json::Value,
102            ) -> Result<Self, crate::Error> {
103                match method {
104                    $( $(#[$meta])* $method => crate::util::json_cast_params(params).map(Self::$variant), )*
105                    _ => {
106                        if method.starts_with('_') {
107                            crate::util::json_cast_params(params).map(
108                                |ext_req: v2::ExtRequest| {
109                                    Self::$ext_variant(Box::new(v2::ExtRequest::new(
110                                        method.to_string(),
111                                        ext_req.params,
112                                    )))
113                                },
114                            )
115                        } else {
116                            Err(crate::Error::method_not_found())
117                        }
118                    }
119                }
120            }
121        }
122
123        impl JsonRpcRequest for $enum {
124            type Response = serde_json::Value;
125        }
126    };
127}
128
129macro_rules! impl_v2_jsonrpc_notification_enum {
130    ($enum:ty {
131        $( $(#[$meta:meta])* $variant:ident => $method:literal, )*
132        [ext] $ext_variant:ident,
133    }) => {
134        impl JsonRpcMessage for $enum {
135            fn matches_method(_method: &str) -> bool {
136                true
137            }
138
139            fn method(&self) -> &str {
140                // The schema enum's inherent `method()` (path syntax prefers
141                // inherent items) covers every variant, including ones this
142                // macro does not list.
143                <$enum>::method(self)
144            }
145
146            fn to_untyped_message(&self) -> Result<UntypedMessage, crate::Error> {
147                UntypedMessage::new(self.method(), self)
148            }
149
150            fn parse_message(
151                method: &str,
152                params: &serde_json::Value,
153            ) -> Result<Self, crate::Error> {
154                match method {
155                    $( $(#[$meta])* $method => crate::util::json_cast_params(params).map(Self::$variant), )*
156                    _ => {
157                        if method.starts_with('_') {
158                            crate::util::json_cast_params(params).map(
159                                |ext_notif: v2::ExtNotification| {
160                                    Self::$ext_variant(Box::new(v2::ExtNotification::new(
161                                        method.to_string(),
162                                        ext_notif.params,
163                                    )))
164                                },
165                            )
166                        } else {
167                            Err(crate::Error::method_not_found())
168                        }
169                    }
170                }
171            }
172        }
173
174        impl JsonRpcNotification for $enum {}
175    };
176}
177
178macro_rules! impl_v2_jsonrpc_response_enum {
179    ($enum:ty {
180        $( $(#[$meta:meta])* $variant:ident => $method:literal, )*
181        [ext] $ext_variant:ident,
182    }) => {
183        impl JsonRpcResponse for $enum {
184            fn into_json(
185                self,
186                _method: &str,
187            ) -> Result<serde_json::Value, crate::Error> {
188                serde_json::to_value(self).map_err(crate::Error::into_internal_error)
189            }
190
191            fn from_json(
192                method: &str,
193                value: serde_json::Value,
194            ) -> Result<Self, crate::Error> {
195                match method {
196                    $( $(#[$meta])* $method => crate::util::json_cast(value).map(Self::$variant), )*
197                    _ => {
198                        if method.starts_with('_') {
199                            crate::util::json_cast(value).map(Self::$ext_variant)
200                        } else {
201                            Err(crate::Error::method_not_found())
202                        }
203                    }
204                }
205            }
206        }
207    };
208}
209
210impl_v2_jsonrpc_request!(v2::InitializeRequest, v2::InitializeResponse, "initialize");
211impl_v2_jsonrpc_request!(v2::LoginAuthRequest, v2::LoginAuthResponse, "auth/login");
212impl_v2_jsonrpc_request!(v2::LogoutAuthRequest, v2::LogoutAuthResponse, "auth/logout");
213#[cfg(feature = "unstable_auth_status")]
214impl_v2_jsonrpc_request!(v2::AuthStatusRequest, v2::AuthStatusResponse, "auth/status");
215#[cfg(feature = "unstable_llm_providers")]
216impl_v2_jsonrpc_request!(
217    v2::ListProvidersRequest,
218    v2::ListProvidersResponse,
219    "providers/list"
220);
221#[cfg(feature = "unstable_llm_providers")]
222impl_v2_jsonrpc_request!(
223    v2::SetProviderRequest,
224    v2::SetProviderResponse,
225    "providers/set"
226);
227#[cfg(feature = "unstable_llm_providers")]
228impl_v2_jsonrpc_request!(
229    v2::DisableProviderRequest,
230    v2::DisableProviderResponse,
231    "providers/disable"
232);
233impl_v2_jsonrpc_request!(v2::NewSessionRequest, v2::NewSessionResponse, "session/new");
234impl_v2_jsonrpc_request!(
235    v2::ListSessionsRequest,
236    v2::ListSessionsResponse,
237    "session/list"
238);
239impl_v2_jsonrpc_request!(
240    v2::DeleteSessionRequest,
241    v2::DeleteSessionResponse,
242    "session/delete"
243);
244#[cfg(feature = "unstable_session_fork")]
245impl_v2_jsonrpc_request!(
246    v2::ForkSessionRequest,
247    v2::ForkSessionResponse,
248    "session/fork"
249);
250#[cfg(feature = "unstable_session_archive")]
251impl_v2_jsonrpc_request!(
252    v2::ArchiveSessionRequest,
253    v2::ArchiveSessionResponse,
254    "session/archive"
255);
256#[cfg(feature = "unstable_session_archive")]
257impl_v2_jsonrpc_request!(
258    v2::UnarchiveSessionRequest,
259    v2::UnarchiveSessionResponse,
260    "session/unarchive"
261);
262#[cfg(feature = "unstable_session_status")]
263impl_v2_jsonrpc_request!(
264    v2::SessionStatusRequest,
265    v2::SessionStatusResponse,
266    "session/status"
267);
268#[cfg(feature = "unstable_session_options")]
269impl_v2_jsonrpc_request!(
270    v2::SessionOptionsRequest,
271    v2::SessionOptionsResponse,
272    "session/options"
273);
274#[cfg(feature = "unstable_session_set_title")]
275impl_v2_jsonrpc_request!(
276    v2::SetSessionTitleRequest,
277    v2::SetSessionTitleResponse,
278    "session/set_title"
279);
280impl_v2_jsonrpc_request!(
281    v2::ResumeSessionRequest,
282    v2::ResumeSessionResponse,
283    "session/resume"
284);
285impl_v2_jsonrpc_request!(
286    v2::CloseSessionRequest,
287    v2::CloseSessionResponse,
288    "session/close"
289);
290impl_v2_jsonrpc_request!(
291    v2::SetSessionConfigOptionRequest,
292    v2::SetSessionConfigOptionResponse,
293    "session/set_config_option"
294);
295impl_v2_jsonrpc_request!(
296    v2::CancelToolCallRequest,
297    v2::CancelToolCallResponse,
298    "tool_call/cancel"
299);
300impl_v2_jsonrpc_request!(
301    v2::CancelTerminalRequest,
302    v2::CancelTerminalResponse,
303    "terminal/cancel"
304);
305impl_v2_jsonrpc_request!(v2::PromptRequest, v2::PromptResponse, "session/prompt");
306#[cfg(feature = "unstable_mcp_over_acp")]
307impl_v2_jsonrpc_request!(v2::MessageMcpRequest, v2::MessageMcpResponse, "mcp/message");
308
309impl_v2_jsonrpc_notification!(v2::CancelRequestNotification, "$/cancel_request");
310impl_v2_jsonrpc_notification!(v2::CancelSessionNotification, "session/cancel");
311#[cfg(feature = "unstable_mcp_over_acp")]
312impl_v2_jsonrpc_notification!(v2::MessageMcpNotification, "mcp/message");
313
314impl_v2_jsonrpc_request!(
315    v2::RequestPermissionRequest,
316    v2::RequestPermissionResponse,
317    "session/request_permission"
318);
319impl_v2_jsonrpc_request!(
320    v2::CreateElicitationRequest,
321    v2::CreateElicitationResponse,
322    "elicitation/create"
323);
324
325impl_v2_jsonrpc_notification!(v2::UpdateSessionNotification, "session/update");
326impl_v2_jsonrpc_notification!(v2::CompleteElicitationNotification, "elicitation/complete");
327#[cfg(feature = "unstable_auth_status")]
328impl_v2_jsonrpc_notification!(v2::AuthStatusUpdateNotification, "auth/status_update");
329
330impl_jsonrpc_protocol_level_notification_enum!(v2::ProtocolLevelNotification {
331    CancelRequestNotification => "$/cancel_request",
332});
333
334impl_v2_jsonrpc_request_enum!(v2::ClientRequest {
335    InitializeRequest => "initialize",
336    LoginAuthRequest => "auth/login",
337    LogoutAuthRequest => "auth/logout",
338    #[cfg(feature = "unstable_auth_status")]
339    AuthStatusRequest => "auth/status",
340    #[cfg(feature = "unstable_llm_providers")]
341    ListProvidersRequest => "providers/list",
342    #[cfg(feature = "unstable_llm_providers")]
343    SetProviderRequest => "providers/set",
344    #[cfg(feature = "unstable_llm_providers")]
345    DisableProviderRequest => "providers/disable",
346    NewSessionRequest => "session/new",
347    ListSessionsRequest => "session/list",
348    DeleteSessionRequest => "session/delete",
349    #[cfg(feature = "unstable_session_fork")]
350    ForkSessionRequest => "session/fork",
351    #[cfg(feature = "unstable_session_archive")]
352    ArchiveSessionRequest => "session/archive",
353    #[cfg(feature = "unstable_session_archive")]
354    UnarchiveSessionRequest => "session/unarchive",
355    #[cfg(feature = "unstable_session_status")]
356    SessionStatusRequest => "session/status",
357    #[cfg(feature = "unstable_session_options")]
358    SessionOptionsRequest => "session/options",
359    #[cfg(feature = "unstable_session_set_title")]
360    SetSessionTitleRequest => "session/set_title",
361    ResumeSessionRequest => "session/resume",
362    CloseSessionRequest => "session/close",
363    CancelToolCallRequest => "tool_call/cancel",
364    CancelTerminalRequest => "terminal/cancel",
365    SetSessionConfigOptionRequest => "session/set_config_option",
366    PromptRequest => "session/prompt",
367    [ext] ExtMethodRequest,
368});
369
370impl_v2_jsonrpc_response_enum!(v2::AgentResponse {
371    InitializeResponse => "initialize",
372    LoginAuthResponse => "auth/login",
373    LogoutAuthResponse => "auth/logout",
374    #[cfg(feature = "unstable_auth_status")]
375    AuthStatusResponse => "auth/status",
376    #[cfg(feature = "unstable_llm_providers")]
377    ListProvidersResponse => "providers/list",
378    #[cfg(feature = "unstable_llm_providers")]
379    SetProviderResponse => "providers/set",
380    #[cfg(feature = "unstable_llm_providers")]
381    DisableProviderResponse => "providers/disable",
382    NewSessionResponse => "session/new",
383    ListSessionsResponse => "session/list",
384    DeleteSessionResponse => "session/delete",
385    #[cfg(feature = "unstable_session_fork")]
386    ForkSessionResponse => "session/fork",
387    #[cfg(feature = "unstable_session_archive")]
388    ArchiveSessionResponse => "session/archive",
389    #[cfg(feature = "unstable_session_archive")]
390    UnarchiveSessionResponse => "session/unarchive",
391    #[cfg(feature = "unstable_session_status")]
392    SessionStatusResponse => "session/status",
393    #[cfg(feature = "unstable_session_options")]
394    SessionOptionsResponse => "session/options",
395    #[cfg(feature = "unstable_session_set_title")]
396    SetSessionTitleResponse => "session/set_title",
397    ResumeSessionResponse => "session/resume",
398    CloseSessionResponse => "session/close",
399    CancelToolCallResponse => "tool_call/cancel",
400    CancelTerminalResponse => "terminal/cancel",
401    SetSessionConfigOptionResponse => "session/set_config_option",
402    PromptResponse => "session/prompt",
403    [ext] ExtMethodResponse,
404});
405
406impl_v2_jsonrpc_notification_enum!(v2::ClientNotification {
407    CancelSessionNotification => "session/cancel",
408    #[cfg(feature = "unstable_mcp_over_acp")]
409    MessageMcpNotification => "mcp/message",
410    [ext] ExtNotification,
411});
412
413impl_v2_jsonrpc_request_enum!(v2::AgentRequest {
414    RequestPermissionRequest => "session/request_permission",
415    CreateElicitationRequest => "elicitation/create",
416    #[cfg(feature = "unstable_mcp_over_acp")]
417    MessageMcpRequest => "mcp/message",
418    [ext] ExtMethodRequest,
419});
420
421impl_v2_jsonrpc_response_enum!(v2::ClientResponse {
422    RequestPermissionResponse => "session/request_permission",
423    CreateElicitationResponse => "elicitation/create",
424    #[cfg(feature = "unstable_mcp_over_acp")]
425    MessageMcpResponse => "mcp/message",
426    [ext] ExtMethodResponse,
427});
428
429impl_v2_jsonrpc_notification_enum!(v2::AgentNotification {
430    UpdateSessionNotification => "session/update",
431    CompleteElicitationNotification => "elicitation/complete",
432    #[cfg(feature = "unstable_auth_status")]
433    AuthStatusUpdateNotification => "auth/status_update",
434    [ext] ExtNotification,
435});