codex-autorunner 0.1.2__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/opencode/client.py

@@ -4,6 +4,7 @@ import asyncio
 import dataclasses
 import json
 import logging
+import re
 from typing import Any, AsyncIterator, Iterable, Optional
 
 import httpx
@@ -48,7 +49,18 @@ def _normalize_sse_event(event: SSEEvent) -> SSEEvent:
         payload_obj = None
 
     if isinstance(payload_obj, dict) and isinstance(payload_obj.get("payload"), dict):
-        payload_obj = payload_obj["payload"]
+        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")
@@ -505,49 +517,70 @@ class OpenCodeClient:
 
     async def fetch_openapi_spec(self) -> dict[str, Any]:
         """Fetch OpenAPI spec from /doc endpoint for capability negotiation."""
-        async with self._client.stream("GET", "/doc") as response:
-            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
+        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."""
+        """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
-        path_info = paths.get(path)
-        if not isinstance(path_info, dict):
-            return False
-        return method in path_info
+
+        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", "OpenCodeApiProfile"]

codex_autorunner/agents/opencode/logging.py

@@ -66,11 +66,6 @@ class OpenCodeEventFormatter:
             for line in complete_lines:
                 if line.strip():
                     lines.append(f"**{line.strip()}**")
-
-            remaining = coalescer.get_buffer()
-            if remaining and remaining.strip():
-                lines.append(f"**{remaining.strip()}**")
-                coalescer.clear()
         return lines
 
     def _format_tool_part(self, part: dict[str, Any]) -> list[str]:
@@ -120,6 +115,27 @@ class OpenCodeEventFormatter:
             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]:

codex_autorunner/agents/opencode/run_prompt.py

