Cleanup

Author: benbrandt

src/agent-client-protocol-core/src/jsonrpc.rs

@@ -2436,7 +2436,9 @@ impl<Req: JsonRpcRequest, Notif: JsonRpcMessage> Dispatch<Req, Notif> {
         }
     }
 
-    pub(crate) fn into_handled_no_untyped(
+    /// Erase this typed dispatch back to untyped JSON and wrap it in
+    /// [`Handled::No`] so the connection loop can offer it to later handlers.
+    pub(crate) fn erase_into_unhandled(
         self,
         retry: bool,
     ) -> Result<Handled<Dispatch>, crate::Error> {
@@ -2468,24 +2470,6 @@ impl<Req: JsonRpcRequest, Notif: JsonRpcMessage> Dispatch<Req, Notif> {
     }
 }
 
-/// Normalize legacy parse errors from matched incoming request/notification params.
-///
-/// `MethodNotFound` still means "this type does not handle the method" and therefore falls
-/// through to later handlers. The SDK's own request/notification parsers now return
-/// `InvalidParams` directly; this rewrite remains only as a compatibility backstop for older
-/// custom parsers that still emit `ParseError`.
-fn normalize_incoming_message_parse_error(err: crate::Error) -> Option<crate::Error> {
-    match &err.code {
-        crate::ErrorCode::MethodNotFound => None,
-        crate::ErrorCode::ParseError => {
-            let mut invalid_params = crate::Error::invalid_params();
-            invalid_params.data = err.data;
-            Some(invalid_params)
-        }
-        _ => Some(err),
-    }
-}
-
 /// Outcome of matching an untyped [`Dispatch`] against a request type.
 #[derive(Debug)]
 pub enum RequestMatch<Req: JsonRpcRequest> {
@@ -2546,12 +2530,9 @@ impl Dispatch {
                 if Req::matches_method(&message.method) {
                     match Req::parse_message(&message.method, &message.params) {
                         Ok(req) => RequestMatch::Matched(req, responder.cast()),
-                        Err(err) => match normalize_incoming_message_parse_error(err) {
-                            Some(error) => RequestMatch::Rejected {
-                                dispatch: Dispatch::Request(message, responder),
-                                error,
-                            },
-                            None => RequestMatch::Unhandled(Dispatch::Request(message, responder)),
+                        Err(error) => RequestMatch::Rejected {
+                            dispatch: Dispatch::Request(message, responder),
+                            error,
                         },
                     }
                 } else {
@@ -2575,12 +2556,9 @@ impl Dispatch {
                 if Notif::matches_method(&message.method) {
                     match Notif::parse_message(&message.method, &message.params) {
                         Ok(notif) => NotificationMatch::Matched(notif),
-                        Err(err) => match normalize_incoming_message_parse_error(err) {
-                            Some(error) => NotificationMatch::Rejected {
-                                dispatch: Dispatch::Notification(message),
-                                error,
-                            },
-                            None => NotificationMatch::Unhandled(Dispatch::Notification(message)),
+                        Err(error) => NotificationMatch::Rejected {
+                            dispatch: Dispatch::Notification(message),
+                            error,
                         },
                     }
                 } else {
@@ -2599,6 +2577,7 @@ impl Dispatch {
     /// Once the request/notification side matches by method, any parse error is terminal for
     /// that method and yields [`TypedDispatchMatch::Rejected`]. Likewise, a matched response
     /// whose result cannot be decoded is rejected instead of bubbling up as a fatal `Err`.
+    #[must_use]
     pub fn match_typed_dispatch<Req: JsonRpcRequest, Notif: JsonRpcNotification>(
         self,
     ) -> TypedDispatchMatch<Req, Notif> {

src/agent-client-protocol-core/src/jsonrpc/handlers.rs

@@ -133,7 +133,7 @@ where
                                 message: (request, responder),
                                 retry,
                             } => Dispatch::<Req, UntypedMessage>::Request(request, responder)
-                                .into_handled_no_untyped(retry),
+                                .erase_into_unhandled(retry),
                         }
                     }
                     RequestMatch::Unhandled(dispatch) => {
@@ -236,7 +236,7 @@ where
                                 message: (notification, _cx),
                                 retry,
                             } => Dispatch::<UntypedMessage, Notif>::Notification(notification)
-                                .into_handled_no_untyped(retry),
+                                .erase_into_unhandled(retry),
                         }
                     }
                     NotificationMatch::Unhandled(dispatch) => {
@@ -337,7 +337,7 @@ where
                         Handled::No {
                             message: typed_dispatch,
                             retry,
-                        } => typed_dispatch.into_handled_no_untyped(retry),
+                        } => typed_dispatch.erase_into_unhandled(retry),
                     }
                 }
                 TypedDispatchMatch::Unhandled(dispatch) => Ok(Handled::No {

src/agent-client-protocol-core/src/util/typed.rs

@@ -115,7 +115,7 @@ impl MatchDispatch {
                                 message: (request, responder),
                                 retry: request_retry,
                             } => Dispatch::<Req, UntypedMessage>::Request(request, responder)
-                                .into_handled_no_untyped(retry | request_retry),
+                                .erase_into_unhandled(retry | request_retry),
                         },
                         Err(err) => Err(err),
                     }
@@ -157,7 +157,7 @@ impl MatchDispatch {
                                 message: notification,
                                 retry: notification_retry,
                             } => Dispatch::<UntypedMessage, N>::Notification(notification)
-                                .into_handled_no_untyped(retry | notification_retry),
+                                .erase_into_unhandled(retry | notification_retry),
                         },
                         Err(err) => Err(err),
                     }
@@ -197,7 +197,7 @@ impl MatchDispatch {
                         Handled::No {
                             message: typed_dispatch,
                             retry: message_retry,
-                        } => match typed_dispatch.into_handled_no_untyped(retry | message_retry) {
+                        } => match typed_dispatch.erase_into_unhandled(retry | message_retry) {
                             Ok(handled) => Ok(handled),
                             Err(err) => return Self { state: Err(err) },
                         },
@@ -259,7 +259,7 @@ impl MatchDispatch {
                                     message: (result, router),
                                     retry: response_retry,
                                 } => Dispatch::<Req, UntypedMessage>::Response(result, router)
-                                    .into_handled_no_untyped(retry | response_retry),
+                                    .erase_into_unhandled(retry | response_retry),
                             },
                             Err(err) => Err(err),
                         }
@@ -520,7 +520,7 @@ impl<Counterpart: Role> MatchDispatchFrom<Counterpart> {
                                     message: notification,
                                     retry: notification_retry,
                                 } => Dispatch::<UntypedMessage, N>::Notification(notification)
-                                    .into_handled_no_untyped(notification_retry),
+                                    .erase_into_unhandled(notification_retry),
                             },
                             Err(err) => Err(err),
                         }
@@ -571,7 +571,7 @@ impl<Counterpart: Role> MatchDispatchFrom<Counterpart> {
                             Handled::No {
                                 message: typed_dispatch,
                                 retry: message_retry,
-                            } => typed_dispatch.into_handled_no_untyped(message_retry),
+                            } => typed_dispatch.erase_into_unhandled(message_retry),
                         },
                         Err(err) => Err(err),
                     },