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.

29.2 KB
Raw Blame
"""Save, inventory and explicitly selected model tests have independent results."""

import asyncio
import copy
from dataclasses import replace
from types import SimpleNamespace
from unittest.mock import AsyncMock

import pytest

from config.v2_config import ModelHubSourceStateConfig
from core.handlers.model_hub.adapter import DiscoveredModel, MODEL_PROTOCOLS, RawOutcomeKind, SourceBinding
from core.handlers.model_hub.classification import ResolutionDecision
from core.handlers.model_hub.service import ModelHubError
from core.handlers.model_hub import service as service_module
from tests.test_model_hub_api import FakeAdapter, FakeInvokeHandle, _service
from tests.test_model_hub_unverified import _draft


@pytest.mark.parametrize("protocol", MODEL_PROTOCOLS)
@pytest.mark.parametrize("listing", ["success", "empty", "invalid", "failed"])
def test_save_inventory_is_ordered_optional_and_never_authenticates(tmp_path, protocol, listing):
    service, store, adapter = _service(tmp_path)
    rows = {
        "success": (DiscoveredModel("z-model"), DiscoveredModel("a-model")),
        "empty": (),
        "invalid": (DiscoveredModel("duplicate"), DiscoveredModel("duplicate")),
        "failed": (),
    }[listing]
    adapter.discover_models = AsyncMock(
        return_value=rows,
        side_effect=ModelHubError("discovery_failed") if listing == "failed" else None,
    )
    adapter.observe_source = AsyncMock(side_effect=AssertionError("observation is not admission"))
    result = asyncio.run(service.create_source(_draft(protocol=protocol)))["source"]
    assert result["protocol"] == protocol
    assert result["verification_pending"]
    assert [model["id"] for model in result["models"]] == (
        ["z-model", "a-model"] if listing == "success" else []
    )
    assert len(store.config.sources) == 1
    adapter.discover_models.assert_awaited_once()
    adapter.observe_source.assert_not_awaited()


@pytest.mark.parametrize("protocol", MODEL_PROTOCOLS)
@pytest.mark.parametrize("kind", list(RawOutcomeKind))
def test_probe_invokes_selected_source_even_without_agent_routes_and_isolates_failure(tmp_path, protocol, kind):
    service, store, adapter = _service(tmp_path)

    async def scenario():
        result = (await service.create_source(_draft(protocol=protocol)))["source"]
        for agent in store.config.agents.values():
            if agent.backend != "vibey":
                agent.mode = "direct"
            agent.sources.order = []
        source_id = result["id"]
        model_id = result["models"][0]["id"]
        before = copy.deepcopy(store.config.to_payload())
        original = adapter.invoke

        async def invoke(*args, **kwargs):
            handle = await original(*args, **kwargs)
            return FakeInvokeHandle(replace(
                await handle.outcome(), kind=kind,
                http_status=200 if kind is RawOutcomeKind.SUCCESS else 401,
                error_code=None if kind is RawOutcomeKind.SUCCESS else "invalid_api_key",
            ))

        adapter.invoke = AsyncMock(side_effect=invoke)
        adapter.discover_models = AsyncMock(side_effect=AssertionError("no discovery during a test"))
        answer = await service.probe_source(source_id, {"model": model_id})
        assert answer["source_id"] == source_id
        assert answer["model_id"] == model_id
        assert answer["protocol"] == protocol
        assert answer["reachable"] is (kind is RawOutcomeKind.SUCCESS)
        assert (answer["error"] is None) is answer["reachable"]
        adapter.invoke.assert_awaited_once()
        args = adapter.invoke.call_args.args
        assert args[:2] == (source_id, model_id)
        assert args[2].protocol == protocol
        if protocol == "google":
            assert args[2] == {
                "contents": [{"role": "user", "parts": [{"text": "ping"}]}],
                "generationConfig": {"maxOutputTokens": 128},
            }
        else:
            assert args[2]["model"] == model_id
            budget_key = "max_output_tokens" if protocol == "openai_responses" else "max_tokens"
            assert args[2][budget_key] == 128
        assert args[3:] == (False, "opencode")
        adapter.discover_models.assert_not_awaited()
        after = store.config.to_payload()
        if answer["reachable"]:
            assert not store.config.sources[0].verification_pending
            before["sources"][0].pop("verification_pending", None)
            after["sources"][0].pop("verification_pending", None)
        assert before == after

    asyncio.run(scenario())


