harn-vm 0.10.153

//! Anthropic and Anthropic-wire route rows: thinking style, effort
//! controls, tool-search gating, and the OpenRouter/Bedrock mirrors that must
//! track the direct rows.

use super::lookup_tests_support::reset;
use super::model::WireDialect;
use super::*;

fn assert_openrouter_anthropic_runtime_parity(model: &str) {
    let direct = lookup("anthropic", model);
    let routed = lookup("openrouter", model);

    assert_eq!(
        routed.native_tools, direct.native_tools,
        "{model}: native tool support should match direct Anthropic"
    );
    assert_eq!(
        routed.preferred_tool_format, direct.preferred_tool_format,
        "{model}: preferred tool format should match direct Anthropic"
    );
    // Structured-output lowering is deliberately route-specific. Direct
    // Anthropic uses output_config.format; OpenRouter's OpenAI-compatible
    // transport retains its synthetic-tool strategy.
    assert_eq!(
        routed.thinking_modes,
        Vec::<String>::new(),
        "{model}: OpenRouter Claude routes must not advertise direct Anthropic thinking controls"
    );
    assert!(
        !routed.reasoning_effort_supported,
        "{model}: OpenRouter Claude routes must not advertise direct Anthropic effort controls"
    );
    assert!(
        !routed.interleaved_thinking_supported,
        "{model}: OpenRouter Claude routes must not advertise interleaved thinking"
    );
    assert_eq!(
        routed.supports_assistant_prefill, direct.supports_assistant_prefill,
        "{model}: assistant prefill support should match direct Anthropic"
    );
    assert_eq!(
        routed.prompt_caching, direct.prompt_caching,
        "{model}: prompt cache support should match direct Anthropic"
    );
    assert_eq!(
        routed.prefers_xml_scaffolding, direct.prefers_xml_scaffolding,
        "{model}: XML scaffolding preference should match direct Anthropic"
    );
    assert_eq!(
        routed.prefers_markdown_scaffolding, direct.prefers_markdown_scaffolding,
        "{model}: Markdown scaffolding preference should match direct Anthropic"
    );
    assert_eq!(
        routed.prefers_role_developer, direct.prefers_role_developer,
        "{model}: developer role preference should match direct Anthropic"
    );
    assert_eq!(
        routed.prefers_xml_tools, direct.prefers_xml_tools,
        "{model}: XML tool preference should match direct Anthropic"
    );
    assert_eq!(
        routed.thinking_block_style, direct.thinking_block_style,
        "{model}: thinking block style should match direct Anthropic"
    );
    assert_eq!(
        routed.text_tool_wire_format_supported, direct.text_tool_wire_format_supported,
        "{model}: text-tool fallback support should match direct Anthropic"
    );
}

#[test]
fn anthropic_opus_47_gets_full_capabilities() {
    reset();
    let caps = lookup("anthropic", "claude-opus-4-7");
    assert!(caps.native_tools);
    assert!(caps.defer_loading);
    assert_eq!(caps.tool_search, vec!["bm25", "regex"]);
    assert!(caps.prompt_caching);
    assert_eq!(caps.thinking_modes, vec!["adaptive", "effort"]);
    assert!(caps.reasoning_effort_supported);
    assert_eq!(
        caps.reasoning_effort_levels,
        vec!["low", "medium", "high", "xhigh", "max"]
    );
    assert!(caps.interleaved_thinking_supported);
    assert!(caps.vision_supported);
    assert!(caps.audio);
    assert!(caps.pdf);
    assert!(caps.files_api_supported);
    assert_eq!(caps.max_tools, Some(10000));
    assert!(caps.prefers_xml_scaffolding);
    assert!(!caps.prefers_markdown_scaffolding);
    assert_eq!(caps.structured_output.as_deref(), Some("native"));
    assert_eq!(caps.structured_output_mode, "native_json");
    assert!(!caps.supports_assistant_prefill);
    assert!(!caps.prefers_role_developer);
    assert!(caps.prefers_xml_tools);
    assert_eq!(caps.thinking_block_style, "thinking_blocks");
}

