Skip to content

armgit / avibe

Public Imported from GitHub
0

Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.

47.4 KB
Raw Blame
from __future__ import annotations

import asyncio
import copy
import json
from dataclasses import asdict, replace
from pathlib import Path

import pytest

from config.v2_config import (
    ModelHubBackendModelConfig,
    ModelHubConfig,
    ModelHubModelConfig,
    ModelHubRouteConfig,
    ModelHubRouteHopConfig,
    ModelHubSourceStateConfig,
)
from core.handlers.model_hub.adapter import RawCallOutcome, RawOutcomeKind, SourceBinding
from core.handlers.model_hub.resolver import (
    effective_model_route,
    resolve_model_hub_turn,
    validate_cache_ttl_override,
)
from core.handlers.model_hub.service import ModelHubError
from scripts.check_model_hub_authorities import AuthorityInput, _typescript_string_union
from tests.test_model_hub_resolution import _service, _source
from vibe.model_hub_runtime.config import _append_source
from vibe.model_hub_runtime.state import EngineStateStore, SourceRecord


MODEL = "claude-opus-4-6"


def _sparse_config(*sources):
    config = ModelHubConfig(sources=list(sources))
    agent = config.agents["claude"]
    agent.mode = "hub"
    agent.models = [ModelHubBackendModelConfig(id=MODEL)]
    agent.sources.order = [source.id for source in sources]
    return config


def _pairs(plan):
    return [(hop.source_id, hop.model_id) for hop in plan.hops]


def test_prompt_cache_override_is_route_wide_and_openai_wire_eligible():
    source = _source("src_openai001", ("gpt-6-astra",), vendor="openai")
    config = ModelHubConfig(sources=[source])
    agent = config.agents["vibey"]
    agent.mode = "hub"
    agent.models = [ModelHubBackendModelConfig(id="gpt-6-astra")]
    agent.sources.order = [source.id]
    route = ModelHubRouteConfig(
        hops=(ModelHubRouteHopConfig(source.id, "gpt-6-astra"),),
        cache_ttl="30m",
    )
    agent.routes["gpt-6-astra"] = route

    validate_cache_ttl_override(config, "vibey", route)
    resolution = resolve_model_hub_turn(config, "vibey", "gpt-6-astra")
    assert resolution.cache_ttl == "30m"
    assert resolution.cache_ttl_wire is True

    route = ModelHubRouteConfig(
        hops=(ModelHubRouteHopConfig(source.id, "gpt-6-astra"),),
        cache_ttl="12h",
    )
    agent.routes["gpt-6-astra"] = route
    validate_cache_ttl_override(config, "vibey", route)
    resolution = resolve_model_hub_turn(config, "vibey", "gpt-6-astra")
    assert resolution.cache_ttl == "12h"
    assert resolution.cache_ttl_wire is True
    route = ModelHubRouteConfig(
        hops=(ModelHubRouteHopConfig(source.id, "gpt-6-astra"),),
        cache_ttl="30m",
    )
    agent.routes["gpt-6-astra"] = route
    source.base_url = "https://relay.example.test/v1"
    validate_cache_ttl_override(config, "vibey", route)
    resolution = resolve_model_hub_turn(config, "vibey", "gpt-6-astra")
    assert resolution.cache_ttl == "30m"
    assert resolution.cache_ttl_wire is False


def test_prompt_cache_override_rejects_unsupported_official_values():
    source = _source("src_openai001", ("gpt-6-astra",), vendor="openai")
    config = ModelHubConfig(sources=[source])
    route = ModelHubRouteConfig(
        hops=(ModelHubRouteHopConfig(source.id, "gpt-6-astra"),),
        cache_ttl="1h",
    )
    with pytest.raises(ValueError, match="30m or 12h"):
        validate_cache_ttl_override(config, "vibey", route)


def test_prompt_cache_override_rejects_unsupported_official_anthropic_values():
    source = _source("src_anthropic001", ("claude-opus-4-6",), vendor="anthropic")
    config = ModelHubConfig(sources=[source])
    route = ModelHubRouteConfig(
        hops=(ModelHubRouteHopConfig(source.id, "claude-opus-4-6"),),
        cache_ttl="5m",
    )
    with pytest.raises(ValueError, match="only 1h"):
        validate_cache_ttl_override(config, "vibey", route)


def test_prompt_cache_override_accepts_the_official_anthropic_one_hour_mode():
    source = _source("src_anthropic001", ("claude-opus-4-6",), vendor="anthropic")
    config = ModelHubConfig(sources=[source])
    route = ModelHubRouteConfig(
        hops=(ModelHubRouteHopConfig(source.id, "claude-opus-4-6"),),
        cache_ttl="1h",
    )
    validate_cache_ttl_override(config, "vibey", route)


def test_prompt_cache_override_is_rejected_for_non_vibey_routes():
    source = _source("src_openai001", ("gpt-6-astra",), vendor="openai")
    config = ModelHubConfig(sources=[source])
    route = ModelHubRouteConfig(
        hops=(ModelHubRouteHopConfig(source.id, "gpt-6-astra"),),
        cache_ttl="30m",
    )
    with pytest.raises(ValueError, match="only for Vibey"):
        validate_cache_ttl_override(config, "claude", route)


    absent = _source("src_absent001", ())
    known = _source("src_known001")
    config = _sparse_config(absent, known)
    plan = effective_model_route(config, "claude", MODEL)
    assert plan.manual_override is None
    assert plan.route_origin == "automatic"
    assert _pairs(plan) == [(known.id, MODEL)]

    known.state = ModelHubSourceStateConfig(
        status="needs_action", detail_key="models.source.needs_action.oauth_expired"
    )
    blocked = resolve_model_hub_turn(config, "claude", MODEL)
    assert blocked.route_origin == "automatic"
    assert blocked.candidates == ()
    assert [hop.source_id for hop in blocked.inspected_hops] == [known.id]
    assert effective_model_route(config, "claude", MODEL) == plan
    assert config.agents["claude"].routes == {}


