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

codex_autorunner/agents/__init__.py

@@ -0,0 +1 @@
+"""Agent harness abstractions."""

codex_autorunner/agents/base.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, AsyncIterator, Optional, Protocol
+
+from .types import ConversationRef, ModelCatalog, TurnRef
+
+
+class AgentHarness(Protocol):
+    agent_id: str
+    display_name: str
+
+    async def ensure_ready(self, workspace_root: Path) -> None: ...
+
+    async def model_catalog(self, workspace_root: Path) -> ModelCatalog: ...
+
+    async def new_conversation(
+        self, workspace_root: Path, title: Optional[str] = None
+    ) -> ConversationRef: ...
+
+    async def list_conversations(
+        self, workspace_root: Path
+    ) -> list[ConversationRef]: ...
+
+    async def resume_conversation(
+        self, workspace_root: Path, conversation_id: str
+    ) -> ConversationRef: ...
+
+    async def start_turn(
+        self,
+        workspace_root: Path,
+        conversation_id: str,
+        prompt: str,
+        model: Optional[str],
+        reasoning: Optional[str],
+        *,
+        approval_mode: Optional[str],
+        sandbox_policy: Optional[Any],
+    ) -> TurnRef: ...
+
+    async def start_review(
+        self,
+        workspace_root: Path,
+        conversation_id: str,
+        prompt: str,
+        model: Optional[str],
+        reasoning: Optional[str],
+        *,
+        approval_mode: Optional[str],
+        sandbox_policy: Optional[Any],
+    ) -> TurnRef: ...
+
+    async def interrupt(
+        self, workspace_root: Path, conversation_id: str, turn_id: Optional[str]
+    ) -> None: ...
+
+    def stream_events(
+        self, workspace_root: Path, conversation_id: str, turn_id: str
+    ) -> AsyncIterator[str]: ...
+
+
+__all__ = ["AgentHarness"]

codex_autorunner/agents/codex/__init__.py

@@ -0,0 +1,5 @@
+"""Codex harness adapter."""
+
+from .harness import CodexHarness
+
+__all__ = ["CodexHarness"]

