Lightweight coding agent that runs in your terminal
Rust
Add provider-owned authentication recovery (#39274)
alexsong-oai22b860e80b06
diff --git a/codex-rs/core/src/client.rs b/codex-rs/core/src/client.rsindex da3b6dad38..f26d41955e 100644--- a/codex-rs/core/src/client.rs+++ b/codex-rs/core/src/client.rs@@ -126,6 +126,7 @@ use codex_login::auth_env_telemetry::AuthEnvTelemetry;use codex_login::auth_env_telemetry::collect_auth_env_telemetry;use codex_model_provider::AgentIdentitySessionFallback;use codex_model_provider::ProviderAuthScope;+use codex_model_provider::ProviderUnauthorizedRecovery;use codex_model_provider::SharedModelProvider;use codex_model_provider::create_model_provider;#[cfg(test)]@@ -1451,6 +1452,7 @@ impl ModelClientSession {let mut auth_recovery = auth_manager.as_ref().map(AuthManager::unauthorized_recovery);+ let mut provider_auth_recovery_attempted = false;let mut pending_retry = PendingUnauthorizedRetry::default();loop {let client_setup = self.client.current_client_setup().await?;@@ -1520,9 +1522,13 @@ impl ModelClientSession {);return Ok(stream);}- Err(ApiError::Transport(- unauthorized_transport @ TransportError::Http { status, .. },- )) if status == StatusCode::UNAUTHORIZED => {+ Err(ApiError::Transport(unauthorized_transport))+ if self+ .client+ .state+ .provider+ .is_recoverable_auth_error(&unauthorized_transport) =>+ {let response_debug_context =extract_response_debug_context(&unauthorized_transport);inference_trace_attempt.record_failed(@@ -1534,6 +1540,7 @@ impl ModelClientSession {handle_unauthorized(unauthorized_transport,&mut auth_recovery,+ &mut provider_auth_recovery_attempted,session_telemetry,&self.client.state.provider,)@@ -1584,11 +1591,13 @@ impl ModelClientSession {request_trace: Option<W3cTraceContext>,inference_trace: &InferenceTraceContext,) -> Result<WebsocketStreamOutcome> {- let auth_manager = self.client.state.provider.auth_manager();+ let provider = Arc::clone(&self.client.state.provider);+ let auth_manager = provider.auth_manager();let mut auth_recovery = auth_manager.as_ref().map(AuthManager::unauthorized_recovery);+ let mut provider_auth_recovery_attempted = false;let mut pending_retry = PendingUnauthorizedRetry::default();loop {let client_setup = self.client.current_client_setup().await?;@@ -1643,21 +1652,22 @@ impl ModelClientSession {{return Ok(WebsocketStreamOutcome::FallbackToHttp);}- Err(ApiError::Transport(- unauthorized_transport @ TransportError::Http { status, .. },- )) if status == StatusCode::UNAUTHORIZED => {+ Err(ApiError::Transport(unauthorized_transport))+ if provider.is_recoverable_auth_error(&unauthorized_transport) =>+ {pending_retry = PendingUnauthorizedRetry::from_recovery(handle_unauthorized(unauthorized_transport,&mut auth_recovery,+ &mut provider_auth_recovery_attempted,session_telemetry,- &self.client.state.provider,+ &provider,).await?,);continue;}- Err(err) => return Err(self.client.state.provider.map_api_error(err)),+ Err(err) => return Err(provider.map_api_error(err)),}let (incremental_request, previous_response_id_from_untraced_warmup) =@@ -2225,10 +2235,37 @@ struct WebsocketConnectParams<'a> {async fn handle_unauthorized(transport: TransportError,auth_recovery: &mut Option<UnauthorizedRecovery>,+ provider_auth_recovery_attempted: &mut bool,session_telemetry: &SessionTelemetry,provider: &SharedModelProvider,) -> Result<UnauthorizedRecoveryExecution> {let debug = extract_response_debug_context(&transport);+ if !*provider_auth_recovery_attempted {+ *provider_auth_recovery_attempted = true;+ match provider.recover_from_unauthorized().await {+ Ok(ProviderUnauthorizedRecovery::Recovered) => {+ return Ok(UnauthorizedRecoveryExecution {+ mode: "provider",+ phase: "provider_refresh",+ });+ }+ Ok(ProviderUnauthorizedRecovery::NotConfigured) => {}+ Err(error) => {+ let original = provider.map_api_error(ApiError::Transport(transport));+ warn!(+ error = %error,+ original_error = %original,+ "provider authentication recovery failed"+ );+ return Err(if error.is_retryable() {+ original+ } else {+ error+ });+ }+ }+ }+if let Some(recovery) = auth_recovery&& recovery.has_next(){diff --git a/codex-rs/core/src/client_tests.rs b/codex-rs/core/src/client_tests.rsindex 41c7dc1ab0..58f2f5f72e 100644--- a/codex-rs/core/src/client_tests.rs+++ b/codex-rs/core/src/client_tests.rs@@ -27,19 +27,27 @@ use codex_login::AuthManager;use codex_login::CodexAuth;use codex_login::auth::AgentIdentityAuthPolicy;use codex_model_provider::BearerAuthProvider;+use codex_model_provider::ModelProvider;+use codex_model_provider::ModelProviderFuture;+use codex_model_provider::ProviderAccountResult;+use codex_model_provider::ProviderUnauthorizedRecovery;use codex_model_provider::SharedModelProvider;use codex_model_provider::create_model_provider;use codex_model_provider_info::CHATGPT_CODEX_BASE_URL;use codex_model_provider_info::ModelProviderInfo;use codex_model_provider_info::WireApi;use codex_model_provider_info::create_oss_provider_with_base_url;+use codex_models_manager::manager::SharedModelsManager;use codex_otel::SessionTelemetry;use codex_protocol::ThreadId;use codex_protocol::auth::AuthMode;+use codex_protocol::error::CodexErr;+use codex_protocol::error::CodexErrorDetails;use codex_protocol::models::BaseInstructions;use codex_protocol::models::ContentItem;use codex_protocol::models::ResponseItem;use codex_protocol::openai_models::ModelInfo;+use codex_protocol::openai_models::ModelsResponse;use codex_protocol::openai_models::ReasoningEffort;use codex_protocol::protocol::InternalSessionSource;use codex_protocol::protocol::SessionSource;@@ -57,6 +65,7 @@ use pretty_assertions::assert_eq;use serde_json::json;use std::collections::BTreeMap;use std::collections::VecDeque;+use std::path::PathBuf;use std::pin::Pin;use std::sync::Arc;use std::sync::Mutex;@@ -659,6 +668,7 @@ async fn bedrock_unauthorized_error_uses_provider_mapping() {/*auth_manager*/ None,);let mut auth_recovery = None;+ let mut provider_auth_recovery_attempted = false;let url = "https://bedrock-mantle.us-east-2.api.aws/openai/v1/responses";let error = super::handle_unauthorized(TransportError::Http {@@ -671,6 +681,7 @@ async fn bedrock_unauthorized_error_uses_provider_mapping() {),},&mut auth_recovery,+ &mut provider_auth_recovery_attempted,&test_session_telemetry(),&provider,)@@ -685,6 +696,113 @@ async fn bedrock_unauthorized_error_uses_provider_mapping() {);}+#[derive(Debug)]+struct TestRecoveryProvider {+ inner: SharedModelProvider,+ should_fail: bool,+ attempts: Arc<AtomicUsize>,+}++impl ModelProvider for TestRecoveryProvider {+ fn info(&self) -> &ModelProviderInfo {+ self.inner.info()+ }++ fn auth_manager(&self) -> Option<Arc<AuthManager>> {+ None+ }++ fn auth(&self) -> ModelProviderFuture<'_, Option<CodexAuth>> {+ self.inner.auth()+ }++ fn account_state(&self) -> ProviderAccountResult {+ self.inner.account_state()+ }++ fn recover_from_unauthorized(+ &self,+ ) -> ModelProviderFuture<'_, codex_protocol::error::Result<ProviderUnauthorizedRecovery>> {+ self.attempts.fetch_add(1, Ordering::Relaxed);+ Box::pin(async move {+ if self.should_fail {+ Err(CodexErr::Io(std::io::Error::other(+ "provider recovery failed",+ )))+ } else {+ Ok(ProviderUnauthorizedRecovery::Recovered)+ }+ })+ }++ fn models_manager(+ &self,+ codex_home: PathBuf,+ config_model_catalog: Option<ModelsResponse>,+ ) -> SharedModelsManager {+ self.inner.models_manager(codex_home, config_model_catalog)+ }+}++#[tokio::test]+async fn provider_owned_auth_recovery_is_bounded_and_preserves_unauthorized_failures() {+ for should_fail in [false, true] {+ let attempts = Arc::new(AtomicUsize::new(0));+ let provider: SharedModelProvider = Arc::new(TestRecoveryProvider {+ inner: test_model_provider(),+ should_fail,+ attempts: Arc::clone(&attempts),+ });+ assert!(provider.auth_manager().is_none());++ let unauthorized = || TransportError::Http {+ status: http::StatusCode::UNAUTHORIZED,+ url: Some("https://example.com/v1/responses".to_string()),+ headers: None,+ body: Some("unauthorized".to_string()),+ };+ let mut auth_recovery = None;+ let mut provider_auth_recovery_attempted = false;+ let telemetry = test_session_telemetry();+ let result = super::handle_unauthorized(+ unauthorized(),+ &mut auth_recovery,+ &mut provider_auth_recovery_attempted,+ &telemetry,+ &provider,+ )+ .await;++ let error = if should_fail {+ result.expect_err("failed provider recovery should return the original error")+ } else {+ let recovered = result.expect("provider recovery should succeed without AuthManager");+ assert_eq!(+ (recovered.mode, recovered.phase),+ ("provider", "provider_refresh")+ );+ super::handle_unauthorized(+ unauthorized(),+ &mut auth_recovery,+ &mut provider_auth_recovery_attempted,+ &telemetry,+ &provider,+ )+ .await+ .expect_err("provider recovery should not run more than once")+ };++ match error.details() {+ CodexErrorDetails::UnexpectedStatus(response) => {+ assert_eq!(response.status, http::StatusCode::UNAUTHORIZED);+ assert_eq!(response.body, "unauthorized");+ }+ other => panic!("unexpected error after provider recovery: {other}"),+ }+ assert_eq!(attempts.load(Ordering::Relaxed), 1);+ }+}+#[tokio::test]async fn dropped_backpressured_response_stream_traces_cancelled_partial_output()-> anyhow::Result<()> {diff --git a/codex-rs/model-provider/src/lib.rs b/codex-rs/model-provider/src/lib.rsindex b1bd6d2162..22b5da74ed 100644--- a/codex-rs/model-provider/src/lib.rs+++ b/codex-rs/model-provider/src/lib.rs@@ -23,6 +23,7 @@ pub use provider::ProviderAccountError;pub use provider::ProviderAccountResult;pub use provider::ProviderAccountState;pub use provider::ProviderCapabilities;+pub use provider::ProviderUnauthorizedRecovery;pub use provider::RemoteCompactionSupport;pub use provider::SharedModelProvider;pub use provider::create_model_provider;diff --git a/codex-rs/model-provider/src/provider.rs b/codex-rs/model-provider/src/provider.rsindex aee4f9a2b5..f4fc6b6688 100644--- a/codex-rs/model-provider/src/provider.rs+++ b/codex-rs/model-provider/src/provider.rs@@ -7,6 +7,7 @@ use std::sync::Arc;use codex_api::ApiError;use codex_api::Provider;use codex_api::SharedAuthProvider;+use codex_api::TransportError;use codex_api::is_azure_responses_provider;use codex_login::AuthManager;use codex_login::CodexAuth;@@ -71,6 +72,15 @@ pub struct ProviderAccountState {pub requires_openai_auth: bool,}+/// Outcome of a provider-owned attempt to recover from an authentication failure.+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum ProviderUnauthorizedRecovery {+ /// The provider has no provider-specific authentication recovery configured.+ NotConfigured,+ /// The provider recovered its authentication state and the request can be retried.+ Recovered,+}+/// Error returned when a provider cannot construct its app-visible account state.#[derive(Debug, Clone, Copy, PartialEq, Eq)]pub enum ProviderAccountError {@@ -160,6 +170,24 @@ pub trait ModelProvider: fmt::Debug + Send + Sync {/// manager throughout the codebase; that is a larger refactor than this change.fn auth_manager(&self) -> Option<Arc<AuthManager>>;+ /// Returns whether this transport failure can be recovered by provider-scoped authentication.+ ///+ /// The default preserves existing unauthorized-response handling. Providers with other+ /// authentication failure shapes may recognize additional response or request-signing errors.+ fn is_recoverable_auth_error(&self, error: &TransportError) -> bool {+ matches!(+ error,+ TransportError::Http { status, .. } if *status == http::StatusCode::UNAUTHORIZED+ )+ }++ /// Attempts provider-owned authentication recovery before using the auth manager.+ fn recover_from_unauthorized(+ &self,+ ) -> ModelProviderFuture<'_, codex_protocol::error::Result<ProviderUnauthorizedRecovery>> {+ Box::pin(async { Ok(ProviderUnauthorizedRecovery::NotConfigured) })+ }+/// Returns the current provider-scoped auth value, if one is configured.fn auth(&self) -> ModelProviderFuture<'_, Option<CodexAuth>>;