def test_no_matching_inventory_forwards_exact_id_to_all_defaults():
    first = _source("src_first001", ())
    second = _source("src_second001", ("other-model",))
    config = _sparse_config(first, second)
    plan = effective_model_route(config, "claude", MODEL)
    assert plan.route_origin == "passthrough"
    assert _pairs(plan) == [(first.id, MODEL), (second.id, MODEL)]
    resolution = resolve_model_hub_turn(config, "claude", MODEL)
    assert resolution.source is first
    assert resolution.target_model == MODEL
    assert all(not hop.inventory_member and hop.runnable for hop in resolution.inspected_hops)


def test_manual_inventory_is_matching_evidence_and_retirement_is_not():
    first = _source("src_first001", ())
    second = _source("src_second001", ())
    second.models = [ModelHubModelConfig(id=MODEL, provenance="manual")]
    config = _sparse_config(first, second)
    assert _pairs(effective_model_route(config, "claude", MODEL)) == [(second.id, MODEL)]
    second.models = [ModelHubModelConfig(id=MODEL, provenance="discovered", retired=True)]
    plan = effective_model_route(config, "claude", MODEL)
    assert plan.route_origin == "passthrough"
    assert _pairs(plan) == [(first.id, MODEL)]
    config.agents["claude"].routes[MODEL] = ModelHubRouteConfig(hops=(ModelHubRouteHopConfig(second.id, MODEL),))
    blocked = resolve_model_hub_turn(config, "claude", MODEL)
    assert blocked.route_origin == "manual"
    assert not blocked.candidates
    assert blocked.inspected_hops[0].reason == "model_unsupported"


def test_native_alias_tier_is_chosen_before_hub_transport_filter():
    native = _source("src_native001", (), kind="subscription", channel="native_cli", credential_ref=None)
    native.models = [ModelHubModelConfig(id="claude-opus-4-6-20260115", provenance="manual")]
    api = _source("src_api00001", ())
    config = _sparse_config(api, native)
    plan = effective_model_route(config, "claude", MODEL)
    assert plan.route_origin == "automatic"
    assert _pairs(plan) == [(native.id, "claude-opus-4-6-20260115")]
    resolution = resolve_model_hub_turn(config, "claude", MODEL, supply_channel="hub")
    assert resolution.route_origin == "automatic"
    assert not resolution.candidates
    assert [hop.source_id for hop in resolution.inspected_hops] == [native.id]


def test_absence_does_not_broaden_backend_model_admission():
    config = _sparse_config(_source("src_first001", ()))
    assert effective_model_route(config, "claude", "not-in-catalog").hops == ()
    assert resolve_model_hub_turn(config, "claude", "not-in-catalog").source is None


@pytest.mark.parametrize("channel", ["hub", "native_cli"])
def test_subscriptions_do_not_gain_unknown_fallback_or_manual_admission(tmp_path, channel):
    source = _source(
        "src_subscription01",
        (),
        kind="subscription",
        channel=channel,
        credential_ref=None if channel == "native_cli" else "cred_source",
    )
    config = _sparse_config(source)
    service, store, _ = _service(tmp_path, config)
    plan = effective_model_route(config, "claude", MODEL)
    assert plan.hops == ()
    assert plan.route_origin is None
    payload = {"hops": [{"source_id": source.id, "model_id": "unknown-target"}]}
    with pytest.raises(ModelHubError):
        asyncio.run(service.set_agent_chain("claude", MODEL, payload))
    with pytest.raises(ModelHubError):
        service.preview_agent_chain("claude", MODEL, {"manual_override": payload})
    assert service._bindings(config) == []

    # Historical stale intent remains editable, but never becomes runnable.
    config.agents["claude"].routes[MODEL] = ModelHubRouteConfig(
        hops=(ModelHubRouteHopConfig(source.id, "unknown-target"),)
    )
    saved = asyncio.run(service.set_agent_chain("claude", MODEL, payload))
    assert saved["chain"]["manual_override"] == payload
    assert saved["chain"]["route_origin"] == "manual"
    assert saved["chain"]["current"] is None
    assert saved["chain"]["chain"][0]["reason"] == "model_unsupported"
    assert store.config.agents["claude"].routes[MODEL].to_payload() == payload


def test_subscription_match_suppresses_unknown_api_speculation(tmp_path):
    api = _source("src_api00001", ())
    subscription = _source("src_subscription01", kind="subscription")
    config = _sparse_config(api, subscription)
    service, _, _ = _service(tmp_path, config)
    plan = effective_model_route(config, "claude", MODEL)
    assert plan.route_origin == "automatic"
    assert _pairs(plan) == [(subscription.id, MODEL)]
    bindings = service._bindings(config)
    assert all(binding.route_model_ids == () for binding in bindings)


def test_mixed_unmatched_defaults_only_use_api_key_passthrough():
    subscription = _source("src_subscription01", (), kind="subscription")
    api = _source("src_api00001", ())
    config = _sparse_config(subscription, api)
    plan = effective_model_route(config, "claude", MODEL)
    assert plan.route_origin == "passthrough"
    assert _pairs(plan) == [(api.id, MODEL)]


def test_equal_save_is_manual_and_empty_save_restores_inherited_changes(tmp_path):
    source = _source("src_first001")
    config = _sparse_config(source)
    service, store, adapter = _service(tmp_path, config)
    hops = [{"source_id": source.id, "model_id": MODEL}]
    saved = asyncio.run(service.set_agent_chain("claude", MODEL, {"hops": hops}))
    assert saved["chain"]["route_origin"] == "manual"
    assert saved["chain"]["manual_override"] == {"hops": hops}
    empty = asyncio.run(service.set_agent_chain("claude", MODEL, {"hops": []}))
    assert empty["chain"]["manual_override"] is None
    assert empty["chain"]["route_origin"] == "automatic"
    store.config.sources[0].models.clear()
    reloaded = ModelHubConfig.from_payload(store.config.to_payload())
    assert reloaded.agents["claude"].routes == {}
    assert effective_model_route(reloaded, "claude", MODEL).route_origin == "passthrough"
    with pytest.raises(ModelHubError) as guard:
        asyncio.run(service.set_agent_sources("claude", {"order": []}))
    asyncio.run(service.set_agent_sources("claude", {"order": [], "force": True, **guard.value.data}))
    assert service.agent_chain("claude", MODEL)["route_origin"] is None
    assert adapter.synced