@pytest.mark.parametrize("case", ["success", "unverified_success", "failure", "newer_attempt", "older_attempt"])
def test_successful_test_lifts_cooldown_only_for_its_own_current_attempt(tmp_path, case):
    service, store, adapter = _service(tmp_path)

    async def scenario():
        source = (await service.create_source(_draft()))["source"]
        store.config.sources[0].state = ModelHubSourceStateConfig(
            status="cooldown", retry_at="2026-07-23T02:59:00+00:00",
            detail_key="models.source.cooldown.server_error",
        )
        # Inference admitted before the test and still in flight.
        older = service._reserve_settlement_generation(source["id"])
        original = adapter.invoke

        async def invoke(*args, **kwargs):
            handle = await original(*args, **kwargs)
            if case == "newer_attempt":
                # Inference admitted while the test was in flight owns the verdict.
                service._reserve_settlement_generation(source["id"])
            outcome = await handle.outcome()
            if case == "failure":
                outcome = replace(outcome, kind=RawOutcomeKind.HTTP_ERROR, http_status=500)
            return FakeInvokeHandle(replace(outcome, recovery_verified=case != "unverified_success"))

        adapter.invoke = AsyncMock(side_effect=invoke)
        await service.probe_source(source["id"], {"model": source["models"][0]["id"]})
        if case == "older_attempt":
            # The earlier attempt fails after the later test already succeeded.
            await service._settle_fallback_source(
                store.config.sources[0], ResolutionDecision("fallback", reason="server_error"),
                backend="claude", model_id=source["models"][0]["id"], settlement_generation=older,
            )
        state = store.config.sources[0].state
        recovered = [event for event in service.events.list() if event["kind"] == "recover"]
        if case in {"success", "older_attempt"}:
            assert state == ModelHubSourceStateConfig(status="standby")
            assert [(event["agent"], event["to_source"]) for event in recovered] == [("system", source["id"])]
        else:
            assert state.status == "cooldown"
            assert state.detail_key == "models.source.cooldown.server_error"
            assert recovered == []

    asyncio.run(scenario())


@pytest.mark.parametrize("change", ["delete", "replace", "same_handle"])
def test_test_settlement_cannot_verify_a_different_credential_identity(tmp_path, change):
    class ConcurrentAdapter(FakeAdapter):
        async def invoke(self, *args, **kwargs):
            handle = await super().invoke(*args, **kwargs)
            if change == "delete":
                store.config.sources.clear()
            else:
                current = store.config.sources[0]
                if change == "replace":
                    current.credential_ref = "cred_replacement"
                service._mark_source_unverified(current)
            return handle

    service, store, _ = _service(tmp_path, ConcurrentAdapter())

    async def scenario():
        source = (await service.create_source(_draft()))["source"]
        answer = await service.probe_source(source["id"], {"model": source["models"][0]["id"]})
        assert answer["reachable"]
        if change == "delete":
            assert not store.config.sources
        else:
            assert store.config.sources[0].verification_pending

    asyncio.run(scenario())


@pytest.mark.parametrize("payload", [{}, {"model": None}, {"model": "missing"}, {"model": "x", "key": "ignored"}])
def test_probe_refuses_invalid_or_unknown_selection_before_runtime_work(tmp_path, payload):
    service, _, adapter = _service(tmp_path)
    source = asyncio.run(service.create_source(_draft()))["source"]
    adapter.invoke = AsyncMock()
    before = adapter.start_calls
    with pytest.raises(ModelHubError):
        asyncio.run(service.probe_source(source["id"], payload))
    assert adapter.start_calls == before
    adapter.invoke.assert_not_awaited()