#[test]
fn anthropic_sonnet_5_gets_adaptive_effort_capabilities() {
    reset();
    let caps = lookup("anthropic", "claude-sonnet-5");
    assert!(caps.native_tools);
    assert!(caps.defer_loading);
    assert_eq!(caps.tool_search, vec!["bm25", "regex"]);
    assert!(caps.prompt_caching);
    assert_eq!(caps.thinking_modes, vec!["adaptive", "effort"]);
    assert!(caps.reasoning_effort_supported);
    assert_eq!(
        caps.reasoning_effort_levels,
        vec!["low", "medium", "high", "xhigh", "max"]
    );
    assert!(caps.reasoning_disable_supported);
    assert!(!caps.reasoning_none_supported);
    assert!(caps.interleaved_thinking_supported);
    assert!(!caps.supports_assistant_prefill);
    assert_eq!(caps.thinking_block_style, "thinking_blocks");
}

/// Sonnet 5.5 narrows Sonnet 5 three ways (live API, 2026-09-29): thinking
/// turns off with `between_tools`, forced tool choice is a 400, and the cache
/// floor drops to 512. The `claude-sonnet-5*` glob also matches
/// `claude-sonnet-5-5`, so Sonnet 5 is the control that proves the 5.5 row
/// decided each value; before that row existed every default Harn call to
/// Sonnet 5.5 sent `disabled` and failed.
#[test]
fn anthropic_sonnet_55_turns_thinking_off_between_tools() {
    reset();
    for model in ["claude-sonnet-5-5", "anthropic/claude-sonnet-5.5"] {
        let caps = lookup("anthropic", model);
        assert_eq!(
            caps.thinking_off_type,
            ThinkingOffType::BetweenTools,
            "{model}"
        );
        assert!(caps.reasoning_disable_supported, "{model}");
        assert_eq!(
            caps.allowed_tool_choice_modes,
            vec!["auto", "none"],
            "{model}"
        );
        assert_eq!(caps.prompt_cache_min_prefix_tokens, Some(512), "{model}");
        // The rest layers on from the Sonnet 5 row through `extends`.
        assert_eq!(caps.thinking_modes, vec!["adaptive", "effort"], "{model}");
        assert!(!caps.temperature_supported, "{model}");
        assert!(caps.native_tools, "{model}");
    }
    for model in ["claude-sonnet-5", "anthropic/claude-sonnet-5"] {
        let caps = lookup("anthropic", model);
        assert_eq!(caps.thinking_off_type, ThinkingOffType::Disabled, "{model}");
        assert!(caps.allowed_tool_choice_modes.is_empty(), "{model}");
        assert_eq!(caps.prompt_cache_min_prefix_tokens, Some(1024), "{model}");
    }
}

/// Through OpenRouter, Sonnet 5.5's reasoning cannot be disabled at all and a
/// forced tool choice returns Anthropic's 400 (probed 2026-09-29). Sonnet 5
/// on the same route keeps both.
#[test]
fn openrouter_sonnet_55_keeps_reasoning_on_and_tool_choice_unforced() {
    reset();
    let caps = lookup("openrouter", "anthropic/claude-sonnet-5.5");
    assert!(!caps.reasoning_disable_supported);
    assert_eq!(caps.allowed_tool_choice_modes, vec!["auto", "none"]);
    assert!(caps.native_tools);

    let sonnet5 = lookup("openrouter", "anthropic/claude-sonnet-5");
    assert!(sonnet5.reasoning_disable_supported);
    assert!(sonnet5.allowed_tool_choice_modes.is_empty());
}