def test_preview_and_restore_use_same_plan_without_preview_side_effects(tmp_path):
    source = _source("src_first001", ())
    config = _sparse_config(source)
    config.agents["claude"].routes[MODEL] = ModelHubRouteConfig()
    service, store, adapter = _service(tmp_path, config)
    before = store.config.to_payload()
    writes = []
    original_save = store.save
    store.save = lambda updated: (writes.append(updated), original_save(updated))[-1]
    draft = service.preview_agent_chain("claude", MODEL, {"manual_override": None})
    assert draft["manual_override"] is None
    assert draft["route_origin"] == "passthrough"
    assert draft["current"] == {"source_id": source.id, "model_id": MODEL}
    assert store.config.to_payload() == before
    assert writes == adapter.synced == []
    assert not (tmp_path / "events.json").exists()
    restored = asyncio.run(service.delete_agent_chain("claude", MODEL))
    assert restored["chain"] == draft
    assert MODEL not in store.config.agents["claude"].routes
    repeated = asyncio.run(service.delete_agent_chain("claude", MODEL))
    assert repeated == restored
    assert adapter.synced == []


def test_restore_guards_effective_removal_and_accepts_only_exact_echo(tmp_path):
    default = _source("src_default01")
    manual = _source("src_manual001", ())
    config = _sparse_config(default)
    config.sources.append(manual)
    config.agents["claude"].routes[MODEL] = ModelHubRouteConfig(
        hops=(ModelHubRouteHopConfig(manual.id, "exact-unlisted"),)
    )
    service, store, _ = _service(tmp_path, config)
    with pytest.raises(ModelHubError) as refusal:
        asyncio.run(service.delete_agent_chain("claude", MODEL))
    assert refusal.value.code == "source_in_route_chain"
    assert refusal.value.data["would_interrupt"] == []
    assert refusal.value.data["would_remove_hops"][0]["model_id"] == "exact-unlisted"
    with pytest.raises(ModelHubError):
        asyncio.run(service.delete_agent_chain("claude", MODEL, {"force": True}))
    result = asyncio.run(service.delete_agent_chain("claude", MODEL, {"force": True, **refusal.value.data}))
    assert result["chain"]["route_origin"] == "automatic"
    assert result["chain"]["current"] == {"source_id": default.id, "model_id": MODEL}
    assert MODEL not in store.config.agents["claude"].routes


def test_default_membership_guards_generated_removal_without_rewriting_manual(tmp_path):
    first = _source("src_first001")
    second = _source("src_second001")
    config = _sparse_config(first, second)
    service, store, adapter = _service(tmp_path, config)
    asyncio.run(service.set_agent_sources("claude", {"order": [second.id, first.id]}))
    assert adapter.synced == []
    assert service.agent_chain("claude", MODEL)["chain"][0]["source_id"] == second.id
    with pytest.raises(ModelHubError) as refusal:
        asyncio.run(service.set_agent_sources("claude", {"order": [first.id]}))
    assert refusal.value.data["would_remove_hops"][0]["source_id"] == second.id
    assert refusal.value.data["would_interrupt"] == []
    asyncio.run(service.set_agent_sources("claude", {"order": [first.id], "force": True, **refusal.value.data}))
    asyncio.run(service.set_agent_chain("claude", MODEL, {"hops": [{"source_id": second.id, "model_id": "exact"}]}))
    original = store.config.agents["claude"].routes[MODEL].to_payload()
    asyncio.run(service.set_agent_sources("claude", {"order": []}))
    assert store.config.agents["claude"].routes[MODEL].to_payload() == original
    assert service.agent_chain("claude", MODEL)["current"] == {"source_id": second.id, "model_id": "exact"}


def test_engine_route_targets_are_deterministic_truthful_and_health_mode_independent(tmp_path):
    source = _source("src_first001", ("inventory-only",))
    config = _sparse_config(source)
    agent = config.agents["claude"]
    agent.models.append(ModelHubBackendModelConfig(id="claude-extra"))
    agent.routes["claude-extra"] = ModelHubRouteConfig(hops=(ModelHubRouteHopConfig(source.id, "unlisted"),))
    service, _, _ = _service(tmp_path, config)
    binding = service._bindings(config)[0]
    assert binding.model_ids == ("inventory-only",)
    assert binding.route_model_ids == (MODEL, "unlisted")
    agent.mode = "direct"
    source.state = ModelHubSourceStateConfig(
        status="needs_action", detail_key="models.source.needs_action.oauth_expired"
    )
    assert service._bindings(config) == [binding]
    source.models.clear()
    empty_inventory = service._bindings(config)[0]
    assert empty_inventory.model_ids == ()
    assert empty_inventory.route_model_ids == binding.route_model_ids
    assert source.models == []


@pytest.mark.parametrize(
    "protocol,section",
    [("anthropic", "claude-api-key"), ("openai_responses", "codex-api-key"), ("openai_chat", "openai-compatibility")],
)
def test_engine_compiler_registers_inventory_union_without_invented_reasoning(tmp_path, protocol, section):
    store = EngineStateStore(tmp_path / "engine")
    ref = store.store_api_key("fixture-key", vendor="custom", protocol=protocol, base_url="https://api.example/v1")
    binding = SourceBinding(
        source_id="src_first001",
        vendor="custom",
        protocol=protocol,
        base_url="https://api.example/v1",
        credential_ref=ref,
        allowed_origins=(),
        model_ids=("listed",),
        model_reasoning_efforts=(("listed", ("low", "high")),),
        route_model_ids=("listed", "unlisted"),
    )
    store.sync_sources([binding])
    record = store.list_sources()[0]
    assert record.model_ids == ("listed",)
    assert record.route_model_ids == ("listed", "unlisted")
    payload = {}
    _append_source(payload, record, store)
    assert payload[section][0]["models"] == [
        {"name": "listed", "alias": "listed", "display-name": "listed #0", "thinking": {"levels": ["high", "low"]}},
        {"name": "unlisted", "alias": "unlisted", "display-name": "unlisted #0"},
    ]
    store.sync_sources([replace(binding, model_ids=(), model_reasoning_efforts=())])
    assert store.list_sources()[0].model_ids == ()


