fix(acp): drain failed initialize negotiation state

Author: benbrandt

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

@@ -64,29 +64,29 @@ pub(super) async fn outgoing_protocol_actor(
             OutgoingMessage::Response {
                 id,
                 method,
-                response: Ok(value),
-            } => {
-                let value = protocol_compat.outgoing_response(&method, Ok(value))?;
-                tracing::debug!(?id, "Sending success response");
-                jsonrpcmsg::Message::Response(jsonrpcmsg::Response::success_v2(value, Some(id)))
-            }
-            OutgoingMessage::Response {
-                id,
-                method,
-                response: Err(error),
-            } => {
-                tracing::warn!(?id, %method, ?error, "Sending error response");
-                // Convert crate::Error to jsonrpcmsg::Error
-                let jsonrpc_error = jsonrpcmsg::Error {
-                    code: error.code.into(),
-                    message: error.message,
-                    data: error.data,
-                };
-                jsonrpcmsg::Message::Response(jsonrpcmsg::Response::error_v2(
-                    jsonrpc_error,
-                    Some(id),
-                ))
-            }
+                response,
+            } => match protocol_compat.outgoing_response(&method, response) {
+                Ok(value) => {
+                    tracing::debug!(?id, "Sending success response");
+                    jsonrpcmsg::Message::Response(jsonrpcmsg::Response::success_v2(
+                        value,
+                        Some(id),
+                    ))
+                }
+                Err(error) => {
+                    tracing::warn!(?id, %method, ?error, "Sending error response");
+                    // Convert crate::Error to jsonrpcmsg::Error
+                    let jsonrpc_error = jsonrpcmsg::Error {
+                        code: error.code.into(),
+                        message: error.message,
+                        data: error.data,
+                    };
+                    jsonrpcmsg::Message::Response(jsonrpcmsg::Response::error_v2(
+                        jsonrpc_error,
+                        Some(id),
+                    ))
+                }
+            },
             OutgoingMessage::Error { error } => {
                 // Convert crate::Error to jsonrpcmsg::Error
                 let jsonrpc_error = jsonrpcmsg::Error {

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

@@ -134,6 +134,11 @@ mod imp {
                 (Self::Disabled, other) => other,
                 (this, Self::Disabled) => this,
                 (Self::Acp(this), Self::Acp(other)) => {
+                    debug_assert_eq!(
+                        this.api, other.api,
+                        "cannot merge ACP builders with different API protocol versions; \
+                         handler chains share a single API surface",
+                    );
                     if this.latest_supported >= other.latest_supported {
                         Self::Acp(this)
                     } else {
@@ -250,13 +255,22 @@ mod imp {
             method: &str,
             result: Result<serde_json::Value, crate::Error>,
         ) -> Result<serde_json::Value, crate::Error> {
-            let mut value = result?;
             let Some(mode) = self.mode else {
-                return Ok(value);
+                return result;
+            };
+
+            // Always drain any pending initialize state so a failed initialize
+            // doesn't leak negotiation state to a subsequent request.
+            let pending_initialize = if method == "initialize" {
+                self.take_pending_initialize()
+            } else {
+                None
             };
 
+            let mut value = result?;
+
             let wire_version = if method == "initialize" {
-                let negotiated = self.take_pending_initialize().unwrap_or_else(|| {
+                let negotiated = pending_initialize.unwrap_or_else(|| {
                     protocol_version_from_value(&value)
                         .and_then(ProtocolVersionKind::from_protocol_version)
                         .unwrap_or(mode.latest_supported)