mirror of
https://github.com/openai/codex.git
synced 2026-11-18 22:20:48 +00:00
## Why Custom providers with gateway OAuth and an explicit model catalog should be able to discover models without an API key or API key model discovery enabled. ## What changed - Enable catalog refreshes for custom gateway providers when `model_catalog_url` and `base_url` have the same origin. - Reuse gateway credentials without starting an interactive login during catalog refreshes. - Keep an unrelated saved API key from making gateway catalog discovery depend on the API key discovery setting. ## Testing Add an app-server test for discovering a gateway catalog after OAuth login with no API key. Update coverage for catalog invalidation after gateway credentials require login, including across manager restarts, with API key discovery disabled. GitOrigin-RevId: b133c428cb45a9037e4b2ef13ff2f9473ed96636
843 lines
32 KiB
Rust
843 lines
32 KiB
Rust
//! Tests gateway-manager sharing, credential refresh, and model catalog cache isolation.
|
|
//! Discovery and inference must preserve primary auth and reject requests when gateway auth fails.
|
|
|
|
use super::*;
|
|
use crate::AgentIdentitySessionFallback;
|
|
use crate::ProviderAuthScope;
|
|
use crate::create_model_provider;
|
|
use crate::test_support::seed_gateway_auth;
|
|
use codex_api::Compression;
|
|
use codex_api::ResponsesClient;
|
|
use codex_http_client::ClientRouteClass;
|
|
use codex_http_client::HttpClientFactory;
|
|
use codex_http_client::OutboundProxyPolicy;
|
|
use codex_http_client::ReqwestTransport;
|
|
use codex_login::AuthHeaders;
|
|
use codex_login::AuthManager;
|
|
use codex_login::CodexAuth;
|
|
use codex_login::auth::AgentIdentityAuthPolicy;
|
|
use codex_login::default_client::ClientRedirectPolicy;
|
|
use codex_login::default_client::create_client_for_route;
|
|
use codex_model_provider_info::GatewayOAuthConfig;
|
|
use codex_model_provider_info::GatewayOAuthDelivery;
|
|
use codex_model_provider_info::GatewayOAuthSettings;
|
|
use codex_model_provider_info::ModelProviderInfo;
|
|
use codex_model_provider_info::OAuthCredentialsStore;
|
|
use codex_models_manager::manager::RefreshStrategy;
|
|
use codex_protocol::error::CodexErrorDetails;
|
|
use codex_protocol::protocol::CodexErrorInfo;
|
|
use codex_protocol::protocol::SessionSource;
|
|
use http::HeaderMap;
|
|
use http::HeaderName;
|
|
use http::HeaderValue;
|
|
use pretty_assertions::assert_eq;
|
|
use serde_json::json;
|
|
use wiremock::Mock;
|
|
use wiremock::MockServer;
|
|
use wiremock::ResponseTemplate;
|
|
use wiremock::matchers::method;
|
|
use wiremock::matchers::path;
|
|
|
|
#[tokio::test]
|
|
async fn gateway_credentials_accompany_primary_auth_in_models_and_responses() {
|
|
let server = MockServer::start().await;
|
|
let home = tempfile::tempdir().unwrap();
|
|
Mock::given(method("GET"))
|
|
.and(path("/models"))
|
|
.respond_with(ResponseTemplate::new(200).set_body_json(json!({"models": []})))
|
|
.expect(2)
|
|
.mount(&server)
|
|
.await;
|
|
Mock::given(method("POST"))
|
|
.and(path("/responses"))
|
|
.respond_with(
|
|
ResponseTemplate::new(200)
|
|
.insert_header("content-type", "text/event-stream")
|
|
.set_body_string(
|
|
"data: {\"type\":\"response.completed\",\"response\":{\"id\":\"r\"}}\n\n",
|
|
),
|
|
)
|
|
.expect(2)
|
|
.mount(&server)
|
|
.await;
|
|
let factory = HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault);
|
|
for delivery in [
|
|
GatewayOAuthDelivery::Header {
|
|
name: "x-gateway-auth".into(),
|
|
scheme: "Bearer".into(),
|
|
},
|
|
GatewayOAuthDelivery::Cookie {
|
|
name: "gateway_session".into(),
|
|
},
|
|
] {
|
|
let config = GatewayOAuthSettings {
|
|
authorization_url: format!("{}/authorize", server.uri()),
|
|
device_authorization_url: None,
|
|
token_url: format!("{}/token", server.uri()),
|
|
client_id: "test".into(),
|
|
resource: None,
|
|
scopes: vec![],
|
|
redirect_port: None,
|
|
// Avoid spending the model discovery deadline on keyring-backed decryption.
|
|
credentials_store: OAuthCredentialsStore::File,
|
|
delivery: delivery.clone(),
|
|
};
|
|
let info = ModelProviderInfo {
|
|
gateway_oauth: Some(GatewayOAuthConfig::OAuth(config)),
|
|
..ModelProviderInfo::create_openai_provider(Some(server.uri()))
|
|
};
|
|
let mut primary_headers = HeaderMap::new();
|
|
primary_headers.insert(
|
|
"authorization",
|
|
HeaderValue::from_static("Bearer primary-token"),
|
|
);
|
|
primary_headers.insert("chatgpt-account-id", HeaderValue::from_static("account"));
|
|
let primary = AuthManager::from_auth_for_testing_with_home(
|
|
CodexAuth::Headers(AuthHeaders::new(primary_headers)),
|
|
home.path().to_path_buf(),
|
|
);
|
|
let manager = seed_gateway_auth(
|
|
&info,
|
|
&primary,
|
|
json!({"access_token": "gateway-token", "refresh_token": "refresh-secret", "expires_at": i64::MAX}),
|
|
);
|
|
let provider = create_model_provider(info.clone(), Some(primary));
|
|
assert!(Arc::ptr_eq(
|
|
&provider
|
|
.gateway_auth_manager()
|
|
.unwrap()
|
|
.unwrap()
|
|
.oauth_session()
|
|
.unwrap(),
|
|
&manager,
|
|
));
|
|
let models = provider.models_manager_without_cache(/*config_model_catalog*/ None);
|
|
models.set_api_key_model_discovery_enabled(/*enabled*/ true);
|
|
models
|
|
.raw_model_catalog(RefreshStrategy::Online, factory.clone())
|
|
.await;
|
|
let (api, resolved) = provider
|
|
.request_provider_and_auth(/*scope*/ None)
|
|
.await
|
|
.unwrap();
|
|
let auth = resolved.auth;
|
|
let scoped = provider
|
|
.api_auth_for_scope(ProviderAuthScope {
|
|
agent_identity_policy: AgentIdentityAuthPolicy::JwtOnly,
|
|
session_source: SessionSource::Cli,
|
|
agent_identity_session_fallback: AgentIdentitySessionFallback::default(),
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let mut expected = HeaderMap::from_iter([
|
|
(
|
|
http::header::AUTHORIZATION,
|
|
HeaderValue::from_static("Bearer primary-token"),
|
|
),
|
|
(
|
|
HeaderName::from_static("chatgpt-account-id"),
|
|
HeaderValue::from_static("account"),
|
|
),
|
|
]);
|
|
let (name, value) = match delivery {
|
|
GatewayOAuthDelivery::Header { .. } => ("x-gateway-auth", "Bearer gateway-token"),
|
|
GatewayOAuthDelivery::Cookie { .. } => ("cookie", "gateway_session=gateway-token"),
|
|
};
|
|
expected.insert(
|
|
HeaderName::from_static(name),
|
|
HeaderValue::from_static(value),
|
|
);
|
|
// Legacy consumers and asynchronous handshakes preserve the same gateway credential.
|
|
assert_eq!(auth.to_auth_headers().unwrap(), expected);
|
|
assert_eq!(
|
|
auth.apply_auth_headers(HeaderMap::new()).await.unwrap(),
|
|
expected
|
|
);
|
|
assert_eq!(scoped.auth.to_auth_headers().unwrap(), expected);
|
|
assert!(auth.to_auth_headers().unwrap()[name].is_sensitive());
|
|
let transport = ReqwestTransport::from_http_client(
|
|
create_client_for_route(
|
|
&factory,
|
|
&api.url_for_path("responses"),
|
|
ClientRouteClass::Api,
|
|
ClientRedirectPolicy::Default,
|
|
)
|
|
.unwrap(),
|
|
);
|
|
let client = ResponsesClient::new(transport, api, auth);
|
|
let _stream = client
|
|
.stream(
|
|
json!({"model": "test", "input": []}),
|
|
HeaderMap::new(),
|
|
Compression::None,
|
|
/*turn_state*/ None,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
}
|
|
let requests = server.received_requests().await.unwrap();
|
|
assert_eq!(requests.len(), 4);
|
|
for request in requests {
|
|
assert_eq!(request.headers["authorization"], "Bearer primary-token");
|
|
assert!(
|
|
request
|
|
.headers
|
|
.get("x-gateway-auth")
|
|
.is_some_and(|value| value == "Bearer gateway-token")
|
|
|| request
|
|
.headers
|
|
.get("cookie")
|
|
.is_some_and(|value| value == "gateway_session=gateway-token")
|
|
);
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn gateway_preserves_runtime_auth_and_rejects_header_collisions() {
|
|
use codex_features::RuntimeAuthMode;
|
|
use codex_runtime_agent_instance::AgentHostAuthorization;
|
|
use codex_runtime_agent_instance::RuntimeAuthManager;
|
|
use codex_runtime_agent_instance::RuntimeRegistrationMetadata;
|
|
use codex_runtime_agent_instance::RuntimeRole;
|
|
|
|
for mode in [RuntimeAuthMode::DualHeader, RuntimeAuthMode::AssertionOnly] {
|
|
let server = MockServer::start().await;
|
|
let home = tempfile::tempdir().unwrap();
|
|
Mock::given(method("POST"))
|
|
.and(path("/register"))
|
|
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
|
|
"runtime_agent_instance_id": "runtime-a",
|
|
"agent_host_id": "host-a",
|
|
"actor": {"kind":"platform", "user_id":"user-a", "organization_id":"org-a", "project_id":null},
|
|
})))
|
|
.expect(1)
|
|
.mount(&server)
|
|
.await;
|
|
let primary = AuthManager::from_auth_for_testing_with_home(
|
|
CodexAuth::from_api_key("primary-token"),
|
|
home.path().to_path_buf(),
|
|
);
|
|
let info = ModelProviderInfo {
|
|
gateway_oauth: Some(GatewayOAuthConfig::OAuth(GatewayOAuthSettings {
|
|
authorization_url: format!("{}/authorize", server.uri()),
|
|
device_authorization_url: None,
|
|
token_url: format!("{}/token", server.uri()),
|
|
client_id: "client".into(),
|
|
resource: None,
|
|
scopes: vec![],
|
|
redirect_port: None,
|
|
credentials_store: Default::default(),
|
|
delivery: GatewayOAuthDelivery::Header {
|
|
name: "x-gateway-auth".into(),
|
|
scheme: "Bearer".into(),
|
|
},
|
|
})),
|
|
..ModelProviderInfo::create_openai_provider(Some(server.uri()))
|
|
};
|
|
let _gateway = seed_gateway_auth(
|
|
&info,
|
|
&primary,
|
|
json!({"access_token": "gateway-token", "expires_at": i64::MAX}),
|
|
);
|
|
let runtime = Arc::new(RuntimeAuthManager::new(
|
|
Arc::clone(&primary),
|
|
AgentHostAuthorization::InstallationId {
|
|
installation_id: "00000000-0000-0000-0000-000000000000".parse().unwrap(),
|
|
},
|
|
RuntimeRegistrationMetadata {
|
|
harness: None,
|
|
harness_version: None,
|
|
role: RuntimeRole::Orchestrator,
|
|
},
|
|
format!("{}/register", server.uri()).parse().unwrap(),
|
|
));
|
|
let provider = crate::test_support::runtime_model_provider(info, primary, (runtime, mode));
|
|
let auth = provider.api_auth().await.unwrap();
|
|
let stale_headers = HeaderMap::from_iter([
|
|
(
|
|
http::header::AUTHORIZATION,
|
|
HeaderValue::from_static("Bearer stale"),
|
|
),
|
|
(
|
|
HeaderName::from_static("x-openai-agent-assertion"),
|
|
HeaderValue::from_static("stale"),
|
|
),
|
|
(
|
|
HeaderName::from_static("chatgpt-account-id"),
|
|
HeaderValue::from_static("stale"),
|
|
),
|
|
(
|
|
HeaderName::from_static("x-caller"),
|
|
HeaderValue::from_static("retained"),
|
|
),
|
|
]);
|
|
let headers = auth
|
|
.apply_auth_headers(stale_headers.clone())
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(headers["x-gateway-auth"], "Bearer gateway-token");
|
|
assert_eq!(headers["x-caller"], "retained");
|
|
assert!(!headers.contains_key("chatgpt-account-id"));
|
|
let proof_header = match mode {
|
|
RuntimeAuthMode::DualHeader => {
|
|
assert_eq!(headers["authorization"], "Bearer primary-token");
|
|
"x-openai-agent-assertion"
|
|
}
|
|
RuntimeAuthMode::AssertionOnly => {
|
|
assert!(!headers.contains_key("x-openai-agent-assertion"));
|
|
assert!(
|
|
headers["authorization"]
|
|
.to_str()
|
|
.unwrap()
|
|
.starts_with("AgentAssertion 1.")
|
|
);
|
|
"authorization"
|
|
}
|
|
};
|
|
let mut request = codex_http_client::Request::new(http::Method::POST, server.uri());
|
|
request.headers = stale_headers.clone();
|
|
let signed = auth.apply_auth(request).await.unwrap();
|
|
assert_eq!(signed.headers["x-gateway-auth"], "Bearer gateway-token");
|
|
assert_ne!(headers[proof_header], signed.headers[proof_header]);
|
|
|
|
let mut collision = stale_headers;
|
|
collision.insert("x-gateway-auth", HeaderValue::from_static("caller-token"));
|
|
assert!(auth.apply_auth_headers(collision.clone()).await.is_err());
|
|
let mut request = codex_http_client::Request::new(http::Method::POST, server.uri());
|
|
request.headers = collision;
|
|
assert!(auth.apply_auth(request).await.is_err());
|
|
assert_eq!(server.received_requests().await.unwrap().len(), 1);
|
|
server.verify().await;
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn gateway_refresh_preserves_primary_auth_and_hides_issuer_errors() {
|
|
for succeeds in [true, false] {
|
|
let server = MockServer::start().await;
|
|
let home = tempfile::tempdir().unwrap();
|
|
let primary = AuthManager::from_auth_for_testing_with_home(
|
|
CodexAuth::from_api_key("primary-token"),
|
|
home.path().to_path_buf(),
|
|
);
|
|
let info = ModelProviderInfo {
|
|
gateway_oauth: Some(GatewayOAuthConfig::OAuth(GatewayOAuthSettings {
|
|
authorization_url: format!("{}/authorize", server.uri()),
|
|
device_authorization_url: None,
|
|
token_url: format!("{}/token?credential=query-secret", server.uri()),
|
|
client_id: "client".into(),
|
|
resource: None,
|
|
scopes: vec![],
|
|
redirect_port: None,
|
|
credentials_store: Default::default(),
|
|
delivery: GatewayOAuthDelivery::Header {
|
|
name: "x-gateway-auth".into(),
|
|
scheme: "Bearer".into(),
|
|
},
|
|
})),
|
|
..ModelProviderInfo::create_openai_provider(Some(server.uri()))
|
|
};
|
|
let body = if succeeds {
|
|
json!({"access_token": "rotated-token", "expires_in": 3600})
|
|
} else {
|
|
json!({"error": "server_error", "error_description": format!("query-secret {}", "sensitive ".repeat(4000))})
|
|
};
|
|
Mock::given(method("POST"))
|
|
.and(path("/token"))
|
|
.respond_with(
|
|
ResponseTemplate::new(if succeeds { 200 } else { 500 }).set_body_json(body),
|
|
)
|
|
.expect(1)
|
|
.mount(&server)
|
|
.await;
|
|
let _gateway = seed_gateway_auth(
|
|
&info,
|
|
&primary,
|
|
json!({"access_token": "expired", "refresh_token": "refresh-secret", "expires_at": 0}),
|
|
);
|
|
let provider = create_model_provider(info, Some(primary.clone()));
|
|
let result = provider.api_auth().await;
|
|
if succeeds {
|
|
assert_eq!(
|
|
result.unwrap().to_auth_headers().unwrap(),
|
|
HeaderMap::from_iter([
|
|
(
|
|
http::header::AUTHORIZATION,
|
|
HeaderValue::from_static("Bearer primary-token")
|
|
),
|
|
(
|
|
HeaderName::from_static("x-gateway-auth"),
|
|
HeaderValue::from_static("Bearer rotated-token")
|
|
),
|
|
])
|
|
);
|
|
} else {
|
|
let error = match result {
|
|
Ok(_) => panic!("issuer failure should fail auth"),
|
|
Err(error) => error,
|
|
};
|
|
assert!(error.retry_delay(/*retry_count*/ 1).is_some());
|
|
assert_eq!(
|
|
error.to_string(),
|
|
"Gateway OAuth authentication failed; check the gateway configuration and credential store."
|
|
);
|
|
}
|
|
assert_eq!(
|
|
primary.auth_cached(),
|
|
Some(CodexAuth::from_api_key("primary-token"))
|
|
);
|
|
let requests = server.received_requests().await.unwrap();
|
|
assert!(!requests[0].headers.contains_key("authorization"));
|
|
assert!(!requests[0].headers.contains_key("x-gateway-auth"));
|
|
assert_eq!(
|
|
std::str::from_utf8(&requests[0].body)
|
|
.unwrap()
|
|
.split('&')
|
|
.collect::<std::collections::BTreeSet<_>>(),
|
|
std::collections::BTreeSet::from([
|
|
"grant_type=refresh_token",
|
|
"refresh_token=refresh-secret",
|
|
"client_id=client"
|
|
])
|
|
);
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn models_cache_is_reused_only_for_matching_gateway_configuration() {
|
|
let server = MockServer::start().await;
|
|
let home = tempfile::tempdir().unwrap();
|
|
let primary = AuthManager::from_auth_for_testing_with_home(
|
|
CodexAuth::from_api_key("primary-token"),
|
|
home.path().to_path_buf(),
|
|
);
|
|
let mut info = ModelProviderInfo {
|
|
model_catalog_url: Some(format!("{}/models", server.uri()).into()),
|
|
http_headers: Some(std::collections::HashMap::from([(
|
|
codex_login::default_client::RESIDENCY_HEADER_NAME.to_string(),
|
|
"us".into(),
|
|
)])),
|
|
gateway_oauth: Some(GatewayOAuthConfig::OAuth(GatewayOAuthSettings {
|
|
authorization_url: format!("{}/authorize", server.uri()),
|
|
device_authorization_url: None,
|
|
token_url: format!("{}/token", server.uri()),
|
|
client_id: "client".into(),
|
|
resource: None,
|
|
scopes: vec![],
|
|
redirect_port: None,
|
|
// Keyring latency is outside the cache behavior under test.
|
|
credentials_store: OAuthCredentialsStore::File,
|
|
delivery: GatewayOAuthDelivery::Header {
|
|
name: "x-gateway-auth".into(),
|
|
scheme: "Bearer".into(),
|
|
},
|
|
})),
|
|
..ModelProviderInfo::create_openai_provider(Some(server.uri()))
|
|
};
|
|
let factory = HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault);
|
|
let mut model = codex_models_manager::bundled_models_response()
|
|
.unwrap()
|
|
.models
|
|
.remove(0);
|
|
for resource in ["first", "second"] {
|
|
let Some(GatewayOAuthConfig::OAuth(settings)) = &mut info.gateway_oauth else {
|
|
unreachable!()
|
|
};
|
|
settings.resource = Some(format!("{}/{resource}", server.uri()));
|
|
model.slug = format!("catalog-{resource}");
|
|
let _gateway = seed_gateway_auth(
|
|
&info,
|
|
&primary,
|
|
json!({"access_token": resource, "refresh_token": "refresh-secret", "expires_at": i64::MAX}),
|
|
);
|
|
Mock::given(method("GET"))
|
|
.and(path("/models"))
|
|
.and(wiremock::matchers::header(
|
|
"x-gateway-auth",
|
|
format!("Bearer {resource}"),
|
|
))
|
|
.respond_with(ResponseTemplate::new(200).set_body_json(json!({"models": [&model]})))
|
|
.expect(1)
|
|
.mount(&server)
|
|
.await;
|
|
|
|
// Recreate the provider and models manager to exercise the shared disk cache.
|
|
// The first call for each resource fetches; the second must reuse its catalog.
|
|
for _ in 0..2 {
|
|
let provider = create_model_provider(info.clone(), Some(primary.clone()));
|
|
let models = provider.models_manager(
|
|
home.path().to_path_buf(),
|
|
/*config_model_catalog*/ None,
|
|
);
|
|
models.set_api_key_model_discovery_enabled(/*enabled*/ true);
|
|
let catalog = models
|
|
.raw_model_catalog(RefreshStrategy::OnlineIfUncached, factory.clone())
|
|
.await;
|
|
assert_eq!(catalog.models, vec![model.clone()]);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn models_observe_gateway_rotation_from_the_same_provider_instance() {
|
|
models_observe_gateway_rotation(ProviderInstance::Same).await;
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn models_observe_gateway_rotation_from_a_separate_provider_instance() {
|
|
models_observe_gateway_rotation(ProviderInstance::Separate).await;
|
|
}
|
|
|
|
enum ProviderInstance {
|
|
Same,
|
|
Separate,
|
|
}
|
|
|
|
async fn models_observe_gateway_rotation(instance: ProviderInstance) {
|
|
let server = MockServer::start().await;
|
|
let home = tempfile::tempdir().unwrap();
|
|
let primary = AuthManager::from_auth_for_testing_with_home(
|
|
CodexAuth::from_api_key("primary-token"),
|
|
home.path().to_path_buf(),
|
|
);
|
|
let info = ModelProviderInfo {
|
|
model_catalog_url: Some(format!("{}/models", server.uri()).into()),
|
|
gateway_oauth: Some(GatewayOAuthConfig::OAuth(GatewayOAuthSettings {
|
|
authorization_url: format!("{}/authorize", server.uri()),
|
|
device_authorization_url: None,
|
|
token_url: format!("{}/token", server.uri()),
|
|
client_id: "client".into(),
|
|
resource: None,
|
|
scopes: vec![],
|
|
redirect_port: None,
|
|
credentials_store: Default::default(),
|
|
delivery: GatewayOAuthDelivery::Header {
|
|
name: "x-gateway-auth".into(),
|
|
scheme: "Bearer".into(),
|
|
},
|
|
})),
|
|
..ModelProviderInfo::create_openai_provider(Some(server.uri()))
|
|
};
|
|
let gateway = seed_gateway_auth(
|
|
&info,
|
|
&primary,
|
|
json!({"access_token": "first", "refresh_token": "refresh-secret", "expires_at": i64::MAX}),
|
|
);
|
|
let provider = create_model_provider(info.clone(), Some(primary.clone()));
|
|
let models = provider.models_manager_without_cache(/*config_model_catalog*/ None);
|
|
models.set_api_key_model_discovery_enabled(/*enabled*/ true);
|
|
let requests_provider = match instance {
|
|
ProviderInstance::Same => provider,
|
|
ProviderInstance::Separate => create_model_provider(info, Some(primary)),
|
|
};
|
|
let mut first = codex_models_manager::bundled_models_response()
|
|
.unwrap()
|
|
.models
|
|
.remove(0);
|
|
first.slug = "catalog-first".into();
|
|
let mut second = first.clone();
|
|
second.slug = "catalog-second".into();
|
|
for (token, model) in [("first", &first), ("second", &second)] {
|
|
Mock::given(method("GET"))
|
|
.and(path("/models"))
|
|
.and(wiremock::matchers::header(
|
|
"x-gateway-auth",
|
|
format!("Bearer {token}"),
|
|
))
|
|
.respond_with(ResponseTemplate::new(200).set_body_json(json!({"models": [model]})))
|
|
.expect(1)
|
|
.mount(&server)
|
|
.await;
|
|
}
|
|
assert_eq!(
|
|
requests_provider
|
|
.api_auth()
|
|
.await
|
|
.unwrap()
|
|
.to_auth_headers()
|
|
.unwrap(),
|
|
HeaderMap::from_iter([
|
|
(
|
|
http::header::AUTHORIZATION,
|
|
HeaderValue::from_static("Bearer primary-token")
|
|
),
|
|
(
|
|
HeaderName::from_static("x-gateway-auth"),
|
|
HeaderValue::from_static("Bearer first")
|
|
),
|
|
])
|
|
);
|
|
models
|
|
.raw_model_catalog(
|
|
RefreshStrategy::Online,
|
|
HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault),
|
|
)
|
|
.await;
|
|
assert_eq!(models.get_remote_models().await, vec![first]);
|
|
Mock::given(method("POST"))
|
|
.and(path("/token"))
|
|
.respond_with(
|
|
ResponseTemplate::new(200)
|
|
.set_body_json(json!({"access_token": "second", "expires_in": 3600})),
|
|
)
|
|
.expect(1)
|
|
.up_to_n_times(1)
|
|
.mount(&server)
|
|
.await;
|
|
gateway.refresh_access_token("first").await.unwrap();
|
|
assert_eq!(
|
|
requests_provider
|
|
.api_auth()
|
|
.await
|
|
.unwrap()
|
|
.to_auth_headers()
|
|
.unwrap(),
|
|
HeaderMap::from_iter([
|
|
(
|
|
http::header::AUTHORIZATION,
|
|
HeaderValue::from_static("Bearer primary-token")
|
|
),
|
|
(
|
|
HeaderName::from_static("x-gateway-auth"),
|
|
HeaderValue::from_static("Bearer second")
|
|
),
|
|
])
|
|
);
|
|
models
|
|
.raw_model_catalog(
|
|
RefreshStrategy::Online,
|
|
HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault),
|
|
)
|
|
.await;
|
|
assert_eq!(models.get_remote_models().await, vec![second]);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn gateway_setup_errors_are_reported_when_authentication_is_requested() {
|
|
use codex_models_manager::manager::ModelsEndpointClient;
|
|
|
|
let server = MockServer::start().await;
|
|
let mut info = ModelProviderInfo {
|
|
gateway_oauth: Some(GatewayOAuthConfig::OAuth(GatewayOAuthSettings {
|
|
authorization_url: format!("{}/authorize", server.uri()),
|
|
device_authorization_url: None,
|
|
token_url: format!("{}/token", server.uri()),
|
|
client_id: "client".into(),
|
|
resource: None,
|
|
scopes: vec![],
|
|
redirect_port: None,
|
|
credentials_store: Default::default(),
|
|
delivery: GatewayOAuthDelivery::Header {
|
|
name: "x-gateway-auth".into(),
|
|
scheme: "Bearer".into(),
|
|
},
|
|
})),
|
|
..ModelProviderInfo::create_openai_provider(Some(server.uri()))
|
|
};
|
|
let provider = create_model_provider(info.clone(), /*auth_manager*/ None);
|
|
assert_eq!(
|
|
provider.gateway_auth_manager().unwrap_err().to_string(),
|
|
"gateway_oauth requires auth runtime configuration"
|
|
);
|
|
let error = provider.api_auth().await.err().unwrap();
|
|
assert_eq!(
|
|
error.to_string(),
|
|
"gateway_oauth requires auth runtime configuration"
|
|
);
|
|
|
|
let primary = AuthManager::from_auth_for_testing(CodexAuth::from_api_key("primary"));
|
|
let endpoint = crate::models_endpoint::OpenAiModelsEndpoint::new(
|
|
info.clone(),
|
|
Some(primary),
|
|
Some(Err("failed to create provider OAuth HTTP client".into())),
|
|
);
|
|
let error = endpoint
|
|
.list_models(
|
|
"test",
|
|
HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault),
|
|
)
|
|
.await
|
|
.unwrap_err();
|
|
assert_eq!(
|
|
error.to_string(),
|
|
"failed to create provider OAuth HTTP client"
|
|
);
|
|
|
|
let Some(GatewayOAuthConfig::OAuth(settings)) = &mut info.gateway_oauth else {
|
|
unreachable!()
|
|
};
|
|
settings.client_id.clear();
|
|
let primary = AuthManager::from_auth_for_testing(CodexAuth::from_api_key("primary"));
|
|
let error = create_model_provider(info, Some(primary))
|
|
.api_auth()
|
|
.await
|
|
.err()
|
|
.unwrap();
|
|
assert!(matches!(
|
|
error.details(),
|
|
codex_protocol::error::CodexErrorDetails::InvalidRequest(_)
|
|
));
|
|
assert!(server.received_requests().await.unwrap().is_empty());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn gateway_login_required_invalidates_the_last_successful_catalog() {
|
|
let server = MockServer::start().await;
|
|
let home = tempfile::tempdir().unwrap();
|
|
let primary = AuthManager::from_auth_for_testing_with_home(
|
|
CodexAuth::from_api_key("primary-token"),
|
|
home.path().to_path_buf(),
|
|
);
|
|
let info = ModelProviderInfo {
|
|
name: "Gateway".to_string(),
|
|
base_url: Some(server.uri()),
|
|
model_catalog_url: Some(format!("{}/catalog", server.uri()).into()),
|
|
gateway_oauth: Some(GatewayOAuthConfig::OAuth(GatewayOAuthSettings {
|
|
authorization_url: format!("{}/authorize", server.uri()),
|
|
device_authorization_url: None,
|
|
token_url: format!("{}/token", server.uri()),
|
|
client_id: "client".into(),
|
|
resource: None,
|
|
scopes: vec![],
|
|
redirect_port: None,
|
|
credentials_store: OAuthCredentialsStore::File,
|
|
delivery: GatewayOAuthDelivery::default(),
|
|
})),
|
|
..Default::default()
|
|
};
|
|
let login_control = codex_login::GatewayLoginControl::for_runtime(&primary.runtime_config());
|
|
login_control.require_explicit_login();
|
|
let gateway = seed_gateway_auth(
|
|
&info,
|
|
&primary,
|
|
json!({"access_token": "first", "refresh_token": "revoked", "expires_at": i64::MAX}),
|
|
);
|
|
let provider = create_model_provider(info, Some(primary));
|
|
let models = provider.models_manager(
|
|
home.path().to_path_buf(),
|
|
/*config_model_catalog*/ None,
|
|
);
|
|
// Only the gateway token should enable this fetch; the saved API key is unrelated.
|
|
models.set_api_key_model_discovery_enabled(/*enabled*/ false);
|
|
let factory = HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault);
|
|
let catalog = codex_models_manager::bundled_models_response().unwrap();
|
|
Mock::given(method("GET"))
|
|
.and(path("/catalog"))
|
|
.and(wiremock::matchers::header("authorization", "Bearer first"))
|
|
.respond_with(ResponseTemplate::new(200).set_body_json(&catalog))
|
|
.expect(1)
|
|
.mount(&server)
|
|
.await;
|
|
assert_eq!(
|
|
models
|
|
.raw_model_catalog(RefreshStrategy::Online, factory.clone())
|
|
.await,
|
|
catalog
|
|
);
|
|
|
|
Mock::given(method("POST"))
|
|
.and(path("/token"))
|
|
.respond_with(ResponseTemplate::new(400).set_body_json(json!({"error": "invalid_grant"})))
|
|
.expect(1)
|
|
.mount(&server)
|
|
.await;
|
|
let error = gateway.refresh_access_token("first").await.unwrap_err();
|
|
assert!(matches!(
|
|
error
|
|
.get_ref()
|
|
.and_then(|source| source.downcast_ref::<codex_login::GatewayAuthError>()),
|
|
Some(codex_login::GatewayAuthError::LoginRequired)
|
|
));
|
|
assert_eq!(
|
|
models
|
|
.raw_model_catalog(RefreshStrategy::Online, factory.clone())
|
|
.await,
|
|
codex_protocol::openai_models::ModelsResponse::default()
|
|
);
|
|
// Recreate the manager to verify persistent invalidation as well as the in-memory result.
|
|
let restarted = provider.models_manager(
|
|
home.path().to_path_buf(),
|
|
/*config_model_catalog*/ None,
|
|
);
|
|
restarted.set_api_key_model_discovery_enabled(/*enabled*/ false);
|
|
assert_eq!(
|
|
restarted
|
|
.raw_model_catalog(RefreshStrategy::Offline, factory)
|
|
.await,
|
|
codex_protocol::openai_models::ModelsResponse::default()
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn gateway_login_states_stop_request_retries() {
|
|
let server = MockServer::start().await;
|
|
let home = tempfile::tempdir().unwrap();
|
|
let primary = AuthManager::from_auth_for_testing_with_home(
|
|
CodexAuth::from_api_key("primary-token"),
|
|
home.path().to_path_buf(),
|
|
);
|
|
let info = ModelProviderInfo {
|
|
gateway_oauth: Some(GatewayOAuthConfig::OAuth(GatewayOAuthSettings {
|
|
authorization_url: format!("{}/authorize", server.uri()),
|
|
device_authorization_url: None,
|
|
token_url: format!("{}/token", server.uri()),
|
|
client_id: "client".into(),
|
|
resource: None,
|
|
scopes: vec![],
|
|
redirect_port: None,
|
|
credentials_store: Default::default(),
|
|
delivery: GatewayOAuthDelivery::Header {
|
|
name: "x-gateway-auth".into(),
|
|
scheme: "Bearer".into(),
|
|
},
|
|
})),
|
|
..ModelProviderInfo::create_openai_provider(Some(server.uri()))
|
|
};
|
|
let login_control = codex_login::GatewayLoginControl::for_runtime(&primary.runtime_config());
|
|
login_control.require_explicit_login();
|
|
let provider = create_model_provider(info, Some(primary));
|
|
let gateway = provider.gateway_auth_manager().unwrap().unwrap();
|
|
let error = provider.api_auth().await.err().expect("login required");
|
|
assert!(matches!(
|
|
error.details(),
|
|
CodexErrorDetails::GatewayLoginRequired(_)
|
|
));
|
|
assert_eq!(
|
|
(
|
|
error.to_string(),
|
|
error.retry_delay(/*retry_count*/ 1),
|
|
error.to_codex_protocol_error()
|
|
),
|
|
(
|
|
codex_login::GatewayAuthError::LoginRequired.to_string(),
|
|
None,
|
|
CodexErrorInfo::Other
|
|
),
|
|
);
|
|
let cancel = tokio::sync::Notify::new();
|
|
let (url_tx, url_rx) = tokio::sync::oneshot::channel();
|
|
let oauth = gateway.oauth_session().unwrap();
|
|
let login = oauth.login_with_browser(cancel.notified(), |_| {
|
|
let _ = url_tx.send(());
|
|
});
|
|
let check = async {
|
|
url_rx.await.unwrap();
|
|
let error = provider.api_auth().await.err().expect("login in progress");
|
|
assert!(matches!(
|
|
error.details(),
|
|
CodexErrorDetails::InvalidRequest(_)
|
|
));
|
|
assert_eq!(
|
|
(error.to_string(), error.retry_delay(/*retry_count*/ 1)),
|
|
(
|
|
codex_login::GatewayAuthError::LoginInProgress.to_string(),
|
|
None
|
|
),
|
|
);
|
|
cancel.notify_one();
|
|
};
|
|
let (result, ()) = tokio::join!(login, check);
|
|
assert_eq!(result.unwrap_err().kind(), std::io::ErrorKind::Interrupted);
|
|
assert!(server.received_requests().await.unwrap().is_empty());
|
|
}
|