Skip to content

Make Codex and Claude Code subscriptions go further: a local model router that gives routine agent work to economical models and keeps your strongest model for the hard parts.

56.6 KB
Raw Blame
use super::*;
use hiroute_domain::{
    GatewayNativeProviderStateEmissionV1, GatewayNativeReasoningRenderV1,
    GatewayNativeReasoningValueV1, GatewayReasoningControlKindV1, NativeReasoningCapabilityV1,
    NativeReasoningRenderConventionV1,
};
#[path = "candidate_execution_tests/feed_lifecycle.rs"]
mod feed_lifecycle;
#[path = "candidate_execution_tests/native_protocol_profiles.rs"]
mod native_protocol_profiles;

fn user_fact<T>(value: T) -> hiroute_domain::ComputeManagementFactValueV2<T> {
    hiroute_domain::ComputeManagementFactValueV2 {
        value: Some(value),
        basis: hiroute_domain::ComputeManagementFactBasisV2::UserDeclared,
    }
}

fn runtime_fact<T>(value: T) -> hiroute_domain::ComputeManagementFactValueV2<T> {
    hiroute_domain::ComputeManagementFactValueV2 {
        value: Some(value),
        basis: hiroute_domain::ComputeManagementFactBasisV2::RuntimeFallback,
    }
}

fn registered_catalog_fact<T>(value: T) -> hiroute_integrations::NativeCandidateFactValueV1<T> {
    hiroute_integrations::NativeCandidateFactValueV1 {
        value: Some(value),
        basis: hiroute_integrations::NativeCandidateFactBasisV1::RegisteredCatalog,
    }
}

fn current_catalog() -> TrustedReleaseCatalog {
    const MANIFEST: &[u8] =
        include_bytes!("../../../../../assets/release-facts/current/bundle/manifest.json");
    TrustedReleaseCatalog::load_bundled_release_facts(
        MANIFEST,
        MANIFEST,
        include_bytes!(
            "../../../../../assets/release-facts/current/bundle/connector-registry.json"
        ),
        include_bytes!("../../../../../assets/release-facts/current/bundle/model-data.json"),
    )
    .unwrap()
}

fn source_local_fact(
    authentication: GatewayAuthenticationSemanticsV1,
) -> ComputeManagementCompilationFactV2 {
    let target = hiroute_domain::ComputeManagementTargetV2 {
        scheme: "http".into(),
        authority: "127.0.0.1".into(),
        port: 8_123,
        request_path: "/v1/responses".into(),
        upstream_protocol: UpstreamProtocol::Responses,
        protocol_profile_id: "profile/responses".into(),
        protocol_profile_revision: 3,
    };
    let ordered = match &authentication {
        GatewayAuthenticationSemanticsV1::None => {
            vec![hiroute_domain::ComputeCredentialSelectionV2::NoCredential]
        }
        _ => ["credential/manual-a", "credential/manual-b"]
            .into_iter()
            .enumerate()
            .map(|(index, credential_id)| {
                hiroute_domain::ComputeCredentialSelectionV2::Credential {
                    credential_ref: hiroute_domain::CredentialRefV1::new(
                        credential_id,
                        "source/source-manual",
                        "hirouted",
                        "provider-auth",
                        [target.credential_destination().unwrap()],
                        index as u64 + 1,
                    )
                    .unwrap(),
                }
            })
            .collect(),
    };
    ComputeManagementCompilationFactV2 {
        source_id: "source-manual".into(),
        source_revision: 2,
        source_lineage_digest: CanonicalDigest::of_bytes(b"source-local-lineage"),
        binding_id: "binding/manual".into(),
        binding_revision: 4,
        model_ref: "model/manual".into(),
        upstream_model_id: "manual-model".into(),
        display_name: "Manual model".into(),
        catalog_configuration_id: None,
        eligibility: ComputeManagementEligibilityV2::UserConfirmed,
        provenance: hiroute_domain::ComputeManagementProvenanceV2::UserConfigured {
            configuration_revision: 2,
            evidence_digest: CanonicalDigest::of_bytes(b"source-local-evidence"),
        },
        target,
        authentication,
        additional_native_endpoints: Vec::new(),
        capabilities: hiroute_domain::ComputeManagedCapabilitiesV2 {
            tool: user_fact(true),
            vision: user_fact(false),
            streaming: user_fact(true),
            context_tokens: user_fact(32_768),
            max_output_tokens: user_fact(4_096),
            native_reasoning: user_fact(NativeReasoningCapabilityV1::Fixed {
                profile: "provider-default".into(),
            }),
        },
        default_preferences: Default::default(),
        capability_evidence_digest: CanonicalDigest::of_bytes(b"manual-capability"),
        native_reasoning: NativeReasoningCapabilityV1::Fixed {
            profile: "provider-default".into(),
        },
        credential: ComputeManagementCredentialCompilationV2::Native { ordered },
    }
}

#[test]
fn source_local_none_projection_keeps_port_and_has_no_credential_pool() {
    let fact = source_local_fact(GatewayAuthenticationSemanticsV1::None);
    let candidate = materialize_management_candidate(&fact, None).unwrap();
    assert_eq!(
        management_execution_model_id(&fact).as_deref(),
        Some(candidate.model.model_configuration_id.as_str())
    );
    assert_eq!(
        candidate.authority,
        CandidateFactAuthorityV1::SourceLocalUser
    );
    assert!(!candidate.inventory_model_matched);
    assert!(candidate.is_routable());
    assert_eq!(
        candidate.protocol_endpoint.base_url,
        "http://127.0.0.1:8123"
    );
    assert_eq!(
        candidate.operational_target,
        GatewayOperationalTargetV1::UserConfiguredNative {
            uri: "http://127.0.0.1:8123/v1/responses".into(),
        }
    );
    assert!(candidate.binding.credential_pool_id.is_none());
    assert_eq!(candidate.credential_refs.len(), 1);
    assert!(candidate.credential_refs[0].starts_with("credential/none/"));
    assert!(candidate.rating.is_none());
    assert!(candidate.ordering_price.is_none());
    assert!(candidate.free_evidence.is_none());
    assert!(candidate.protocol_profiles.iter().all(|profile| {
        profile.connector.authentication.exact() == Some(&GatewayAuthenticationSemanticsV1::None)
    }));
}

#[test]
fn source_local_header_projection_preserves_order_and_exact_header() {
    let authentication = GatewayAuthenticationSemanticsV1::ApiKeyHeader {
        header: "x-provider-key".into(),
    };
    let candidate =
        materialize_management_candidate(&source_local_fact(authentication.clone()), None).unwrap();
    assert_eq!(
        candidate.credential_refs,
        ["credential/manual-a", "credential/manual-b"]
    );
    assert!(candidate.binding.credential_pool_id.is_some());
    assert!(
        candidate
            .protocol_profiles
            .iter()
            .all(|profile| profile.connector.authentication.exact() == Some(&authentication))
    );
}