@pytest.mark.parametrize("protocol", MODEL_PROTOCOLS)
@pytest.mark.parametrize("model_id", ["fixture:free", "../fixture", "/fixture"])
@pytest.mark.parametrize("selection", ["initial", "reconciled"])
def test_saved_source_probe_checks_google_path_before_engine_and_at_admission(
    tmp_path, protocol, model_id, selection,
):
    """A saved-model test must not turn a known local limitation into upstream evidence.

    The protocol-only probe table missed special model identities and a Source
    changing while engine preparation yields the mutation lock.
    """
    service, store, adapter = _service(tmp_path)

    async def scenario():
        adapter.discover_models = AsyncMock(return_value=(DiscoveredModel(model_id),))
        saved = (await service.create_source(_draft(
            protocol=protocol if selection == "initial" else "openai_chat",
        )))["source"]
        store.config.sources[0].state = ModelHubSourceStateConfig(
            status="cooldown", retry_at="2026-07-23T02:59:00+00:00",
            detail_key="models.source.cooldown.server_error",
        )
        before = copy.deepcopy(store.config.to_payload())
        generation = service._next_settlement_generation
        events = service.events.list()
        original_prepare = service._prepare_engine_for_demand

        async def prepare():
            nonlocal before
            await original_prepare()
            if selection == "reconciled":
                # The saved Source is reloaded after demand preparation; the
                # request must use and check that current protocol snapshot.
                async with service._mutation_lock:
                    changed = copy.deepcopy(store.config)
                    changed.sources[0].protocol = protocol
                    store.save(changed)
                    before = copy.deepcopy(store.config.to_payload())

        service._prepare_engine_for_demand = AsyncMock(side_effect=prepare)
        adapter.invoke = AsyncMock(wraps=adapter.invoke)
        service._meter_call = AsyncMock(wraps=service._meter_call)
        service._verify_successful_source = AsyncMock(wraps=service._verify_successful_source)
        service._record_recovery_success = AsyncMock(wraps=service._record_recovery_success)
        if protocol == "google" and ":" in model_id:
            with pytest.raises(ModelHubError) as refused:
                await service.probe_source(saved["id"], {"model": model_id})
            assert refused.value.code == "google_model_path_unsupported"
            assert refused.value.status == 422
            assert refused.value.origin is None
            adapter.invoke.assert_not_awaited()
            service._meter_call.assert_not_awaited()
            service._verify_successful_source.assert_not_awaited()
            service._record_recovery_success.assert_not_awaited()
            assert store.config.to_payload() == before
            assert service._next_settlement_generation == generation
            assert service.events.list() == events
            assert service._prepare_engine_for_demand.await_count == (selection == "reconciled")
        else:
            answer = await service.probe_source(saved["id"], {"model": model_id})
            assert answer["reachable"]
            assert answer["protocol"] == protocol
            assert answer["model_id"] == model_id
            adapter.invoke.assert_awaited_once()
            assert adapter.invoke.call_args.args[1] == model_id
            assert adapter.invoke.call_args.args[2].protocol == protocol
            service._prepare_engine_for_demand.assert_awaited_once()
        assert not service._mutation_lock.locked()

    asyncio.run(scenario())


def test_manual_model_addition_never_calls_upstream_discovery(tmp_path):
    service, store, adapter = _service(tmp_path)
    source = asyncio.run(service.create_source(_draft()))["source"]
    adapter.discover_models = AsyncMock(side_effect=AssertionError("manual means local inventory"))
    adapter.observe_source = AsyncMock(side_effect=AssertionError("manual means no detection"))
    before = copy.deepcopy(store.config.sources[0].models)
    result = asyncio.run(service.add_custom_model(source["id"], {
        "model_id": "manual-example", "reasoning_efforts": [],
    }))
    assert result["models"][-1]["id"] == "manual-example"
    assert store.config.sources[0].models[:-1] == before
    adapter.discover_models.assert_not_awaited()
    adapter.observe_source.assert_not_awaited()


