codex-autorunner 0.1.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

codex_autorunner/agents/opencode/harness.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import json
 import logging
 from pathlib import Path
@@ -8,7 +9,12 @@ from typing import Any, AsyncIterator, Optional
 from ...core.app_server_events import format_sse
 from ..base import AgentHarness
 from ..types import AgentId, ConversationRef, ModelCatalog, ModelSpec, TurnRef
-from .runtime import build_turn_id, extract_session_id, extract_turn_id, split_model_id
+from .runtime import (
+    build_turn_id,
+    extract_session_id,
+    extract_turn_id,
+    split_model_id,
+)
 from .supervisor import OpenCodeSupervisor
 
 _logger = logging.getLogger(__name__)
@@ -24,8 +30,29 @@ def _coerce_providers(payload: Any) -> list[dict[str, Any]]:
     return []
 
 
+def _iter_provider_models(models_raw: Any) -> list[tuple[str, dict[str, Any]]]:
+    models: list[tuple[str, dict[str, Any]]] = []
+    if isinstance(models_raw, dict):
+        for model_id, model in models_raw.items():
+            if isinstance(model_id, str) and model_id:
+                if isinstance(model, dict):
+                    models.append((model_id, model))
+                else:
+                    models.append((model_id, {"id": model_id}))
+        return models
+    if isinstance(models_raw, list):
+        for entry in models_raw:
+            if isinstance(entry, dict):
+                model_id = entry.get("id") or entry.get("modelID")
+                if isinstance(model_id, str) and model_id:
+                    models.append((model_id, entry))
+            elif isinstance(entry, str) and entry:
+                models.append((entry, {"id": entry}))
+    return models
+
+
 class OpenCodeHarness(AgentHarness):
-    agent_id: AgentId = "opencode"
+    agent_id: AgentId = AgentId("opencode")
     display_name = "OpenCode"
 
     def __init__(self, supervisor: OpenCodeSupervisor) -> None:
@@ -58,12 +85,8 @@ class OpenCodeHarness(AgentHarness):
             provider_id = provider.get("id") or provider.get("providerID")
             if not isinstance(provider_id, str) or not provider_id:
                 continue
-            models_map = provider.get("models")
-            if not isinstance(models_map, dict):
-                continue
-            for model_id, model in models_map.items():
-                if not isinstance(model_id, str) or not isinstance(model, dict):
-                    continue
+            models_raw = provider.get("models")
+            for model_id, model in _iter_provider_models(models_raw):
                 name = model.get("name") or model.get("id") or model_id
                 display_name = name if isinstance(name, str) and name else model_id
                 capabilities = model.get("capabilities")
@@ -101,7 +124,7 @@ class OpenCodeHarness(AgentHarness):
         session_id = extract_session_id(result) or result.get("id")
         if not isinstance(session_id, str) or not session_id:
             raise ValueError("OpenCode did not return a session id")
-        return ConversationRef(agent="opencode", id=session_id)
+        return ConversationRef(agent=AgentId("opencode"), id=session_id)
 
     async def list_conversations(self, workspace_root: Path) -> list[ConversationRef]:
         client = await self._supervisor.get_client(workspace_root)
@@ -117,7 +140,9 @@ class OpenCodeHarness(AgentHarness):
         for entry in sessions:
             session_id = extract_session_id(entry) or entry.get("id")
             if isinstance(session_id, str) and session_id:
-                conversations.append(ConversationRef(agent="opencode", id=session_id))
+                conversations.append(
+                    ConversationRef(agent=AgentId("opencode"), id=session_id)
+                )
         return conversations
 
     async def resume_conversation(
@@ -129,7 +154,7 @@ class OpenCodeHarness(AgentHarness):
         except Exception:
             result = {}
         session_id = extract_session_id(result) or conversation_id
-        return ConversationRef(agent="opencode", id=session_id)
+        return ConversationRef(agent=AgentId("opencode"), id=session_id)
 
     async def start_turn(
         self,
@@ -144,7 +169,7 @@ class OpenCodeHarness(AgentHarness):
     ) -> TurnRef:
         client = await self._supervisor.get_client(workspace_root)
         model_payload = split_model_id(model)
-        await client.prompt(
+        await client.prompt_async(
             conversation_id,
             message=prompt,
             model=model_payload,
@@ -168,13 +193,23 @@ class OpenCodeHarness(AgentHarness):
     ) -> TurnRef:
         client = await self._supervisor.get_client(workspace_root)
         arguments = prompt if prompt else ""
-        result = await client.send_command(
-            conversation_id,
-            command="review",
-            arguments=arguments,
-            model=model,
-        )
-        turn_id = extract_turn_id(conversation_id, result)
+
+        async def _send_review() -> None:
+            try:
+                result = await client.send_command(
+                    conversation_id,
+                    command="review",
+                    arguments=arguments,
+                    model=model,
+                )
+                turn_id = extract_turn_id(conversation_id, result)
+                if turn_id:
+                    _logger.debug("OpenCode review started: %s", turn_id)
+            except Exception as exc:
+                _logger.warning("OpenCode review command failed: %s", exc)
+
+        asyncio.create_task(_send_review())
+        turn_id = build_turn_id(conversation_id)
         return TurnRef(conversation_id=conversation_id, turn_id=turn_id)
 
     async def interrupt(
@@ -199,7 +234,23 @@ class OpenCodeHarness(AgentHarness):
             except json.JSONDecodeError:
                 parsed = {"raw": payload}
             session_id = extract_session_id(parsed)
-            if event.event == "session.idle" and session_id == conversation_id:
+            status_type = None
+            if event.event == "session.status" and isinstance(parsed, dict):
+                properties = parsed.get("properties")
+                if isinstance(properties, dict):
+                    status = properties.get("status") or {}
+                else:
+                    status = parsed.get("status") or {}
+                if isinstance(status, dict):
+                    status_type = status.get("type") or status.get("status")
+            if (
+                event.event == "session.idle"
+                or (
+                    event.event == "session.status"
+                    and isinstance(status_type, str)
+                    and status_type.lower() == "idle"
+                )
+            ) and session_id == conversation_id:
                 break
             if session_id and session_id != conversation_id:
                 continue

codex_autorunner/agents/opencode/logging.py

@@ -0,0 +1,225 @@
+from __future__ import annotations
+
+import logging
+from typing import Any, Optional
+
+from ...core.text_delta_coalescer import TextDeltaCoalescer
+
+
+class OpenCodeEventFormatter:
+    def __init__(self) -> None:
+        self._seen_reasoning_parts: set[str] = set()
+        self._reasoning_coalescers: dict[str, TextDeltaCoalescer] = {}
+        self._tool_last_status: dict[str, str] = {}
+        self._seen_patch_hashes: set[str] = set()
+        self._logger = logging.getLogger(__name__)
+
+    def flush_all_reasoning(self) -> list[str]:
+        lines: list[str] = []
+        for coalescer in self._reasoning_coalescers.values():
+            remaining = coalescer.flush_all()
+            for line in remaining:
+                if line.strip():
+                    lines.append(f"**{line.strip()}**")
+        self._reasoning_coalescers.clear()
+        return lines
+
+    def reset(self) -> None:
+        self._seen_reasoning_parts.clear()
+        self._reasoning_coalescers.clear()
+        self._tool_last_status.clear()
+        self._seen_patch_hashes.clear()
+
+    def format_part(
+        self, part_type: str, part: dict[str, Any], delta_text: Optional[str]
+    ) -> list[str]:
+        lines: list[str] = []
+        part_id = part.get("id") or part.get("partId")
+
+        if part_type == "reasoning":
+            lines.extend(self._format_reasoning_part(part_id, delta_text))
+
+        elif part_type == "tool":
+            lines.extend(self._format_tool_part(part))
+
+        elif part_type == "patch":
+            lines.extend(self._format_patch_part(part))
+
+        return lines
+
+    def _format_reasoning_part(
+        self, part_id: Optional[str], delta_text: Optional[str]
+    ) -> list[str]:
+        lines: list[str] = []
+        key = part_id or "reasoning"
+
+        if delta_text:
+            if key not in self._seen_reasoning_parts:
+                lines.append("thinking")
+                self._seen_reasoning_parts.add(key)
+
+            if key not in self._reasoning_coalescers:
+                self._reasoning_coalescers[key] = TextDeltaCoalescer()
+            coalescer = self._reasoning_coalescers[key]
+            coalescer.add(delta_text)
+            complete_lines = coalescer.flush_lines()
+            for line in complete_lines:
+                if line.strip():
+                    lines.append(f"**{line.strip()}**")
+        return lines
+
+    def _format_tool_part(self, part: dict[str, Any]) -> list[str]:
+        lines: list[str] = []
+        tool_id = part.get("callID") or part.get("id")
+        tool_name = part.get("tool") or part.get("name") or ""
+
+        if not isinstance(tool_name, str) or not tool_name:
+            return lines
+
+        state = part.get("state", {})
+        if not isinstance(state, dict):
+            state = {}
+
+        status = state.get("status")
+        if isinstance(status, str) and status:
+            key = f"{tool_id}:{tool_name}" if tool_id else tool_name
+            last_status = self._tool_last_status.get(key)
+
+            if last_status != status:
+                self._tool_last_status[key] = status
+
+                if status in ("running", "pending"):
+                    lines.append("exec")
+                    lines.append(f"tool: {tool_name}")
+
+                elif status == "completed":
+                    if last_status not in ("running", "pending"):
+                        lines.append("exec")
+                        lines.append(f"tool: {tool_name}")
+                    exit_code = state.get("exitCode")
+                    if exit_code is not None:
+                        lines.append(f"exit {exit_code}")
+
+                elif status in ("error", "failed"):
+                    if last_status not in ("running", "pending"):
+                        lines.append("exec")
+                        lines.append(f"tool: {tool_name}")
+                    error = state.get("error")
+                    if isinstance(error, (str, dict)):
+                        if isinstance(error, dict):
+                            error = error.get("message") or error.get("error")
+                        if isinstance(error, str) and error:
+                            lines.append(f"error: {error}")
+
+        elif tool_id is None:
+            lines.append("exec")
+            lines.append(f"tool: {tool_name}")
+
+        input_preview: Optional[str] = None
+        for key in ("input", "command", "cmd", "script"):
+            value = part.get(key)
+            if isinstance(value, str) and value.strip():
+                input_preview = value.strip()
+                break
+        if input_preview is None:
+            args = part.get("args") or part.get("arguments") or part.get("params")
+            if isinstance(args, dict):
+                for key in ("command", "cmd", "script", "input"):
+                    value = args.get(key)
+                    if isinstance(value, str) and value.strip():
+                        input_preview = value.strip()
+                        break
+            elif isinstance(args, str) and args.strip():
+                input_preview = args.strip()
+        if input_preview:
+            if len(input_preview) > 240:
+                input_preview = input_preview[:240] + "…"
+            lines.append(f"input: {input_preview}")
+
+        return lines
+
+    def _format_patch_part(self, part: dict[str, Any]) -> list[str]:
+        lines: list[str] = []
+        patch_hash = part.get("hash")
+
+        if isinstance(patch_hash, str) and patch_hash:
+            if patch_hash in self._seen_patch_hashes:
+                return lines
+            self._seen_patch_hashes.add(patch_hash)
+
+        files = part.get("files")
+        if isinstance(files, list):
+            if files:
+                lines.append("file update")
+                for file_entry in files:
+                    if isinstance(file_entry, dict):
+                        path = file_entry.get("path") or file_entry.get("file")
+                        action = file_entry.get("status") or "M"
+                        if isinstance(path, str) and path:
+                            lines.append(f"{action} {path}")
+                    elif isinstance(file_entry, str):
+                        lines.append(f"M {file_entry}")
+
+        elif isinstance(files, str):
+            lines.append("file update")
+            lines.append(f"M {files}")
+
+        return lines
+
+    def format_usage(self, usage: dict[str, Any]) -> list[str]:
+        lines: list[str] = []
+
+        total = usage.get("totalTokens")
+        if isinstance(total, int):
+            input_tokens = usage.get("inputTokens")
+            cached_tokens = usage.get("cachedInputTokens")
+            output_tokens = usage.get("outputTokens")
+            reasoning_tokens = usage.get("reasoningTokens")
+
+            parts: list[str] = []
+            if isinstance(input_tokens, int):
+                parts.append(f"input: {input_tokens}")
+            if isinstance(cached_tokens, int) and cached_tokens > 0:
+                parts.append(f"cached: {cached_tokens}")
+            if isinstance(output_tokens, int):
+                parts.append(f"output: {output_tokens}")
+            if isinstance(reasoning_tokens, int):
+                parts.append(f"reasoning: {reasoning_tokens}")
+
+            if parts:
+                lines.append(f"tokens used - {', '.join(parts)}")
+            else:
+                lines.append(f"tokens used: {total}")
+
+            context_window = usage.get("modelContextWindow")
+            if isinstance(context_window, int) and context_window > 0:
+                lines.append(f"context window: {context_window}")
+
+        return lines
+
+    def format_permission(self, properties: dict[str, Any]) -> list[str]:
+        lines: list[str] = []
+
+        reason = properties.get("reason") or properties.get("message")
+        if isinstance(reason, str) and reason:
+            lines.append(f"permission: {reason}")
+        else:
+            lines.append("permission requested")
+
+        return lines
+
+    def format_error(self, error: Any) -> list[str]:
+        lines: list[str] = []
+
+        message = None
+        if isinstance(error, dict):
+            message = error.get("message") or error.get("error") or error.get("detail")
+        elif isinstance(error, str):
+            message = error
+
+        if isinstance(message, str) and message:
+            lines.append(f"error: {message}")
+        else:
+            lines.append("error: session error")
+
+        return lines

codex_autorunner/agents/opencode/run_prompt.py

@@ -0,0 +1,261 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Awaitable, Callable, Optional
+
+from .runtime import (
+    PERMISSION_ALLOW,
+    OpenCodeTurnOutput,
+    build_turn_id,
+    collect_opencode_output,
+    extract_session_id,
+    opencode_missing_env,
+    parse_message_response,
+    split_model_id,
+)
+from .supervisor import OpenCodeSupervisor
+
+
+@dataclass(frozen=True)
+class OpenCodeRunResult:
+    session_id: str
+    turn_id: str
+    output_text: str
+    output_error: Optional[str]
+    stopped: bool
+    timed_out: bool
+
+
+@dataclass
+class OpenCodeRunConfig:
+    agent: str
+    model: Optional[str]
+    reasoning: Optional[str]
+    prompt: str
+    workspace_root: str
+    timeout_seconds: int = 3600
+    interrupt_grace_seconds: int = 10
+    on_turn_start: Optional[Callable[[str, str], Awaitable[None]]] = None
+    permission_policy: str = PERMISSION_ALLOW
+
+
+async def run_opencode_prompt(
+    supervisor: OpenCodeSupervisor,
+    config: OpenCodeRunConfig,
+    *,
+    should_stop: Optional[Callable[[], bool]] = None,
+    logger: Optional[logging.Logger] = None,
+) -> OpenCodeRunResult:
+    client = await supervisor.get_client(Path(config.workspace_root))
+
+    session_id: Optional[str] = None
+    try:
+        session = await client.create_session(directory=config.workspace_root)
+        session_id = extract_session_id(session, allow_fallback_id=True)
+        if not isinstance(session_id, str) or not session_id:
+            raise ValueError("OpenCode did not return a session id")
+    except Exception as exc:
+        raise RuntimeError(f"Failed to create OpenCode session: {exc}") from exc
+
+    model_payload = split_model_id(config.model)
+    missing_env = await opencode_missing_env(
+        client, config.workspace_root, model_payload
+    )
+    if missing_env:
+        provider_id = model_payload.get("providerID") if model_payload else None
+        missing_label = ", ".join(missing_env)
+        raise RuntimeError(
+            f"OpenCode provider {provider_id or 'selected'} requires env vars: {missing_label}"
+        )
+
+    opencode_turn_started = False
+    await supervisor.mark_turn_started(Path(config.workspace_root))
+    opencode_turn_started = True
+    turn_id = build_turn_id(session_id)
+
+    if config.on_turn_start is not None:
+        try:
+            await config.on_turn_start(session_id, turn_id)
+        except Exception:
+            pass
+
+    stopped = False
+    timed_out = False
+    output_result: Optional[OpenCodeTurnOutput] = None
+
+    stop_task = None
+    if should_stop is not None:
+
+        async def _wait_for_stop() -> bool:
+            while True:
+                if should_stop():
+                    return True
+                await asyncio.sleep(0.2)
+
+        stop_task = asyncio.create_task(_wait_for_stop())
+
+    async def _abort_session(reason: str) -> None:
+        try:
+            await client.abort(session_id)
+        except Exception as exc:
+            if logger is not None:
+                logger.warning(f"OpenCode abort failed ({reason}): {exc}")
+
+    permission_policy = config.permission_policy or PERMISSION_ALLOW
+    ready_event = asyncio.Event()
+    output_task = asyncio.create_task(
+        collect_opencode_output(
+            client,
+            session_id=session_id,
+            workspace_path=config.workspace_root,
+            model_payload=model_payload,
+            permission_policy=permission_policy,
+            should_stop=should_stop,
+            ready_event=ready_event,
+        )
+    )
+    with contextlib.suppress(asyncio.TimeoutError):
+        await asyncio.wait_for(ready_event.wait(), timeout=2.0)
+    prompt_task = asyncio.create_task(
+        client.prompt_async(
+            session_id,
+            message=config.prompt,
+            model=model_payload,
+            variant=config.reasoning,
+        )
+    )
+    timeout_task = asyncio.create_task(asyncio.sleep(config.timeout_seconds))
+
+    try:
+
+        async def _finish_output(
+            ignore_errors: bool,
+        ) -> Optional[OpenCodeTurnOutput]:
+            if output_task.done():
+                try:
+                    return await output_task
+                except Exception as exc:
+                    if not ignore_errors:
+                        raise
+                    if logger is not None:
+                        logger.warning(f"OpenCode output failed after interrupt: {exc}")
+                    return None
+
+            grace_seconds = max(0, config.interrupt_grace_seconds or 0)
+            if grace_seconds <= 0:
+                output_task.cancel()
+                with contextlib.suppress(asyncio.CancelledError):
+                    await output_task
+                return None
+
+            try:
+                return await asyncio.wait_for(output_task, timeout=grace_seconds)
+            except asyncio.TimeoutError:
+                output_task.cancel()
+                with contextlib.suppress(asyncio.CancelledError):
+                    await output_task
+                if logger is not None:
+                    logger.warning("OpenCode output did not stop within grace period")
+                return None
+            except Exception as exc:
+                if not ignore_errors:
+                    raise
+                if logger is not None:
+                    logger.warning(f"OpenCode output failed after interrupt: {exc}")
+                return None
+
+        tasks = {output_task, prompt_task, timeout_task}
+        if stop_task is not None:
+            tasks.add(stop_task)
+
+        while True:
+            done, pending = await asyncio.wait(
+                tasks, return_when=asyncio.FIRST_COMPLETED
+            )
+
+            if output_task in done:
+                output_result = await output_task
+                if should_stop is not None and should_stop():
+                    stopped = True
+                break
+
+            if stop_task is not None and stop_task in done:
+                stopped = True
+                if logger is not None:
+                    logger.info("OpenCode prompt stopped")
+                await _abort_session("stop")
+                output_result = await _finish_output(ignore_errors=True)
+                break
+
+            if timeout_task in done:
+                timed_out = True
+                if logger is not None:
+                    logger.warning("OpenCode prompt timed out")
+                await _abort_session("timeout")
+                output_result = await _finish_output(ignore_errors=True)
+                break
+
+            if prompt_task in done:
+                try:
+                    await prompt_task
+                except Exception as exc:
+                    if logger is not None:
+                        logger.error(f"OpenCode prompt failed: {exc}")
+                    output_task.cancel()
+                    with contextlib.suppress(asyncio.CancelledError):
+                        await output_task
+                    raise RuntimeError(f"OpenCode prompt failed: {exc}") from exc
+                tasks.discard(prompt_task)
+                tasks = pending
+
+    finally:
+        timeout_task.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await timeout_task
+        if stop_task is not None:
+            stop_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await stop_task
+        if not prompt_task.done():
+            prompt_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await prompt_task
+        if opencode_turn_started:
+            try:
+                await supervisor.mark_turn_finished(Path(config.workspace_root))
+            except Exception:
+                pass
+
+    output_text = output_result.text if output_result else ""
+    output_error = output_result.error if output_result else None
+    if prompt_task.done() and not output_text:
+        try:
+            prompt_response = prompt_task.result()
+        except Exception:
+            prompt_response = None
+        if prompt_response is not None:
+            fallback = parse_message_response(prompt_response)
+            if fallback.text:
+                output_text = fallback.text
+            if fallback.error and not output_error:
+                output_error = fallback.error
+
+    return OpenCodeRunResult(
+        session_id=session_id,
+        turn_id=turn_id,
+        output_text=output_text,
+        output_error=output_error,
+        stopped=stopped,
+        timed_out=timed_out,
+    )
+
+
+__all__ = [
+    "OpenCodeRunResult",
+    "OpenCodeRunConfig",
+    "run_opencode_prompt",
+]