#[test]
fn registered_runtime_fallback_preserves_exact_provider_endpoint_and_has_no_commercial_facts() {
    let catalog = current_catalog();
    let resolved = catalog
        .resolve_connection_option("deepseek.official.global.v1")
        .unwrap();
    let endpoint = resolved
        .endpoint_profile
        .protocol_endpoints
        .iter()
        .find(|endpoint| endpoint.protocol == UpstreamProtocol::Responses)
        .unwrap();
    let target = hiroute_domain::ComputeManagementTargetV2 {
        scheme: "https".into(),
        authority: endpoint.base_url.strip_prefix("https://").unwrap().into(),
        port: 443,
        request_path: endpoint.request_path.clone(),
        upstream_protocol: endpoint.protocol,
        protocol_profile_id: endpoint.adapter_ref.clone(),
        protocol_profile_revision: endpoint.adapter_revision,
    };
    let credential = hiroute_domain::CredentialRefV1::new(
        "credential/deepseek-fallback",
        "source/source-deepseek-fallback",
        "hirouted",
        "provider-auth",
        [target.credential_destination().unwrap()],
        1,
    )
    .unwrap();
    let provenance = catalog.compute_catalog_provenance().unwrap();
    let reasoning = NativeReasoningCapabilityV1::Fixed {
        profile: "non-thinking".into(),
    };
    let fact = ComputeManagementCompilationFactV2 {
        source_id: "source-deepseek-fallback".into(),
        source_revision: 1,
        source_lineage_digest: CanonicalDigest::of_bytes(b"deepseek-fallback-lineage"),
        binding_id: "binding/deepseek-fallback".into(),
        binding_revision: 1,
        model_ref: "model/deepseek-future-text".into(),
        upstream_model_id: "deepseek-future-text".into(),
        display_name: "deepseek-future-text".into(),
        catalog_configuration_id: None,
        eligibility: ComputeManagementEligibilityV2::RuntimeQualified,
        provenance: hiroute_domain::ComputeManagementProvenanceV2::Registered {
            connection_option_id: resolved.option.connection_option_id.clone(),
            registry_version: catalog.registry().registry_version.clone(),
            catalog_digest: provenance.cross_reference_digest,
        },
        target,
        authentication: GatewayAuthenticationSemanticsV1::Bearer,
        additional_native_endpoints: Vec::new(),
        capabilities: hiroute_domain::ComputeManagedCapabilitiesV2 {
            tool: runtime_fact(true),
            vision: runtime_fact(false),
            streaming: runtime_fact(true),
            context_tokens: runtime_fact(131_072),
            max_output_tokens: runtime_fact(8_192),
            native_reasoning: runtime_fact(reasoning.clone()),
        },
        default_preferences: Default::default(),
        capability_evidence_digest: CanonicalDigest::of_bytes(b"runtime-fallback-capability"),
        native_reasoning: reasoning,
        credential: ComputeManagementCredentialCompilationV2::Native {
            ordered: vec![hiroute_domain::ComputeCredentialSelectionV2::Credential {
                credential_ref: credential,
            }],
        },
    };

    let candidate = materialize_management_candidate(&fact, Some(&catalog)).unwrap();
    assert_eq!(
        candidate.authority,
        CandidateFactAuthorityV1::RuntimeFallback
    );
    assert_eq!(
        candidate.connection_option_id,
        resolved.option.connection_option_id
    );
    assert_eq!(
        candidate.capability.connector_id,
        resolved.connector.connector_id
    );
    assert_eq!(
        candidate.protocol_endpoint.protocol_endpoint_id,
        endpoint.protocol_endpoint_id
    );
    assert_eq!(
        candidate.operational_target,
        GatewayOperationalTargetV1::RegisteredHttps {
            uri: format!("{}{}", endpoint.base_url, endpoint.request_path),
        }
    );
    assert_eq!(
        candidate.capability.upstream_model_id,
        "deepseek-future-text"
    );
    assert!(candidate.rating.is_none());
    assert!(candidate.ordering_price.is_none());
    assert!(candidate.free_evidence.is_none());
    assert!(candidate.is_routable());
    assert!(!candidate.inventory_model_matched);

    let mut tampered = fact;
    tampered.target.authority = "attacker.invalid".into();
    assert!(materialize_management_candidate(&tampered, Some(&catalog)).is_none());
}

#[test]
fn qualified_glm_chat_profiles_preserve_enabled_thinking_and_tool_replay() {
    let bundle: hiroute_domain::ReleaseModelDataBundleV2 = serde_json::from_str(include_str!(
        "../../../../../assets/model-data/current/model-data.json"
    ))
    .unwrap();
    for id in [
        "model.zhipu.glm-5.3.coding-chat",
        "model.zhipu.glm-5.3-flash.coding-chat",
    ] {
        let native = bundle
            .rating_snapshot
            .models
            .iter()
            .find(|n| n.model_configuration_id == id)
            .unwrap();
        assert!(reasoning_profiles(native, UpstreamProtocol::Messages).is_none());
        assert!(reasoning_profiles(native, UpstreamProtocol::Responses).is_none());
        let profiles = reasoning_profiles(native, UpstreamProtocol::ChatCompletions).unwrap();
        assert_eq!(
            profiles
                .iter()
                .map(|p| p.profile_id.as_str())
                .collect::<Vec<_>>(),
            ["low", "high", "max"]
        );
        for profile in profiles {
            assert_eq!(
                profile.render,
                GatewayNativeReasoningRenderV1::ExactFields {
                    protocol: UpstreamProtocol::ChatCompletions,
                    fields: vec![
                        field(
                            "reasoning_effort",
                            GatewayNativeReasoningValueV1::String(profile.profile_id),
                            UpstreamProtocol::ChatCompletions
                        ),
                        field(
                            "thinking.type",
                            GatewayNativeReasoningValueV1::String("enabled".into()),
                            UpstreamProtocol::ChatCompletions
                        ),
                        field(
                            "thinking.clear_thinking",
                            GatewayNativeReasoningValueV1::Bool(false),
                            UpstreamProtocol::ChatCompletions
                        ),
                    ],
                }
            );
        }
    }
}

