Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Refresh the model catalog before turns after auth changes (#46508)

jif2b842962883f
diff --git a/codex-rs/core/src/session/turn_context.rs b/codex-rs/core/src/session/turn_context.rs
index fe60d59b30..22267d7881 100644
--- a/codex-rs/core/src/session/turn_context.rs
+++ b/codex-rs/core/src/session/turn_context.rs
@@ -1060,6 +1060,15 @@ impl Session {
if let Some(service_tier) = service_tier_for_turn {
Arc::make_mut(&mut configuration.step_settings).service_tier = Some(service_tier);
}
+ if !crate::guardian::is_basic_session_source(&configuration.session_source) {
+ self.services
+ .models_manager
+ .refresh_after_auth_change(
+ self.build_effective_session_config(&configuration)
+ .http_client_factory(),
+ )
+ .await;
+ }
let turn_environments = self.activate_turn_environments(&configuration).await;
let turn_context = self
.new_turn_from_configuration(sub_id, configuration, turn_environments, options)
diff --git a/codex-rs/core/src/tasks/mod.rs b/codex-rs/core/src/tasks/mod.rs
index 5bae1532d8..502739aea8 100644
--- a/codex-rs/core/src/tasks/mod.rs
+++ b/codex-rs/core/src/tasks/mod.rs
@@ -457,6 +457,20 @@ impl Session {
Arc::clone(&active_turn.turn_state)
};
+ self.services
+ .models_manager
+ .refresh_after_auth_change(self.get_config().await.http_client_factory())
+ .await;
+ // A completion-triggered wakeup can be interrupted while discovery waits.
+ if self
+ .active_turn
+ .lock()
+ .await
+ .as_ref()
+ .is_none_or(|turn| !Arc::ptr_eq(&turn.turn_state, &turn_state))
+ {
+ return;
+ }
let (input, mut start_options) =
self.input_queue.get_pending_input(&self.active_turn).await;
if !input.iter().any(
diff --git a/codex-rs/core/tests/suite/models_cache_auth.rs b/codex-rs/core/tests/suite/models_cache_auth.rs
index a47b82a97b..430236ce8f 100644
--- a/codex-rs/core/tests/suite/models_cache_auth.rs
+++ b/codex-rs/core/tests/suite/models_cache_auth.rs
@@ -1,23 +1,244 @@
//! Catalogs must follow auth and provider changes without leaking default billing tiers.
use std::sync::Arc;
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::Ordering;
+use std::time::Duration;
+use tokio_util::sync::CancellationToken;
use anyhow::Result;
+use codex_core::TurnInputRequest;
use codex_login::AuthCredentialsStoreMode;
+use codex_login::AuthHeaders;
use codex_login::AuthKeyringBackendKind;
use codex_login::CodexAuth;
+use codex_login::ExternalAuth;
+use codex_login::ExternalAuthFuture;
+use codex_login::ExternalAuthRefreshContext;
use codex_login::login_with_api_key;
use codex_models_manager::bundled_models_response;
use codex_models_manager::manager::RefreshStrategy;
+use codex_protocol::AgentPath;
use codex_protocol::openai_models::ModelVisibility;
use codex_protocol::openai_models::ModelsResponse;
+use codex_protocol::openai_models::ToolMode;
+use codex_protocol::protocol::EventMsg;
+use codex_protocol::protocol::InterAgentCommunication;
+use codex_protocol::protocol::Op;
+use codex_protocol::user_input::UserInput;
use core_test_support::responses;
use core_test_support::responses::ev_completed;
use core_test_support::responses::ev_response_created;
use core_test_support::responses::sse;
use core_test_support::test_codex::test_codex;
+use core_test_support::wait_for_event;
+use http::HeaderMap;
+use http::HeaderValue;
use pretty_assertions::assert_eq;
use tempfile::TempDir;
+use test_case::test_case;
+use wiremock::Mock;
+use wiremock::MockServer;
+use wiremock::ResponseTemplate;
+use wiremock::matchers::header;
+use wiremock::matchers::method;
+use wiremock::matchers::path;
+
+struct SelectedAuth(CodexAuth);
+
+impl ExternalAuth for SelectedAuth {
+ fn resolve(&self) -> ExternalAuthFuture<'_, CodexAuth> {
+ Box::pin(async { Ok(self.0.clone()) })
+ }
+
+ fn refresh(&self, _context: ExternalAuthRefreshContext) -> ExternalAuthFuture<'_, CodexAuth> {
+ self.resolve()
+ }
+}
+
+#[derive(Default)]
+struct StallingAuth {
+ stall: AtomicBool,
+ released: CancellationToken,
+}
+
+impl ExternalAuth for StallingAuth {
+ fn resolve(&self) -> ExternalAuthFuture<'_, CodexAuth> {
+ Box::pin(async {
+ if self.stall.load(Ordering::SeqCst) {
+ self.released.cancelled().await;
+ }
+ Ok(header_auth("Bearer rotated"))
+ })
+ }
+
+ fn refresh(&self, _context: ExternalAuthRefreshContext) -> ExternalAuthFuture<'_, CodexAuth> {
+ self.resolve()
+ }
+}
+
+fn header_auth(token: &'static str) -> CodexAuth {
+ CodexAuth::Headers(AuthHeaders::new(HeaderMap::from_iter([
+ (http::header::AUTHORIZATION, HeaderValue::from_static(token)),
+ (
+ http::header::HeaderName::from_static("chatgpt-account-id"),
+ HeaderValue::from_static("same-account"),
+ ),
+ ])))
+}
+
+#[derive(Clone, Copy)]
+enum Input {
+ User,
+ Mail,
+}
+
+#[derive(Clone, Copy)]
+enum RefreshOutcome {
+ Success,
+ Failure,
+ AuthTimeout,
+}
+
+#[test_case(Input::User, RefreshOutcome::Success; "user refresh")]
+#[test_case(Input::User, RefreshOutcome::Failure; "user fallback")]
+#[test_case(Input::Mail, RefreshOutcome::Success; "mail refresh")]
+#[test_case(Input::Mail, RefreshOutcome::Failure; "mail fallback")]
+#[test_case(Input::User, RefreshOutcome::AuthTimeout; "auth timeout")]
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn auth_rotation_refreshes_before_turn_with_best_effort(
+ input: Input,
+ outcome: RefreshOutcome,
+) -> Result<()> {
+ let server = MockServer::start().await;
+ let catalog = bundled_models_response()?;
+ let mut model = catalog
+ .models
+ .iter()
+ .find(|model| model.slug == "gpt-5.5")
+ .cloned()
+ .expect("bundled model");
+ let fallback_context_window = model.usable_context_window();
+ responses::mount_models_once(&server, catalog).await;
+ let test = test_codex()
+ .with_auth(header_auth("Bearer rotated"))
+ .with_model(&model.slug)
+ .with_config(|config| config.model_provider.request_max_retries = Some(0))
+ .build_with_auto_env(&server)
+ .await?;
+ model.visibility = ModelVisibility::List;
+ model.context_window = Some(481_000);
+ model.max_context_window = Some(481_000);
+ model.effective_context_window_percent = 100;
+ model.use_responses_lite = true;
+ model.tool_mode = Some(ToolMode::CodeModeOnly);
+ let succeeds = matches!(outcome, RefreshOutcome::Success);
+ let stalls_auth = matches!(outcome, RefreshOutcome::AuthTimeout);
+ let expected_context_window = if succeeds {
+ model.usable_context_window()
+ } else {
+ fallback_context_window
+ };
+ let template = if succeeds {
+ ResponseTemplate::new(/*s*/ 200).set_body_json(ModelsResponse {
+ models: vec![model],
+ })
+ } else {
+ ResponseTemplate::new(/*s*/ 503).set_body_string("unavailable")
+ };
+ Mock::given(method("GET"))
+ .and(path("/v1/models"))
+ .and(header("authorization", "Bearer rotated"))
+ .respond_with(template)
+ .expect(/*r*/ u64::from(!stalls_auth))
+ .mount(&server)
+ .await;
+ let stalled_auth = Arc::new(StallingAuth::default());
+ // The shared picker can replace the catalog between turns. Switching back
+ // must refresh even when this was the last identity used to start a turn.
+ test.thread_manager
+ .auth_manager()
+ .set_external_auth(Arc::new(SelectedAuth(header_auth("Bearer other"))))
+ .await?;
+ responses::mount_models_once(&server, bundled_models_response()?).await;
+ test.thread_manager
+ .get_models_manager()
+ .raw_model_catalog(
+ RefreshStrategy::Online,
+ codex_core::test_support::default_http_client_factory(),
+ )
+ .await;
+ let auth: Arc<dyn ExternalAuth> = if stalls_auth {
+ stalled_auth.clone()
+ } else {
+ Arc::new(SelectedAuth(header_auth("Bearer rotated")))
+ };
+ test.thread_manager
+ .auth_manager()
+ .set_external_auth(auth)
+ .await?;
+ stalled_auth.stall.store(stalls_auth, Ordering::SeqCst);
+ let response = responses::mount_sse_once(&server, responses::sse_completed("done")).await;
+ match input {
+ Input::User => {
+ tokio::time::timeout(
+ Duration::from_secs(/*secs*/ 7),
+ test.codex
+ .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
+ text: "hello".into(),
+ text_elements: Vec::new(),
+ }])),
+ )
+ .await??;
+ }
+ Input::Mail => {
+ test.codex
+ .submit(Op::InterAgentCommunication {
+ communication: InterAgentCommunication::new(
+ AgentPath::root().join("worker").expect("valid path"),
+ AgentPath::root(),
+ Vec::new(),
+ "hello".into(),
+ /*trigger_turn*/ true,
+ ),
+ start_options: Default::default(),
+ })
+ .await?;
+ }
+ }
+ let started = wait_for_event(&test.codex, |event| {
+ matches!(event, EventMsg::TurnStarted(_))
+ })
+ .await;
+ let EventMsg::TurnStarted(started) = started else {
+ unreachable!()
+ };
+ assert_eq!(started.model_context_window, expected_context_window);
+ if stalls_auth {
+ stalled_auth.stall.store(/*val*/ false, Ordering::SeqCst);
+ stalled_auth.released.cancel();
+ }
+ wait_for_event(&test.codex, |event| {
+ matches!(event, EventMsg::TurnComplete(_))
+ })
+ .await;
+ let request = response.single_request();
+ assert!(request.body_contains_text("hello"));
+ assert_eq!(
+ request.header("authorization").as_deref(),
+ Some("Bearer rotated")
+ );
+ let body = request.body_json();
+ let uses_responses_lite = body["input"]
+ .as_array()
+ .expect("request input")
+ .iter()
+ .any(|item| item["type"] == "additional_tools");
+ assert_eq!(uses_responses_lite, succeeds);
+ test.codex.submit(Op::Shutdown).await?;
+ test.codex.wait_until_terminated().await;
+ Ok(())
+}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn auth_and_provider_switches_do_not_reuse_chatgpt_catalog() -> Result<()> {
diff --git a/codex-rs/model-provider/src/models_endpoint.rs b/codex-rs/model-provider/src/models_endpoint.rs
index 87c22e2357..a063a90d14 100644
--- a/codex-rs/model-provider/src/models_endpoint.rs
+++ b/codex-rs/model-provider/src/models_endpoint.rs
@@ -603,7 +603,7 @@ mod tests {
.respond_with(ResponseTemplate::new(200).set_body_json(ModelsResponse {
models: vec![model.clone()],
}))
- .expect(2)
+ .expect(/*r*/ 3)
.mount(&server)
.await;
let mut provider = provider_info_with_command_auth();
@@ -634,6 +634,12 @@ mod tests {
.find(|candidate| candidate.slug == model.slug),
Some(&model)
);
+ // The cached identity still matches here; resolving command auth must
+ // detect the next token before deciding whether a refresh is needed.
+ manager
+ .refresh_after_auth_change(HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault))
+ .await;
+ assert_eq!(manager.get_remote_models().await, catalog.models);
auth.auth().await;
let bundled = codex_models_manager::bundled_models_response().unwrap();
assert_eq!(manager.get_remote_models().await, bundled.models);
@@ -662,7 +668,7 @@ mod tests {
.iter()
.map(|request| request.headers["authorization"].to_str().unwrap())
.collect::<Vec<_>>(),
- vec!["Bearer token-2", "Bearer token-6"]
+ vec!["Bearer token-2", "Bearer token-5", "Bearer token-9"]
);
}
}
diff --git a/codex-rs/models-manager/src/manager.rs b/codex-rs/models-manager/src/manager.rs
index c7b1a19ad5..88151f7735 100644
--- a/codex-rs/models-manager/src/manager.rs
+++ b/codex-rs/models-manager/src/manager.rs
@@ -138,6 +138,15 @@ pub trait ModelsManager: fmt::Debug + Send + Sync {
http_client_factory: HttpClientFactory,
) -> ModelsManagerFuture<'_, ModelsResponse>;
+ /// Best-effort refresh when the in-memory catalog belongs to different credentials.
+ /// Static catalogs need no refresh. Failures leave the existing cache/default fallback.
+ fn refresh_after_auth_change(
+ &self,
+ _http_client_factory: HttpClientFactory,
+ ) -> ModelsManagerFuture<'_, ()> {
+ Box::pin(std::future::ready(()))
+ }
+
/// Return the current in-memory remote model catalog without refreshing or loading cache state.
fn get_remote_models(&self) -> ModelsManagerFuture<'_, Vec<ModelInfo>>;
@@ -345,6 +354,36 @@ impl ModelsManager for OpenAiModelsManager {
))
}
+ fn refresh_after_auth_change(
+ &self,
+ http_client_factory: HttpClientFactory,
+ ) -> ModelsManagerFuture<'_, ()> {
+ Box::pin(async move {
+ let refresh = async {
+ // Resolve lazy command credentials before comparing catalog identities.
+ if !self.should_refresh_models().await {
+ return Ok(());
+ }
+ let identity = self.endpoint_client.identity();
+ if identity.is_some() && self.remote_models.read().await.identity == identity {
+ return Ok(());
+ }
+ self.refresh_available_models(
+ RefreshStrategy::OnlineIfUncached,
+ &http_client_factory,
+ )
+ .await
+ };
+ // Include auth resolution and cache access in the best-effort deadline.
+ if !matches!(
+ tokio::time::timeout(Duration::from_secs(/*secs*/ 5), refresh).await,
+ Ok(Ok(()))
+ ) {
+ tracing::warn!("model catalog refresh after auth change failed or timed out");
+ }
+ })
+ }
+
fn get_remote_models(&self) -> ModelsManagerFuture<'_, Vec<ModelInfo>> {
Box::pin(async move {
let entry = self.remote_models.read().await;