harn-vm 0.10.80

use super::routing_test_support::{extract_with_options, test_equivalent_model, test_provider};
use super::*;
use crate::llm::helpers::options::routing::equivalent_failover_requirements_for_options;
use crate::llm_config::ProvidersConfig;

#[test]
fn equivalent_failover_filters_by_provider_tool_requirements() {
    let mut overlay = ProvidersConfig::default();
    for provider in ["mock", "plain-backup", "openai"] {
        overlay.providers.insert(
            provider.to_string(),
            test_provider(&format!("https://{provider}.example/v1")),
        );
    }
    overlay.models.insert(
        "tool-primary-model".to_string(),
        test_equivalent_model("mock", "provider-tool-equivalent-test"),
    );
    overlay.models.insert(
        "plain-backup-model".to_string(),
        test_equivalent_model("plain-backup", "provider-tool-equivalent-test"),
    );
    overlay.models.insert(
        "tool-backup-model".to_string(),
        test_equivalent_model("openai", "provider-tool-equivalent-test"),
    );
    crate::llm_config::set_user_overrides(Some(overlay));
    let capability_overlay = [
        "[[provider.mock]]",
        "model_match = \"tool-primary-model\"",
        "native_tools = true",
        "preferred_tool_format = \"native\"",
        "responses_api = true",
        "hosted_tools = [\"web_search\"]",
        "",
        "[[provider.plain-backup]]",
        "model_match = \"plain-backup-model\"",
        "native_tools = true",
        "preferred_tool_format = \"native\"",
        "responses_api = true",
        "",
        "[[provider.openai]]",
        "model_match = \"tool-backup-model\"",
        "native_tools = true",
        "preferred_tool_format = \"native\"",
        "responses_api = true",
        "hosted_tools = [\"web_search\"]",
    ]
    .join("\n");
    crate::llm::capabilities::set_user_overrides_toml(&capability_overlay)
        .expect("capability override");

    let opts = extract_with_options(crate::value::DictMap::from_iter([
        (
            crate::value::intern_key("provider"),
            VmValue::String(arcstr::ArcStr::from("mock")),
        ),
        (
            crate::value::intern_key("model"),
            VmValue::String(arcstr::ArcStr::from("tool-primary-model")),
        ),
        (
            crate::value::intern_key("api_mode"),
            VmValue::String(arcstr::ArcStr::from("responses")),
        ),
        (
            crate::value::intern_key("provider_tools"),
            VmValue::List(std::sync::Arc::new(vec![VmValue::String(
                arcstr::ArcStr::from("web_search"),
            )])),
        ),
        (
            crate::value::intern_key("equivalent_failover"),
            VmValue::Bool(true),
        ),
    ]))
    .expect("options");

    let requirements = equivalent_failover_requirements_for_options(&opts);
    let candidates = crate::llm_config::equivalent_model_catalog_entries_for_requirements(
        "tool-primary-model",
        requirements.clone(),
    );
    assert!(
        candidates
            .iter()
            .any(|(id, model)| { id == "tool-backup-model" && model.provider == "openai" }),
        "requirements={requirements:?} candidates={candidates:?}"
    );
    assert!(candidates
        .iter()
        .all(|(id, model)| { id != "plain-backup-model" && model.provider != "plain-backup" }));

    crate::llm_config::clear_user_overrides();
    crate::llm::capabilities::clear_user_overrides();
}

#[test]
fn equivalent_failover_filters_routes_without_responses_api_support() {
    let mut overlay = ProvidersConfig::default();
    for provider in ["mock", "chat-backup", "openai"] {
        overlay.providers.insert(
            provider.to_string(),
            test_provider(&format!("https://{provider}.example/v1")),
        );
    }
    overlay.models.insert(
        "responses-primary-model".to_string(),
        test_equivalent_model("mock", "responses-equivalent-test"),
    );
    overlay.models.insert(
        "chat-backup-model".to_string(),
        test_equivalent_model("chat-backup", "responses-equivalent-test"),
    );
    overlay.models.insert(
        "responses-backup-model".to_string(),
        test_equivalent_model("openai", "responses-equivalent-test"),
    );
    crate::llm_config::set_user_overrides(Some(overlay));
    let capability_overlay = [
        "[[provider.mock]]",
        "model_match = \"responses-primary-model\"",
        "responses_api = true",
        "",
        "[[provider.chat-backup]]",
        "model_match = \"chat-backup-model\"",
        "responses_api = false",
        "",
        "[[provider.openai]]",
        "model_match = \"responses-backup-model\"",
        "responses_api = true",
    ]
    .join("\n");
    crate::llm::capabilities::set_user_overrides_toml(&capability_overlay)
        .expect("capability override");

    let opts = extract_with_options(crate::value::DictMap::from_iter([
        (
            crate::value::intern_key("provider"),
            VmValue::String(arcstr::ArcStr::from("mock")),
        ),
        (
            crate::value::intern_key("model"),
            VmValue::String(arcstr::ArcStr::from("responses-primary-model")),
        ),
        (
            crate::value::intern_key("api_mode"),
            VmValue::String(arcstr::ArcStr::from("responses")),
        ),
        (
            crate::value::intern_key("equivalent_failover"),
            VmValue::Bool(true),
        ),
    ]))
    .expect("options");

    let requirements = equivalent_failover_requirements_for_options(&opts);
    assert!(requirements.responses_api);
    let candidates = crate::llm_config::equivalent_model_catalog_entries_for_requirements(
        "responses-primary-model",
        requirements,
    );
    assert!(candidates
        .iter()
        .any(|(id, model)| { id == "responses-backup-model" && model.provider == "openai" }));
    assert!(candidates
        .iter()
        .all(|(id, model)| { id != "chat-backup-model" && model.provider != "chat-backup" }));

    crate::llm_config::clear_user_overrides();
    crate::llm::capabilities::clear_user_overrides();
}