#[test]
fn native_companion_controls_require_exact_catalog_model_product_and_protocol() {
    let catalog = current_catalog();
    let mut fact = registered_fact(
        &catalog,
        "zhipu.coding-chat.cn.v1",
        "model.zhipu.glm-5.3.coding-chat",
    );
    let convention = Some(NativeReasoningRenderConventionV1::ZhipuThinkingChat);
    assert_eq!(
        qualified_native_render_convention(&fact, Some(&catalog)),
        convention
    );
    let original = fact.clone();
    fact.target.request_path = "/api/paas/v4/chat/completions".into();
    assert_eq!(
        qualified_native_render_convention(&fact, Some(&catalog)),
        None
    );
    fact = original.clone();
    fact.authentication = GatewayAuthenticationSemanticsV1::None;
    assert_eq!(
        qualified_native_render_convention(&fact, Some(&catalog)),
        None
    );
    fact = original.clone();
    fact.target.upstream_protocol = UpstreamProtocol::Responses;
    assert_eq!(
        qualified_native_render_convention(&fact, Some(&catalog)),
        None
    );
    fact = original.clone();
    fact.upstream_model_id = "glm-5.3-flashx".into();
    assert_eq!(
        qualified_native_render_convention(&fact, Some(&catalog)),
        None
    );
    fact = original;
    fact.native_reasoning = NativeReasoningCapabilityV1::Toggle {
        parameter: "thinking.type".into(),
    };
    assert_eq!(
        qualified_native_render_convention(&fact, Some(&catalog)),
        None
    );
}

#[test]
fn declared_claude_messages_profiles_emit_both_exact_controls() {
    let bundle: hiroute_domain::ReleaseModelDataBundleV2 = serde_json::from_str(include_str!(
        "../../../../../assets/model-data/current/model-data.json"
    ))
    .unwrap();
    for native in bundle.rating_snapshot.models.iter().filter(|n| {
        n.native_render_convention
            == Some(NativeReasoningRenderConventionV1::ClaudeAdaptiveEffortMessages)
    }) {
        let profiles = reasoning_profiles(native, UpstreamProtocol::Messages).unwrap();
        assert!(!profiles.is_empty());
        for profile in profiles {
            assert_eq!(
                profile.render,
                GatewayNativeReasoningRenderV1::ExactFields {
                    protocol: UpstreamProtocol::Messages,
                    fields: vec![
                        field(
                            "output_config.effort",
                            GatewayNativeReasoningValueV1::String(profile.profile_id.clone()),
                            UpstreamProtocol::Messages
                        ),
                        field(
                            "thinking.type",
                            GatewayNativeReasoningValueV1::String("adaptive".into()),
                            UpstreamProtocol::Messages
                        )
                    ],
                }
            );
        }
        assert!(reasoning_profiles(native, UpstreamProtocol::Responses).is_none());
        assert!(reasoning_profiles(native, UpstreamProtocol::ChatCompletions).is_none());
    }
    let declared_models: std::collections::BTreeSet<_> = bundle
        .rating_snapshot
        .models
        .iter()
        .filter(|n| {
            n.native_render_convention
                == Some(NativeReasoningRenderConventionV1::ClaudeAdaptiveEffortMessages)
        })
        .map(|n| n.model_configuration_id.as_str())
        .collect();
    // Existing models must keep their controls, and the current Claude additions
    // must exercise the same renderer. Future catalog additions also run above.
    for model in [
        "model.anthropic.claude-fable-5-1",
        "model.anthropic.claude-haiku-5-5",
        "model.anthropic.claude-opus-5",
        "model.anthropic.claude-opus-5-5",
        "model.anthropic.claude-sonnet-5",
        "model.anthropic.claude-sonnet-5-5",
    ] {
        assert!(
            declared_models.contains(model),
            "missing renderer coverage: {model}"
        );
    }
}

#[test]
fn cpa_codex_messages_face_maps_effort_to_adaptive_messages_controls() {
    let native = ModelNativeReasoningV1 {
        model_configuration_id: "model.openai.codex".into(),
        capability: NativeReasoningCapabilityV1::Discrete {
            parameter: "reasoning_effort".into(),
            profiles: vec!["low".into(), "high".into()],
            default_profile: None,
        },
        native_render_convention: None,
    };
    let profiles = cpa_reasoning_profiles(
        &native,
        UpstreamProtocol::Responses,
        UpstreamProtocol::Messages,
    )
    .unwrap();
    assert_eq!(profiles.len(), 2);
    for profile in profiles {
        assert_eq!(
            profile.render,
            GatewayNativeReasoningRenderV1::ExactFields {
                protocol: UpstreamProtocol::Messages,
                fields: vec![
                    field(
                        "output_config.effort",
                        GatewayNativeReasoningValueV1::String(profile.profile_id.clone()),
                        UpstreamProtocol::Messages,
                    ),
                    field(
                        "thinking.type",
                        GatewayNativeReasoningValueV1::String("adaptive".into()),
                        UpstreamProtocol::Messages,
                    ),
                ],
            }
        );
    }
}

