mirror of
https://github.com/openai/codex.git
synced 2026-11-18 22:20:48 +00:00
## What changed Recognize `orbit_cca`, `orbit_cca_web`, `orbit_cca_desktop`, and `orbit_cca_mobile` as separate model catalog originators, giving each its own manager and disk cache. ## Testing Extend catalog isolation coverage to the Orbit originators, including cache reuse after manager recreation and avoiding redundant refreshes when the catalog ETag is unchanged. GitOrigin-RevId: 9507daae5c418212c9fed1be76df9aaa43c9d73f
199 lines
7.6 KiB
Rust
199 lines
7.6 KiB
Rust
//! End-to-end catalog partitioning through provider headers, manager state, and file storage.
|
|
|
|
use super::*;
|
|
use codex_http_client::OutboundProxyPolicy;
|
|
use codex_models_manager::manager::ModelsManager;
|
|
use codex_models_manager::manager::OpenAiModelsManager;
|
|
use codex_models_manager::manager::RefreshStrategy;
|
|
use codex_models_manager::model_info::model_info_from_slug;
|
|
use codex_protocol::openai_models::ModelsResponse;
|
|
use pretty_assertions::assert_eq;
|
|
use wiremock::Mock;
|
|
use wiremock::MockServer;
|
|
use wiremock::ResponseTemplate;
|
|
use wiremock::matchers::header;
|
|
use wiremock::matchers::method;
|
|
use wiremock::matchers::path;
|
|
|
|
/// Runtime discovery updates reach existing and newly created scopes, including cached catalogs.
|
|
#[tokio::test]
|
|
async fn originator_managers_share_api_key_discovery_policy() {
|
|
let server = MockServer::start().await;
|
|
let home = tempfile::tempdir().unwrap();
|
|
let mut provider = ModelProviderInfo::create_openai_provider(Some(server.uri()));
|
|
provider.model_catalog_url = Some(format!("{}/models", server.uri()).into());
|
|
provider.http_headers = Some(std::collections::HashMap::from([(
|
|
codex_model_provider_info::RESIDENCY_HEADER_NAME.to_string(),
|
|
"us".into(),
|
|
)]));
|
|
let mut model = model_info_from_slug("gpt-5.5");
|
|
model.visibility = codex_protocol::openai_models::ModelVisibility::List;
|
|
|
|
let catalog = ModelsResponse {
|
|
models: vec![model],
|
|
};
|
|
for originator in ["codex_work_cca", "chatgpt_cca"] {
|
|
Mock::given(method("GET"))
|
|
.and(path("/models"))
|
|
.and(header("originator", originator))
|
|
.respond_with(ResponseTemplate::new(200).set_body_json(&catalog))
|
|
.expect(1)
|
|
.mount(&server)
|
|
.await;
|
|
}
|
|
let auth = AuthManager::from_auth_for_testing(CodexAuth::from_api_key("test-key"));
|
|
let endpoint = Arc::new(OpenAiModelsEndpoint::new(
|
|
provider,
|
|
Some(Arc::clone(&auth)),
|
|
/*gateway_auth_manager*/ None,
|
|
));
|
|
let manager = OpenAiModelsManager::new(home.path().to_path_buf(), endpoint, Some(auth));
|
|
let work = manager.for_originator("codex_work_cca").unwrap();
|
|
let bundled = codex_models_manager::bundled_models_response().unwrap();
|
|
let client = HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault);
|
|
assert_eq!(
|
|
work.raw_model_catalog(RefreshStrategy::Online, client.clone())
|
|
.await,
|
|
bundled
|
|
);
|
|
assert!(server.received_requests().await.unwrap().is_empty());
|
|
|
|
manager.set_api_key_model_discovery_enabled(/*enabled*/ true);
|
|
let chat = manager.for_originator("chatgpt_cca").unwrap();
|
|
for child in [&work, &chat] {
|
|
assert_eq!(
|
|
child
|
|
.raw_model_catalog(RefreshStrategy::OnlineIfUncached, client.clone())
|
|
.await,
|
|
catalog
|
|
);
|
|
}
|
|
|
|
manager.set_api_key_model_discovery_enabled(/*enabled*/ false);
|
|
for child in [&work, &chat] {
|
|
assert_eq!(
|
|
child
|
|
.raw_model_catalog(RefreshStrategy::Online, client.clone())
|
|
.await,
|
|
bundled
|
|
);
|
|
assert_eq!(child.try_get_remote_models().unwrap(), bundled.models);
|
|
}
|
|
|
|
manager.set_api_key_model_discovery_enabled(/*enabled*/ true);
|
|
for child in [&work, &chat] {
|
|
assert_eq!(
|
|
child
|
|
.raw_model_catalog(RefreshStrategy::OnlineIfUncached, client.clone())
|
|
.await,
|
|
catalog
|
|
);
|
|
}
|
|
server.verify().await;
|
|
}
|
|
|
|
/// Concurrent reads and restarts reuse each originator's own model catalog.
|
|
#[tokio::test]
|
|
async fn originator_catalogs_are_isolated_and_reused_from_disk() {
|
|
let server = MockServer::start().await;
|
|
let home = tempfile::tempdir().unwrap();
|
|
let mut provider = ModelProviderInfo::create_openai_provider(Some(server.uri()));
|
|
// The managed-residency test toggles the process-wide US policy. Keep this
|
|
// provider's cache identity stable whether that policy is enabled or disabled.
|
|
provider.http_headers = Some(std::collections::HashMap::from([
|
|
("Originator".to_string(), "provider-default".into()),
|
|
(
|
|
codex_model_provider_info::RESIDENCY_HEADER_NAME.to_string(),
|
|
"us".into(),
|
|
),
|
|
]));
|
|
let surface_originators = [
|
|
// A single account can see different models in each client.
|
|
"codex_work_web",
|
|
"codex_work_desktop",
|
|
"codex_work_mobile",
|
|
"orbit_cca",
|
|
"orbit_cca_web",
|
|
"orbit_cca_desktop",
|
|
"orbit_cca_mobile",
|
|
];
|
|
let mut catalogs = Vec::new();
|
|
for originator in ["provider-default", "codex_work_cca", "chatgpt_cca"]
|
|
.into_iter()
|
|
.chain(surface_originators)
|
|
{
|
|
let mut model = model_info_from_slug("gpt-5.5");
|
|
model.visibility = codex_protocol::openai_models::ModelVisibility::List;
|
|
|
|
model.description = Some(originator.to_string());
|
|
let catalog = ModelsResponse {
|
|
models: vec![model],
|
|
};
|
|
Mock::given(method("GET"))
|
|
.and(path("/models"))
|
|
.and(header("originator", originator))
|
|
.respond_with(
|
|
ResponseTemplate::new(200)
|
|
.insert_header("etag", format!("\"{originator}\""))
|
|
.set_body_json(&catalog),
|
|
)
|
|
.expect(1)
|
|
.mount(&server)
|
|
.await;
|
|
catalogs.push(catalog);
|
|
}
|
|
let client = HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault);
|
|
for _ in 0..2 {
|
|
let auth =
|
|
AuthManager::from_auth_for_testing(CodexAuth::create_dummy_chatgpt_auth_for_testing());
|
|
let endpoint = Arc::new(OpenAiModelsEndpoint::new(
|
|
provider.clone(),
|
|
Some(Arc::clone(&auth)),
|
|
/*gateway_auth_manager*/ None,
|
|
));
|
|
let manager = OpenAiModelsManager::new(home.path().to_path_buf(), endpoint, Some(auth));
|
|
let work = manager.for_originator("codex_work_cca").unwrap();
|
|
let chat = manager.for_originator("chatgpt_cca").unwrap();
|
|
for (originator, scoped) in [("codex_work_cca", &work), ("chatgpt_cca", &chat)] {
|
|
assert!(Arc::ptr_eq(
|
|
scoped,
|
|
&manager.for_originator(originator).unwrap()
|
|
));
|
|
}
|
|
let (default_catalog, work_catalog, chat_catalog) = tokio::join!(
|
|
manager.raw_model_catalog(RefreshStrategy::OnlineIfUncached, client.clone()),
|
|
work.raw_model_catalog(RefreshStrategy::OnlineIfUncached, client.clone()),
|
|
chat.raw_model_catalog(RefreshStrategy::OnlineIfUncached, client.clone()),
|
|
);
|
|
let mut actual = vec![default_catalog, work_catalog, chat_catalog];
|
|
for originator in surface_originators {
|
|
let scoped = manager.for_originator(originator).unwrap();
|
|
actual.push(
|
|
scoped
|
|
.raw_model_catalog(RefreshStrategy::OnlineIfUncached, client.clone())
|
|
.await,
|
|
);
|
|
scoped
|
|
.refresh_if_new_etag(format!("\"{originator}\""), client.clone())
|
|
.await;
|
|
}
|
|
assert_eq!(actual, catalogs);
|
|
for originator in [
|
|
"",
|
|
"unknown",
|
|
"codex_cli_rs",
|
|
"codex_vscode",
|
|
"chatgpt_cca_local_dev",
|
|
] {
|
|
assert!(manager.for_originator(originator).is_none());
|
|
}
|
|
}
|
|
assert!(home.path().join("models_cache.json").exists());
|
|
assert!(
|
|
home.path()
|
|
.join("models_cache.codex_work_cca.json")
|
|
.exists()
|
|
);
|
|
assert!(home.path().join("models_cache.chatgpt_cca.json").exists());
|
|
}
|