def test_internal_engine_record_loads_old_shape_without_route_targets():
    record = SourceRecord(
        source_id="src_first001",
        vendor="custom",
        protocol="openai_chat",
        base_url="https://api.example/v1",
        credential_ref="cred_fixture",
        allowed_origins=(),
        model_ids=(),
        prefix="avibe-fixture",
    )
    payload = asdict(record)
    payload["model_ids"] = []
    payload["model_reasoning_efforts"] = []
    payload.pop("route_model_ids")
    assert SourceRecord.from_payload(payload).route_model_ids == ()


@pytest.mark.parametrize(
    "declaration",
    [
        'export type RouteOrigin = "automatic" | "manual" | "passthrough" | null;',
        "export type RouteOrigin =\n  | 'automatic'\n  | 'manual'\n  | 'passthrough'\n  | null;",
    ],
)
def test_authority_extractor_reads_exported_nullable_string_union(monkeypatch, declaration):
    source = AuthorityInput(Path.cwd())
    monkeypatch.setattr(source, "text", lambda _: declaration)
    assert _typescript_string_union(source, {"file": "fixture.ts", "name": "RouteOrigin"}) == {
        "automatic",
        "manual",
        "passthrough",
    }


@pytest.mark.parametrize(
    "declaration",
    [
        'type RouteOrigin = "manual";',
        'export type RouteOrigin = "manual" | string;',
        'export type RouteOrigin = "manual" |;',
        "export type RouteOrigin = null;",
    ],
)
def test_authority_extractor_rejects_missing_or_nonliteral_union(monkeypatch, declaration):
    source = AuthorityInput(Path.cwd())
    monkeypatch.setattr(source, "text", lambda _: declaration)
    with pytest.raises(ValueError):
        _typescript_string_union(source, {"file": "fixture.ts", "name": "RouteOrigin"})


def _loaded_catalog_config(backend, requested, *sources):
    config = ModelHubConfig(sources=list(sources))
    agent = config.agents[backend]
    agent.mode = "hub"
    agent.models = [
        ModelHubBackendModelConfig(
            id=requested,
            origin="manual",
            native_protocol="openai_responses" if backend == "opencode" else None,
        )
    ]
    agent.sources.order = [source.id for source in sources]
    return ModelHubConfig.from_payload(config.to_payload())


@pytest.mark.parametrize("backend", ["claude", "codex", "opencode"])
@pytest.mark.parametrize("matched", [False, True])
def test_empty_override_equals_absence_at_all_route_consumers(tmp_path, backend, matched):
    source = _source("src_inherit01", (MODEL,) if matched else ())
    config = _loaded_catalog_config(backend, MODEL, source)
    service, store, adapter = _service(tmp_path, config)
    expected = service.agent_chain(backend, MODEL)
    bindings = service._bindings(config)
    config.agents[backend].routes[MODEL] = ModelHubRouteConfig()
    assert service.agent_chain(backend, MODEL) == expected
    assert service._bindings(config) == bindings
    assert service.get_agent_sources(backend)["routes"] == {}
    for draft in (None, {"hops": []}):
        assert service.preview_agent_chain(backend, MODEL, {"manual_override": draft}) == expected
    assert adapter.synced == []
    payload = config.to_payload()
    assert payload["agents"][backend]["routes"] == {}
    payload["agents"][backend]["routes"][MODEL] = {"hops": []}
    loaded = ModelHubConfig.from_payload(payload)
    assert loaded.agents[backend].routes == {}
    assert effective_model_route(loaded, backend, MODEL).route_origin == ("automatic" if matched else "passthrough")
    saved = asyncio.run(service.set_agent_chain(backend, MODEL, {"hops": []}))
    assert saved["chain"] == expected
    assert store.config.agents[backend].routes == {}
    assert asyncio.run(service.delete_agent_chain(backend, MODEL)) == saved
    adapter.outcomes.append(RawCallOutcome(
        kind=RawOutcomeKind.SUCCESS, http_status=200, error_code=None, redacted_message=None,
        stream_started=False, source_id=source.id, model_id=MODEL,
    ))
    assert asyncio.run(service.probe_agent(backend, MODEL))["reachable"] is True
    assert adapter.invocations == [(source.id, MODEL)]


@pytest.mark.parametrize("backend", ["claude", "codex", "opencode"])
def test_empty_put_has_exact_restore_guard_and_final_hop_deletion_inherits(tmp_path, backend):
    default = _source("src_default01", (MODEL,))
    manual = _source("src_manual001", ("mapped",))
    config = _loaded_catalog_config(backend, MODEL, default)
    config.sources.append(manual)
    config.agents[backend].routes[MODEL] = ModelHubRouteConfig(
        hops=(ModelHubRouteHopConfig(manual.id, "mapped"),)
    )
    service, store, _ = _service(tmp_path, config)
    before = config.to_payload()
    with pytest.raises(ModelHubError) as restored:
        asyncio.run(service.delete_agent_chain(backend, MODEL))
    with pytest.raises(ModelHubError) as empty:
        asyncio.run(service.set_agent_chain(backend, MODEL, {"hops": []}))
    assert (empty.value.code, empty.value.data) == (restored.value.code, restored.value.data)
    assert empty.value.data["would_interrupt"] == []
    assert store.config.to_payload() == before
    with pytest.raises(ModelHubError) as deletion:
        asyncio.run(service.delete_source(manual.id))
    assert deletion.value.data["would_interrupt"] == []
    asyncio.run(service.delete_source(manual.id, force=True,
        confirmed_remove_hops=deletion.value.data["would_remove_hops"],
        confirmed_interruptions=deletion.value.data["would_interrupt"],
    ))
    assert store.config.agents[backend].routes == {}
    assert service.agent_chain(backend, MODEL)["current"] == {"source_id": default.id, "model_id": MODEL}
    assert service._bindings(store.config)[0].route_model_ids == (MODEL,)