@pytest.mark.parametrize("listing", ["empty", "invalid", "timeout"])
def test_optional_discovery_preserves_manual_inventory(tmp_path, listing):
    service, _, adapter = _service(tmp_path)
    adapter.discover_models = AsyncMock(
        return_value=(DiscoveredModel("duplicate"),) * 2 if listing == "invalid" else (),
        side_effect=TimeoutError if listing == "timeout" else None,
    )
    draft = _draft()
    draft["models"] = [{"id": "manual-model", "origin": "manual", "reasoning_efforts": []}]
    source = asyncio.run(service.create_source(draft))["source"]
    assert [(model["id"], model["origin"]) for model in source["models"]] == [("manual-model", "manual")]
    assert source["verification_pending"]


@pytest.mark.parametrize("protocol", MODEL_PROTOCOLS)
def test_source_probe_crosses_real_adapter_and_http_transport(tmp_path, protocol):
    from aiohttp import web

    from core.handlers.model_hub.rpc import dispatch_model_hub_rpc
    from tests.test_model_hub_transport_leases import LeaseSupervisor
    from vibe.model_hub_runtime.adapter import CLIProxyEngineAdapter
    from vibe.model_hub_runtime.state import EngineStateStore

    async def scenario():
        requests = []

        async def handler(request):
            body = await request.json()
            requests.append((request.path, body))
            if protocol == "google":
                return web.json_response({
                    "candidates": [{"content": {"parts": [{"text": "pong"}]}, "finishReason": "STOP"}],
                    "usageMetadata": {"promptTokenCount": 2, "candidatesTokenCount": 1},
                })
            return web.json_response({
                "choices": [{"message": {"content": "pong"}, "finish_reason": "stop"}],
                "content": [{"type": "text", "text": "pong"}],
                "output": [{"type": "message", "content": [{"type": "output_text", "text": "pong"}]}],
                "usage": {"input_tokens": 2, "output_tokens": 1, "prompt_tokens": 2, "completion_tokens": 1},
            })

        app = web.Application()
        app.router.add_post("/{path:.*}", handler)
        runner = web.AppRunner(app)
        await runner.setup()
        site = web.TCPSite(runner, "127.0.0.1", 0)
        await site.start()
        try:
            origin = f"http://127.0.0.1:{site._server.sockets[0].getsockname()[1]}"
            service, store, adapter = _service(tmp_path)
            source = (await service.create_source(_draft(protocol=protocol)))["source"]
            model_id = source["models"][0]["id"]
            runtime_store = EngineStateStore(tmp_path / "engine")
            ref = runtime_store.store_api_key("fixture-key", protocol=protocol, base_url=source["base_url"])
            binding = SourceBinding(
                source_id=source["id"], vendor="custom", protocol=protocol,
                base_url=source["base_url"], credential_ref=ref, allowed_origins=(), model_ids=(model_id,),
            )
            runtime_store.sync_sources([binding])
            transport = CLIProxyEngineAdapter(supervisor=LeaseSupervisor(origin), state_store=runtime_store)
            adapter.invoke = transport.invoke
            service._meter_call = AsyncMock()
            answer = await dispatch_model_hub_rpc(service, "probe_source", {
                "source_id": source["id"], "probe": {"model": model_id},
            })
            assert answer["reachable"]
            assert len(requests) == 1
            path, body = requests[0]
            routed_model = f"{runtime_store.get_source(source['id']).prefix}/{model_id}"
            if protocol == "google":
                assert path == f"/v1beta/models/{routed_model}:generateContent"
                assert body == {
                    "contents": [{"role": "user", "parts": [{"text": "ping"}]}],
                    "generationConfig": {"maxOutputTokens": 128},
                }
            else:
                assert path == {"anthropic": "/v1/messages", "openai_chat": "/v1/chat/completions", "openai_responses": "/v1/responses"}[protocol]
                assert body["model"] == routed_model
                assert body["stream"] is False
            assert transport._active_transports == 0
            assert not store.config.sources[0].verification_pending
            service._meter_call.assert_awaited_once()
            assert service._meter_call.call_args.kwargs["outcome"].usage is not None
        finally:
            await runner.cleanup()

    asyncio.run(scenario())


