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

codex_autorunner/__main__.py

@@ -0,0 +1,4 @@
+from .cli import app
+
+if __name__ == "__main__":
+    app()

codex_autorunner/agents/__init__.py

@@ -1 +1,21 @@
 """Agent harness abstractions."""
+
+from .registry import (
+    AgentCapability,
+    AgentDescriptor,
+    get_agent_descriptor,
+    get_available_agents,
+    get_registered_agents,
+    has_capability,
+    validate_agent_id,
+)
+
+__all__ = [
+    "AgentCapability",
+    "AgentDescriptor",
+    "get_registered_agents",
+    "get_available_agents",
+    "get_agent_descriptor",
+    "validate_agent_id",
+    "has_capability",
+]

codex_autorunner/agents/base.py

@@ -3,11 +3,11 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Any, AsyncIterator, Optional, Protocol
 
-from .types import ConversationRef, ModelCatalog, TurnRef
+from .types import AgentId, ConversationRef, ModelCatalog, TurnRef
 
 
 class AgentHarness(Protocol):
-    agent_id: str
+    agent_id: AgentId
     display_name: str
 
     async def ensure_ready(self, workspace_root: Path) -> None: ...

codex_autorunner/agents/codex/harness.py

@@ -73,7 +73,7 @@ def _coerce_reasoning_efforts(entry: dict[str, Any]) -> list[str]:
 
 
 class CodexHarness(AgentHarness):