@pytest.mark.parametrize("backend", ["claude", "codex", "opencode"])
@pytest.mark.parametrize("bad", [{}, {"hops": None}, {"hops": [], "unknown": True}, {"hops": [{}]}])
def test_invalid_empty_intent_is_validated_before_normalization(tmp_path, backend, bad):
    config = _loaded_catalog_config(backend, MODEL, _source("src_inherit01", (MODEL,)))
    raw = config.to_payload()
    raw["agents"][backend]["routes"][MODEL] = bad
    for repairing in (False, True):
        with pytest.raises(ValueError):
            ModelHubConfig.from_payload(raw, repairing=repairing)
    service, store, adapter = _service(tmp_path, config)
    with pytest.raises(ModelHubError):
        service.preview_agent_chain(backend, MODEL, {"manual_override": bad})
    with pytest.raises(ModelHubError):
        asyncio.run(service.set_agent_chain(backend, MODEL, bad))
    assert store.config.to_payload() == config.to_payload()
    assert adapter.synced == []


@pytest.mark.parametrize("backend", ["claude", "codex"])
def test_legacy_empty_key_keeps_derived_catalog_but_invalid_nonmenu_key_is_not_repaired(backend):
    config = _loaded_catalog_config(backend, MODEL)
    raw = config.to_payload()
    agent = raw["agents"][backend]
    agent["routes"] = {"legacy-empty-row": {"hops": []}}
    for repairing in (False, True):
        with pytest.raises(ValueError, match="non-menu"):
            ModelHubConfig.from_payload(raw, repairing=repairing)
    agent.pop("models")
    loaded = ModelHubConfig.from_payload(raw)
    assert "legacy-empty-row" in {model.id for model in loaded.agents[backend].models}
    assert loaded.agents[backend].routes == {}


@pytest.mark.parametrize("backend", ["claude", "codex", "opencode"])
@pytest.mark.parametrize("mode", ["hub", "direct"])
@pytest.mark.parametrize("operation", ["retire_discovered", "remove_subscription_manual", "refresh_subscription"])
def test_final_inventory_hop_removal_uses_inherited_guard_plan(tmp_path, backend, mode, operation):
    default = _source("src_default01", (MODEL,))
    manual = _source("src_manual001", ("mapped",), kind="api_key" if operation == "retire_discovered" else "subscription")
    if operation == "remove_subscription_manual":
        manual.models[0].provenance = "manual"
    config = _loaded_catalog_config(backend, MODEL, default)
    config.agents[backend].mode = mode
    config.sources.append(manual)
    config.agents[backend].routes[MODEL] = ModelHubRouteConfig(hops=(ModelHubRouteHopConfig(manual.id, "mapped"),))
    service, store, adapter = _service(tmp_path, config)
    adapter.discovered = ()

    def mutate(**kwargs):
        if operation == "refresh_subscription":
            return service.refresh_source(manual.id, **kwargs)
        return service.delete_custom_model(manual.id, "mapped", **kwargs)

    before = config.to_payload()
    with pytest.raises(ModelHubError) as refusal:
        asyncio.run(mutate())
    assert refusal.value.data["would_interrupt"] == []
    assert refusal.value.data["would_remove_hops"] == [{
        "backend": backend, "menu_model": MODEL, "source_id": manual.id, "model_id": "mapped", "position": 1,
    }]
    assert store.config.to_payload() == before
    result = asyncio.run(mutate(force=True,
        confirmed_remove_hops=refusal.value.data["would_remove_hops"],
        confirmed_interruptions=refusal.value.data["would_interrupt"],
    ))
    assert result["interrupted"] == []
    assert store.config.agents[backend].routes == {}
    assert _pairs(effective_model_route(store.config, backend, MODEL)) == [(default.id, MODEL)]
    if mode == "hub":
        assert service.agent_chain(backend, MODEL)["current"] == {"source_id": default.id, "model_id": MODEL}
        assert service._bindings(store.config)[0].route_model_ids == (MODEL,)


@pytest.mark.parametrize("backend", ["claude", "codex", "opencode"])
def test_normalization_preserves_nonempty_intent_and_other_config_through_refresh(tmp_path, backend):
    api = _source("src_preserve01", (MODEL,))
    retired = _source("src_preserve03", ("retired",))
    retired.models[0].retired = True
    subscription = _source("src_preserve02", ("known",), kind="subscription")
    config = _loaded_catalog_config(backend, MODEL, api, subscription)
    config.sources.append(retired)
    agent = config.agents[backend]
    shapes = {
        "exact": [(api.id, MODEL)],
        "unknown-long": [(api.id, "legacy-" + "x" * 256)],
        "retired": [(retired.id, "retired")],
        "subscription-stale": [(subscription.id, "stale")],
        "ordered": [(subscription.id, "known"), (api.id, "mapped")],
    }
    for name, pairs in shapes.items():
        agent.models.append(ModelHubBackendModelConfig(id=name, origin="manual", native_protocol="openai_responses" if backend == "opencode" else None))
        agent.routes[name] = ModelHubRouteConfig(hops=tuple(ModelHubRouteHopConfig(*pair) for pair in pairs))
    before = config.to_payload()
    before["agents"][backend]["routes"][MODEL] = {"hops": []}
    original = copy.deepcopy(before)
    loaded = ModelHubConfig.from_payload(before)
    assert before == original
    expected = copy.deepcopy(before)
    del expected["agents"][backend]["routes"][MODEL]
    if backend == "opencode":
        expected["agents"][backend]["menu"]["checked"] = [model.id for model in agent.models]
    assert loaded.to_payload() == expected
    service, store, adapter = _service(tmp_path, loaded)
    adapter.discovered = (MODEL,)
    asyncio.run(service.refresh_source(api.id))
    assert store.config.agents[backend].to_payload() == expected["agents"][backend]
    assert store.config.sources[1].to_payload() == expected["sources"][1]
    assert store.config.sources[0].credential_ref == api.credential_ref


