Lightweight coding agent that runs in your terminal
Rust
Add a built-in Google Cloud Vertex AI provider (#56265)
Celia Chen3fd148a20c18
diff --git a/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json b/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.jsonindex cf785c660d..0d051d503a 100644--- a/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json+++ b/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json@@ -6834,6 +6834,23 @@],"title": "AmazonBedrockAccount","type": "object"+ },+ {+ "description": "Google Cloud Vertex AI with externally managed credentials.",+ "properties": {+ "type": {+ "enum": [+ "gcp"+ ],+ "title": "GcpAccountType",+ "type": "string"+ }+ },+ "required": [+ "type"+ ],+ "title": "GcpAccount",+ "type": "object"}]},diff --git a/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.json b/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.jsonindex bd88041df4..2e81ae2bd3 100644--- a/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.json+++ b/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.json@@ -69,6 +69,23 @@],"title": "AmazonBedrockAccount","type": "object"+ },+ {+ "description": "Google Cloud Vertex AI with externally managed credentials.",+ "properties": {+ "type": {+ "enum": [+ "gcp"+ ],+ "title": "GcpAccountType",+ "type": "string"+ }+ },+ "required": [+ "type"+ ],+ "title": "GcpAccount",+ "type": "object"}]},diff --git a/codex-rs/app-server-protocol/schema/json/v2/GetAccountResponse.json b/codex-rs/app-server-protocol/schema/json/v2/GetAccountResponse.jsonindex 595d01e3b8..3a0b91064f 100644--- a/codex-rs/app-server-protocol/schema/json/v2/GetAccountResponse.json+++ b/codex-rs/app-server-protocol/schema/json/v2/GetAccountResponse.json@@ -65,6 +65,23 @@],"title": "AmazonBedrockAccount","type": "object"+ },+ {+ "description": "Google Cloud Vertex AI with externally managed credentials.",+ "properties": {+ "type": {+ "enum": [+ "gcp"+ ],+ "title": "GcpAccountType",+ "type": "string"+ }+ },+ "required": [+ "type"+ ],+ "title": "GcpAccount",+ "type": "object"}]},diff --git a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zstindex a9e3c99cba..c4b50dc236 100644Binary files a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst and b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst differdiff --git a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zstindex 90c6e35e92..0592a2f3ad 100644Binary files a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst and b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst differdiff --git a/codex-rs/app-server-protocol/schema/typescript/v2/Account.ts b/codex-rs/app-server-protocol/schema/typescript/v2/Account.tsindex 1f1ad851c7..4897b1ff9a 100644--- a/codex-rs/app-server-protocol/schema/typescript/v2/Account.ts+++ b/codex-rs/app-server-protocol/schema/typescript/v2/Account.ts@@ -3,4 +3,4 @@// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.import type { PlanType } from "../PlanType";-export type Account = { "type": "apiKey", } | { "type": "chatgpt", email: string | null, planType: PlanType, } | { "type": "amazonBedrock", usesCodexManagedCredentials: boolean, };+export type Account = { "type": "apiKey", } | { "type": "chatgpt", email: string | null, planType: PlanType, } | { "type": "amazonBedrock", usesCodexManagedCredentials: boolean, } | { "type": "gcp", };diff --git a/codex-rs/app-server-protocol/src/protocol/v2/account.rs b/codex-rs/app-server-protocol/src/protocol/v2/account.rsindex e1b8e8b2df..2de06c9eda 100644--- a/codex-rs/app-server-protocol/src/protocol/v2/account.rs+++ b/codex-rs/app-server-protocol/src/protocol/v2/account.rs@@ -41,6 +41,11 @@ pub enum Account {#[serde(default)]uses_codex_managed_credentials: bool,},++ /// Google Cloud Vertex AI with externally managed credentials.+ #[serde(rename = "gcp", rename_all = "camelCase")]+ #[ts(rename = "gcp", rename_all = "camelCase")]+ Gcp {},}impl From<ProviderAccount> for Account {@@ -53,6 +58,7 @@ impl From<ProviderAccount> for Account {} => Self::AmazonBedrock {uses_codex_managed_credentials,},+ ProviderAccount::Gcp => Self::Gcp {},}}}diff --git a/codex-rs/app-server/tests/suite/v2/account_gcp.rs b/codex-rs/app-server/tests/suite/v2/account_gcp.rsnew file mode 100644index 0000000000..a7c94d2fba--- /dev/null+++ b/codex-rs/app-server/tests/suite/v2/account_gcp.rs@@ -0,0 +1,100 @@+//! GCP account reporting follows the selected provider without resolving its credentials.++use anyhow::Result;+use app_test_support::ChatGptAuthFixture;+use app_test_support::TestAppServer;+use app_test_support::write_chatgpt_auth;+use codex_app_server_protocol::GetAccountParams;+use codex_config::types::AuthCredentialsStoreMode;+use pretty_assertions::assert_eq;+use serde_json::Value;+use serde_json::json;+use tempfile::TempDir;+use test_case::test_case;+use tokio::time::timeout;++const READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(/*secs*/ 30);++#[test_case(""; "application_default_credentials")]+#[test_case(+ r#"+[model_providers.gcp]+base_url = "https://vertex.example.com/v1"+[model_providers.gcp.auth]+command = "codex-test-gcp-command-that-does-not-exist"+"#;+ "external_command_and_endpoint"+)]+#[tokio::test]+async fn gcp_account_is_reported_without_resolving_credentials(overrides: &str) -> Result<()> {+ let codex_home = TempDir::new()?;+ std::fs::write(+ codex_home.path().join("config.toml"),+ format!("model_provider = \"gcp\"\n{overrides}"),+ )?;+ let mut app_server = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ .with_env_overrides(&[("OPENAI_API_KEY", None)])+ .build_initialized()+ .await?;++ for refresh_token in [false, true] {+ let request_id = app_server+ .send_get_account_request(GetAccountParams { refresh_token })+ .await?;+ let received: Value = timeout(READ_TIMEOUT, app_server.read_response(request_id)).await??;+ assert_eq!(+ received,+ json!({"account": {"type": "gcp"}, "requiresOpenaiAuth": false, "workspaceRouting": null})+ );+ }+ Ok(())+}++#[tokio::test]+async fn gcp_account_tracks_provider_changes_with_saved_chatgpt_credentials() -> Result<()> {+ let codex_home = TempDir::new()?;+ let config_path = codex_home.path().join("config.toml");+ std::fs::write(&config_path, "model_provider = \"gcp\"\n")?;+ write_chatgpt_auth(+ codex_home.path(),+ ChatGptAuthFixture::new("access-chatgpt")+ .email("[email protected]")+ .plan_type("pro"),+ AuthCredentialsStoreMode::File,+ )?;+ let mut app_server = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ .with_env_overrides(&[("OPENAI_API_KEY", None)])+ .build_initialized()+ .await?;++ for (provider, expected) in [+ (+ "gcp",+ json!({"account": {"type": "gcp"}, "requiresOpenaiAuth": false, "workspaceRouting": null}),+ ),+ (+ "amazon-bedrock",+ json!({"account": {"type": "amazonBedrock", "usesCodexManagedCredentials": false}, "requiresOpenaiAuth": false, "workspaceRouting": null}),+ ),+ (+ "openai",+ json!({"account": {"type": "chatgpt", "email": "[email protected]", "planType": "pro"}, "requiresOpenaiAuth": true, "workspaceRouting": null}),+ ),+ (+ "gcp",+ json!({"account": {"type": "gcp"}, "requiresOpenaiAuth": false, "workspaceRouting": null}),+ ),+ ] {+ std::fs::write(&config_path, format!("model_provider = \"{provider}\"\n"))?;+ let request_id = app_server+ .send_get_account_request(GetAccountParams {+ refresh_token: false,+ })+ .await?;+ let received: Value = timeout(READ_TIMEOUT, app_server.read_response(request_id)).await??;+ assert_eq!(received, expected);+ }+ Ok(())+}diff --git a/codex-rs/app-server/tests/suite/v2/mod.rs b/codex-rs/app-server/tests/suite/v2/mod.rsindex f1ac09e54d..21df247cf3 100644--- a/codex-rs/app-server/tests/suite/v2/mod.rs+++ b/codex-rs/app-server/tests/suite/v2/mod.rs@@ -1,6 +1,8 @@mod account;#[path = "account_system_proxy_tests.rs"]mod account_system_proxy;++mod account_gcp;mod account_thread_usage;mod agent_message_board;mod analytics;diff --git a/codex-rs/config/src/config_toml.rs b/codex-rs/config/src/config_toml.rsindex 7f70fb8814..b31342230e 100644--- a/codex-rs/config/src/config_toml.rs+++ b/codex-rs/config/src/config_toml.rs@@ -35,6 +35,7 @@ use crate::types::WindowsToml;use codex_features::FeaturesToml;use codex_model_provider_info::AMAZON_BEDROCK_PROVIDER_ID;use codex_model_provider_info::AMAZON_BEDROCK_RUNTIME_PROVIDER_ID;+use codex_model_provider_info::GCP_PROVIDER_ID;use codex_model_provider_info::LEGACY_OLLAMA_CHAT_PROVIDER_ID;use codex_model_provider_info::LMSTUDIO_OSS_PROVIDER_ID;use codex_model_provider_info::ModelProviderInfo;@@ -64,9 +65,10 @@ use serde::Serialize;use serde::de::Error as SerdeError;use serde_json::Value as JsonValue;-const RESERVED_MODEL_PROVIDER_IDS: [&str; 5] = [+const RESERVED_MODEL_PROVIDER_IDS: [&str; 6] = [AMAZON_BEDROCK_PROVIDER_ID,AMAZON_BEDROCK_RUNTIME_PROVIDER_ID,+ GCP_PROVIDER_ID,OPENAI_PROVIDER_ID,OLLAMA_OSS_PROVIDER_ID,LMSTUDIO_OSS_PROVIDER_ID,@@ -936,7 +938,7 @@ pub fn validate_reserved_model_provider_ids(.filter(|key| {!matches!(key.as_str(),- AMAZON_BEDROCK_PROVIDER_ID | AMAZON_BEDROCK_RUNTIME_PROVIDER_ID+ AMAZON_BEDROCK_PROVIDER_ID | AMAZON_BEDROCK_RUNTIME_PROVIDER_ID | GCP_PROVIDER_ID) && RESERVED_MODEL_PROVIDER_IDS.contains(&key.as_str())}).map(|key| format!("`{key}`"))@@ -965,18 +967,20 @@ pub fn validate_model_providers(provider.validate_bedrock_override().map_err(|message| format!("model_providers.{key} {message}"))?;- } else {- if provider.aws.is_some() {- return Err(format!(- "model_providers.{key}: provider aws is only supported for \+ } else if provider.aws.is_some() {+ return Err(format!(+ "model_providers.{key}: provider aws is only supported for \`{AMAZON_BEDROCK_PROVIDER_ID}` or `{AMAZON_BEDROCK_RUNTIME_PROVIDER_ID}`"- ));- }- if provider.name.trim().is_empty() {- return Err(format!(- "model_providers.{key}: provider name must not be empty"- ));- }+ ));+ }+ if !matches!(+ key.as_str(),+ AMAZON_BEDROCK_PROVIDER_ID | AMAZON_BEDROCK_RUNTIME_PROVIDER_ID | GCP_PROVIDER_ID+ ) && provider.name.trim().is_empty()+ {+ return Err(format!(+ "model_providers.{key}: provider name must not be empty"+ ));}provider.validate()@@ -1125,4 +1129,30 @@ command = " "));}++ #[test]+ fn gcp_provider_accepts_partial_endpoint_and_auth_overrides() {+ let config = toml::from_str::<ConfigToml>(+ r#"+[model_providers.gcp]+base_url = "https://vertex.example.com/v1"++[model_providers.gcp.auth]+command = "print-token"+"#,+ )+ .expect("partial GCP provider overrides should deserialize");++ let provider = config+ .model_providers+ .get(GCP_PROVIDER_ID)+ .expect("GCP overrides should be retained");+ assert_eq!(+ (+ provider.base_url.as_deref(),+ provider.auth.as_ref().map(|auth| auth.command.as_str()),+ ),+ (Some("https://vertex.example.com/v1"), Some("print-token"))+ );+ }}diff --git a/codex-rs/core/src/client.rs b/codex-rs/core/src/client.rsindex 815ab10a7d..152fa7145a 100644--- a/codex-rs/core/src/client.rs+++ b/codex-rs/core/src/client.rs@@ -964,7 +964,8 @@ impl ModelClient {effort: effort.or_else(|| model_info.default_reasoning_level.clone()).map(|effort| model_info.resolve_reasoning_effort(effort)),- summary: (model_info.supports_reasoning_summary_parameter+ summary: (self.state.provider.capabilities().reasoning_summaries+ && model_info.supports_reasoning_summary_parameter&& summary != ReasoningSummaryConfig::None).then_some(summary),// When Responses Lite is disabled, omit context so Responses uses the default,diff --git a/codex-rs/core/src/config/config_tests.rs b/codex-rs/core/src/config/config_tests.rsindex fc82e704e1..40b809731b 100644--- a/codex-rs/core/src/config/config_tests.rs+++ b/codex-rs/core/src/config/config_tests.rs@@ -1254,6 +1254,108 @@ command = "print-token"assert_eq!(config.model_provider, expected_provider);}+#[tokio::test]+async fn load_config_uses_resolved_cwd_for_default_gcp_auth() {+ let codex_home = tempdir().expect("tempdir");+ let workspace = tempdir().expect("tempdir");+ let cwd = workspace.abs();++ for base_url in [None, Some("https://vertex.example.com/v1")] {+ let mut cfg = ConfigToml {+ model_provider: Some("gcp".to_string()),+ ..Default::default()+ };+ if let Some(base_url) = base_url {+ cfg.model_providers.insert(+ "gcp".to_string(),+ ModelProviderInfo {+ base_url: Some(base_url.to_string()),+ ..Default::default()+ },+ );+ }+ let config = Config::load_from_base_config_with_overrides(+ cfg,+ ConfigOverrides {+ cwd: Some(cwd.to_path_buf()),+ ..Default::default()+ },+ codex_home.abs(),+ )+ .await+ .expect("load config");++ let mut expected_provider = ModelProviderInfo::create_gcp_provider();+ expected_provider.base_url = base_url.map(str::to_string);+ expected_provider.auth = Some(ModelProviderAuthInfo {+ command: if cfg!(windows) {+ "gcloud.cmd"+ } else {+ "gcloud"+ }+ .to_string(),+ args: vec![+ "auth".into(),+ "application-default".into(),+ "print-access-token".into(),+ ],+ timeout_ms: std::num::NonZeroU64::new(30_000).expect("timeout should be non-zero"),+ refresh_interval_ms: 3_000_000,+ cwd: cwd.clone(),+ });+ assert_eq!(config.model_provider_id, "gcp");+ assert_eq!(config.model_provider, expected_provider);+ assert_eq!(config.model_providers.get("gcp"), Some(&expected_provider));+ }+}++#[tokio::test]+async fn load_config_applies_gcp_transport_overrides() {+ let cfg = toml::from_str::<ConfigToml>(+ r#"+model_provider = "gcp"++[model_providers.gcp]+base_url = "https://vertex.example.com/v1"+http_headers = { "X-Custom-Header" = "value" }++[model_providers.gcp.auth]+command = "print-token"+"#,+ )+ .expect("GCP transport overrides should deserialize");++ let config = Config::load_from_base_config_with_overrides(+ cfg,+ ConfigOverrides::default(),+ tempdir().expect("tempdir").abs(),+ )+ .await+ .expect("load config");++ let mut expected_provider = built_in_model_providers(/*openai_base_url*/ None)+ .remove("gcp")+ .expect("GCP provider should be built in");+ expected_provider.base_url = Some("https://vertex.example.com/v1".to_string());+ expected_provider.auth = Some(ModelProviderAuthInfo {+ command: "print-token".to_string(),+ args: Vec::new(),+ timeout_ms: std::num::NonZeroU64::new(5_000).expect("timeout should be non-zero"),+ refresh_interval_ms: 300_000,+ cwd: std::env::current_dir()+ .expect("current directory should be available")+ .try_into()+ .expect("current directory should be absolute"),+ });+ expected_provider.http_headers = Some(std::collections::HashMap::from([(+ "X-Custom-Header".to_string(),+ "value".into(),+ )]));++ assert_eq!(config.model_provider_id, "gcp");+ assert_eq!(config.model_provider, expected_provider);+}+#[test]fn config_toml_rejects_unsupported_amazon_bedrock_overrides() {let err = toml::from_str::<ConfigToml>(diff --git a/codex-rs/core/src/config/mod.rs b/codex-rs/core/src/config/mod.rsindex d93932417d..1ce4a28839 100644--- a/codex-rs/core/src/config/mod.rs+++ b/codex-rs/core/src/config/mod.rs@@ -90,6 +90,7 @@ use codex_mcp::McpProtocolMode;use codex_mcp::McpServerRegistration;use codex_mcp::ResolvedMcpCatalog;use codex_model_provider::ProviderCapabilities;+use codex_model_provider_info::GCP_PROVIDER_ID;use codex_model_provider_info::LEGACY_OLLAMA_CHAT_PROVIDER_ID;use codex_model_provider_info::ModelProviderInfo;use codex_model_provider_info::OLLAMA_CHAT_PROVIDER_REMOVED_ERROR;@@ -101,6 +102,7 @@ use codex_protocol::MemoryVersion;use codex_protocol::config_types::AltScreenMode;use codex_protocol::config_types::AutoCompactTokenLimitScope;use codex_protocol::config_types::ForcedLoginMethod;+use codex_protocol::config_types::ModelProviderAuthInfo;use codex_protocol::config_types::Personality;use codex_protocol::config_types::ReasoningSummary;use codex_protocol::config_types::SERVICE_TIER_DEFAULT_REQUEST_VALUE;@@ -3983,10 +3985,27 @@ impl Config {.clone().filter(|value| !value.is_empty());- let model_providers =+ let mut model_providers =merge_configured_model_providers(built_in_model_providers(openai_base_url), cfg.model_providers).map_err(|message| std::io::Error::new(std::io::ErrorKind::InvalidData, message))?;+ if let Some(provider) = model_providers.get_mut(GCP_PROVIDER_ID)+ && provider.auth.is_none()+ {+ // Registry construction must not depend on the process cwd, which may be deleted.+ provider.auth = Some(ModelProviderAuthInfo {+ command: if cfg!(windows) { "gcloud.cmd" } else { "gcloud" }.to_string(),+ args: vec![+ "auth".into(),+ "application-default".into(),+ "print-access-token".into(),+ ],+ timeout_ms: std::num::NonZeroU64::new(30_000).unwrap_or(std::num::NonZeroU64::MIN),+ refresh_interval_ms: 3_000_000,+ cwd: resolved_cwd.clone(),+ });+ }+let model_provider_id = config_layer_stack.required_model_provider().map(str::to_string).or(model_provider).or(cfg.model_provider)diff --git a/codex-rs/core/tests/suite/client.rs b/codex-rs/core/tests/suite/client.rsindex 7e24379417..ebdcb7a42d 100644--- a/codex-rs/core/tests/suite/client.rs+++ b/codex-rs/core/tests/suite/client.rs@@ -871,14 +871,14 @@ fn write_auth_json(fake_jwt}-struct ProviderAuthCommandFixture {+pub(super) struct ProviderAuthCommandFixture {tempdir: TempDir,command: String,args: Vec<String>,}impl ProviderAuthCommandFixture {- fn new(tokens: &[&str]) -> std::io::Result<Self> {+ pub(super) fn new(tokens: &[&str]) -> std::io::Result<Self> {let tempdir = tempfile::tempdir()?;let tokens_file = tempdir.path().join("tokens.txt");let mut token_file_contents = String::new();@@ -942,7 +942,7 @@ move /y tokens.next tokens.txt >nul})}- fn auth(&self) -> ModelProviderAuthInfo {+ pub(super) fn auth(&self) -> ModelProviderAuthInfo {ModelProviderAuthInfo {command: self.command.clone(),args: self.args.iter().cloned().map(Into::into).collect(),diff --git a/codex-rs/core/tests/suite/compact_remote.rs b/codex-rs/core/tests/suite/compact_remote.rsindex 467a3509d9..671fe45d2b 100644--- a/codex-rs/core/tests/suite/compact_remote.rs+++ b/codex-rs/core/tests/suite/compact_remote.rs@@ -15,8 +15,10 @@ use codex_login::CodexAuth;use codex_login::auth::BedrockApiKeyAuth;use codex_model_provider_info::AMAZON_BEDROCK_GPT_5_5_MODEL_ID;use codex_model_provider_info::AMAZON_BEDROCK_PROVIDER_ID;+use codex_model_provider_info::GCP_PROVIDER_ID;use codex_model_provider_info::ModelProviderInfo;use codex_protocol::AgentPath;+use codex_protocol::config_types::ReasoningSummary;use codex_protocol::models::ContentItem;use codex_protocol::models::ImageReference;use codex_protocol::models::ResponseItem;@@ -51,6 +53,8 @@ use test_case::test_case;use tokio::time::Duration;use wiremock::ResponseTemplate;+use super::client::ProviderAuthCommandFixture;+#[path = "compact_remote_trimming.rs"]mod trimming;@@ -534,18 +538,62 @@ async fn remote_compact_v2_records_usage_before_output_validation() -> Result<()Ok(())}+enum CompactionProvider {+ AmazonBedrock,+ Gcp,+}++#[test_case(CompactionProvider::AmazonBedrock; "bedrock")]+#[test_case(CompactionProvider::Gcp; "gcp")]#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn amazon_bedrock_automatic_compaction_uses_v2_responses_endpoint() -> Result<()> {+async fn provider_automatic_compaction_uses_v2_responses_endpoint(+ provider: CompactionProvider,+) -> Result<()> {skip_if_no_network!(Ok(()));- let harness = TestCodexHarness::with_auto_env_builder(amazon_bedrock_test_codex().with_config(- |config| {+ let server = responses::start_mock_server().await;+ let auth_fixture;+ let (builder, expected_model, expected_path, expected_auth) = match provider {+ CompactionProvider::AmazonBedrock => (+ amazon_bedrock_test_codex(),+ AMAZON_BEDROCK_GPT_5_5_MODEL_ID,+ "/v1/responses",+ "Bearer bedrock-test-api-key",+ ),+ CompactionProvider::Gcp => {+ auth_fixture = ProviderAuthCommandFixture::new(&["vertex-access-token"])?;+ let mut provider = ModelProviderInfo::create_gcp_provider();+ provider.base_url = Some(format!(+ "{}/v1/projects/example-project/locations/global/publishers/openai/v1",+ server.uri()+ ));+ provider.auth = Some(auth_fixture.auth());+ (+ test_codex()+ .with_model("gpt-6.1-sol")+ .with_config(move |config| {+ config.model_provider_id = GCP_PROVIDER_ID.to_string();+ config.model_provider = provider;+ config.model_reasoning_summary = Some(ReasoningSummary::Detailed);+ config+ .features+ .enable(Feature::RemoteCompactionV2)+ .expect("test config should allow feature update");+ }),+ "gpt-6.1-sol",+ "/v1/projects/example-project/locations/global/publishers/openai/v1/responses",+ "Bearer vertex-access-token",+ )+ }+ };+ let test = builder+ .with_config(|config| {config.model_auto_compact_token_limit = Some(200);- },- ))- .await?;+ })+ .build_with_auto_env(&server)+ .await?;let response_mock = responses::mount_sse_sequence(- harness.server(),+ &server,vec![sse(vec![responses::ev_assistant_message("message-1", "before automatic compaction"),@@ -556,7 +604,7 @@ async fn amazon_bedrock_automatic_compaction_uses_v2_responses_endpoint() -> Res"type": "response.output_item.done","item": {"type": "compaction",- "encrypted_content": "BEDROCK_AUTOMATIC_REMOTE_COMPACTED_SUMMARY",+ "encrypted_content": "PROVIDER_AUTOMATIC_REMOTE_COMPACTED_SUMMARY",}}),responses::ev_completed("response-compact"),@@ -569,44 +617,47 @@ async fn amazon_bedrock_automatic_compaction_uses_v2_responses_endpoint() -> Res).await;- harness- .test()- .submit_turn("before automatic compact")- .await?;- harness- .test()- .submit_turn("after automatic compact")- .await?;+ test.submit_turn("before automatic compact").await?;+ test.submit_turn("after automatic compact").await?;let response_requests = response_mock.requests();assert_eq!(response_requests.len(), 3);assert!(response_requests.iter()- .all(|request| request.path() == "/v1/responses")+ .all(|request| request.path() == expected_path));let compact_request = &response_requests[1];assert_eq!(compact_request.header("authorization").as_deref(),- Some("Bearer bedrock-test-api-key")- );- assert_eq!(- compact_request- .header("x-amzn-mantle-client-agent")- .as_deref(),- Some("codex")- );- assert_eq!(- compact_request.body_json()["model"],- AMAZON_BEDROCK_GPT_5_5_MODEL_ID+ Some(expected_auth));+ match provider {+ CompactionProvider::AmazonBedrock => assert_eq!(+ compact_request+ .header("x-amzn-mantle-client-agent")+ .as_deref(),+ Some("codex")+ ),+ CompactionProvider::Gcp => {+ for request in &response_requests {+ assert_eq!(request.body_json()["reasoning"].get("summary"), None);+ assert_eq!(+ request.header("x-openai-internal-codex-responses-lite"),+ None+ );+ assert!(request.inputs_of_type("additional_tools").is_empty());+ }+ }+ }+ assert_eq!(compact_request.body_json()["model"], expected_model);assert_eq!(compact_request.inputs_of_type("compaction_trigger").len(),1);assert!(response_requests[2].input().iter().any(|item| {item["type"] == "compaction"- && item["encrypted_content"] == "BEDROCK_AUTOMATIC_REMOTE_COMPACTED_SUMMARY"+ && item["encrypted_content"] == "PROVIDER_AUTOMATIC_REMOTE_COMPACTED_SUMMARY"}));Ok(())diff --git a/codex-rs/core/tests/suite/gcp.rs b/codex-rs/core/tests/suite/gcp.rsnew file mode 100644index 0000000000..bcbde46ac7--- /dev/null+++ b/codex-rs/core/tests/suite/gcp.rs@@ -0,0 +1,355 @@+use anyhow::Context;+use anyhow::Result;+use codex_core::StartThreadOptions;+use codex_core::TurnInputRequest;+use codex_core::config::Constrained;+use codex_features::Feature;+use codex_model_provider_info::GCP_PROVIDER_ID;+use codex_model_provider_info::ModelProviderInfo;+use codex_protocol::config_types::ApprovalsReviewer;+use codex_protocol::config_types::ReasoningSummary;+use codex_protocol::dynamic_tools::DynamicToolFunctionSpec;+use codex_protocol::dynamic_tools::DynamicToolNamespaceSpec;+use codex_protocol::dynamic_tools::DynamicToolNamespaceTool;+use codex_protocol::dynamic_tools::DynamicToolSpec;+use codex_protocol::openai_models::ApplyPatchToolType;+use codex_protocol::openai_models::ReasoningEffort;+use codex_protocol::openai_models::ToolMode;+use codex_protocol::protocol::AskForApproval;+use codex_protocol::protocol::EventMsg;+use codex_protocol::protocol::MultiAgentVersion;+use codex_protocol::protocol::ThreadSettingsOverrides;+use codex_protocol::user_input::UserInput;+use core_test_support::responses;+use core_test_support::skip_if_no_network;+use core_test_support::test_codex::test_codex;+use core_test_support::wait_for_event;+use pretty_assertions::assert_eq;+use serde_json::Value;+use serde_json::json;+use test_case::test_case;++use super::client::ProviderAuthCommandFixture;++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn vertex_requests_use_command_auth_with_namespaces_and_tool_search() -> Result<()> {+ skip_if_no_network!(Ok(()));++ let server = responses::start_mock_server().await;+ let response = responses::mount_sse_once(+ &server,+ responses::sse(vec![+ responses::ev_response_created("resp-1"),+ responses::ev_completed("resp-1"),+ ]),+ )+ .await;+ let auth_fixture =+ ProviderAuthCommandFixture::new(&["vertex-access-token", "vertex-access-token"])?;+ let mut provider = ModelProviderInfo::create_gcp_provider();+ provider.base_url = Some(format!(+ "{}/v1/projects/example-project/locations/global/publishers/openai/v1",+ server.uri()+ ));+ provider.auth = Some(auth_fixture.auth());++ let mut test = test_codex()+ .with_model_info_override("gpt-6.1-sol", |model| {+ model.use_responses_lite = true;+ model.tool_mode = Some(ToolMode::CodeModeOnly);+ model.apply_patch_tool_type = Some(ApplyPatchToolType::Freeform);+ model.supports_search_tool = true;+ model.multi_agent_version = Some(MultiAgentVersion::V2);+ })+ .with_config(move |config| {+ config.model_provider_id = GCP_PROVIDER_ID.to_string();+ config.model_provider = provider;+ config.base_instructions = Some("Vertex test instructions".to_string());+ })+ .build_with_auto_env(&server)+ .await?;+ let input_schema = json!({+ "type": "object",+ "properties": {},+ "additionalProperties": false,+ });+ let dynamic_tool = DynamicToolSpec::Namespace(DynamicToolNamespaceSpec {+ name: "records".to_string(),+ description: "Record tools.".to_string(),+ tools: vec![+ DynamicToolNamespaceTool::Function(DynamicToolFunctionSpec {+ name: "status".to_string(),+ description: "Get record service status.".to_string(),+ input_schema: input_schema.clone(),+ defer_loading: false,+ }),+ DynamicToolNamespaceTool::Function(DynamicToolFunctionSpec {+ name: "lookup".to_string(),+ description: "Look up a record.".to_string(),+ input_schema: input_schema.clone(),+ defer_loading: true,+ }),+ ],+ });+ let thread = test+ .thread_manager+ .start_thread(StartThreadOptions {+ dynamic_tools: vec![dynamic_tool],+ ..test.start_thread_options().await+ })+ .await?;+ test.codex = thread.thread;+ test.session_configured = thread.session_configured;++ test.submit_turn("Look up a record").await?;++ let request = response.single_request();+ assert_eq!(+ request.path(),+ "/v1/projects/example-project/locations/global/publishers/openai/v1/responses"+ );+ assert_eq!(+ request.header("authorization").as_deref(),+ Some("Bearer vertex-access-token")+ );+ assert_eq!(+ request.header("x-openai-internal-codex-responses-lite"),+ None+ );+ assert!(+ request.inputs_of_type("additional_tools").is_empty(),+ "Vertex request must omit Responses Lite additional_tools inputs"+ );+ let body = request.body_json();+ assert_eq!(body["model"], "gpt-6.1-sol");+ assert_eq!(request.instructions_text(), "Vertex test instructions");+ let tools = body["tools"]+ .as_array()+ .context("Vertex request should include model tools")?;+ assert_eq!(+ test.codex.multi_agent_version(),+ Some(MultiAgentVersion::V2)+ );+ assert!(tools.iter().any(|tool| tool["name"] == "collaboration"));+ let namespace = tools.iter().find(|tool| tool["name"] == "records");+ assert_eq!(+ namespace,+ Some(&json!({+ "type": "namespace",+ "name": "records",+ "description": "Record tools.",+ "tools": [{+ "type": "function",+ "name": "status",+ "description": "Get record service status.",+ "strict": false,+ "parameters": input_schema,+ }],+ }))+ );+ assert!(+ tools+ .iter()+ .any(|tool| tool["type"] == "tool_search" && tool["execution"] == "client"),+ "Vertex request should expose client-side tool search: {tools:?}"+ );+ assert!(+ tools+ .iter()+ .any(|tool| tool.get("name").and_then(Value::as_str) == Some("exec_command")),+ "Vertex request should preserve the exec_command function tool: {tools:?}"+ );++ Ok(())+}++#[test_case("gpt-6.1-sol"; "catalog model")]+#[test_case("vertex-test-model"; "fallback model")]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn vertex_requests_omit_reasoning_summaries(model: &str) -> Result<()> {+ skip_if_no_network!(Ok(()));++ let server = responses::start_mock_server().await;+ let response = responses::mount_sse_once(+ &server,+ responses::sse(vec![+ responses::ev_response_created("resp-1"),+ responses::ev_completed("resp-1"),+ ]),+ )+ .await;+ let auth_fixture = ProviderAuthCommandFixture::new(&["vertex-access-token"])?;+ let mut provider = ModelProviderInfo::create_gcp_provider();+ provider.base_url = Some(format!("{}/v1", server.uri()));+ provider.auth = Some(auth_fixture.auth());+ let test = test_codex()+ .with_model_info_override("gpt-6.1-sol", |model_info| {+ model_info.supports_reasoning_summary_parameter = true;+ model_info.default_reasoning_summary = ReasoningSummary::Detailed;+ })+ .with_model(model)+ .with_config(move |config| {+ config.model_provider_id = GCP_PROVIDER_ID.to_string();+ config.model_provider = provider;+ config.model_reasoning_effort = Some(ReasoningEffort::High);+ config.model_reasoning_summary = Some(ReasoningSummary::None);+ config+ .features+ .enable(Feature::ConcurrentReasoningSummaries)+ .expect("test config should allow feature update");+ })+ .build_with_auto_env(&server)+ .await?;++ test.codex+ .start_or_steer_turn(+ TurnInputRequest::user_input(vec![UserInput::Text {+ text: "say hello".into(),+ text_elements: Vec::new(),+ }])+ .with_thread_settings(ThreadSettingsOverrides {+ summary: Some(ReasoningSummary::Concise),+ ..Default::default()+ }),+ )+ .await?;+ wait_for_event(&test.codex, |event| {+ matches!(event, EventMsg::TurnComplete(_))+ })+ .await;++ let body = response.single_request().body_json();+ assert_eq!(body["model"], model);+ assert_eq!(body["reasoning"], json!({"effort": "high"}));+ assert_eq!(body["include"], json!(["reasoning.encrypted_content"]));+ assert_eq!(body.get("stream_options"), None);++ Ok(())+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn missing_vertex_credentials_explain_how_to_reauthenticate() -> Result<()> {+ skip_if_no_network!(Ok(()));++ let server = responses::start_mock_server().await;+ let response = responses::mount_sse_once(+ &server,+ responses::sse(vec![+ responses::ev_response_created("unused-response"),+ responses::ev_completed("unused-response"),+ ]),+ )+ .await;+ let auth_fixture = ProviderAuthCommandFixture::new(&[])?;+ let mut provider = ModelProviderInfo::create_gcp_provider();+ provider.base_url = Some(format!(+ "{}/v1/projects/example-project/locations/global/publishers/openai/v1",+ server.uri()+ ));+ provider.auth = Some(auth_fixture.auth());++ let test = test_codex()+ .with_model("vertex-test-model")+ .with_config(move |config| {+ config.model_provider_id = GCP_PROVIDER_ID.to_string();+ config.model_provider = provider;+ })+ .build_with_auto_env(&server)+ .await?;++ test.codex+ .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {+ text: "say hello".into(),+ text_elements: Vec::new(),+ }]))+ .await?;++ let EventMsg::Error(error) =+ wait_for_event(&test.codex, |event| matches!(event, EventMsg::Error(_))).await+ else {+ unreachable!();+ };+ assert_eq!(+ error.message,+ "Google Cloud credentials are unavailable or expired. Run \+`gcloud auth application-default login` to reauthenticate."+ );+ assert!(response.requests().is_empty());++ Ok(())+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn vertex_guardian_requests_use_luna() -> Result<()> {+ skip_if_no_network!(Ok(()));++ let server = responses::start_mock_server().await;+ let response = responses::mount_sse_sequence(+ &server,+ vec![+ responses::sse(vec![+ responses::ev_response_created("parent-tool"),+ responses::ev_function_call(+ "reviewed-tool",+ "exec_command",+ r#"{"cmd":"true","sandbox_permissions":"require_escalated","justification":"test"}"#,+ ),+ responses::ev_completed("parent-tool"),+ ]),+ responses::sse(vec![+ responses::ev_response_created("guardian-review"),+ responses::ev_assistant_message("guardian", r#"{"outcome":"deny"}"#),+ responses::ev_completed("guardian-review"),+ ]),+ responses::sse(vec![responses::ev_completed("parent-complete")]),+ ],+ )+ .await;+ let auth_fixture =+ ProviderAuthCommandFixture::new(&["vertex-access-token", "vertex-access-token"])?;+ let mut provider = ModelProviderInfo::create_gcp_provider();+ provider.base_url = Some(format!("{}/v1", server.uri()));+ provider.auth = Some(auth_fixture.auth());+ let test = test_codex()+ .with_model("gpt-6.1-sol")+ .with_config(move |config| {+ config.model_provider_id = GCP_PROVIDER_ID.to_string();+ config.model_provider = provider;+ config.permissions.approval_policy = Constrained::allow_any(AskForApproval::OnRequest);+ config.approvals_reviewer = ApprovalsReviewer::AutoReview;+ })+ .build_with_auto_env(&server)+ .await?;++ let models = test.thread_manager.get_models_manager().try_list_models()?;+ insta::assert_debug_snapshot!(+ "gcp_model_picker",+ models+ .iter()+ .map(|model| (&model.model, model.show_in_picker, model.is_default))+ .collect::<Vec<_>>()+ );++ test.submit_text_turn("run a command").await?;++ let requests = response.requests();+ assert_eq!(+ requests+ .iter()+ .map(|request| request.body_json()["model"].clone())+ .collect::<Vec<_>>(),+ vec![+ json!("gpt-6.1-sol"),+ json!("gpt-6-luna"),+ json!("gpt-6.1-sol")+ ]+ );+ let guardian_request = &requests[1];+ assert_eq!(guardian_request.path(), "/v1/responses");+ assert_eq!(+ guardian_request.header("authorization").as_deref(),+ Some("Bearer vertex-access-token")+ );++ Ok(())+}diff --git a/codex-rs/core/tests/suite/mod.rs b/codex-rs/core/tests/suite/mod.rsindex d64ef3a06d..c1eab6608b 100644--- a/codex-rs/core/tests/suite/mod.rs+++ b/codex-rs/core/tests/suite/mod.rs@@ -88,6 +88,7 @@ mod exec_policy;mod extension_sandbox;mod external_auth;mod fork_thread;+mod gcp;mod git_enrichment;mod guardian_authorization;mod guardian_authorization_refresh;diff --git a/codex-rs/core/tests/suite/snapshots/all__suite__gcp__gcp_model_picker.snap b/codex-rs/core/tests/suite/snapshots/all__suite__gcp__gcp_model_picker.snapnew file mode 100644index 0000000000..3531310947--- /dev/null+++ b/codex-rs/core/tests/suite/snapshots/all__suite__gcp__gcp_model_picker.snap@@ -0,0 +1,21 @@+---+source: core/tests/suite/gcp.rs+expression: "models.iter().map(|model|\n(&model.model, model.show_in_picker, model.is_default)).collect::<Vec<_>>()"+---+[+ (+ "gpt-6.1-sol",+ true,+ true,+ ),+ (+ "gpt-6-astra",+ true,+ false,+ ),+ (+ "gpt-6-luna",+ true,+ false,+ ),+]diff --git a/codex-rs/exec/src/daybreak.rs b/codex-rs/exec/src/daybreak.rsindex e3fdf41bf4..9f4a1cb8b7 100644--- a/codex-rs/exec/src/daybreak.rs+++ b/codex-rs/exec/src/daybreak.rs@@ -73,7 +73,7 @@ pub(crate) async fn program_for_turn(Some(Account::ApiKey { .. }) => {features.enabled(Feature::ApiKeyCyberAccessPrograms)}- Some(Account::AmazonBedrock { .. }) | None => false,+ Some(Account::AmazonBedrock { .. } | Account::Gcp {}) | None => false,};return Ok(eligible.then_some(standard.into()));}diff --git a/codex-rs/model-provider-info/src/lib.rs b/codex-rs/model-provider-info/src/lib.rsindex a70ab290ea..177d7c5917 100644--- a/codex-rs/model-provider-info/src/lib.rs+++ b/codex-rs/model-provider-info/src/lib.rs@@ -84,6 +84,8 @@ const AMAZON_BEDROCK_PROVIDER_NAME: &str = "Amazon Bedrock";pub const AMAZON_BEDROCK_PROVIDER_ID: &str = "amazon-bedrock";const AMAZON_BEDROCK_RUNTIME_PROVIDER_NAME: &str = "Amazon Bedrock Runtime";pub const AMAZON_BEDROCK_RUNTIME_PROVIDER_ID: &str = "amazon-bedrock-runtime";+const GCP_PROVIDER_NAME: &str = "Google Cloud Vertex AI";+pub const GCP_PROVIDER_ID: &str = "gcp";pub const AMAZON_BEDROCK_GPT_5_5_MODEL_ID: &str = "openai.gpt-5.5";pub const AMAZON_BEDROCK_GPT_5_6_SOL_MODEL_ID: &str = "openai.gpt-5.6-sol";pub const AMAZON_BEDROCK_GPT_6_1_SOL_MODEL_ID: &str = "openai.gpt-6.1-sol";@@ -615,6 +617,34 @@ other non-default provider fields are not supported"provider}+ pub fn create_gcp_provider() -> ModelProviderInfo {+ ModelProviderInfo {+ name: GCP_PROVIDER_NAME.into(),+ base_url: None,+ model_catalog_url: None,+ env_key: None,+ env_key_instructions: None,+ experimental_bearer_token: None,+ // Config loading supplies default command auth after resolving its working directory.+ auth: None,+ gateway_oauth: None,+ aws: None,+ capabilities: None,+ wire_api: WireApi::Responses,+ query_params: None,+ http_headers: None,+ env_http_headers: None,+ request_max_retries: None,+ stream_max_retries: None,+ stream_idle_timeout_ms: None,+ websocket_connect_timeout_ms: None,+ requires_openai_auth: false,+ supports_websockets: false,+ supports_standalone_web_search: false,+ include_internal_metadata: false,+ }+ }+pub fn is_openai(&self) -> bool {self.name == OPENAI_PROVIDER_NAME}@@ -647,6 +677,10 @@ other non-default provider fields are not supported"self.name == AMAZON_BEDROCK_RUNTIME_PROVIDER_NAME}+ pub fn is_gcp(&self) -> bool {+ self.name == GCP_PROVIDER_NAME+ }+pub fn has_command_auth(&self) -> bool {self.auth.is_some()}@@ -667,14 +701,14 @@ pub fn built_in_model_providers(let amazon_bedrock_provider = P::create_amazon_bedrock_provider(/*aws*/ None);let amazon_bedrock_runtime_provider =P::create_amazon_bedrock_runtime_provider(/*aws*/ None);+ let gcp_provider = P::create_gcp_provider();- // We do not want to be in the business of adjucating which third-party- // providers are bundled with Codex CLI, so we only include the OpenAI and- // open source ("oss") providers by default. Users are encouraged to add to- // `model_providers` in config.toml to add their own providers.+ // Bundle OpenAI, supported cloud-hosted OpenAI backends, and local OSS providers.+ // Other compatible providers can be added through `model_providers` in config.toml.[(OPENAI_PROVIDER_ID, openai_provider),(AMAZON_BEDROCK_PROVIDER_ID, amazon_bedrock_provider),+ (GCP_PROVIDER_ID, gcp_provider),(AMAZON_BEDROCK_RUNTIME_PROVIDER_ID,amazon_bedrock_runtime_provider,@@ -696,8 +730,8 @@ pub fn built_in_model_providers(/// Merge configured providers into the built-in provider catalog.////// Configured providers extend the built-in set. Built-in providers are not-/// generally overridable, but built-in Amazon Bedrock providers allow the user-/// to customize their endpoint, authentication, headers, and AWS settings.+/// generally overridable, but the cloud-hosted OpenAI providers allow a limited+/// set of endpoint, authentication, header, and cloud-specific overrides.pub fn merge_configured_model_providers(mut model_providers: HashMap<String, ModelProviderInfo>,configured_model_providers: HashMap<String, ModelProviderInfo>,@@ -727,6 +761,31 @@ pub fn merge_configured_model_providers(.extend(http_headers_override);}}+ } else if key == GCP_PROVIDER_ID {+ let base_url_override = provider.base_url.take();+ let auth_override = provider.auth.take();+ let http_headers_override = provider.http_headers.take();+ if provider != ModelProviderInfo::default() {+ return Err(format!(+ "model_providers.{GCP_PROVIDER_ID} only supports changing \+`base_url`, `auth`, and `http_headers`; other non-default provider fields are not supported"+ ));+ }++ if let Some(built_in_provider) = model_providers.get_mut(GCP_PROVIDER_ID) {+ if let Some(base_url_override) = base_url_override {+ built_in_provider.base_url = Some(base_url_override);+ }+ if let Some(auth_override) = auth_override {+ built_in_provider.auth = Some(auth_override);+ }+ if let Some(http_headers_override) = http_headers_override {+ built_in_provider+ .http_headers+ .get_or_insert_default()+ .extend(http_headers_override);+ }+ }} else {model_providers.entry(key).or_insert(provider);}diff --git a/codex-rs/model-provider-info/src/model_provider_info_tests.rs b/codex-rs/model-provider-info/src/model_provider_info_tests.rsindex 9c15c54b70..10a70b66ee 100644--- a/codex-rs/model-provider-info/src/model_provider_info_tests.rs+++ b/codex-rs/model-provider-info/src/model_provider_info_tests.rs@@ -637,6 +637,64 @@ fn test_merge_configured_model_providers_applies_amazon_bedrock_transport_overri);}+#[test]+fn test_merge_configured_model_providers_applies_gcp_transport_overrides() {+ let auth = provider_auth_for_test();+ let configured_model_providers = std::collections::HashMap::from([(+ GCP_PROVIDER_ID.to_string(),+ ModelProviderInfo {+ base_url: Some("https://vertex.example.com/v1".to_string()),+ auth: Some(auth.clone()),+ http_headers: Some(maplit::hashmap! {+ "x-example-header".to_string() => "value".into(),+ }),+ ..ModelProviderInfo::default()+ },+ )]);++ let mut expected = built_in_model_providers(/*openai_base_url*/ None);+ let provider = expected+ .get_mut(GCP_PROVIDER_ID)+ .expect("GCP provider should be built in");+ provider.base_url = Some("https://vertex.example.com/v1".to_string());+ provider.auth = Some(auth);+ provider.http_headers = Some(maplit::hashmap! {+ "x-example-header".to_string() => "value".into(),+ });++ assert_eq!(+ merge_configured_model_providers(+ built_in_model_providers(/*openai_base_url*/ None),+ configured_model_providers,+ ),+ Ok(expected)+ );+}++#[test]+fn test_merge_configured_model_providers_applies_gcp_endpoint_override() {+ let configured_model_providers = std::collections::HashMap::from([(+ GCP_PROVIDER_ID.to_string(),+ ModelProviderInfo {+ base_url: Some("https://vertex.example.com/v1".to_string()),+ ..ModelProviderInfo::default()+ },+ )]);+ let mut expected = built_in_model_providers(/*openai_base_url*/ None);+ expected+ .get_mut(GCP_PROVIDER_ID)+ .expect("GCP provider should be built in")+ .base_url = Some("https://vertex.example.com/v1".to_string());++ assert_eq!(+ merge_configured_model_providers(+ built_in_model_providers(/*openai_base_url*/ None),+ configured_model_providers,+ ),+ Ok(expected)+ );+}+#[test]fn test_merge_configured_model_providers_rejects_amazon_bedrock_non_default_fields() {let configured_model_providers = std::collections::HashMap::from([(diff --git a/codex-rs/model-provider/src/amazon_bedrock/mod.rs b/codex-rs/model-provider/src/amazon_bedrock/mod.rsindex d18aa4bd56..3bd18668b8 100644--- a/codex-rs/model-provider/src/amazon_bedrock/mod.rs+++ b/codex-rs/model-provider/src/amazon_bedrock/mod.rs@@ -279,6 +279,7 @@ impl ModelProvider for AmazonBedrockModelProvider {fn capabilities(&self) -> ProviderCapabilities {ProviderCapabilities {+ reasoning_summaries: true,image_generation: false,web_search: self.endpoint == BedrockEndpoint::Mantle,external_web_access: false,@@ -696,6 +697,7 @@ mod tests {assert_eq!(provider.capabilities(),ProviderCapabilities {+ reasoning_summaries: true,image_generation: false,web_search: true,external_web_access: false,@@ -714,6 +716,7 @@ mod tests {assert_eq!(provider.capabilities(),ProviderCapabilities {+ reasoning_summaries: true,image_generation: false,web_search: false,external_web_access: false,diff --git a/codex-rs/model-provider/src/capabilities.rs b/codex-rs/model-provider/src/capabilities.rsindex f8e8891fb0..311a83fe45 100644--- a/codex-rs/model-provider/src/capabilities.rs+++ b/codex-rs/model-provider/src/capabilities.rs@@ -10,6 +10,8 @@ use codex_model_provider_info::RemoteCompactionSupport;/// can further restrict the functionality exposed to the model.#[derive(Debug, Clone, Copy, PartialEq, Eq)]pub struct ProviderCapabilities {+ /// Whether requests may include the Responses API `reasoning.summary` parameter.+ pub reasoning_summaries: bool,pub image_generation: bool,pub web_search: bool,pub external_web_access: bool,@@ -19,6 +21,7 @@ pub struct ProviderCapabilities {impl Default for ProviderCapabilities {fn default() -> Self {Self {+ reasoning_summaries: true,image_generation: true,web_search: true,external_web_access: true,diff --git a/codex-rs/model-provider/src/gcp/gcp_tests.rs b/codex-rs/model-provider/src/gcp/gcp_tests.rsnew file mode 100644index 0000000000..e2046dbe55--- /dev/null+++ b/codex-rs/model-provider/src/gcp/gcp_tests.rs@@ -0,0 +1,176 @@+use codex_models_manager::ModelsManagerConfig;+use codex_protocol::config_types::ModelProviderAuthInfo;+use codex_protocol::openai_models::ApplyPatchToolType;+use codex_protocol::protocol::MultiAgentVersion;+use pretty_assertions::assert_eq;++use super::*;++#[test]+fn vertex_base_url_defaults_to_global_location() {+ assert_eq!(+ vertex_base_url(Some("example-project"), /*location*/ None)+ .expect("project should resolve a Vertex endpoint"),+ "https://aiplatform.googleapis.com/v1/projects/example-project/locations/global/publishers/openai/v1"+ );+}++#[test]+fn vertex_base_url_uses_explicit_location() {+ assert_eq!(+ vertex_base_url(Some("example-project"), Some("us-central1"))+ .expect("project and location should resolve a Vertex endpoint"),+ "https://aiplatform.googleapis.com/v1/projects/example-project/locations/us-central1/publishers/openai/v1"+ );+}++#[test]+fn vertex_base_url_explains_missing_project() {+ let error = vertex_base_url(/*project*/ None, /*location*/ None)+ .expect_err("missing project should be rejected");++ assert_eq!(+ error.to_string(),+ "Missing environment variable: `GOOGLE_CLOUD_PROJECT`. Set GOOGLE_CLOUD_PROJECT to your Google Cloud project ID, or configure model_providers.gcp.base_url."+ );+}++#[test]+fn vertex_base_url_rejects_path_components() {+ let error = vertex_base_url(Some("example-project/other"), /*location*/ None)+ .expect_err("project must not add endpoint path components");++ assert_eq!(+ error.to_string(),+ "GOOGLE_CLOUD_PROJECT must contain only ASCII letters, digits, and hyphens"+ );+}++#[tokio::test]+async fn configured_base_url_bypasses_project_discovery() {+ let mut provider_info = ModelProviderInfo::create_gcp_provider();+ provider_info.base_url = Some("https://vertex.example.com/v1".to_string());+ provider_info.auth = Some(ModelProviderAuthInfo {+ command: "print-token".to_string(),+ args: Vec::new(),+ timeout_ms: std::num::NonZeroU64::new(5_000).expect("timeout should be non-zero"),+ refresh_interval_ms: 300_000,+ cwd: std::env::current_dir()+ .expect("current directory should be available")+ .try_into()+ .expect("current directory should be absolute"),+ });+ let provider = GcpModelProvider::new(provider_info, /*auth_manager*/ None);++ assert_eq!(+ provider+ .api_provider()+ .await+ .expect("configured endpoint should build")+ .base_url,+ "https://vertex.example.com/v1"+ );+ assert!(+ provider+ .auth_manager()+ .expect("GCP should create a command-backed auth manager")+ .has_external_auth()+ );+}++#[tokio::test]+async fn bundled_vertex_models_filter_catalog_and_normalize_unsupported_tool_metadata() {+ let provider = GcpModelProvider::new(+ ModelProviderInfo::create_gcp_provider(),+ /*auth_manager*/ None,+ );+ let manager = provider.models_manager(+ PathBuf::from("unused-codex-home"),+ /*config_model_catalog*/ None,+ );+ let bundled_models = codex_models_manager::bundled_models_response()+ .expect("bundled model catalog should deserialize")+ .models;+ let mut expected: Vec<_> = ["gpt-6-astra", "gpt-6.1-sol", "gpt-6-luna"]+ .into_iter()+ .map(|slug| {+ bundled_models+ .iter()+ .find(|model| model.slug == slug)+ .expect("bundled catalog should contain the supported Vertex model")+ .clone()+ })+ .collect();+ for model in &mut expected {+ model.use_responses_lite = false;+ model.tool_mode = Some(ToolMode::Direct);+ model.apply_patch_tool_type = None;+ }++ assert_eq!(manager.get_remote_models().await, expected);+ assert_eq!(+ manager+ .try_list_models()+ .expect("static models should be available")+ .into_iter()+ .map(|model| (model.model, model.show_in_picker))+ .collect::<Vec<_>>(),+ vec![+ ("gpt-6.1-sol".to_string(), true),+ ("gpt-6-astra".to_string(), true),+ ("gpt-6-luna".to_string(), true),+ ]+ );+}++#[tokio::test]+async fn configured_vertex_models_filter_catalog_and_normalize_tool_metadata_without_cache() {+ let provider = GcpModelProvider::new(+ ModelProviderInfo::create_gcp_provider(),+ /*auth_manager*/ None,+ );+ let mut configured_model = codex_models_manager::bundled_models_response()+ .expect("bundled model catalog should deserialize")+ .models+ .into_iter()+ .find(|model| model.slug == "gpt-6.1-sol")+ .expect("bundled model catalog should contain gpt-6.1-sol");+ configured_model.use_responses_lite = true;+ configured_model.tool_mode = Some(ToolMode::CodeModeOnly);+ configured_model.apply_patch_tool_type = Some(ApplyPatchToolType::Freeform);+ configured_model.multi_agent_version = Some(MultiAgentVersion::V2);+ let mut expected_model = configured_model.clone();+ expected_model.use_responses_lite = false;+ expected_model.tool_mode = Some(ToolMode::Direct);+ expected_model.apply_patch_tool_type = None;+ let mut unsupported_model = configured_model.clone();+ unsupported_model.slug = "gpt-6-sol".to_string();+ let mut unsupported_variant = configured_model.clone();+ unsupported_variant.slug = "gpt-6.1-sol-extra".to_string();+ let manager = provider.models_manager_without_cache(Some(ModelsResponse {+ models: vec![unsupported_model, configured_model, unsupported_variant],+ }));++ assert_eq!(manager.get_remote_models().await, vec![expected_model]);+}++#[tokio::test]+async fn unknown_vertex_models_use_static_catalog_fallback() {+ let provider = GcpModelProvider::new(+ ModelProviderInfo::create_gcp_provider(),+ /*auth_manager*/ None,+ );+ let manager = provider.models_manager(+ PathBuf::from("unused-codex-home"),+ Some(ModelsResponse::default()),+ );++ let model = manager+ .get_model_info("vertex-test-model", &ModelsManagerConfig::default())+ .await;++ assert_eq!(+ (model.slug, model.used_fallback_model_metadata),+ ("vertex-test-model".to_string(), true)+ );+}diff --git a/codex-rs/model-provider/src/gcp/mod.rs b/codex-rs/model-provider/src/gcp/mod.rsnew file mode 100644index 0000000000..831b9e719c--- /dev/null+++ b/codex-rs/model-provider/src/gcp/mod.rs@@ -0,0 +1,215 @@+//! Vertex AI provider routing, command-backed credentials, and supported model capabilities.++use std::path::PathBuf;+use std::sync::Arc;++use codex_api::Provider;+use codex_api::SharedAuthProvider;+use codex_login::AuthManager;+use codex_login::CodexAuth;+use codex_model_provider_info::ModelProviderInfo;+use codex_models_manager::manager::SharedModelsManager;+use codex_models_manager::manager::StaticModelsManager;+use codex_protocol::account::ProviderAccount;+use codex_protocol::error::CodexErr;+use codex_protocol::error::EnvVarError;+use codex_protocol::error::Result;+use codex_protocol::openai_models::ModelsResponse;+use codex_protocol::openai_models::ToolMode;++use crate::ProviderCapabilities;+use crate::RemoteCompactionSupport;+use crate::auth::auth_manager_for_provider;+use crate::auth::resolve_provider_auth;+use crate::provider::ModelProvider;+use crate::provider::ModelProviderFuture;+use crate::provider::ProviderAccountResult;+use crate::provider::ProviderAccountState;++const GOOGLE_CLOUD_PROJECT_ENV_VAR: &str = "GOOGLE_CLOUD_PROJECT";+const GOOGLE_CLOUD_LOCATION_ENV_VAR: &str = "GOOGLE_CLOUD_LOCATION";+const DEFAULT_GOOGLE_CLOUD_LOCATION: &str = "global";++/// Runtime provider for Google Cloud Vertex AI's OpenAI-compatible endpoint.+#[derive(Clone, Debug)]+pub(crate) struct GcpModelProvider {+ info: ModelProviderInfo,+ auth_manager: Option<Arc<AuthManager>>,+}++impl GcpModelProvider {+ pub(crate) fn new(+ provider_info: ModelProviderInfo,+ auth_manager: Option<Arc<AuthManager>>,+ ) -> Self {+ let auth_manager = auth_manager_for_provider(auth_manager, &provider_info);+ Self {+ info: provider_info,+ auth_manager,+ }+ }++ async fn auth(&self) -> Option<CodexAuth> {+ match self.auth_manager.as_ref() {+ Some(auth_manager) => auth_manager.auth().await,+ None => None,+ }+ }++ async fn api_provider(&self) -> Result<Provider> {+ let mut provider_info = self.info.clone();+ provider_info.base_url = self.runtime_base_url().await?;+ provider_info.to_api_provider(/*auth_mode*/ None)+ }++ async fn runtime_base_url(&self) -> Result<Option<String>> {+ if let Some(base_url) = self.info.base_url.clone() {+ return Ok(Some(base_url));+ }++ let project = std::env::var(GOOGLE_CLOUD_PROJECT_ENV_VAR).ok();+ let location = std::env::var(GOOGLE_CLOUD_LOCATION_ENV_VAR).ok();+ vertex_base_url(project.as_deref(), location.as_deref()).map(Some)+ }+}++impl ModelProvider for GcpModelProvider {+ fn info(&self) -> &ModelProviderInfo {+ &self.info+ }++ fn capabilities(&self) -> ProviderCapabilities {+ ProviderCapabilities {+ reasoning_summaries: false,+ image_generation: false,+ web_search: false,+ external_web_access: false,+ remote_compaction: RemoteCompactionSupport::V2,+ }+ }++ fn approval_review_preferred_model(&self) -> &'static str {+ // TODO: Switch Guardian to gpt-5.6-luna once it is available on GCP.+ "gpt-6-luna"+ }++ fn memory_extraction_preferred_model(&self) -> &'static str {+ "gpt-6-luna"+ }++ fn memory_consolidation_preferred_model(&self) -> &'static str {+ "gpt-6.1-sol"+ }++ fn auth_manager(&self) -> Option<Arc<AuthManager>> {+ self.auth_manager.clone()+ }++ fn auth(&self) -> ModelProviderFuture<'_, Option<CodexAuth>> {+ Box::pin(GcpModelProvider::auth(self))+ }++ fn account_state(&self) -> ProviderAccountResult {+ Ok(ProviderAccountState {+ account: Some(ProviderAccount::Gcp),+ requires_openai_auth: false,+ })+ }++ fn api_provider(&self) -> ModelProviderFuture<'_, Result<Provider>> {+ Box::pin(GcpModelProvider::api_provider(self))+ }++ fn api_auth(&self) -> ModelProviderFuture<'_, Result<SharedAuthProvider>> {+ Box::pin(async move {+ let auth = self.auth().await.ok_or_else(|| {+ CodexErr::InvalidRequest(+ "Google Cloud credentials are unavailable or expired. Run \+`gcloud auth application-default login` to reauthenticate."+ .to_string(),+ )+ })?;+ resolve_provider_auth(Some(&auth), &self.info)+ })+ }++ fn runtime_base_url(&self) -> ModelProviderFuture<'_, Result<Option<String>>> {+ Box::pin(GcpModelProvider::runtime_base_url(self))+ }++ fn models_manager(+ &self,+ _codex_home: PathBuf,+ config_model_catalog: Option<ModelsResponse>,+ ) -> SharedModelsManager {+ self.models_manager_without_cache(config_model_catalog)+ }++ fn models_manager_without_cache(+ &self,+ config_model_catalog: Option<ModelsResponse>,+ ) -> SharedModelsManager {+ let mut model_catalog = config_model_catalog+ .or_else(|| codex_models_manager::bundled_models_response().ok())+ .unwrap_or_default();+ model_catalog.models.retain(|model| {+ matches!(+ model.slug.as_str(),+ "gpt-6-astra" | "gpt-6-luna" | "gpt-6.1-sol"+ )+ });+ // Vertex supports function tools, namespaces, and client-side tool search, but not+ // Responses Lite or custom tools.+ for model in &mut model_catalog.models {+ model.use_responses_lite = false;+ model.tool_mode = Some(ToolMode::Direct);+ model.apply_patch_tool_type = None;+ }+ Arc::new(StaticModelsManager::new(+ self.auth_manager.clone(),+ model_catalog,+ ))+ }+}++fn vertex_base_url(project: Option<&str>, location: Option<&str>) -> Result<String> {+ let project = project+ .map(str::trim)+ .filter(|project| !project.is_empty())+ .ok_or_else(|| {+ CodexErr::EnvVar(EnvVarError {+ var: GOOGLE_CLOUD_PROJECT_ENV_VAR.to_string(),+ instructions: Some(+ "Set GOOGLE_CLOUD_PROJECT to your Google Cloud project ID, or configure \+model_providers.gcp.base_url."+ .to_string(),+ ),+ })+ })?;+ let location = location+ .map(str::trim)+ .filter(|location| !location.is_empty())+ .unwrap_or(DEFAULT_GOOGLE_CLOUD_LOCATION);++ for (name, value) in [+ (GOOGLE_CLOUD_PROJECT_ENV_VAR, project),+ (GOOGLE_CLOUD_LOCATION_ENV_VAR, location),+ ] {+ if !value+ .chars()+ .all(|character| character.is_ascii_alphanumeric() || character == '-')+ {+ return Err(CodexErr::InvalidRequest(format!(+ "{name} must contain only ASCII letters, digits, and hyphens"+ )));+ }+ }++ Ok(format!(+ "https://aiplatform.googleapis.com/v1/projects/{project}/locations/{location}/publishers/openai/v1"+ ))+}++#[cfg(test)]+#[path = "gcp_tests.rs"]+mod tests;diff --git a/codex-rs/model-provider/src/lib.rs b/codex-rs/model-provider/src/lib.rsindex 9c818af7dd..2fc5f1cf8d 100644--- a/codex-rs/model-provider/src/lib.rs+++ b/codex-rs/model-provider/src/lib.rs@@ -3,6 +3,7 @@ mod auth;mod bearer_auth_provider;mod capabilities;mod combined_auth;+mod gcp;mod models_endpoint;mod models_identity;mod provider;@@ -29,6 +30,7 @@ pub use capabilities::ProviderCapabilities;pub use codex_model_provider_info::AMAZON_BEDROCK_PROVIDER_ID;pub use codex_model_provider_info::AMAZON_BEDROCK_RUNTIME_PROVIDER_ID;pub use codex_model_provider_info::CHATGPT_CODEX_BASE_URL;+pub use codex_model_provider_info::GCP_PROVIDER_ID;pub use codex_model_provider_info::RemoteCompactionSupport;pub use codex_protocol::account::ProviderAccount;pub use provider::ModelProvider;diff --git a/codex-rs/model-provider/src/provider.rs b/codex-rs/model-provider/src/provider.rsindex a5263a8523..49592497c3 100644--- a/codex-rs/model-provider/src/provider.rs+++ b/codex-rs/model-provider/src/provider.rs@@ -33,6 +33,7 @@ use crate::auth::auth_manager_for_provider;use crate::auth::resolve_provider_auth;use crate::auth::resolve_provider_auth_for_scope;use crate::combined_auth::compose_auth;+use crate::gcp::GcpModelProvider;use crate::models_endpoint::OpenAiModelsEndpoint;use crate::workspace_routing::WorkspaceRoutingContext;@@ -348,6 +349,9 @@ pub fn create_model_provider(if provider_info.is_amazon_bedrock() {return Arc::new(AmazonBedrockModelProvider::new(provider_info, auth_manager));}+ if provider_info.is_gcp() {+ return Arc::new(GcpModelProvider::new(provider_info, auth_manager));+ }let gateway_auth_manager = provider_info.gateway_oauth.as_ref().map(|config| {provider_info.validate()?;let manager = auth_managerdiff --git a/codex-rs/protocol/src/account.rs b/codex-rs/protocol/src/account.rsindex 21af040e03..efc4f3b13a 100644--- a/codex-rs/protocol/src/account.rs+++ b/codex-rs/protocol/src/account.rs@@ -59,6 +59,7 @@ pub enum ProviderAccount {AmazonBedrock {uses_codex_managed_credentials: bool,},+ Gcp,}impl PlanType {diff --git a/codex-rs/tui/src/app_server_session.rs b/codex-rs/tui/src/app_server_session.rsindex fd0ddbbd19..143f09d357 100644--- a/codex-rs/tui/src/app_server_session.rs+++ b/codex-rs/tui/src/app_server_session.rs@@ -821,7 +821,7 @@ impl AppServerSession {true,)}- Some(Account::AmazonBedrock { .. }) => {+ Some(Account::AmazonBedrock { .. } | Account::Gcp {}) => {(None, None, None, None, FeedbackAudience::External, false)}None => (None, None, None, None, FeedbackAudience::External, false),diff --git a/codex-rs/tui/src/dynamic_tools.rs b/codex-rs/tui/src/dynamic_tools.rsindex 48e677d311..6015350a56 100644--- a/codex-rs/tui/src/dynamic_tools.rs+++ b/codex-rs/tui/src/dynamic_tools.rs@@ -1320,7 +1320,7 @@ async fn background_turn_program(}true}- Some(Account::AmazonBedrock { .. }) | None => false,+ Some(Account::AmazonBedrock { .. } | Account::Gcp {}) | None => false,};// Retain saved metadata while suppressing it for accounts that cannot use Daybreak.let enabled = enabled && eligible;diff --git a/codex-rs/tui/src/lib.rs b/codex-rs/tui/src/lib.rsindex ac7ec3b53d..96c21c70f6 100644--- a/codex-rs/tui/src/lib.rs+++ b/codex-rs/tui/src/lib.rs@@ -2292,7 +2292,9 @@ async fn get_login_status(let login_status = match &account.account {Some(AppServerAccount::ApiKey {}) => LoginStatus::AuthMode(AuthMode::ApiKey),Some(AppServerAccount::Chatgpt { .. }) => LoginStatus::AuthMode(AuthMode::Chatgpt),- Some(AppServerAccount::AmazonBedrock { .. }) | None => LoginStatus::NotAuthenticated,+ Some(AppServerAccount::AmazonBedrock { .. } | AppServerAccount::Gcp {}) | None => {+ LoginStatus::NotAuthenticated+ }};Ok((login_status, account))}diff --git a/sdk/python/src/openai_codex/generated/v2_all.py b/sdk/python/src/openai_codex/generated/v2_all.pyindex 4ea7e766aa..b0a740ae89 100644--- a/sdk/python/src/openai_codex/generated/v2_all.py+++ b/sdk/python/src/openai_codex/generated/v2_all.py@@ -43,6 +43,13 @@ class AmazonBedrockAccount(BaseModel):] = False+class GcpAccount(BaseModel):+ model_config = ConfigDict(+ populate_by_name=True,+ )+ type: Annotated[Literal["gcp"], Field(title="GcpAccountType")]++class AccountRoutingOverride(Enum):no_constraint = "NO_CONSTRAINT"us = "us"@@ -6847,11 +6854,11 @@ class ChatgptAccount(BaseModel):type: Annotated[Literal["chatgpt"], Field(title="ChatgptAccountType")]-class Account(RootModel[ApiKeyAccount | ChatgptAccount | AmazonBedrockAccount]):+class Account(RootModel[ApiKeyAccount | ChatgptAccount | AmazonBedrockAccount | GcpAccount]):model_config = ConfigDict(populate_by_name=True,)- root: ApiKeyAccount | ChatgptAccount | AmazonBedrockAccount+ root: ApiKeyAccount | ChatgptAccount | AmazonBedrockAccount | GcpAccountclass AccountLoginCompletedNotification(BaseModel):