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
from __future__ import annotations
import asyncio
import json
import threading
from types import SimpleNamespace
from unittest.mock import AsyncMock, Mock
import pytest
from config.v2_config import V2Config
from core.controller import Controller
from core.handlers.model_hub.provenance import BoundedProvenanceStore, TurnCorrelationRegistry
from modules.agents.model_hub import resolve_model_hub_launch, resolve_opencode_overlay_launch
def test_controller_leaves_model_hub_aggregate_absent_when_explicitly_disabled(monkeypatch):
import core.handlers.model_hub as model_hub
import vibe.model_hub_runtime as model_hub_runtime
factory_calls = 0
adapter = object()
def create_service():
nonlocal factory_calls
factory_calls += 1
return object()
monkeypatch.setenv("VIBE_MODEL_HUB_ENABLED", "0")
monkeypatch.setattr(model_hub, "create_default_service", create_service)
monkeypatch.setattr(
model_hub_runtime,
"get_model_hub_engine_adapter",
lambda: adapter,
)
controller = Controller.__new__(Controller)
controller._init_model_hub()
assert controller.model_hub_service is None
assert controller.model_hub_turn_gateway is None
assert controller.model_hub_runtime is None
assert controller.model_hub_engine_adapter is adapter
assert factory_calls == 0
@pytest.mark.parametrize("env_value", [None, "1"])
def test_controller_builds_one_model_hub_aggregate_by_default_or_explicit_enable(monkeypatch, tmp_path, env_value):
import core.handlers.model_hub as model_hub
import core.handlers.model_hub.turn_gateway as turn_gateway
import modules.agents.model_hub as agent_model_hub
import vibe.model_hub_runtime as model_hub_runtime
from vibe import api, backend_model_catalog, models_dev_catalog
service = SimpleNamespace(
reconcile_builtin_models=AsyncMock(return_value=[]),
backfill_models_dev_limits=AsyncMock(return_value=[]),
)
calls = []
class Gateway:
def __init__(self, value, *, language_provider):
calls.append(("gateway", value, language_provider))
self.service = value
self.language_provider = language_provider
self.correlation = TurnCorrelationRegistry(
BoundedProvenanceStore(tmp_path / "provenance.json"),
)
class Router:
def __init__(self, *, service, turn_gateway):
calls.append(("router", service, turn_gateway))
self.service = service
self.turn_gateway = turn_gateway
if env_value is None:
monkeypatch.delenv("VIBE_MODEL_HUB_ENABLED", raising=False)
else:
monkeypatch.setenv("VIBE_MODEL_HUB_ENABLED", env_value)
adapter = object()
captured = {}
def create_service(**kwargs):
captured.update(kwargs)
return service
monkeypatch.setattr(model_hub, "create_default_service", create_service)
monkeypatch.setattr(
model_hub_runtime,
"get_model_hub_engine_adapter",
lambda: adapter,
)
monkeypatch.setattr(turn_gateway, "ModelHubTurnGateway", Gateway)
monkeypatch.setattr(agent_model_hub, "ModelHubRuntimeRouter", Router)
refresh_callbacks = []
monkeypatch.setattr(
backend_model_catalog,
"set_remote_catalog_refresh_completed",
refresh_callbacks.append,
)
arrival_callbacks = []
monkeypatch.setattr(
models_dev_catalog,
"set_models_dev_copy_arrived",
arrival_callbacks.append,
)
presence_probes = []
probe_failure = [False]
block_full_probe = [False]
opencode_present = [False]
full_probe_started = threading.Event()
full_probe_release = threading.Event()
def resolve_cli_paths(binaries, *, include_npm_global=True):
presence_probes.append((binaries, include_npm_global))
if probe_failure[0]:
raise OSError("CLI inventory unavailable")
result = {
binary: f"/usr/bin/{binary}" if binary == "codex" else None
for binary in binaries
}
if "opencode" in result and opencode_present[0]:
result["opencode"] = "/usr/bin/opencode"
if block_full_probe[0] and len(binaries) > 1:
full_probe_started.set()
full_probe_release.wait(timeout=2)
return result
monkeypatch.setattr(api, "resolve_cli_paths", resolve_cli_paths)
controller = Controller.__new__(Controller)
controller.config = SimpleNamespace(language="zh")
controller._loop = None
controller._shutdown_requested = False
controller.vibe_agent_store = SimpleNamespace(
get_default_agent=lambda: SimpleNamespace(
backend="codex",
model="agent-model",
)
)
controller._init_model_hub()
assert controller.model_hub_service is service
assert controller.model_hub_turn_gateway.service is service
assert controller.model_hub_runtime.service is service
assert controller.model_hub_runtime.turn_gateway is controller.model_hub_turn_gateway
assert captured["adapter"] is adapter
assert captured["requested_model_override"]("codex") == "agent-model"
assert captured["requested_model_override"]("claude") is None
assert captured["cli_present_override"]("codex") is True
assert captured["cli_present_override"]("claude") is False
service.reconcile_builtin_models.assert_awaited_once_with(notify=False)
assert refresh_callbacks == [controller._model_hub_snapshot_refresh_completed]
# MH-LIMITS-001: a models.dev copy landing takes the same refresh path.
assert arrival_callbacks == [controller._model_hub_snapshot_refresh_completed]
assert presence_probes == [(["claude", "codex", "opencode"], False)]
probe_failure[0] = True
captured["cli_presence_refresh"](True, ("opencode",))
assert captured["cli_present_override"]("codex") is True
assert presence_probes[-1] == (["opencode"], True)
probe_failure[0] = False
block_full_probe[0] = True
full_refresh = threading.Thread(
target=captured["cli_presence_refresh"],
args=(True, None),
)
full_refresh.start()
assert full_probe_started.wait(timeout=0.5)
opencode_present[0] = True
captured["cli_presence_refresh"](True, ("opencode",))
full_probe_release.set()
full_refresh.join(timeout=0.5)
assert not full_refresh.is_alive()
assert captured["cli_present_override"]("opencode") is True
assert controller.model_hub_turn_gateway.language_provider() == "zh"
assert calls == [
("gateway", service, controller.model_hub_turn_gateway.language_provider),
("router", service, controller.model_hub_turn_gateway),
]
# Exercise the initializer's real callback binding, not a second test-only
# binding: one registry publishes material changes for its live Session.
registry = controller.model_hub_turn_gateway.correlation
assert callable(registry.on_recovery_changed)
token = registry.credentials("codex", "fixture-controller", "turn-live")
registry.begin_gateway_request(
backend="codex", token=token, requested_model_id="agent-model",
)
controller.session_turns = SimpleNamespace(in_flight={
"ses-live": SimpleNamespace(
task=SimpleNamespace(done=lambda: False),
context=SimpleNamespace(platform_specific={"turn_token": "turn-live"}),
),
"ses-peer": SimpleNamespace(
task=SimpleNamespace(done=lambda: False),
context=SimpleNamespace(platform_specific={"turn_token": "turn-peer"}),
),
})
publish = Mock()
monkeypatch.setattr("core.inbox_events.bus.publish", publish)
progress = {
"phase": "waiting", "attempt_count": 1, "source_id": "src_recovery01",
"reason": "network", "started_at": "2026-09-09T00:00:00+00:00",
"next_eligible_at": "2026-09-09T00:00:01+00:00",
"window_end": "2026-09-09T00:02:00+00:00",
}
registry.update_recovery("turn-live", backend="codex", request_id="one", snapshot=progress)
registry.update_recovery("turn-live", backend="codex", request_id="one", snapshot=dict(progress))
publish.assert_called_once_with(
"session.activity", {"session_id": "ses-live", "event": "model_recovery"},
)
assert registry.recovery_snapshot("turn-live") == [{**progress, "request_id": "one"}]
publish.reset_mock()
registry.update_recovery("turn-live", backend="codex", request_id="one", snapshot=None)
publish.assert_called_once_with(
"session.activity", {"session_id": "ses-live", "event": "model_recovery"},
)
assert registry.recovery_snapshot("turn-live") == []
assert not registry.store.path.exists()
refresh_callbacks[0]()
async def drain_refresh() -> None:
controller._loop = asyncio.get_running_loop()
controller._schedule_model_hub_snapshot_reconcile()
await controller._model_hub_snapshot_reconcile_task
asyncio.run(drain_refresh())
assert service.reconcile_builtin_models.await_count == 2
service.backfill_models_dev_limits.assert_awaited_once_with()
# A catalog change moves each runtime at its next turn: the agent adopts
# the committed catalog, and nothing restarts.
controller.backend_restart_coordinator = SimpleNamespace(request_restart=AsyncMock())
codex = SimpleNamespace(adopt_model_hub_catalog=AsyncMock())
controller.agent_service = SimpleNamespace(agents={"codex": codex})
asyncio.run(captured["backend_catalog_changed"]("codex"))
asyncio.run(captured["backend_catalog_changed"]("opencode"))
# Model Hub's config is read through model_hub_runtime; the app config carries none of it.
assert not hasattr(controller.config, "model_hub")
codex.adopt_model_hub_catalog.assert_awaited_once_with()
controller.backend_restart_coordinator.request_restart.assert_not_awaited()
@pytest.mark.anyio
async def test_controller_periodic_tick_reconciles_cross_process_snapshot_changes():
reconciled = asyncio.Event()
async def reconcile_builtin_models():
reconciled.set()
return []
controller = Controller.__new__(Controller)
controller.model_hub_service = SimpleNamespace(
reconcile_builtin_models=reconcile_builtin_models,
backfill_models_dev_limits=AsyncMock(return_value=[]),
)
controller._loop = asyncio.get_running_loop()
controller._shutdown_requested = False
controller._model_hub_snapshot_refresh_pending = threading.Event()
controller._model_hub_snapshot_reconcile_task = None
controller._model_hub_snapshot_reconcile_loop_task = None
controller._model_hub_snapshot_reconcile_stopping = False
controller._model_hub_snapshot_reconcile_interval_seconds = 0.01
controller._start_model_hub_snapshot_reconcile_loop()
await asyncio.wait_for(reconciled.wait(), 1)
controller._shutdown_requested = True
await controller._stop_model_hub_snapshot_reconciliation()
assert controller._model_hub_snapshot_reconcile_loop_task is None
assert controller._model_hub_snapshot_reconcile_task is None
@pytest.mark.anyio
async def test_controller_shutdown_joins_reconcile_and_rejects_late_completion():
reconcile_started = asyncio.Event()
release_reconcile = asyncio.Event()
service_stopped = asyncio.Event()
calls = []
async def reconcile_builtin_models():
calls.append("reconcile")
reconcile_started.set()
await release_reconcile.wait()
return []
async def stop():
calls.append("stop")
service_stopped.set()
controller = Controller.__new__(Controller)
controller.model_hub_service = SimpleNamespace(
reconcile_builtin_models=reconcile_builtin_models,
backfill_models_dev_limits=AsyncMock(return_value=[]),
stop=stop,
)
controller.runtime_work_supervisor = None
controller._runtime_work_tokens = []
controller._shutdown_tainted = False
controller._loop = asyncio.get_running_loop()
controller._shutdown_requested = False
controller._model_hub_snapshot_refresh_pending = threading.Event()
controller._model_hub_snapshot_reconcile_task = None
controller._model_hub_snapshot_reconcile_loop_task = None
controller._model_hub_snapshot_reconcile_stopping = False
controller._model_hub_snapshot_refresh_completed()
await asyncio.wait_for(reconcile_started.wait(), 1)
controller._shutdown_requested = True
shutdown = asyncio.create_task(controller._stop_runtime_work_stack())
await asyncio.sleep(0)
controller._model_hub_snapshot_refresh_completed()
release_reconcile.set()
await asyncio.wait_for(service_stopped.wait(), 1)
await shutdown
assert calls == ["reconcile", "stop"]
assert not controller._model_hub_snapshot_refresh_pending.is_set()
assert controller._model_hub_snapshot_reconcile_task is None
assert controller._model_hub_snapshot_reconcile_loop_task is None
@pytest.mark.parametrize("backend", ["claude", "codex", "opencode"])
def test_disabled_controller_resolver_is_direct_without_loading_model_hub_config(
monkeypatch,
backend,
):
def corrupt_config(*_args, **_kwargs):
raise json.JSONDecodeError("corrupt model_hub config", "{", 1)
monkeypatch.setattr(V2Config, "load", classmethod(corrupt_config))
controller = Controller.__new__(Controller)
controller.model_hub_runtime = None
launch = asyncio.run(resolve_model_hub_launch(controller, backend, f"{backend}-native"))
assert launch.backend == backend
assert launch.channel == "direct"
assert launch.requested_model == f"{backend}-native"
assert launch.target_model == f"{backend}-native"
assert launch.runtime_model == f"{backend}-native"
def test_disabled_controller_opencode_overlay_resolver_is_direct_without_config_read(monkeypatch):
def corrupt_config(*_args, **_kwargs):
raise json.JSONDecodeError("corrupt model_hub config", "{", 1)
monkeypatch.setattr(V2Config, "load", classmethod(corrupt_config))
controller = Controller.__new__(Controller)
controller.model_hub_runtime = None
launch = asyncio.run(resolve_opencode_overlay_launch(controller, "openai/gpt-direct", None))
assert launch.channel == "direct"
assert launch.runtime_model == "openai/gpt-direct"