diff --git a/codex-rs/core/tests/suite/mcp_oauth_refresh_tests.rs b/codex-rs/core/tests/suite/mcp_oauth_refresh_tests.rs index 309370f9c7..6ecfde4d06 100644 --- a/codex-rs/core/tests/suite/mcp_oauth_refresh_tests.rs +++ b/codex-rs/core/tests/suite/mcp_oauth_refresh_tests.rs @@ -1,7 +1,8 @@ -//! Covers OAuth connection replacement when a running thread refreshes its feature config. +//! Covers OAuth recovery and authentication challenges in running MCP connections. use super::EnvVarGuard; use super::OAuthCredentialExpiry; +use super::read_only_user_turn; use super::write_fallback_oauth_tokens; use std::sync::Arc; @@ -9,16 +10,23 @@ use codex_config::DEFAULT_MCP_SERVER_ENVIRONMENT_ID; use codex_config::McpServerConfig; use codex_config::types::OAuthCredentialsStoreMode; use codex_features::Feature; +use codex_protocol::items::McpToolCallStatus; +use codex_protocol::items::TurnItem; +use codex_protocol::mcp::CallToolResult; +use codex_protocol::protocol::EventMsg; use core_test_support::apps_test_server::AppsTestServer; use core_test_support::responses; use core_test_support::skip_if_no_network; use core_test_support::test_codex::test_codex; +use core_test_support::wait_for_event; +use core_test_support::wait_for_mcp_server; use pretty_assertions::assert_eq; use serde_json::json; use serial_test::serial; use test_case::test_case; use wiremock::Mock; use wiremock::ResponseTemplate; +use wiremock::matchers::body_partial_json; use wiremock::matchers::method; use wiremock::matchers::path; @@ -27,6 +35,107 @@ enum ConfigRefreshPath { Mcp, } +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn http_auth_challenge_reaches_agent_tool_call_events_without_replay() -> anyhow::Result<()> { + skip_if_no_network!(Ok(())); + + let responses_server = responses::start_mock_server().await; + let mcp_server = responses::start_mock_server().await; + let http_server = AppsTestServer::mount(&mcp_server).await?; + let challenge = r#"Bearer error="invalid_token", scope="calendar:read", resource_metadata="https://example.com/.well-known/oauth-protected-resource""#; + Mock::given(method("POST")) + .and(path("/api/codex/ps/mcp")) + .and(body_partial_json(json!({"method": "tools/call"}))) + .respond_with( + ResponseTemplate::new(/*s*/ 401) + .append_header("www-authenticate", r#"Basic realm="proxy, login""#) + .append_header("www-authenticate", challenge), + ) + .with_priority(/*p*/ 1) + .expect(1) + .mount(&mcp_server) + .await; + let call_id = "auth-challenge-call"; + let model_requests = responses::mount_sse_sequence( + &responses_server, + vec![ + responses::sse(vec![ + responses::ev_response_created("resp-1"), + responses::ev_function_call_with_namespace( + call_id, + "mcp__reauth", + "calendar_list_events", + "{}", + ), + responses::ev_completed("resp-1"), + ]), + responses::sse(vec![ + responses::ev_response_created("resp-2"), + responses::ev_assistant_message("msg-1", "Please reconnect the MCP server."), + responses::ev_completed("resp-2"), + ]), + ], + ) + .await; + let server_config: McpServerConfig = serde_json::from_value(json!({ + "url": format!("{}/api/codex/ps/mcp", http_server.chatgpt_base_url), + "environment_id": DEFAULT_MCP_SERVER_ENVIRONMENT_ID, + }))?; + let fixture = test_codex() + .with_config(move |config| { + config + .mcp_servers + .set([("reauth".to_string(), server_config)].into()) + .expect("test config should allow the MCP server"); + }) + // The mock MCP endpoint stays on the host when the executor is remote. + .build_with_remote_and_local_env(&responses_server) + .await?; + wait_for_mcp_server(&fixture.codex, "reauth").await?; + fixture + .codex + .start_or_steer_turn(read_only_user_turn(&fixture, "List calendar events.")) + .await?; + + let mut end_results = Vec::new(); + let mut completed_results = Vec::new(); + wait_for_event(&fixture.codex, |event| { + match event { + EventMsg::McpToolCallEnd(event) if event.call_id == call_id => { + end_results.push(event.result.clone()); + } + EventMsg::ItemCompleted(event) => { + if let TurnItem::McpToolCall(item) = &event.item + && item.id == call_id + { + completed_results.push((item.status, item.result.clone(), item.error.clone())); + } + } + _ => {} + } + matches!(event, EventMsg::TurnComplete(_)) + }) + .await; + + let expected = CallToolResult { + content: vec![json!({"type": "text", "text": "Authentication required"})], + structured_content: None, + is_error: Some(true), + meta: Some(json!({ + "mcp/www_authenticate": [format!(r#"Basic realm="proxy, login", {challenge}"#)], + })), + }; + assert_eq!(end_results, vec![Ok(expected.clone())]); + assert_eq!( + completed_results, + vec![(McpToolCallStatus::Failed, Some(expected), None)] + ); + assert_eq!(model_requests.requests().len(), 2); + mcp_server.verify().await; + fixture.codex.shutdown_and_wait().await?; + Ok(()) +} + #[test_case(ConfigRefreshPath::Runtime; "runtime configuration refresh")] #[test_case(ConfigRefreshPath::Mcp; "MCP configuration refresh")] #[tokio::test(flavor = "multi_thread", worker_threads = 2)] diff --git a/codex-rs/rmcp-client/src/http_client_adapter.rs b/codex-rs/rmcp-client/src/http_client_adapter.rs index 0371341aaa..fee686286b 100644 --- a/codex-rs/rmcp-client/src/http_client_adapter.rs +++ b/codex-rs/rmcp-client/src/http_client_adapter.rs @@ -275,12 +275,19 @@ impl StreamableHttpClient for StreamableHttpClientAdapter { StreamableHttpClientAdapterError::SessionExpired404, )); } - if response.status == StatusCode::UNAUTHORIZED.as_u16() - && let Some(header) = response_header(&response.headers, WWW_AUTHENTICATE) - { - return Err(StreamableHttpError::AuthRequired(AuthRequiredError::new( - header, - ))); + if response.status == StatusCode::UNAUTHORIZED.as_u16() { + let challenges = response + .headers + .iter() + .filter(|header| header.name.eq_ignore_ascii_case(WWW_AUTHENTICATE.as_str())) + .map(|header| header.value.as_str()) + .collect::>(); + if !challenges.is_empty() { + // RFC 9110 allows combining these list-based fields; keep challenges after the first. + return Err(StreamableHttpError::AuthRequired(AuthRequiredError::new( + challenges.join(", "), + ))); + } } if response.status == StatusCode::FORBIDDEN.as_u16() && let Some(challenge) = insufficient_scope_challenge(&response.headers) diff --git a/codex-rs/rmcp-client/src/rmcp_client.rs b/codex-rs/rmcp-client/src/rmcp_client.rs index 36cc5e88d9..31998b31b4 100644 --- a/codex-rs/rmcp-client/src/rmcp_client.rs +++ b/codex-rs/rmcp-client/src/rmcp_client.rs @@ -29,6 +29,7 @@ use rmcp::model::CallToolRequestParams; use rmcp::model::CallToolResult; use rmcp::model::ClientNotification; use rmcp::model::ClientRequest; +use rmcp::model::ContentBlock; use rmcp::model::CustomNotification; use rmcp::model::CustomRequest; use rmcp::model::ElicitRequestParams; @@ -39,6 +40,7 @@ use rmcp::model::InitializeRequestParams; use rmcp::model::ListResourceTemplatesResult; use rmcp::model::ListResourcesResult; use rmcp::model::ListToolsResult; +use rmcp::model::MetaObject; use rmcp::model::PaginatedRequestParams; use rmcp::model::ProtocolVersion; use rmcp::model::ReadResourceRequestParams; @@ -54,6 +56,7 @@ use rmcp::service::ClientServiceExt; use rmcp::service::RequestHandle; use rmcp::service::RoleClient; use rmcp::service::RunningService; +use rmcp::service::ServiceError; use rmcp::transport::AuthorizationManager; use rmcp::transport::StreamableHttpClientTransport; use rmcp::transport::auth::AuthClient; @@ -811,7 +814,7 @@ impl RmcpClient { let mut rmcp_params = CallToolRequestParams::new(name); rmcp_params.arguments = arguments; let requested_modern = self.protocol_mode == McpProtocolMode::V20260728; - let result = self + match self .run_service_operation("tools/call", timeout, move |service| { let mut rmcp_params = rmcp_params.clone(); let meta = meta.clone(); @@ -844,9 +847,36 @@ impl RmcpClient { } .boxed() }) - .await?; - self.persist_oauth_tokens().await; - Ok(result) + .await + { + Ok(result) => { + self.persist_oauth_tokens().await; + Ok(result) + } + Err(error) => { + let Some(ClientOperationError::Service(ServiceError::TransportSend(transport))) = + error.downcast_ref() + else { + return Err(error); + }; + let Some(StreamableHttpError::AuthRequired(challenge)) = + transport + .error + .downcast_ref::>() + else { + return Err(error); + }; + // The transport has already handled automatic refresh. Preserve the challenge + // for interactive login without replaying the rejected tool call. + let mut result = + CallToolResult::error(vec![ContentBlock::text("Authentication required")]); + result.meta = Some(MetaObject::from(serde_json::Map::from_iter([( + "mcp/www_authenticate".to_string(), + serde_json::json!([challenge.www_authenticate_header]), + )]))); + Ok(result) + } + } } pub async fn send_custom_notification( diff --git a/codex-rs/rmcp-client/tests/streamable_http_oauth_startup.rs b/codex-rs/rmcp-client/tests/streamable_http_oauth_startup.rs index 9b8162d077..e41986541e 100644 --- a/codex-rs/rmcp-client/tests/streamable_http_oauth_startup.rs +++ b/codex-rs/rmcp-client/tests/streamable_http_oauth_startup.rs @@ -60,6 +60,7 @@ const CHILD_HELPER_COMMAND_ENV: &str = "MCP_TEST_OAUTH_STARTUP_HELPER_COMMAND"; const CHILD_RESOURCE_API_KEY_ENV: &str = "MCP_TEST_OAUTH_STARTUP_RESOURCE_API_KEY"; const CHILD_STORED_ISSUER_ENV: &str = "MCP_TEST_OAUTH_STARTUP_STORED_ISSUER"; const CHILD_ACCESS_TOKEN_EXPIRY_ENV: &str = "MCP_TEST_OAUTH_STARTUP_ACCESS_TOKEN_EXPIRY"; +const CHILD_REFRESH_SUCCEEDS_ENV: &str = "MCP_TEST_REFRESH_SUCCEEDS"; const LEGACY_REFRESHABLE_SERVER_URL: &str = "https://legacy-refreshable.example/mcp"; const UNEXPIRED_SERVER_URL: &str = "https://unexpired.example/mcp"; const REFRESHABLE_SERVER_URL: &str = "https://refreshable.example/mcp"; @@ -78,6 +79,173 @@ enum IssuerMismatchAccessToken { Unexpired, } +#[tokio::test(flavor = "multi_thread", worker_threads = 1)] +async fn tool_call_preserves_challenge_only_after_silent_refresh_fails() -> anyhow::Result<()> { + for refresh_succeeds in [true, false] { + let server = MockServer::start().await; + let server_url = format!("{}/mcp", server.uri()); + Mock::given(method("GET")) + .and(path("/.well-known/oauth-authorization-server/mcp")) + .respond_with(ResponseTemplate::new(/*s*/ 200).set_body_json(json!({ + "issuer": server_url, + "authorization_endpoint": format!("{}/authorize", server.uri()), + "token_endpoint": format!("{}/token", server.uri()), + }))) + .mount(&server) + .await; + Mock::given(method("POST")) + .and(path("/token")) + .and(body_string_contains("grant_type=refresh_token")) + .and(body_string_contains(format!( + "refresh_token={REFRESH_TOKEN}" + ))) + .respond_with(if refresh_succeeds { + ResponseTemplate::new(/*s*/ 200).set_body_json(json!({ + "access_token": REFRESHED_ACCESS_TOKEN, + "token_type": "Bearer", + "expires_in": 7200, + "refresh_token": REFRESH_TOKEN, + })) + } else { + ResponseTemplate::new(/*s*/ 400).set_body_json(json!({"error": "invalid_grant"})) + }) + .expect(1) + .mount(&server) + .await; + Mock::given(method("POST")) + .and(path("/mcp")) + .respond_with(|request: &Request| { + let body: Value = request.body_json().unwrap(); + let result = match body["method"].as_str() { + Some("initialize") => json!({ + "protocolVersion": body["params"]["protocolVersion"], + "capabilities": {}, + "serverInfo": {"name": "oauth-tool-call-test", "version": "1"}, + }), + Some("notifications/initialized") => { + return ResponseTemplate::new(/*s*/ 202); + } + Some("tools/call") => { + if request.headers.get("authorization").unwrap() + != format!("Bearer {REFRESHED_ACCESS_TOKEN}").as_str() + { + return ResponseTemplate::new(/*s*/ 401).insert_header( + "www-authenticate", + r#"Bearer error="invalid_token""#, + ); + } + json!({"content": [{"type": "text", "text": "refreshed"}]}) + } + _ => return ResponseTemplate::new(/*s*/ 400), + }; + ResponseTemplate::new(/*s*/ 200).set_body_json(json!({ + "jsonrpc": "2.0", "id": body["id"], "result": result, + })) + }) + .mount(&server) + .await; + + // The child owns its credential store; the parallel test runner's environment is unchanged. + let codex_home = TempDir::new()?; + let status = Command::new(std::env::current_exe()?) + .args([ + "oauth_tool_call_child", + "--exact", + "--ignored", + "--nocapture", + ]) + .env("CODEX_HOME", codex_home.path()) + .env(CHILD_SERVER_URL_ENV, server_url) + .env(CHILD_REFRESH_SUCCEEDS_ENV, refresh_succeeds.to_string()) + .status() + .await?; + assert!(status.success(), "OAuth tool call child failed: {status}"); + server.verify().await; + let tool_calls = server + .received_requests() + .await + .unwrap() + .into_iter() + .filter(|request| { + request + .body_json::() + .ok() + .is_some_and(|body| body["method"] == "tools/call") + }) + .count(); + assert_eq!(tool_calls, if refresh_succeeds { 2 } else { 1 }); + } + Ok(()) +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 1)] +#[ignore = "spawned by tool_call_preserves_challenge_only_after_silent_refresh_fails"] +async fn oauth_tool_call_child() -> anyhow::Result<()> { + let server_url = std::env::var(CHILD_SERVER_URL_ENV)?; + let refresh_succeeds = std::env::var(CHILD_REFRESH_SUCCEEDS_ENV)? == "true"; + let mut response = OAuthTokenResponse::new( + AccessToken::new(EXPIRED_ACCESS_TOKEN.to_string()), + BasicTokenType::Bearer, + VendorExtraTokenFields::default(), + ); + response.set_refresh_token(Some(RefreshToken::new(REFRESH_TOKEN.to_string()))); + response.set_expires_in(Some(&Duration::from_secs(/*secs*/ 7200))); + save_oauth_tokens( + SERVER_NAME, + &StoredOAuthTokens { + server_name: SERVER_NAME.to_string(), + url: server_url.clone(), + issuer: Some(server_url.clone()), + client_id: "test-client-id".to_string(), + token_response: WrappedOAuthTokenResponse(response), + expires_at: Some( + (SystemTime::now().duration_since(UNIX_EPOCH)?.as_millis() + 7_200_000) as u64, + ), + }, + OAuthCredentialsStoreMode::File, + AuthKeyringBackendKind::default(), + ) + .await?; + let client = RmcpClient::new_streamable_http_client( + SERVER_NAME, + &server_url, + /*bearer_token*/ None, + /*http_headers*/ None, + /*env_http_headers*/ None, + OAuthCredentialsStoreMode::File, + AuthKeyringBackendKind::default(), + Environment::default_for_tests().get_http_client(), + /*auth_provider*/ None, + ) + .await?; + initialize_client(&client).await?; + let result = client + .call_tool( + "probe".to_string(), + /*arguments*/ None, + /*meta*/ None, + Some(Duration::from_secs(/*secs*/ 5)), + ) + .await?; + if refresh_succeeds { + assert_eq!( + serde_json::to_value(result)?, + json!({ + "content": [{"type": "text", "text": "refreshed"}], + }) + ); + } else { + assert_eq!(result.is_error, Some(true)); + assert_eq!( + serde_json::to_value(result.meta)?, + json!({ + "mcp/www_authenticate": [r#"Bearer error="invalid_token""#], + }) + ); + } + Ok(()) +} + #[tokio::test(flavor = "multi_thread", worker_threads = 1)] async fn refreshes_expired_persisted_token_before_initialize() -> anyhow::Result<()> { assert_expired_token_refresh( diff --git a/codex-rs/rmcp-client/tests/streamable_http_recovery.rs b/codex-rs/rmcp-client/tests/streamable_http_recovery.rs index 29d2404ede..817587a9b7 100644 --- a/codex-rs/rmcp-client/tests/streamable_http_recovery.rs +++ b/codex-rs/rmcp-client/tests/streamable_http_recovery.rs @@ -14,7 +14,11 @@ use codex_exec_server::HttpResponseBodyStream; use futures::FutureExt as _; use futures::future::BoxFuture; use pretty_assertions::assert_eq; +use rmcp::model::CallToolResult; +use rmcp::model::ContentBlock; +use rmcp::model::MetaObject; use serde_json::Value; +use serde_json::json; use streamable_http_test_support::arm_initialize_post_failure; use streamable_http_test_support::arm_initialize_post_json_rpc_failure; @@ -301,6 +305,42 @@ async fn streamable_http_401_does_not_trigger_recovery() -> anyhow::Result<()> { Ok(()) } +#[tokio::test(flavor = "multi_thread", worker_threads = 1)] +async fn streamable_http_401_challenge_is_a_tool_error_without_replay() -> anyhow::Result<()> { + let challenge = r#"Bearer error="invalid_token", resource_metadata="https://example.com/.well-known/oauth-protected-resource""#; + for challenges in [ + vec![challenge], + vec![r#"Basic realm="proxy, login""#, challenge], + ] { + let (_server, base_url) = spawn_streamable_http_server().await?; + let client = create_client(&base_url).await?; + + arm_session_post_failure( + &base_url, + /*status*/ 401, + /*remaining*/ 1, + &challenges, + ) + .await?; + + let result = call_echo_tool(&client, "rejected").await?; + let mut expected = + CallToolResult::error(vec![ContentBlock::text("Authentication required")]); + expected.meta = Some(MetaObject::from(serde_json::Map::from_iter([( + "mcp/www_authenticate".to_string(), + json!([challenges.join(", ")]), + )]))); + assert_eq!(result, expected); + + // A retry inside the failed call would consume the single rejection and return success. + assert_eq!( + call_echo_tool(&client, "next-user-call").await?, + expected_echo_result("next-user-call"), + ); + } + Ok(()) +} + #[tokio::test(flavor = "multi_thread", worker_threads = 1)] async fn streamable_http_403_scope_challenge_returns_insufficient_scope() -> anyhow::Result<()> { let (_server, base_url) = spawn_streamable_http_server().await?;