Files
codex/codex-rs/rmcp-client/src/tool_input_tests.rs
T
riley-oai c6a59ef923 Support native verification in MCP tool continuations (#44346)
## Why

RMCP's standard input request union excludes custom methods, so tool continuations need explicit handling for OpenAI form elicitation and native user verification.

## What changed

- Route MCP `2026-07-28` tool inputs through the existing client service, preserving capability checks and verification response validation.
- Support `openai/elicitation/create` form and `openai/userVerification` inputs alongside standard MCP inputs, and return responses with the server's opaque `requestState`.
- Bound continuation rounds, back off for state-only responses, and reject unsupported or malformed inputs.
- Give concurrent verification prompts distinct cancellation ownership and release pending prompts and timeout pauses when the connection closes.
- Prevent session recovery from restarting a tool after submitting a verification proof while preserving authentication challenges.

## Testing

Add HTTP continuation tests covering mixed input types, proof validation, request metadata preservation, invalid requests, round limits, authentication challenges, session expiry after proof submission, and independent prompt cancellation. Add duplex transport tests for pending-input cleanup on cancellation and transport closure.

GitOrigin-RevId: b7db6d47fa0969b6a938220dfe3610e5ba5188b2
2026-09-10 00:14:43 +00:00

102 lines
4.1 KiB
Rust

//! Exercises pending MRTR input cleanup over a real duplex transport.
use super::ElicitationClientService;
use crate::rmcp_client::ElicitationPauseState;
use crate::tool_input::call_tool;
use codex_protocol::mcp::OPENAI_ELICITATION_EXTENSION_ID;
use rmcp::RoleServer;
use rmcp::model::CallToolRequestParams;
use rmcp::model::ClientInfo;
use rmcp::model::ClientJsonRpcMessage;
use rmcp::model::CustomResult;
use rmcp::model::ServerJsonRpcMessage;
use rmcp::model::ServerResult;
use rmcp::service::ServiceError;
use rmcp::service::serve_directly;
use rmcp::transport::IntoTransport;
use rmcp::transport::Transport;
use serde_json::json;
use std::time::Duration;
use tokio::sync::mpsc;
use tokio::sync::oneshot;
use tokio::time::timeout;
#[tokio::test]
async fn connection_closure_releases_pending_inputs_and_timeout_pause() -> anyhow::Result<()> {
for mode in ["form", "openai/userVerification"] {
for close_transport in [false, true] {
let pause_state = ElicitationPauseState::new();
let mut paused = pause_state.subscribe();
let (route_tx, mut route_rx) = mpsc::unbounded_channel();
let mut info = ClientInfo::default();
info.capabilities.extensions = Some(
[(
OPENAI_ELICITATION_EXTENSION_ID.into(),
serde_json::Map::from_iter([
("userVerification".into(), json!({})),
("form".into(), json!({})),
]),
)]
.into_iter()
.collect(),
);
let service = ElicitationClientService::new(
info,
Box::new(move |_, _| {
let (tx, rx) = oneshot::channel();
route_tx.send(tx).unwrap();
Box::pin(async move { Ok(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 call = call_tool(&client, CallToolRequestParams::new("test"));
tokio::pin!(call);
let request = tokio::select! {
result = &mut call => panic!("tool completed before input: {result:?}"),
request = timeout(Duration::from_secs(/*secs*/ 5), server.receive()) => request?,
};
let Some(ClientJsonRpcMessage::Request(request)) = request else {
anyhow::bail!("expected tool call");
};
let params = match mode {
"form" => json!({
"mode": mode, "message": "Confirm",
"requestedSchema": {"type": "object", "properties": {}},
}),
_ => json!({
"mode": mode, "title": "Verify", "description": "", "challenge": "AQID",
}),
};
server.send(ServerJsonRpcMessage::response(
ServerResult::CustomResult(CustomResult(json!({
"resultType": "input_required",
"inputRequests": {"input": {"method": "openai/elicitation/create", "params": params}},
}))),
request.id,
)).await?;
let reply = tokio::select! {
result = &mut call => panic!("tool completed before prompting: {result:?}"),
reply = timeout(Duration::from_secs(/*secs*/ 5), route_rx.recv()) => reply?.unwrap(),
};
assert!(*paused.borrow());
if close_transport {
drop(server);
} else {
client.cancellation_token().cancel();
}
let result = timeout(Duration::from_secs(/*secs*/ 5), call).await?;
assert!(
matches!(result, Err(ServiceError::TransportClosed)),
"{result:?}"
);
assert!(reply.is_closed());
assert!(!*paused.borrow_and_update());
}
}
Ok(())
}