Lightweight coding agent that runs in your terminal
Rust
Fix MCP elicitation cancellation and reset state on reconnect (#44238)
jif3436cad5abbe
diff --git a/codex-rs/rmcp-client/src/elicitation_client_service.rs b/codex-rs/rmcp-client/src/elicitation_client_service.rsindex 1eff73f788..70ac92582b 100644--- a/codex-rs/rmcp-client/src/elicitation_client_service.rs+++ b/codex-rs/rmcp-client/src/elicitation_client_service.rs@@ -68,7 +68,7 @@ pub(crate) struct ElicitationClientService {}// A notification handler can run before its request handler. Never evict an early-// cancellation: after saturation, cancel new verifications for this connection.+// cancellation: after saturation, cancel new elicitations for this connection.const MAX_EARLY_CANCELLATIONS: usize = 1024;#[derive(Default)]@@ -142,7 +142,7 @@ impl ElicitationClientService {let request = restore_context_meta(request, meta);let user_verification = matches!(&request, Elicitation::UserVerification { .. });let (cancel_tx, cancel_rx) = oneshot::channel();- let _pending = if user_verification {+ let _pending = {let mut cancellations = self.pending_verifications.lock()@@ -155,24 +155,22 @@ impl ElicitationClientService {});}cancellations.pending.insert(id.clone(), cancel_tx);- Some(PendingVerification {+ PendingVerification {request_id: id.clone(),cancellations: Arc::clone(&self.pending_verifications),- })- } else {- None+ }};let _pause = self.pause_state.enter();let response = tokio::select! {biased;- _ = ct.cancelled(), if user_verification => {+ _ = ct.cancelled() => {return Ok(ElicitationResponse {action: ElicitationAction::Cancel,content: None,meta: None,});}- _ = cancel_rx, if user_verification => {+ _ = cancel_rx => {return Ok(ElicitationResponse {action: ElicitationAction::Cancel,content: None,@@ -319,7 +317,6 @@ impl Service<RoleClient> for ElicitationClientService {context: NotificationContext<RoleClient>,) -> Result<(), rmcp::ErrorData> {if let ServerNotification::CancelledNotification(cancelled) = ¬ification- && self.supports_user_verification&& let Some(request_id) = cancelled.params.request_id.as_ref(){let mut cancellations = selfdiff --git a/codex-rs/rmcp-client/src/rmcp_client.rs b/codex-rs/rmcp-client/src/rmcp_client.rsindex 30931dad03..549e6d9d3f 100644--- a/codex-rs/rmcp-client/src/rmcp_client.rs+++ b/codex-rs/rmcp-client/src/rmcp_client.rs@@ -185,7 +185,8 @@ impl Drop for InitializeDeadlineGuard {#[derive(Clone)]struct InitializeContext {timeout: Option<Duration>,- client_service: ElicitationClientService,+ client_info: InitializeRequestParams,+ send_elicitation: Arc<SendElicitation>,}#[derive(Clone)]@@ -611,11 +612,11 @@ impl RmcpClient {timeout: Option<Duration>,send_elicitation: SendElicitation,) -> Result<ServerPeerInfo> {- let client_service = ElicitationClientService::new(- params.clone(),- send_elicitation,- self.elicitation_pause_state.clone(),- );+ let context = InitializeContext {+ timeout,+ client_info: params,+ send_elicitation: Arc::new(send_elicitation),+ };let pending_transport = {let mut guard = self.state.lock().await;match &mut *guard {@@ -629,11 +630,7 @@ impl RmcpClient {};let (service, oauth_runtime) = self- .connect_pending_transport_with_initialize_retries(- pending_transport,- client_service.clone(),- timeout,- )+ .connect_pending_transport_with_initialize_retries(pending_transport, &context).await?;let initialize_result_rmcp = service@@ -644,10 +641,7 @@ impl RmcpClient {{let mut initialize_context = self.initialize_context.lock().await;- *initialize_context = Some(InitializeContext {- timeout,- client_service,- });+ *initialize_context = Some(context);}{@@ -1245,12 +1239,20 @@ impl RmcpClient {async fn connect_pending_transport(&self,pending_transport: PendingTransport,- client_service: ElicitationClientService,+ initialize_context: &InitializeContext,timeout: Option<Duration>,) -> Result<(Arc<RunningService<RoleClient, ElicitationClientService>>,Option<OAuthRuntime>,)> {+ // Request IDs and remembered cancellations belong to this connection, including+ // when a failed initialization or expired HTTP session creates a new transport.+ let send_elicitation = Arc::clone(&initialize_context.send_elicitation);+ let client_service = ElicitationClientService::new(+ initialize_context.client_info.clone(),+ Box::new(move |id, request| send_elicitation(id, request)),+ self.elicitation_pause_state.clone(),+ );let _initialize_deadline = match &self.transport_recipe {TransportRecipe::StreamableHttp {initialize_deadline,@@ -1531,8 +1533,7 @@ impl RmcpClient {let (service, oauth_runtime) = self.connect_pending_transport_with_initialize_retries(pending_transport,- initialize_context.client_service,- initialize_context.timeout,+ &initialize_context,).await?;servicediff --git a/codex-rs/rmcp-client/src/streamable_http_retry.rs b/codex-rs/rmcp-client/src/streamable_http_retry.rsindex 3f564630eb..66dda2cb59 100644--- a/codex-rs/rmcp-client/src/streamable_http_retry.rs+++ b/codex-rs/rmcp-client/src/streamable_http_retry.rs@@ -16,6 +16,7 @@ use crate::elicitation_client_service::ElicitationClientService;use crate::http_client_adapter::StreamableHttpClientAdapterError;use crate::oauth::OAuthRuntime;+use super::InitializeContext;use super::PendingTransport;use super::RmcpClient;@@ -26,12 +27,12 @@ impl RmcpClient {pub(super) async fn connect_pending_transport_with_initialize_retries(&self,initial_transport: PendingTransport,- client_service: ElicitationClientService,- timeout: Option<Duration>,+ initialize_context: &InitializeContext,) -> Result<(Arc<RunningService<RoleClient, ElicitationClientService>>,Option<OAuthRuntime>,)> {+ let timeout = initialize_context.timeout;let should_retry = match &initial_transport {PendingTransport::InProcess { .. } | PendingTransport::Stdio { .. } => false,PendingTransport::StreamableHttp { .. }@@ -75,7 +76,7 @@ impl RmcpClient {let attempt_timeout = remaining_initialize_timeout(timeout, retry_deadline)?;match self- .connect_pending_transport(transport, client_service.clone(), attempt_timeout)+ .connect_pending_transport(transport, initialize_context, attempt_timeout).await{Ok(result) => return Ok(result),diff --git a/codex-rs/rmcp-client/src/user_verification_cancellation_tests.rs b/codex-rs/rmcp-client/src/user_verification_cancellation_tests.rsindex 5f69fcebf6..2fc8a2f146 100644--- a/codex-rs/rmcp-client/src/user_verification_cancellation_tests.rs+++ b/codex-rs/rmcp-client/src/user_verification_cancellation_tests.rs@@ -1,28 +1,243 @@-//! Ensures MCP service cancellation releases the pending verification route and tool timeout pause.+//! Ensures MCP cancellation releases pending elicitation routes and tool timeout pauses.use super::ElicitationClientService;use super::ElicitationPauseState;use super::ElicitationResponse;+use super::RmcpClient;+use crate::InProcessTransportFactory;use codex_protocol::mcp::OPENAI_ELICITATION_EXTENSION_ID;+use futures::future::BoxFuture;+use pretty_assertions::assert_eq;use rmcp::RoleServer;+use rmcp::ServerHandler;+use rmcp::ServiceExt;use rmcp::model::CancelledNotification;use rmcp::model::CancelledNotificationParam;use rmcp::model::ClientInfo;use rmcp::model::ClientJsonRpcMessage;use rmcp::model::CustomRequest;use rmcp::model::ElicitationAction;+use rmcp::model::ProtocolVersion;use rmcp::model::RequestId;use rmcp::model::ServerJsonRpcMessage;use rmcp::model::ServerNotification;use rmcp::model::ServerRequest;+use rmcp::service::PeerRequestOptions;+use rmcp::service::RunningService;+use rmcp::service::ServerInitializeError;use rmcp::service::serve_directly;use rmcp::transport::IntoTransport;use rmcp::transport::Transport;use serde_json::json;+use std::sync::Arc;use std::time::Duration;use tokio::sync::mpsc;use tokio::sync::oneshot;use tokio::time::timeout;+use tracing_test::traced_test;++struct ElicitationTestServer;++impl ServerHandler for ElicitationTestServer {}++struct ElicitationTestTransport {+ servers: mpsc::UnboundedSender<+ Result<RunningService<RoleServer, ElicitationTestServer>, ServerInitializeError>,+ >,+}++impl InProcessTransportFactory for ElicitationTestTransport {+ fn open(&self) -> BoxFuture<'static, std::io::Result<tokio::io::DuplexStream>> {+ let servers = self.servers.clone();+ Box::pin(async move {+ let (client, server) = tokio::io::duplex(/*max_buf_size*/ 4096);+ tokio::spawn(async move {+ let _ = servers.send(ElicitationTestServer.serve(server).await);+ });+ Ok(client)+ })+ }+}++#[tokio::test]+#[traced_test]+async fn recovered_connections_accept_elicitations_with_previously_cancelled_ids()+-> anyhow::Result<()> {+ for params in [+ json!({+ "mode": "form",+ "message": "Confirm",+ "requestedSchema": {"type": "object", "properties": {}},+ }),+ json!({+ "mode": "url",+ "message": "Authorize",+ "url": "https://example.com/authorize",+ "elicitationId": "authorization",+ }),+ ] {+ let (servers, mut server_rx) = mpsc::unbounded_channel();+ let client =+ RmcpClient::new_in_process_client(Arc::new(ElicitationTestTransport { servers }))+ .await?;+ client+ .initialize(+ ClientInfo::default().with_protocol_version(ProtocolVersion::V_2025_06_18),+ Some(Duration::from_secs(/*secs*/ 5)),+ Box::new(|_, _| {+ Box::pin(async {+ Ok(ElicitationResponse {+ action: ElicitationAction::Accept,+ content: None,+ meta: None,+ })+ })+ }),+ )+ .await?;+ let server = timeout(Duration::from_secs(/*secs*/ 5), server_rx.recv())+ .await?+ .unwrap()?;+ let reason = format!("late cancellation for {}", params["mode"]);+ let request =+ ServerRequest::CustomRequest(CustomRequest::new("elicitation/create", Some(params)));+ let original = server+ .send_request_with_option(request.clone(), PeerRequestOptions::no_options())+ .await?;+ let id = original.id.clone();+ assert_eq!(+ serde_json::to_value(+ timeout(Duration::from_secs(/*secs*/ 5), original.await_response()).await??+ )?,+ json!({"action": "accept"}),+ );+ server+ .notify_cancelled(CancelledNotificationParam::new(+ Some(id.clone()),+ Some(reason.clone()),+ ))+ .await?;+ // Notifications run in independent tasks. The handler logs only after recording+ // the cancellation, so wait for that acknowledgement before starting recovery.+ let handled = format!(+ "MCP server cancelled request (request_id: Some({id:?}), reason: Some({reason:?}))"+ );+ timeout(Duration::from_secs(/*secs*/ 5), async {+ while !logs_contain(&handled) {+ tokio::task::yield_now().await;+ }+ })+ .await?;++ let previous = client.service().await?;+ client.reinitialize_after_session_expiry(&previous).await?;+ let recovered_server = timeout(Duration::from_secs(/*secs*/ 5), server_rx.recv())+ .await?+ .unwrap()?;+ let recovered = recovered_server+ .send_request_with_option(request, PeerRequestOptions::no_options())+ .await?;+ assert_eq!(recovered.id, id);+ assert_eq!(+ serde_json::to_value(+ timeout(Duration::from_secs(/*secs*/ 5), recovered.await_response()).await??+ )?,+ json!({"action": "accept"}),+ );+ client.shutdown().await;+ drop(previous);+ server.cancel().await?;+ recovered_server.cancel().await?;+ }+ Ok(())+}++#[tokio::test]+async fn ordinary_elicitations_release_pending_responses_on_cancellation() -> anyhow::Result<()> {+ for params in [+ json!({+ "mode": "form",+ "message": "Confirm",+ "requestedSchema": {"type": "object", "properties": {}},+ }),+ json!({+ "mode": "url",+ "message": "Authorize",+ "url": "https://example.com/authorize",+ "elicitationId": "authorization",+ }),+ ] {+ let pause_state = ElicitationPauseState::new();+ let mut paused = pause_state.subscribe();+ let (route_tx, mut route_rx) = mpsc::unbounded_channel();+ let service = ElicitationClientService::new(+ ClientInfo::default(),+ Box::new(move |_, _| {+ let (response_tx, response_rx) = oneshot::channel();+ route_tx.send(response_tx).expect("observe elicitation");+ Box::pin(async move { Ok(response_rx.await?) })+ }),+ pause_state,+ );+ let (client_transport, server_transport) = tokio::io::duplex(/*max_buf_size*/ 4096);+ let client = serve_directly(service, client_transport, /*peer_info*/ None);+ let mut server = IntoTransport::<RoleServer, _, _>::into_transport(server_transport);+ let request =+ ServerRequest::CustomRequest(CustomRequest::new("elicitation/create", Some(params)));+ server+ .send(ServerJsonRpcMessage::request(+ request.clone(),+ RequestId::Number(1),+ ))+ .await?;+ let mut response_tx = timeout(Duration::from_secs(/*secs*/ 5), route_rx.recv())+ .await?+ .expect("elicitation reached UI without user-verification capability");+ assert!(*paused.borrow());++ server+ .send(ServerJsonRpcMessage::notification(+ ServerNotification::CancelledNotification(CancelledNotification::new(+ CancelledNotificationParam::new(+ Some(RequestId::Number(1)),+ /*reason*/ None,+ ),+ )),+ ))+ .await?;+ timeout(Duration::from_secs(/*secs*/ 5), response_tx.closed()).await?;+ timeout(+ Duration::from_secs(/*secs*/ 5),+ paused.wait_for(|paused| !*paused),+ )+ .await??;+ let response = timeout(Duration::from_secs(/*secs*/ 5), server.receive())+ .await?+ .expect("cancelled elicitation returned a response");+ assert_eq!(+ serde_json::to_value(response)?,+ json!({"jsonrpc": "2.0", "id": 1, "result": {"action": "cancel"}}),+ );++ server+ .send(ServerJsonRpcMessage::request(request, RequestId::Number(2)))+ .await?;+ let mut response_tx = timeout(Duration::from_secs(/*secs*/ 5), route_rx.recv())+ .await?+ .expect("connection still accepts elicitations after cancellation");+ assert!(*paused.borrow());++ client.cancel().await?;++ timeout(Duration::from_secs(/*secs*/ 5), response_tx.closed()).await?;+ timeout(+ Duration::from_secs(/*secs*/ 5),+ paused.wait_for(|paused| !*paused),+ )+ .await??;+ }+ Ok(())+}#[tokio::test]async fn user_verification_service_cancellation_drops_pending_response() -> anyhow::Result<()> {