@@ -112,6 +112,7 @@ async def run_opencode_prompt(
             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,

codex_autorunner/agents/opencode/runtime.py

@@ -15,6 +15,7 @@ from typing import (
     Callable,
     MutableMapping,
     Optional,
+    cast,
 )
 
 import httpx
@@ -127,17 +128,19 @@ def extract_session_id(
             return value
     properties = payload.get("properties")
     if isinstance(properties, dict):
-        value = properties.get("sessionID")
-        if isinstance(value, str) and value:
-            return value
-        part = properties.get("part")
-        if isinstance(part, dict):
-            value = part.get("sessionID")
+        for key in ("sessionID", "sessionId", "session_id"):
+            value = properties.get(key)
             if isinstance(value, str) and value:
                 return value
+        part = properties.get("part")
+        if isinstance(part, dict):
+            for key in ("sessionID", "sessionId", "session_id"):
+                value = part.get(key)
+                if isinstance(value, str) and value:
+                    return value
     session = payload.get("session")
     if isinstance(session, dict):
-        return extract_session_id(session, allow_fallback_id=allow_fallback_id)
+        return extract_session_id(session, allow_fallback_id=True)
     return None
 
 
@@ -676,7 +679,7 @@ async def opencode_missing_env(
         providers = [entry for entry in payload if isinstance(entry, dict)]
     for provider in providers:
         pid = provider.get("id") or provider.get("providerID")
-        if pid != provider_id:
+        if not pid or pid != provider_id:
             continue
         if _provider_has_auth(pid, workspace_root):
             return []
@@ -732,6 +735,7 @@ async def collect_opencode_output_from_events(
     events: Optional[AsyncIterator[SSEEvent]] = None,
     *,
     session_id: str,
+    model_payload: Optional[dict[str, str]] = None,
     progress_session_ids: Optional[set[str]] = None,
     permission_policy: str = PERMISSION_ALLOW,
     permission_handler: Optional[PermissionHandler] = None,
@@ -759,13 +763,16 @@ async def collect_opencode_output_from_events(
     last_usage_total: Optional[int] = None
     last_context_window: Optional[int] = None
     part_types: dict[str, str] = {}
-    seen_question_request_ids: set[tuple[str, str]] = set()
+    seen_question_request_ids: set[tuple[Optional[str], str]] = set()
     logged_permission_errors: set[str] = set()
     normalized_question_policy = _normalize_question_policy(question_policy)
     logger = logging.getLogger(__name__)
     providers_cache: Optional[list[dict[str, Any]]] = None
     context_window_cache: dict[str, Optional[int]] = {}
     session_model_ids: Optional[tuple[Optional[str], Optional[str]]] = None
+    default_model_ids = (
+        _extract_model_ids(model_payload) if isinstance(model_payload, dict) else None
+    )
 
     def _message_id_from_info(info: Any) -> Optional[str]:
         if not isinstance(info, dict):
@@ -843,15 +850,19 @@ async def collect_opencode_output_from_events(
         nonlocal session_model_ids
         if session_model_ids is not None:
             return session_model_ids
-        if session_fetcher is None:
-            session_model_ids = (None, None)
-            return session_model_ids
-        try:
-            payload = await session_fetcher()
-        except Exception:
-            session_model_ids = (None, None)
-            return session_model_ids
-        session_model_ids = _extract_model_ids(payload)
+        resolved_ids: Optional[tuple[Optional[str], Optional[str]]] = None
+        if session_fetcher is not None:
+            try:
+                payload = await session_fetcher()
+                resolved_ids = _extract_model_ids(payload)
+            except Exception:
+                resolved_ids = None
+        # If we failed to resolve model ids from the session (including the empty
+        # tuple case), fall back to the caller-provided model payload so we can
+        # still backfill usage metadata.
+        if not resolved_ids or all(value is None for value in resolved_ids):
+            resolved_ids = default_model_ids
+        session_model_ids = resolved_ids or (None, None)
         return session_model_ids
 
     async def _resolve_context_window_from_providers(
@@ -946,7 +957,7 @@ async def collect_opencode_output_from_events(
             await aclose()
 
     stream_iter = _new_stream().__aiter__()
-    last_event_at = time.monotonic()
+    last_relevant_event_at = time.monotonic()
     last_primary_completion_at: Optional[float] = None
     reconnect_attempts = 0
     can_reconnect = (
@@ -981,6 +992,7 @@ async def collect_opencode_output_from_events(
                             session_id=session_id,
                             exc=exc,
                         )
+                idle_seconds = now - last_relevant_event_at
                 if _status_is_idle(status_type):
                     log_event(
                         logger,
@@ -988,7 +1000,7 @@ async def collect_opencode_output_from_events(
                         "opencode.stream.stalled.session_idle",
                         session_id=session_id,
                         status_type=status_type,
-                        idle_seconds=now - last_event_at,
+                        idle_seconds=idle_seconds,
                     )
                     if not text_parts and pending_text:
                         _flush_all_pending_text()
@@ -1000,7 +1012,7 @@ async def collect_opencode_output_from_events(
                         "opencode.stream.stalled.after_completion",
                         session_id=session_id,
                         status_type=status_type,
-                        idle_seconds=now - last_event_at,
+                        idle_seconds=idle_seconds,
                     )
                 if not can_reconnect:
                     break
@@ -1015,7 +1027,7 @@ async def collect_opencode_output_from_events(
                     logging.WARNING,
                     "opencode.stream.stalled.reconnecting",
                     session_id=session_id,
-                    idle_seconds=now - last_event_at,
+                    idle_seconds=idle_seconds,
                     backoff_seconds=backoff,
                     status_type=status_type,
                     attempts=reconnect_attempts,
@@ -1023,21 +1035,86 @@ async def collect_opencode_output_from_events(
                 await _close_stream(stream_iter)
                 await asyncio.sleep(backoff)
                 stream_iter = _new_stream().__aiter__()
+                last_relevant_event_at = now
                 continue
-            last_event_at = time.monotonic()
+            now = time.monotonic()
             raw = event.data or ""
             try:
                 payload = json.loads(raw) if raw else {}
             except json.JSONDecodeError:
                 payload = {}
             event_session_id = extract_session_id(payload)
-            if not event_session_id:
-                continue
-            if progress_session_ids is None:
-                if event_session_id != session_id:
-                    continue
-            elif event_session_id not in progress_session_ids:
+            is_relevant = False
+            if event_session_id:
+                if progress_session_ids is None:
+                    is_relevant = event_session_id == session_id
+                else:
+                    is_relevant = event_session_id in progress_session_ids
+            if not is_relevant:
+                if (
+                    stall_timeout_seconds is not None
+                    and now - last_relevant_event_at > stall_timeout_seconds
+                ):
+                    idle_seconds = now - last_relevant_event_at
+                    last_relevant_event_at = now
+                    status_type = None
+                    if session_fetcher is not None:
+                        try:
+                            payload = await session_fetcher()
+                            status_type = _extract_status_type(payload)
+                        except Exception as exc:
+                            log_event(
+                                logger,
+                                logging.WARNING,
+                                "opencode.session.poll_failed",
+                                session_id=session_id,
+                                exc=exc,
+                            )
+                    if _status_is_idle(status_type):
+                        log_event(
+                            logger,
+                            logging.INFO,
+                            "opencode.stream.stalled.session_idle",
+                            session_id=session_id,
+                            status_type=status_type,
+                            idle_seconds=idle_seconds,
+                        )
+                        if not text_parts and pending_text:
+                            _flush_all_pending_text()
+                        break
+                    if last_primary_completion_at is not None:
+                        log_event(
+                            logger,
+                            logging.INFO,
+                            "opencode.stream.stalled.after_completion",
+                            session_id=session_id,
+                            status_type=status_type,
+                            idle_seconds=idle_seconds,
+                        )
+                    if not can_reconnect:
+                        break
+                    backoff_index = min(
+                        reconnect_attempts,
+                        len(_OPENCODE_STREAM_RECONNECT_BACKOFF_SECONDS) - 1,
+                    )
+                    backoff = _OPENCODE_STREAM_RECONNECT_BACKOFF_SECONDS[backoff_index]
+                    reconnect_attempts += 1
+                    log_event(
+                        logger,
+                        logging.WARNING,
+                        "opencode.stream.stalled.reconnecting",
+                        session_id=session_id,
+                        idle_seconds=idle_seconds,
+                        backoff_seconds=backoff,
+                        status_type=status_type,
+                        attempts=reconnect_attempts,
+                    )
+                    await _close_stream(stream_iter)
+                    await asyncio.sleep(backoff)
+                    stream_iter = _new_stream().__aiter__()
                 continue
+            last_relevant_event_at = now
+            reconnect_attempts = 0
             is_primary_session = event_session_id == session_id
             if event.event == "question.asked":
                 request_id, props = _extract_question_request(payload)
@@ -1419,6 +1496,7 @@ async def collect_opencode_output(
     *,
     session_id: str,
     workspace_path: str,
+    model_payload: Optional[dict[str, str]] = None,
     progress_session_ids: Optional[set[str]] = None,
     permission_policy: str = PERMISSION_ALLOW,
     permission_handler: Optional[PermissionHandler] = None,
@@ -1427,6 +1505,7 @@ async def collect_opencode_output(
     should_stop: Optional[Callable[[], bool]] = None,
     ready_event: Optional[Any] = None,
     part_handler: Optional[PartHandler] = None,
+    stall_timeout_seconds: Optional[float] = _OPENCODE_STREAM_STALL_TIMEOUT_SECONDS,
 ) -> OpenCodeTurnOutput:
     async def _respond(request_id: str, reply: str) -> None:
         await client.respond_permission(request_id=request_id, reply=reply)
@@ -1438,14 +1517,21 @@ async def collect_opencode_output(
         await client.reject_question(request_id)
 
     def _stream_factory() -> AsyncIterator[SSEEvent]:
-        return client.stream_events(directory=workspace_path, ready_event=ready_event)
+        return cast(
+            AsyncIterator[SSEEvent],
+            client.stream_events(directory=workspace_path, ready_event=ready_event),
+        )
 
     async def _fetch_session() -> Any:
         statuses = await client.session_status(directory=workspace_path)
         if isinstance(statuses, dict):
             session_status = statuses.get(session_id)
+            if session_status is None:
+                return {"status": {"type": "idle"}}
             if isinstance(session_status, dict):
                 return {"status": session_status}
+            if isinstance(session_status, str):
+                return {"status": session_status}
         return {"status": {}}
 
     async def _fetch_providers() -> Any:
@@ -1465,8 +1551,10 @@ async def collect_opencode_output(
         reject_question=_reject_question,
         part_handler=part_handler,
         event_stream_factory=_stream_factory,
+        model_payload=model_payload,
         session_fetcher=_fetch_session,
         provider_fetcher=_fetch_providers,
+        stall_timeout_seconds=stall_timeout_seconds,
     )
 
 

codex_autorunner/agents/opencode/supervisor.py

@@ -11,6 +11,7 @@ from typing import Any, Mapping, Optional, Sequence
 import httpx
 
 from ...core.logging_utils import log_event
+from ...core.supervisor_utils import evict_lru_handle_locked, pop_idle_handles_locked
 from ...core.utils import infer_home_from_workspace, subprocess_env
 from ...workspace import canonical_workspace_root, workspace_id_for_path
 from .client import OpenCodeClient
@@ -53,20 +54,28 @@ class OpenCodeSupervisor:
         base_env: Optional[Mapping[str, str]] = None,
         base_url: Optional[str] = None,
         subagent_models: Optional[Mapping[str, str]] = None,
+        session_stall_timeout_seconds: Optional[float] = None,
     ) -> None:
         self._command = [str(arg) for arg in command]
         self._logger = logger or logging.getLogger(__name__)
         self._request_timeout = request_timeout
         self._max_handles = max_handles
         self._idle_ttl_seconds = idle_ttl_seconds
+        self._session_stall_timeout_seconds = session_stall_timeout_seconds
         if password and not username:
             username = "opencode"
-        self._auth = (username, password) if password else None
+        self._auth: Optional[tuple[str, str]] = (
+            (username, password) if password and username else None
+        )
         self._base_env = base_env
         self._base_url = base_url
         self._subagent_models = subagent_models or {}
         self._handles: dict[str, OpenCodeHandle] = {}
-        self._lock = asyncio.Lock()
+        self._lock: Optional[asyncio.Lock] = None
+
+    @property
+    def session_stall_timeout_seconds(self) -> Optional[float]:
+        return self._session_stall_timeout_seconds
 
     async def get_client(self, workspace_root: Path) -> OpenCodeClient:
         canonical_root = canonical_workspace_root(workspace_root)
@@ -79,7 +88,7 @@ class OpenCodeSupervisor:
         return handle.client
 
     async def close_all(self) -> None:
-        async with self._lock:
+        async with self._get_lock():
             handles = list(self._handles.values())
             self._handles = {}
         for handle in handles:
@@ -98,7 +107,7 @@ class OpenCodeSupervisor:
     async def mark_turn_started(self, workspace_root: Path) -> None:
         canonical_root = canonical_workspace_root(workspace_root)
         workspace_id = workspace_id_for_path(canonical_root)
-        async with self._lock:
+        async with self._get_lock():
             handle = self._handles.get(workspace_id)
             if handle is None:
                 return
@@ -108,7 +117,7 @@ class OpenCodeSupervisor:
     async def mark_turn_finished(self, workspace_root: Path) -> None:
         canonical_root = canonical_workspace_root(workspace_root)
         workspace_id = workspace_id_for_path(canonical_root)
-        async with self._lock:
+        async with self._get_lock():
             handle = self._handles.get(workspace_id)
             if handle is None:
                 return
@@ -187,7 +196,7 @@ class OpenCodeSupervisor:
     ) -> OpenCodeHandle:
         handles_to_close: list[OpenCodeHandle] = []
         evicted_id: Optional[str] = None
-        async with self._lock:
+        async with self._get_lock():
             existing = self._handles.get(workspace_id)
             if existing is not None:
                 existing.last_used_at = time.monotonic()
@@ -287,7 +296,7 @@ class OpenCodeSupervisor:
                     logging.WARNING,
                     "opencode.openapi.fetch_failed",
                     base_url=base_url,
-                    exc=str(exc),
+                    exc=exc,
                 )
                 handle.openapi_spec = {}
             handle.started = True
@@ -356,7 +365,7 @@ class OpenCodeSupervisor:
                     logging.WARNING,
                     "opencode.openapi.fetch_failed",
                     base_url=base_url,
-                    exc=str(exc),
+                    exc=exc,
                 )
                 handle.openapi_spec = {}
             self._start_stdout_drain(handle)
@@ -468,53 +477,32 @@ class OpenCodeSupervisor:
                 return match.group(1)
 
     async def _pop_idle_handles(self) -> list[OpenCodeHandle]:
-        async with self._lock:
+        async with self._get_lock():
             return self._pop_idle_handles_locked()
 
+    def _get_lock(self) -> asyncio.Lock:
+        if self._lock is None:
+            self._lock = asyncio.Lock()
+        return self._lock
+
     def _pop_idle_handles_locked(self) -> list[OpenCodeHandle]:
-        if not self._idle_ttl_seconds or self._idle_ttl_seconds <= 0:
-            return []
-        cutoff = time.monotonic() - self._idle_ttl_seconds
-        stale: list[OpenCodeHandle] = []
-        for handle in list(self._handles.values()):
-            if handle.active_turns:
-                log_event(
-                    self._logger,
-                    logging.INFO,
-                    "opencode.handle.prune.skipped",
-                    reason="active_turns",
-                    workspace_id=handle.workspace_id,
-                    workspace_root=str(handle.workspace_root),
-                    active_turns=handle.active_turns,
-                )
-                continue
-            if handle.last_used_at and handle.last_used_at < cutoff:
-                self._handles.pop(handle.workspace_id, None)
-                stale.append(handle)
-        return stale
+        return pop_idle_handles_locked(
+            self._handles,
+            self._idle_ttl_seconds,
+            self._logger,
+            "opencode",
+            last_used_at_getter=lambda h: h.last_used_at,
+            should_skip_prune=lambda h: h.active_turns > 0,
+        )
 
     def _evict_lru_handle_locked(self) -> Optional[OpenCodeHandle]:
-        if not self._max_handles or self._max_handles <= 0:
-            return None
-        if len(self._handles) < self._max_handles:
-            return None
-        lru_handle = min(
-            self._handles.values(),
-            key=lambda handle: handle.last_used_at or 0.0,
-        )
-        log_event(
+        return evict_lru_handle_locked(
+            self._handles,
+            self._max_handles,
             self._logger,
-            logging.INFO,
-            "opencode.handle.evicted",
-            reason="max_handles",
-            workspace_id=lru_handle.workspace_id,
-            workspace_root=str(lru_handle.workspace_root),
-            max_handles=self._max_handles,
-            handle_count=len(self._handles),
-            last_used_at=lru_handle.last_used_at,
+            "opencode",
+            last_used_at_getter=lambda h: h.last_used_at or 0.0,
         )
-        self._handles.pop(lru_handle.workspace_id, None)
-        return lru_handle
 
 
 __all__ = ["OpenCodeHandle", "OpenCodeSupervisor", "OpenCodeSupervisorError"]