-    agent_id: AgentId = "codex"
+    agent_id: AgentId = AgentId("codex")
     display_name = "Codex"
 
     def __init__(

codex_autorunner/agents/opencode/__init__.py

@@ -3,12 +3,16 @@
 from .client import OpenCodeClient
 from .events import SSEEvent, parse_sse_lines
 from .harness import OpenCodeHarness
+from .run_prompt import OpenCodeRunConfig, OpenCodeRunResult, run_opencode_prompt
 from .supervisor import OpenCodeSupervisor
 
 __all__ = [
     "OpenCodeClient",
     "OpenCodeHarness",
+    "OpenCodeRunConfig",
+    "OpenCodeRunResult",
     "OpenCodeSupervisor",
     "SSEEvent",
     "parse_sse_lines",
+    "run_opencode_prompt",
 ]

codex_autorunner/agents/opencode/agent_config.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from pathlib import Path
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+async def ensure_agent_config(
+    workspace_root: Path,
+    agent_id: str,
+    model: Optional[str],
+    title: Optional[str] = None,
+    description: Optional[str] = None,
+) -> None:
+    """Ensure .opencode/agent/<agent_id>.md exists with frontmatter config.
+
+    Args:
+        workspace_root: Path to the workspace root
+        agent_id: Agent ID (e.g., "subagent")
+        model: Model ID in format "providerID/modelID" (e.g., "zai-coding-plan/glm-4.7-flashx")
+        title: Optional title for the agent
+        description: Optional description for the agent
+    """
+    if model is None:
+        logger.debug(f"Skipping agent config for {agent_id}: no model configured")
+        return
+
+    agent_dir = workspace_root / ".opencode" / "agent"
+    agent_file = agent_dir / f"{agent_id}.md"
+
+    # Check if file already exists and has the correct model
+    if agent_file.exists():
+        existing_content = agent_file.read_text(encoding="utf-8")
+        existing_model = _extract_model_from_frontmatter(existing_content)
+        if existing_model == model:
+            logger.debug(f"Agent config already exists for {agent_id}: {agent_file}")
+            return
+
+    # Create agent directory if needed
+    await asyncio.to_thread(agent_dir.mkdir, parents=True, exist_ok=True)
+
+    # Build agent markdown with frontmatter
+    content = _build_agent_md(
+        agent_id=agent_id,
+        model=model,
+        title=title or agent_id,
+        description=description or f"Subagent for {agent_id} tasks",
+    )
+
+    # Write atomically
+    await asyncio.to_thread(agent_file.write_text, content, encoding="utf-8")
+    logger.info(f"Created agent config: {agent_file} with model {model}")
+
+
+def _build_agent_md(
+    agent_id: str,
+    model: str,
+    title: str,
+    description: str,
+) -> str:
+    """Generate markdown with YAML frontmatter.
+
+    Frontmatter format per OpenCode config schema:
+    ---
+    agent: <agent_id>
+    title: "<title>"
+    description: "<description>"
+    model: <providerID>/<modelID>
+    ---
+
+    <Optional agent instructions go here>
+    """
+    return f"""---
+agent: {agent_id}
+title: "{title}"
+description: "{description}"
+model: {model}
+---
+"""
+
+
+def _extract_model_from_frontmatter(content: str) -> Optional[str]:
+    """Extract model value from YAML frontmatter.
+
+    Returns None if frontmatter or model field is not found.
+    """
+    lines = content.splitlines()
+    if not lines or not lines[0].startswith("---"):
+        return None
+
+    for _i, line in enumerate(lines[1:], start=1):
+        if line.startswith("---"):
+            break
+        if line.startswith("model:"):
+            model = line.split(":", 1)[1].strip()
+            return model if model else None
+
+    return None
+
+
+__all__ = ["ensure_agent_config"]

codex_autorunner/agents/opencode/client.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
 
+import asyncio
+import dataclasses
 import json
 import logging
-from typing import Any, AsyncIterator, Optional
+import re
+from typing import Any, AsyncIterator, Iterable, Optional
 
 import httpx
 
@@ -12,6 +15,15 @@ from .events import SSEEvent, parse_sse_lines
 _MAX_INVALID_JSON_PREVIEW_BYTES = 512
 
 
+@dataclasses.dataclass
+class OpenCodeApiProfile:
+    """Detected OpenCode API capabilities from OpenAPI spec."""
+
+    supports_prompt_async: bool = True
+    supports_global_endpoints: bool = True
+    spec_fetched: bool = False
+
+
 class OpenCodeProtocolError(Exception):
     def __init__(
         self,
@@ -27,6 +39,43 @@ class OpenCodeProtocolError(Exception):
         self.body_preview = body_preview
 
 
+def _normalize_sse_event(event: SSEEvent) -> SSEEvent:
+    event_type = event.event
+    raw_data = event.data or ""
+    payload_obj: Optional[dict[str, Any]] = None
+    try:
+        payload_obj = json.loads(raw_data) if raw_data else None
+    except (json.JSONDecodeError, TypeError):
+        payload_obj = None
+
+    if isinstance(payload_obj, dict) and isinstance(payload_obj.get("payload"), dict):
+        outer = payload_obj
+        inner = dict(outer.get("payload") or {})
+        if "type" not in inner and isinstance(outer.get("type"), str):
+            inner["type"] = outer["type"]
+        for key in ("sessionID", "sessionId", "session_id"):
+            if key in outer and key not in inner:
+                inner[key] = outer[key]
+        if "session" in outer and "session" not in inner:
+            inner["session"] = outer["session"]
+        if "properties" in outer and "properties" not in inner:
+            inner["properties"] = outer["properties"]
+        payload_obj = inner
+
+    if isinstance(payload_obj, dict):
+        payload_type = payload_obj.get("type")
+        if isinstance(payload_type, str) and payload_type:
+            event_type = payload_type
+        raw_data = json.dumps(payload_obj)
+
+    return SSEEvent(
+        event=event_type,
+        data=raw_data,
+        id=event.id,
+        retry=event.retry,
+    )
+
+
 class OpenCodeClient:
     def __init__(
         self,
@@ -42,10 +91,62 @@ class OpenCodeClient:
             timeout=timeout,
         )
         self._logger = logger or logging.getLogger(__name__)
+        self._api_profile: Optional[OpenCodeApiProfile] = None
+        self._api_profile_lock = asyncio.Lock()
 
     async def close(self) -> None:
         await self._client.aclose()
 
+    async def detect_api_shape(self) -> OpenCodeApiProfile:
+        """Detect OpenCode API capabilities by fetching and parsing OpenAPI spec.
+        Results are cached for the lifetime of the client instance.
+        Thread-safe: multiple concurrent calls will wait for first detection to complete.
+        """
+        async with self._api_profile_lock:
+            if self._api_profile is not None:
+                return self._api_profile
+
+            profile = OpenCodeApiProfile()
+            try:
+                spec = await self.fetch_openapi_spec()
+                profile.spec_fetched = True
+
+                if isinstance(spec, dict):
+                    # Check if /session/{id}/prompt_async exists
+                    profile.supports_prompt_async = self.has_endpoint(
+                        spec, "post", "/session/{session_id}/prompt_async"
+                    )
+
+                    # Check if /global/* endpoints exist
+                    profile.supports_global_endpoints = self.has_endpoint(
+                        spec, "get", "/global/health"
+                    ) or self.has_endpoint(spec, "get", "/global/event")
+
+                log_event(
+                    self._logger,
+                    logging.INFO,
+                    "opencode.api_shape_detected",
+                    supports_prompt_async=profile.supports_prompt_async,
+                    supports_global_endpoints=profile.supports_global_endpoints,
+                )
+            except Exception as exc:
+                self._logger.warning(
+                    "Failed to detect API shape, assuming modern OpenCode: %s", exc
+                )
+                # Default to assuming modern OpenCode with all features
+                profile.supports_prompt_async = True
+                profile.supports_global_endpoints = True
+
+            self._api_profile = profile
+            return profile
+
+    def _get_api_profile(self) -> OpenCodeApiProfile:
+        """Get API profile, detecting if needed. Synchronous for use in sync methods."""
+        if self._api_profile is None:
+            # Return default profile if not yet detected
+            return OpenCodeApiProfile()
+        return self._api_profile
+
     def _dir_params(self, directory: Optional[str]) -> dict[str, str]:
         return {"directory": directory} if directory else {}
 
@@ -157,6 +258,14 @@ class OpenCodeClient:
     async def get_session(self, session_id: str) -> Any:
         return await self._request("GET", f"/session/{session_id}", expect_json=True)
 
+    async def session_status(self, *, directory: Optional[str] = None) -> Any:
+        return await self._request(
+            "GET",
+            "/session/status",
+            params=self._dir_params(directory),
+            expect_json=True,
+        )
+
     async def send_message(
         self,
         session_id: str,
@@ -200,22 +309,57 @@ class OpenCodeClient:
             payload["model"] = model
         if variant:
             payload["variant"] = variant
-        try:
+
+        profile = await self.detect_api_shape()
+        if profile.supports_prompt_async:
+            return await self._request(
+                "POST",
+                f"/session/{session_id}/prompt_async",
+                json_body=payload,
+                expect_json=False,
+            )
+        else:
+            return await self._request(
+                "POST",
+                f"/session/{session_id}/message",
+                json_body=payload,
+                expect_json=True,
+            )
+
+    async def prompt_async(
+        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
+
+        profile = await self.detect_api_shape()
+        if profile.supports_prompt_async:
+            return await self._request(
+                "POST",
+                f"/session/{session_id}/prompt_async",
+                json_body=payload,
+                expect_json=False,
+            )
+        else:
             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,
@@ -279,31 +423,164 @@ class OpenCodeClient:
             expect_json=False,
         )
 
+    async def list_questions(self) -> Any:
+        return await self._request("GET", "/question", expect_json=True)
+
+    async def reply_question(self, request_id: str, *, answers: list[list[str]]) -> Any:
+        payload: dict[str, Any] = {"answers": answers}
+        return await self._request(
+            "POST",
+            f"/question/{request_id}/reply",
+            json_body=payload,
+            expect_json=False,
+        )
+
+    async def reject_question(self, request_id: str) -> Any:
+        return await self._request(
+            "POST",
+            f"/question/{request_id}/reject",
+            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 health(self) -> Any:
+        """Check OpenCode server health using /global/health or /health endpoint."""
+        profile = await self.detect_api_shape()
+        if profile.supports_global_endpoints:
+            return await self._request("GET", "/global/health", expect_json=True)
+        else:
+            return await self._request("GET", "/health", expect_json=True)
+
+    async def dispose(self, session_id: str) -> Any:
+        """Dispose of a session using /global/dispose/{id} or /session/{id}/dispose endpoint."""
+        profile = await self.detect_api_shape()
+        if profile.supports_global_endpoints:
+            return await self._request(
+                "POST", f"/global/dispose/{session_id}", expect_json=False
+            )
+        else:
+            return await self._request(
+                "POST", f"/session/{session_id}/dispose", expect_json=False
+            )
+
     async def stream_events(
-        self, *, directory: Optional[str] = None
+        self,
+        *,
+        directory: Optional[str] = None,
+        ready_event: Optional[asyncio.Event] = None,
+        paths: Optional[Iterable[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,
+
+        if paths is not None:
+            event_paths = list(paths)
+        else:
+            profile = await self.detect_api_shape()
+            if profile.supports_global_endpoints:
+                event_paths = (
+                    ["/event", "/global/event"]
+                    if directory
+                    else ["/global/event", "/event"]
                 )
+            else:
+                event_paths = ["/event"]
+
+        last_error: Optional[BaseException] = None
+        for path in event_paths:
+            try:
+                async with self._client.stream(
+                    "GET", path, params=params, timeout=None
+                ) as response:
+                    response.raise_for_status()
+                    if ready_event is not None:
+                        ready_event.set()
+                    async for sse in parse_sse_lines(response.aiter_lines()):
+                        yield _normalize_sse_event(sse)
+                return
+            except httpx.HTTPStatusError as exc:
+                last_error = exc
+                status_code = exc.response.status_code
+                if status_code in (404, 405):
+                    continue
+                raise
+            except Exception as exc:
+                last_error = exc
+                raise
+        if ready_event is not None and not ready_event.is_set():
+            ready_event.set()
+        if last_error is not None:
+            raise last_error
+
+    async def fetch_openapi_spec(self) -> dict[str, Any]:
+        """Fetch OpenAPI spec from /doc endpoint for capability negotiation."""
+        response = await self._client.get("/doc")
+        response.raise_for_status()
+        content = response.content
+        try:
+            spec = json.loads(content) if content else {}
+            log_event(
+                self._logger,
+                logging.INFO,
+                "opencode.openapi.fetched",
+                paths=len(spec.get("paths", {})) if isinstance(spec, dict) else 0,
+                has_components=(
+                    "components" in spec if isinstance(spec, dict) else False
+                ),
+            )
+            return spec
+        except Exception as exc:
+            log_event(
+                self._logger,
+                logging.WARNING,
+                "opencode.openapi.parse_failed",
+                exc=exc,
+            )
+            raise OpenCodeProtocolError(
+                f"Failed to parse OpenAPI spec: {exc}",
+                status_code=response.status_code,
+                content_type=(
+                    response.headers.get("content-type") if response else None
+                ),
+            ) from exc
+
+    def has_endpoint(
+        self, openapi_spec: dict[str, Any], method: str, path: str
+    ) -> bool:
+        """Check if endpoint is available in OpenAPI spec.
+
+        The OpenAPI spec sometimes uses different template parameter names (e.g.,
+        `{sessionID}` vs `{session_id}`). We normalize templates before matching so
+        capability detection does not depend on placeholder spelling.
+        """
+        if not isinstance(openapi_spec, dict):
+            return False
+        paths = openapi_spec.get("paths", {})
+        if not isinstance(paths, dict):
+            return False
+
+        target = _normalize_template_path(path)
+        method = method.lower()
+
+        for candidate_path, info in paths.items():
+            if not isinstance(info, dict):
+                continue
+            if _normalize_template_path(candidate_path) != target:
+                continue
+            if method in info:
+                return True
+        return False
+
+
+def _normalize_template_path(path: str) -> str:
+    """Collapse template placeholders to a canonical form.
+
+    Example: `/session/{sessionID}/prompt_async` -> `/session/{}/prompt_async`
+    """
+    return re.sub(r"{[^/]+}", "{}", path)
 
 
-__all__ = ["OpenCodeClient", "OpenCodeProtocolError"]
+__all__ = ["OpenCodeClient", "OpenCodeProtocolError", "OpenCodeApiProfile"]