#[test]
fn cpa_profiles_prefer_same_protocol_and_messages_falls_back_to_responses() {
    let model = ModelDefinitionV1 {
        model_configuration_id: "model.openai.codex".into(),
        revision: 1,
        display_name: "Codex".into(),
        publisher_id: "publisher.openai".into(),
        capabilities: CapabilityFactsV1 {
            tool: true,
            vision: true,
            streaming: true,
            context_tokens: 128_000,
            max_output_tokens: 8_192,
        },
    };
    let capability = ModelEndpointCapabilityV1 {
        capability_id: "cap.codex.responses".into(),
        revision: 1,
        model_configuration_id: model.model_configuration_id.clone(),
        connector_id: "connector.cpa.codex".into(),
        connector_revision: 1,
        endpoint_profile_id: "endpoint.cpa.codex".into(),
        endpoint_profile_revision: 1,
        protocol_endpoint_id: "endpoint.cpa.codex.responses".into(),
        upstream_protocol: UpstreamProtocol::Responses,
        upstream_model_id: "codex-model".into(),
        required_adapter_ref: "adapter.openai-responses.v1".into(),
        required_adapter_revision: 1,
        evidence_digest: CanonicalDigest::of_bytes(b"cpa-profile-test"),
    };
    let reasoning = ModelNativeReasoningV1 {
        model_configuration_id: model.model_configuration_id.clone(),
        capability: NativeReasoningCapabilityV1::Discrete {
            parameter: "reasoning_effort".into(),
            profiles: vec!["low".into(), "high".into()],
            default_profile: None,
        },
        native_render_convention: None,
    };
    let connector = ProtocolConnectorFacts {
        provider_id: "provider.openai".into(),
        endpoint_id: "endpoint.cpa.codex".into(),
        entitlement_id: "codex-subscription".into(),
        connector_id: "connector.cpa.codex".into(),
        connector_revision: "1".into(),
    };
    let faces = [
        ProtocolFace {
            protocol: UpstreamProtocol::Responses,
            request_path: "/v1/responses".into(),
            authentication: GatewayAuthenticationSemanticsV1::Bearer,
            required_headers: Vec::new(),
            native_target: None,
            adapter_ref: None,
            adapter_revision: None,
        },
        ProtocolFace {
            protocol: UpstreamProtocol::ChatCompletions,
            request_path: "/v1/chat/completions".into(),
            authentication: GatewayAuthenticationSemanticsV1::Bearer,
            required_headers: Vec::new(),
            native_target: None,
            adapter_ref: None,
            adapter_revision: None,
        },
        ProtocolFace {
            protocol: UpstreamProtocol::Messages,
            request_path: "/v1/messages".into(),
            authentication: GatewayAuthenticationSemanticsV1::Bearer,
            required_headers: vec![("anthropic-version".into(), "2023-06-01".into())],
            native_target: None,
            adapter_ref: None,
            adapter_revision: None,
        },
    ];
    let profiles = protocol_profiles(
        &connector,
        &model,
        &capability,
        &reasoning,
        "hiroute-account/codex-model",
        ConnectorRuntimeKind::CpaBridge,
        &faces,
    )
    .unwrap();
    assert!(profiles.iter().all(|profile| {
        let expected_path = match profile.ingress_protocol {
            UpstreamProtocol::Responses => "/v1/responses",
            UpstreamProtocol::ChatCompletions => "/v1/chat/completions",
            UpstreamProtocol::Messages => "/v1/messages",
        };
        profile.ingress_protocol == profile.capability.upstream_protocol
            && profile.connector.upstream_protocol == profile.capability.upstream_protocol
            && profile.connector.request_path == expected_path
    }));
    for protocol in [UpstreamProtocol::Responses, UpstreamProtocol::Messages] {
        let profile = profiles
            .iter()
            .find(|profile| profile.ingress_protocol == protocol)
            .unwrap();
        assert_eq!(
            profile.capability.native_provider_state,
            GatewayNativeProviderStateEmissionV1::Native
        );
    }

    let mut preferred = reasoning.clone();
    let NativeReasoningCapabilityV1::Discrete {
        default_profile, ..
    } = &mut preferred.capability
    else {
        unreachable!();
    };
    *default_profile = Some("high".into());
    let selected = protocol_profiles(
        &connector,
        &model,
        &capability,
        &preferred,
        "hiroute-account/codex-model",
        ConnectorRuntimeKind::CpaBridge,
        &faces,
    )
    .unwrap();
    assert!(
        selected
            .iter()
            .all(|profile| profile.capability.selected_reasoning_profile_id == "high")
    );

    let fallback = protocol_profiles(
        &connector,
        &model,
        &capability,
        &reasoning,
        "hiroute-account/codex-model",
        ConnectorRuntimeKind::CpaBridge,
        &faces[..2],
    )
    .unwrap();
    let messages = fallback
        .iter()
        .find(|profile| profile.ingress_protocol == UpstreamProtocol::Messages)
        .unwrap();
    assert_eq!(
        messages.capability.upstream_protocol,
        UpstreamProtocol::Responses
    );
    assert_eq!(messages.connector.request_path, "/v1/responses");
}

#[test]
fn cpa_messages_only_face_is_not_dropped_by_absent_responses() {
    let model = ModelDefinitionV1 {
        model_configuration_id: "model.messages-only".into(),
        revision: 1,
        display_name: "Messages only".into(),
        publisher_id: "publisher.fixture".into(),
        capabilities: CapabilityFactsV1 {
            tool: true,
            vision: false,
            streaming: true,
            context_tokens: 128_000,
            max_output_tokens: 8_192,
        },
    };
    let capability = ModelEndpointCapabilityV1 {
        capability_id: "cap.messages-only".into(),
        revision: 1,
        model_configuration_id: model.model_configuration_id.clone(),
        connector_id: "connector.cpa.messages".into(),
        connector_revision: 1,
        endpoint_profile_id: "endpoint.cpa.messages".into(),
        endpoint_profile_revision: 1,
        protocol_endpoint_id: "endpoint.cpa.messages.native".into(),
        upstream_protocol: UpstreamProtocol::Messages,
        upstream_model_id: "messages-model".into(),
        required_adapter_ref: "adapter.anthropic-messages.v1".into(),
        required_adapter_revision: 1,
        evidence_digest: CanonicalDigest::of_bytes(b"messages-only"),
    };
    let reasoning = ModelNativeReasoningV1 {
        model_configuration_id: model.model_configuration_id.clone(),
        capability: NativeReasoningCapabilityV1::Fixed {
            profile: "provider-default".into(),
        },
        native_render_convention: None,
    };
    let connector = ProtocolConnectorFacts {
        provider_id: "provider.fixture".into(),
        endpoint_id: "endpoint.cpa.messages".into(),
        entitlement_id: "fixture-subscription".into(),
        connector_id: "connector.cpa.messages".into(),
        connector_revision: "1".into(),
    };
    let profiles = protocol_profiles(
        &connector,
        &model,
        &capability,
        &reasoning,
        "messages-model",
        ConnectorRuntimeKind::CpaBridge,
        &[ProtocolFace {
            protocol: UpstreamProtocol::Messages,
            request_path: "/v1/messages".into(),
            authentication: GatewayAuthenticationSemanticsV1::Bearer,
            required_headers: vec![("anthropic-version".into(), "2023-06-01".into())],
            native_target: None,
            adapter_ref: None,
            adapter_revision: None,
        }],
    )
    .unwrap();
    assert_eq!(profiles.len(), 1);
    assert_eq!(profiles[0].ingress_protocol, UpstreamProtocol::Messages);
    assert_eq!(
        profiles[0].connector.authentication.exact(),
        Some(&GatewayAuthenticationSemanticsV1::Bearer)
    );
    assert_eq!(
        profiles[0]
            .connector
            .headers
            .exact()
            .unwrap()
            .required_headers,
        [("anthropic-version".into(), "2023-06-01".into())]
    );
}

#[test]
fn unmarked_native_controls_never_infer_adaptive_from_model_name() {
    for capability in [
        NativeReasoningCapabilityV1::Fixed {
            profile: "provider-default".into(),
        },
        NativeReasoningCapabilityV1::Toggle {
            parameter: "thinking.enabled".into(),
        },
        NativeReasoningCapabilityV1::Budget {
            parameter: "thinking.budget_tokens".into(),
            minimum_tokens: 1024,
            maximum_tokens: 2048,
            step_tokens: 1024,
        },
        NativeReasoningCapabilityV1::Discrete {
            parameter: "output_config.effort".into(),
            profiles: vec!["high".into()],
            default_profile: None,
        },
    ] {
        let native = ModelNativeReasoningV1 {
            model_configuration_id: "model.anthropic.claude-opus-5".into(),
            capability,
            native_render_convention: None,
        };
        for protocol in [
            UpstreamProtocol::Messages,
            UpstreamProtocol::Responses,
            UpstreamProtocol::ChatCompletions,
        ] {
            let profiles = reasoning_profiles(&native, protocol);
            if protocol == UpstreamProtocol::Responses
                && matches!(
                    native.capability,
                    NativeReasoningCapabilityV1::Budget { .. }
                )
            {
                assert!(
                    profiles.is_none(),
                    "Responses has no standard budget control"
                );
                continue;
            }
            let profiles = profiles.unwrap();
            assert!(
                !serde_json::to_string(&profiles)
                    .unwrap()
                    .contains("adaptive")
            );
            for profile in profiles {
                match profile.render {
                    GatewayNativeReasoningRenderV1::NoControlParameter => {
                        assert_eq!(profile.control_kind, GatewayReasoningControlKindV1::Fixed)
                    }
                    GatewayNativeReasoningRenderV1::ExactFields { fields, .. }
                    | GatewayNativeReasoningRenderV1::ExactBudget { fields, .. } => {
                        assert!(!fields.is_empty())
                    }
                }
            }
        }
    }
}

