Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Retire rejected MCP OAuth refresh tokens (#54079)

Matthew Zeng4ae6016a9388
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 6f7d1a5618..c0207b95ee 100644
--- a/codex-rs/core/tests/suite/mcp_oauth_refresh_tests.rs
+++ b/codex-rs/core/tests/suite/mcp_oauth_refresh_tests.rs
@@ -8,12 +8,16 @@ use std::sync::Arc;
use codex_config::DEFAULT_MCP_SERVER_ENVIRONMENT_ID;
use codex_config::McpServerConfig;
+use codex_config::types::AuthKeyringBackendKind;
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 codex_protocol::protocol::McpStartupFailureReason;
+use codex_protocol::protocol::McpStartupStatus;
+use codex_rmcp_client::stored_oauth_credentials;
use core_test_support::apps_test_server::AppsTestServer;
use core_test_support::responses;
use core_test_support::skip_if_no_network;
@@ -27,6 +31,7 @@ use test_case::test_case;
use wiremock::Mock;
use wiremock::ResponseTemplate;
use wiremock::matchers::body_partial_json;
+use wiremock::matchers::body_string_contains;
use wiremock::matchers::method;
use wiremock::matchers::path;
@@ -35,6 +40,119 @@ enum ConfigRefreshPath {
Mcp,
}
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+#[serial(codex_home)]
+async fn rejected_refresh_requires_reauthentication_after_runtime_rebuild() -> 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 server_name = "rejected_refresh";
+ let server_url = format!("{}/api/codex/ps/mcp", http_server.chatgpt_base_url);
+ Mock::given(method("GET"))
+ .and(path(
+ "/.well-known/oauth-authorization-server/api/codex/ps/mcp",
+ ))
+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({
+ "issuer": server_url,
+ "authorization_endpoint": format!("{}/oauth/authorize", mcp_server.uri()),
+ "token_endpoint": format!("{}/oauth/token", mcp_server.uri()),
+ })))
+ .mount(&mcp_server)
+ .await;
+ Mock::given(method("POST"))
+ .and(path("/oauth/token"))
+ .and(body_string_contains(
+ "refresh_token=synthetic-refresh-token",
+ ))
+ .respond_with(ResponseTemplate::new(400).set_body_json(json!({"error": "invalid_grant"})))
+ .expect(1)
+ .mount(&mcp_server)
+ .await;
+ let server_config: McpServerConfig = serde_json::from_value(json!({
+ "url": server_url,
+ "environment_id": DEFAULT_MCP_SERVER_ENVIRONMENT_ID,
+ }))?;
+ let credential_name = server_config.oauth_credential_name(server_name);
+ let home = Arc::new(tempfile::tempdir()?);
+ let _codex_home_guard = EnvVarGuard::set("CODEX_HOME", home.path().as_os_str());
+ write_fallback_oauth_tokens(
+ credential_name.as_ref(),
+ &server_url,
+ "test-client-id",
+ "synthetic-access-token",
+ "synthetic-refresh-token",
+ OAuthCredentialExpiry::Expired,
+ )
+ .await?;
+ // Another binary may have saved the same credential under a different computed key.
+ let credentials_path = home.path().join(".credentials.json");
+ let saved: serde_json::Map<String, serde_json::Value> =
+ serde_json::from_slice(&std::fs::read(&credentials_path)?)?;
+ let entry = saved.into_values().next().expect("seeded file entry");
+ std::fs::write(
+ &credentials_path,
+ serde_json::to_vec(&json!({"!legacy-key": entry}))?,
+ )?;
+ let mut expected = stored_oauth_credentials(
+ credential_name.as_ref(),
+ &server_url,
+ OAuthCredentialsStoreMode::File,
+ AuthKeyringBackendKind::default(),
+ )?
+ .expect("seeded credentials");
+ expected.token_response.0.set_refresh_token(None);
+
+ // Rebuilding the agent must observe durable retirement, not retry the rejected token.
+ for _ in 0..2 {
+ let server_config = server_config.clone();
+ let fixture = test_codex()
+ .with_home(Arc::clone(&home))
+ .with_config(move |config| {
+ config
+ .features
+ .enable(Feature::McpOAuthRefreshCoordination)
+ .expect("test config should allow coordinated OAuth refresh");
+ config.mcp_oauth_credentials_store_mode = OAuthCredentialsStoreMode::File;
+ config
+ .mcp_servers
+ .set([(server_name.to_string(), server_config)].into())
+ .expect("test config should allow the OAuth server");
+ })
+ // The OAuth provider stays on the host when the executor is remote.
+ .build_with_remote_and_local_env(&responses_server)
+ .await?;
+ let mut failures = Vec::new();
+ wait_for_event(&fixture.codex, |event| {
+ if let EventMsg::McpStartupUpdate(update) = event
+ && update.server == server_name
+ && let McpStartupStatus::Failed { reason, .. } = &update.status
+ {
+ failures.push(*reason);
+ }
+ matches!(event, EventMsg::McpStartupComplete(_))
+ })
+ .await;
+ assert_eq!(
+ failures,
+ vec![Some(McpStartupFailureReason::ReauthenticationRequired)]
+ );
+ assert_eq!(
+ stored_oauth_credentials(
+ credential_name.as_ref(),
+ &server_url,
+ OAuthCredentialsStoreMode::File,
+ AuthKeyringBackendKind::default(),
+ )?,
+ Some(expected.clone()),
+ );
+ fixture.codex.shutdown_and_wait().await?;
+ }
+ mcp_server.verify().await;
+ Ok(())
+}
+
#[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(()));
diff --git a/codex-rs/rmcp-client/src/oauth.rs b/codex-rs/rmcp-client/src/oauth.rs
index a0773a768e..f80cd6eb47 100644
--- a/codex-rs/rmcp-client/src/oauth.rs
+++ b/codex-rs/rmcp-client/src/oauth.rs
@@ -881,12 +881,14 @@ struct FallbackTokenEntry {
fn load_oauth_tokens_from_file(server_name: &str, url: &str) -> Result<Option<StoredOAuthTokens>> {
let _store_lock = OAuthStoreLock::acquire_for_read(OAuthStore::File)?;
load_oauth_tokens_from_file_with_lock_held(server_name, url)
+ .map(|entry| entry.map(|(_, tokens)| tokens))
}
+/// Retains the matched entry's key. The caller must hold the File aggregate-store lock.
fn load_oauth_tokens_from_file_with_lock_held(
server_name: &str,
url: &str,
-) -> Result<Option<StoredOAuthTokens>> {
+) -> Result<Option<(String, StoredOAuthTokens)>> {
let Some(store) = read_fallback_file_unlocked()? else {
return Ok(None);
};
@@ -939,7 +941,7 @@ fn load_oauth_tokens_from_file_with_lock_held(
};
refresh_expires_in_from_timestamp(&mut stored);
- return Ok(Some(stored));
+ return Ok(Some((stored_key.clone(), stored)));
}
Ok(None)
diff --git a/codex-rs/rmcp-client/src/oauth/credential_store.rs b/codex-rs/rmcp-client/src/oauth/credential_store.rs
index c191e6936a..d7e6bc5e90 100644
--- a/codex-rs/rmcp-client/src/oauth/credential_store.rs
+++ b/codex-rs/rmcp-client/src/oauth/credential_store.rs
@@ -12,6 +12,9 @@
//! so replacement logins still cause a rebuild.
//! Synchronous store operations run off the Tokio workers so caller deadlines remain pollable.
//! Blocking mutations retain the caller's transaction guard even if their await is cancelled.
+//! Definitive refresh rejection removes only refresh capability, retaining the existing record
+//! format and access token. Shared direct-keyring entries are retired only in this runtime until
+//! cross-home locking exists. A local rejected snapshot also prevents reuse after a write failure.
use std::sync::Arc;
use std::sync::Weak;
@@ -19,6 +22,7 @@ use std::sync::Weak;
use anyhow::Context;
use anyhow::Result;
use codex_config::McpServerOAuthConfig;
+use codex_config::types::AuthKeyringBackendKind;
use codex_keyring_store::DefaultKeyringStore;
use codex_keyring_store::KeyringStore;
use futures::future::BoxFuture;
@@ -42,6 +46,7 @@ use super::WrappedOAuthTokenResponse;
use super::normalized_oauth_credentials;
use super::refresh_expires_in_from_timestamp;
use super::refresh_transaction::REFRESH_REQUEST_TIMEOUT;
+use super::resolved_store::Backend;
use super::token_needs_refresh;
use super::validate_refresh_token_issuer;
@@ -60,6 +65,7 @@ struct OAuthCredentialStoreInner<K> {
keyring: K,
oauth_config: Option<McpServerOAuthConfig>,
last_credentials: Mutex<Option<StoredOAuthTokens>>,
+ rejected_credentials: Mutex<Option<StoredOAuthTokens>>,
refresh_guard: Mutex<Weak<RefreshCredentialLock>>,
}
@@ -80,6 +86,7 @@ impl<K: KeyringStore + Clone + 'static> OAuthCredentialStore<K> {
keyring,
oauth_config,
last_credentials: Mutex::new(Some(tokens)),
+ rejected_credentials: Mutex::new(None),
refresh_guard: Mutex::new(Weak::new()),
}),
held_refresh_guard: None,
@@ -146,6 +153,11 @@ impl<K: KeyringStore + Clone + 'static> OAuthCredentialStore<K> {
.map_err(credential_store_error)?
.map_err(credential_store_error)?
.ok_or(AuthError::AuthorizationRequired)?;
+ if normalized_oauth_credentials(Some(&tokens))
+ == *self.inner.rejected_credentials.lock().await
+ {
+ return Err(AuthError::AuthorizationRequired);
+ }
self.validate_connection(&tokens)?;
*self.inner.last_credentials.lock().await = Some(tokens);
*self.inner.refresh_guard.lock().await = Arc::downgrade(&guard);
@@ -288,6 +300,102 @@ impl<K: KeyringStore + Clone + 'static> CredentialStore for OAuthCredentialStore
})
}
+ fn on_refresh_token_rejected<'life0, 'life1, 'async_trait>(
+ &'life0 self,
+ credentials: &'life1 StoredCredentials,
+ ) -> BoxFuture<'async_trait, Result<(), AuthError>>
+ where
+ 'life0: 'async_trait,
+ 'life1: 'async_trait,
+ Self: 'async_trait,
+ {
+ Box::pin(async move {
+ let guard = self
+ .inner
+ .refresh_guard
+ .lock()
+ .await
+ .upgrade()
+ .context("OAuth credential mutation requires an active refresh guard")
+ .map_err(credential_store_error)?;
+ let credentials = credentials.clone();
+ let inner = Arc::clone(&self.inner);
+ // Own both cache retirement and persistence: cancellation must not leave a reusable
+ // cached token after the durable mutation, or release the guard before either finishes.
+ tokio::spawn(async move {
+ let Some(expected) =
+ normalized_oauth_credentials(inner.last_credentials.lock().await.as_ref())
+ else {
+ return Ok(());
+ };
+ let mut attempted = credentials
+ .token_response
+ .ok_or(AuthError::AuthorizationRequired)?;
+ attempted.set_expires_in(None);
+ if credentials.client_id != expected.client_id
+ || credentials.issuer != expected.issuer
+ || WrappedOAuthTokenResponse(attempted) != expected.token_response
+ {
+ return Ok(());
+ }
+ *inner.rejected_credentials.lock().await = Some(expected.clone());
+ let mut retired = expected.clone();
+ retired.token_response.0.set_refresh_token(None);
+ *inner.last_credentials.lock().await = Some(retired.clone());
+ if inner.store.backend == Backend::Keyring(AuthKeyringBackendKind::Direct)
+ && !inner.server_name.starts_with("ema-idp:")
+ {
+ // Ordinary direct-keyring entries are shared across CODEX_HOMEs, but their
+ // refresh locks are not. Do not risk overwriting another home's newer login.
+ // Enterprise entries include the home in their key and remain protected.
+ warn!(
+ server_name = %inner.server_name,
+ "rejected MCP OAuth refresh token retired only in this connection; shared direct-keyring storage lacks cross-home coordination"
+ );
+ return Ok(());
+ }
+ let store_inner = Arc::clone(&inner);
+ let result = tokio::task::spawn_blocking(move || -> Result<()> {
+ let _guard = guard;
+ // The aggregate-store transaction also excludes legacy persistors that
+ // do not participate in the per-credential refresh guard.
+ store_inner.store.retire_refresh_token_if_matches(
+ &store_inner.keyring,
+ &store_inner.server_name,
+ &store_inner.url,
+ &expected,
+ )
+ })
+ .await
+ .context("OAuth rejected credential mutation task failed")
+ .map_err(credential_store_error)
+ .and_then(|result| result.map_err(credential_store_error));
+ // This task can outlive its caller, so report failures here without logging
+ // backend error text that may contain credential material.
+ if result.is_err() {
+ warn!(
+ server_name = %inner.server_name,
+ "failed to persist rejected MCP OAuth refresh token retirement"
+ );
+ }
+ result
+ })
+ .await
+ // RMCP logs callback errors. Neither backend diagnostics nor task panic text
+ // may cross that boundary, even though the owned task reports failure safely.
+ .unwrap_or_else(|_| {
+ Err(AuthError::CredentialStoreError(
+ "OAuth rejection task failed".to_string(),
+ ))
+ })
+ .map_err(|_| {
+ AuthError::CredentialStoreError(
+ "failed to retire rejected MCP OAuth refresh token".to_string(),
+ )
+ })
+ })
+ }
+
fn acquire_refresh_guard<'life0, 'async_trait>(
&'life0 self,
) -> BoxFuture<'async_trait, Result<Option<CredentialRefreshGuard>, AuthError>>
diff --git a/codex-rs/rmcp-client/src/oauth/resolved_store.rs b/codex-rs/rmcp-client/src/oauth/resolved_store.rs
index bdd29b58f9..f141c9cd74 100644
--- a/codex-rs/rmcp-client/src/oauth/resolved_store.rs
+++ b/codex-rs/rmcp-client/src/oauth/resolved_store.rs
@@ -24,8 +24,13 @@ use super::load_oauth_tokens_from_file;
use super::load_oauth_tokens_from_file_with_lock_held;
use super::load_oauth_tokens_from_keyring;
use super::load_oauth_tokens_from_secrets_keyring_with_lock_held;
+use super::normalized_oauth_credentials;
+use super::read_fallback_file_unlocked;
+use super::save_oauth_tokens_to_direct_keyring;
use super::save_oauth_tokens_to_file;
+use super::save_oauth_tokens_to_secrets_keyring_with_lock_held;
use super::save_oauth_tokens_with_keyring;
+use super::write_fallback_file;
/// Concrete credential store resolved for one MCP OAuth client lifecycle.
///
@@ -129,6 +134,7 @@ impl ResolvedOAuthCredentialStore {
Backend::File => {
let _store_lock = OAuthStoreLock::try_acquire_for_read(OAuthStore::File)?;
load_oauth_tokens_from_file_with_lock_held(server_name, url)
+ .map(|entry| entry.map(|(_, tokens)| tokens))
.context("failed to probe OAuth tokens from resolved file storage")
}
Backend::Keyring(AuthKeyringBackendKind::Direct) => {
@@ -192,6 +198,105 @@ impl ResolvedOAuthCredentialStore {
result
}
+ /// Retires a rejected refresh token only while its durable snapshot still matches.
+ ///
+ /// File and Secrets keep one exclusive aggregate lock across the comparison and write,
+ /// including against legacy writers that do not take the caller's refresh guard. Direct
+ /// keyring callers must hold that guard and use a home-scoped enterprise credential.
+ pub(crate) fn retire_refresh_token_if_matches<K: KeyringStore + Clone + 'static>(
+ self,
+ keyring_store: &K,
+ server_name: &str,
+ url: &str,
+ expected: &StoredOAuthTokens,
+ ) -> Result<()> {
+ let mut observation = telemetry::resolved(self, Operation::Load);
+ let mut _store_lock = None;
+ let mut file_key = None;
+ let current = (|| -> Result<_> {
+ _store_lock = match self.backend {
+ Backend::File => Some(OAuthStoreLock::acquire_for_write(OAuthStore::File)?),
+ Backend::Keyring(AuthKeyringBackendKind::Secrets) => {
+ Some(OAuthStoreLock::acquire_for_write(OAuthStore::Secrets)?)
+ }
+ Backend::Keyring(AuthKeyringBackendKind::Direct) => None,
+ };
+ match self.backend {
+ Backend::File => Ok(
+ load_oauth_tokens_from_file_with_lock_held(server_name, url)?.map(
+ |(key, tokens)| {
+ file_key = Some(key);
+ tokens
+ },
+ ),
+ ),
+ Backend::Keyring(AuthKeyringBackendKind::Secrets) => {
+ load_oauth_tokens_from_secrets_keyring_with_lock_held(
+ keyring_store,
+ server_name,
+ url,
+ )
+ .map_err(anyhow::Error::from)
+ }
+ Backend::Keyring(AuthKeyringBackendKind::Direct) => load_oauth_tokens_from_keyring(
+ keyring_store,
+ AuthKeyringBackendKind::Direct,
+ server_name,
+ url,
+ )
+ .map_err(anyhow::Error::from),
+ }
+ })();
+ observation.record_load_attempt(telemetry::store(self), &current);
+ if matches!(self.backend, Backend::Keyring(_))
+ && let Err(error) = &current
+ {
+ telemetry::record_secure_error(&mut observation, error.as_ref());
+ }
+ drop(observation);
+ let current = current?;
+ if normalized_oauth_credentials(current.as_ref())
+ != normalized_oauth_credentials(Some(expected))
+ {
+ return Ok(());
+ }
+ let mut retired = expected.clone();
+ retired.token_response.0.set_refresh_token(None);
+ let mut observation = telemetry::resolved(self, Operation::Save);
+ let result = match self.backend {
+ Backend::File => {
+ let mut store = read_fallback_file_unlocked()?.context("OAuth file disappeared")?;
+ // Reuse the key we compared: another binary may compute a different key.
+ let key = file_key.context("missing loaded OAuth file key")?;
+ store
+ .get_mut(&key)
+ .context("OAuth file entry disappeared")?
+ .refresh_token = None;
+ write_fallback_file(&store)
+ }
+ Backend::Keyring(AuthKeyringBackendKind::Secrets) => {
+ let serialized =
+ serde_json::to_string(&retired).context("failed to serialize OAuth tokens")?;
+ save_oauth_tokens_to_secrets_keyring_with_lock_held(
+ keyring_store,
+ server_name,
+ &retired,
+ &serialized,
+ )
+ }
+ Backend::Keyring(AuthKeyringBackendKind::Direct) => {
+ save_oauth_tokens_to_direct_keyring(keyring_store, server_name, &retired)
+ }
+ };
+ observation.record_save_attempt(telemetry::store(self), &result);
+ if matches!(self.backend, Backend::Keyring(_))
+ && let Err(error) = &result
+ {
+ telemetry::record_secure_error(&mut observation, error.as_ref());
+ }
+ result
+ }
+
/// Deletes credentials only from this already-resolved authority.
pub(crate) fn delete<K: KeyringStore + Clone + 'static>(
self,
diff --git a/codex-rs/rmcp-client/src/oauth/tests/credential_store_tests.rs b/codex-rs/rmcp-client/src/oauth/tests/credential_store_tests.rs
index 575ed835cd..02dc54a270 100644
--- a/codex-rs/rmcp-client/src/oauth/tests/credential_store_tests.rs
+++ b/codex-rs/rmcp-client/src/oauth/tests/credential_store_tests.rs
@@ -25,6 +25,7 @@ use crate::oauth::compute_store_key;
use crate::oauth::load_oauth_tokens_from_file;
use crate::oauth::normalized_oauth_credentials;
use crate::oauth::save_oauth_tokens_to_file;
+use crate::oauth::save_oauth_tokens_to_file_with_lock_held;
use crate::oauth::store_lock::OAuthStore;
use crate::oauth::store_lock::OAuthStoreLock;
@@ -289,3 +290,98 @@ async fn storage_roundtrip_preserves_absolute_and_unknown_expiry() -> Result<()>
}
Ok(())
}
+
+#[tokio::test(flavor = "current_thread")]
+async fn cancelled_rejection_retains_guard_and_preserves_replacement() -> Result<()> {
+ let _env = TempCodexHome::new();
+ let initial = sample_tokens();
+ save_oauth_tokens_to_file(&initial)?;
+ let store = OAuthCredentialStore::new(
+ initial.clone(),
+ ResolvedOAuthCredentialStore::file(),
+ MockKeyringStore::default(),
+ /*oauth_config*/ None,
+ );
+ let credentials = store.load().await?.unwrap();
+ assert!(matches!(
+ store.on_refresh_token_rejected(&credentials).await,
+ Err(AuthError::CredentialStoreError(error)) if error.contains("active refresh guard")
+ ));
+ let guard = store.acquire_transaction_guard().await?;
+ let aggregate_lock = OAuthStoreLock::acquire_for_write(OAuthStore::File)?;
+ let mut mutation = store.on_refresh_token_rejected(&credentials);
+ assert!(futures::poll!(&mut mutation).is_pending());
+ drop(mutation);
+ drop(guard);
+ let mut contender = Box::pin(RefreshCredentialLock::acquire_for_server(
+ &initial.server_name,
+ &initial.url,
+ ));
+ assert!(futures::poll!(&mut contender).is_pending());
+ let mut replacement = initial.clone();
+ replacement
+ .token_response
+ .0
+ .set_refresh_token(Some(RefreshToken::new("replacement-refresh".into())));
+ // A legacy writer may finish while retirement is waiting for the aggregate lock.
+ save_oauth_tokens_to_file_with_lock_held(&replacement)?;
+ drop(aggregate_lock);
+ let _guard = tokio::time::timeout(Duration::from_secs(/*secs*/ 5), contender).await??;
+ let mut expected = initial.clone();
+ expected.token_response.0.set_refresh_token(None);
+ let durable = load_oauth_tokens_from_file(&initial.server_name, &initial.url)?.unwrap();
+ assert_tokens_match_without_expiry(&durable, &replacement);
+ assert_eq!(
+ store.stored_credentials().await,
+ normalized_oauth_credentials(Some(&expected))
+ );
+ Ok(())
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn keyring_rejection_respects_credential_scope() -> Result<()> {
+ for kind in [
+ AuthKeyringBackendKind::Direct,
+ AuthKeyringBackendKind::Secrets,
+ ] {
+ let _env = TempCodexHome::new();
+ let initial = sample_tokens();
+ let keyring = MockKeyringStore::default();
+ let authority = ResolvedOAuthCredentialStore::keyring(kind);
+ authority.save(&keyring, &initial.server_name, &initial)?;
+ let store = OAuthCredentialStore::new(
+ initial.clone(),
+ authority,
+ keyring.clone(),
+ /*oauth_config*/ None,
+ );
+ let guard = store.acquire_transaction_guard().await?;
+ store
+ .on_refresh_token_rejected(&store.load().await?.unwrap())
+ .await?;
+ let mut retired = initial.clone();
+ retired.token_response.0.set_refresh_token(None);
+ let expected_durable = match kind {
+ AuthKeyringBackendKind::Direct => &initial,
+ AuthKeyringBackendKind::Secrets => &retired,
+ };
+ assert_tokens_match_without_expiry(
+ &authority
+ .load(&keyring, &initial.server_name, &initial.url)?
+ .unwrap(),
+ expected_durable,
+ );
+ assert_eq!(
+ store.stored_credentials().await,
+ normalized_oauth_credentials(Some(&retired))
+ );
+ drop(guard);
+ if kind == AuthKeyringBackendKind::Direct {
+ assert!(matches!(
+ store.acquire_transaction_guard().await,
+ Err(AuthError::AuthorizationRequired)
+ ));
+ }
+ }
+ Ok(())
+}
diff --git a/codex-rs/rmcp-client/src/oauth/tests/persistor_tests.rs b/codex-rs/rmcp-client/src/oauth/tests/persistor_tests.rs
index e938bcec48..a8b2eb499e 100644
--- a/codex-rs/rmcp-client/src/oauth/tests/persistor_tests.rs
+++ b/codex-rs/rmcp-client/src/oauth/tests/persistor_tests.rs
@@ -29,6 +29,7 @@ use tracing::Subscriber;
use tracing::span::Attributes;
use tracing::span::Record;
use tracing::subscriber::Interest;
+use tracing_test::traced_test;
use wiremock::Mock;
use wiremock::MockServer;
use wiremock::ResponseTemplate;
@@ -53,6 +54,7 @@ use crate::oauth::compute_expires_at_millis;
use crate::oauth::compute_store_key;
use crate::oauth::delete_oauth_tokens;
use crate::oauth::load_oauth_tokens_from_file;
+use crate::oauth::normalized_oauth_credentials;
use crate::oauth::refresh_lock::RefreshCredentialLock;
use crate::oauth::save_oauth_tokens;
use crate::oauth::save_oauth_tokens_to_file;
@@ -465,6 +467,58 @@ async fn rejected_refresh_token_requires_reauthorization() -> Result<()> {
Ok(())
}
+#[tokio::test(flavor = "current_thread")]
+#[traced_test]
+async fn rejection_callback_failure_keeps_reauthentication_and_redacts_diagnostics() -> Result<()> {
+ let (env, server, initial) = test_context().await?;
+ save_oauth_tokens_to_file(&initial)?;
+ let (auth_manager, store) = coordinated_manager_for(&initial).await?;
+ let credentials_path = env.path().join(".credentials.json");
+ Mock::given(method("POST"))
+ .and(path("/oauth/token"))
+ .respond_with(move |_: &wiremock::Request| {
+ // The provider rejects after the guarded reread. Make retirement fail with a
+ // deserialization error containing a sentinel credential value.
+ std::fs::write(
+ &credentials_path,
+ r#"{"invalid-entry":"credential-backend-secret"}"#,
+ )
+ .expect("corrupt the synthetic credential store");
+ ResponseTemplate::new(400).set_body_json(serde_json::json!({"error": "invalid_grant"}))
+ })
+ .expect(1)
+ .mount(&server)
+ .await;
+ let error = OAuthRuntime::Coordinated {
+ auth_manager,
+ store: store.clone(),
+ }
+ .refresh_if_needed()
+ .await
+ .expect_err("rejected credentials must still require reauthentication");
+ assert!(is_authentication_required_error(&error));
+ let mut expected = initial.clone();
+ expected.token_response.0.set_refresh_token(None);
+ assert_eq!(
+ store.stored_credentials().await,
+ normalized_oauth_credentials(Some(&expected))
+ );
+ assert!(logs_contain(
+ "failed to persist rejected MCP OAuth refresh token retirement"
+ ));
+ assert!(logs_contain("Failed to handle rejected refresh token"));
+ assert!(!logs_contain("credential-backend-secret"));
+ // A failed durable retirement must not let this runtime reuse the same credential.
+ std::fs::remove_file(env.path().join(".credentials.json"))?;
+ save_oauth_tokens_to_file(&initial)?;
+ assert!(matches!(
+ store.acquire_transaction_guard().await,
+ Err(AuthError::AuthorizationRequired)
+ ));
+ server.verify().await;
+ Ok(())
+}
+
#[tokio::test(flavor = "current_thread")]
async fn changed_issuer_requires_reauthorization_before_refresh() -> Result<()> {
let (_env, server, mut initial) = test_context().await?;