def test_direct_dormant_empty_is_absent_from_route_and_guard_enumeration(tmp_path):
    source = _source("src_dormant01", (MODEL,))
    config = _loaded_catalog_config("opencode", MODEL, source)
    service, _, _ = _service(tmp_path, config)
    before = service.agent_chains("opencode")
    protected = service._protected_menu_models(config, "opencode")
    config.agents["opencode"].routes["dormant"] = ModelHubRouteConfig()
    assert service.agent_chains("opencode") == before
    assert service._protected_menu_models(config, "opencode") == protected


@pytest.mark.parametrize("backend", ["claude", "codex", "opencode"])
@pytest.mark.parametrize("restore", [False, True])
def test_failed_route_sync_rolls_back_canonical_intent_and_retry(tmp_path, backend, restore):
    source = _source("src_rollback1", ())
    config = _loaded_catalog_config(backend, MODEL, source)
    manual = {"hops": [{"source_id": source.id, "model_id": "mapped"}]}
    config.agents[backend].routes[MODEL] = ModelHubRouteConfig.from_payload(manual) if restore else ModelHubRouteConfig()
    service, store, adapter = _service(tmp_path, config)
    before = config.to_payload()
    payload = {"hops": []} if restore else manual
    if restore:
        with pytest.raises(ModelHubError) as refusal:
            asyncio.run(service.set_agent_chain(backend, MODEL, payload))
        payload = {**payload, "force": True, **refusal.value.data}
    original_sync = adapter.sync_sources
    failures = 1

    async def fail_once(bindings):
        nonlocal failures
        if failures:
            failures -= 1
            raise RuntimeError("synthetic sync failure")
        await original_sync(bindings)

    adapter.sync_sources = fail_once
    with pytest.raises(ModelHubError, match="engine_down"):
        asyncio.run(service.set_agent_chain(backend, MODEL, payload))
    assert store.config.to_payload() == before
    assert all(route.hops for route in store.config.agents[backend].routes.values())
    result = asyncio.run(service.set_agent_chain(backend, MODEL, payload))
    assert result["chain"]["manual_override"] == (None if restore else manual)
    assert all(route.hops for route in store.config.agents[backend].routes.values())
    assert adapter.synced[-1][0].route_model_ids == ((MODEL,) if restore else ("mapped",))


@pytest.mark.parametrize("backend", ["claude", "codex", "opencode"])
def test_empty_intent_follows_refresh_defaults_and_health_without_reseeding(tmp_path, backend):
    first = _source("src_refresh01", ())
    second = _source("src_refresh02", ())
    config = _loaded_catalog_config(backend, MODEL, first, second)
    config.agents[backend].routes[MODEL] = ModelHubRouteConfig()
    service, store, adapter = _service(tmp_path, config)
    assert service.agent_chain(backend, MODEL)["route_origin"] == "passthrough"
    adapter.discovered = (MODEL,)
    refreshed = asyncio.run(service.refresh_source(second.id))
    assert refreshed["removed_hops"] == refreshed["interrupted"] == []
    assert service.agent_chain(backend, MODEL)["route_origin"] == "automatic"
    bindings = service._bindings(store.config)
    store.config.sources[1].state = ModelHubSourceStateConfig(status="error", detail_key="models.source.error.unclassified")
    assert service.agent_chain(backend, MODEL)["route_origin"] == "automatic"
    assert service.agent_chain(backend, MODEL)["current"] is None
    assert service._bindings(store.config) == bindings
    with pytest.raises(ModelHubError) as defaults:
        asyncio.run(service.set_agent_sources(backend, {"order": [first.id]}))
    asyncio.run(service.set_agent_sources(backend, {"order": [first.id], "force": True, **defaults.value.data}))
    assert service.agent_chain(backend, MODEL)["route_origin"] == "passthrough"
    assert store.config.agents[backend].routes == {}


@pytest.mark.parametrize("backend", ["claude", "codex", "opencode"])
def test_inventory_refinement_still_guards_new_supply_loss(tmp_path, backend):
    fallback = _source("src_fallback1", ())
    known = _source("src_known0001", (), status="error")
    known.state.detail_key = "models.source.error.unclassified"
    config = _loaded_catalog_config(backend, MODEL, fallback, known)
    service, store, adapter = _service(tmp_path, config)
    updated = copy.deepcopy(config)
    updated.sources[1].models = [ModelHubModelConfig(id=MODEL, provenance="discovered")]
    before = config.to_payload()
    with pytest.raises(ModelHubError) as refusal:
        service._guard_inventory_mutation(
            config, updated, known.id, force=False,
            confirmed_remove_hops=None, confirmed_interruptions=None,
        )
    assert refusal.value.code == "source_last_supplier"
    assert refusal.value.data == {
        "would_remove_hops": [],
        "would_interrupt": [{"backend": backend, "model_id": MODEL, "agents": []}],
    }
    assert store.config.to_payload() == before
    assert adapter.synced == []


@pytest.mark.parametrize("backend", ["claude", "codex", "opencode"])
@pytest.mark.parametrize("mode", ["hub", "direct"])
def test_refresh_preserves_guard_for_disappearing_inventory_matches(tmp_path, backend, mode):
    first = _source("src_refresh01", (MODEL,))
    second = _source("src_refresh02", (MODEL,))
    config = _loaded_catalog_config(backend, MODEL, first, second)
    config.agents[backend].mode = mode
    service, store, adapter = _service(tmp_path, config)
    adapter.discovered = ()
    before = config.to_payload()
    with pytest.raises(ModelHubError) as refusal:
        asyncio.run(service.refresh_source(second.id))
    assert refusal.value.code == "source_model_in_route_chain"
    assert refusal.value.data == {
        "would_remove_hops": [{
            "backend": backend, "menu_model": MODEL, "source_id": second.id,
            "model_id": MODEL, "position": 2,
        }],
        "would_interrupt": [],
    }
    assert store.config.to_payload() == before
    assert adapter.synced == []
    result = asyncio.run(service.refresh_source(second.id, force=True,
        confirmed_remove_hops=refusal.value.data["would_remove_hops"],
        confirmed_interruptions=refusal.value.data["would_interrupt"],
    ))
    assert result["removed_hops"] == refusal.value.data["would_remove_hops"]
    assert result["interrupted"] == []


