Skip to content

armgit / codex

Public Imported from GitHub
0

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.rs
index 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) = &notification
- && self.supports_user_verification
&& let Some(request_id) = cancelled.params.request_id.as_ref()
{
let mut cancellations = self
diff --git a/codex-rs/rmcp-client/src/rmcp_client.rs b/codex-rs/rmcp-client/src/rmcp_client.rs
index 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?;
service
diff --git a/codex-rs/rmcp-client/src/streamable_http_retry.rs b/codex-rs/rmcp-client/src/streamable_http_retry.rs
index 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.rs
index 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<()> {