#[test]
fn portable_thinking_toggle_renders_the_selected_native_protocol() {
    let native = ModelNativeReasoningV1 {
        model_configuration_id: "model.custom.unknown".into(),
        capability: NativeReasoningCapabilityV1::Toggle {
            parameter: "enable_thinking".into(),
        },
        native_render_convention: None,
    };
    for (protocol, path, enabled, disabled) in [
        (
            UpstreamProtocol::ChatCompletions,
            vec!["enable_thinking"],
            GatewayNativeReasoningValueV1::Bool(true),
            GatewayNativeReasoningValueV1::Bool(false),
        ),
        (
            UpstreamProtocol::Responses,
            vec!["reasoning", "effort"],
            GatewayNativeReasoningValueV1::String("low".into()),
            GatewayNativeReasoningValueV1::String("none".into()),
        ),
        (
            UpstreamProtocol::Messages,
            vec!["thinking", "type"],
            GatewayNativeReasoningValueV1::String("enabled".into()),
            GatewayNativeReasoningValueV1::String("disabled".into()),
        ),
    ] {
        let profiles = reasoning_profiles(&native, protocol).unwrap();
        for (profile, expected) in profiles.iter().zip([disabled, enabled]) {
            let GatewayNativeReasoningRenderV1::ExactFields { fields, .. } = &profile.render else {
                panic!("toggle must render an explicit wire field");
            };
            let enabled = profile.profile_id == "enabled";
            assert_eq!(
                fields.len(),
                if protocol == UpstreamProtocol::Messages && enabled {
                    2
                } else {
                    1
                }
            );
            if protocol == UpstreamProtocol::Messages && enabled {
                assert_eq!(
                    fields[1],
                    field(
                        "thinking.budget_tokens",
                        GatewayNativeReasoningValueV1::U64(1024),
                        protocol
                    )
                );
            }
            assert_eq!(fields[0].path, path);
            assert_eq!(fields[0].value, expected);
        }
    }
}

#[test]
fn deepseek_toggle_uses_each_native_protocols_documented_control() {
    let native = ModelNativeReasoningV1 {
        model_configuration_id: "model.deepseek.direct".into(),
        capability: NativeReasoningCapabilityV1::Toggle {
            parameter: "deepseek_thinking".into(),
        },
        native_render_convention: None,
    };
    for (protocol, path, on, off) in [
        (
            UpstreamProtocol::ChatCompletions,
            "thinking.type",
            "enabled",
            "disabled",
        ),
        (
            UpstreamProtocol::Responses,
            "reasoning.effort",
            "low",
            "none",
        ),
        (
            UpstreamProtocol::Messages,
            "thinking.type",
            "enabled",
            "disabled",
        ),
    ] {
        let profiles = reasoning_profiles(&native, protocol).unwrap();
        for (profile, value) in profiles.iter().zip([off, on]) {
            let GatewayNativeReasoningRenderV1::ExactFields { fields, .. } = &profile.render else {
                panic!("DeepSeek toggle must render exact native fields");
            };
            assert_eq!(
                fields[0],
                field(
                    path,
                    GatewayNativeReasoningValueV1::String(value.into()),
                    protocol
                )
            );
            let enabled = profile.profile_id == "enabled";
            assert_eq!(
                fields.len(),
                if protocol == UpstreamProtocol::Messages && enabled {
                    2
                } else {
                    1
                }
            );
            if protocol == UpstreamProtocol::Messages && enabled {
                assert_eq!(
                    fields[1],
                    field(
                        "thinking.budget_tokens",
                        GatewayNativeReasoningValueV1::U64(1024),
                        protocol
                    )
                );
            }
        }
    }
}

#[test]
fn claude_adaptive_effort_never_renders_manual_thinking() {
    let native = ModelNativeReasoningV1 {
        model_configuration_id: "model.anthropic.claude-opus-5-5".into(),
        capability: NativeReasoningCapabilityV1::Discrete {
            parameter: "claude_adaptive_effort".into(),
            profiles: vec!["low".into(), "medium".into(), "high".into()],
            default_profile: Some("medium".into()),
        },
        native_render_convention: None,
    };
    let profiles = reasoning_profiles(&native, UpstreamProtocol::Messages).unwrap();
    assert!(reasoning_profiles(&native, UpstreamProtocol::Responses).is_none());
    assert!(reasoning_profiles(&native, UpstreamProtocol::ChatCompletions).is_none());
    assert_eq!(
        profiles
            .iter()
            .map(|profile| profile.profile_id.as_str())
            .collect::<Vec<_>>(),
        ["low", "medium", "high"]
    );
    for profile in profiles {
        assert_eq!(
            profile.render,
            GatewayNativeReasoningRenderV1::ExactFields {
                protocol: UpstreamProtocol::Messages,
                fields: vec![
                    field(
                        "output_config.effort",
                        GatewayNativeReasoningValueV1::String(profile.profile_id.clone()),
                        UpstreamProtocol::Messages
                    ),
                    field(
                        "thinking.type",
                        GatewayNativeReasoningValueV1::String("adaptive".into()),
                        UpstreamProtocol::Messages
                    ),
                ],
            }
        );
    }
}

