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.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
"""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())