@pytest.mark.parametrize("termination", ["cancel", "timeout"])
def test_probe_termination_closes_handle_and_releases_mutation_owner(tmp_path, monkeypatch, termination):
    service, store, adapter = _service(tmp_path)

    async def scenario():
        source = (await service.create_source(_draft()))["source"]
        entered = asyncio.Event()
        original = adapter.invoke
        handle_closed = AsyncMock()

        async def invoke(*args, **kwargs):
            handle = await original(*args, **kwargs)

            async def pending_outcome():
                entered.set()
                await asyncio.Event().wait()

            handle.outcome = pending_outcome
            handle.close_stream = handle_closed
            return handle

        adapter.invoke = invoke
        service._meter_call = AsyncMock()
        if termination == "timeout":
            monkeypatch.setattr(service_module, "_SOURCE_PROBE_TIMEOUT_SECONDS", 0.02)
        task = asyncio.create_task(service.probe_source(source["id"], {"model": source["models"][0]["id"]}))
        await entered.wait()
        if termination == "cancel":
            task.cancel()
            with pytest.raises(asyncio.CancelledError):
                await task
        else:
            answer = await task
            assert not answer["reachable"]
            assert answer["error"] == "models.source.cooldown.timeout"
        assert not service._mutation_lock.locked()
        assert store.config.sources[0].verification_pending
        handle_closed.assert_awaited_once()
        service._meter_call.assert_awaited_once()

    asyncio.run(scenario())


@pytest.mark.parametrize("phase", ["selection_lock", "preparation", "transport"])
def test_pre_admission_timeout_is_a_request_failure_not_a_model_result(tmp_path, monkeypatch, phase):
    service, store, adapter = _service(tmp_path)

    async def scenario():
        source = (await service.create_source(_draft()))["source"]
        before = copy.deepcopy(store.config.to_payload())
        monkeypatch.setattr(service_module, "_SOURCE_PROBE_TIMEOUT_SECONDS", 0.02)
        service._meter_call = AsyncMock()

        async def stalled(*args, **kwargs):
            await asyncio.Event().wait()

        if phase == "selection_lock":
            await service._mutation_lock.acquire()
        elif phase == "preparation":
            service._prepare_engine_for_demand = stalled
        else:
            adapter.invoke = stalled
        try:
            with pytest.raises(ModelHubError) as error:
                await service.probe_source(source["id"], {"model": source["models"][0]["id"]})
            assert error.value.code == "engine_down"
            assert error.value.status == 503
            assert service._mutation_lock.locked() is (phase == "selection_lock")
            assert store.config.to_payload() == before
            service._meter_call.assert_not_awaited()
        finally:
            if phase == "selection_lock":
                service._mutation_lock.release()

    asyncio.run(scenario())