fn registered_fact(
    catalog: &TrustedReleaseCatalog,
    option: &str,
    model_id: &str,
) -> ComputeManagementCompilationFactV2 {
    let mut fact = source_local_fact(GatewayAuthenticationSemanticsV1::Bearer);
    let resolved = catalog.resolve_connection_option(option).unwrap();
    let capability = catalog
        .model_data()
        .model_endpoint_capabilities
        .iter()
        .find(|capability| {
            capability.model_configuration_id == model_id
                && capability.endpoint_profile_id == resolved.endpoint_profile.endpoint_profile_id
        })
        .unwrap();
    let endpoint = resolved
        .endpoint_profile
        .protocol_endpoints
        .iter()
        .find(|endpoint| endpoint.protocol_endpoint_id == capability.protocol_endpoint_id)
        .unwrap();
    let model = catalog.model_data().model(model_id).unwrap();
    let reasoning = catalog
        .native_reasoning()
        .iter()
        .find(|reasoning| reasoning.model_configuration_id == model_id)
        .unwrap();
    fact.eligibility = ComputeManagementEligibilityV2::CatalogMatched;
    fact.provenance = hiroute_domain::ComputeManagementProvenanceV2::Registered {
        connection_option_id: option.into(),
        registry_version: catalog.registry().registry_version.clone(),
        catalog_digest: catalog
            .compute_catalog_provenance()
            .unwrap()
            .cross_reference_digest,
    };
    fact.target = hiroute_domain::ComputeManagementTargetV2 {
        scheme: "https".into(),
        authority: endpoint.base_url.strip_prefix("https://").unwrap().into(),
        port: 443,
        request_path: endpoint.request_path.clone(),
        upstream_protocol: endpoint.protocol,
        protocol_profile_id: endpoint.adapter_ref.clone(),
        protocol_profile_revision: endpoint.adapter_revision,
    };
    fact.authentication = endpoint.authentication_semantics.clone().unwrap();
    fact.additional_native_endpoints = resolved
        .endpoint_profile
        .protocol_endpoints
        .iter()
        .filter(|other| other.protocol != endpoint.protocol)
        .map(|other| hiroute_domain::ComputeNativeEndpointV3 {
            target: hiroute_domain::ComputeManagementTargetV2 {
                scheme: "https".into(),
                authority: other.base_url.strip_prefix("https://").unwrap().into(),
                port: 443,
                request_path: other.request_path.clone(),
                upstream_protocol: other.protocol,
                protocol_profile_id: other.adapter_ref.clone(),
                protocol_profile_revision: other.adapter_revision,
            },
            authentication: other.authentication_semantics.clone().unwrap(),
            recheck:
                crate::control::runtime::model_connections::registered_endpoint_recheck_descriptor(
                    &resolved, other,
                ),
        })
        .collect();
    fact.upstream_model_id = capability.upstream_model_id.clone();
    fact.catalog_configuration_id = Some(model_id.into());
    let registered = |value| hiroute_domain::ComputeManagementFactValueV2 {
        value: Some(value),
        basis: hiroute_domain::ComputeManagementFactBasisV2::RegisteredCatalog,
    };
    fact.capabilities = hiroute_domain::ComputeManagedCapabilitiesV2 {
        tool: registered(model.capabilities.tool),
        vision: registered(model.capabilities.vision),
        streaming: registered(model.capabilities.streaming),
        context_tokens: hiroute_domain::ComputeManagementFactValueV2 {
            value: Some(model.capabilities.context_tokens),
            basis: hiroute_domain::ComputeManagementFactBasisV2::RegisteredCatalog,
        },
        max_output_tokens: hiroute_domain::ComputeManagementFactValueV2 {
            value: Some(model.capabilities.max_output_tokens),
            basis: hiroute_domain::ComputeManagementFactBasisV2::RegisteredCatalog,
        },
        native_reasoning: hiroute_domain::ComputeManagementFactValueV2 {
            value: Some(reasoning.capability.clone()),
            basis: hiroute_domain::ComputeManagementFactBasisV2::RegisteredCatalog,
        },
    };
    fact.native_reasoning = reasoning.capability.clone();
    let declaration = hiroute_integrations::NativeModelCapabilityDeclarationV1 {
        tool: registered_catalog_fact(model.capabilities.tool),
        vision: registered_catalog_fact(model.capabilities.vision),
        streaming: registered_catalog_fact(model.capabilities.streaming),
        context_tokens: registered_catalog_fact(model.capabilities.context_tokens),
        max_output_tokens: registered_catalog_fact(model.capabilities.max_output_tokens),
        native_reasoning: registered_catalog_fact(reasoning.capability.clone()),
    };
    fact.capability_evidence_digest = CanonicalDigest::of(&(
        "declared-model-capabilities/v1",
        &fact.upstream_model_id,
        &declaration,
    ))
    .unwrap();
    let mut destinations =
        std::collections::BTreeSet::from([fact.target.credential_destination().unwrap()]);
    destinations.extend(
        fact.additional_native_endpoints
            .iter()
            .map(|endpoint| endpoint.target.credential_destination().unwrap()),
    );
    fact.credential = ComputeManagementCredentialCompilationV2::Native {
        ordered: ["credential/registered-a", "credential/registered-b"]
            .into_iter()
            .map(
                |id| hiroute_domain::ComputeCredentialSelectionV2::Credential {
                    credential_ref: hiroute_domain::CredentialRefV1::new(
                        id,
                        format!("source/{}", fact.source_id),
                        "hirouted",
                        "provider-auth",
                        destinations.iter().cloned(),
                        1,
                    )
                    .unwrap(),
                },
            )
            .collect(),
    };
    fact
}

#[test]
fn registered_management_preserves_catalog_and_exact_credential_destination() {
    let catalog = crate::release_catalog::current_fixture_catalog();
    let (option, model, billing) = (
        "bailian.payg.cn.v1",
        "model.bailian.qwen3-max-2026-01-23",
        BillingClass::Paid,
    );
    let fact = registered_fact(&catalog, option, model);
    let candidate = materialize_registered_management_candidate(&fact, &catalog).unwrap();
    assert_eq!(
        candidate.authority,
        CandidateFactAuthorityV1::RegisteredCatalog
    );
    assert!(candidate.is_routable());
    assert_eq!(candidate.connection_option_id, option);
    assert_eq!(candidate.binding.model_configuration_id, model);
    assert_eq!(candidate.binding.billing_class, billing);
    assert_eq!(candidate.binding.binding_id, fact.binding_id);
    assert_eq!(candidate.binding.revision, fact.binding_revision);
    assert_eq!(candidate.binding.source_id, fact.source_id);
    assert_eq!(candidate.binding.source_revision, fact.source_revision);
    assert_eq!(
        candidate.binding.source_identity_digest,
        fact.source_lineage_digest
    );
    assert_eq!(
        candidate.capability.evidence_digest,
        catalog
            .model_data()
            .model_endpoint_capabilities
            .iter()
            .find(|capability| { capability.capability_id == candidate.binding.capability_id })
            .unwrap()
            .evidence_digest
    );
    let offer = catalog
        .model_data()
        .offer(&candidate.binding.offer_ref)
        .unwrap();
    assert_eq!(
        candidate.binding.offer_evidence_digest,
        offer.evidence_digest
    );
    assert_eq!(candidate.offer_revision, offer.revision);
    assert_eq!(candidate.reasoning, fact.native_reasoning);
    assert_eq!(
        candidate.credential_refs,
        ["credential/registered-a", "credential/registered-b"]
    );
    assert_eq!(
        candidate.credential_destination_ref,
        Some(fact.target.credential_destination().unwrap())
    );
    assert!(
        candidate.protocol_profiles.iter().all(|profile| {
            profile.connector.authentication.exact() == Some(&fact.authentication)
        })
    );
    let mut wrong = candidate.clone();
    wrong.credential_destination_ref = Some("compute-target/substituted".into());
    assert!(wrong.validate().is_err());
    let mut legacy = candidate;
    legacy.credential_destination_ref = None;
    assert!(legacy.validate().is_ok());
    assert!(materialize_management_candidate(&fact, None).is_none());
}