codex_autorunner/agents/codex/harness.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, AsyncIterator, Optional
+
+from ...core.app_server_events import AppServerEventBuffer
+from ...integrations.app_server.supervisor import WorkspaceAppServerSupervisor
+from ..base import AgentHarness
+from ..types import AgentId, ConversationRef, ModelCatalog, ModelSpec, TurnRef
+
+_DEFAULT_REASONING_EFFORTS = ("none", "minimal", "low", "medium", "high", "xhigh")
+
+
+def _coerce_entries(result: Any, keys: tuple[str, ...]) -> list[dict[str, Any]]:
+    if isinstance(result, list):
+        return [entry for entry in result if isinstance(entry, dict)]
+    if isinstance(result, dict):
+        for key in keys:
+            value = result.get(key)
+            if isinstance(value, list):
+                return [entry for entry in value if isinstance(entry, dict)]
+    return []
+
+
+def _select_default_model(result: Any, entries: list[dict[str, Any]]) -> str:
+    if isinstance(result, dict):
+        for key in (
+            "defaultModel",
+            "default_model",
+            "default",
+            "model",
+            "modelId",
+            "model_id",
+        ):
+            value = result.get(key)
+            if isinstance(value, str) and value:
+                return value
+        config = result.get("config")
+        if isinstance(config, dict):
+            for key in ("defaultModel", "default_model", "model", "modelId"):
+                value = config.get(key)
+                if isinstance(value, str) and value:
+                    return value
+    for entry in entries:
+        if entry.get("default") or entry.get("isDefault"):
+            model_id = entry.get("model") or entry.get("id")
+            if isinstance(model_id, str) and model_id:
+                return model_id
+    for entry in entries:
+        model_id = entry.get("model") or entry.get("id")
+        if isinstance(model_id, str) and model_id:
+            return model_id
+    return ""
+
+
+def _coerce_reasoning_efforts(entry: dict[str, Any]) -> list[str]:
+    efforts_raw = entry.get("supportedReasoningEfforts")
+    efforts: list[str] = []
+    if isinstance(efforts_raw, list):
+        for effort in efforts_raw:
+            if isinstance(effort, dict):
+                value = effort.get("reasoningEffort")
+                if isinstance(value, str):
+                    efforts.append(value)
+            elif isinstance(effort, str):
+                efforts.append(effort)
+    default_effort = entry.get("defaultReasoningEffort")
+    if isinstance(default_effort, str) and default_effort:
+        efforts.append(default_effort)
+    if not efforts:
+        efforts = list(_DEFAULT_REASONING_EFFORTS)
+    return list(dict.fromkeys(efforts))
+
+
+class CodexHarness(AgentHarness):
+    agent_id: AgentId = "codex"
+    display_name = "Codex"
+
+    def __init__(
+        self,
+        supervisor: WorkspaceAppServerSupervisor,
+        events: AppServerEventBuffer,
+    ) -> None:
+        self._supervisor = supervisor
+        self._events = events
+
+    async def ensure_ready(self, workspace_root: Path) -> None:
+        await self._supervisor.get_client(workspace_root)
+
+    async def model_catalog(self, workspace_root: Path) -> ModelCatalog:
+        client = await self._supervisor.get_client(workspace_root)
+        result = await client.model_list()
+        entries = _coerce_entries(result, ("data", "models", "items", "results"))
+        models: list[ModelSpec] = []
+        for entry in entries:
+            model_id = entry.get("model") or entry.get("id")
+            if not isinstance(model_id, str) or not model_id:
+                continue
+            display_name = entry.get("displayName") or entry.get("name") or model_id
+            if not isinstance(display_name, str) or not display_name:
+                display_name = model_id
+            efforts = _coerce_reasoning_efforts(entry)
+            models.append(
+                ModelSpec(
+                    id=model_id,
+                    display_name=display_name,
+                    supports_reasoning=bool(efforts),
+                    reasoning_options=efforts,
+                )
+            )
+        default_model = _select_default_model(result, entries)
+        if not default_model and models:
+            default_model = models[0].id
+        return ModelCatalog(default_model=default_model, models=models)
+
+    async def new_conversation(
+        self, workspace_root: Path, title: Optional[str] = None
+    ) -> ConversationRef:
+        client = await self._supervisor.get_client(workspace_root)
+        result = await client.thread_start(str(workspace_root))
+        thread_id = result.get("id")
+        if not isinstance(thread_id, str) or not thread_id:
+            raise ValueError("Codex app-server did not return a thread id")
+        return ConversationRef(agent=self.agent_id, id=thread_id)
+
+    async def list_conversations(self, workspace_root: Path) -> list[ConversationRef]:
+        client = await self._supervisor.get_client(workspace_root)
+        result = await client.thread_list()
+        entries = _coerce_entries(result, ("threads", "data", "items", "results"))
+        conversations: list[ConversationRef] = []
+        for entry in entries:
+            thread_id = entry.get("id")
+            if isinstance(thread_id, str) and thread_id:
+                conversations.append(ConversationRef(agent=self.agent_id, id=thread_id))
+        return conversations
+
+    async def resume_conversation(
+        self, workspace_root: Path, conversation_id: str
+    ) -> ConversationRef:
+        client = await self._supervisor.get_client(workspace_root)
+        result = await client.thread_resume(conversation_id)
+        thread_id = result.get("id") or conversation_id
+        if not isinstance(thread_id, str) or not thread_id:
+            thread_id = conversation_id
+        return ConversationRef(agent=self.agent_id, id=thread_id)
+
+    async def start_turn(
+        self,
+        workspace_root: Path,
+        conversation_id: str,
+        prompt: str,
+        model: Optional[str],
+        reasoning: Optional[str],
+        *,
+        approval_mode: Optional[str],
+        sandbox_policy: Optional[Any],
+    ) -> TurnRef:
+        client = await self._supervisor.get_client(workspace_root)
+        turn_kwargs: dict[str, Any] = {}
+        if model:
+            turn_kwargs["model"] = model
+        if reasoning:
+            turn_kwargs["effort"] = reasoning
+        handle = await client.turn_start(
+            conversation_id,
+            prompt,
+            approval_policy=approval_mode,
+            sandbox_policy=sandbox_policy,
+            **turn_kwargs,
+        )
+        await self._events.register_turn(handle.thread_id, handle.turn_id)
+        return TurnRef(conversation_id=handle.thread_id, turn_id=handle.turn_id)
+
+    async def start_review(
+        self,
+        workspace_root: Path,
+        conversation_id: str,
+        prompt: str,
+        model: Optional[str],
+        reasoning: Optional[str],
+        *,
+        approval_mode: Optional[str],
+        sandbox_policy: Optional[Any],
+    ) -> TurnRef:
+        client = await self._supervisor.get_client(workspace_root)
+        review_kwargs: dict[str, Any] = {}
+        if model:
+            review_kwargs["model"] = model
+        if reasoning:
+            review_kwargs["effort"] = reasoning
+        instructions = (prompt or "").strip()
+        if instructions:
+            target = {"type": "custom", "instructions": instructions}
+        else:
+            target = {"type": "uncommittedChanges"}
+        handle = await client.review_start(
+            conversation_id,
+            target=target,
+            approval_policy=approval_mode,
+            sandbox_policy=sandbox_policy,
+            **review_kwargs,
+        )
+        await self._events.register_turn(handle.thread_id, handle.turn_id)
+        return TurnRef(conversation_id=handle.thread_id, turn_id=handle.turn_id)
+
+    async def interrupt(
+        self, workspace_root: Path, conversation_id: str, turn_id: Optional[str]
+    ) -> None:
+        if not turn_id:
+            return
+        client = await self._supervisor.get_client(workspace_root)
+        await client.turn_interrupt(turn_id, thread_id=conversation_id)
+
+    def stream_events(
+        self, workspace_root: Path, conversation_id: str, turn_id: str
+    ) -> AsyncIterator[str]:
+        return self._events.stream(conversation_id, turn_id)
+
+
+__all__ = ["CodexHarness"]