@pytest.mark.parametrize("backend", ["claude", "codex", "opencode"])
@pytest.mark.parametrize("state", ["automatic", "manual", "empty"])
@pytest.mark.parametrize("operation", ["put", "preview", "restore_preview", "restore_save"])
def test_persisted_legacy_catalog_identity_survives_route_consumers(tmp_path, backend, state, operation):
    requested = "legacy-" + "模型🧪/" * 3000
    source = _source("src_legacy001", (requested,))
    config = _loaded_catalog_config(backend, requested, source)
    route = {"hops": [] if state == "empty" else [{"source_id": source.id, "model_id": "mapped-target"}]}
    if state != "automatic":
        config.agents[backend].routes[requested] = ModelHubRouteConfig.from_payload(route)
    config = ModelHubConfig.from_payload(config.to_payload())
    service, store, adapter = _service(tmp_path, config)
    before = config.to_payload()
    if operation == "put":
        result = asyncio.run(service.set_agent_chain(backend, requested, route))["chain"]
        assert result["manual_override"] == (route if route["hops"] else None)
    elif operation == "preview":
        result = service.preview_agent_chain(backend, requested, {"manual_override": route})
        assert result["manual_override"] == (route if route["hops"] else None)
    elif operation == "restore_preview":
        result = service.preview_agent_chain(backend, requested, {"manual_override": None})
        assert result["route_origin"] == "automatic"
        assert result["current"] == {"source_id": source.id, "model_id": requested}
    else:
        if state == "manual":
            with pytest.raises(ModelHubError) as refusal:
                asyncio.run(service.delete_agent_chain(backend, requested))
            assert refusal.value.code == "source_in_route_chain"
            assert refusal.value.data["would_remove_hops"] == [
                {
                    "backend": backend,
                    "menu_model": requested,
                    "source_id": source.id,
                    "model_id": "mapped-target",
                    "position": 1,
                }
            ]
            assert store.config.to_payload() == before
            result = asyncio.run(
                service.delete_agent_chain(
                    backend,
                    requested,
                    {"force": True, **refusal.value.data},
                )
            )["chain"]
        else:
            result = asyncio.run(service.delete_agent_chain(backend, requested))["chain"]
        assert result["manual_override"] is None
        assert result["route_origin"] == "automatic"
        assert requested not in store.config.agents[backend].routes
    assert result["model_id"] == requested
    assert [model.id for model in store.config.agents[backend].models] == [requested]
    assert ModelHubConfig.from_payload(store.config.to_payload()).to_payload() == store.config.to_payload()
    if "preview" in operation:
        assert store.config.to_payload() == before
        assert adapter.synced == []


@pytest.mark.parametrize("backend", ["claude", "codex", "opencode"])
def test_persisted_unencodable_catalog_identity_still_loads(backend):
    identifier = "legacy\ud800"
    loaded = _loaded_catalog_config(backend, identifier)
    assert loaded.agents[backend].models[0].id == identifier
    assert ModelHubConfig.from_payload(loaded.to_payload()).to_payload() == loaded.to_payload()


@pytest.mark.parametrize("backend", ["claude", "codex", "opencode"])
@pytest.mark.parametrize("kind", ["api_key", "subscription"])
@pytest.mark.parametrize("evidence", ["override", "inventory"])
def test_existing_long_target_identity_can_be_saved_and_reordered(tmp_path, backend, kind, evidence):
    target = "legacy-target-" + "x" * 256
    source = _source("src_legacy001", (target,) if evidence == "inventory" else (), kind=kind)
    other = _source("src_legacy002", ("other",), kind=kind)
    config = _loaded_catalog_config(backend, MODEL, source, other)
    hops = [{"source_id": source.id, "model_id": target}, {"source_id": other.id, "model_id": "other"}]
    if evidence == "override":
        config.agents[backend].routes[MODEL] = ModelHubRouteConfig.from_payload({"hops": hops})
    config = ModelHubConfig.from_payload(config.to_payload())
    service, store, _adapter = _service(tmp_path, config)
    original_inventory = [source.to_payload()["models"] for source in config.sources]
    for desired in (hops, list(reversed(hops))):
        preview = service.preview_agent_chain(backend, MODEL, {"manual_override": {"hops": desired}})
        assert preview["manual_override"] == {"hops": desired}
        saved = asyncio.run(service.set_agent_chain(backend, MODEL, {"hops": desired}))["chain"]
        assert saved["manual_override"] == {"hops": desired}
        loaded = ModelHubConfig.from_payload(store.config.to_payload())
        assert loaded.agents[backend].routes[MODEL].to_payload() == {"hops": desired}
        assert [source.to_payload()["models"] for source in loaded.sources] == original_inventory


@pytest.mark.parametrize("backend", ["claude", "codex", "opencode"])
@pytest.mark.parametrize("kind", ["api_key", "subscription"])
@pytest.mark.parametrize("target_kind", ["new_long", "padded_known", "padded_long", "other_source_long", "unencodable"])
def test_new_target_admission_keeps_spelling_and_source_policy(tmp_path, backend, kind, target_kind):
    legacy = "legacy-" + "x" * 256
    source = _source("src_legacy001", ("known", legacy), kind=kind)
    other = _source("src_legacy002", (), kind=kind)
    config = _loaded_catalog_config(backend, MODEL, source, other)
    config.agents[backend].routes[MODEL] = ModelHubRouteConfig.from_payload(
        {
            "hops": [{"source_id": source.id, "model_id": legacy}],
        }
    )
    service, store, adapter = _service(tmp_path, ModelHubConfig.from_payload(config.to_payload()))
    target = {
        "new_long": "new-" + "x" * 256,
        "padded_known": " known ",
        "padded_long": f" {legacy} ",
        "other_source_long": legacy,
        "unencodable": "new-" + "x" * 17000 + "\ud800",
    }[target_kind]
    route = {"hops": [{"source_id": other.id if target_kind == "other_source_long" else source.id, "model_id": target}]}
    before = store.config.to_payload()
    if kind == "api_key" and target_kind in {"new_long", "other_source_long"}:
        assert service.preview_agent_chain(backend, MODEL, {"manual_override": route})["manual_override"] == route
        assert asyncio.run(service.set_agent_chain(backend, MODEL, route))["chain"]["manual_override"] == route
        assert ModelHubConfig.from_payload(store.config.to_payload()).to_payload() == store.config.to_payload()
        return
    with pytest.raises(ModelHubError):
        service.preview_agent_chain(backend, MODEL, {"manual_override": route})
    with pytest.raises(ModelHubError):
        asyncio.run(service.set_agent_chain(backend, MODEL, route))
    assert store.config.to_payload() == before
    assert adapter.synced == []


