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.

fix(opencode): give cold starts and the provider probe room to bootstrap (#2307)

Call Whiteb8252c3a24b4
diff --git a/core/agent_auth_service.py b/core/agent_auth_service.py
index 8a46440ad..221e9aa78 100644
--- a/core/agent_auth_service.py
+++ b/core/agent_auth_service.py
@@ -3229,6 +3229,14 @@ class AgentAuthService:
return {"ok": False, "error": "opencode_server_unavailable"}
directory = os.path.expanduser("~")
+ # On a fresh install the first request for a directory waits while
+ # OpenCode bootstraps it, which can outlast the catalog request's
+ # timeout and read as "no models".
+ try:
+ await server.ensure_directory_ready(directory)
+ except Exception as err: # noqa: BLE001
+ detail = str(err)
+ return {"ok": False, "error": _classify_test_failure("", detail), "detail": detail[:600]}
try:
catalog = await server.get_native_available_models(directory)
except Exception: # noqa: BLE001
diff --git a/modules/agents/opencode/server.py b/modules/agents/opencode/server.py
index 11c037d7a..ab9b0d3ea 100644
--- a/modules/agents/opencode/server.py
+++ b/modules/agents/opencode/server.py
@@ -49,9 +49,10 @@ logger = logging.getLogger(__name__)
DEFAULT_OPENCODE_PORT = 4096
DEFAULT_OPENCODE_HOST = "127.0.0.1"
-# A cold OpenCode process can take more than 15 seconds to load on a busy or
-# freshly provisioned host. This is a startup ceiling, not a request timeout.
-SERVER_START_TIMEOUT = 60
+# A cold OpenCode process can take close to a minute to load on a busy or
+# freshly provisioned host. This is only a ceiling: a healthy start returns as
+# soon as ``/global/health`` answers, and it is not a request timeout.
+SERVER_START_TIMEOUT = 120
# ``/global/health`` only proves the process is serving. OpenCode bootstraps a
# per-directory instance on that directory's first request, and with any plugin
# configured (Avibe always installs one) the bootstrap waits for OpenCode's own
diff --git a/tests/test_opencode_directory_bootstrap.py b/tests/test_opencode_directory_bootstrap.py
index 8dc5585ba..875aeff08 100644
--- a/tests/test_opencode_directory_bootstrap.py
+++ b/tests/test_opencode_directory_bootstrap.py
@@ -3,7 +3,7 @@
OpenCode answers ``/global/health`` as soon as it serves, but bootstraps a
per-directory instance on that directory's first request. On a fresh host the
bootstrap waits for OpenCode's own npm install and outlasts Avibe's ordinary
-request timeout, so a first turn must wait for it instead of failing.
+request timeout, so a first turn or provider probe must wait for it instead of failing.
"""
from __future__ import annotations
@@ -16,6 +16,8 @@ from unittest.mock import AsyncMock, Mock
from aiohttp import web
import modules.agents.opencode.server as server_module
+from config.v2_config import V2Config
+from core.agent_auth_service import AgentAuthService
from modules.agents.base import AgentRequest
from modules.agents.opencode.agent import OpenCodeAgent
from modules.agents.opencode.server import OpenCodeServerManager
@@ -34,7 +36,7 @@ async def _cold_opencode(bootstrap_seconds: float):
"""
bootstraps: dict[str, asyncio.Task] = {}
- created_sessions: list[str] = []
+ opencode = SimpleNamespace(port=0, created_sessions=[], prompts=[])
async def bootstrapped(request: web.Request) -> None:
directory = request.headers["x-opencode-directory"]
@@ -49,12 +51,31 @@ async def _cold_opencode(bootstrap_seconds: float):
await bootstrapped(request)
return web.json_response({"directory": request.headers["x-opencode-directory"]})
+ async def providers(request: web.Request) -> web.Response:
+ await bootstrapped(request)
+ return web.json_response({"providers": [{"id": "openai", "models": {"gpt-cold": {}}}], "default": {}})
+
async def create_session(request: web.Request) -> web.Response:
await bootstrapped(request)
- session_id = f"ses_cold_{len(created_sessions) + 1}"
- created_sessions.append(session_id)
+ session_id = f"ses_cold_{len(opencode.created_sessions) + 1}"
+ opencode.created_sessions.append(session_id)
return web.json_response({"id": session_id})
+ async def prompt_async(request: web.Request) -> web.Response:
+ await bootstrapped(request)
+ opencode.prompts.append(await request.json())
+ return web.Response(status=204)
+
+ async def messages(request: web.Request) -> web.Response:
+ await bootstrapped(request)
+ if not opencode.prompts:
+ return web.json_response([])
+ reply = {
+ "info": {"id": "msg_reply", "role": "assistant", "time": {"completed": 1}, "finish": "stop"},
+ "parts": [{"type": "text", "text": "OK"}],
+ }
+ return web.json_response([reply])
+
async def abort_session(request: web.Request) -> web.Response:
await bootstrapped(request)
return web.json_response(True)
@@ -62,13 +83,17 @@ async def _cold_opencode(bootstrap_seconds: float):
app = web.Application()
app.router.add_get("/global/health", health)
app.router.add_get("/path", path)
+ app.router.add_get("/config/providers", providers)
app.router.add_post("/session", create_session)
+ app.router.add_post("/session/{session_id}/prompt_async", prompt_async)
+ app.router.add_get("/session/{session_id}/message", messages)
app.router.add_post("/session/{session_id}/abort", abort_session)
runner = web.AppRunner(app, handler_cancellation=True)
await runner.setup()
try:
await web.TCPSite(runner, "127.0.0.1", 0).start()
- yield runner.addresses[0][1], created_sessions
+ opencode.port = runner.addresses[0][1]
+ yield opencode
finally:
for task in bootstraps.values():
task.cancel()
@@ -134,9 +159,9 @@ async def _first_turn(tmp_path, port: int, monkeypatch):
def test_first_turn_waits_for_directory_bootstrap_longer_than_request_timeout(tmp_path, monkeypatch) -> None:
async def scenario():
- async with _cold_opencode(bootstrap_seconds=REQUEST_TIMEOUT_SECONDS + 1) as (port, created_sessions):
- working_path, reached_prompt, failures = await _first_turn(tmp_path, port, monkeypatch)
- return working_path, reached_prompt, failures, created_sessions
+ async with _cold_opencode(bootstrap_seconds=REQUEST_TIMEOUT_SECONDS + 1) as opencode:
+ working_path, reached_prompt, failures = await _first_turn(tmp_path, opencode.port, monkeypatch)
+ return working_path, reached_prompt, failures, opencode.created_sessions
working_path, reached_prompt, failures, created_sessions = asyncio.run(scenario())
@@ -149,9 +174,9 @@ def test_bootstrap_past_the_readiness_ceiling_reports_first_time_setup(tmp_path,
monkeypatch.setattr(server_module, "DIRECTORY_BOOTSTRAP_TIMEOUT", REQUEST_TIMEOUT_SECONDS, raising=False)
async def scenario():
- async with _cold_opencode(bootstrap_seconds=REQUEST_TIMEOUT_SECONDS + 2) as (port, created_sessions):
- _working_path, reached_prompt, failures = await _first_turn(tmp_path, port, monkeypatch)
- return reached_prompt, failures, created_sessions
+ async with _cold_opencode(bootstrap_seconds=REQUEST_TIMEOUT_SECONDS + 2) as opencode:
+ _working_path, reached_prompt, failures = await _first_turn(tmp_path, opencode.port, monkeypatch)
+ return reached_prompt, failures, opencode.created_sessions
reached_prompt, failures, created_sessions = asyncio.run(scenario())
@@ -159,3 +184,26 @@ def test_bootstrap_past_the_readiness_ceiling_reports_first_time_setup(tmp_path,
assert created_sessions == []
assert failures == ["❌ OpenCode is still finishing its first-time setup. Send your message again shortly."]
+
+def test_provider_probe_lists_models_after_directory_bootstrap_longer_than_request_timeout(monkeypatch) -> None:
+ # The probe tests native connectivity, which only direct mode allows.
+ config = V2Config.default()
+ config.model_hub.agents["opencode"].mode = "direct"
+ config.save()
+
+ async def scenario():
+ async with _cold_opencode(bootstrap_seconds=REQUEST_TIMEOUT_SECONDS + 1) as opencode:
+ server = OpenCodeServerManager(port=opencode.port, request_timeout_seconds=REQUEST_TIMEOUT_SECONDS)
+ service = AgentAuthService(SimpleNamespace(config=SimpleNamespace(language="en")))
+ monkeypatch.setattr(service, "_opencode_server", AsyncMock(return_value=server))
+ try:
+ result = await service.test_opencode_provider("openai")
+ finally:
+ await server.close_http_session()
+ return result, opencode.prompts
+
+ result, prompts = asyncio.run(scenario())
+
+ assert result["ok"] is True, result
+ assert result["model"] == "gpt-cold"
+ assert [prompt["model"] for prompt in prompts] == [{"providerID": "openai", "modelID": "gpt-cold"}]
diff --git a/tests/test_opencode_server.py b/tests/test_opencode_server.py
index a4f626a28..068184115 100644
--- a/tests/test_opencode_server.py
+++ b/tests/test_opencode_server.py
@@ -204,12 +204,12 @@ class OpenCodeServerTests(unittest.IsolatedAsyncioTestCase):
create_process,
),
patch.object(SERVER_MODULE.asyncio, "sleep", AsyncMock()),
- patch.object(SERVER_MODULE.time, "monotonic", side_effect=[0.0, 0.0, 61.0]),
+ patch.object(SERVER_MODULE.time, "monotonic", side_effect=[0.0, 0.0, 121.0]),
patch.object(SERVER_MODULE, "server_environment", return_value={}),
patch.object(SERVER_MODULE, "terminate_process_tree", terminate),
patch.dict(os.environ, {"OPENCODE_CONFIG_CONTENT": user_config, "AVIBE_OPENCODE_MODEL_HUB": "1"}),
):
- with self.assertRaisesRegex(RuntimeError, "failed to start within 60s"):
+ with self.assertRaisesRegex(RuntimeError, "failed to start within 120s"):
await manager._start_server()
terminate.assert_awaited_once_with(
diff --git a/tests/test_web_oauth_flow.py b/tests/test_web_oauth_flow.py
index eb856f306..4ec967816 100644
--- a/tests/test_web_oauth_flow.py
+++ b/tests/test_web_oauth_flow.py
@@ -803,6 +803,9 @@ class _FakeOpencodeServer:
async def get_provider_auth(self):
return self.auth_map
+ async def ensure_directory_ready(self, _directory):
+ return None
+
async def get_available_models(self, _directory):
return self.catalog