The agent that turns websites into APIs!
[codex] Improve OpenCode setup and compatibility (#107)
kalil032183210a49f7f6
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 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.mdindex 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.## CLIdiff --git a/src/reverse_api/auto_engineer.py b/src/reverse_api/auto_engineer.pyindex 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 UIself.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.pyindex 52e4555..a54bfe8 100644--- a/src/reverse_api/cli.py+++ b/src/reverse_api/cli.py@@ -20,7 +20,7 @@ from rich.console import Consolefrom . import __version__from .browser import ManualBrowser-from .config import ConfigManager+from .config import DEFAULT_OPENCODE_MODEL, DEFAULT_OPENCODE_PROVIDER, ConfigManagerfrom .engineer import run_reverse_engineeringfrom .messages import MessageStorefrom .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 promptif 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.pyindex 676b5f3..9586db5 100644--- a/src/reverse_api/config.py+++ b/src/reverse_api/config.py@@ -4,6 +4,9 @@ import jsonfrom pathlib import Pathfrom 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 engineeringdiff --git a/src/reverse_api/ollama_runtime.py b/src/reverse_api/ollama_runtime.pynew file mode 100644index 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.pyindex 7c5e9d9..e4f5456 100644--- a/src/reverse_api/opencode_engineer.py+++ b/src/reverse_api/opencode_engineer.py@@ -14,6 +14,20 @@ from typing import Anyimport httpxfrom .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.0self._work_started = False # Track if any real work has been doneself._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 variablesself.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 UIself.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):+ returndebug_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 errorawait self._check_session_error(client)+ if self._last_error:+ return+ if not await self._reconcile_pending_text_parts(client, seen_parts):+ returndebug_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 proceedpermission_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_typedebug_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)+ returnexcept 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)+ returnelif 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)returnexcept 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 errorsmsg_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)returnexcept 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 availablediff --git a/src/reverse_api/opencode_runtime.py b/src/reverse_api/opencode_runtime.pynew file mode 100644index 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.pyindex 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 formatself.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.pyindex 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 osimport platformimport reimport 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 modelconfig_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_PROMPTfolder_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 esession_created = Falseif session_id is None:diff --git a/tests/test_auto_engineer.py b/tests/test_auto_engineer.pyindex 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_messagesreturn 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_messagesreturn 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.pynew file mode 100644index 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.pynew file mode 100644index 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 outputdiff --git a/tests/test_config.py b/tests/test_config.pyindex 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 Trueassert 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.pynew file mode 100644index 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 Nonediff --git a/tests/test_opencode_engineer.py b/tests/test_opencode_engineer.pyindex 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.asyncioasync 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.asyncioasync 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_errorassert "anthropic" in eng._last_error+ eng.opencode_ui.error.assert_not_called()@pytest.mark.asyncioasync 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_errorassert "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.asyncioasync 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.asyncioasync 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.asyncioasync 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.asyncioasync 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_responsereturn MagicMock()@@ -1315,6 +1624,8 @@ class TestOpenCodeEngineerAnalyzeAndGenerate:get_count[0] += 1if 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.pynew file mode 100644index 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 Nonediff --git a/tests/test_opencode_ui.py b/tests/test_opencode_ui.pyindex 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 outputassert "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.pyindex 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_responsereturn 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_responsereturn 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_responsereturn 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_responsereturn 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.mdxindex 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 usersdiff --git a/website/content/docs/configuration/sdks.mdx b/website/content/docs/configuration/sdks.mdxindex 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