#[test]
fn anthropic_fable_effort_cannot_be_disabled() {
    reset();
    for model in ["claude-fable-5", "anthropic/claude-fable-5"] {
        let caps = lookup("anthropic", model);
        assert_eq!(caps.thinking_modes, vec!["adaptive", "effort"]);
        assert!(caps.reasoning_effort_supported);
        assert_eq!(
            caps.reasoning_effort_levels,
            vec!["low", "medium", "high", "xhigh", "max"]
        );
        assert!(!caps.reasoning_disable_supported);
        assert!(!caps.supports_assistant_prefill);
    }
}

/// Fable 5.1 keeps the whole Fable/Mythos surface and narrows exactly one
/// thing: forced tool choice is gone. `tool_choice` `any` / `tool` are a 400
/// on this model, so only `auto` and `none` may reach the wire. The Fable 5
/// control below is what makes this assertion mean something — an empty
/// `allowed_tool_choice_modes` is "unrestricted", so without the control a
/// silently-unmatched 5.1 rule would still read as a pass on every other line.
#[test]
fn anthropic_fable_51_forbids_forced_tool_choice() {
    reset();
    let caps = lookup("anthropic", "claude-fable-5-1");
    assert_eq!(caps.allowed_tool_choice_modes, vec!["auto", "none"]);

    // Inherited-by-restatement: 5.1 is a full rule, not an `extends` merge,
    // so every field the catch-all sets has to survive the copy.
    assert_eq!(caps.thinking_modes, vec!["adaptive", "effort"]);
    assert_eq!(
        caps.reasoning_effort_levels,
        vec!["low", "medium", "high", "xhigh", "max"]
    );
    assert!(!caps.reasoning_disable_supported);
    assert!(!caps.supports_assistant_prefill);
    assert!(!caps.temperature_supported);
    assert!(caps.native_tools);
    assert!(caps.prompt_caching);
    assert_eq!(caps.prompt_cache_min_prefix_tokens, Some(512));

    // Control: Fable 5 must stay unrestricted, or the 5.1 row is matching
    // more than it should.
    let fable5 = lookup("anthropic", "claude-fable-5");
    assert!(fable5.allowed_tool_choice_modes.is_empty());
}

/// Opus 5.5 narrows the Opus 5 surface: thinking cannot be disabled and
/// forced tool choice is a 400 (live API, 2026-09-22). Opus 5 is the control
/// that keeps both, so an Opus 5.5 row that matched too broadly would fail
/// here instead of silently tightening the previous generation.
#[test]
fn anthropic_opus_55_is_always_on_and_forbids_forced_tool_choice() {
    reset();
    for model in [
        "claude-opus-5-5",
        "anthropic/claude-opus-5-5",
        "anthropic/claude-opus-5.5",
    ] {
        let caps = lookup("anthropic", model);
        assert!(!caps.reasoning_disable_supported, "{model}");
        assert_eq!(
            caps.allowed_tool_choice_modes,
            vec!["auto", "none"],
            "{model}"
        );
        assert_eq!(caps.prompt_cache_min_prefix_tokens, Some(512), "{model}");
        assert_eq!(
            caps.reasoning_effort_levels,
            vec!["low", "medium", "high", "xhigh", "max"],
            "{model}"
        );
        assert!(!caps.temperature_supported, "{model}");
        assert!(!caps.supports_assistant_prefill, "{model}");
    }
    assert_eq!(
        lookup("anthropic", "claude-opus-5-5").system_message_placement,
        lookup("anthropic", "claude-opus-5").system_message_placement,
        "Opus 5.5 keeps native mid-conversation system messages"
    );

    for model in ["claude-opus-5", "anthropic/claude-opus-5"] {
        let caps = lookup("anthropic", model);
        assert!(caps.reasoning_disable_supported, "{model}");
        assert!(caps.allowed_tool_choice_modes.is_empty(), "{model}");
        assert_eq!(caps.prompt_cache_min_prefix_tokens, Some(512), "{model}");
    }

    // OpenRouter passes tool_choice through verbatim, so the restriction
    // follows the model onto that route; Opus 5 there stays unrestricted.
    assert_eq!(
        lookup("openrouter", "anthropic/claude-opus-5.5").allowed_tool_choice_modes,
        vec!["auto", "none"]
    );
    assert_eq!(
        lookup("openrouter", "anthropic/claude-fable-5.1").allowed_tool_choice_modes,
        vec!["auto", "none"]
    );
    assert!(lookup("openrouter", "anthropic/claude-opus-5")
        .allowed_tool_choice_modes
        .is_empty());
    assert!(lookup("openrouter", "anthropic/claude-fable-5")
        .allowed_tool_choice_modes
        .is_empty());
}

