Skip to content

The agent that turns websites into APIs!

[codex] Improve OpenCode setup and compatibility (#107)

kalil032183210a49f7f6
diff --git a/CHANGELOG.md b/CHANGELOG.md
index fa6b869..e4ef133 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,7 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
## [Unreleased]
+### Changed
+- **OpenCode setup**: RAE now reuses an existing server or downloads/starts `opencode-ai@latest` through `npx` without requiring a global OpenCode install, with configurable auto-start, package, and base URL settings plus password inheritance. Fresh configurations default to free `opencode/big-pickle`. Provider/model pairs are validated before session creation, invalid configurations include current free-model suggestions, and older compatible servers show an upgrade warning. `/settings` shows a loading spinner, uses a live searchable provider/model picker, saves the pair atomically, and remains open across related changes until Back is selected.
+- **Ollama setup**: OpenCode mode can discover tool-capable Ollama models, start an installed daemon, and inject provider configuration without modifying the user's `opencode.json`.
+
### Fixed
+- **OpenCode permissions**: Permission V2 events now reply through OpenCode's current, non-deprecated permission endpoint while retaining compatibility with older servers.
+- **OpenCode errors**: Known authentication, model configuration, and temporary provider-availability failures now produce one actionable message without the unexpected-error issue prompt.
+- **OpenCode TUI prompt echo**: Streamed text is now restricted to assistant message IDs, preventing RAE's internal browser and reverse-engineering instructions from appearing as model output.
- **`run`/`list` now work for every output language**: `discover_scripts()` previously only found `.py` files, so `reverse-api-engineer run <run_id>` failed with "No Python scripts found" for JS/TS/Go/Java/C#/PHP/Ruby/C clients. Discovery now covers all supported extensions (excluding build dirs and the vendored cJSON sources), and the run command dispatches to the right toolchain per language (compile+execute for C), with a clear error when the required tool isn't on PATH.
- **Windows-safe run-command quoting**: the Java/C#/PHP/Ruby/C run commands quoted paths with POSIX-only `shlex.quote`, which cmd.exe/PowerShell parse incorrectly for paths containing spaces. Paths are now quoted per-platform (`subprocess.list2cmdline` on Windows).
diff --git a/README.md b/README.md
index cc08aec..6643b1c 100644
--- a/README.md
+++ b/README.md
@@ -87,8 +87,13 @@ Settings live in `~/.reverse-api/config.json` and can be edited via `/settings`
"agent_browser_notes": "",
"claude_code_model": "claude-sonnet-4-6",
"collector_model": "claude-sonnet-4-6",
- "opencode_model": "claude-sonnet-4-6",
- "opencode_provider": "anthropic",
+ "ollama_auto_start": true,
+ "ollama_base_url": "http://127.0.0.1:11434",
+ "opencode_auto_start": true,
+ "opencode_base_url": "http://127.0.0.1:4096",
+ "opencode_model": "big-pickle",
+ "opencode_npx_package": "opencode-ai@latest",
+ "opencode_provider": "opencode",
"copilot_model": "gpt-5",
"cursor_model": "composer-2.5",
"output_dir": null,
@@ -100,6 +105,8 @@ Settings live in `~/.reverse-api/config.json` and can be edited via `/settings`
- **Models**: Sonnet 4.6 (default), Opus 4.6 (most capable), Haiku 4.5 (fastest). For OpenCode see [models.dev](https://models.dev).
- **SDK**: `claude` (default), `opencode`, `cursor`, or `copilot` (GitHub Copilot).
+- **OpenCode setup**: with `sdk: "opencode"`, RAE reuses an existing server or downloads/starts `opencode-ai@latest` through `npx`; a global OpenCode installation is not required. Fresh configurations default to the free `opencode/big-pickle` model. `/settings` shows a loading spinner, then offers a searchable **OpenCode Provider / Model** picker populated from the server's connected, tool-capable catalog and marks free OpenCode options. Before creating a session, RAE validates the saved pair again and suggests currently available free models when configuration is invalid. Compatible older servers are reused with a version warning. Node.js 20+ is required for automatic startup. Password-protected servers use `OPENCODE_SERVER_PASSWORD` and optional `OPENCODE_SERVER_USERNAME`. Override startup with `OPENCODE_BASE_URL`, `RAE_OPENCODE_PACKAGE`, or `RAE_OPENCODE_AUTO_START=0`.
+- **Ollama through OpenCode**: choose provider `ollama` in `/settings`; RAE starts an installed Ollama daemon if needed, lists only installed models with tool calling and 64k+ context, and supplies OpenCode's provider config inline. Models are never downloaded silently. Override with `RAE_OLLAMA_BASE_URL` or `RAE_OLLAMA_AUTO_START=0`.
- **Output language**: `python`, `javascript`, `typescript`, `go`, `java`, `csharp`, `php`, `ruby`, or `c`. C needs a POSIX toolchain (`cc`, libcurl headers) — macOS/Linux, or WSL/MSYS2 on Windows.
## CLI
diff --git a/src/reverse_api/auto_engineer.py b/src/reverse_api/auto_engineer.py
index 818bc35..5bc2ae7 100644
--- a/src/reverse_api/auto_engineer.py
+++ b/src/reverse_api/auto_engineer.py
@@ -378,24 +378,7 @@ class OpenCodeAutoEngineer(OpenCodeEngineer):
try:
auth = self._get_auth()
async with httpx.AsyncClient(base_url=self.BASE_URL, timeout=600.0, auth=auth) as client:
- try:
- health_r = await client.get("/global/health")
- health_r.raise_for_status()
- health = health_r.json()
- self.opencode_ui.health_check(health)
- except httpx.HTTPStatusError as e:
- if e.response.status_code == 401:
- debug_log(f"Health check failed: Authentication required")
- self.opencode_ui.error("Authentication failed. OpenCode server requires a password.")
- self.opencode_ui.console.print("\n[dim]Please set OPENCODE_SERVER_PASSWORD environment variable[/dim]")
- if self.opencode_username != "opencode":
- self.opencode_ui.console.print(f"[dim]Username: {self.opencode_username}[/dim]")
- return None
- raise
- except Exception as e:
- debug_log(f"Health check failed: {e}")
- self.opencode_ui.error(f"OpenCode server not responding. Is it running on {self.BASE_URL}?")
- self.opencode_ui.console.print("\n[dim]Please run: opencode serve[/dim]")
+ if not await self._prepare_server(client):
return None
# Create session first
@@ -440,7 +423,6 @@ class OpenCodeAutoEngineer(OpenCodeEngineer):
await asyncio.wait_for(event_task, timeout=600.0)
except TimeoutError:
self._last_error = "Session timed out (10 min)"
- self.opencode_ui.error(self._last_error)
# Stop streaming UI
self.opencode_ui.stop_streaming()
@@ -496,7 +478,7 @@ class OpenCodeAutoEngineer(OpenCodeEngineer):
except httpx.HTTPStatusError as e:
if e.response.status_code == 401:
- self.opencode_ui.error("Authentication failed. OpenCode server requires a password.")
+ self.opencode_ui.error("Authentication failed. OpenCode server requires a password.", unexpected=False)
self.opencode_ui.console.print("\n[dim]Please set OPENCODE_SERVER_PASSWORD environment variable[/dim]")
if self.opencode_username != "opencode":
self.opencode_ui.console.print(f"[dim]Username: {self.opencode_username}[/dim]")
diff --git a/src/reverse_api/cli.py b/src/reverse_api/cli.py
index 52e4555..a54bfe8 100644
--- a/src/reverse_api/cli.py
+++ b/src/reverse_api/cli.py
@@ -20,7 +20,7 @@ from rich.console import Console
from . import __version__
from .browser import ManualBrowser
-from .config import ConfigManager
+from .config import DEFAULT_OPENCODE_MODEL, DEFAULT_OPENCODE_PROVIDER, ConfigManager
from .engineer import run_reverse_engineering
from .messages import MessageStore
from .session import SessionManager
@@ -56,11 +56,63 @@ config_manager = ConfigManager(get_config_path())
session_manager = SessionManager(get_history_path())
+def _format_ollama_size(size: int) -> str:
+ if size < 1024:
+ return "cloud"
+ return f"{size / (1024**3):.1f} GB"
+
+
+def _select_ollama_model_for_settings() -> str | None:
+ """Discover installed agent-capable Ollama models and let the user choose."""
+
+ from .ollama_runtime import OllamaSetupError, ensure_ollama_models
+
+ try:
+ status = asyncio.run(ensure_ollama_models())
+ except OllamaSetupError as e:
+ console.print(f" [yellow]error:[/yellow] {e}\n")
+ return None
+
+ models = status.compatible_models
+ if not models:
+ console.print(" [yellow]error:[/yellow] no installed Ollama model supports tools with at least 64k context")
+ console.print(" [dim]Pull a compatible model explicitly, then retry. RAE will not download multi-GB models silently.[/dim]\n")
+ return None
+ if len(models) == 1:
+ console.print(f" [dim]using the only compatible Ollama model: {models[0].name}[/dim]")
+ return models[0].name
+
+ choices = [
+ Choice(
+ title=(
+ f"{model.name} ({model.parameter_size or 'unknown'}, {_format_ollama_size(model.size)}, "
+ f"{model.context_length // 1024}k context)"
+ ),
+ value=model.name,
+ )
+ for model in models
+ ]
+ choices.append(Choice(title="back", value="back"))
+ selected = questionary.select(
+ " > ollama model",
+ choices=choices,
+ pointer=">",
+ qmark="",
+ style=questionary.Style(
+ [
+ ("pointer", f"fg:{THEME_SECONDARY} bold"),
+ ("highlighted", f"fg:{THEME_SECONDARY} bold"),
+ ]
+ ),
+ ).ask()
+ return None if selected in {None, "back"} else str(selected)
+
+
def default_model_for_configured_sdk(sdk: str | None = None) -> str:
"""Return the configured default model id for the given SDK (or current config SDK)."""
s = (sdk or config_manager.get("sdk", "claude") or "claude").lower()
if s == "opencode":
- return config_manager.get("opencode_model", "claude-opus-4-6")
+ return config_manager.get("opencode_model", DEFAULT_OPENCODE_MODEL)
if s == "copilot":
return config_manager.get("copilot_model", "gpt-5")
if s == "cursor":
@@ -68,6 +120,129 @@ def default_model_for_configured_sdk(sdk: str | None = None) -> str:
return config_manager.get("claude_code_model", "claude-sonnet-4-6")
+async def _load_opencode_catalog_for_settings() -> dict:
+ """Start or reuse OpenCode and load its live provider/model catalog."""
+ import httpx
+
+ from .opencode_runtime import (
+ ensure_opencode_server,
+ get_opencode_model_catalog,
+ opencode_base_url,
+ )
+
+ base_url = opencode_base_url()
+ password = os.environ.get("OPENCODE_SERVER_PASSWORD")
+ username = os.environ.get("OPENCODE_SERVER_USERNAME", "opencode")
+ auth = httpx.BasicAuth(username, password) if password else None
+ async with httpx.AsyncClient(base_url=base_url, timeout=120.0, auth=auth) as client:
+ await ensure_opencode_server(client, base_url=base_url)
+ return await get_opencode_model_catalog(client)
+
+
+def _select_opencode_pair_for_settings(mode_color=THEME_PRIMARY) -> tuple[str, str] | None:
+ """Select a valid tool-capable provider/model pair from the live OpenCode catalog."""
+ from .opencode_runtime import opencode_model_is_free, opencode_model_is_selectable
+
+ try:
+ with console.status(" Loading OpenCode providers and models...", spinner="dots"):
+ catalog = asyncio.run(_load_opencode_catalog_for_settings())
+ except Exception as e:
+ response = getattr(e, "response", None)
+ if getattr(response, "status_code", None) == 401:
+ console.print(
+ " [yellow]error:[/yellow] OpenCode authentication failed. "
+ "Set OPENCODE_SERVER_PASSWORD (and OPENCODE_SERVER_USERNAME when customized).\n"
+ )
+ else:
+ console.print(f" [yellow]error:[/yellow] could not load OpenCode providers and models: {e}\n")
+ return None
+
+ providers = [provider for provider in catalog.get("providers", []) if isinstance(provider, dict)]
+ defaults = catalog.get("default") if isinstance(catalog.get("default"), dict) else {}
+ selectable = []
+ for provider in providers:
+ models = provider.get("models")
+ if provider.get("id") and isinstance(models, dict) and any(opencode_model_is_selectable(model) for model in models.values()):
+ selectable.append(provider)
+
+ style = questionary.Style(
+ [
+ ("pointer", f"fg:{mode_color} bold"),
+ ("highlighted", f"fg:{mode_color} bold"),
+ ]
+ )
+ current_provider = config_manager.get("opencode_provider", "")
+ provider_choices = []
+ for provider in selectable:
+ provider_id = str(provider["id"])
+ provider_name = str(provider.get("name") or "")
+ title = (
+ f"{provider_id} — {provider_name}"
+ if provider_name and provider_name != provider_id
+ else provider_id
+ )
+ provider_choices.append(Choice(title=title, value=provider_id))
+ provider_ids = {str(provider["id"]) for provider in selectable}
+ if "ollama" not in provider_ids:
+ provider_choices.append(Choice(title="ollama — installed local models", value="ollama"))
+ provider_ids.add("ollama")
+ provider_choices.append(Choice(title="back", value="back"))
+ provider_id = questionary.select(
+ " > opencode provider",
+ choices=provider_choices,
+ default=current_provider if current_provider in provider_ids else None,
+ pointer=">",
+ qmark="",
+ style=style,
+ use_search_filter=True,
+ use_jk_keys=False,
+ ).ask()
+ if provider_id is None or provider_id == "back":
+ return None
+ if provider_id == "ollama":
+ model_id = _select_ollama_model_for_settings()
+ return ("ollama", model_id) if model_id else None
+
+ provider = next(item for item in selectable if item.get("id") == provider_id)
+ models = provider["models"]
+ current_model = config_manager.get("opencode_model", "") if provider_id == current_provider else ""
+ default_model = str(defaults.get(provider_id) or "")
+ model_ids = [str(model_id) for model_id, model in models.items() if opencode_model_is_selectable(model)]
+ model_ids.sort(key=lambda model_id: (model_id not in {current_model, default_model}, model_id))
+ model_choices = []
+ for model_id in model_ids:
+ model = models[model_id]
+ model_name = str(model.get("name") or "")
+ title = f"{model_id} — {model_name}" if model_name and model_name != model_id else model_id
+ markers = []
+ if opencode_model_is_free(provider_id, model_id, model):
+ markers.append("free")
+ if model_id == default_model:
+ markers.append("default")
+ if markers:
+ title += f" ({', '.join(markers)})"
+ model_choices.append(Choice(title=title, value=model_id))
+ model_choices.append(Choice(title="back", value="back"))
+ selected_default = None
+ if current_model in model_ids:
+ selected_default = current_model
+ elif default_model in model_ids:
+ selected_default = default_model
+ model_id = questionary.select(
+ " > opencode model",
+ choices=model_choices,
+ default=selected_default,
+ pointer=">",
+ qmark="",
+ style=style,
+ use_search_filter=True,
+ use_jk_keys=False,
+ ).ask()
+ if model_id is None or model_id == "back":
+ return None
+ return str(provider_id), str(model_id)
+
+
# Schema version for --json outputs. Wrappers can query it via
# `reverse-api-engineer --json-schema-version`.
AGENT_JSON_SCHEMA_VERSION = 1
@@ -979,6 +1154,12 @@ def repl_loop():
def handle_settings(mode_color=THEME_PRIMARY):
+ """Keep the settings menu open until the user explicitly goes back."""
+ while _handle_settings_action(mode_color):
+ pass
+
+
+def _handle_settings_action(mode_color=THEME_PRIMARY) -> bool:
"""Display and manage settings with improved layout and descriptions."""
from rich.table import Table
@@ -1008,8 +1189,7 @@ def handle_settings(mode_color=THEME_PRIMARY):
Choice(title="Copilot Model", value="copilot_model"),
Choice(title="Cursor Model", value="cursor_model"),
Choice(title="Cursor Web Search", value="cursor_web_search"),
- Choice(title="OpenCode Model", value="opencode_model"),
- Choice(title="OpenCode Provider", value="opencode_provider"),
+ Choice(title="OpenCode Provider / Model", value="opencode_pair"),
Choice(title="Output Directory", value="output_dir"),
Choice(title="Output Language", value="output_language"),
Choice(title="Real-time Sync", value="real_time_sync"),
@@ -1033,7 +1213,7 @@ def handle_settings(mode_color=THEME_PRIMARY):
).ask()
if action is None or action == "back":
- return # Exit settings to main prompt
+ return False # Exit settings to main prompt
if action == "claude_code_model":
model_choices = [Choice(title=c["name"].lower(), value=c["value"]) for c in get_model_choices()]
@@ -1162,27 +1342,12 @@ def handle_settings(mode_color=THEME_PRIMARY):
console.print(" [dim]avoid browsing sensitive sites while the agent is active.[/dim]")
console.print()
- elif action == "opencode_provider":
- current = config_manager.get("opencode_provider", "anthropic")
- new_provider = questionary.text(
- " > opencode provider",
- default=current or "anthropic",
- instruction="(e.g., 'anthropic', 'openai', 'google')",
- qmark="",
- style=questionary.Style(
- [
- ("question", f"fg:{THEME_SECONDARY}"),
- ("instruction", f"fg:{THEME_DIM} italic"),
- ]
- ),
- ).ask()
- if new_provider is not None:
- new_provider = new_provider.strip()
- if not new_provider:
- console.print(" [yellow]error:[/yellow] opencode provider cannot be empty\n")
- else:
- config_manager.set("opencode_provider", new_provider)
- console.print(f" [dim]updated[/dim] opencode provider: {new_provider}\n")
+ elif action == "opencode_pair":
+ pair = _select_opencode_pair_for_settings(mode_color)
+ if pair is not None:
+ provider_id, model_id = pair
+ config_manager.update({"opencode_provider": provider_id, "opencode_model": model_id})
+ console.print(f" [dim]updated[/dim] opencode: {provider_id}/{model_id}\n")
elif action == "copilot_model":
current = config_manager.get("copilot_model", "gpt-5")
@@ -1249,28 +1414,6 @@ def handle_settings(mode_color=THEME_PRIMARY):
config_manager.set("cursor_web_search", pick)
console.print(f" [dim]updated[/dim] cursor web search: {'on' if pick else 'off'}\n")
- elif action == "opencode_model":
- current = config_manager.get("opencode_model", "claude-opus-4-6")
- new_model = questionary.text(
- " > opencode model",
- default=current or "claude-opus-4-6",
- instruction="(e.g., 'claude-sonnet-4-6', 'claude-opus-4-6')",
- qmark="",
- style=questionary.Style(
- [
- ("question", f"fg:{THEME_SECONDARY}"),
- ("instruction", f"fg:{THEME_DIM} italic"),
- ]
- ),
- ).ask()
- if new_model is not None:
- new_model = new_model.strip()
- if not new_model:
- console.print(" [yellow]error:[/yellow] opencode model cannot be empty\n")
- else:
- config_manager.set("opencode_model", new_model)
- console.print(f" [dim]updated[/dim] opencode model: {new_model}\n")
-
elif action == "real_time_sync":
current = config_manager.get("real_time_sync", True)
sync_choices = [
@@ -1313,6 +1456,8 @@ def handle_settings(mode_color=THEME_PRIMARY):
config_manager.set("output_dir", new_dir if new_dir.strip() else None)
console.print(" [dim]updated[/dim] output directory\n")
+ return True
+
def handle_history(mode_color=THEME_PRIMARY):
"""Display history of runs."""
@@ -1940,8 +2085,8 @@ def run_auto_capture(
prompt=prompt,
output_dir=output_dir,
agent_provider=agent_provider,
- opencode_provider=config_manager.get("opencode_provider", "anthropic"),
- opencode_model=model or config_manager.get("opencode_model", "claude-opus-4-6"),
+ opencode_provider=config_manager.get("opencode_provider", DEFAULT_OPENCODE_PROVIDER),
+ opencode_model=model or config_manager.get("opencode_model", DEFAULT_OPENCODE_MODEL),
enable_sync=config_manager.get("real_time_sync", False),
sdk=sdk,
output_language=output_language,
@@ -2257,8 +2402,8 @@ def run_engineer(
model=model,
output_dir=output_dir,
sdk=sdk,
- opencode_provider=config_manager.get("opencode_provider", "anthropic"),
- opencode_model=config_manager.get("opencode_model", "claude-opus-4-6"),
+ opencode_provider=config_manager.get("opencode_provider", DEFAULT_OPENCODE_PROVIDER),
+ opencode_model=config_manager.get("opencode_model", DEFAULT_OPENCODE_MODEL),
enable_sync=enable_sync,
additional_instructions=additional_instructions,
is_fresh=is_fresh,
diff --git a/src/reverse_api/config.py b/src/reverse_api/config.py
index 676b5f3..9586db5 100644
--- a/src/reverse_api/config.py
+++ b/src/reverse_api/config.py
@@ -4,6 +4,9 @@ import json
from pathlib import Path
from typing import Any
+DEFAULT_OPENCODE_PROVIDER = "opencode"
+DEFAULT_OPENCODE_MODEL = "big-pickle"
+
DEFAULT_CONFIG = {
"agent_provider": "auto", # "auto" | "chrome-mcp" | "agent-browser"
"agent_browser_notes": "", # extra instructions merged into agent-browser prompt / RAE_AGENT_BROWSER_NOTES env
@@ -17,8 +20,13 @@ DEFAULT_CONFIG = {
# Optional override: list of setting source ids, e.g. ["project","user","all"]. None uses cursor_web_search.
"cursor_setting_sources": None,
"copilot_model": "gpt-5", # Model for Copilot SDK sessions
- "opencode_model": "claude-opus-4-6",
- "opencode_provider": "anthropic",
+ "opencode_model": DEFAULT_OPENCODE_MODEL,
+ "opencode_provider": DEFAULT_OPENCODE_PROVIDER,
+ "opencode_auto_start": True,
+ "opencode_base_url": "http://127.0.0.1:4096",
+ "opencode_npx_package": "opencode-ai@latest",
+ "ollama_auto_start": True,
+ "ollama_base_url": "http://127.0.0.1:11434",
"output_dir": None, # None means use ~/.reverse-api/runs
"output_language": "python", # "python", "javascript", "typescript", "go", "java", "csharp", "php", "ruby", or "c"
"real_time_sync": True, # Enable real-time file sync during engineering
diff --git a/src/reverse_api/ollama_runtime.py b/src/reverse_api/ollama_runtime.py
new file mode 100644
index 0000000..5497d51
--- /dev/null
+++ b/src/reverse_api/ollama_runtime.py
@@ -0,0 +1,365 @@
+"""Ollama discovery, lifecycle, and OpenCode provider configuration."""
+
+from __future__ import annotations
+
+import asyncio
+import atexit
+import json
+import os
+import shutil
+import subprocess
+import threading
+import time
+from dataclasses import dataclass
+from typing import Any
+from urllib.parse import urlparse
+
+import httpx
+
+from .utils import get_config_path
+
+DEFAULT_OLLAMA_BASE_URL = "http://127.0.0.1:11434"
+MIN_OPENCODE_CONTEXT = 65_536
+_START_TIMEOUT_SECONDS = 30.0
+
+_PROCESS: subprocess.Popen[bytes] | None = None
+_PROCESS_URL: str | None = None
+_PROCESS_CONTEXT_LENGTH: int | None = None
+_PROCESS_LOCK = threading.Lock()
+_ATEXIT_REGISTERED = False
+
+
+class OllamaSetupError(RuntimeError):
+ """Raised when Ollama or the selected model is not ready for agent use."""
+
+
+@dataclass(frozen=True)
+class OllamaModel:
+ """Installed Ollama model metadata relevant to OpenCode."""
+
+ name: str
+ size: int
+ capabilities: tuple[str, ...]
+ context_length: int
+ parameter_size: str = ""
+
+ @property
+ def supports_tools(self) -> bool:
+ return "tools" in self.capabilities
+
+ @property
+ def supports_opencode(self) -> bool:
+ return self.supports_tools and self.context_length >= MIN_OPENCODE_CONTEXT
+
+
+@dataclass(frozen=True)
+class OllamaStatus:
+ """Ollama daemon state and installed models."""
+
+ base_url: str
+ models: tuple[OllamaModel, ...]
+ started: bool = False
+ allocated_context_length: int | None = None
+
+ @property
+ def compatible_models(self) -> tuple[OllamaModel, ...]:
+ return tuple(model for model in self.models if model.supports_opencode)
+
+
+@dataclass(frozen=True)
+class OllamaProviderSetup:
+ """Validated model plus the daemon state used to configure OpenCode."""
+
+ status: OllamaStatus
+ model: OllamaModel
+
+
+def _config_manager_snapshot() -> dict[str, Any]:
+ try:
+ from .config import ConfigManager
+
+ return ConfigManager(get_config_path()).config.copy()
+ except Exception:
+ return {}
+
+
+def ollama_base_url() -> str:
+ """Return the Ollama API URL, with an RAE-specific env override."""
+
+ env = os.environ.get("RAE_OLLAMA_BASE_URL", "").strip()
+ if env:
+ if "://" not in env:
+ env = f"http://{env}"
+ return env.rstrip("/")
+ configured = str(_config_manager_snapshot().get("ollama_base_url") or DEFAULT_OLLAMA_BASE_URL)
+ return configured.rstrip("/")
+
+
+def ollama_auto_start() -> bool:
+ """Return whether RAE may start an installed Ollama daemon."""
+
+ env = os.environ.get("RAE_OLLAMA_AUTO_START")
+ if env is not None:
+ return env.strip().lower() not in {"0", "false", "no", "off"}
+ return bool(_config_manager_snapshot().get("ollama_auto_start", True))
+
+
+def _context_length(show: dict[str, Any]) -> int:
+ """Read the architecture-specific context window returned by /api/show."""
+
+ model_info = show.get("model_info") or {}
+ if not isinstance(model_info, dict):
+ return 0
+ architecture = str(model_info.get("general.architecture") or "").strip()
+ keys = [f"{architecture}.context_length"] if architecture else []
+ keys.extend(key for key in model_info if str(key).endswith(".context_length") and key not in keys)
+ for key in keys:
+ try:
+ return int(model_info[key])
+ except (KeyError, TypeError, ValueError):
+ continue
+ return 0
+
+
+def _parse_model(tag: dict[str, Any], show: dict[str, Any]) -> OllamaModel:
+ """Merge list metadata from /api/tags with capabilities from /api/show."""
+
+ name = str(tag.get("name") or tag.get("model") or "").strip()
+ details = show.get("details") or {}
+ if not isinstance(details, dict):
+ details = {}
+ return OllamaModel(
+ name=name,
+ size=int(tag.get("size") or 0),
+ capabilities=tuple(str(value) for value in show.get("capabilities") or ()),
+ context_length=_context_length(show),
+ parameter_size=str(details.get("parameter_size") or ""),
+ )
+
+
+async def _load_models(client: httpx.AsyncClient, base_url: str, payload: dict[str, Any]) -> tuple[OllamaModel, ...]:
+ """Enrich every installed model with its authoritative /api/show metadata."""
+
+ tags = [raw for raw in payload.get("models", []) if isinstance(raw, dict) and str(raw.get("name") or raw.get("model") or "").strip()]
+
+ async def load(tag: dict[str, Any]) -> OllamaModel:
+ name = str(tag.get("name") or tag.get("model")).strip()
+ response = await client.post("/api/show", json={"model": name})
+ try:
+ response.raise_for_status()
+ except httpx.HTTPStatusError as e:
+ raise OllamaSetupError(f"Ollama at {base_url} returned HTTP {e.response.status_code} for /api/show ({name}).") from e
+ show = response.json()
+ if not isinstance(show, dict):
+ raise OllamaSetupError(f"Ollama returned invalid /api/show metadata for {name!r}.")
+ return _parse_model(tag, show)
+
+ return tuple(await asyncio.gather(*(load(tag) for tag in tags)))
+
+
+def _server_address(base_url: str) -> tuple[str, int]:
+ parsed = urlparse(base_url)
+ host = parsed.hostname
+ if parsed.scheme != "http" or not host or parsed.path not in {"", "/"}:
+ raise OllamaSetupError(f"Cannot auto-start Ollama for {base_url!r}; use a plain local http URL.")
+ if host not in {"127.0.0.1", "localhost", "::1"}:
+ raise OllamaSetupError(f"Refusing to auto-start Ollama on non-loopback host {host!r}.")
+ try:
+ port = parsed.port or 80
+ except ValueError as e:
+ raise OllamaSetupError(f"Invalid Ollama URL {base_url!r}: {e}") from e
+ return host, port
+
+
+def _managed_context_length(base_url: str) -> int | None:
+ """Return the configured context window for RAE's live managed daemon."""
+
+ with _PROCESS_LOCK:
+ if _PROCESS is not None and _PROCESS.poll() is None and _PROCESS_URL == base_url:
+ return _PROCESS_CONTEXT_LENGTH
+ return None
+
+
+def _start_managed_server(base_url: str) -> tuple[subprocess.Popen[bytes], bool]:
+ global _ATEXIT_REGISTERED, _PROCESS, _PROCESS_CONTEXT_LENGTH, _PROCESS_URL
+
+ with _PROCESS_LOCK:
+ if _PROCESS is not None and _PROCESS.poll() is None:
+ if _PROCESS_URL != base_url:
+ raise OllamaSetupError(f"RAE already manages Ollama at {_PROCESS_URL}; it cannot also start {base_url}.")
+ return _PROCESS, False
+
+ host, port = _server_address(base_url)
+ executable = shutil.which("ollama")
+ if executable is None:
+ raise OllamaSetupError("Ollama is not running and the `ollama` command is not installed. Install it from https://ollama.com/download.")
+
+ child_env = os.environ.copy()
+ child_env["OLLAMA_HOST"] = f"{host}:{port}"
+ child_env["OLLAMA_CONTEXT_LENGTH"] = str(MIN_OPENCODE_CONTEXT)
+ try:
+ process = subprocess.Popen(
+ [executable, "serve"],
+ stdin=subprocess.DEVNULL,
+ stdout=subprocess.DEVNULL,
+ stderr=subprocess.DEVNULL,
+ env=child_env,
+ start_new_session=True,
+ )
+ except OSError as e:
+ raise OllamaSetupError(f"Could not start `ollama serve`: {e}") from e
+
+ _PROCESS = process
+ _PROCESS_URL = base_url
+ _PROCESS_CONTEXT_LENGTH = MIN_OPENCODE_CONTEXT
+ if not _ATEXIT_REGISTERED:
+ atexit.register(stop_managed_ollama_server)
+ _ATEXIT_REGISTERED = True
+ return process, True
+
+
+async def ensure_ollama_models(*, timeout: float = _START_TIMEOUT_SECONDS) -> OllamaStatus:
+ """Reuse Ollama or start an installed daemon, then return model metadata."""
+
+ base_url = ollama_base_url()
+ async with httpx.AsyncClient(base_url=base_url, timeout=2.0) as client:
+ try:
+ response = await client.get("/api/tags")
+ response.raise_for_status()
+ return OllamaStatus(
+ base_url=base_url,
+ models=await _load_models(client, base_url, response.json()),
+ allocated_context_length=_managed_context_length(base_url),
+ )
+ except httpx.HTTPStatusError as e:
+ raise OllamaSetupError(f"Ollama at {base_url} returned HTTP {e.response.status_code} for /api/tags.") from e
+ except httpx.RequestError as initial_error:
+ if not ollama_auto_start():
+ raise OllamaSetupError(
+ f"Ollama is not responding at {base_url} and automatic startup is disabled. Run `ollama serve` first."
+ ) from initial_error
+
+ process, started = _start_managed_server(base_url)
+ deadline = time.monotonic() + timeout
+ last_error: Exception | None = None
+ while time.monotonic() < deadline:
+ if process.poll() is not None:
+ raise OllamaSetupError(f"`ollama serve` exited with status {process.returncode} before becoming healthy.")
+ try:
+ response = await client.get("/api/tags")
+ response.raise_for_status()
+ return OllamaStatus(
+ base_url=base_url,
+ models=await _load_models(client, base_url, response.json()),
+ started=started,
+ allocated_context_length=_managed_context_length(base_url),
+ )
+ except httpx.HTTPStatusError as e:
+ if started:
+ stop_managed_ollama_server()
+ raise OllamaSetupError(f"Ollama at {base_url} returned HTTP {e.response.status_code} for /api/tags.") from e
+ except httpx.RequestError as e:
+ last_error = e
+ await asyncio.sleep(0.25)
+
+ if started:
+ stop_managed_ollama_server()
+ raise OllamaSetupError(f"Timed out after {timeout:.0f}s waiting for Ollama at {base_url}.") from last_error
+
+
+async def prepare_ollama_model(model_name: str) -> OllamaProviderSetup:
+ """Validate that an installed model can drive the OpenCode agent loop."""
+
+ status = await ensure_ollama_models()
+ selected = next((model for model in status.models if model.name == model_name), None)
+ if selected is None:
+ available = ", ".join(model.name for model in status.models) or "none"
+ raise OllamaSetupError(
+ f"Ollama model {model_name!r} is not installed. Installed models: {available}. Pull it explicitly with `ollama pull {model_name}`."
+ )
+ if not selected.supports_tools:
+ raise OllamaSetupError(f"Ollama model {model_name!r} does not advertise tool calling, which RAE requires.")
+ if selected.context_length < MIN_OPENCODE_CONTEXT:
+ raise OllamaSetupError(f"Ollama model {model_name!r} has a {selected.context_length:,}-token context; OpenCode requires at least 65,536.")
+ return OllamaProviderSetup(status=status, model=selected)
+
+
+def opencode_ollama_env(setup: OllamaProviderSetup) -> dict[str, str]:
+ """Build inline OpenCode config without overwriting a user's config file."""
+
+ raw = os.environ.get("OPENCODE_CONFIG_CONTENT", "").strip()
+ try:
+ config = json.loads(raw) if raw else {}
+ except json.JSONDecodeError as e:
+ raise OllamaSetupError(f"OPENCODE_CONFIG_CONTENT is not valid JSON: {e}") from e
+ if not isinstance(config, dict):
+ raise OllamaSetupError("OPENCODE_CONFIG_CONTENT must contain a JSON object.")
+
+ providers = config.setdefault("provider", {})
+ if not isinstance(providers, dict):
+ raise OllamaSetupError("OPENCODE_CONFIG_CONTENT field 'provider' must be a JSON object.")
+ ollama = providers.setdefault("ollama", {})
+ if not isinstance(ollama, dict):
+ raise OllamaSetupError("OPENCODE_CONFIG_CONTENT field 'provider.ollama' must be a JSON object.")
+ ollama["npm"] = "@ai-sdk/openai-compatible"
+ ollama["name"] = "Ollama"
+ options = ollama.setdefault("options", {})
+ if not isinstance(options, dict):
+ raise OllamaSetupError("OPENCODE_CONFIG_CONTENT field 'provider.ollama.options' must be a JSON object.")
+ options["baseURL"] = f"{setup.status.base_url}/v1"
+ models = ollama.setdefault("models", {})
+ if not isinstance(models, dict):
+ raise OllamaSetupError("OPENCODE_CONFIG_CONTENT field 'provider.ollama.models' must be a JSON object.")
+ for model in setup.status.compatible_models:
+ context_length = model.context_length
+ if setup.status.allocated_context_length is not None:
+ context_length = min(context_length, setup.status.allocated_context_length)
+ models[model.name] = {
+ "name": model.name,
+ "limit": {
+ "context": context_length,
+ "output": min(context_length, 8192),
+ },
+ }
+ config["small_model"] = f"ollama/{setup.model.name}"
+ return {"OPENCODE_CONFIG_CONTENT": json.dumps(config, separators=(",", ":"), sort_keys=True)}
+
+
+async def validate_opencode_ollama_provider(client: httpx.AsyncClient, model_name: str) -> None:
+ """Ensure a reused OpenCode server already exposes the selected Ollama model."""
+
+ response = await client.get("/config", timeout=5.0)
+ response.raise_for_status()
+ config = response.json()
+ if not isinstance(config, dict):
+ raise OllamaSetupError("OpenCode returned an invalid configuration response.")
+ model_config = ((config.get("provider") or {}).get("ollama") or {}).get("models") or {}
+ if model_name not in model_config:
+ raise OllamaSetupError(
+ "The existing OpenCode server is not configured for "
+ f"ollama/{model_name}. Stop it so RAE can start a configured server, or restart it with `ollama launch opencode`."
+ )
+
+
+def stop_managed_ollama_server() -> None:
+ """Stop the Ollama child process started by RAE, if any."""
+
+ global _PROCESS, _PROCESS_CONTEXT_LENGTH, _PROCESS_URL
+
+ with _PROCESS_LOCK:
+ process = _PROCESS
+ _PROCESS = None
+ _PROCESS_URL = None
+ _PROCESS_CONTEXT_LENGTH = None
+
+ if process is None or process.poll() is not None:
+ return
+ try:
+ process.terminate()
+ except OSError:
+ return
+ try:
+ process.wait(timeout=3)
+ except subprocess.TimeoutExpired:
+ process.kill()
+ process.wait(timeout=3)
diff --git a/src/reverse_api/opencode_engineer.py b/src/reverse_api/opencode_engineer.py
index 7c5e9d9..e4f5456 100644
--- a/src/reverse_api/opencode_engineer.py
+++ b/src/reverse_api/opencode_engineer.py
@@ -14,6 +14,20 @@ from typing import Any
import httpx
from .base_engineer import BaseEngineer
+from .config import DEFAULT_OPENCODE_MODEL, DEFAULT_OPENCODE_PROVIDER
+from .ollama_runtime import (
+ OllamaProviderSetup,
+ OllamaSetupError,
+ opencode_ollama_env,
+ prepare_ollama_model,
+ validate_opencode_ollama_provider,
+)
+from .opencode_runtime import (
+ OpenCodeSetupError,
+ ensure_opencode_server,
+ opencode_base_url,
+ validate_opencode_model,
+)
from .opencode_ui import OpenCodeUI
# Enable debug mode with OPENCODE_DEBUG=1
@@ -110,8 +124,9 @@ class OpenCodeEngineer(BaseEngineer):
def __init__(self, *args, **kwargs):
# Pop OpenCode-specific kwargs before passing to parent class
- self.opencode_provider = kwargs.pop("opencode_provider", "anthropic")
- self.opencode_model = kwargs.pop("opencode_model", "claude-opus-4-6")
+ self.opencode_provider = kwargs.pop("opencode_provider", DEFAULT_OPENCODE_PROVIDER)
+ self.opencode_model = kwargs.pop("opencode_model", DEFAULT_OPENCODE_MODEL)
+ self.BASE_URL = opencode_base_url()
super().__init__(*args, **kwargs)
@@ -123,6 +138,9 @@ class OpenCodeEngineer(BaseEngineer):
self._last_event_time = 0.0
self._work_started = False # Track if any real work has been done
self._busy_time: float | None = None # When session became busy
+ self._assistant_message_ids: set[str] = set()
+ self._message_roles: dict[str, str] = {}
+ self._pending_text_parts: dict[str, list[dict[str, Any]]] = {}
# Read OpenCode server authentication from environment variables
self.opencode_password = os.environ.get("OPENCODE_SERVER_PASSWORD")
@@ -134,6 +152,46 @@ class OpenCodeEngineer(BaseEngineer):
return httpx.BasicAuth(self.opencode_username, self.opencode_password)
return None
+ async def _prepare_server(self, client: httpx.AsyncClient) -> bool:
+ """Ensure OpenCode is healthy, starting the managed runtime if needed."""
+ try:
+ ollama_setup: OllamaProviderSetup | None = None
+ env_overrides: dict[str, str] = {}
+ if self.opencode_provider == "ollama":
+ ollama_setup = await prepare_ollama_model(self.opencode_model)
+ env_overrides = opencode_ollama_env(ollama_setup)
+
+ server = await ensure_opencode_server(client, base_url=self.BASE_URL, env_overrides=env_overrides)
+ if ollama_setup is not None:
+ await validate_opencode_ollama_provider(client, self.opencode_model)
+ self.opencode_ui.ollama_ready(self.opencode_model, ollama_setup.status.started)
+ if server.started and server.package:
+ self.opencode_ui.server_started(server.package, self.BASE_URL)
+ self.opencode_ui.health_check(server.health)
+ if server.version_warning:
+ self.opencode_ui.compatibility_warning(server.version_warning)
+ model_id = self.MODEL_MAP.get(self.opencode_model, self.opencode_model)
+ await validate_opencode_model(client, self.opencode_provider, model_id)
+ return True
+ except httpx.HTTPStatusError as e:
+ if e.response.status_code != 401:
+ raise
+ debug_log("Health check failed: authentication required")
+ self.opencode_ui.error("Authentication failed. OpenCode server requires a password.", unexpected=False)
+ self.opencode_ui.console.print("\n[dim]Please set OPENCODE_SERVER_PASSWORD environment variable[/dim]")
+ if self.opencode_username != "opencode":
+ self.opencode_ui.console.print(f"[dim]Username: {self.opencode_username}[/dim]")
+ return False
+ except (OllamaSetupError, OpenCodeSetupError) as e:
+ debug_log(f"OpenCode setup failed: {e}")
+ self.opencode_ui.error(str(e), unexpected=False)
+ return False
+ except Exception as e:
+ debug_log(f"Health check failed: {e}")
+ self.opencode_ui.error(f"OpenCode server not responding. Is it running on {self.BASE_URL}?")
+ self.opencode_ui.console.print("\n[dim]RAE can auto-start OpenCode when Node.js and npx are available.[/dim]")
+ return False
+
async def analyze_and_generate(self) -> dict[str, Any] | None:
"""Run the reverse engineering analysis with OpenCode."""
self.opencode_ui.header(self.run_id, self.prompt, self.opencode_model, self.sdk, mode="engineer")
@@ -146,25 +204,7 @@ class OpenCodeEngineer(BaseEngineer):
try:
auth = self._get_auth()
async with httpx.AsyncClient(base_url=self.BASE_URL, timeout=600.0, auth=auth) as client:
- # Health check
- try:
- health_r = await client.get("/global/health")
- health_r.raise_for_status()
- health = health_r.json()
- self.opencode_ui.health_check(health)
- except httpx.HTTPStatusError as e:
- if e.response.status_code == 401:
- debug_log(f"Health check failed: Authentication required")
- self.opencode_ui.error("Authentication failed. OpenCode server requires a password.")
- self.opencode_ui.console.print("\n[dim]Please set OPENCODE_SERVER_PASSWORD environment variable[/dim]")
- if self.opencode_username != "opencode":
- self.opencode_ui.console.print(f"[dim]Username: {self.opencode_username}[/dim]")
- return None
- raise
- except Exception as e:
- debug_log(f"Health check failed: {e}")
- self.opencode_ui.error(f"OpenCode server not responding. Is it running on {self.BASE_URL}?")
- self.opencode_ui.console.print("\n[dim]Please run: opencode serve[/dim]")
+ if not await self._prepare_server(client):
return None
# Create a new session
@@ -202,7 +242,6 @@ class OpenCodeEngineer(BaseEngineer):
await asyncio.wait_for(event_task, timeout=600.0)
except TimeoutError:
self._last_error = "Session timed out (10 min)"
- self.opencode_ui.error(self._last_error)
# Stop streaming UI
self.opencode_ui.stop_streaming()
@@ -252,7 +291,7 @@ class OpenCodeEngineer(BaseEngineer):
except httpx.HTTPStatusError as e:
if e.response.status_code == 401:
- self.opencode_ui.error("Authentication failed. OpenCode server requires a password.")
+ self.opencode_ui.error("Authentication failed. OpenCode server requires a password.", unexpected=False)
self.opencode_ui.console.print("\n[dim]Please set OPENCODE_SERVER_PASSWORD environment variable[/dim]")
if self.opencode_username != "opencode":
self.opencode_ui.console.print(f"[dim]Username: {self.opencode_username}[/dim]")
@@ -341,13 +380,29 @@ class OpenCodeEngineer(BaseEngineer):
debug_log(f"Event: {event_type}")
# Handle different event types
- if event_type == "message.part.updated":
+ if event_type == "message.updated":
+ info = properties.get("info", {})
+ event_sid = properties.get("sessionID") or info.get("sessionID")
+ message_id = info.get("id")
+ if event_sid == self._session_id and message_id:
+ message_id = str(message_id)
+ role = str(info.get("role") or "")
+ self._message_roles[message_id] = role
+ pending = self._pending_text_parts.pop(message_id, [])
+ if role == "assistant":
+ self._assistant_message_ids.add(message_id)
+ for pending_properties in pending:
+ await self._handle_part_update(pending_properties, seen_parts)
+
+ elif event_type == "message.part.updated":
await self._handle_part_update(properties, seen_parts)
elif event_type == "session.idle":
event_sid = properties.get("sessionID")
debug_log(f"session.idle: sessionID={event_sid}, our session={self._session_id}")
if event_sid == self._session_id:
+ if not await self._reconcile_pending_text_parts(client, seen_parts):
+ return
debug_log("Our session is idle, returning!")
self.opencode_ui.session_status("idle")
return # Done!
@@ -378,15 +433,21 @@ class OpenCodeEngineer(BaseEngineer):
debug_log("Suspiciously fast idle - checking for errors")
# Try to get session details to check for error
await self._check_session_error(client)
+ if self._last_error:
+ return
+ if not await self._reconcile_pending_text_parts(client, seen_parts):
+ return
debug_log("Our session status is idle, returning!")
return # Done!
- elif event_type == "permission.updated" or event_type == "permission.asked":
+ elif event_type in {"permission.updated", "permission.asked", "permission.v2.asked"}:
# Auto-approve permissions so the agent can proceed
permission_id = properties.get("id")
perm_session = properties.get("sessionID")
- perm_type = properties.get("type", "")
- perm_title = properties.get("title", "")
+ is_v2 = event_type == "permission.v2.asked"
+ perm_type = properties.get("type") or properties.get("permission") or properties.get("action") or "permission"
+ resources = properties.get("resources") or properties.get("patterns") or []
+ perm_title = properties.get("title") or ", ".join(resources) or perm_type
debug_log(f"{event_type}: id={permission_id}, type={perm_type}, title={perm_title}")
@@ -398,15 +459,30 @@ class OpenCodeEngineer(BaseEngineer):
# OpenCode expects: "once" | "always" | "reject"
debug_log(f"Auto-approving permission {permission_id}")
try:
- perm_response = await client.post(
- f"/session/{self._session_id}/permissions/{permission_id}",
- json={"response": "always"}, # "once", "always", or "reject"
- )
+ if is_v2:
+ perm_response = await client.post(
+ f"/api/session/{self._session_id}/permission/{permission_id}/reply",
+ json={"reply": "always"},
+ )
+ else:
+ perm_response = await client.post(
+ f"/session/{self._session_id}/permissions/{permission_id}",
+ json={"response": "always"}, # Legacy OpenCode permission API
+ )
debug_log(f"Permission response: {perm_response.status_code}")
- if perm_response.status_code == 200:
+ if 200 <= perm_response.status_code < 300:
self.opencode_ui.permission_approved(perm_type)
+ else:
+ self._last_error = (
+ f"Permission approval failed for {perm_type}: "
+ f"OpenCode returned HTTP {perm_response.status_code}."
+ )
+ debug_log(self._last_error)
+ return
except Exception as pe:
- debug_log(f"Permission approval failed: {pe}")
+ self._last_error = f"Permission approval failed for {perm_type}: {pe}"
+ debug_log(self._last_error)
+ return
elif event_type == "todo.updated":
todos = properties.get("todos", [])
@@ -462,7 +538,13 @@ class OpenCodeEngineer(BaseEngineer):
elif error_name == "APIError":
msg = error_data.get("message", "API error")
status = error_data.get("statusCode", "")
- self._last_error = f"API error{' (' + str(status) + ')' if status else ''}: {msg}"
+ if str(status) == "401" and str(msg).casefold() == "no provider available":
+ self._last_error = (
+ "OpenCode has no serving provider available for this model right now. "
+ "Try another free model or retry later."
+ )
+ else:
+ self._last_error = f"API error{' (' + str(status) + ')' if status else ''}: {msg}"
elif error_name == "MessageAbortedError":
self._last_error = "Aborted"
else:
@@ -471,7 +553,6 @@ class OpenCodeEngineer(BaseEngineer):
else:
self._last_error = str(error_obj)
- self.opencode_ui.error(self._last_error)
return
except httpx.ReadError as e:
@@ -481,6 +562,43 @@ class OpenCodeEngineer(BaseEngineer):
self._last_error = format_error(e)
debug_log(f"Exception in _stream_events: {self._last_error}")
+ async def _reconcile_pending_text_parts(self, client: httpx.AsyncClient, seen_parts: set) -> bool:
+ """Resolve buffered text roles from OpenCode's final session state."""
+
+ if not self._pending_text_parts:
+ return True
+ try:
+ response = await client.get(f"/session/{self._session_id}/message")
+ if not 200 <= response.status_code < 300:
+ self._last_error = f"Could not reconcile final OpenCode messages: HTTP {response.status_code}."
+ return False
+ messages = response.json()
+ except Exception as e:
+ self._last_error = f"Could not reconcile final OpenCode messages: {e}"
+ return False
+ if not isinstance(messages, list):
+ self._last_error = "Could not reconcile final OpenCode messages: invalid response."
+ return False
+
+ for message in messages:
+ info = message.get("info", {}) if isinstance(message, dict) else {}
+ message_id = str(info.get("id") or "")
+ role = str(info.get("role") or "")
+ if not message_id or not role or message_id not in self._pending_text_parts:
+ continue
+ self._message_roles[message_id] = role
+ pending = self._pending_text_parts.pop(message_id)
+ if role == "assistant":
+ self._assistant_message_ids.add(message_id)
+ for pending_properties in pending:
+ await self._handle_part_update(pending_properties, seen_parts)
+
+ if self._pending_text_parts:
+ unresolved = ", ".join(sorted(self._pending_text_parts))
+ self._last_error = f"OpenCode completed without role metadata for buffered message(s): {unresolved}."
+ return False
+ return True
+
async def _check_session_error(self, client: httpx.AsyncClient):
"""Check session for errors when we get suspiciously fast idle."""
try:
@@ -508,9 +626,6 @@ class OpenCodeEngineer(BaseEngineer):
msg = error_data.get("message", "") if isinstance(error_data, dict) else str(error_data)
self._last_error = f"{error_name}: {msg}" if msg else error_name
- if self._last_error:
- self.opencode_ui.error(self._last_error)
-
# Also check messages for errors
msg_r = await client.get(f"/session/{self._session_id}/message")
if msg_r.status_code == 200:
@@ -532,7 +647,6 @@ class OpenCodeEngineer(BaseEngineer):
self._last_error = f"Model not found: {provider}/{model}"
if suggestions:
self._last_error += f"\n Did you mean: {', '.join(suggestions)}?"
- self.opencode_ui.error(self._last_error)
return
except Exception as e:
debug_log(f"Error checking session: {e}")
@@ -557,12 +671,13 @@ class OpenCodeEngineer(BaseEngineer):
text = part.get("text", "")
debug_log(f"Handling text part: id={part_id}, delta={'yes' if delta else 'no'}, len={len(text)}")
- # Filter out known prompt text patterns that get echoed back
- # This prevents the tag context section from appearing in streaming output
- # Check for the specific tag context pattern that appears at the end of prompts
- tag_context_pattern = "By default, treat this as an iterative refinement"
- if tag_context_pattern in text and "Note: Full message history is available" in text:
- debug_log(f"Filtering out echoed tag context from streaming output")
+ message_id = str(part.get("messageID") or "")
+ if message_id and message_id not in self._message_roles and message_id not in self._assistant_message_ids:
+ debug_log(f"Buffering text until role is known for message {message_id}")
+ self._pending_text_parts.setdefault(message_id, []).append(properties)
+ return
+ if message_id not in self._assistant_message_ids:
+ debug_log(f"Skipping text for non-assistant message {message_id or 'unknown'}")
return
# Use delta for incremental updates if available
diff --git a/src/reverse_api/opencode_runtime.py b/src/reverse_api/opencode_runtime.py
new file mode 100644
index 0000000..2c4ddb5
--- /dev/null
+++ b/src/reverse_api/opencode_runtime.py
@@ -0,0 +1,391 @@
+"""OpenCode server discovery and managed startup.
+
+Reverse API Engineer reuses an already-running OpenCode server when possible.
+When the configured local server is unavailable, it can start the latest npm
+release through ``npx`` and keep that process alive for the current RAE run.
+"""
+
+from __future__ import annotations
+
+import atexit
+import os
+import re
+import shutil
+import subprocess
+import threading
+import time
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Any
+from urllib.parse import urlparse
+
+import httpx
+
+from .utils import get_config_path
+
+DEFAULT_OPENCODE_BASE_URL = "http://127.0.0.1:4096"
+DEFAULT_OPENCODE_PACKAGE = "opencode-ai@latest"
+TESTED_OPENCODE_VERSION = (1, 18, 4)
+_START_TIMEOUT_SECONDS = 120.0
+
+_PROCESS: subprocess.Popen[bytes] | None = None
+_PROCESS_URL: str | None = None
+_PROCESS_ENV_OVERRIDES: dict[str, str] = {}
+_PROCESS_LOCK = threading.Lock()
+_ATEXIT_REGISTERED = False
+
+
+class OpenCodeSetupError(RuntimeError):
+ """Raised when a local OpenCode server cannot be prepared."""
+
+
+@dataclass(frozen=True)
+class OpenCodeServerStatus:
+ """Result of locating or starting the OpenCode server."""
+
+ health: dict[str, Any]
+ started: bool = False
+ package: str | None = None
+ version_warning: str | None = None
+
+
+def _parse_version(value: object) -> tuple[int, int, int] | None:
+ match = re.match(r"^(\d+)\.(\d+)\.(\d+)", str(value or "").strip())
+ if match is None:
+ return None
+ return tuple(int(part) for part in match.groups())
+
+
+def _format_version(version: tuple[int, int, int]) -> str:
+ return ".".join(str(part) for part in version)
+
+
+def opencode_version_warning(health: dict[str, Any]) -> str | None:
+ """Warn about versions older than the server tested with this RAE release."""
+
+ raw_version = health.get("version")
+ version = _parse_version(raw_version)
+ if version is None:
+ return "OpenCode did not report a parseable version; compatibility will be checked through its APIs."
+ if version < TESTED_OPENCODE_VERSION:
+ tested = _format_version(TESTED_OPENCODE_VERSION)
+ return (
+ f"OpenCode v{raw_version} is older than RAE's tested v{tested}; required APIs will be checked before use. "
+ "Stop the existing server to let RAE use opencode-ai@latest."
+ )
+ return None
+
+
+def _tool_capable(model: dict[str, Any]) -> bool:
+ capabilities = model.get("capabilities")
+ return not isinstance(capabilities, dict) or capabilities.get("toolcall") is not False
+
+
+def _active(model: dict[str, Any]) -> bool:
+ return str(model.get("status") or "active").casefold() == "active"
+
+
+def opencode_model_is_selectable(model: object) -> bool:
+ """Return whether a catalog model is active and supports the tools RAE needs."""
+ return isinstance(model, dict) and _active(model) and _tool_capable(model)
+
+
+def opencode_model_is_free(provider_id: str, model_id: str, model: dict[str, Any]) -> bool:
+ """Return whether a catalog entry is explicitly a free OpenCode model."""
+ cost = model.get("cost")
+ if not isinstance(cost, dict):
+ return model_id.casefold().endswith("-free")
+ input_cost = cost.get("input")
+ output_cost = cost.get("output")
+ return (input_cost == 0 and output_cost == 0) and (
+ provider_id == "opencode" or model_id.casefold().endswith("-free")
+ )
+
+
+def _model_references(
+ providers: list[dict[str, Any]],
+ defaults: dict[str, Any],
+ *,
+ provider_id: str | None = None,
+ free_only: bool = False,
+ limit: int = 5,
+) -> list[str]:
+ references: list[str] = []
+ for provider in providers:
+ current_provider = str(provider.get("id") or "")
+ if not current_provider or (provider_id is not None and current_provider != provider_id):
+ continue
+ models = provider.get("models")
+ if not isinstance(models, dict):
+ continue
+ ordered_ids = list(models)
+ default_model = defaults.get(current_provider)
+ if default_model in models:
+ ordered_ids.remove(default_model)
+ ordered_ids.insert(0, default_model)
+ for model_id in ordered_ids:
+ model = models.get(model_id)
+ if not opencode_model_is_selectable(model):
+ continue
+ if free_only and not opencode_model_is_free(current_provider, str(model_id), model):
+ continue
+ reference = f"{current_provider}/{model_id}"
+ if reference not in references:
+ references.append(reference)
+ if len(references) == limit:
+ return references
+ return references
+
+
+async def get_opencode_model_catalog(client: httpx.AsyncClient) -> dict[str, Any]:
+ """Return OpenCode's provider/model catalog or raise an actionable setup error."""
+ try:
+ response = await client.get("/config/providers", timeout=10.0)
+ response.raise_for_status()
+ except httpx.HTTPStatusError as e:
+ if e.response.status_code == 401:
+ raise
+ raise OpenCodeSetupError(
+ f"OpenCode could not provide its model catalog (HTTP {e.response.status_code}). "
+ "This server is incompatible because RAE requires /config/providers. "
+ "Stop it so RAE can start opencode-ai@latest."
+ ) from e
+ except httpx.RequestError as e:
+ raise OpenCodeSetupError(f"Could not read the OpenCode model catalog: {e}") from e
+
+ payload = response.json()
+ if not isinstance(payload, dict) or not isinstance(payload.get("providers"), list):
+ raise OpenCodeSetupError("OpenCode returned an invalid model catalog from /config/providers.")
+ return payload
+
+
+async def validate_opencode_model(client: httpx.AsyncClient, provider_id: str, model_id: str) -> None:
+ """Validate the configured pair before creating a session or starting agent work."""
+
+ payload = await get_opencode_model_catalog(client)
+ providers = [provider for provider in payload["providers"] if isinstance(provider, dict)]
+ defaults = payload.get("default") if isinstance(payload.get("default"), dict) else {}
+ provider = next((item for item in providers if item.get("id") == provider_id), None)
+ free_models = _model_references(providers, defaults, free_only=True)
+ free_hint = f" Free options currently available: {', '.join(free_models)}." if free_models else ""
+
+ if provider is None:
+ available = ", ".join(str(item.get("id")) for item in providers if item.get("id")) or "none"
+ raise OpenCodeSetupError(
+ f"Invalid OpenCode model pairing: provider {provider_id!r} is not connected. "
+ f"Connected providers: {available}.{free_hint} Change OpenCode Provider and OpenCode Model in /settings."
+ )
+
+ models = provider.get("models")
+ models = models if isinstance(models, dict) else {}
+ model = models.get(model_id)
+ if not isinstance(model, dict):
+ suggestions = _model_references(providers, defaults, provider_id=provider_id)
+ suggestion_hint = f" Try: {', '.join(suggestions)}." if suggestions else ""
+ raise OpenCodeSetupError(
+ f"Invalid OpenCode model pairing: {provider_id}/{model_id} is not available."
+ f"{suggestion_hint}{free_hint} Change OpenCode Model in /settings."
+ )
+ if not _tool_capable(model):
+ suggestions = _model_references(providers, defaults, provider_id=provider_id)
+ suggestion_hint = f" Try: {', '.join(suggestions)}." if suggestions else ""
+ raise OpenCodeSetupError(
+ f"OpenCode model {provider_id}/{model_id} does not support tool calling, which RAE requires."
+ f"{suggestion_hint}{free_hint}"
+ )
+
+
+def _config_manager_snapshot() -> dict[str, Any]:
+ """Load config defaults merged with the user's RAE config."""
+
+ try:
+ from .config import ConfigManager
+
+ return ConfigManager(get_config_path()).config.copy()
+ except Exception:
+ return {}
+
+
+def opencode_base_url() -> str:
+ """Return the OpenCode server URL, with an environment override."""
+
+ env = os.environ.get("OPENCODE_BASE_URL", "").strip()
+ if env:
+ return env.rstrip("/")
+ configured = str(_config_manager_snapshot().get("opencode_base_url") or DEFAULT_OPENCODE_BASE_URL)
+ return configured.rstrip("/")
+
+
+def opencode_npx_package() -> str:
+ """Return the npm package used for managed OpenCode startup."""
+
+ env = os.environ.get("RAE_OPENCODE_PACKAGE", "").strip()
+ if env:
+ return env
+ return str(_config_manager_snapshot().get("opencode_npx_package") or DEFAULT_OPENCODE_PACKAGE)
+
+
+def opencode_auto_start() -> bool:
+ """Return whether RAE may start OpenCode when no server is listening."""
+
+ env = os.environ.get("RAE_OPENCODE_AUTO_START")
+ if env is not None:
+ return env.strip().lower() not in {"0", "false", "no", "off"}
+ return bool(_config_manager_snapshot().get("opencode_auto_start", True))
+
+
+def _server_address(base_url: str) -> tuple[str, int]:
+ parsed = urlparse(base_url)
+ host = parsed.hostname
+ if parsed.scheme != "http" or not host or parsed.path not in {"", "/"}:
+ raise OpenCodeSetupError(f"Cannot auto-start OpenCode for {base_url!r}. Use a plain local http URL or start the custom server yourself.")
+ if host not in {"127.0.0.1", "localhost", "::1"}:
+ raise OpenCodeSetupError(f"Refusing to auto-start OpenCode on non-loopback host {host!r}. Start that server yourself or disable auto-start.")
+ try:
+ port = parsed.port or 80
+ except ValueError as e:
+ raise OpenCodeSetupError(f"Invalid OpenCode server URL {base_url!r}: {e}") from e
+ return host, port
+
+
+def _start_managed_server(
+ base_url: str,
+ env_overrides: Mapping[str, str] | None = None,
+) -> tuple[subprocess.Popen[bytes], str, bool]:
+ """Start the configured OpenCode npm package once for this process."""
+
+ global _ATEXIT_REGISTERED, _PROCESS, _PROCESS_ENV_OVERRIDES, _PROCESS_URL
+
+ desired_env = dict(env_overrides or {})
+
+ with _PROCESS_LOCK:
+ if _PROCESS is not None and _PROCESS.poll() is None:
+ if _PROCESS_URL != base_url:
+ raise OpenCodeSetupError(f"RAE already manages OpenCode at {_PROCESS_URL}; it cannot also start {base_url} in the same process.")
+ if _PROCESS_ENV_OVERRIDES != desired_env:
+ raise OpenCodeSetupError("The managed OpenCode server needs different provider configuration; restart it and retry.")
+ return _PROCESS, opencode_npx_package(), False
+
+ host, port = _server_address(base_url)
+ npx = shutil.which("npx")
+ if npx is None or shutil.which("node") is None:
+ raise OpenCodeSetupError(
+ "OpenCode is not running and Node.js/npx is unavailable. Install Node.js 20+ or start `opencode serve` manually."
+ )
+
+ package = opencode_npx_package()
+ argv = [npx, "-y", package, "serve", "--hostname", host, "--port", str(port)]
+ child_env = os.environ.copy()
+ child_env.update(desired_env)
+ try:
+ process = subprocess.Popen(
+ argv,
+ stdin=subprocess.DEVNULL,
+ stdout=subprocess.DEVNULL,
+ stderr=subprocess.DEVNULL,
+ env=child_env,
+ start_new_session=True,
+ )
+ except OSError as e:
+ raise OpenCodeSetupError(f"Could not start `{package}` through npx: {e}") from e
+
+ _PROCESS = process
+ _PROCESS_URL = base_url
+ _PROCESS_ENV_OVERRIDES = desired_env
+ if not _ATEXIT_REGISTERED:
+ atexit.register(stop_managed_opencode_server)
+ _ATEXIT_REGISTERED = True
+ return process, package, True
+
+
+async def ensure_opencode_server(
+ client: httpx.AsyncClient,
+ *,
+ base_url: str,
+ env_overrides: Mapping[str, str] | None = None,
+ timeout: float = _START_TIMEOUT_SECONDS,
+) -> OpenCodeServerStatus:
+ """Reuse a healthy server or start the configured OpenCode release locally."""
+
+ try:
+ response = await client.get("/global/health", timeout=2.0)
+ response.raise_for_status()
+ health = response.json()
+ if not isinstance(health, dict):
+ raise OpenCodeSetupError("OpenCode returned an invalid health response.")
+ version_warning = opencode_version_warning(health)
+ desired_env = dict(env_overrides or {})
+ with _PROCESS_LOCK:
+ restart_managed = _PROCESS is not None and _PROCESS.poll() is None and _PROCESS_URL == base_url and _PROCESS_ENV_OVERRIDES != desired_env
+ if not restart_managed:
+ return OpenCodeServerStatus(health=health, version_warning=version_warning)
+ stop_managed_opencode_server()
+ except httpx.HTTPStatusError:
+ raise
+ except httpx.RequestError as initial_error:
+ if not opencode_auto_start():
+ raise OpenCodeSetupError(
+ f"OpenCode is not responding at {base_url} and automatic startup is disabled. Run `opencode serve` first."
+ ) from initial_error
+
+ process, package, started = _start_managed_server(base_url, env_overrides)
+ deadline = time.monotonic() + timeout
+ last_error: Exception | None = None
+ while time.monotonic() < deadline:
+ if process.poll() is not None:
+ raise OpenCodeSetupError(f"`npx -y {package} serve` exited with status {process.returncode} before becoming healthy.")
+ try:
+ response = await client.get("/global/health", timeout=2.0)
+ response.raise_for_status()
+ health = response.json()
+ if not isinstance(health, dict):
+ raise OpenCodeSetupError("OpenCode returned an invalid health response.")
+ try:
+ version_warning = opencode_version_warning(health)
+ except OpenCodeSetupError:
+ if started:
+ stop_managed_opencode_server()
+ raise
+ return OpenCodeServerStatus(
+ health=health,
+ started=started,
+ package=package,
+ version_warning=version_warning,
+ )
+ except httpx.HTTPStatusError:
+ if started:
+ stop_managed_opencode_server()
+ raise
+ except httpx.RequestError as e:
+ last_error = e
+ import asyncio
+
+ await asyncio.sleep(0.25)
+
+ if started:
+ stop_managed_opencode_server()
+ raise OpenCodeSetupError(f"Timed out after {timeout:.0f}s waiting for `npx -y {package} serve` at {base_url}.") from last_error
+
+
+def stop_managed_opencode_server() -> None:
+ """Stop the OpenCode child process started by RAE, if any."""
+
+ global _PROCESS, _PROCESS_ENV_OVERRIDES, _PROCESS_URL
+
+ with _PROCESS_LOCK:
+ process = _PROCESS
+ _PROCESS = None
+ _PROCESS_URL = None
+ _PROCESS_ENV_OVERRIDES = {}
+
+ if process is None or process.poll() is not None:
+ return
+ try:
+ process.terminate()
+ except OSError:
+ return
+ try:
+ process.wait(timeout=3)
+ except subprocess.TimeoutExpired:
+ process.kill()
+ process.wait(timeout=3)
diff --git a/src/reverse_api/opencode_ui.py b/src/reverse_api/opencode_ui.py
index a733dcd..4b40d91 100644
--- a/src/reverse_api/opencode_ui.py
+++ b/src/reverse_api/opencode_ui.py
@@ -45,6 +45,19 @@ class OpenCodeUI:
version = health.get("version", "unknown")
self.console.print(f" [dim]server: OpenCode v{version}[/dim]")
+ def server_started(self, package: str, base_url: str) -> None:
+ """Display managed server startup."""
+ self.console.print(f" [dim]started: {package} at {base_url}[/dim]")
+
+ def compatibility_warning(self, message: str) -> None:
+ """Display a concise warning for an older or unknown server version."""
+ self.console.print(f" [yellow]warning:[/yellow] {message}")
+
+ def ollama_ready(self, model: str, started: bool = False) -> None:
+ """Display the validated Ollama model and daemon state."""
+ action = "started" if started else "connected"
+ self.console.print(f" [dim]ollama: {action}, using {model}[/dim]")
+
def session_created(self, session_id: str) -> None:
"""Display session creation."""
self.console.print(f" [dim]session: {session_id[:16]}...[/dim]")
@@ -222,7 +235,7 @@ class OpenCodeUI:
self.console.print(f" [dim]synced:[/dim] [white]{local_path}[/white]")
self.console.print()
- def error(self, message: str) -> None:
+ def error(self, message: str, *, unexpected: bool | None = None) -> None:
"""Display error message with Rich formatting support."""
self.console.print()
# Check if message already contains Rich markup (from format_error)
@@ -232,7 +245,22 @@ class OpenCodeUI:
else:
# Simple error format
self.console.print(f" [dim]![/dim] [red]error:[/red] {message}")
- self.console.print(f" [dim]{ERROR_CTA}[/dim]")
+ if unexpected is None:
+ normalized = message.casefold()
+ expected_markers = (
+ "api error (401): no provider available",
+ "no serving provider available",
+ "auth error",
+ "authentication failed",
+ "invalid opencode model pairing",
+ "model not found:",
+ "does not support tool calling",
+ "permission approval failed",
+ "aborted",
+ )
+ unexpected = not any(marker in normalized for marker in expected_markers)
+ if unexpected:
+ self.console.print(f" [dim]{ERROR_CTA}[/dim]")
def permission_requested(self, perm_type: str, title: str) -> None:
"""Display when a permission is requested."""
diff --git a/src/reverse_api/utils.py b/src/reverse_api/utils.py
index 9c9b9dd..d2e506e 100644
--- a/src/reverse_api/utils.py
+++ b/src/reverse_api/utils.py
@@ -1,6 +1,7 @@
"""Utility functions for run ID generation and path management."""
import asyncio
+import os
import platform
import re
import uuid
@@ -151,26 +152,37 @@ async def _generate_folder_name_opencode_async(prompt: str, session_id: str = No
"""
import json
- import httpx
+ from .config import DEFAULT_OPENCODE_MODEL, DEFAULT_OPENCODE_PROVIDER, ConfigManager
+ from .ollama_runtime import opencode_ollama_env, prepare_ollama_model, validate_opencode_ollama_provider
+ from .opencode_runtime import ensure_opencode_server, opencode_base_url, validate_opencode_model
- from .config import ConfigManager
-
- BASE_URL = "http://127.0.0.1:4096"
+ base_url = opencode_base_url()
# Get config for provider and model
config_manager = ConfigManager(get_config_path())
- opencode_provider = config_manager.get("opencode_provider", "anthropic")
- opencode_model = config_manager.get("opencode_model", "claude-opus-4-6")
+ opencode_provider = config_manager.get("opencode_provider", DEFAULT_OPENCODE_PROVIDER)
+ opencode_model = config_manager.get("opencode_model", DEFAULT_OPENCODE_MODEL)
from .prompts import FOLDER_NAME_PROMPT
folder_prompt = FOLDER_NAME_PROMPT.format(prompt=prompt)
- async with httpx.AsyncClient(base_url=BASE_URL, timeout=15.0) as client:
+ password = os.environ.get("OPENCODE_SERVER_PASSWORD")
+ username = os.environ.get("OPENCODE_SERVER_USERNAME", "opencode")
+ auth = httpx.BasicAuth(username, password) if password else None
+
+ async with httpx.AsyncClient(base_url=base_url, timeout=15.0, auth=auth) as client:
try:
- await client.get("/global/health")
+ env_overrides: dict[str, str] = {}
+ if opencode_provider == "ollama":
+ ollama_setup = await prepare_ollama_model(opencode_model)
+ env_overrides = opencode_ollama_env(ollama_setup)
+ await ensure_opencode_server(client, base_url=base_url, env_overrides=env_overrides)
+ if opencode_provider == "ollama":
+ await validate_opencode_ollama_provider(client, opencode_model)
+ await validate_opencode_model(client, opencode_provider, opencode_model)
except Exception as e:
- raise Exception("OpenCode server not responding") from e
+ raise Exception(f"OpenCode server not responding: {e}") from e
session_created = False
if session_id is None:
diff --git a/tests/test_auto_engineer.py b/tests/test_auto_engineer.py
index 9764e47..57d94a9 100644
--- a/tests/test_auto_engineer.py
+++ b/tests/test_auto_engineer.py
@@ -45,6 +45,26 @@ def _sdk_result_message(*, is_error: bool = False, result: str | None = None) ->
)
+def _valid_catalog_response() -> MagicMock:
+ response = MagicMock()
+ response.raise_for_status = MagicMock()
+ response.json.return_value = {
+ "default": {"anthropic": "claude-opus-4-6"},
+ "providers": [
+ {
+ "id": "anthropic",
+ "models": {
+ "claude-opus-4-6": {
+ "status": "active",
+ "capabilities": {"toolcall": True},
+ }
+ },
+ }
+ ],
+ }
+ return response
+
+
class TestClaudeAutoEngineerInit:
"""Test ClaudeAutoEngineer initialization."""
@@ -915,6 +935,8 @@ class TestOpenCodeAutoEngineerAnalyze:
async def mock_get(path, **kwargs):
if path == "/global/health":
return mock_health
+ if path == "/config/providers":
+ return _valid_catalog_response()
if "/message" in path:
return mock_messages
return MagicMock()
@@ -1099,6 +1121,8 @@ class TestOpenCodeAutoEngineerAnalyze:
async def mock_get(path, **kwargs):
if path == "/global/health":
return mock_health
+ if path == "/config/providers":
+ return _valid_catalog_response()
if "/message" in path:
return mock_messages
return MagicMock()
@@ -1157,6 +1181,8 @@ class TestOpenCodeAutoEngineerAnalyze:
async def mock_get(path, **kwargs):
if path == "/global/health":
return mock_health
+ if path == "/config/providers":
+ return _valid_catalog_response()
return MagicMock()
async def mock_post(path, **kwargs):
diff --git a/tests/test_cli_ollama.py b/tests/test_cli_ollama.py
new file mode 100644
index 0000000..d138789
--- /dev/null
+++ b/tests/test_cli_ollama.py
@@ -0,0 +1,67 @@
+"""Tests for Ollama model selection in CLI settings."""
+
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from reverse_api import cli
+from reverse_api.ollama_runtime import OllamaModel, OllamaStatus
+
+
+def _model(name: str, *, size: int = 100) -> OllamaModel:
+ return OllamaModel(
+ name=name,
+ size=size,
+ capabilities=("completion", "tools"),
+ context_length=131_072,
+ parameter_size="20B",
+ )
+
+
+def test_single_compatible_model_is_selected_without_prompt():
+ status = OllamaStatus(base_url="http://127.0.0.1:11434", models=(_model("only:model"),))
+
+ with patch("reverse_api.ollama_runtime.ensure_ollama_models", new=AsyncMock(return_value=status)):
+ with patch.object(cli.questionary, "select") as select:
+ selected = cli._select_ollama_model_for_settings()
+
+ assert selected == "only:model"
+ select.assert_not_called()
+
+
+def test_multiple_compatible_models_show_picker():
+ status = OllamaStatus(
+ base_url="http://127.0.0.1:11434",
+ models=(_model("local:model", size=2_000_000_000), _model("cloud:model")),
+ )
+ prompt = MagicMock()
+ prompt.ask.return_value = "cloud:model"
+
+ with patch("reverse_api.ollama_runtime.ensure_ollama_models", new=AsyncMock(return_value=status)):
+ with patch.object(cli.questionary, "select", return_value=prompt) as select:
+ selected = cli._select_ollama_model_for_settings()
+
+ assert selected == "cloud:model"
+ choices = select.call_args.kwargs["choices"]
+ assert "1.9 GB" in choices[0].title
+ assert "cloud" in choices[1].title
+
+
+def test_live_opencode_picker_always_offers_ollama():
+ """Ollama can bootstrap itself even when it is absent from OpenCode's current catalog."""
+ catalog = {"default": {}, "providers": []}
+ provider_prompt = MagicMock()
+ provider_prompt.ask.return_value = "ollama"
+
+ with patch.object(
+ cli,
+ "_load_opencode_catalog_for_settings",
+ new=AsyncMock(return_value=catalog),
+ ):
+ with patch.object(cli.questionary, "select", return_value=provider_prompt) as select:
+ with patch.object(cli, "_select_ollama_model_for_settings", return_value="qwen3:8b"):
+ selected = cli._select_opencode_pair_for_settings()
+
+ assert selected == ("ollama", "qwen3:8b")
+ choices = select.call_args.kwargs["choices"]
+ assert [choice.value for choice in choices] == ["ollama", "back"]
diff --git a/tests/test_cli_settings.py b/tests/test_cli_settings.py
new file mode 100644
index 0000000..d94bf81
--- /dev/null
+++ b/tests/test_cli_settings.py
@@ -0,0 +1,97 @@
+"""Tests for the interactive settings navigation."""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import httpx
+
+from reverse_api import cli
+
+
+def test_settings_stays_open_until_back():
+ """Changing settings should return to settings, not the REPL."""
+ with patch.object(cli, "_handle_settings_action", side_effect=[True, True, False]) as action:
+ cli.handle_settings("magenta")
+
+ assert action.call_count == 3
+
+
+def _answer(value):
+ question = MagicMock()
+ question.ask.return_value = value
+ return question
+
+
+def _catalog():
+ return {
+ "default": {"opencode": "big-pickle"},
+ "providers": [
+ {
+ "id": "opencode",
+ "name": "OpenCode Zen",
+ "models": {
+ "big-pickle": {
+ "name": "Big Pickle",
+ "status": "active",
+ "cost": {"input": 0, "output": 0},
+ "capabilities": {"toolcall": True},
+ },
+ "no-tools": {
+ "status": "active",
+ "capabilities": {"toolcall": False},
+ },
+ },
+ }
+ ],
+ }
+
+
+def test_opencode_pair_picker_uses_live_tool_capable_catalog():
+ """The picker only returns a provider/model pair exposed by OpenCode."""
+ with patch.object(cli.console, "status") as loading:
+ with patch.object(
+ cli,
+ "_load_opencode_catalog_for_settings",
+ new=AsyncMock(return_value=_catalog()),
+ ):
+ with patch.object(
+ cli.questionary,
+ "select",
+ side_effect=[_answer("opencode"), _answer("big-pickle")],
+ ) as select:
+ pair = cli._select_opencode_pair_for_settings("magenta")
+
+ assert pair == ("opencode", "big-pickle")
+ loading.assert_called_once_with(" Loading OpenCode providers and models...", spinner="dots")
+ model_choices = select.call_args_list[1].kwargs["choices"]
+ assert [choice.value for choice in model_choices] == ["big-pickle", "back"]
+ assert "free" in model_choices[0].title
+ assert select.call_args_list[0].kwargs["use_jk_keys"] is False
+ assert select.call_args_list[1].kwargs["use_search_filter"] is True
+ assert select.call_args_list[1].kwargs["use_jk_keys"] is False
+
+
+def test_opencode_pair_is_saved_atomically():
+ """Settings never persist only one half of a provider/model pair."""
+ with patch.object(cli.questionary, "select", return_value=_answer("opencode_pair")):
+ with patch.object(cli, "_select_opencode_pair_for_settings", return_value=("google", "gemini-3-flash")):
+ with patch.object(cli.config_manager, "update") as update:
+ assert cli._handle_settings_action("magenta") is True
+
+ update.assert_called_once_with({"opencode_provider": "google", "opencode_model": "gemini-3-flash"})
+
+
+def test_opencode_pair_picker_explains_server_authentication():
+ """A password-protected server produces a settings-specific auth hint."""
+ request = httpx.Request("GET", "http://127.0.0.1:4096/config/providers")
+ response = httpx.Response(401, request=request)
+ error = httpx.HTTPStatusError("unauthorized", request=request, response=response)
+ with patch.object(
+ cli,
+ "_load_opencode_catalog_for_settings",
+ new=AsyncMock(side_effect=error),
+ ):
+ with patch.object(cli.console, "print") as print_message:
+ assert cli._select_opencode_pair_for_settings() is None
+
+ output = " ".join(str(call.args[0]) for call in print_message.call_args_list)
+ assert "OPENCODE_SERVER_PASSWORD" in output
diff --git a/tests/test_config.py b/tests/test_config.py
index 046591b..bc27654 100644
--- a/tests/test_config.py
+++ b/tests/test_config.py
@@ -153,6 +153,11 @@ class TestDefaultConfig:
"cursor_web_search",
"opencode_model",
"opencode_provider",
+ "opencode_auto_start",
+ "opencode_base_url",
+ "opencode_npx_package",
+ "ollama_auto_start",
+ "ollama_base_url",
"output_dir",
"output_language",
"real_time_sync",
@@ -169,3 +174,9 @@ class TestDefaultConfig:
assert DEFAULT_CONFIG["cursor_model"] == "composer-2.5"
assert DEFAULT_CONFIG["cursor_web_search"] is True
assert DEFAULT_CONFIG["cursor_setting_sources"] is None
+ assert DEFAULT_CONFIG["opencode_provider"] == "opencode"
+ assert DEFAULT_CONFIG["opencode_model"] == "big-pickle"
+ assert DEFAULT_CONFIG["opencode_auto_start"] is True
+ assert DEFAULT_CONFIG["opencode_npx_package"] == "opencode-ai@latest"
+ assert DEFAULT_CONFIG["ollama_auto_start"] is True
+ assert DEFAULT_CONFIG["ollama_base_url"] == "http://127.0.0.1:11434"
diff --git a/tests/test_ollama_runtime.py b/tests/test_ollama_runtime.py
new file mode 100644
index 0000000..f43c57c
--- /dev/null
+++ b/tests/test_ollama_runtime.py
@@ -0,0 +1,205 @@
+"""Tests for Ollama discovery and OpenCode configuration."""
+
+from __future__ import annotations
+
+import json
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import httpx
+import pytest
+
+from reverse_api import ollama_runtime
+
+
+def _tags_payload() -> dict:
+ return {
+ "models": [
+ {
+ "name": "qwen3:4b",
+ "size": 2_497_000_000,
+ },
+ {
+ "name": "tiny:no-tools",
+ "size": 100,
+ },
+ {
+ "name": "tools:short-context",
+ "size": 200,
+ },
+ ]
+ }
+
+
+def _show_payload(model: str) -> dict:
+ metadata = {
+ "qwen3:4b": ("qwen3", ["completion", "tools", "thinking"], "4.0B", 262_144),
+ "tiny:no-tools": ("llama", ["completion"], "1B", 131_072),
+ "tools:short-context": ("qwen", ["completion", "tools"], "2B", 32_768),
+ }
+ architecture, capabilities, parameter_size, context_length = metadata[model]
+ return {
+ "capabilities": capabilities,
+ "details": {"parameter_size": parameter_size},
+ "model_info": {
+ "general.architecture": architecture,
+ f"{architecture}.context_length": context_length,
+ },
+ }
+
+
+def _models() -> tuple[ollama_runtime.OllamaModel, ...]:
+ return tuple(ollama_runtime._parse_model(tag, _show_payload(tag["name"])) for tag in _tags_payload()["models"])
+
+
+def _response(payload: dict | None = None) -> MagicMock:
+ response = MagicMock()
+ response.raise_for_status = MagicMock()
+ response.json.return_value = payload if payload is not None else _tags_payload()
+ return response
+
+
[email protected](autouse=True)
+def reset_runtime_state():
+ ollama_runtime._PROCESS = None
+ ollama_runtime._PROCESS_URL = None
+ ollama_runtime._PROCESS_CONTEXT_LENGTH = None
+ yield
+ ollama_runtime._PROCESS = None
+ ollama_runtime._PROCESS_URL = None
+ ollama_runtime._PROCESS_CONTEXT_LENGTH = None
+
+
+def test_parse_show_metadata_filters_agent_compatible_models():
+ models = _models()
+ status = ollama_runtime.OllamaStatus(base_url="http://127.0.0.1:11434", models=models)
+
+ assert [model.name for model in models] == ["qwen3:4b", "tiny:no-tools", "tools:short-context"]
+ assert [model.name for model in status.compatible_models] == ["qwen3:4b"]
+
+
+async def test_reuses_running_ollama():
+ client = AsyncMock()
+ client.get = AsyncMock(return_value=_response())
+ client.post = AsyncMock(side_effect=lambda _path, json: _response(_show_payload(json["model"])))
+
+ with patch.object(ollama_runtime.httpx, "AsyncClient") as async_client:
+ async_client.return_value.__aenter__ = AsyncMock(return_value=client)
+ async_client.return_value.__aexit__ = AsyncMock(return_value=False)
+ status = await ollama_runtime.ensure_ollama_models()
+
+ assert status.started is False
+ assert status.allocated_context_length is None
+ assert status.models[0].name == "qwen3:4b"
+ assert status.models[0].supports_opencode is True
+ assert client.post.await_count == 3
+ client.post.assert_any_await("/api/show", json={"model": "qwen3:4b"})
+
+
+async def test_starts_installed_ollama_daemon(monkeypatch: pytest.MonkeyPatch):
+ monkeypatch.setenv("RAE_OLLAMA_BASE_URL", "127.0.0.1:11434")
+ request = httpx.Request("GET", "http://127.0.0.1:11434/api/tags")
+ client = AsyncMock()
+ client.get = AsyncMock(side_effect=[httpx.ConnectError("refused", request=request), _response()])
+ client.post = AsyncMock(side_effect=lambda _path, json: _response(_show_payload(json["model"])))
+ process = MagicMock()
+ process.poll.return_value = None
+
+ with patch.object(ollama_runtime.httpx, "AsyncClient") as async_client:
+ async_client.return_value.__aenter__ = AsyncMock(return_value=client)
+ async_client.return_value.__aexit__ = AsyncMock(return_value=False)
+ with patch.object(ollama_runtime.shutil, "which", return_value="/usr/local/bin/ollama"):
+ with patch.object(ollama_runtime.subprocess, "Popen", return_value=process) as popen:
+ status = await ollama_runtime.ensure_ollama_models(timeout=1)
+
+ assert status.started is True
+ assert popen.call_args.args[0] == ["/usr/local/bin/ollama", "serve"]
+ assert popen.call_args.kwargs["env"]["OLLAMA_HOST"] == "127.0.0.1:11434"
+ assert popen.call_args.kwargs["env"]["OLLAMA_CONTEXT_LENGTH"] == "65536"
+ assert status.allocated_context_length == 65_536
+
+
+ ("model_name", "message"),
+ [
+ ("missing:model", "not installed"),
+ ("tiny:no-tools", "does not advertise tool calling"),
+ ("tools:short-context", "requires at least 65,536"),
+ ],
+)
+async def test_prepare_model_rejects_incompatible_models(model_name: str, message: str):
+ status = ollama_runtime.OllamaStatus(
+ base_url="http://127.0.0.1:11434",
+ models=_models(),
+ )
+ with patch.object(ollama_runtime, "ensure_ollama_models", new=AsyncMock(return_value=status)):
+ with pytest.raises(ollama_runtime.OllamaSetupError, match=message):
+ await ollama_runtime.prepare_ollama_model(model_name)
+
+
+def test_opencode_env_preserves_existing_config(monkeypatch: pytest.MonkeyPatch):
+ monkeypatch.setenv("OPENCODE_CONFIG_CONTENT", '{"plugin":["example"],"provider":{"custom":{"name":"Custom"}}}')
+ status = ollama_runtime.OllamaStatus(
+ base_url="http://127.0.0.1:11434",
+ models=_models(),
+ )
+ setup = ollama_runtime.OllamaProviderSetup(status=status, model=status.models[0])
+
+ env = ollama_runtime.opencode_ollama_env(setup)
+ config = json.loads(env["OPENCODE_CONFIG_CONTENT"])
+
+ assert config["plugin"] == ["example"]
+ assert config["provider"]["custom"]["name"] == "Custom"
+ assert config["provider"]["ollama"]["options"]["baseURL"] == "http://127.0.0.1:11434/v1"
+ assert list(config["provider"]["ollama"]["models"]) == ["qwen3:4b"]
+ assert config["provider"]["ollama"]["models"]["qwen3:4b"]["limit"]["context"] == 262_144
+ assert config["small_model"] == "ollama/qwen3:4b"
+
+
+def test_opencode_env_advertises_managed_context_allocation():
+ status = ollama_runtime.OllamaStatus(
+ base_url="http://127.0.0.1:11434",
+ models=_models(),
+ started=True,
+ allocated_context_length=65_536,
+ )
+ setup = ollama_runtime.OllamaProviderSetup(status=status, model=status.models[0])
+
+ config = json.loads(ollama_runtime.opencode_ollama_env(setup)["OPENCODE_CONFIG_CONTENT"])
+
+ assert config["provider"]["ollama"]["models"]["qwen3:4b"]["limit"]["context"] == 65_536
+
+
+async def test_validate_existing_opencode_ollama_config():
+ client = AsyncMock()
+ client.get = AsyncMock(return_value=_response({"provider": {"ollama": {"models": {"qwen3:4b": {"name": "qwen3:4b"}}}}}))
+
+ await ollama_runtime.validate_opencode_ollama_provider(client, "qwen3:4b")
+
+ client.get.assert_awaited_once_with("/config", timeout=5.0)
+
+
+async def test_validate_existing_opencode_requires_model_config():
+ client = AsyncMock()
+ client.get = AsyncMock(return_value=_response({"provider": {}}))
+
+ with pytest.raises(ollama_runtime.OllamaSetupError, match="not configured"):
+ await ollama_runtime.validate_opencode_ollama_provider(client, "qwen3:4b")
+
+
+def test_stop_managed_ollama_server():
+ process = MagicMock()
+ process.poll.return_value = None
+ ollama_runtime._PROCESS = process
+ ollama_runtime._PROCESS_URL = "http://127.0.0.1:11434"
+ ollama_runtime._PROCESS_CONTEXT_LENGTH = 65_536
+
+ ollama_runtime.stop_managed_ollama_server()
+
+ process.terminate.assert_called_once_with()
+ process.wait.assert_called_once_with(timeout=3)
+ assert ollama_runtime._PROCESS_CONTEXT_LENGTH is None
diff --git a/tests/test_opencode_engineer.py b/tests/test_opencode_engineer.py
index ebb37d7..e0cf90c 100644
--- a/tests/test_opencode_engineer.py
+++ b/tests/test_opencode_engineer.py
@@ -17,6 +17,35 @@ from reverse_api.opencode_engineer import (
)
+def _valid_catalog_response() -> MagicMock:
+ response = MagicMock()
+ response.raise_for_status = MagicMock()
+ response.json.return_value = {
+ "default": {"opencode": "big-pickle"},
+ "providers": [
+ {
+ "id": "opencode",
+ "models": {
+ "big-pickle": {
+ "status": "active",
+ "capabilities": {"toolcall": True},
+ }
+ },
+ },
+ {
+ "id": "anthropic",
+ "models": {
+ "claude-opus-4-6": {
+ "status": "active",
+ "capabilities": {"toolcall": True},
+ }
+ },
+ }
+ ],
+ }
+ return response
+
+
class TestDebugLog:
"""Test debug_log function."""
@@ -190,8 +219,8 @@ class TestOpenCodeEngineerInit:
prompt="test prompt",
output_dir=str(tmp_path),
)
- assert eng.opencode_provider == "anthropic"
- assert eng.opencode_model == "claude-opus-4-6"
+ assert eng.opencode_provider == "opencode"
+ assert eng.opencode_model == "big-pickle"
class TestOpenCodeEngineerAuth:
@@ -254,6 +283,7 @@ class TestOpenCodeEngineerHandlePartUpdate:
output_dir=str(tmp_path),
)
eng._session_id = "session_abc"
+ eng._assistant_message_ids.add("message_assistant")
return eng
@pytest.mark.asyncio
@@ -267,6 +297,7 @@ class TestOpenCodeEngineerHandlePartUpdate:
"type": "text",
"text": "x" * 100,
"sessionID": "session_abc",
+ "messageID": "message_assistant",
},
"delta": None,
}
@@ -285,12 +316,32 @@ class TestOpenCodeEngineerHandlePartUpdate:
"type": "text",
"text": "ok",
"sessionID": "session_abc",
+ "messageID": "message_assistant",
},
"delta": None,
}
await eng._handle_part_update(properties, seen_parts)
eng.message_store.save_thinking.assert_not_called()
+ @pytest.mark.asyncio
+ async def test_user_text_part_is_not_rendered(self, tmp_path):
+ """The submitted internal prompt must not appear as assistant output."""
+ eng = self._make_engineer(tmp_path)
+ properties = {
+ "part": {
+ "id": "part-user",
+ "messageID": "message_user",
+ "type": "text",
+ "text": "There is no HAR file — capture all network data.",
+ "sessionID": "session_abc",
+ }
+ }
+
+ await eng._handle_part_update(properties, set())
+
+ eng.opencode_ui.update_text.assert_not_called()
+ eng.message_store.save_thinking.assert_not_called()
+
@pytest.mark.asyncio
async def test_tool_running(self, tmp_path):
"""Running tool part starts tool in UI."""
@@ -543,6 +594,42 @@ class TestOpenCodeEngineerStreamEvents:
eng.opencode_ui.permission_requested.assert_called_with("write", "Write file")
eng.opencode_ui.permission_approved.assert_called_with("write")
+ @pytest.mark.asyncio
+ async def test_permission_v2_event_uses_current_reply_endpoint(self, tmp_path):
+ """OpenCode 1.18 permission.v2 events use the non-deprecated endpoint."""
+ eng = self._make_engineer(tmp_path)
+
+ lines = [
+ (
+ 'data: {"type":"permission.v2.asked","properties":{"id":"per_1","sessionID":"session_abc",'
+ '"action":"write","resources":["/tmp/client.py"]}}'
+ ),
+ 'data: {"type":"session.idle","properties":{"sessionID":"session_abc"}}',
+ ]
+ mock_response = AsyncMock()
+
+ async def mock_aiter_lines():
+ for line in lines:
+ yield line
+
+ mock_response.aiter_lines = mock_aiter_lines
+ stream = AsyncMock()
+ stream.__aenter__ = AsyncMock(return_value=mock_response)
+ stream.__aexit__ = AsyncMock(return_value=False)
+
+ mock_client = AsyncMock()
+ mock_client.stream = MagicMock(return_value=stream)
+ mock_client.post = AsyncMock(return_value=MagicMock(status_code=204))
+
+ await eng._stream_events(mock_client)
+
+ mock_client.post.assert_awaited_once_with(
+ "/api/session/session_abc/permission/per_1/reply",
+ json={"reply": "always"},
+ )
+ eng.opencode_ui.permission_requested.assert_called_once_with("write", "/tmp/client.py")
+ eng.opencode_ui.permission_approved.assert_called_once_with("write")
+
@pytest.mark.asyncio
async def test_todo_updated_event(self, tmp_path):
"""todo.updated event updates UI."""
@@ -682,6 +769,7 @@ class TestOpenCodeEngineerStreamEvents:
await eng._stream_events(mock_client)
assert "Auth error" in eng._last_error
assert "anthropic" in eng._last_error
+ eng.opencode_ui.error.assert_not_called()
@pytest.mark.asyncio
async def test_session_error_api_error(self, tmp_path):
@@ -710,6 +798,40 @@ class TestOpenCodeEngineerStreamEvents:
await eng._stream_events(mock_client)
assert "API error" in eng._last_error
assert "429" in eng._last_error
+ eng.opencode_ui.error.assert_not_called()
+
+ @pytest.mark.asyncio
+ async def test_session_error_no_provider_available(self, tmp_path):
+ """Zen capacity errors are explained without being displayed twice."""
+ eng = self._make_engineer(tmp_path)
+
+ lines = [
+ "data: "
+ '{"type":"session.error","properties":{"sessionID":"session_abc",'
+ '"error":{"name":"APIError","data":{"message":"No provider available","statusCode":401}}}}',
+ ]
+
+ mock_response = AsyncMock()
+
+ async def mock_aiter_lines():
+ for line in lines:
+ yield line
+
+ mock_response.aiter_lines = mock_aiter_lines
+
+ cm = AsyncMock()
+ cm.__aenter__ = AsyncMock(return_value=mock_response)
+ cm.__aexit__ = AsyncMock(return_value=False)
+
+ mock_client = AsyncMock()
+ mock_client.stream = MagicMock(return_value=cm)
+
+ await eng._stream_events(mock_client)
+ assert eng._last_error == (
+ "OpenCode has no serving provider available for this model right now. "
+ "Try another free model or retry later."
+ )
+ eng.opencode_ui.error.assert_not_called()
@pytest.mark.asyncio
async def test_session_error_aborted(self, tmp_path):
@@ -940,6 +1062,120 @@ class TestOpenCodeEngineerStreamEvents:
await eng._stream_events(mock_client)
mock_handle.assert_called_once()
+ @pytest.mark.asyncio
+ async def test_stream_renders_only_assistant_text(self, tmp_path):
+ """Parts arriving before their roles are known are safely buffered."""
+ eng = self._make_engineer(tmp_path)
+ lines = [
+ 'data: {"type":"message.part.updated","properties":{"sessionID":"session_abc",'
+ '"part":{"id":"part_user","messageID":"message_user","sessionID":"session_abc",'
+ '"type":"text","text":"There is no HAR file — capture all network data."}}}',
+ 'data: {"type":"message.part.updated","properties":{"sessionID":"session_abc",'
+ '"part":{"id":"part_assistant","messageID":"message_assistant","sessionID":"session_abc",'
+ '"type":"text","text":"Assistant answer","time":{"start":1,"end":2}}}}',
+ 'data: {"type":"message.updated","properties":{"sessionID":"session_abc",'
+ '"info":{"id":"message_user","sessionID":"session_abc","role":"user"}}}',
+ 'data: {"type":"message.updated","properties":{"sessionID":"session_abc",'
+ '"info":{"id":"message_assistant","sessionID":"session_abc","role":"assistant"}}}',
+ 'data: {"type":"session.idle","properties":{"sessionID":"session_abc"}}',
+ ]
+ mock_response = AsyncMock()
+
+ async def mock_aiter_lines():
+ for line in lines:
+ yield line
+
+ mock_response.aiter_lines = mock_aiter_lines
+ cm = AsyncMock()
+ cm.__aenter__ = AsyncMock(return_value=mock_response)
+ cm.__aexit__ = AsyncMock(return_value=False)
+ mock_client = AsyncMock()
+ mock_client.stream = MagicMock(return_value=cm)
+
+ await eng._stream_events(mock_client)
+
+ eng.opencode_ui.update_text.assert_called_once_with("Assistant answer", None)
+ assert eng._pending_text_parts == {}
+
+ @pytest.mark.asyncio
+ @pytest.mark.parametrize(
+ "idle_event",
+ [
+ 'data: {"type":"session.idle","properties":{"sessionID":"session_abc"}}',
+ 'data: {"type":"session.status","properties":{"sessionID":"session_abc","status":{"type":"idle"}}}',
+ ],
+ )
+ async def test_idle_reconciles_buffered_assistant_role(self, tmp_path, idle_event):
+ """Idle resolves buffered roles from final state without waiting on SSE order."""
+ eng = self._make_engineer(tmp_path)
+ lines = [
+ 'data: {"type":"message.part.updated","properties":{"sessionID":"session_abc",'
+ '"part":{"id":"part_user","messageID":"message_user","sessionID":"session_abc",'
+ '"type":"text","text":"Internal user prompt"}}}',
+ 'data: {"type":"message.part.updated","properties":{"sessionID":"session_abc",'
+ '"part":{"id":"part_assistant","messageID":"message_assistant","sessionID":"session_abc",'
+ '"type":"text","text":"Late assistant answer"}}}',
+ idle_event,
+ 'data: {"type":"message.updated","properties":{"sessionID":"session_abc",'
+ '"info":{"id":"message_assistant","sessionID":"session_abc","role":"assistant"}}}',
+ ]
+ mock_response = AsyncMock()
+
+ async def mock_aiter_lines():
+ for line in lines:
+ yield line
+
+ mock_response.aiter_lines = mock_aiter_lines
+ cm = AsyncMock()
+ cm.__aenter__ = AsyncMock(return_value=mock_response)
+ cm.__aexit__ = AsyncMock(return_value=False)
+ mock_client = AsyncMock()
+ mock_client.stream = MagicMock(return_value=cm)
+ final_response = MagicMock(status_code=200)
+ final_response.json.return_value = [
+ {"info": {"id": "message_user", "sessionID": "session_abc", "role": "user"}},
+ {"info": {"id": "message_assistant", "sessionID": "session_abc", "role": "assistant"}},
+ ]
+ mock_client.get = AsyncMock(return_value=final_response)
+
+ await eng._stream_events(mock_client)
+
+ assert eng._last_error is None
+ eng.opencode_ui.update_text.assert_called_once_with("Late assistant answer", None)
+ assert eng._pending_text_parts == {}
+ mock_client.get.assert_awaited_once_with("/session/session_abc/message")
+
+ @pytest.mark.asyncio
+ async def test_idle_with_unresolved_buffer_reports_specific_error(self, tmp_path):
+ """A closed stream cannot turn unresolved buffered output into success."""
+ eng = self._make_engineer(tmp_path)
+ lines = [
+ 'data: {"type":"message.part.updated","properties":{"sessionID":"session_abc",'
+ '"part":{"id":"part_assistant","messageID":"message_assistant","sessionID":"session_abc",'
+ '"type":"text","text":"Unresolved answer"}}}',
+ 'data: {"type":"session.idle","properties":{"sessionID":"session_abc"}}',
+ ]
+ mock_response = AsyncMock()
+
+ async def mock_aiter_lines():
+ for line in lines:
+ yield line
+
+ mock_response.aiter_lines = mock_aiter_lines
+ cm = AsyncMock()
+ cm.__aenter__ = AsyncMock(return_value=mock_response)
+ cm.__aexit__ = AsyncMock(return_value=False)
+ mock_client = AsyncMock()
+ mock_client.stream = MagicMock(return_value=cm)
+ final_response = MagicMock(status_code=200)
+ final_response.json.return_value = []
+ mock_client.get = AsyncMock(return_value=final_response)
+
+ await eng._stream_events(mock_client)
+
+ assert eng._last_error == "OpenCode completed without role metadata for buffered message(s): message_assistant."
+ eng.opencode_ui.update_text.assert_not_called()
+
@pytest.mark.asyncio
async def test_empty_and_non_data_lines_skipped(self, tmp_path):
"""Empty lines and non-data lines are skipped."""
@@ -1043,7 +1279,7 @@ class TestOpenCodeEngineerStreamEvents:
@pytest.mark.asyncio
async def test_permission_approval_fails(self, tmp_path):
- """Permission approval failure is handled gracefully."""
+ """Permission transport failures stop the stream immediately."""
eng = self._make_engineer(tmp_path)
lines = [
@@ -1068,7 +1304,36 @@ class TestOpenCodeEngineerStreamEvents:
mock_client.post = AsyncMock(side_effect=Exception("permission failed"))
await eng._stream_events(mock_client)
- # Should not raise
+ assert eng._last_error == "Permission approval failed for write: permission failed"
+ eng.opencode_ui.session_status.assert_not_called()
+
+ @pytest.mark.asyncio
+ async def test_permission_rejection_reports_status_and_stops_stream(self, tmp_path):
+ """A rejected permission reply is fatal instead of timing out later."""
+ eng = self._make_engineer(tmp_path)
+ lines = [
+ 'data: {"type":"permission.v2.asked","properties":{"id":"perm1","sessionID":"session_abc","action":"write"}}',
+ 'data: {"type":"session.idle","properties":{"sessionID":"session_abc"}}',
+ ]
+ mock_response = AsyncMock()
+
+ async def mock_aiter_lines():
+ for line in lines:
+ yield line
+
+ mock_response.aiter_lines = mock_aiter_lines
+ cm = AsyncMock()
+ cm.__aenter__ = AsyncMock(return_value=mock_response)
+ cm.__aexit__ = AsyncMock(return_value=False)
+ mock_client = AsyncMock()
+ mock_client.stream = MagicMock(return_value=cm)
+ mock_client.post = AsyncMock(return_value=MagicMock(status_code=403))
+
+ await eng._stream_events(mock_client)
+
+ assert eng._last_error == "Permission approval failed for write: OpenCode returned HTTP 403."
+ eng.opencode_ui.permission_approved.assert_not_called()
+ eng.opencode_ui.session_status.assert_not_called()
class TestOpenCodeEngineerAnalyzeAndGenerate:
@@ -1092,6 +1357,48 @@ class TestOpenCodeEngineerAnalyzeAndGenerate:
eng.scripts_dir.mkdir(parents=True, exist_ok=True)
return eng
+ @pytest.mark.asyncio
+ async def test_prepare_server_configures_ollama_before_opencode(self, tmp_path):
+ eng = self._make_engineer(tmp_path)
+ eng.opencode_provider = "ollama"
+ eng.opencode_model = "qwen3:4b"
+ client = AsyncMock()
+ ollama_setup = MagicMock()
+ ollama_setup.status.started = False
+ server = MagicMock(started=True, package="opencode-ai@latest", health={"version": "1.18.4"})
+
+ with patch(
+ "reverse_api.opencode_engineer.prepare_ollama_model",
+ new=AsyncMock(return_value=ollama_setup),
+ ) as prepare:
+ with patch(
+ "reverse_api.opencode_engineer.opencode_ollama_env",
+ return_value={"OPENCODE_CONFIG_CONTENT": "{}"},
+ ):
+ with patch(
+ "reverse_api.opencode_engineer.ensure_opencode_server",
+ new=AsyncMock(return_value=server),
+ ) as ensure:
+ with patch(
+ "reverse_api.opencode_engineer.validate_opencode_ollama_provider",
+ new=AsyncMock(),
+ ) as validate:
+ with patch(
+ "reverse_api.opencode_engineer.validate_opencode_model",
+ new=AsyncMock(),
+ ) as validate_model:
+ assert await eng._prepare_server(client) is True
+
+ prepare.assert_awaited_once_with("qwen3:4b")
+ ensure.assert_awaited_once_with(
+ client,
+ base_url=eng.BASE_URL,
+ env_overrides={"OPENCODE_CONFIG_CONTENT": "{}"},
+ )
+ validate.assert_awaited_once_with(client, "qwen3:4b")
+ validate_model.assert_awaited_once_with(client, "ollama", "qwen3:4b")
+ eng.opencode_ui.ollama_ready.assert_called_once_with("qwen3:4b", False)
+
@pytest.mark.asyncio
async def test_health_check_401(self, tmp_path):
"""401 on health check returns None."""
@@ -1209,6 +1516,8 @@ class TestOpenCodeEngineerAnalyzeAndGenerate:
async def mock_get(path, **kwargs):
if path == "/global/health":
return health_response
+ if path == "/config/providers":
+ return _valid_catalog_response()
if "/message" in path:
return messages_response
return MagicMock()
@@ -1315,6 +1624,8 @@ class TestOpenCodeEngineerAnalyzeAndGenerate:
get_count[0] += 1
if path == "/global/health":
return health_response
+ if path == "/config/providers":
+ return _valid_catalog_response()
if "/message" in path:
raise Exception("message fetch failed")
return MagicMock()
diff --git a/tests/test_opencode_runtime.py b/tests/test_opencode_runtime.py
new file mode 100644
index 0000000..c718eac
--- /dev/null
+++ b/tests/test_opencode_runtime.py
@@ -0,0 +1,280 @@
+"""Tests for managed OpenCode server startup."""
+
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import httpx
+import pytest
+
+from reverse_api import opencode_runtime
+
+
[email protected](autouse=True)
+def reset_runtime_state():
+ opencode_runtime._PROCESS = None
+ opencode_runtime._PROCESS_URL = None
+ opencode_runtime._PROCESS_ENV_OVERRIDES = {}
+ yield
+ opencode_runtime._PROCESS = None
+ opencode_runtime._PROCESS_URL = None
+ opencode_runtime._PROCESS_ENV_OVERRIDES = {}
+
+
+def _health_response(version: str = "1.18.4") -> MagicMock:
+ response = MagicMock()
+ response.raise_for_status = MagicMock()
+ response.json.return_value = {"healthy": True, "version": version}
+ return response
+
+
+def _catalog_response() -> MagicMock:
+ response = MagicMock()
+ response.raise_for_status = MagicMock()
+ response.json.return_value = {
+ "default": {"openai": "gpt-paid", "opencode": "big-pickle"},
+ "providers": [
+ {
+ "id": "openai",
+ "models": {
+ "gpt-paid": {
+ "status": "active",
+ "cost": {"input": 1, "output": 2},
+ "capabilities": {"toolcall": True},
+ }
+ },
+ },
+ {
+ "id": "opencode",
+ "models": {
+ "big-pickle": {
+ "status": "active",
+ "cost": {"input": 0, "output": 0},
+ "capabilities": {"toolcall": True},
+ },
+ "no-tools-free": {
+ "status": "active",
+ "cost": {"input": 0, "output": 0},
+ "capabilities": {"toolcall": False},
+ },
+ },
+ },
+ ],
+ }
+ return response
+
+
+async def test_reuses_healthy_server():
+ client = AsyncMock()
+ client.get = AsyncMock(return_value=_health_response())
+
+ status = await opencode_runtime.ensure_opencode_server(client, base_url="http://127.0.0.1:4096")
+
+ assert status.health["version"] == "1.18.4"
+ assert status.started is False
+ assert status.version_warning is None
+
+
+async def test_warns_for_compatible_but_older_server():
+ client = AsyncMock()
+ client.get = AsyncMock(return_value=_health_response("1.0.203"))
+
+ status = await opencode_runtime.ensure_opencode_server(client, base_url="http://127.0.0.1:4096")
+
+ assert "older than RAE's tested v1.18.4" in str(status.version_warning)
+
+
+async def test_validates_connected_provider_model_pair():
+ client = AsyncMock()
+ client.get = AsyncMock(return_value=_catalog_response())
+
+ await opencode_runtime.validate_opencode_model(client, "opencode", "big-pickle")
+
+ client.get.assert_awaited_once_with("/config/providers", timeout=10.0)
+
+
+async def test_model_catalog_endpoint_is_required_for_compatibility():
+ request = httpx.Request("GET", "http://127.0.0.1:4096/config/providers")
+ response = httpx.Response(404, request=request)
+ client = AsyncMock()
+ client.get = AsyncMock(return_value=response)
+
+ with pytest.raises(opencode_runtime.OpenCodeSetupError, match="server is incompatible"):
+ await opencode_runtime.validate_opencode_model(client, "opencode", "big-pickle")
+
+
+async def test_invalid_provider_suggests_connected_and_free_models():
+ client = AsyncMock()
+ client.get = AsyncMock(return_value=_catalog_response())
+
+ with pytest.raises(opencode_runtime.OpenCodeSetupError) as error:
+ await opencode_runtime.validate_opencode_model(client, "anthropic", "claude-opus-4-6")
+
+ message = str(error.value)
+ assert "provider 'anthropic' is not connected" in message
+ assert "Connected providers: openai, opencode" in message
+ assert "opencode/big-pickle" in message
+ assert "/settings" in message
+
+
+async def test_invalid_model_suggests_valid_pair_for_provider():
+ client = AsyncMock()
+ client.get = AsyncMock(return_value=_catalog_response())
+
+ with pytest.raises(opencode_runtime.OpenCodeSetupError) as error:
+ await opencode_runtime.validate_opencode_model(client, "openai", "missing")
+
+ message = str(error.value)
+ assert "openai/missing is not available" in message
+ assert "Try: openai/gpt-paid" in message
+ assert "opencode/big-pickle" in message
+
+
+async def test_rejects_model_without_tool_calling():
+ client = AsyncMock()
+ client.get = AsyncMock(return_value=_catalog_response())
+
+ with pytest.raises(opencode_runtime.OpenCodeSetupError, match="does not support tool calling"):
+ await opencode_runtime.validate_opencode_model(client, "opencode", "no-tools-free")
+
+
+async def test_starts_latest_package_without_global_opencode(monkeypatch: pytest.MonkeyPatch):
+ monkeypatch.setenv("OPENCODE_SERVER_PASSWORD", "secret")
+ request = httpx.Request("GET", "http://127.0.0.1:4096/global/health")
+ client = AsyncMock()
+ client.get = AsyncMock(side_effect=[httpx.ConnectError("refused", request=request), _health_response()])
+ process = MagicMock()
+ process.poll.return_value = None
+
+ with patch.object(opencode_runtime, "_config_manager_snapshot", return_value={}):
+ with patch.object(
+ opencode_runtime.shutil,
+ "which",
+ side_effect=lambda name: None if name == "opencode" else f"/bin/{name}",
+ ):
+ with patch.object(opencode_runtime.subprocess, "Popen", return_value=process) as popen:
+ status = await opencode_runtime.ensure_opencode_server(
+ client,
+ base_url="http://127.0.0.1:4096",
+ env_overrides={"OPENCODE_CONFIG_CONTENT": "{}"},
+ timeout=1,
+ )
+
+ assert status.started is True
+ assert status.package == "opencode-ai@latest"
+ assert client.get.await_args_list[0].kwargs == {"timeout": 2.0}
+ argv = popen.call_args.args[0]
+ assert argv == [
+ "/bin/npx",
+ "-y",
+ "opencode-ai@latest",
+ "serve",
+ "--hostname",
+ "127.0.0.1",
+ "--port",
+ "4096",
+ ]
+ assert popen.call_args.kwargs["env"]["OPENCODE_SERVER_PASSWORD"] == "secret"
+ assert popen.call_args.kwargs["env"]["OPENCODE_CONFIG_CONTENT"] == "{}"
+
+
+async def test_disabled_auto_start_has_actionable_error(monkeypatch: pytest.MonkeyPatch):
+ monkeypatch.setenv("RAE_OPENCODE_AUTO_START", "0")
+ request = httpx.Request("GET", "http://127.0.0.1:4096/global/health")
+ client = AsyncMock()
+ client.get = AsyncMock(side_effect=httpx.ConnectError("refused", request=request))
+
+ with pytest.raises(opencode_runtime.OpenCodeSetupError, match="disabled"):
+ await opencode_runtime.ensure_opencode_server(client, base_url="http://127.0.0.1:4096")
+
+
+async def test_restarts_managed_server_when_provider_config_changes():
+ client = AsyncMock()
+ client.get = AsyncMock(side_effect=[_health_response(), _health_response()])
+ old_process = MagicMock()
+ old_process.poll.return_value = None
+ new_process = MagicMock()
+ new_process.poll.return_value = None
+ opencode_runtime._PROCESS = old_process
+ opencode_runtime._PROCESS_URL = "http://127.0.0.1:4096"
+ opencode_runtime._PROCESS_ENV_OVERRIDES = {"OPENCODE_CONFIG_CONTENT": '{"old":true}'}
+
+ with patch.object(opencode_runtime, "_config_manager_snapshot", return_value={}):
+ with patch.object(opencode_runtime.shutil, "which", side_effect=lambda name: f"/bin/{name}"):
+ with patch.object(opencode_runtime.subprocess, "Popen", return_value=new_process):
+ status = await opencode_runtime.ensure_opencode_server(
+ client,
+ base_url="http://127.0.0.1:4096",
+ env_overrides={"OPENCODE_CONFIG_CONTENT": '{"ollama":true}'},
+ timeout=1,
+ )
+
+ assert status.started is True
+ old_process.terminate.assert_called_once_with()
+ assert opencode_runtime._PROCESS_ENV_OVERRIDES == {"OPENCODE_CONFIG_CONTENT": '{"ollama":true}'}
+
+
+async def test_refuses_to_auto_start_remote_host():
+ request = httpx.Request("GET", "https://opencode.example.com/global/health")
+ client = AsyncMock()
+ client.get = AsyncMock(side_effect=httpx.ConnectError("refused", request=request))
+
+ with patch.object(opencode_runtime, "_config_manager_snapshot", return_value={}):
+ with pytest.raises(opencode_runtime.OpenCodeSetupError, match="non-loopback"):
+ await opencode_runtime.ensure_opencode_server(client, base_url="http://opencode.example.com:4096")
+
+
+async def test_start_timeout_stops_managed_child():
+ request = httpx.Request("GET", "http://127.0.0.1:4096/global/health")
+ client = AsyncMock()
+ client.get = AsyncMock(side_effect=httpx.ConnectError("refused", request=request))
+ process = MagicMock()
+ process.poll.return_value = None
+
+ with patch.object(opencode_runtime, "_config_manager_snapshot", return_value={}):
+ with patch.object(opencode_runtime.shutil, "which", side_effect=lambda name: f"/bin/{name}"):
+ with patch.object(opencode_runtime.subprocess, "Popen", return_value=process):
+ with patch.object(opencode_runtime.time, "monotonic", side_effect=[0.0, 2.0]):
+ with pytest.raises(opencode_runtime.OpenCodeSetupError, match="Timed out"):
+ await opencode_runtime.ensure_opencode_server(
+ client,
+ base_url="http://127.0.0.1:4096",
+ timeout=1,
+ )
+
+ process.terminate.assert_called_once_with()
+
+
+def test_runtime_settings_environment_overrides(monkeypatch: pytest.MonkeyPatch):
+ monkeypatch.setenv("OPENCODE_BASE_URL", "http://localhost:7777/")
+ monkeypatch.setenv("RAE_OPENCODE_PACKAGE", "opencode-ai@test")
+ monkeypatch.setenv("RAE_OPENCODE_AUTO_START", "false")
+
+ assert opencode_runtime.opencode_base_url() == "http://localhost:7777"
+ assert opencode_runtime.opencode_npx_package() == "opencode-ai@test"
+ assert opencode_runtime.opencode_auto_start() is False
+
+
+def test_stop_managed_server_terminates_child():
+ process = MagicMock()
+ process.poll.return_value = None
+ opencode_runtime._PROCESS = process
+ opencode_runtime._PROCESS_URL = "http://127.0.0.1:4096"
+
+ opencode_runtime.stop_managed_opencode_server()
+
+ process.terminate.assert_called_once_with()
+ process.wait.assert_called_once_with(timeout=3)
+ assert opencode_runtime._PROCESS is None
diff --git a/tests/test_opencode_ui.py b/tests/test_opencode_ui.py
index f9a4a79..daaa477 100644
--- a/tests/test_opencode_ui.py
+++ b/tests/test_opencode_ui.py
@@ -56,6 +56,30 @@ class TestOpenCodeUI:
output = console.file.getvalue()
assert "1.2.3" in output
+ def test_server_started(self):
+ """Managed server startup shows package and address."""
+ ui, console = self._make_ui()
+ ui.server_started("opencode-ai@latest", "http://127.0.0.1:4096")
+ output = console.file.getvalue()
+ assert "opencode-ai@latest" in output
+ assert "127.0.0.1:4096" in output
+
+ def test_compatibility_warning(self):
+ """Compatibility warning is visible and concise."""
+ ui, console = self._make_ui()
+ ui.compatibility_warning("OpenCode is older than the tested version.")
+ output = console.file.getvalue()
+ assert "warning:" in output
+ assert "older than the tested version" in output
+
+ def test_ollama_ready(self):
+ """Ollama status shows whether RAE started or reused the daemon."""
+ ui, console = self._make_ui()
+ ui.ollama_ready("qwen3:4b", started=True)
+ output = console.file.getvalue()
+ assert "started" in output
+ assert "qwen3:4b" in output
+
def test_session_created(self):
"""Session created shows truncated ID."""
ui, console = self._make_ui()
@@ -218,6 +242,30 @@ class TestOpenCodeUI:
output = console.file.getvalue()
assert "error" in output
assert "Something went wrong" in output
+ assert "unexpected error" in output.lower()
+
+ def test_expected_provider_error_omits_issue_cta(self):
+ """Known provider availability errors should not ask for an issue report."""
+ ui, console = self._make_ui()
+ ui.error(
+ "OpenCode has no serving provider available for this model right now. "
+ "Try another free model or retry later."
+ )
+ output = console.file.getvalue()
+ assert "no serving provider available" in output
+ assert "unexpected error" not in output.lower()
+
+ def test_permission_failure_omits_issue_cta(self):
+ """A rejected OpenCode permission reply is an expected runtime failure."""
+ ui, console = self._make_ui()
+ ui.error("Permission approval failed for write: OpenCode returned HTTP 403.")
+ assert "unexpected error" not in console.file.getvalue().lower()
+
+ def test_explicit_expected_error_omits_issue_cta(self):
+ """Callers can explicitly classify an error as expected."""
+ ui, console = self._make_ui()
+ ui.error("Authentication failed", unexpected=False)
+ assert "unexpected error" not in console.file.getvalue().lower()
def test_error_rich_markup(self):
"""Error with Rich markup passes through."""
diff --git a/tests/test_utils.py b/tests/test_utils.py
index 55a5fa2..814fba0 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -24,6 +24,33 @@ from reverse_api.utils import (
)
+def _opencode_health_response() -> MagicMock:
+ response = MagicMock()
+ response.raise_for_status = MagicMock()
+ response.json.return_value = {"healthy": True, "version": "1.18.4"}
+ return response
+
+
+def _opencode_catalog_response() -> MagicMock:
+ response = MagicMock()
+ response.raise_for_status = MagicMock()
+ response.json.return_value = {
+ "default": {"anthropic": "claude-opus-4-6"},
+ "providers": [
+ {
+ "id": "anthropic",
+ "models": {
+ "claude-opus-4-6": {
+ "status": "active",
+ "capabilities": {"toolcall": True},
+ }
+ },
+ }
+ ],
+ }
+ return response
+
+
class TestSlugify:
"""Test _slugify function."""
@@ -530,7 +557,9 @@ class TestGenerateFolderNameOpencodeAsync:
async def mock_get(path, **kwargs):
if path == "/global/health":
- return MagicMock()
+ return _opencode_health_response()
+ if path == "/config/providers":
+ return _opencode_catalog_response()
if "/message" in path:
return mock_messages_response
return MagicMock()
@@ -559,7 +588,10 @@ class TestGenerateFolderNameOpencodeAsync:
mock_client.delete = AsyncMock()
with patch("reverse_api.config.ConfigManager") as mock_cm:
- mock_cm.return_value.get.return_value = "anthropic"
+ mock_cm.return_value.get.side_effect = lambda key, default=None: {
+ "opencode_provider": "anthropic",
+ "opencode_model": "claude-opus-4-6",
+ }.get(key, default)
with patch("reverse_api.utils.get_config_path"):
with patch("httpx.AsyncClient") as mock_async:
mock_async.return_value.__aenter__ = AsyncMock(return_value=mock_client)
@@ -586,7 +618,9 @@ class TestGenerateFolderNameOpencodeAsync:
async def mock_get(path, **kwargs):
if path == "/global/health":
- return MagicMock()
+ return _opencode_health_response()
+ if path == "/config/providers":
+ return _opencode_catalog_response()
if "/message" in path:
return mock_messages_response
return MagicMock()
@@ -612,7 +646,10 @@ class TestGenerateFolderNameOpencodeAsync:
mock_client.delete = AsyncMock()
with patch("reverse_api.config.ConfigManager") as mock_cm:
- mock_cm.return_value.get.return_value = "anthropic"
+ mock_cm.return_value.get.side_effect = lambda key, default=None: {
+ "opencode_provider": "anthropic",
+ "opencode_model": "claude-opus-4-6",
+ }.get(key, default)
with patch("reverse_api.utils.get_config_path"):
with patch("httpx.AsyncClient") as mock_async:
mock_async.return_value.__aenter__ = AsyncMock(return_value=mock_client)
@@ -634,7 +671,9 @@ class TestGenerateFolderNameOpencodeAsync:
async def mock_get(path, **kwargs):
if path == "/global/health":
- return MagicMock()
+ return _opencode_health_response()
+ if path == "/config/providers":
+ return _opencode_catalog_response()
if "/message" in path:
return mock_messages_response
return MagicMock()
@@ -659,7 +698,10 @@ class TestGenerateFolderNameOpencodeAsync:
mock_client.stream = MagicMock(return_value=mock_stream_cm)
with patch("reverse_api.config.ConfigManager") as mock_cm:
- mock_cm.return_value.get.return_value = "anthropic"
+ mock_cm.return_value.get.side_effect = lambda key, default=None: {
+ "opencode_provider": "anthropic",
+ "opencode_model": "claude-opus-4-6",
+ }.get(key, default)
with patch("reverse_api.utils.get_config_path"):
with patch("httpx.AsyncClient") as mock_async:
mock_async.return_value.__aenter__ = AsyncMock(return_value=mock_client)
@@ -685,7 +727,9 @@ class TestGenerateFolderNameOpencodeAsync:
async def mock_get(path, **kwargs):
if path == "/global/health":
- return MagicMock()
+ return _opencode_health_response()
+ if path == "/config/providers":
+ return _opencode_catalog_response()
if "/message" in path:
return mock_messages_response
return MagicMock()
@@ -710,7 +754,10 @@ class TestGenerateFolderNameOpencodeAsync:
mock_client.stream = MagicMock(return_value=mock_stream_cm)
with patch("reverse_api.config.ConfigManager") as mock_cm:
- mock_cm.return_value.get.return_value = "anthropic"
+ mock_cm.return_value.get.side_effect = lambda key, default=None: {
+ "opencode_provider": "anthropic",
+ "opencode_model": "claude-opus-4-6",
+ }.get(key, default)
with patch("reverse_api.utils.get_config_path"):
with patch("httpx.AsyncClient") as mock_async:
mock_async.return_value.__aenter__ = AsyncMock(return_value=mock_client)
diff --git a/website/content/docs/configuration/models.mdx b/website/content/docs/configuration/models.mdx
index 3d57af7..e9a4b4d 100644
--- a/website/content/docs/configuration/models.mdx
+++ b/website/content/docs/configuration/models.mdx
@@ -48,8 +48,8 @@ The full default config:
"cursor_web_search": true,
"cursor_setting_sources": null,
"copilot_model": "gpt-5",
- "opencode_model": "claude-opus-4-6",
- "opencode_provider": "anthropic",
+ "opencode_model": "big-pickle",
+ "opencode_provider": "opencode",
"output_dir": null,
"output_language": "python",
"real_time_sync": true,
@@ -59,9 +59,15 @@ The full default config:
## OpenCode users
-If you've configured the OpenCode SDK, see [models.dev](https://models.dev)
-for the available model IDs. Set them via the `opencode_model` and
-`opencode_provider` keys in the config.
+If you've configured the OpenCode SDK, choose **OpenCode Provider / Model** in
+`/settings`. RAE loads the connected providers and active tool-capable models
+from your OpenCode server, marks free OpenCode options, and saves the pair
+together. Advanced users can still edit the `opencode_model` and
+`opencode_provider` keys directly.
+
+For Ollama, set `opencode_provider` to `ollama`. The `/settings` flow discovers
+installed models and only offers those that report tool calling plus the 64k
+context OpenCode requires. RAE does not pull models automatically.
## Copilot and Cursor users
diff --git a/website/content/docs/configuration/sdks.mdx b/website/content/docs/configuration/sdks.mdx
index 2b13489..62f2e87 100644
--- a/website/content/docs/configuration/sdks.mdx
+++ b/website/content/docs/configuration/sdks.mdx
@@ -27,13 +27,65 @@ or use a non-Anthropic provider.
```json
{
"sdk": "opencode",
- "opencode_model": "claude-opus-4-6",
- "opencode_provider": "anthropic"
+ "opencode_auto_start": true,
+ "opencode_base_url": "http://127.0.0.1:4096",
+ "opencode_model": "big-pickle",
+ "opencode_npx_package": "opencode-ai@latest",
+ "opencode_provider": "opencode"
}
```
-OpenCode must be running locally before the CLI starts. Model identifiers
-are defined by OpenCode itself, see [models.dev](https://models.dev).
+RAE reuses an existing OpenCode server. If none is listening, it downloads and
+starts the latest `opencode-ai` release through `npx`, then stops that child
+process when RAE exits. A global OpenCode installation is not required.
+Automatic setup needs Node.js 20+; the first run downloads the OpenCode npm
+package and later runs use npm's cache. Fresh configurations use the free
+`opencode/big-pickle` model by default.
+
+Set `opencode_auto_start` to `false` when you manage the server yourself. The
+environment variables `OPENCODE_BASE_URL`, `RAE_OPENCODE_PACKAGE`, and
+`RAE_OPENCODE_AUTO_START` override the matching settings. Provider credentials
+and model identifiers remain OpenCode configuration. Password-protected servers
+use `OPENCODE_SERVER_PASSWORD` and optional `OPENCODE_SERVER_USERNAME`; these
+variables are inherited by an auto-started server. See
+[OpenCode providers](https://opencode.ai/docs/providers/) and
+[models.dev](https://models.dev).
+
+RAE validates the configured provider/model pair against OpenCode's connected
+provider catalog before creating a session. Invalid pairs fail immediately and
+include valid alternatives plus currently exposed free, tool-capable models.
+Existing compatible servers are reused; versions older than RAE's tested
+OpenCode release display an upgrade warning.
+
+### Ollama through OpenCode
+
+In `/settings`, set the OpenCode provider to `ollama`. RAE connects to the
+configured Ollama daemon (default `http://127.0.0.1:11434`) and offers the
+installed models that advertise tool calling and at least 64k context. Picking
+one updates both `opencode_provider` and `opencode_model`.
+
+```json
+{
+ "sdk": "opencode",
+ "opencode_provider": "ollama",
+ "opencode_model": "qwen3.5",
+ "ollama_auto_start": true,
+ "ollama_base_url": "http://127.0.0.1:11434"
+}
+```
+
+RAE reuses a running Ollama daemon or starts `ollama serve` when the CLI is
+installed. It passes an inline provider definition to an auto-started OpenCode
+server, so it does not overwrite `opencode.json`. If you run OpenCode yourself,
+that existing server must already expose the selected Ollama model; RAE reports
+the exact remediation when it does not.
+
+Model downloads are intentionally explicit because they can consume many
+gigabytes: run `ollama pull <model>` yourself, then select it. Override daemon
+discovery with `RAE_OLLAMA_BASE_URL` and disable startup with
+`RAE_OLLAMA_AUTO_START=0`. See Ollama's
+[OpenCode integration](https://docs.ollama.com/integrations/opencode) for the
+upstream context-window guidance.
## Copilot