codex_autorunner/agents/opencode/__init__.py

@@ -0,0 +1,14 @@
+"""OpenCode harness support."""
+
+from .client import OpenCodeClient
+from .events import SSEEvent, parse_sse_lines
+from .harness import OpenCodeHarness
+from .supervisor import OpenCodeSupervisor
+
+__all__ = [
+    "OpenCodeClient",
+    "OpenCodeHarness",
+    "OpenCodeSupervisor",
+    "SSEEvent",
+    "parse_sse_lines",
+]

codex_autorunner/agents/opencode/client.py

@@ -0,0 +1,309 @@
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any, AsyncIterator, Optional
+
+import httpx
+
+from ...core.logging_utils import log_event
+from .events import SSEEvent, parse_sse_lines
+
+_MAX_INVALID_JSON_PREVIEW_BYTES = 512
+
+
+class OpenCodeProtocolError(Exception):
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: Optional[int] = None,
+        content_type: Optional[str] = None,
+        body_preview: Optional[str] = None,
+    ) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.content_type = content_type
+        self.body_preview = body_preview
+
+
+class OpenCodeClient:
+    def __init__(
+        self,
+        base_url: str,
+        *,
+        auth: Optional[tuple[str, str]] = None,
+        timeout: Optional[float] = None,
+        logger: Optional[logging.Logger] = None,
+    ) -> None:
+        self._client = httpx.AsyncClient(
+            base_url=base_url,
+            auth=auth,
+            timeout=timeout,
+        )
+        self._logger = logger or logging.getLogger(__name__)
+
+    async def close(self) -> None:
+        await self._client.aclose()
+
+    def _dir_params(self, directory: Optional[str]) -> dict[str, str]:
+        return {"directory": directory} if directory else {}
+
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: Optional[dict[str, Any]] = None,
+        json_body: Optional[dict[str, Any]] = None,
+        expect_json: bool = True,
+    ) -> Any:
+        response = await self._client.request(
+            method, path, params=params, json=json_body
+        )
+        response.raise_for_status()
+        raw = response.content
+        if not raw or not raw.strip():
+            return None
+        try:
+            return json.loads(raw)
+        except json.JSONDecodeError as exc:
+            self._log_invalid_json(
+                method,
+                path,
+                response,
+                raw,
+                expect_json=expect_json,
+            )
+            if expect_json:
+                preview = (
+                    raw[:_MAX_INVALID_JSON_PREVIEW_BYTES]
+                    .decode("utf-8", errors="replace")
+                    .strip()
+                )
+                content_type = response.headers.get("content-type")
+                hint = ""
+                if content_type and "text/html" in content_type.lower():
+                    hint = (
+                        " Response looks like HTML; the OpenCode server may have "
+                        "proxied the request instead of handling an API route."
+                    )
+                elif preview.startswith("<"):
+                    hint = (
+                        " Response looks like HTML; check that the OpenCode API "
+                        "endpoint is correct."
+                    )
+                raise OpenCodeProtocolError(
+                    f"OpenCode returned invalid JSON.{hint}",
+                    status_code=response.status_code,
+                    content_type=content_type,
+                    body_preview=preview or None,
+                ) from exc
+        return None
+
+    def _log_invalid_json(
+        self,
+        method: str,
+        path: str,
+        response: httpx.Response,
+        raw: bytes,
+        *,
+        expect_json: bool,
+    ) -> None:
+        preview = raw[:_MAX_INVALID_JSON_PREVIEW_BYTES].decode(
+            "utf-8", errors="replace"
+        )
+        log_event(
+            self._logger,
+            logging.WARNING,
+            "opencode.response.invalid_json",
+            method=method,
+            path=path,
+            status_code=response.status_code,
+            content_length=len(raw),
+            content_type=response.headers.get("content-type"),
+            expect_json=expect_json,
+            preview=preview,
+        )
+
+    async def providers(self, directory: Optional[str] = None) -> Any:
+        return await self._request(
+            "GET",
+            "/config/providers",
+            params=self._dir_params(directory),
+            expect_json=True,
+        )
+
+    async def create_session(
+        self,
+        *,
+        title: Optional[str] = None,
+        directory: Optional[str] = None,
+    ) -> Any:
+        payload: dict[str, Any] = {}
+        if title:
+            payload["title"] = title
+        if directory:
+            payload["directory"] = directory
+        return await self._request(
+            "POST", "/session", json_body=payload, expect_json=True
+        )
+
+    async def list_sessions(self, directory: Optional[str] = None) -> Any:
+        return await self._request(
+            "GET", "/session", params=self._dir_params(directory), expect_json=True
+        )
+
+    async def get_session(self, session_id: str) -> Any:
+        return await self._request("GET", f"/session/{session_id}", expect_json=True)
+
+    async def send_message(
+        self,
+        session_id: str,
+        *,
+        message: str,
+        agent: Optional[str] = None,
+        model: Optional[dict[str, str]] = None,
+        variant: Optional[str] = None,
+    ) -> Any:
+        payload: dict[str, Any] = {
+            "parts": [{"type": "text", "text": message}],
+        }
+        if agent:
+            payload["agent"] = agent
+        if model:
+            payload["model"] = model
+        if variant:
+            payload["variant"] = variant
+        return await self._request(
+            "POST",
+            f"/session/{session_id}/message",
+            json_body=payload,
+            expect_json=False,
+        )
+
+    async def prompt(
+        self,
+        session_id: str,
+        *,
+        message: str,
+        agent: Optional[str] = None,
+        model: Optional[dict[str, str]] = None,
+        variant: Optional[str] = None,
+    ) -> Any:
+        payload: dict[str, Any] = {
+            "parts": [{"type": "text", "text": message}],
+        }
+        if agent:
+            payload["agent"] = agent
+        if model:
+            payload["model"] = model
+        if variant:
+            payload["variant"] = variant
+        try:
+            return await self._request(
+                "POST",
+                f"/session/{session_id}/message",
+                json_body=payload,
+                expect_json=True,
+            )
+        except httpx.HTTPStatusError as exc:
+            if exc.response.status_code in (404, 405):
+                return await self._request(
+                    "POST",
+                    f"/session/{session_id}/prompt_async",
+                    json_body=payload,
+                    expect_json=False,
+                )
+            raise
+
+    async def send_command(
+        self,
+        session_id: str,
+        *,
+        command: str,
+        arguments: Optional[str] = None,
+        model: Optional[str] = None,
+        agent: Optional[str] = None,
+    ) -> Any:
+        payload: dict[str, Any] = {
+            "command": command,
+            "arguments": arguments or "",
+        }
+        if model:
+            payload["model"] = model
+        if agent:
+            payload["agent"] = agent
+        return await self._request(
+            "POST",
+            f"/session/{session_id}/command",
+            json_body=payload,
+            expect_json=False,
+        )
+
+    async def summarize(
+        self,
+        session_id: str,
+        *,
+        provider_id: str,
+        model_id: str,
+        auto: Optional[bool] = None,
+    ) -> Any:
+        payload: dict[str, Any] = {
+            "providerID": provider_id,
+            "modelID": model_id,
+        }
+        if auto is not None:
+            payload["auto"] = auto
+        return await self._request(
+            "POST",
+            f"/session/{session_id}/summarize",
+            json_body=payload,
+            expect_json=True,
+        )
+
+    async def respond_permission(
+        self,
+        *,
+        request_id: str,
+        reply: str,
+        message: Optional[str] = None,
+    ) -> Any:
+        payload: dict[str, Any] = {"reply": reply}
+        if message:
+            payload["message"] = message
+        return await self._request(
+            "POST",
+            f"/permission/{request_id}/reply",
+            json_body=payload,
+            expect_json=False,
+        )
+
+    async def abort(self, session_id: str) -> Any:
+        return await self._request(
+            "POST", f"/session/{session_id}/abort", expect_json=False
+        )
+
+    async def stream_events(
+        self, *, directory: Optional[str] = None
+    ) -> AsyncIterator[SSEEvent]:
+        params = self._dir_params(directory)
+        async with self._client.stream("GET", "/event", params=params) as response:
+            response.raise_for_status()
+            async for sse in parse_sse_lines(response.aiter_lines()):
+                event_type = sse.event
+                try:
+                    payload = json.loads(sse.data) if sse.data else None
+                    if isinstance(payload, dict) and "type" in payload:
+                        event_type = str(payload["type"])
+                except (json.JSONDecodeError, TypeError):
+                    pass
+                yield SSEEvent(
+                    event=event_type,
+                    data=sse.data,
+                    id=sse.id,
+                    retry=sse.retry,
+                )
+
+
+__all__ = ["OpenCodeClient", "OpenCodeProtocolError"]