#[test]
fn registered_management_rejects_unproved_catalog_target_capability_and_credentials() {
    let catalog = crate::release_catalog::current_fixture_catalog();
    let fact = registered_fact(
        &catalog,
        "bailian.payg.cn.v1",
        "model.bailian.qwen3-max-2026-01-23",
    );
    let mutations: &[fn(&mut ComputeManagementCompilationFactV2)] = &[
        |fact| fact.eligibility = ComputeManagementEligibilityV2::UserConfirmed,
        |fact| {
            if let hiroute_domain::ComputeManagementProvenanceV2::Registered {
                connection_option_id,
                ..
            } = &mut fact.provenance
            {
                *connection_option_id = "option/unregistered".into();
            }
        },
        |fact| fact.catalog_configuration_id = Some("model/unregistered".into()),
        |fact| fact.upstream_model_id = "unmatched".into(),
        |fact| fact.target.authority = "substituted.invalid".into(),
        |fact| fact.target.port = 8443,
        |fact| fact.target.scheme = "http".into(),
        |fact| fact.target.request_path = "/other/messages".into(),
        |fact| fact.target.upstream_protocol = UpstreamProtocol::Responses,
        |fact| fact.target.protocol_profile_id = "adapter/substituted".into(),
        |fact| fact.target.protocol_profile_revision += 1,
        |fact| fact.authentication = GatewayAuthenticationSemanticsV1::None,
        |fact| {
            fact.authentication = GatewayAuthenticationSemanticsV1::ApiKeyHeader {
                header: "x-api-key".into(),
            }
        },
        |fact| fact.capabilities.tool.value = Some(false),
        |fact| fact.capabilities.vision.value = None,
        |fact| {
            fact.capabilities.streaming.basis =
                hiroute_domain::ComputeManagementFactBasisV2::UserDeclared
        },
        |fact| fact.capabilities.context_tokens.value = Some(1),
        |fact| fact.capabilities.max_output_tokens.value = Some(1),
        |fact| fact.capability_evidence_digest = CanonicalDigest::of_bytes(b"substituted-evidence"),
        |fact| {
            fact.native_reasoning = NativeReasoningCapabilityV1::Fixed {
                profile: "unproved".into(),
            }
        },
        |fact| {
            fact.credential = ComputeManagementCredentialCompilationV2::Native {
                ordered: Vec::new(),
            }
        },
        |fact| {
            fact.credential = ComputeManagementCredentialCompilationV2::Native {
                ordered: vec![hiroute_domain::ComputeCredentialSelectionV2::NoCredential],
            }
        },
        |fact| {
            fact.credential = source_local_fact(GatewayAuthenticationSemanticsV1::Bearer).credential
        },
        |fact| {
            fact.credential = ComputeManagementCredentialCompilationV2::Native {
                ordered: vec![hiroute_domain::ComputeCredentialSelectionV2::Credential {
                    credential_ref: hiroute_domain::CredentialRefV1::new(
                        "credential/other-source",
                        "source/other",
                        "hirouted",
                        "provider-auth",
                        [fact.target.credential_destination().unwrap()],
                        1,
                    )
                    .unwrap(),
                }],
            }
        },
    ];
    for (index, mutate) in mutations.iter().enumerate() {
        let mut invalid = fact.clone();
        mutate(&mut invalid);
        assert!(
            materialize_registered_management_candidate(&invalid, &catalog).is_none(),
            "mutation {index}"
        );
    }
}

#[test]
fn registered_management_re_resolves_stable_option_across_global_catalog_identity_change() {
    let catalog = crate::release_catalog::current_fixture_catalog();
    let mut fact = registered_fact(
        &catalog,
        "bailian.payg.cn.v1",
        "model.bailian.qwen3-max-2026-01-23",
    );
    let hiroute_domain::ComputeManagementProvenanceV2::Registered {
        registry_version,
        catalog_digest,
        ..
    } = &mut fact.provenance
    else {
        unreachable!();
    };
    registry_version.push_str("-catalog-a");
    *catalog_digest = CanonicalDigest::of_bytes(b"catalog-a");

    let candidate = materialize_registered_management_candidate(&fact, &catalog).unwrap();
    assert_eq!(candidate.connection_option_id, "bailian.payg.cn.v1");
    assert_eq!(
        candidate.operational_target.request_path(),
        Some(fact.target.request_path.as_str())
    );
}

#[test]
fn registered_management_compilation_excludes_disabled_missing_keys_and_unknown_members() {
    use hiroute_application::compute_management::compile_compute_management_source;
    use hiroute_domain::*;
    let catalog = crate::release_catalog::current_fixture_catalog();
    let fact = registered_fact(
        &catalog,
        "bailian.payg.cn.v1",
        "model.bailian.qwen3-max-2026-01-23",
    );
    let ComputeManagementCredentialCompilationV2::Native { ordered } = &fact.credential else {
        unreachable!();
    };
    let source = ComputeManagementSourceV2 {
        schema: COMPUTE_MANAGEMENT_SOURCE_SCHEMA_V2.into(),
        source_id: fact.source_id.clone(),
        revision: fact.source_revision,
        lineage_digest: fact.source_lineage_digest.clone(),
        display_name: fact.display_name.clone(),
        provenance: fact.provenance.clone(),
        target: fact.target.clone(),
        authentication: fact.authentication.clone(),
        state: MaterializationState::Ready,
        models: vec![ComputeManagedModelV2 {
            model_ref: fact.model_ref.clone(),
            binding_id: fact.binding_id.clone(),
            revision: fact.binding_revision,
            upstream_model_id: fact.upstream_model_id.clone(),
            display_name: fact.display_name.clone(),
            catalog_configuration_id: fact.catalog_configuration_id.clone(),
            membership: ComputeManagementMembershipV2::Catalog,
            execution_eligible: true,
            capabilities: fact.capabilities.clone(),
            capability_evidence_digest: fact.capability_evidence_digest.clone(),
        }],
        native_recheck: None,
        additional_native_endpoints: fact.additional_native_endpoints.clone(),
        credentials: ordered
            .iter()
            .enumerate()
            .map(|(index, selection)| {
                let ComputeCredentialSelectionV2::Credential { credential_ref } = selection else {
                    unreachable!()
                };
                ComputeManagedCredentialV2 {
                    key_id: credential_ref.credential_id().into(),
                    credential: credential_ref.clone(),
                    fingerprint: CanonicalDigest::of_bytes(&[index as u8]),
                    ordinal: index as u32,
                    enabled: true,
                }
            })
            .collect(),
        validation: None,
        last_candidate_ref: "candidate/native/registered".into(),
        last_candidate_revision: 1,
    };
    source.validate().unwrap();
    let compiled = compile_compute_management_source(&source).unwrap();
    assert_eq!(compiled.len(), 1);
    assert!(materialize_registered_management_candidate(&compiled[0], &catalog).is_some());
    let mut partially_disabled = source.clone();
    partially_disabled.credentials[0].enabled = false;
    let compiled = compile_compute_management_source(&partially_disabled).unwrap();
    let candidate = materialize_registered_management_candidate(&compiled[0], &catalog).unwrap();
    assert_eq!(candidate.credential_refs, ["credential/registered-b"]);
    let mut disabled = source.clone();
    disabled.state = MaterializationState::Disabled;
    assert!(compile_compute_management_source(&disabled).is_err());
    let mut missing = source.clone();
    missing.credentials.clear();
    missing.state = MaterializationState::NeedsCredential;
    assert!(compile_compute_management_source(&missing).is_err());
    let mut all_disabled = source.clone();
    all_disabled
        .credentials
        .iter_mut()
        .for_each(|key| key.enabled = false);
    assert!(compile_compute_management_source(&all_disabled).is_err());
    let mut unknown = source.clone();
    unknown.models[0].capabilities.tool = ComputeManagementFactValueV2 {
        value: None,
        basis: ComputeManagementFactBasisV2::Unknown,
    };
    assert!(compile_compute_management_source(&unknown).is_err());
    let mut observed = source;
    observed.models[0].membership = ComputeManagementMembershipV2::Observed;
    assert!(compile_compute_management_source(&observed).is_err());
}