@pytest.mark.parametrize("phase", ["verification", "close", "meter"])
@pytest.mark.parametrize("change", ["unchanged", "delete", "replace", "same_handle"])
def test_known_success_settles_once_despite_cancellation(tmp_path, phase, change):
    service, store, adapter = _service(tmp_path)

    async def scenario():
        source = (await service.create_source(_draft()))["source"]
        entered, release = asyncio.Event(), asyncio.Event()
        original_invoke, original_verify = adapter.invoke, service._verify_successful_source
        steps = []

        async def barrier(step):
            steps.append(step)
            if step == phase:
                entered.set()
                await release.wait()

        async def verify(*args):
            await barrier("verification")
            await original_verify(*args)

        async def close():
            await barrier("close")

        async def meter(**kwargs):
            await barrier("meter")

        async def invoke(*args, **kwargs):
            handle = await original_invoke(*args, **kwargs)
            handle.close_stream = AsyncMock(side_effect=close)
            return handle

        adapter.invoke = AsyncMock(side_effect=invoke)
        service._verify_successful_source = AsyncMock(side_effect=verify)
        service._meter_call = AsyncMock(side_effect=meter)
        task = asyncio.create_task(service.probe_source(source["id"], {"model": source["models"][0]["id"]}))
        await asyncio.wait_for(entered.wait(), timeout=1)
        current = store.config.sources[0]
        if change == "delete":
            store.config.sources.clear()
        elif change != "unchanged":
            if change == "replace":
                current.credential_ref = "cred_replacement"
            service._mark_source_unverified(current)
        pending = current.verification_pending
        task.cancel()
        await asyncio.sleep(0)
        task.cancel()
        await asyncio.sleep(0)
        still_settling = not task.done()
        release.set()
        with pytest.raises(asyncio.CancelledError):
            await asyncio.wait_for(task, timeout=1)
        assert still_settling
        assert steps == ["verification", "close", "meter"]
        adapter.invoke.assert_awaited_once()
        service._verify_successful_source.assert_awaited_once()
        service._meter_call.assert_awaited_once()
        assert service._meter_call.call_args.kwargs["outcome"].kind is RawOutcomeKind.SUCCESS
        assert not service._mutation_lock.locked()
        if change == "delete":
            assert not store.config.sources
        elif change == "unchanged":
            assert store.config.sources[0].verification_pending is None
        else:
            assert store.config.sources[0].verification_pending == pending
            assert pending is not None

    asyncio.run(scenario())


def test_unadmitted_engine_handle_is_not_presented_as_a_model_failure(tmp_path):
    service, store, adapter = _service(tmp_path)

    async def scenario():
        source = (await service.create_source(_draft()))["source"]
        original = adapter.invoke
        closed = AsyncMock()

        async def unavailable(*args, **kwargs):
            kwargs.pop("on_admitted")
            handle = await original(*args, **kwargs)
            result = FakeInvokeHandle(replace(
                await handle.outcome(), kind=RawOutcomeKind.NETWORK_ERROR,
                http_status=None, error_code="engine_down",
            ))
            result.close_stream = closed
            return result

        adapter.invoke = unavailable
        with pytest.raises(ModelHubError) as error:
            await service.probe_source(source["id"], {"model": source["models"][0]["id"]})
        assert error.value.code == "engine_down"
        assert not service._mutation_lock.locked()
        assert store.config.sources[0].verification_pending
        closed.assert_awaited_once()

    asyncio.run(scenario())


def test_admitted_timeout_is_a_model_result_even_before_handle_delivery(tmp_path, monkeypatch):
    service, store, adapter = _service(tmp_path)

    async def scenario():
        source = (await service.create_source(_draft()))["source"]

        async def admitted_then_stalled(*args, on_admitted, **kwargs):
            on_admitted()
            await asyncio.Event().wait()

        adapter.invoke = admitted_then_stalled
        monkeypatch.setattr(service_module, "_SOURCE_PROBE_TIMEOUT_SECONDS", 0.02)
        answer = await service.probe_source(source["id"], {"model": source["models"][0]["id"]})
        assert not answer["reachable"]
        assert answer["error"] == "models.source.cooldown.timeout"
        assert store.config.sources[0].verification_pending
        assert not service._mutation_lock.locked()

    asyncio.run(scenario())