#[test]
fn anthropic_47_and_newer_sampling_is_denied_by_the_catalog() {
    reset();
    for model in [
        "claude-fable-5",
        "anthropic/claude-fable-5",
        "claude-mythos-5-preview",
        "anthropic/claude-mythos-5-preview",
        "claude-opus-4-7",
        "anthropic/claude-opus-4-7",
        "claude-opus-5",
        "anthropic/claude-opus-5",
        "claude-opus-5-5",
        "anthropic/claude-opus-5.5",
        "claude-sonnet-5",
        "anthropic/claude-sonnet-5",
    ] {
        let caps = lookup("anthropic", model);
        assert!(!caps.temperature_supported, "{model}: temperature");
        assert!(!caps.top_p_supported, "{model}: top_p");
        assert!(!caps.top_k_supported, "{model}: top_k");
    }

    let pre_47 = lookup("anthropic", "claude-sonnet-4-6");
    assert!(pre_47.temperature_supported);
    assert!(pre_47.top_p_supported);
    assert!(pre_47.top_k_supported);
}

#[test]
fn anthropic_opus_46_uses_budgeted_thinking() {
    reset();
    let caps = lookup("anthropic", "claude-opus-4-6");
    assert_eq!(caps.thinking_modes, vec!["enabled"]);
    assert!(caps.interleaved_thinking_supported);
    assert!(!caps.supports_assistant_prefill);
}

#[test]
fn anthropic_opus_45_does_not_support_interleaved_thinking() {
    reset();
    let caps = lookup("anthropic", "claude-opus-4-5");
    assert_eq!(caps.thinking_modes, vec!["enabled"]);
    assert!(!caps.interleaved_thinking_supported);
    assert!(caps.supports_assistant_prefill);
}

#[test]
fn native_schema_output_tracks_supported_direct_anthropic_generations() {
    reset();
    for model in [
        "claude-fable-5",
        "claude-mythos-preview",
        "claude-mythos-5",
        "claude-haiku-4-5",
        "claude-opus-4-5",
        "claude-opus-4-6",
        "claude-sonnet-4-5",
        "claude-sonnet-4-6",
        "claude-sonnet-5",
        "anthropic/claude-haiku-4-5",
        "anthropic/claude-opus-4-5",
        "anthropic/claude-sonnet-4-5",
    ] {
        let caps = lookup("anthropic", model);
        assert_eq!(
            caps.structured_output.as_deref(),
            Some("native"),
            "{model}: supported direct Anthropic models use output_config.format",
        );
        assert_eq!(caps.structured_output_mode, "native_json", "{model}");
    }
}

#[test]
fn older_anthropic_generations_keep_synthetic_tool_fallback() {
    reset();
    for model in ["claude-opus-4-0", "claude-sonnet-4-0", "claude-opus-3-5"] {
        let caps = lookup("anthropic", model);
        assert_eq!(
            caps.structured_output.as_deref(),
            Some("tool_use"),
            "{model}: unsupported generations retain the compatibility fallback",
        );
        assert_eq!(caps.structured_output_mode, "xml_tagged", "{model}");
    }
}

