Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust
6.3 KB
Raw Blame
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)
    );
}