@pytest.mark.parametrize("backend", ["claude", "codex", "opencode"])
@pytest.mark.parametrize(
    "kind,existing,allowed",
    [
        ("api_key", False, False),
        ("api_key", True, False),
        ("subscription", False, False),
        ("subscription", True, True),
    ],
)
def test_legacy_target_retirement_keeps_existing_source_policy(tmp_path, backend, kind, existing, allowed):
    target = "retired-" + "x" * 256
    source = _source("src_legacy001", (target,), kind=kind)
    source.models[0].retired = True
    config = _loaded_catalog_config(backend, MODEL, source)
    route = {"hops": [{"source_id": source.id, "model_id": target}]}
    if existing:
        config.agents[backend].routes[MODEL] = ModelHubRouteConfig.from_payload(route)
    service, store, adapter = _service(tmp_path, ModelHubConfig.from_payload(config.to_payload()))
    before = store.config.to_payload()
    if allowed:
        preview = service.preview_agent_chain(backend, MODEL, {"manual_override": route})
        assert preview["chain"][0]["runnable"] is False
        assert asyncio.run(service.set_agent_chain(backend, MODEL, route))["chain"] == preview
    else:
        with pytest.raises(ModelHubError):
            service.preview_agent_chain(backend, MODEL, {"manual_override": route})
        with pytest.raises(ModelHubError):
            asyncio.run(service.set_agent_chain(backend, MODEL, route))
        assert store.config.to_payload() == before
        assert adapter.synced == []


@pytest.mark.parametrize(
    "state", ["unknown", "known", "retired", "empty", "subscription_known", "subscription_unknown"]
)
def test_retained_opencode_route_registration_matches_resolver_without_inventing_catalog(tmp_path, state):
    target, dormant, catalog = "dormant-target", "dormant-model", "catalog-model"
    inventory = (catalog, target) if state in {"known", "retired", "subscription_known"} else (catalog,)
    engine_store = EngineStateStore(tmp_path / "engine")
    credential = engine_store.store_api_key(
        "fixture-key", vendor="custom", protocol="openai_responses", base_url="https://api.example/v1"
    )
    source = _source("src_dormant01", inventory, vendor="custom", credential_ref=credential)
    source.base_url = "https://api.example/v1"
    if state.startswith("subscription"):
        source.kind, source.billing = "subscription", "monthly"
        source.vendor, source.base_url = "openai", None
    if state == "retired":
        source.models[-1].retired = True
    config = _loaded_catalog_config("opencode", catalog, source)
    config.agents["opencode"].routes[dormant] = ModelHubRouteConfig.from_payload(
        {
            "hops": [] if state == "empty" else [{"source_id": source.id, "model_id": target}],
        }
    )
    path = tmp_path / "persisted-model-hub.json"
    path.write_text(json.dumps(config.to_payload()))
    config = ModelHubConfig.from_payload(json.loads(path.read_text()))
    service, store, adapter = _service(tmp_path, config)
    before = config.to_payload()
    agent_before = before["agents"]["opencode"]
    plan = effective_model_route(config, "opencode", dormant)
    assert plan.route_origin == (None if state == "empty" else "manual")
    expected_targets = (
        ()
        if state.startswith("subscription")
        else tuple(sorted((catalog,) if state in {"retired", "empty"} else (catalog, target)))
    )
    binding = service._bindings(config)[0]
    assert binding.route_model_ids == expected_targets
    assert binding.model_ids == tuple(model.id for model in config.sources[0].models if not model.retired)
    assert {item["model_id"] for item in service.agent_chains("opencode")} == ({catalog} if state == "empty" else {catalog, dormant})
    if state != "empty":
        assert {"backend": "opencode", "menu_model": dormant} in service._adopted_by(source.id)
        assert any(item["menu_model"] == dormant for item in service._added_to(source.id))
        with pytest.raises(ModelHubError) as refusal:
            asyncio.run(service.delete_source(source.id))
        assert any(item["menu_model"] == dormant for item in refusal.value.data["would_remove_hops"])
        assert store.config.to_payload() == before
    if not state.startswith("subscription"):
        engine_store.sync_sources([binding])
        compiled = {}
        _append_source(compiled, engine_store.get_source(source.id), engine_store)
        compiled_models = compiled["codex-api-key"][0]["models"]
        assert {item["name"] for item in compiled_models} == set(binding.model_ids) | set(expected_targets)
        assert all(set(item) == {"name", "alias", "display-name"} for item in compiled_models)
    if state == "unknown":
        adapter.outcomes.append(
            RawCallOutcome(
                kind=RawOutcomeKind.SUCCESS,
                http_status=200,
                error_code=None,
                redacted_message=None,
                stream_started=False,
                source_id=source.id,
                model_id=target,
            )
        )
        probe = asyncio.run(service.probe_agent("opencode", dormant))
        assert probe["reachable"] is True
        assert adapter.invocations == [(source.id, target)]
        assert adapter.synced[-1][0].route_model_ids == expected_targets
    for mode in ("direct", "hub"):
        for health in ("standby", "error"):
            changed = ModelHubConfig.from_payload(before)
            changed.agents["opencode"].mode = mode
            changed.sources[0].state = ModelHubSourceStateConfig(status=health)
            assert service._bindings(changed)[0].route_model_ids == expected_targets
    loaded = ModelHubConfig.from_payload(store.config.to_payload())
    assert loaded.agents["opencode"].to_payload() == agent_before
    assert loaded.sources[0].to_payload()["models"] == before["sources"][0]["models"]
    assert dormant not in {model.id for model in loaded.agents["opencode"].models}
    assert loaded.agents["opencode"].menu.checked == [catalog]