codex_autorunner/agents/opencode/events.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import AsyncIterator, Optional
+
+
+@dataclass(frozen=True)
+class SSEEvent:
+    event: str
+    data: str
+    id: Optional[str] = None
+    retry: Optional[int] = None
+
+
+async def parse_sse_lines(lines: AsyncIterator[str]) -> AsyncIterator[SSEEvent]:
+    event_name = "message"
+    data_lines: list[str] = []
+    event_id: Optional[str] = None
+    retry_value: Optional[int] = None
+
+    async for line in lines:
+        if not line:
+            if data_lines or event_id is not None or retry_value is not None:
+                yield SSEEvent(
+                    event=event_name or "message",
+                    data="\n".join(data_lines),
+                    id=event_id,
+                    retry=retry_value,
+                )
+            event_name = "message"
+            data_lines = []
+            event_id = None
+            retry_value = None
+            continue
+
+        if line.startswith(":"):
+            continue
+
+        if ":" in line:
+            field, value = line.split(":", 1)
+            if value.startswith(" "):
+                value = value[1:]
+        else:
+            field, value = line, ""
+
+        if field == "event":
+            event_name = value
+        elif field == "data":
+            data_lines.append(value)
+        elif field == "id":
+            event_id = value
+        elif field == "retry":
+            try:
+                retry_value = int(value)
+            except ValueError:
+                retry_value = None
+
+    if data_lines or event_id is not None or retry_value is not None:
+        yield SSEEvent(
+            event=event_name or "message",
+            data="\n".join(data_lines),
+            id=event_id,
+            retry=retry_value,
+        )
+
+
+__all__ = ["SSEEvent", "parse_sse_lines"]