Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Scope model catalog caches to the current provider and auth identity (#43906)

Ahmed Ibrahimf046cf35df09
diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lock
index 20a55a69ac..8eb7df52fa 100644
--- a/codex-rs/Cargo.lock
+++ b/codex-rs/Cargo.lock
@@ -427,7 +427,7 @@ dependencies = [
"codex-exec-server",
"codex-features",
"codex-login",
- "codex-models-manager",
+ "codex-model-provider",
"codex-protocol",
"codex-utils-cargo-bin",
"core_test_support",
diff --git a/codex-rs/app-server/tests/common/Cargo.toml b/codex-rs/app-server/tests/common/Cargo.toml
index 8dd43051c7..8efd1763c8 100644
--- a/codex-rs/app-server/tests/common/Cargo.toml
+++ b/codex-rs/app-server/tests/common/Cargo.toml
@@ -21,7 +21,7 @@ codex-core = { workspace = true }
codex-exec-server = { workspace = true }
codex-features = { workspace = true }
codex-login = { workspace = true }
-codex-models-manager = { workspace = true }
+codex-model-provider = { workspace = true }
codex-protocol = { workspace = true }
codex-utils-cargo-bin = { workspace = true }
serde = { workspace = true }
diff --git a/codex-rs/app-server/tests/common/models_cache.rs b/codex-rs/app-server/tests/common/models_cache.rs
index 1bd6f316d7..6f44943e3d 100644
--- a/codex-rs/app-server/tests/common/models_cache.rs
+++ b/codex-rs/app-server/tests/common/models_cache.rs
@@ -1,7 +1,4 @@
-use chrono::DateTime;
-use chrono::Utc;
use codex_core::test_support::all_model_presets;
-use codex_models_manager::client_version_to_whole;
use codex_protocol::config_types::ReasoningSummary;
use codex_protocol::openai_models::ConfigShellToolType;
use codex_protocol::openai_models::ModelInfo;
@@ -10,7 +7,6 @@ use codex_protocol::openai_models::ModelPreset;
use codex_protocol::openai_models::ModelVisibility;
use codex_protocol::openai_models::TruncationPolicyConfig;
use codex_protocol::openai_models::default_input_modalities;
-use serde_json::json;
use std::path::Path;
/// Convert a ModelPreset to ModelInfo for cache storage.
@@ -85,7 +81,7 @@ fn preset_to_info(preset: &ModelPreset, priority: i32) -> ModelInfo {
/// This prevents ModelsManager from making network requests to refresh models.
/// The cache will be treated as fresh (within TTL) and used instead of fetching from the network.
/// Uses bundled-catalog-derived presets, converted to ModelInfo format.
-pub fn write_models_cache(codex_home: &Path) -> std::io::Result<()> {
+pub async fn write_models_cache(codex_home: &Path) -> std::io::Result<()> {
// Get a stable bundled-catalog-derived preset list and filter for picker-visible entries.
let presets: Vec<&ModelPreset> = all_model_presets()
.iter()
@@ -103,24 +99,33 @@ pub fn write_models_cache(codex_home: &Path) -> std::io::Result<()> {
})
.collect();
- write_models_cache_with_models(codex_home, models)
+ write_models_cache_with_models(codex_home, models).await
}
/// Write a models_cache.json file with specific models.
/// Useful when tests need specific models to be available.
-pub fn write_models_cache_with_models(
+pub async fn write_models_cache_with_models(
codex_home: &Path,
models: Vec<ModelInfo>,
) -> std::io::Result<()> {
+ let config = codex_core::config::ConfigBuilder::default()
+ .loader_overrides(codex_config::LoaderOverrides::without_managed_config_for_tests())
+ .codex_home(codex_home.to_path_buf())
+ .build()
+ .await?;
+ let auth = codex_login::CodexAuth::from_auth_storage(
+ codex_home,
+ config.cli_auth_credentials_store_mode,
+ Some(&config.chatgpt_base_url),
+ config.auth_keyring_backend_kind(),
+ &codex_login::test_support::transport_default_auth_route_config(),
+ )
+ .await?;
+ let cache = codex_model_provider::test_support::models_cache_entry(
+ &config.model_provider,
+ auth.as_ref(),
+ models,
+ );
let cache_path = codex_home.join("models_cache.json");
- // DateTime<Utc> serializes to RFC3339 format by default with serde
- let fetched_at: DateTime<Utc> = Utc::now();
- let client_version = client_version_to_whole();
- let cache = json!({
- "fetched_at": fetched_at,
- "etag": null,
- "client_version": client_version,
- "models": models
- });
std::fs::write(cache_path, serde_json::to_string_pretty(&cache)?)
}
diff --git a/codex-rs/app-server/tests/suite/logging.rs b/codex-rs/app-server/tests/suite/logging.rs
index f1a6dc8c92..9c62bb5b88 100644
--- a/codex-rs/app-server/tests/suite/logging.rs
+++ b/codex-rs/app-server/tests/suite/logging.rs
@@ -97,7 +97,7 @@ supports_websockets = false
"#
))
.write(codex_home.path())?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
let mut app_server = TestAppServer::builder()
.with_codex_home(codex_home.path())
.with_env_overrides(&[("OPENAI_API_KEY", None)])
diff --git a/codex-rs/app-server/tests/suite/v2/account.rs b/codex-rs/app-server/tests/suite/v2/account.rs
index 3b67408538..6db61e21fe 100644
--- a/codex-rs/app-server/tests/suite/v2/account.rs
+++ b/codex-rs/app-server/tests/suite/v2/account.rs
@@ -416,7 +416,7 @@ async fn set_auth_token_updates_account_and_notifies() -> Result<()> {
..Default::default()
},
)?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
let access_token = encode_id_token(
&ChatGptIdTokenClaims::new()
@@ -499,7 +499,7 @@ async fn account_read_refresh_token_is_noop_in_external_mode() -> Result<()> {
..Default::default()
},
)?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
let access_token = encode_id_token(
&ChatGptIdTokenClaims::new()
@@ -611,7 +611,7 @@ async fn external_auth_refreshes_on_unauthorized() -> Result<()> {
..Default::default()
},
)?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
let success_sse = responses::sse(vec![
responses::ev_response_created("resp-turn"),
@@ -726,7 +726,7 @@ async fn external_auth_refresh_error_fails_turn() -> Result<()> {
..Default::default()
},
)?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
let unauthorized = ResponseTemplate::new(401).set_body_json(json!({
"error": { "message": "unauthorized" }
@@ -837,7 +837,7 @@ async fn external_auth_refresh_mismatched_workspace_fails_turn() -> Result<()> {
..Default::default()
},
)?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
let unauthorized = ResponseTemplate::new(401).set_body_json(json!({
"error": { "message": "unauthorized" }
@@ -953,7 +953,7 @@ async fn external_auth_refresh_invalid_access_token_fails_turn() -> Result<()> {
..Default::default()
},
)?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
let unauthorized = ResponseTemplate::new(401).set_body_json(json!({
"error": { "message": "unauthorized" }
@@ -2003,7 +2003,7 @@ async fn login_account_chatgpt_device_code_returns_error_when_disabled() -> Resu
..Default::default()
},
)?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
mock_device_code_usercode_failure(&mock_server, /*status*/ 404).await;
let issuer = mock_server.uri();
@@ -2059,7 +2059,7 @@ async fn login_account_chatgpt_device_code_succeeds_and_notifies() -> Result<()>
..Default::default()
},
)?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
mock_device_code_usercode(&mock_server, /*interval_seconds*/ 0).await;
mock_device_code_token_success(&mock_server).await;
@@ -2139,7 +2139,7 @@ async fn login_account_chatgpt_device_code_failure_notifies_without_account_upda
..Default::default()
},
)?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
mock_device_code_usercode(&mock_server, /*interval_seconds*/ 0).await;
mock_device_code_token_failure(&mock_server, /*status*/ 500).await;
@@ -2210,7 +2210,7 @@ async fn login_account_chatgpt_device_code_can_be_cancelled() -> Result<()> {
..Default::default()
},
)?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
mock_device_code_usercode(&mock_server, /*interval_seconds*/ 1).await;
mock_device_code_token_failure(&mock_server, /*status*/ 404).await;
diff --git a/codex-rs/app-server/tests/suite/v2/attestation.rs b/codex-rs/app-server/tests/suite/v2/attestation.rs
index 0260b05808..8b6b30b519 100644
--- a/codex-rs/app-server/tests/suite/v2/attestation.rs
+++ b/codex-rs/app-server/tests/suite/v2/attestation.rs
@@ -56,7 +56,6 @@ async fn attestation_generate_round_trip_adds_header_to_responses_websocket_hand
.await;
let codex_home = TempDir::new()?;
- write_models_cache(codex_home.path())?;
create_chatgpt_websocket_config(
codex_home.path(),
&websocket_server.uri().replacen("ws://", "http://", 1),
@@ -66,6 +65,7 @@ async fn attestation_generate_round_trip_adds_header_to_responses_websocket_hand
ChatGptAuthFixture::new("access-chatgpt").plan_type("pro"),
AuthCredentialsStoreMode::File,
)?;
+ write_models_cache(codex_home.path()).await?;
let mut mcp = TestAppServer::builder()
.with_codex_home(codex_home.path())
diff --git a/codex-rs/app-server/tests/suite/v2/dynamic_tools.rs b/codex-rs/app-server/tests/suite/v2/dynamic_tools.rs
index 349f4573d1..38cad9c430 100644
--- a/codex-rs/app-server/tests/suite/v2/dynamic_tools.rs
+++ b/codex-rs/app-server/tests/suite/v2/dynamic_tools.rs
@@ -601,7 +601,7 @@ async fn start_function_dynamic_tool_call(call_id: &str) -> Result<PendingDynami
let mut model_info =
codex_core::test_support::construct_model_info_offline("mock-model", &config);
model_info.input_modalities.push(InputModality::Audio);
- write_models_cache_with_models(codex_home.path(), vec![model_info])?;
+ write_models_cache_with_models(codex_home.path(), vec![model_info]).await?;
let mut mcp = TestAppServer::builder()
.with_codex_home(codex_home.path())
diff --git a/codex-rs/app-server/tests/suite/v2/guardian_code_mode_tests.rs b/codex-rs/app-server/tests/suite/v2/guardian_code_mode_tests.rs
index bd58be5eb3..3decacec04 100644
--- a/codex-rs/app-server/tests/suite/v2/guardian_code_mode_tests.rs
+++ b/codex-rs/app-server/tests/suite/v2/guardian_code_mode_tests.rs
@@ -127,7 +127,7 @@ async fn model_guardian_policy_scores_code_mode_cells(
shell: Some(GuardianReviewMode::Adaptive),
..Default::default()
});
- write_models_cache_with_models(codex_home.path(), vec![model])?;
+ write_models_cache_with_models(codex_home.path(), vec![model]).await?;
let mut app_server = TestAppServer::builder()
.with_codex_home(codex_home.path())
.build_initialized_with_timeout(TIMEOUT)
diff --git a/codex-rs/app-server/tests/suite/v2/guardian_policy_tests.rs b/codex-rs/app-server/tests/suite/v2/guardian_policy_tests.rs
index 20385c64f6..73c637b024 100644
--- a/codex-rs/app-server/tests/suite/v2/guardian_policy_tests.rs
+++ b/codex-rs/app-server/tests/suite/v2/guardian_policy_tests.rs
@@ -76,7 +76,7 @@ async fn model_guardian_policy_controls_cua(
computer_use: Some(computer_use),
..Default::default()
});
- write_models_cache_with_models(codex_home.path(), vec![model])?;
+ write_models_cache_with_models(codex_home.path(), vec![model]).await?;
let mut app_server = TestAppServer::builder()
.with_codex_home(codex_home.path())
.build_initialized_with_timeout(TIMEOUT)
diff --git a/codex-rs/app-server/tests/suite/v2/guardian_sync_session_tests.rs b/codex-rs/app-server/tests/suite/v2/guardian_sync_session_tests.rs
index 7f57f1370d..a3dfa3b6ab 100644
--- a/codex-rs/app-server/tests/suite/v2/guardian_sync_session_tests.rs
+++ b/codex-rs/app-server/tests/suite/v2/guardian_sync_session_tests.rs
@@ -284,7 +284,7 @@ async fn inline_review_delegate_runs_strict_guardian_assessment() -> Result<()>
let mut model = codex_core::test_support::construct_model_info_offline(MODEL, &config);
// Strict MCP approvals must work under the inline delegate's `never` policy.
model.node_repl_auto_review_required = true;
- write_models_cache_with_models(codex_home.path(), vec![model])?;
+ write_models_cache_with_models(codex_home.path(), vec![model]).await?;
let mut app = TestAppServer::builder()
.with_codex_home(codex_home.path())
.build_initialized_with_timeout(TIMEOUT)
diff --git a/codex-rs/app-server/tests/suite/v2/guardian_v2.rs b/codex-rs/app-server/tests/suite/v2/guardian_v2.rs
index 05f56210a2..8cb99e9ac2 100644
--- a/codex-rs/app-server/tests/suite/v2/guardian_v2.rs
+++ b/codex-rs/app-server/tests/suite/v2/guardian_v2.rs
@@ -131,7 +131,7 @@ async fn resumed_thread_does_not_wait_for_guardian_websocket_warmup() -> Result<
let config = load_default_config_for_test(&codex_home).await;
let mut model = codex_core::test_support::construct_model_info_offline(MODEL, &config);
model.node_repl_auto_review_required = true;
- write_models_cache_with_models(codex_home.path(), vec![model])?;
+ write_models_cache_with_models(codex_home.path(), vec![model]).await?;
let thread_id = create_fake_rollout(
codex_home.path(),
"2025-01-05T12-00-00",
@@ -833,7 +833,7 @@ async fn guardian_v2_routes_scoped_tool_approvals(
let config = load_default_config_for_test(&codex_home).await;
let mut model_info = codex_core::test_support::construct_model_info_offline(MODEL, &config);
model_info.node_repl_auto_review_required = true;
- write_models_cache_with_models(codex_home.path(), vec![model_info])?;
+ write_models_cache_with_models(codex_home.path(), vec![model_info]).await?;
}
let original_thread_id = match lifecycle {
ThreadLifecycle::New
@@ -2042,7 +2042,7 @@ async fn first_cua_review_does_not_wait_for_initial_score(
let config = load_default_config_for_test(&codex_home).await;
let mut model_info = codex_core::test_support::construct_model_info_offline(MODEL, &config);
model_info.node_repl_auto_review_required = true;
- write_models_cache_with_models(codex_home.path(), vec![model_info])?;
+ write_models_cache_with_models(codex_home.path(), vec![model_info]).await?;
let mut app_server = TestAppServer::builder()
.with_codex_home(codex_home.path())
.build_initialized_with_timeout(TIMEOUT)
@@ -2128,7 +2128,7 @@ async fn user_approval_skips_async_guardian_without_changing_other_modes() -> Re
let config = load_default_config_for_test(&codex_home).await;
let mut model_info = codex_core::test_support::construct_model_info_offline(MODEL, &config);
model_info.node_repl_auto_review_required = true;
- write_models_cache_with_models(codex_home.path(), vec![model_info])?;
+ write_models_cache_with_models(codex_home.path(), vec![model_info]).await?;
let mut app_server = TestAppServer::builder()
.with_codex_home(codex_home.path())
.build_initialized_with_timeout(TIMEOUT)
diff --git a/codex-rs/app-server/tests/suite/v2/guardian_v2_history_tests.rs b/codex-rs/app-server/tests/suite/v2/guardian_v2_history_tests.rs
index 9f626946b1..e5b5908ff3 100644
--- a/codex-rs/app-server/tests/suite/v2/guardian_v2_history_tests.rs
+++ b/codex-rs/app-server/tests/suite/v2/guardian_v2_history_tests.rs
@@ -314,12 +314,12 @@ async fn guardians_retain_evidence_after_compaction_and_discard_it_after_rollbac
info
})
.collect();
- write_models_cache_with_models(codex_home.path(), models)?;
write_chatgpt_auth(
codex_home.path(),
ChatGptAuthFixture::new("access-chatgpt").plan_type("pro"),
AuthCredentialsStoreMode::File,
)?;
+ write_models_cache_with_models(codex_home.path(), models).await?;
let mut app_server = TestAppServer::builder()
.with_codex_home(codex_home.path())
.with_env_overrides(&[("OPENAI_API_KEY", None)])
diff --git a/codex-rs/app-server/tests/suite/v2/guardian_v2_model_tests.rs b/codex-rs/app-server/tests/suite/v2/guardian_v2_model_tests.rs
index e2fb38d0ff..8e87490490 100644
--- a/codex-rs/app-server/tests/suite/v2/guardian_v2_model_tests.rs
+++ b/codex-rs/app-server/tests/suite/v2/guardian_v2_model_tests.rs
@@ -77,7 +77,7 @@ async fn computer_use_scoring_follows_model_review_requirement(
let mut reviewed_model =
codex_core::test_support::construct_model_info_offline(REVIEWED_MODEL, &config);
reviewed_model.node_repl_auto_review_required = true;
- write_models_cache_with_models(codex_home.path(), vec![ordinary_model, reviewed_model])?;
+ write_models_cache_with_models(codex_home.path(), vec![ordinary_model, reviewed_model]).await?;
let mut app_server = TestAppServer::builder()
.with_codex_home(codex_home.path())
.build_initialized_with_timeout(TIMEOUT)
diff --git a/codex-rs/app-server/tests/suite/v2/model_list.rs b/codex-rs/app-server/tests/suite/v2/model_list.rs
index 7e21fb6d8e..fbc262a308 100644
--- a/codex-rs/app-server/tests/suite/v2/model_list.rs
+++ b/codex-rs/app-server/tests/suite/v2/model_list.rs
@@ -60,7 +60,7 @@ fn model_from_preset(preset: &ModelPreset) -> Model {
.collect(),
default_reasoning_effort: preset.default_reasoning_effort.clone(),
input_modalities: preset.input_modalities.clone(),
- // `write_models_cache()` round-trips through a simplified ModelInfo fixture that does not
+ // `write_models_cache().await` round-trips through a simplified ModelInfo fixture that does not
// preserve personality placeholders in base instructions, so app-server list results from
// cache report `supports_personality = false`.
// todo(sayan): fix, maybe make roundtrip use ModelInfo only
@@ -101,7 +101,7 @@ fn expected_visible_models() -> Vec<Model> {
#[tokio::test]
async fn list_models_returns_all_models_with_large_limit() -> Result<()> {
let codex_home = TempDir::new()?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
let mut mcp = TestAppServer::builder()
.with_codex_home(codex_home.path())
.without_auto_env()
@@ -131,7 +131,7 @@ async fn list_models_returns_all_models_with_large_limit() -> Result<()> {
#[tokio::test]
async fn list_models_includes_hidden_models() -> Result<()> {
let codex_home = TempDir::new()?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
let mut mcp = TestAppServer::builder()
.with_codex_home(codex_home.path())
.without_auto_env()
@@ -286,7 +286,7 @@ openai_base_url = "{server_uri}/v1"
#[tokio::test]
async fn list_models_pagination_works() -> Result<()> {
let codex_home = TempDir::new()?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
let mut mcp = TestAppServer::builder()
.with_codex_home(codex_home.path())
.without_auto_env()
@@ -332,7 +332,7 @@ async fn list_models_pagination_works() -> Result<()> {
#[tokio::test]
async fn list_models_rejects_invalid_cursor() -> Result<()> {
let codex_home = TempDir::new()?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
let mut mcp = TestAppServer::builder()
.with_codex_home(codex_home.path())
.without_auto_env()
diff --git a/codex-rs/app-server/tests/suite/v2/multi_agent_v2_developer_instructions.rs b/codex-rs/app-server/tests/suite/v2/multi_agent_v2_developer_instructions.rs
index e5553bffdf..d4e0c71e43 100644
--- a/codex-rs/app-server/tests/suite/v2/multi_agent_v2_developer_instructions.rs
+++ b/codex-rs/app-server/tests/suite/v2/multi_agent_v2_developer_instructions.rs
@@ -198,7 +198,7 @@ async fn spawned_subagents_apply_configured_developer_instruction_precedence(
config
.with_extra_config(&feature_config)
.write(codex_home.path())?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
let mut app_server = TestAppServer::builder()
.with_codex_home(codex_home.path())
.build_initialized()
@@ -379,7 +379,7 @@ async fn compacted_full_history_fork_replaces_parent_developer_instructions() ->
"[features.multi_agent_v2]\nenabled = true\nsubagent_developer_instructions = {CHILD_INSTRUCTIONS:?}"
))
.write(codex_home.path())?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
let mut app_server = TestAppServer::builder()
.with_codex_home(codex_home.path())
@@ -641,7 +641,7 @@ async fn cold_resume_preserves_effective_developer_instructions_for_worker(
))
.with_extra_config(&feature_config)
.write(codex_home.path())?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
let (thread_id, child_resume_params, baseline) = {
let mut app_server = TestAppServer::builder()
diff --git a/codex-rs/app-server/tests/suite/v2/otel.rs b/codex-rs/app-server/tests/suite/v2/otel.rs
index bbaa3692be..197af70f4d 100644
--- a/codex-rs/app-server/tests/suite/v2/otel.rs
+++ b/codex-rs/app-server/tests/suite/v2/otel.rs
@@ -48,7 +48,7 @@ async fn account_switch_reloads_telemetry_collectors_and_preserves_trace_context
.email(INITIAL_EMAIL),
AuthCredentialsStoreMode::File,
)?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
let mut app_server = TestAppServer::builder()
.with_codex_home(codex_home.path())
diff --git a/codex-rs/app-server/tests/suite/v2/residency.rs b/codex-rs/app-server/tests/suite/v2/residency.rs
index 74cb932a67..89799dc4f7 100644
--- a/codex-rs/app-server/tests/suite/v2/residency.rs
+++ b/codex-rs/app-server/tests/suite/v2/residency.rs
@@ -27,7 +27,7 @@ enum ModelTransport {
Websocket,
}
-fn write_provider_config(
+async fn write_provider_config(
codex_home: &Path,
model_base_url: &str,
transport: ModelTransport,
@@ -60,7 +60,7 @@ supports_websockets = {supports_websockets}
"#
);
std::fs::write(codex_home.join("config.toml"), config)?;
- write_models_cache(codex_home)?;
+ write_models_cache(codex_home).await?;
Ok(())
}
@@ -98,7 +98,7 @@ async fn managed_residency_overrides_provider_headers(transport: ModelTransport)
};
let codex_home = TempDir::new()?;
- write_provider_config(codex_home.path(), &model_base_url, transport)?;
+ write_provider_config(codex_home.path(), &model_base_url, transport).await?;
std::fs::write(
codex_home.path().join("requirements.toml"),
"enforce_residency = \"us\"\n",
diff --git a/codex-rs/app-server/tests/suite/v2/thread_fork_multi_agent_tests.rs b/codex-rs/app-server/tests/suite/v2/thread_fork_multi_agent_tests.rs
index d8bde37558..305953ed83 100644
--- a/codex-rs/app-server/tests/suite/v2/thread_fork_multi_agent_tests.rs
+++ b/codex-rs/app-server/tests/suite/v2/thread_fork_multi_agent_tests.rs
@@ -47,7 +47,7 @@ async fn fork_before_first_turn_preserves_model_selected_multi_agent_version(
let config = load_default_config_for_test(&codex_home).await;
let mut model = codex_core::test_support::construct_model_info_offline("mock-model", &config);
model.multi_agent_version = Some(MultiAgentVersion::V2);
- write_models_cache_with_models(codex_home.path(), vec![model])?;
+ write_models_cache_with_models(codex_home.path(), vec![model]).await?;
let mut mcp = TestAppServer::builder()
.with_codex_home(codex_home.path())
.build_initialized()
diff --git a/codex-rs/app-server/tests/suite/v2/thread_revert.rs b/codex-rs/app-server/tests/suite/v2/thread_revert.rs
index 9bb8ff9281..a8a9cc8a49 100644
--- a/codex-rs/app-server/tests/suite/v2/thread_revert.rs
+++ b/codex-rs/app-server/tests/suite/v2/thread_revert.rs
@@ -63,7 +63,7 @@ async fn thread_revert_preserves_model_selected_multi_agent_version(restart: boo
let config = load_default_config_for_test(&codex_home).await;
let mut model = codex_core::test_support::construct_model_info_offline("mock-model", &config);
model.multi_agent_version = Some(MultiAgentVersion::V2);
- write_models_cache_with_models(codex_home.path(), vec![model])?;
+ write_models_cache_with_models(codex_home.path(), vec![model]).await?;
let mut mcp = TestAppServer::builder()
.with_codex_home(codex_home.path())
.build()
diff --git a/codex-rs/app-server/tests/suite/v2/thread_settings_update.rs b/codex-rs/app-server/tests/suite/v2/thread_settings_update.rs
index dee123f590..d51578dfdb 100644
--- a/codex-rs/app-server/tests/suite/v2/thread_settings_update.rs
+++ b/codex-rs/app-server/tests/suite/v2/thread_settings_update.rs
@@ -47,7 +47,7 @@ async fn thread_settings_update_emits_notification_and_updates_future_turns() ->
.await;
let codex_home = TempDir::new()?;
create_config_toml(codex_home.path(), &server.uri())?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
let (model_id, service_tier_id) = service_tier_model_and_tier_id()?;
let mut mcp = TestAppServer::builder()
@@ -289,7 +289,7 @@ async fn thread_settings_update_null_service_tier_uses_default() -> Result<()> {
.await;
let codex_home = TempDir::new()?;
create_config_toml(codex_home.path(), &server.uri())?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
let (model_id, service_tier_id) = service_tier_model_and_tier_id()?;
let mut mcp = TestAppServer::builder()
diff --git a/codex-rs/app-server/tests/suite/v2/turn_cost_otel.rs b/codex-rs/app-server/tests/suite/v2/turn_cost_otel.rs
index 80e3f2eabf..48cfbe1d14 100644
--- a/codex-rs/app-server/tests/suite/v2/turn_cost_otel.rs
+++ b/codex-rs/app-server/tests/suite/v2/turn_cost_otel.rs
@@ -113,7 +113,7 @@ metrics_exporter = {{ otlp-http = {{ endpoint = "{}/metrics", protocol = "json"
.chatgpt_user_id("user-a"),
AuthCredentialsStoreMode::File,
)?;
- write_models_cache(home.path())?;
+ write_models_cache(home.path()).await?;
let loader_overrides = LoaderOverrides::without_managed_config_for_tests();
let config = Arc::new(
ConfigBuilder::default()
diff --git a/codex-rs/app-server/tests/suite/v2/turn_start.rs b/codex-rs/app-server/tests/suite/v2/turn_start.rs
index e567bceb4a..d5c35e3d74 100644
--- a/codex-rs/app-server/tests/suite/v2/turn_start.rs
+++ b/codex-rs/app-server/tests/suite/v2/turn_start.rs
@@ -777,7 +777,7 @@ async fn turn_start_emits_thread_scoped_warning_notification_for_trimmed_skills(
MockResponsesConfig::new(&server.uri())
.enable_feature(Feature::Personality)
.write(codex_home.path())?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
let cache_path = codex_home.path().join("models_cache.json");
let mut cache: serde_json::Value =
serde_json::from_str(&std::fs::read_to_string(&cache_path)?)?;
@@ -874,7 +874,7 @@ async fn turn_start_sends_service_tier_id_to_model_request() -> Result<()> {
let codex_home = TempDir::new()?;
MockResponsesConfig::new(&server.uri()).write(codex_home.path())?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
let service_tier_model = all_model_presets()
.iter()
.find(|preset| preset.show_in_picker && !preset.service_tiers.is_empty())
@@ -998,7 +998,7 @@ async fn turn_start_emits_raw_response_completed_with_upstream_usage(
let codex_home = TempDir::new()?;
MockResponsesConfig::new(&server.uri()).write(codex_home.path())?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
let mut mcp = TestAppServer::builder()
.with_codex_home(codex_home.path())
@@ -3978,7 +3978,7 @@ async fn turn_start_streams_apply_patch_change_updates_v2() -> Result<()> {
.disable_feature(Feature::RemoteModels)
.disable_feature(Feature::ShellSnapshot)
.write(&codex_home)?;
- write_models_cache(&codex_home)?;
+ write_models_cache(&codex_home).await?;
let cache_path = codex_home.join("models_cache.json");
let mut cache: serde_json::Value =
serde_json::from_str(&std::fs::read_to_string(&cache_path)?)?;
@@ -4368,7 +4368,7 @@ async fn direct_input_to_multi_agent_v2_subagent_is_rejected(
.enable_feature(Feature::Goals)
.with_root_config(&format!("chatgpt_base_url = \"{}\"", server.uri()))
.write(codex_home.path())?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
mount_analytics_capture(&server, codex_home.path()).await?;
let mut mcp = TestAppServer::builder()
diff --git a/codex-rs/app-server/tests/suite/v2/view_image.rs b/codex-rs/app-server/tests/suite/v2/view_image.rs
index 2d88d82c61..8ea35efabd 100644
--- a/codex-rs/app-server/tests/suite/v2/view_image.rs
+++ b/codex-rs/app-server/tests/suite/v2/view_image.rs
@@ -50,7 +50,7 @@ async fn fresh_context_subagent_inherits_disabled_view_image_and_mcp_tools() ->
"[mcp_servers.{TEST_SERVER_NAME}]\nurl = \"{mcp_server_url}/mcp\"\n\n[features.multi_agent_v2]\nenabled = true"
))
.write(codex_home.path())?;
- write_models_cache(codex_home.path())?;
+ write_models_cache(codex_home.path()).await?;
let mut mcp = TestAppServer::builder()
.with_codex_home(codex_home.path())
diff --git a/codex-rs/core/tests/suite/injected_models_cache.rs b/codex-rs/core/tests/suite/injected_models_cache.rs
index 3d0d114c68..8d2ab86bd8 100644
--- a/codex-rs/core/tests/suite/injected_models_cache.rs
+++ b/codex-rs/core/tests/suite/injected_models_cache.rs
@@ -1,3 +1,5 @@
+//! Integration coverage for model catalogs supplied through the public cache interface.
+
use codex_core::TurnInputRequest;
use std::sync::Arc;
use std::sync::Mutex;
@@ -5,10 +7,13 @@ use std::sync::atomic::AtomicUsize;
use std::sync::atomic::Ordering;
use anyhow::Result;
+use base64::Engine;
use chrono::Utc;
use codex_http_client::HttpClientFactory;
use codex_login::AuthManager;
use codex_login::CodexAuth;
+use codex_model_provider::create_model_provider;
+use codex_model_provider_info::built_in_model_providers;
use codex_models_manager::cache::ModelsCache;
use codex_models_manager::cache::ModelsCacheEntry;
use codex_models_manager::cache::ModelsCacheError;
@@ -20,9 +25,11 @@ use codex_models_manager::manager::OpenAiModelsManager;
use codex_models_manager::manager::RefreshStrategy;
use codex_models_manager::manager::SharedModelsManager;
use codex_models_manager::model_info::model_info_from_slug;
+use codex_protocol::config_types::ReasoningSummary;
use codex_protocol::error::Result as CoreResult;
use codex_protocol::openai_models::ModelInfo;
use codex_protocol::openai_models::ModelVisibility;
+use codex_protocol::openai_models::ModelsResponse;
use codex_protocol::protocol::EventMsg;
use codex_protocol::protocol::ThreadSettingsOverrides;
use codex_protocol::user_input::UserInput;
@@ -36,12 +43,23 @@ use core_test_support::submit_thread_settings;
use core_test_support::test_codex::test_codex;
use core_test_support::wait_for_event;
use pretty_assertions::assert_eq;
+use tempfile::TempDir;
+use tokio::sync::oneshot;
+use tokio::time::Duration;
+use tokio::time::timeout;
+
+#[derive(Debug)]
+struct StoreGate {
+ entered: oneshot::Sender<()>,
+ release: oneshot::Receiver<()>,
+}
#[derive(Debug)]
struct TestModelsCache {
entry: Option<ModelsCacheEntry>,
load_error: bool,
stored_entries: Mutex<Vec<ModelsCacheEntry>>,
+ store_gate: Mutex<Option<StoreGate>>,
}
impl ModelsCache for TestModelsCache {
@@ -53,7 +71,13 @@ impl ModelsCache for TestModelsCache {
if self.load_error {
Err(ModelsCacheError::new("test load failure"))
} else {
- Ok(self.entry.clone())
+ Ok(self
+ .stored_entries
+ .lock()
+ .expect("stored entries lock should not be poisoned")
+ .last()
+ .cloned()
+ .or_else(|| self.entry.clone()))
}
})
}
@@ -67,6 +91,15 @@ impl ModelsCache for TestModelsCache {
.lock()
.expect("stored entries lock should not be poisoned")
.push(entry.clone());
+ let gate = self
+ .store_gate
+ .lock()
+ .expect("store gate lock should not be poisoned")
+ .take();
+ if let Some(StoreGate { entered, release }) = gate {
+ let _ = entered.send(());
+ let _ = release.await;
+ }
Ok(())
})
}
@@ -74,6 +107,8 @@ impl ModelsCache for TestModelsCache {
fn refresh_ttl<'a>(
&'a self,
_client_version: &'a str,
+ _identity: &'a str,
+ _etag: &'a str,
) -> ModelsCacheFuture<'a, Result<(), ModelsCacheError>> {
Box::pin(async move {
let mut entry = self
@@ -227,6 +262,7 @@ async fn injected_cache_hit_drives_agent_model_selection() -> Result<()> {
}),
load_error: false,
stored_entries: Mutex::new(Vec::new()),
+ store_gate: Mutex::new(None),
});
let endpoint = TestModelsEndpoint::new(Vec::new());
@@ -243,6 +279,7 @@ async fn injected_cache_error_falls_back_for_agent_model_selection() -> Result<(
entry: None,
load_error: true,
stored_entries: Mutex::new(Vec::new()),
+ store_gate: Mutex::new(None),
});
let endpoint = TestModelsEndpoint::new(vec![remote_model(model_slug)]);
@@ -258,3 +295,133 @@ async fn injected_cache_error_falls_back_for_agent_model_selection() -> Result<(
);
Ok(())
}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn account_switch_during_cache_store_preserves_new_catalog_for_next_turn() -> Result<()> {
+ let server = wiremock::MockServer::start().await;
+ let home = Arc::new(TempDir::new()?);
+ let initial_auth = CodexAuth::create_dummy_chatgpt_auth_for_testing();
+ let auth = AuthManager::from_auth_for_testing_with_home(
+ initial_auth.clone(),
+ home.path().to_path_buf(),
+ );
+ let mut provider_info = built_in_model_providers(/*openai_base_url*/ None)["openai"].clone();
+ provider_info.base_url = Some(format!("{}/v1", server.uri()));
+ provider_info.supports_websockets = false;
+ let cache = Arc::new(TestModelsCache {
+ entry: None,
+ load_error: false,
+ stored_entries: Mutex::new(Vec::new()),
+ store_gate: Mutex::new(None),
+ });
+ let manager = create_model_provider(provider_info.clone(), Some(auth.clone()))
+ .models_manager_with_cache(/*config_model_catalog*/ None, cache.clone());
+ let mut old_model = remote_model("gpt-5.4");
+ old_model.default_reasoning_summary = ReasoningSummary::Concise;
+ let initial = responses::mount_models_once(
+ &server,
+ ModelsResponse {
+ models: vec![old_model.clone()],
+ },
+ )
+ .await;
+ let test = test_codex()
+ .with_home(home.clone())
+ .with_auth(initial_auth.clone())
+ .with_model("gpt-5.4")
+ .with_models_manager(manager.clone())
+ .with_config(move |config| {
+ config.model_provider = provider_info;
+ config.model_reasoning_summary = None;
+ })
+ .build_with_auto_env(&server)
+ .await?;
+ assert_eq!(initial.requests().len(), 1);
+
+ // Pause after the old catalog has been stored, before its refresh can publish it.
+ let (store_entered, entered) = oneshot::channel();
+ let (release_store, release) = oneshot::channel();
+ *cache.store_gate.lock().unwrap() = Some(StoreGate {
+ entered: store_entered,
+ release,
+ });
+ let old_request = responses::mount_models_once(
+ &server,
+ ModelsResponse {
+ models: vec![old_model],
+ },
+ )
+ .await;
+ let old_refresh = tokio::spawn({
+ let manager = manager.clone();
+ async move {
+ manager
+ .list_models(
+ RefreshStrategy::Online,
+ codex_core::test_support::default_http_client_factory(),
+ )
+ .await
+ }
+ });
+ timeout(Duration::from_secs(10), entered).await??;
+
+ let mut tokens = initial_auth.get_token_data()?;
+ tokens.id_token.raw_jwt = format!(
+ "e30.{}.signature",
+ base64::engine::general_purpose::URL_SAFE_NO_PAD
+ .encode(br#"{"email":"[email protected]"}"#)
+ );
+ tokens.account_id = Some("second-account".into());
+ tokens.access_token = "second-account-token".into();
+ std::fs::write(
+ home.path().join("auth.json"),
+ serde_json::to_vec(&serde_json::json!({
+ "auth_mode": "chatgpt", "tokens": tokens, "last_refresh": Utc::now(),
+ }))?,
+ )?;
+ auth.reload().await;
+ test.thread_manager.auth_manager().reload().await;
+
+ let mut new_model = remote_model("gpt-5.4");
+ new_model.default_reasoning_summary = ReasoningSummary::Detailed;
+ let new_request = responses::mount_models_once(
+ &server,
+ ModelsResponse {
+ models: vec![new_model.clone()],
+ },
+ )
+ .await;
+ manager
+ .list_models(
+ RefreshStrategy::Online,
+ codex_core::test_support::default_http_client_factory(),
+ )
+ .await;
+ assert_eq!(manager.get_remote_models().await, vec![new_model.clone()]);
+ release_store.send(()).unwrap();
+ timeout(Duration::from_secs(10), old_refresh).await??;
+ assert_eq!(manager.get_remote_models().await, vec![new_model]);
+ for (mock, account) in [(old_request, "account_id"), (new_request, "second-account")] {
+ let requests = mock.requests();
+ assert_eq!(requests.len(), 1);
+ assert_eq!(requests[0].headers["chatgpt-account-id"], account);
+ }
+
+ let response = mount_sse_once(
+ &server,
+ sse(vec![
+ ev_response_created("next-turn"),
+ ev_completed("next-turn"),
+ ]),
+ )
+ .await;
+ test.submit_turn("use the new account's model defaults")
+ .await?;
+ let request = response.single_request();
+ assert_eq!(
+ request.header("chatgpt-account-id").as_deref(),
+ Some("second-account")
+ );
+ assert_eq!(request.body_json()["reasoning"]["summary"], "detailed");
+ Ok(())
+}
diff --git a/codex-rs/core/tests/suite/mod.rs b/codex-rs/core/tests/suite/mod.rs
index 1c23e2aba9..95eb4a4e0b 100644
--- a/codex-rs/core/tests/suite/mod.rs
+++ b/codex-rs/core/tests/suite/mod.rs
@@ -108,6 +108,7 @@ mod model_overrides;
mod model_runtime_selectors;
mod model_switching;
mod model_visible_layout;
+mod models_cache_auth;
mod models_cache_ttl;
mod models_etag_responses;
mod multi_agent_mode;
diff --git a/codex-rs/core/tests/suite/models_cache_auth.rs b/codex-rs/core/tests/suite/models_cache_auth.rs
new file mode 100644
index 0000000000..f1a1009e91
--- /dev/null
+++ b/codex-rs/core/tests/suite/models_cache_auth.rs
@@ -0,0 +1,144 @@
+//! Catalogs must follow auth and provider changes without leaking default billing tiers.
+
+use std::sync::Arc;
+
+use anyhow::Result;
+use codex_login::AuthCredentialsStoreMode;
+use codex_login::AuthKeyringBackendKind;
+use codex_login::CodexAuth;
+use codex_login::login_with_api_key;
+use codex_models_manager::bundled_models_response;
+use codex_models_manager::manager::RefreshStrategy;
+use codex_protocol::openai_models::ModelVisibility;
+use codex_protocol::openai_models::ModelsResponse;
+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 pretty_assertions::assert_eq;
+use tempfile::TempDir;
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn auth_and_provider_switches_do_not_reuse_chatgpt_catalog() -> Result<()> {
+ let server = wiremock::MockServer::start().await;
+ let home = Arc::new(TempDir::new()?);
+ let mut model = bundled_models_response()?
+ .models
+ .into_iter()
+ .find(|model| model.slug == "gpt-5.4")
+ .unwrap();
+ model.visibility = ModelVisibility::List;
+ model.default_service_tier = Some("priority".into());
+ let models_mock = responses::mount_models_once(
+ &server,
+ ModelsResponse {
+ models: vec![model.clone()],
+ },
+ )
+ .await;
+ let chatgpt = test_codex()
+ .with_home(home.clone())
+ .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
+ .with_model("gpt-5.4")
+ .build_with_auto_env(&server)
+ .await?;
+ assert!(home.path().join("models_cache.json").exists());
+ assert_eq!(
+ chatgpt
+ .thread_manager
+ .get_models_manager()
+ .get_remote_models()
+ .await,
+ vec![model.clone()]
+ );
+ login_with_api_key(
+ home.path(),
+ "api-key",
+ AuthCredentialsStoreMode::File,
+ AuthKeyringBackendKind::default(),
+ )?;
+ assert!(chatgpt.thread_manager.auth_manager().reload().await);
+ let manager = chatgpt.thread_manager.get_models_manager();
+ let bundled = bundled_models_response()?.models;
+ assert_eq!(manager.get_remote_models().await, bundled);
+ assert_eq!(
+ manager
+ .raw_model_catalog(
+ RefreshStrategy::Offline,
+ codex_core::test_support::default_http_client_factory()
+ )
+ .await
+ .models,
+ bundled
+ );
+ drop(chatgpt);
+
+ let api = test_codex()
+ .with_home(home.clone())
+ .with_auth(CodexAuth::from_api_key("api-key"))
+ .with_model("gpt-5.4")
+ .build_with_auto_env(&server)
+ .await?;
+ let ordinary = responses::mount_sse_once(
+ &server,
+ sse(vec![
+ ev_response_created("ordinary"),
+ ev_completed("ordinary"),
+ ]),
+ )
+ .await;
+ api.submit_turn("hello").await?;
+ assert_eq!(
+ ordinary.single_request().body_json().get("service_tier"),
+ None
+ );
+
+ let explicit = responses::mount_sse_once(
+ &server,
+ sse(vec![
+ ev_response_created("explicit"),
+ ev_completed("explicit"),
+ ]),
+ )
+ .await;
+ api.submit_turn_with_service_tier("hello again", Some("priority"))
+ .await?;
+ assert_eq!(
+ explicit.single_request().body_json()["service_tier"],
+ "priority"
+ );
+ assert_eq!(models_mock.requests().len(), 1);
+ drop(api);
+
+ let other_server = wiremock::MockServer::start().await;
+ model.default_service_tier = None;
+ model.display_name = "Second provider model".into();
+ let other_models = responses::mount_models_once(
+ &other_server,
+ ModelsResponse {
+ models: vec![model.clone()],
+ },
+ )
+ .await;
+ let other = test_codex()
+ .with_home(home)
+ .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
+ .with_model("gpt-5.4")
+ .with_config(|config| {
+ config.model_provider_id = "second".into();
+ config.model_provider.name = "Second".into();
+ })
+ .build_with_auto_env(&other_server)
+ .await?;
+ assert_eq!(
+ other
+ .thread_manager
+ .get_models_manager()
+ .get_remote_models()
+ .await,
+ vec![model]
+ );
+ assert_eq!(other_models.requests().len(), 1);
+ Ok(())
+}
diff --git a/codex-rs/core/tests/suite/models_cache_ttl.rs b/codex-rs/core/tests/suite/models_cache_ttl.rs
index 701ada2f8c..7a3fa935ba 100644
--- a/codex-rs/core/tests/suite/models_cache_ttl.rs
+++ b/codex-rs/core/tests/suite/models_cache_ttl.rs
@@ -289,9 +289,19 @@ async fn uses_cache_when_version_matches() -> Result<()> {
.await;
let mut builder = test_codex().with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing());
+ let identity = codex_model_provider::test_support::models_cache_entry(
+ &codex_model_provider_info::ModelProviderInfo::create_openai_provider(Some(format!(
+ "{}/v1",
+ server.uri()
+ ))),
+ Some(&CodexAuth::create_dummy_chatgpt_auth_for_testing()),
+ Vec::new(),
+ )
+ .identity;
builder = builder
.with_pre_build_hook(move |home| {
let mut cache = serde_json::to_value(ModelsCache {
+ identity,
fetched_at: Utc::now(),
etag: None,
client_version: Some(client_version_to_whole()),
@@ -354,9 +364,19 @@ async fn refreshes_when_cache_version_missing() -> Result<()> {
.await;
let mut builder = test_codex().with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing());
+ let identity = codex_model_provider::test_support::models_cache_entry(
+ &codex_model_provider_info::ModelProviderInfo::create_openai_provider(Some(format!(
+ "{}/v1",
+ server.uri()
+ ))),
+ Some(&CodexAuth::create_dummy_chatgpt_auth_for_testing()),
+ Vec::new(),
+ )
+ .identity;
builder = builder
.with_pre_build_hook(move |home| {
let cache = ModelsCache {
+ identity,
fetched_at: Utc::now(),
etag: None,
client_version: None,
@@ -404,10 +424,20 @@ async fn refreshes_when_cache_version_differs() -> Result<()> {
}
let mut builder = test_codex().with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing());
+ let identity = codex_model_provider::test_support::models_cache_entry(
+ &codex_model_provider_info::ModelProviderInfo::create_openai_provider(Some(format!(
+ "{}/v1",
+ server.uri()
+ ))),
+ Some(&CodexAuth::create_dummy_chatgpt_auth_for_testing()),
+ Vec::new(),
+ )
+ .identity;
builder = builder
.with_pre_build_hook(move |home| {
let client_version = client_version_to_whole();
let cache = ModelsCache {
+ identity,
fetched_at: Utc::now(),
etag: None,
client_version: Some(format!("{client_version}-diff")),
@@ -471,6 +501,8 @@ fn write_cache_sync(path: &Path, cache: &ModelsCache) -> Result<()> {
#[derive(Debug, Clone, Serialize, Deserialize)]
struct ModelsCache {
+ #[serde(default)]
+ identity: Option<String>,
fetched_at: DateTime<Utc>,
#[serde(default)]
etag: Option<String>,
diff --git a/codex-rs/model-provider/src/lib.rs b/codex-rs/model-provider/src/lib.rs
index f248f963fe..b3ca480d8c 100644
--- a/codex-rs/model-provider/src/lib.rs
+++ b/codex-rs/model-provider/src/lib.rs
@@ -5,6 +5,7 @@ mod models_endpoint;
mod models_identity;
mod provider;
mod shared_state;
+pub mod test_support;
pub use amazon_bedrock::is_supported_amazon_bedrock_region;
pub use auth::AgentIdentitySessionFallback;
diff --git a/codex-rs/model-provider/src/models_endpoint.rs b/codex-rs/model-provider/src/models_endpoint.rs
index 76bf039f2a..12a2917bc5 100644
--- a/codex-rs/model-provider/src/models_endpoint.rs
+++ b/codex-rs/model-provider/src/models_endpoint.rs
@@ -456,4 +456,104 @@ mod tests {
Some(&"eu".into())
);
}
+
+ #[derive(Debug)]
+ struct RotatingAuth(std::sync::atomic::AtomicUsize);
+
+ impl codex_login::ExternalAuth for RotatingAuth {
+ fn resolve(&self) -> codex_login::ExternalAuthFuture<'_, CodexAuth> {
+ Box::pin(async move {
+ let generation = self.0.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+ Ok(CodexAuth::from_api_key(&format!("token-{generation}")))
+ })
+ }
+
+ fn refresh(
+ &self,
+ _context: codex_login::ExternalAuthRefreshContext,
+ ) -> codex_login::ExternalAuthFuture<'_, CodexAuth> {
+ self.resolve()
+ }
+ }
+
+ #[tokio::test]
+ async fn command_auth_refresh_fetches_a_catalog_for_the_current_credentials() {
+ use codex_models_manager::manager::ModelsManager;
+ use codex_models_manager::manager::OpenAiModelsManager;
+ use codex_models_manager::manager::RefreshStrategy;
+
+ let server = MockServer::start().await;
+ let auth = AuthManager::from_auth_for_testing(CodexAuth::from_api_key("initial"));
+ auth.set_external_auth(Arc::new(RotatingAuth(std::sync::atomic::AtomicUsize::new(
+ 0,
+ ))))
+ .await
+ .unwrap();
+ let model = codex_protocol::openai_models::ModelInfo {
+ used_fallback_model_metadata: false,
+ ..codex_models_manager::model_info::model_info_from_slug("command-auth-model")
+ };
+ Mock::given(method("GET"))
+ .and(path("/models"))
+ .respond_with(ResponseTemplate::new(200).set_body_json(ModelsResponse {
+ models: vec![model.clone()],
+ }))
+ .expect(2)
+ .mount(&server)
+ .await;
+ let mut provider = provider_info_with_command_auth();
+ provider.base_url = Some(server.uri());
+ // Keep this test independent of the residency override exercised in parallel.
+ provider.http_headers = Some(std::collections::HashMap::from([(
+ RESIDENCY_HEADER_NAME.to_string(),
+ "us".into(),
+ )]));
+ let manager = OpenAiModelsManager::new_without_cache(
+ Arc::new(OpenAiModelsEndpoint::new(provider, Some(auth.clone()))),
+ Some(auth.clone()),
+ );
+ let catalog = manager
+ .raw_model_catalog(
+ RefreshStrategy::OnlineIfUncached,
+ HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault),
+ )
+ .await;
+ assert_eq!(
+ catalog
+ .models
+ .iter()
+ .find(|candidate| candidate.slug == model.slug),
+ Some(&model)
+ );
+ auth.auth().await;
+ let bundled = codex_models_manager::bundled_models_response().unwrap();
+ assert_eq!(manager.get_remote_models().await, bundled.models);
+ assert_eq!(manager.try_get_remote_models().unwrap(), bundled.models);
+ assert_eq!(
+ manager
+ .raw_model_catalog(
+ RefreshStrategy::Offline,
+ HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault),
+ )
+ .await,
+ bundled
+ );
+ assert_eq!(
+ manager
+ .raw_model_catalog(
+ RefreshStrategy::OnlineIfUncached,
+ HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault),
+ )
+ .await,
+ catalog
+ );
+ let requests = server.received_requests().await.unwrap();
+ assert_eq!(
+ requests
+ .iter()
+ .map(|request| request.headers["authorization"].to_str().unwrap())
+ .collect::<Vec<_>>(),
+ vec!["Bearer token-2", "Bearer token-6"]
+ );
+ }
}
diff --git a/codex-rs/model-provider/src/test_support.rs b/codex-rs/model-provider/src/test_support.rs
new file mode 100644
index 0000000000..2e017aee55
--- /dev/null
+++ b/codex-rs/model-provider/src/test_support.rs
@@ -0,0 +1,21 @@
+//! Fixtures for integration tests that seed the provider's model cache.
+
+use codex_login::CodexAuth;
+use codex_model_provider_info::ModelProviderInfo;
+use codex_models_manager::cache::ModelsCacheEntry;
+use codex_protocol::openai_models::ModelInfo;
+
+/// Constructs a cache fixture matching the supplied test provider and authentication.
+pub fn models_cache_entry(
+ provider_info: &ModelProviderInfo,
+ auth: Option<&CodexAuth>,
+ models: Vec<ModelInfo>,
+) -> ModelsCacheEntry {
+ ModelsCacheEntry {
+ fetched_at: std::time::SystemTime::now().into(),
+ etag: None,
+ client_version: Some(codex_models_manager::client_version_to_whole()),
+ identity: crate::models_identity::identity(provider_info, auth).ok(),
+ models,
+ }
+}
diff --git a/codex-rs/models-manager/src/cache.rs b/codex-rs/models-manager/src/cache.rs
index 240ec7e11b..14d08977f4 100644
--- a/codex-rs/models-manager/src/cache.rs
+++ b/codex-rs/models-manager/src/cache.rs
@@ -17,8 +17,8 @@ use tracing::info;
///
/// Implementations own cache freshness and lookup partitioning. [`ModelsCache::load`] must not
/// return stale entries or entries for a different client version. A shared backend must also keep
-/// catalogs for different providers and tenants separate, typically through configuration captured
-/// by the implementation.
+/// catalogs for different providers and tenants separate. The manager also validates the entry
+/// identity against the current endpoint before using it.
///
/// Cache failures are non-fatal. The models manager logs them and falls back to the configured
/// models endpoint.
@@ -42,16 +42,18 @@ pub trait ModelsCache: fmt::Debug + Send + Sync {
entry: &'a ModelsCacheEntry,
) -> ModelsCacheFuture<'a, Result<(), ModelsCacheError>>;
- /// Extends the freshness of the entry for `client_version` without changing its catalog.
+ /// Extends freshness only if the stored version, identity, and ETag match.
///
/// The models manager calls this after the endpoint confirms that the cached ETag is still
- /// current. Implementations must preserve the models, ETag, and client version. This operation
+ /// current. Implementations must preserve the models, identity, ETag, and client version. This operation
/// cannot be expressed in terms of [`ModelsCache::load`], because `load` intentionally omits
/// expired entries. File-backed implementations can read and revalidate the stored entry
/// directly, while backends with native TTL support can extend the entry in place.
fn refresh_ttl<'a>(
&'a self,
client_version: &'a str,
+ identity: &'a str,
+ etag: &'a str,
) -> ModelsCacheFuture<'a, Result<(), ModelsCacheError>>;
}
@@ -71,7 +73,7 @@ pub struct ModelsCacheEntry {
/// The models manager rejects entries whose value is absent or differs from its current version.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub client_version: Option<String>,
- /// Opaque provider and auth identity associated with this catalog.
+ /// Opaque provider and auth identity. Unscoped legacy entries are cache misses.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub identity: Option<String>,
/// Models returned by the catalog endpoint.
@@ -154,14 +156,20 @@ impl ModelsCache for FileModelsCache {
fn refresh_ttl<'a>(
&'a self,
- _client_version: &'a str,
+ client_version: &'a str,
+ identity: &'a str,
+ etag: &'a str,
) -> ModelsCacheFuture<'a, Result<(), ModelsCacheError>> {
Box::pin(async move {
let mut entry = load_file(&self.cache_path)
.await
.map_err(cache_error)?
.ok_or_else(|| ModelsCacheError::new("cache not found"))?;
- if entry.is_fresh(self.cache_ttl / 2) {
+ if entry.client_version.as_deref() != Some(client_version)
+ || entry.identity.as_deref() != Some(identity)
+ || entry.etag.as_deref() != Some(etag)
+ || entry.is_fresh(self.cache_ttl / 2)
+ {
return Ok(());
}
entry.fetched_at = Utc::now();
diff --git a/codex-rs/models-manager/src/cache_identity_tests.rs b/codex-rs/models-manager/src/cache_identity_tests.rs
new file mode 100644
index 0000000000..b4fbe252c0
--- /dev/null
+++ b/codex-rs/models-manager/src/cache_identity_tests.rs
@@ -0,0 +1,83 @@
+//! Coverage for cache identity validation and conditional freshness updates.
+
+use super::*;
+use pretty_assertions::assert_eq;
+
+#[tokio::test]
+async fn mismatched_and_legacy_cache_entries_fetch_the_current_catalog() {
+ for identity in [None, Some("other-provider-or-account".to_string())] {
+ let stale = remote_model("stale", "Stale", /*priority*/ 0);
+ let current = remote_model("current", "Current", /*priority*/ 0);
+ let cache = TestModelsCache::with_entry(ModelsCacheEntry {
+ fetched_at: Utc::now(),
+ etag: Some("old-etag".into()),
+ client_version: Some(crate::client_version_to_whole()),
+ identity,
+ models: vec![stale],
+ });
+ let endpoint = TestModelsEndpoint::new(vec![vec![current.clone()]]);
+ let manager = OpenAiModelsManager::new_with_cache(
+ cache.clone(),
+ endpoint.clone(),
+ Some(AuthManager::from_auth_for_testing(
+ CodexAuth::create_dummy_chatgpt_auth_for_testing(),
+ )),
+ );
+ assert_eq!(
+ manager
+ .raw_model_catalog(
+ RefreshStrategy::OnlineIfUncached,
+ DEFAULT_HTTP_CLIENT_FACTORY
+ )
+ .await
+ .models,
+ vec![current.clone()]
+ );
+ assert_eq!(endpoint.fetch_count(), 1);
+ }
+}
+
+#[tokio::test]
+async fn matching_etag_cannot_renew_a_different_identity_or_catalog() {
+ let home = tempdir().unwrap();
+ let cache = FileModelsCache::new(home.path().join(MODEL_CACHE_FILE), DEFAULT_MODEL_CACHE_TTL);
+ let expected = ModelsCacheEntry {
+ fetched_at: Utc::now() - chrono::Duration::hours(1),
+ etag: Some("etag".into()),
+ client_version: Some(crate::client_version_to_whole()),
+ identity: Some("first-account".into()),
+ models: vec![remote_model("model", "Model", /*priority*/ 0)],
+ };
+ for (key, etag, version) in [
+ ("other-account", "etag", crate::client_version_to_whole()),
+ (
+ "first-account",
+ "new-etag",
+ crate::client_version_to_whole(),
+ ),
+ ("first-account", "etag", "other-version".into()),
+ ] {
+ let stored = ModelsCacheEntry {
+ identity: Some(key.into()),
+ etag: Some(etag.into()),
+ client_version: Some(version),
+ ..expected.clone()
+ };
+ cache.store(&stored).await.unwrap();
+ cache
+ .refresh_ttl(
+ expected.client_version.as_deref().unwrap(),
+ expected.identity.as_deref().unwrap(),
+ expected.etag.as_deref().unwrap(),
+ )
+ .await
+ .unwrap();
+ let actual: ModelsCacheEntry = serde_json::from_slice(
+ &tokio::fs::read(home.path().join(MODEL_CACHE_FILE))
+ .await
+ .unwrap(),
+ )
+ .unwrap();
+ assert_eq!(actual, stored);
+ }
+}
diff --git a/codex-rs/models-manager/src/manager.rs b/codex-rs/models-manager/src/manager.rs
index 9b37abe10e..cb38919900 100644
--- a/codex-rs/models-manager/src/manager.rs
+++ b/codex-rs/models-manager/src/manager.rs
@@ -38,7 +38,7 @@ pub trait ModelsEndpointClient: fmt::Debug + Send + Sync {
/// Opaque identity of the current provider and credentials, without resolving auth.
///
/// Must change when account, email, plan, provider, or API credentials change.
- /// Return `None` when identity is unavailable.
+ /// Return `None` when identity is unavailable; cached catalog reuse is then disabled.
fn identity(&self) -> Option<String>;
/// Returns whether this provider can authenticate command-scoped requests.
@@ -232,8 +232,7 @@ pub type SharedModelsManager = Arc<dyn ModelsManager>;
/// OpenAI-compatible model manager backed by bundled models, cache, and `/models`.
#[derive(Debug)]
pub struct OpenAiModelsManager {
- remote_models: RwLock<Vec<ModelInfo>>,
- etag: RwLock<Option<String>>,
+ remote_models: RwLock<ModelsCacheEntry>,
cache: Option<Arc<dyn ModelsCache>>,
endpoint_client: SharedModelsEndpointClient,
auth_manager: Option<Arc<AuthManager>>,
@@ -291,8 +290,13 @@ impl OpenAiModelsManager {
) -> Self {
let remote_models = load_remote_models_from_file().unwrap_or_default();
Self {
- remote_models: RwLock::new(remote_models),
- etag: RwLock::new(None),
+ remote_models: RwLock::new(ModelsCacheEntry {
+ fetched_at: Utc::now(),
+ etag: None,
+ client_version: Some(crate::client_version_to_whole()),
+ identity: endpoint_client.identity(),
+ models: remote_models,
+ }),
cache,
endpoint_client,
auth_manager,
@@ -324,11 +328,25 @@ impl ModelsManager for OpenAiModelsManager {
}
fn get_remote_models(&self) -> ModelsManagerFuture<'_, Vec<ModelInfo>> {
- Box::pin(async move { self.remote_models.read().await.clone() })
+ Box::pin(async move {
+ let entry = self.remote_models.read().await;
+ if entry.identity.is_some() && entry.identity == self.endpoint_client.identity() {
+ entry.models.clone()
+ } else {
+ load_remote_models_from_file().unwrap_or_default()
+ }
+ })
}
fn try_get_remote_models(&self) -> Result<Vec<ModelInfo>, TryLockError> {
- Ok(self.remote_models.try_read()?.clone())
+ let entry = self.remote_models.try_read()?;
+ Ok(
+ if entry.identity.is_some() && entry.identity == self.endpoint_client.identity() {
+ entry.models.clone()
+ } else {
+ load_remote_models_from_file().unwrap_or_default()
+ },
+ )
}
fn auth_manager(&self) -> Option<&AuthManager> {
@@ -370,10 +388,18 @@ impl OpenAiModelsManager {
}
async fn refresh_if_new_etag(&self, etag: String, http_client_factory: HttpClientFactory) {
- let current_etag = self.get_etag().await;
- if current_etag.clone().is_some() && current_etag.as_deref() == Some(etag.as_str()) {
+ let (identity, current_etag) = {
+ let entry = self.remote_models.read().await;
+ (entry.identity.clone(), entry.etag.clone())
+ };
+ if let Some(identity) = identity
+ && Some(&identity) == self.endpoint_client.identity().as_ref()
+ && current_etag.as_deref() == Some(etag.as_str())
+ {
if let Some(cache) = self.cache.as_ref()
- && let Err(err) = cache.refresh_ttl(&crate::client_version_to_whole()).await
+ && let Err(err) = cache
+ .refresh_ttl(&crate::client_version_to_whole(), &identity, &etag)
+ .await
{
error!("failed to renew cache TTL: {err}");
}
@@ -402,26 +428,18 @@ impl OpenAiModelsManager {
}
return Ok(());
}
-
match refresh_strategy {
RefreshStrategy::Offline => {
- // Only try to load from cache, never fetch
self.try_load_cache().await;
Ok(())
}
RefreshStrategy::OnlineIfUncached => {
- // Try cache first, fall back to online if unavailable
if self.try_load_cache().await {
- info!("models cache: using cached models for OnlineIfUncached");
return Ok(());
}
- info!("models cache: cache miss, fetching remote models");
- self.fetch_and_update_models(http_client_factory).await
- }
- RefreshStrategy::Online => {
- // Always fetch from network
self.fetch_and_update_models(http_client_factory).await
}
+ RefreshStrategy::Online => self.fetch_and_update_models(http_client_factory).await,
}
}
@@ -438,20 +456,22 @@ impl OpenAiModelsManager {
.endpoint_client
.list_models(&client_version, http_client_factory.clone())
.await?;
- self.apply_remote_models(models.clone()).await;
- *self.etag.write().await = etag.clone();
- if let Some(cache) = self.cache.as_ref() {
- let entry = ModelsCacheEntry {
- fetched_at: Utc::now(),
- etag,
- client_version: Some(client_version),
- identity: Some(identity),
- models,
- };
- if let Err(err) = cache.store(&entry).await {
- error!("failed to write models cache: {err}");
- }
+ if Some(&identity) != self.endpoint_client.identity().as_ref() {
+ return Ok(());
+ }
+ let entry = ModelsCacheEntry {
+ fetched_at: Utc::now(),
+ etag,
+ client_version: Some(client_version),
+ identity: Some(identity),
+ models,
+ };
+ if let Some(cache) = self.cache.as_ref()
+ && let Err(err) = cache.store(&entry).await
+ {
+ error!("failed to write models cache: {err}");
}
+ self.apply_remote_models(entry).await;
Ok(())
}
@@ -459,40 +479,38 @@ impl OpenAiModelsManager {
self.endpoint_client.uses_codex_backend().await || self.endpoint_client.has_command_auth()
}
- async fn get_etag(&self) -> Option<String> {
- self.etag.read().await.clone()
- }
-
- /// Replace the cached remote models and rebuild the derived presets list.
- async fn apply_remote_models(&self, models: Vec<ModelInfo>) {
- // Use the remote models list as the source of truth if it contains at least one
- // non-hidden model and the user is using ChatGPT auth.
- let should_use_remote_models_only = !models.is_empty()
- && models
- .iter()
- .any(|model| model.visibility == ModelVisibility::List)
+ /// Publish only while the request identity still matches, including after async storage.
+ async fn apply_remote_models(&self, mut entry: ModelsCacheEntry) -> bool {
+ let mut current = self.remote_models.write().await;
+ if entry.identity != self.endpoint_client.identity() {
+ return false;
+ }
+ // Visible ChatGPT catalogs are authoritative; other catalogs augment bundled metadata.
+ let remote_only = entry
+ .models
+ .iter()
+ .any(|model| model.visibility == ModelVisibility::List)
&& self.auth_manager.as_ref().is_some_and(|auth_manager| {
auth_manager
.auth_mode()
.is_some_and(AuthMode::has_chatgpt_account)
});
- if should_use_remote_models_only {
- *self.remote_models.write().await = models;
- return;
- }
-
- let mut existing_models = load_remote_models_from_file().unwrap_or_default();
- for model in models {
- if let Some(existing_index) = existing_models
- .iter()
- .position(|existing| existing.slug == model.slug)
- {
- existing_models[existing_index] = model;
- } else {
- existing_models.push(model);
+ if !remote_only {
+ let mut models = load_remote_models_from_file().unwrap_or_default();
+ for model in entry.models {
+ if let Some(index) = models
+ .iter()
+ .position(|existing| existing.slug == model.slug)
+ {
+ models[index] = model;
+ } else {
+ models.push(model);
+ }
}
+ entry.models = models;
}
- *self.remote_models.write().await = existing_models;
+ *current = entry;
+ true
}
/// Attempt to satisfy the refresh from the cache when it matches the provider and TTL.
@@ -504,8 +522,9 @@ impl OpenAiModelsManager {
codex_otel::start_global_timer("codex.remote_models.load_cache.duration_ms", &[]);
let client_version = crate::client_version_to_whole();
info!(client_version, "models cache: evaluating cache eligibility");
- // TODO(celia-oai): Include provider identity in cache eligibility so switching
- // providers does not reuse a fresh models_cache.json entry from another provider.
+ let Some(identity) = self.endpoint_client.identity() else {
+ return false;
+ };
let cache_entry = match cache.load(&client_version).await {
Ok(Some(cache_entry)) => cache_entry,
Ok(None) => {
@@ -525,15 +544,13 @@ impl OpenAiModelsManager {
);
return false;
}
- let models = cache_entry.models.clone();
- *self.etag.write().await = cache_entry.etag.clone();
- self.apply_remote_models(models.clone()).await;
- info!(
- models_count = models.len(),
- etag = ?cache_entry.etag,
- "models cache: cache entry applied"
- );
- true
+ if cache_entry.identity.as_ref() != Some(&identity)
+ || self.endpoint_client.identity().as_ref() != Some(&identity)
+ {
+ info!("models cache: provider or auth identity mismatch");
+ return false;
+ }
+ self.apply_remote_models(cache_entry).await
}
}
diff --git a/codex-rs/models-manager/src/manager_tests.rs b/codex-rs/models-manager/src/manager_tests.rs
index 78ecf95336..b3f732c0ae 100644
--- a/codex-rs/models-manager/src/manager_tests.rs
+++ b/codex-rs/models-manager/src/manager_tests.rs
@@ -27,6 +27,9 @@ use std::sync::atomic::AtomicUsize;
use std::sync::atomic::Ordering;
use tempfile::tempdir;
+#[path = "cache_identity_tests.rs"]
+mod cache_identity_tests;
+
#[path = "model_info_overrides_tests.rs"]
mod model_info_overrides_tests;
@@ -164,6 +167,8 @@ impl ModelsCache for TestModelsCache {
fn refresh_ttl<'a>(
&'a self,
_client_version: &'a str,
+ _identity: &'a str,
+ _etag: &'a str,
) -> ModelsCacheFuture<'a, Result<(), ModelsCacheError>> {
Box::pin(async move {
let refreshed = {
@@ -394,7 +399,11 @@ async fn file_cache_refresh_ttl_renews_expired_entry_without_serving_it_stale()
);
cache
- .refresh_ttl(&client_version)
+ .refresh_ttl(
+ &client_version,
+ entry.identity.as_deref().unwrap(),
+ entry.etag.as_deref().unwrap(),
+ )
.await
.expect("TTL refresh succeeds");
diff --git a/codex-rs/tui/src/status/tests.rs b/codex-rs/tui/src/status/tests.rs
index e644dcb2cc..b6482d462b 100644
--- a/codex-rs/tui/src/status/tests.rs
+++ b/codex-rs/tui/src/status/tests.rs
@@ -358,7 +358,6 @@ async fn status_snapshot_includes_reasoning_details() {
#[tokio::test]
async fn status_snapshot_shows_chatgpt_plan_without_email() {
let temp_home = TempDir::new().expect("temp home");
- write_models_cache(temp_home.path()).expect("write models cache");
let mut config = test_config(&temp_home).await;
config.model = Some("gpt-5.1-codex-max".to_string());
config.model_provider_id = "openai".to_string();
@@ -371,6 +370,9 @@ async fn status_snapshot_shows_chatgpt_plan_without_email() {
AuthCredentialsStoreMode::File,
)
.expect("write email-less ChatGPT auth");
+ write_models_cache(temp_home.path())
+ .await
+ .expect("write models cache");
let mut app_server = crate::start_embedded_app_server_for_picker(&config)
.await
.expect("start embedded app server");