#[test]
fn openrouter_claude_rows_track_direct_anthropic_runtime_quirks() {
    reset();
    for model in [
        "anthropic/claude-fable-5-0",
        "anthropic/claude-mythos-5-0",
        "anthropic/claude-haiku-4-5",
        "anthropic/claude-haiku-4-7",
        "anthropic/claude-sonnet-4-6",
        "anthropic/claude-sonnet-4-7",
        "anthropic/claude-sonnet-5",
        "anthropic/claude-opus-4-6",
        "anthropic/claude-opus-4-7",
        "anthropic/claude-opus-5.5",
    ] {
        assert_openrouter_anthropic_runtime_parity(model);
    }
}

#[test]
fn override_can_supply_anthropic_beta_features() {
    reset();
    let toml_src = r#"
[[provider.anthropic]]
model_match = "claude-custom-*"
native_tools = true
anthropic_beta_features = ["fine-grained-tool-streaming-2025-05-14"]
"#;
    set_user_overrides_toml(toml_src).unwrap();
    let caps = lookup("anthropic", "claude-custom-1");
    assert_eq!(
        caps.anthropic_beta_features,
        vec!["fine-grained-tool-streaming-2025-05-14"]
    );
    reset();
}

#[test]
fn anthropic_haiku_44_has_no_tool_search() {
    reset();
    let caps = lookup("anthropic", "claude-haiku-4-4");
    // Haiku 4.4 falls through to the `claude-*` catch-all row.
    assert!(caps.native_tools);
    assert!(caps.prompt_caching);
    assert!(!caps.defer_loading);
    assert!(caps.tool_search.is_empty());
}

#[test]
fn anthropic_haiku_45_supports_tool_search() {
    reset();
    let caps = lookup("anthropic", "claude-haiku-4-5");
    assert!(caps.defer_loading);
    assert_eq!(caps.tool_search, vec!["bm25", "regex"]);
}

#[test]
fn old_claude_gets_catchall() {
    reset();
    let caps = lookup("anthropic", "claude-opus-3-5");
    assert!(caps.native_tools);
    assert!(caps.prompt_caching);
    assert!(!caps.defer_loading);
    assert!(caps.tool_search.is_empty());
}

#[test]
fn openrouter_anthropic_claude_models_support_native_tools() {
    // Regression for #2319: OpenRouter Anthropic slugs must match the
    // Anthropic capability rules before the OpenRouter -> OpenAI family
    // chain, otherwise native-tool requests get rejected as unsupported.
    reset();
    for model in [
        "anthropic/claude-haiku-4-5",
        "anthropic/claude-haiku-4-5-20251001",
        "anthropic/claude-sonnet-4-6",
        "anthropic/claude-sonnet-4-7",
        "anthropic/claude-opus-4-7",
    ] {
        let caps = lookup("openrouter", model);
        assert!(
            caps.native_tools,
            "{model} via openrouter should report native_tools=true",
        );
        assert!(
            caps.prompt_caching,
            "{model} via openrouter should report prompt_caching=true",
        );
        assert_eq!(
            caps.cache_breakpoint_style,
            super::CacheBreakpointStyle::TopLevel,
            "{model} via openrouter should use top-level cache_control",
        );
        assert_eq!(
            caps.structured_output.as_deref(),
            Some("tool_use"),
            "{model} via OpenRouter retains the route-specific synthetic-tool strategy",
        );
    }
}

#[test]
fn bedrock_claude_uses_anthropic_wire_capabilities() {
    reset();
    let caps = lookup("bedrock", "anthropic.claude-3-5-sonnet-20240620-v1:0");
    assert!(caps.native_tools);
    assert_eq!(caps.message_wire_format, WireDialect::Anthropic);
    assert_eq!(caps.native_tool_wire_format, "anthropic");
}

#[test]
fn openrouter_namespaced_anthropic_model() {
    reset();
    let caps = lookup("anthropic", "anthropic/claude-opus-4-7");
    assert!(caps.defer_loading);
}