The agent that turns websites into APIs!
"""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 httpx2 as 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)