Lightweight coding agent that runs in your terminal
Rust
//! 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;