def test_probe_latency_excludes_local_preparation_acquisition_and_settlement(tmp_path, monkeypatch):
    service, _, adapter = _service(tmp_path)

    async def scenario():
        source = (await service.create_source(_draft()))["source"]
        clock = SimpleNamespace(now=0.0)
        monkeypatch.setattr(service_module, "time", SimpleNamespace(monotonic=lambda: clock.now))
        prepare, invoke, verify = service._prepare_engine_for_demand, adapter.invoke, service._verify_successful_source

        async def prepare_slowly():
            clock.now += 20
            await prepare()

        async def invoke_after_acquisition(*args, **kwargs):
            clock.now += 30
            handle = await invoke(*args, **kwargs)
            outcome = await handle.outcome()

            async def respond():
                clock.now += 0.125
                return outcome

            async def close():
                clock.now += 40

            handle.outcome, handle.close_stream = respond, close
            return handle

        async def meter_slowly(**kwargs):
            clock.now += 50

        async def verify_slowly(*args):
            clock.now += 60
            await verify(*args)

        service._prepare_engine_for_demand = prepare_slowly
        adapter.invoke = invoke_after_acquisition
        service._meter_call = meter_slowly
        service._verify_successful_source = verify_slowly
        answer = await service.probe_source(source["id"], {"model": source["models"][0]["id"]})
        assert answer["reachable"]
        assert answer["latency_ms"] == 125
        assert clock.now == 200.125

    asyncio.run(scenario())


@pytest.mark.parametrize("status,code", [(401, None), (400, "invalid_api_key")])
@pytest.mark.parametrize("stream_started", [False, True])
def test_key_rejection_has_credential_copy_without_refresh_or_health_changes(tmp_path, status, code, stream_started):
    service, store, adapter = _service(tmp_path)

    async def scenario():
        source = (await service.create_source(_draft()))["source"]
        before = copy.deepcopy(store.config.to_payload())
        original = adapter.invoke

        async def rejected(*args, **kwargs):
            handle = await original(*args, **kwargs)
            return FakeInvokeHandle(replace(
                await handle.outcome(), kind=RawOutcomeKind.HTTP_ERROR,
                http_status=status, error_code=code, stream_started=stream_started,
            ))

        adapter.invoke = AsyncMock(side_effect=rejected)
        adapter.credential_supports_refresh = AsyncMock(side_effect=AssertionError("test never refreshes"))
        answer = await service.probe_source(source["id"], {"model": source["models"][0]["id"]})
        assert not answer["reachable"]
        assert answer["error"] == "models.source.needs_action.credential_revoked"
        adapter.invoke.assert_awaited_once()
        adapter.credential_supports_refresh.assert_not_awaited()
        assert store.config.to_payload() == before

    asyncio.run(scenario())


def test_save_and_model_probe_work_without_python311_timeout_context(tmp_path, monkeypatch):
    service, _, _ = _service(tmp_path)
    monkeypatch.delattr(asyncio, "timeout", raising=False)

    async def scenario():
        source = (await service.create_source(_draft()))["source"]
        result = await service.probe_source(source["id"], {"model": source["models"][0]["id"]})
        assert result["reachable"]

    asyncio.run(scenario())


def test_discovery_deadline_saves_manual_inventory_and_drains_cancelled_work(tmp_path, monkeypatch):
    service, _, adapter = _service(tmp_path)

    async def scenario():
        cancelled = asyncio.Event()

        async def stalled(*args, **_kwargs):
            try:
                await asyncio.Event().wait()
            finally:
                cancelled.set()

        adapter.discover_models = stalled
        monkeypatch.setattr(service_module, "_SOURCE_DISCOVERY_TIMEOUT_SECONDS", 0.02)
        draft = _draft()
        draft["models"] = [{"id": "manual-model", "origin": "manual", "reasoning_efforts": []}]
        source = (await service.create_source(draft))["source"]
        assert cancelled.is_set()
        assert [model["id"] for model in source["models"]] == ["manual-model"]
        assert source["verification_pending"]

    asyncio.run(scenario())