#[test]
fn responses_effort_uses_the_exact_nested_native_field() {
    assert_eq!(
        parameter_path("reasoning_effort", UpstreamProtocol::Responses),
        ["reasoning", "effort"]
    );
    assert_eq!(
        parameter_path("reasoning_effort", UpstreamProtocol::ChatCompletions),
        ["reasoning_effort"]
    );
}

#[test]
fn unknown_native_text_uses_execution_defaults_without_overwriting_unknown_facts() {
    let mut fact = source_local_fact(GatewayAuthenticationSemanticsV1::None);
    fn unknown<T>() -> hiroute_domain::ComputeManagementFactValueV2<T> {
        hiroute_domain::ComputeManagementFactValueV2 {
            value: None,
            basis: hiroute_domain::ComputeManagementFactBasisV2::Unknown,
        }
    }
    fact.capabilities = hiroute_domain::ComputeManagedCapabilitiesV2 {
        tool: unknown(),
        vision: unknown(),
        streaming: unknown(),
        context_tokens: unknown(),
        max_output_tokens: unknown(),
        native_reasoning: unknown(),
    };
    fact.native_reasoning = NativeReasoningCapabilityV1::Toggle {
        parameter: "enable_thinking".into(),
    };
    let candidate = materialize_management_candidate(&fact, None).unwrap();
    assert!(candidate.is_routable());
    assert!(candidate.model.capabilities.tool);
    assert!(!candidate.model.capabilities.vision);
    assert!(candidate.model.capabilities.streaming);
    assert_eq!(candidate.model.capabilities.context_tokens, 200_000);
    assert_eq!(candidate.model.capabilities.max_output_tokens, 32_768);
    assert!(fact.capabilities.context_tokens.value.is_none());
    assert!(fact.capabilities.tool.value.is_none());
    assert!(candidate.free_evidence.is_none());
    assert!(candidate.ordering_price.is_none());
    // Native observations keep their measured limits and source-local target,
    // including a loopback HTTP API, rather than acquiring Registry authority.
    let mut imported = fact.clone();
    imported.eligibility = ComputeManagementEligibilityV2::NativeObserved;
    imported.capabilities.context_tokens = hiroute_domain::ComputeManagementFactValueV2 {
        value: Some(16_384),
        basis: hiroute_domain::ComputeManagementFactBasisV2::Observed,
    };
    imported.capabilities.max_output_tokens = hiroute_domain::ComputeManagementFactValueV2 {
        value: Some(4_096),
        basis: hiroute_domain::ComputeManagementFactBasisV2::Observed,
    };
    let native = materialize_management_candidate(&imported, None).unwrap();
    assert_eq!(native.authority, CandidateFactAuthorityV1::SourceLocalUser);
    assert_eq!(native.model.capabilities.context_tokens, 16_384);
    assert_eq!(native.model.capabilities.max_output_tokens, 4_096);
    assert_eq!(native.operational_target, candidate.operational_target);
    for (protocol, path) in [
        (UpstreamProtocol::Responses, "/v1/responses"),
        (UpstreamProtocol::ChatCompletions, "/v1/chat/completions"),
        (UpstreamProtocol::Messages, "/v1/messages"),
    ] {
        for parameter in [
            "enable_thinking",
            "deepseek_thinking",
            "reasoning_effort",
            "thinking_budget",
            "custom_toggle",
        ] {
            let mut toggled = imported.clone();
            toggled.target.upstream_protocol = protocol;
            toggled.target.request_path = path.into();
            toggled.native_reasoning = NativeReasoningCapabilityV1::Toggle {
                parameter: parameter.into(),
            };
            let native = materialize_management_candidate(&toggled, None).unwrap();
            for enabled in [false, true] {
                let selection = hiroute_domain::AgentFixedModelSelectionV2 {
                    client_model_id: "native-route".into(),
                    candidate: hiroute_domain::CandidateSelectionV1 {
                        binding_id: native.binding.binding_id.clone(),
                        reasoning: Some(hiroute_domain::ReasoningSelectionV1::Toggle { enabled }),
                    },
                };
                // Follow actual renderer output through both the compiler and
                // Gateway ingestion; matching the Domain alone is insufficient.
                let routes = hiroute_application::compiler::compile_fixed_model_bindings(
                    &[selection],
                    std::slice::from_ref(&native),
                )
                .unwrap();
                assert_eq!(
                    routes["native-route"].operational_target,
                    native.operational_target
                );
                for profile in &routes["native-route"].protocol_profiles {
                    let gateway: hiroute_gateway::server::core_runtime::profiles::CandidateProtocolProfile =
                        serde_json::from_value(serde_json::to_value(profile).unwrap()).unwrap();
                    assert!(
                        gateway
                            .capability
                            .reasoning_profiles
                            .iter()
                            .all(|reasoning| reasoning
                                .validate_for(gateway.capability.upstream_protocol)),
                        "{parameter} {protocol:?} {enabled}"
                    );
                }
            }
        }
    }
    let mut second_source = fact.clone();
    second_source.source_id = "second-source-same-model".into();
    second_source.binding_id = "binding/second-source".into();
    let second = materialize_management_candidate(&second_source, None).unwrap();
    assert_ne!(
        candidate.model.model_configuration_id,
        second.model.model_configuration_id
    );
}

#[path = "candidate_execution_tests/model_defaults.rs"]
mod model_defaults;