Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Unify external authentication provider handling (#38258)

cooper-oai18dcc7646f6a
diff --git a/codex-rs/core/tests/suite/external_auth.rs b/codex-rs/core/tests/suite/external_auth.rs
index b764ee5a29..496518e14f 100644
--- a/codex-rs/core/tests/suite/external_auth.rs
+++ b/codex-rs/core/tests/suite/external_auth.rs
@@ -94,7 +94,7 @@ async fn header_auth_is_attached_to_responses_requests() -> anyhow::Result<()> {
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn configured_external_auth_401_retry_uses_refreshed_chatgpt_headers() -> anyhow::Result<()> {
+async fn external_auth_401_retry_uses_refreshed_chatgpt_headers() -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let server = start_mock_server().await;
@@ -136,7 +136,7 @@ async fn configured_external_auth_401_retry_uses_refreshed_chatgpt_headers() ->
});
test.thread_manager
.auth_manager()
- .set_configured_external_auth(external_auth.clone())
+ .set_external_auth(external_auth.clone())
.await?;
test.submit_turn("hello").await?;
diff --git a/codex-rs/login/src/auth/auth_tests.rs b/codex-rs/login/src/auth/auth_tests.rs
index eb9c266acb..07d8a67ae5 100644
--- a/codex-rs/login/src/auth/auth_tests.rs
+++ b/codex-rs/login/src/auth/auth_tests.rs
@@ -1324,7 +1324,7 @@ impl ExternalAuth for FailingExternalAuth {
}
#[tokio::test]
-async fn configured_auth_keeps_cached_credentials_after_permanent_reload_failure() {
+async fn external_auth_keeps_cached_credentials_after_permanent_reload_failure() {
let manager = AuthManager::from_auth_for_testing(CodexAuth::from_api_key("seed"));
let auth = CodexAuth::from_api_key("configured-token");
let external_auth = Arc::new(FailingExternalAuth {
@@ -1332,9 +1332,9 @@ async fn configured_auth_keeps_cached_credentials_after_permanent_reload_failure
resolve_count: AtomicUsize::new(0),
});
manager
- .set_configured_external_auth(external_auth.clone())
+ .set_external_auth(external_auth.clone())
.await
- .expect("configured auth should install");
+ .expect("external auth should install");
assert_eq!(external_auth.resolve_count.load(Ordering::SeqCst), 1);
@@ -1353,7 +1353,34 @@ async fn configured_auth_keeps_cached_credentials_after_permanent_reload_failure
}
#[tokio::test]
-async fn runtime_external_auth_errors_remain_transient() {
+async fn replacing_external_auth_clears_permanent_failure() {
+ let manager = AuthManager::from_auth_for_testing(CodexAuth::from_api_key("seed"));
+ let auth = CodexAuth::from_api_key("external-token");
+ manager
+ .set_external_auth(Arc::new(FailingExternalAuth {
+ auth: auth.clone(),
+ resolve_count: AtomicUsize::new(0),
+ }))
+ .await
+ .expect("external auth should install");
+
+ assert_eq!(manager.auth().await, Some(auth.clone()));
+ assert!(manager.refresh_failure_for_auth(&auth).is_some());
+
+ manager
+ .set_external_auth(Arc::new(StaticExternalAuth(auth.clone())))
+ .await
+ .expect("replacement external auth should install");
+
+ manager
+ .refresh_token_from_authority()
+ .await
+ .expect("replacement external auth should refresh");
+ assert_eq!(manager.auth_cached(), Some(auth));
+}
+
+#[tokio::test]
+async fn runtime_external_auth_uses_provider_error_classification() {
let manager = AuthManager::from_auth_for_testing(CodexAuth::from_api_key("seed"));
manager
.set_external_auth(Arc::new(FailingExternalAuth {
@@ -1365,7 +1392,7 @@ async fn runtime_external_auth_errors_remain_transient() {
assert!(matches!(
manager.refresh_token_from_authority().await,
- Err(RefreshTokenError::Transient(_))
+ Err(RefreshTokenError::Permanent(_))
));
}
@@ -1409,12 +1436,15 @@ async fn external_auth_provider_can_install_headers() {
}
#[tokio::test]
-async fn configured_external_auth_is_immutable_and_process_local() {
+async fn workload_identity_auth_is_immutable_and_process_local() {
let codex_home = tempdir().expect("tempdir");
- let manager = AuthManager::from_auth_for_testing_with_home(
+ let mut manager = AuthManager::from_auth_for_testing_with_home(
CodexAuth::from_api_key("seed"),
codex_home.path().to_path_buf(),
);
+ Arc::get_mut(&mut manager)
+ .expect("test manager should not be shared yet")
+ .workload_identity_selected = true;
let access_token = fake_jwt_for_auth_file_params(&AuthFileParams {
openai_api_key: None,
chatgpt_plan_type: Some("enterprise".to_string()),
@@ -1426,12 +1456,12 @@ async fn configured_external_auth_is_immutable_and_process_local() {
.expect("external ChatGPT auth");
manager
- .set_configured_external_auth(Arc::new(StaticExternalAuth(auth.clone())))
+ .install_external_auth(Arc::new(StaticExternalAuth(auth.clone())))
.await
- .expect("configured auth should install");
+ .expect("workload identity auth should install");
manager.clear_external_auth();
- assert!(manager.has_configured_external_auth());
+ assert!(manager.has_external_auth());
assert_eq!(manager.auth().await, Some(auth.clone()));
assert!(matches!(
manager
@@ -1443,9 +1473,9 @@ async fn configured_external_auth_is_immutable_and_process_local() {
let logout_error = manager
.logout()
.await
- .expect_err("host-configured auth must not be logged out");
+ .expect_err("workload identity auth must not be logged out");
assert_eq!(logout_error.kind(), std::io::ErrorKind::PermissionDenied);
- assert!(manager.has_configured_external_auth());
+ assert!(manager.has_external_auth());
assert_eq!(manager.auth_cached(), Some(auth));
assert!(!get_auth_file(codex_home.path()).exists());
@@ -1454,7 +1484,12 @@ async fn configured_external_auth_is_immutable_and_process_local() {
AuthCredentialsStoreMode::Ephemeral,
AuthKeyringBackendKind::default(),
);
- assert_eq!(ephemeral_storage.load().expect("load ephemeral auth"), None);
+ assert!(
+ ephemeral_storage
+ .load()
+ .expect("load ephemeral auth")
+ .is_some()
+ );
}
struct ProviderAuthScript {
diff --git a/codex-rs/login/src/auth/manager.rs b/codex-rs/login/src/auth/manager.rs
index 96d3a39439..ffd855cf71 100644
--- a/codex-rs/login/src/auth/manager.rs
+++ b/codex-rs/login/src/auth/manager.rs
@@ -227,7 +227,7 @@ pub trait ExternalAuth: Send + Sync {
/// Refreshes auth and makes the returned value current for future `resolve()` calls.
fn refresh(&self, context: ExternalAuthRefreshContext) -> ExternalAuthFuture<'_, CodexAuth>;
- /// Maps a provider error into the retry policy used by configured-auth reload and recovery.
+ /// Maps a provider error into the retry policy used by external-auth reload and recovery.
fn classify_error(&self, error: std::io::Error) -> RefreshTokenError {
RefreshTokenError::Transient(error)
}
@@ -235,31 +235,6 @@ pub trait ExternalAuth: Send + Sync {
pub type ExternalAuthFuture<'a, T> = Pin<Box<dyn Future<Output = std::io::Result<T>> + Send + 'a>>;
-#[derive(Clone)]
-enum ExternalAuthSource {
- Configured(Arc<dyn ExternalAuth>),
- Runtime(Arc<dyn ExternalAuth>),
-}
-
-impl ExternalAuthSource {
- fn provider(&self) -> Arc<dyn ExternalAuth> {
- match self {
- Self::Configured(provider) | Self::Runtime(provider) => Arc::clone(provider),
- }
- }
-
- fn is_runtime(&self) -> bool {
- matches!(self, Self::Runtime(_))
- }
-
- fn classify_provider_error(&self, error: std::io::Error) -> RefreshTokenError {
- match self {
- Self::Configured(provider) => provider.classify_error(error),
- Self::Runtime(_) => RefreshTokenError::Transient(error),
- }
- }
-}
-
fn permanent_external_auth_error(message: impl Into<String>) -> RefreshTokenError {
RefreshTokenError::Permanent(RefreshTokenFailedError::new(
RefreshTokenFailedReason::Other,
@@ -1990,7 +1965,8 @@ pub struct AuthManager {
refresh_lock: Semaphore,
agent_identity_lock: Semaphore,
agent_identity_bootstrap_cooldown: Mutex<AgentIdentityBootstrapCooldown>,
- external_auth: RwLock<Option<ExternalAuthSource>>,
+ external_auth: RwLock<Option<Arc<dyn ExternalAuth>>>,
+ workload_identity_selected: bool,
auth_route_config: AuthRouteConfig,
}
@@ -2046,6 +2022,10 @@ impl Debug for AuthManager {
.field("chatgpt_base_url", &self.chatgpt_base_url)
.field("auth_route_config", &self.auth_route_config)
.field("has_external_auth", &self.has_external_auth())
+ .field(
+ "workload_identity_selected",
+ &self.workload_identity_selected,
+ )
.finish_non_exhaustive()
}
}
@@ -2122,6 +2102,7 @@ impl AuthManager {
agent_identity_lock: Semaphore::new(/*permits*/ 1),
agent_identity_bootstrap_cooldown: Mutex::default(),
external_auth: RwLock::new(None),
+ workload_identity_selected: false,
auth_route_config,
}
}
@@ -2150,6 +2131,7 @@ impl AuthManager {
agent_identity_lock: Semaphore::new(/*permits*/ 1),
agent_identity_bootstrap_cooldown: Mutex::default(),
external_auth: RwLock::new(None),
+ workload_identity_selected: false,
auth_route_config: crate::test_support::transport_default_auth_route_config(),
})
}
@@ -2177,6 +2159,7 @@ impl AuthManager {
agent_identity_lock: Semaphore::new(/*permits*/ 1),
agent_identity_bootstrap_cooldown: Mutex::default(),
external_auth: RwLock::new(None),
+ workload_identity_selected: false,
auth_route_config: crate::test_support::transport_default_auth_route_config(),
})
}
@@ -2212,6 +2195,7 @@ impl AuthManager {
agent_identity_lock: Semaphore::new(/*permits*/ 1),
agent_identity_bootstrap_cooldown: Mutex::default(),
external_auth: RwLock::new(None),
+ workload_identity_selected: false,
auth_route_config: crate::test_support::transport_default_auth_route_config(),
})
}
@@ -2236,9 +2220,8 @@ impl AuthManager {
refresh_lock: Semaphore::new(/*permits*/ 1),
agent_identity_lock: Semaphore::new(/*permits*/ 1),
agent_identity_bootstrap_cooldown: Mutex::default(),
- external_auth: RwLock::new(Some(ExternalAuthSource::Runtime(Arc::new(
- BearerTokenRefresher::new(config),
- )))),
+ external_auth: RwLock::new(Some(Arc::new(BearerTokenRefresher::new(config)))),
+ workload_identity_selected: false,
// External bearer auth refreshes by running the provider's command and never makes
// auth-owned HTTP requests, so this route is intentionally inert.
auth_route_config: AuthRouteConfig::from_http_client_factory(HttpClientFactory::new(
@@ -2449,29 +2432,26 @@ impl AuthManager {
}
async fn load_auth(&self) -> Option<CodexAuth> {
- if let Some(source) = self.external_auth_source() {
+ if let Some(external_auth) = self.external_auth_provider() {
let cached_auth = self.auth_cached();
- if !source.is_runtime()
- && cached_auth
- .as_ref()
- .is_some_and(|auth| self.refresh_failure_for_auth(auth).is_some())
+ if cached_auth
+ .as_ref()
+ .is_some_and(|auth| self.refresh_failure_for_auth(auth).is_some())
{
return cached_auth;
}
- return match self.resolve_external_auth(&source).await {
+ return match self.resolve_external_auth(external_auth.as_ref()).await {
Ok(auth) => Some(auth),
Err(err) => {
tracing::error!("Failed to resolve external auth: {err}");
- if let (Some(auth), RefreshTokenError::Permanent(error)) =
- (cached_auth.as_ref(), &err)
- && !source.is_runtime()
- {
- self.record_permanent_refresh_failure_if_unchanged(auth, error);
- }
- if source.is_runtime() {
- None
- } else {
- cached_auth
+ match err {
+ RefreshTokenError::Permanent(error) => {
+ if let Some(auth) = cached_auth.as_ref() {
+ self.record_permanent_refresh_failure_if_unchanged(auth, &error);
+ }
+ cached_auth
+ }
+ RefreshTokenError::Transient(_) => None,
}
}
};
@@ -2527,65 +2507,37 @@ impl AuthManager {
&self,
external_auth: Arc<dyn ExternalAuth>,
) -> Result<(), RefreshTokenError> {
- if self.has_configured_external_auth() {
+ if self.workload_identity_selected {
return Err(permanent_external_auth_error(
- "configuration-backed external auth cannot be replaced at runtime",
+ "workload identity auth cannot be replaced at runtime",
));
}
- let external_auth_source = ExternalAuthSource::Runtime(external_auth);
- let auth = self.resolve_external_auth(&external_auth_source).await?;
- let mut source_slot = self.external_auth.write().map_err(|_| {
- RefreshTokenError::Transient(std::io::Error::other("external auth lock is poisoned"))
- })?;
- if matches!(
- source_slot.as_ref(),
- Some(ExternalAuthSource::Configured(_))
- ) {
- return Err(permanent_external_auth_error(
- "configuration-backed external auth cannot be replaced at runtime",
- ));
- }
- *source_slot = Some(external_auth_source.clone());
- drop(source_slot);
- self.commit_external_auth(auth, &external_auth_source)
+ self.install_external_auth(external_auth).await
}
- /// Installs an external auth source selected from process configuration at startup.
- ///
- /// Unlike [`Self::set_external_auth`], configured auth is host-owned: runtime account APIs
- /// cannot replace or clear it, and its credentials are not copied into the process-wide auth
- /// store. Call this once while constructing the manager, before exposing it to clients.
- pub async fn set_configured_external_auth(
+ async fn install_external_auth(
&self,
external_auth: Arc<dyn ExternalAuth>,
) -> Result<(), RefreshTokenError> {
- if self.has_external_auth() {
- return Err(permanent_external_auth_error(
- "external auth is already configured",
- ));
- }
- let external_auth_source = ExternalAuthSource::Configured(external_auth);
- let auth = self.resolve_external_auth(&external_auth_source).await?;
- let mut source = self
- .external_auth
- .write()
- .map_err(|_| permanent_external_auth_error("external auth lock is poisoned"))?;
- if source.is_some() {
- return Err(permanent_external_auth_error(
- "external auth is already configured",
- ));
+ let auth = self.resolve_external_auth(external_auth.as_ref()).await?;
+ let mut external_auth_slot = self.external_auth.write().map_err(|_| {
+ RefreshTokenError::Transient(std::io::Error::other("external auth lock is poisoned"))
+ })?;
+ *external_auth_slot = Some(external_auth);
+ drop(external_auth_slot);
+ if let Ok(mut guard) = self.inner.write() {
+ guard.permanent_refresh_failure = None;
}
- *source = Some(external_auth_source.clone());
- drop(source);
- self.commit_external_auth(auth, &external_auth_source)
+ self.commit_external_auth(auth)
}
- /// Clears only auth installed through the runtime API. Configured auth is immutable.
pub fn clear_external_auth(&self) {
+ if self.workload_identity_selected {
+ return;
+ }
if let Ok(mut external_auth) = self.external_auth.write()
- && matches!(external_auth.as_ref(), Some(ExternalAuthSource::Runtime(_)))
+ && external_auth.take().is_some()
{
- external_auth.take();
self.set_cached_auth(/*new_auth*/ None);
}
}
@@ -2626,13 +2578,7 @@ impl AuthManager {
}
pub fn has_external_auth(&self) -> bool {
- self.external_auth_source().is_some()
- }
-
- pub fn has_configured_external_auth(&self) -> bool {
- self.external_auth.read().ok().is_some_and(|source| {
- matches!(source.as_ref(), Some(ExternalAuthSource::Configured(_)))
- })
+ self.external_auth_provider().is_some()
}
pub fn is_external_chatgpt_auth_active(&self) -> bool {
@@ -2703,10 +2649,12 @@ impl AuthManager {
enable_codex_api_key_env,
)
.map_err(configured_workload_identity_error)?;
- let manager = Self::shared_from_auth_config(auth_config, enable_codex_api_key_env).await;
+ let mut manager = Self::new_from_auth_config(auth_config, enable_codex_api_key_env).await;
+ manager.workload_identity_selected = external_auth.is_some();
+ let manager = Arc::new(manager);
if let Some(external_auth) = external_auth {
manager
- .set_configured_external_auth(Arc::new(external_auth))
+ .install_external_auth(Arc::new(external_auth))
.await?;
}
Ok(manager)
@@ -2716,7 +2664,7 @@ impl AuthManager {
UnauthorizedRecovery::new(Arc::clone(self))
}
- fn external_auth_source(&self) -> Option<ExternalAuthSource> {
+ fn external_auth_provider(&self) -> Option<Arc<dyn ExternalAuth>> {
self.external_auth
.read()
.ok()
@@ -2733,14 +2681,13 @@ impl AuthManager {
async fn resolve_external_auth(
&self,
- source: &ExternalAuthSource,
+ external_auth: &dyn ExternalAuth,
) -> Result<CodexAuth, RefreshTokenError> {
- let external_auth = source.provider();
let auth = external_auth
.resolve()
.await
- .map_err(|error| source.classify_provider_error(error))?;
- self.validate_external_auth(&auth, source)?;
+ .map_err(|error| external_auth.classify_error(error))?;
+ self.validate_external_auth(&auth, external_auth)?;
Ok(auth)
}
@@ -2875,10 +2822,10 @@ impl AuthManager {
}
fn ensure_logout_allowed(&self) -> std::io::Result<()> {
- if self.has_configured_external_auth() {
+ if self.workload_identity_selected {
return Err(std::io::Error::new(
std::io::ErrorKind::PermissionDenied,
- "configuration-backed external auth is managed by the host and cannot be logged out",
+ "workload identity auth is managed by the host and cannot be logged out",
));
}
Ok(())
@@ -2927,12 +2874,11 @@ impl AuthManager {
&self,
reason: ExternalAuthRefreshReason,
) -> Result<(), RefreshTokenError> {
- let Some(source) = self.external_auth_source() else {
+ let Some(external_auth) = self.external_auth_provider() else {
return Err(RefreshTokenError::Transient(std::io::Error::other(
"external auth is not configured",
)));
};
- let external_auth = source.provider();
let previous_account_id = self
.auth_cached()
.as_ref()
@@ -2945,25 +2891,20 @@ impl AuthManager {
let refreshed = external_auth
.refresh(context)
.await
- .map_err(|error| source.classify_provider_error(error))?;
- self.validate_external_auth(&refreshed, &source)?;
- self.commit_external_auth(refreshed, &source)?;
+ .map_err(|error| external_auth.classify_error(error))?;
+ self.validate_external_auth(&refreshed, external_auth.as_ref())?;
+ self.commit_external_auth(refreshed)?;
Ok(())
}
- fn commit_external_auth(
- &self,
- auth: CodexAuth,
- source: &ExternalAuthSource,
- ) -> Result<(), RefreshTokenError> {
- if source.is_runtime() && auth.is_external_chatgpt_tokens() {
+ fn commit_external_auth(&self, auth: CodexAuth) -> Result<(), RefreshTokenError> {
+ if auth.is_external_chatgpt_tokens() {
let auth_dot_json = auth.get_current_auth_json().ok_or_else(|| {
RefreshTokenError::Transient(std::io::Error::other(
"external ChatGPT auth tokens are missing auth state",
))
})?;
- // App/connectors paths still construct independent AuthManagers from Config. Mirror
- // external ChatGPT auth into the process-local store so those managers see it too.
+ // Independent AuthManagers share external ChatGPT auth through the process-local store.
save_auth(
&self.codex_home,
&auth_dot_json,
@@ -2980,21 +2921,15 @@ impl AuthManager {
fn validate_external_auth(
&self,
auth: &CodexAuth,
- source: &ExternalAuthSource,
+ external_auth: &dyn ExternalAuth,
) -> Result<(), RefreshTokenError> {
let allowed_login_methods = self.allowed_login_methods();
- let result = validate_auth_restrictions(
+ validate_auth_restrictions(
Some(&allowed_login_methods),
self.effective_chatgpt_workspaces().as_deref(),
auth,
- );
- match result {
- Ok(()) => Ok(()),
- Err(error) if source.is_runtime() => {
- Err(RefreshTokenError::Transient(std::io::Error::other(error)))
- }
- Err(error) => Err(permanent_external_auth_error(error)),
- }
+ )
+ .map_err(|error| external_auth.classify_error(std::io::Error::other(error)))
}
// Refreshes ChatGPT OAuth tokens, persists the updated auth state, and