codex-autorunner 0.1.2__py3-none-any.whl → 1.1.0__py3-none-any.whl

codex_autorunner/__init__.py

@@ -1,3 +1,14 @@
 """Codex autorunner package."""
 
-__all__ = ["cli", "core", "integrations", "routes", "server", "voice", "web"]
+__all__ = [
+    "cli",
+    "core",
+    "integrations",
+    "routes",
+    "server",
+    "surfaces",
+    "surfaces.web.routes",
+    "surfaces.web",
+    "voice",
+    "web",
+]

codex_autorunner/__main__.py

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

codex_autorunner/agents/codex/harness.py

@@ -3,7 +3,7 @@ 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.event_buffer import AppServerEventBuffer
 from ...integrations.app_server.supervisor import WorkspaceAppServerSupervisor
 from ..base import AgentHarness
 from ..types import AgentId, ConversationRef, ModelCatalog, ModelSpec, TurnRef

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/constants.py

@@ -0,0 +1,3 @@
+DEFAULT_TICKET_MODEL = "zai-coding-plan/glm-4.7"
+
+__all__ = ["DEFAULT_TICKET_MODEL"]

codex_autorunner/agents/opencode/harness.py

@@ -6,9 +6,10 @@ import logging
 from pathlib import Path
 from typing import Any, AsyncIterator, Optional
 
-from ...core.app_server_events import format_sse
+from ...integrations.app_server.event_buffer import format_sse
 from ..base import AgentHarness
 from ..types import AgentId, ConversationRef, ModelCatalog, ModelSpec, TurnRef
+from .constants import DEFAULT_TICKET_MODEL
 from .runtime import (
     build_turn_id,
     extract_session_id,
@@ -168,6 +169,8 @@ class OpenCodeHarness(AgentHarness):
         sandbox_policy: Optional[Any],
     ) -> TurnRef:
         client = await self._supervisor.get_client(workspace_root)
+        if model is None:
+            model = DEFAULT_TICKET_MODEL
         model_payload = split_model_id(model)
         await client.prompt_async(
             conversation_id,
@@ -192,6 +195,8 @@ class OpenCodeHarness(AgentHarness):
         sandbox_policy: Optional[Any],
     ) -> TurnRef:
         client = await self._supervisor.get_client(workspace_root)
+        if model is None:
+            model = DEFAULT_TICKET_MODEL
         arguments = prompt if prompt else ""
 
         async def _send_review() -> None:

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
@@ -121,23 +122,37 @@ def extract_session_id(
         value = payload.get(key)
         if isinstance(value, str) and value:
             return value
+    info = payload.get("info")
+    if isinstance(info, dict):
+        for key in ("sessionID", "sessionId", "session_id"):
+            value = info.get(key)
+            if isinstance(value, str) and value:
+                return value
     if allow_fallback_id:
         value = payload.get("id")
         if isinstance(value, str) and value:
             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
+        info = properties.get("info")
+        if isinstance(info, dict):
+            for key in ("sessionID", "sessionId", "session_id"):
+                value = info.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 +691,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 +747,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,
@@ -753,19 +769,23 @@ async def collect_opencode_output_from_events(
     error: Optional[str] = None
     message_roles: dict[str, str] = {}
     message_roles_seen = False
-    last_role_seen: Optional[str] = None
     pending_text: dict[str, list[str]] = {}
+    pending_no_id: list[str] = []
+    no_id_role: Optional[str] = None
     fallback_message: Optional[tuple[Optional[str], Optional[str], str]] = None
     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):
@@ -786,7 +806,7 @@ async def collect_opencode_output_from_events(
         return None
 
     def _register_message_role(payload: Any) -> tuple[Optional[str], Optional[str]]:
-        nonlocal last_role_seen, message_roles_seen
+        nonlocal message_roles_seen
         if not isinstance(payload, dict):
             return None, None
         info = payload.get("info")
@@ -799,18 +819,27 @@ async def collect_opencode_output_from_events(
         if isinstance(role, str) and msg_id:
             message_roles[msg_id] = role
             message_roles_seen = True
-            last_role_seen = role
         return msg_id, role if isinstance(role, str) else None
 
+    def _flush_pending_no_id_as_assistant() -> None:
+        nonlocal no_id_role
+        if pending_no_id:
+            text_parts.extend(pending_no_id)
+            pending_no_id.clear()
+        no_id_role = "assistant"
+
+    def _discard_pending_no_id() -> None:
+        if pending_no_id:
+            pending_no_id.clear()
+
     def _append_text_for_message(message_id: Optional[str], text: str) -> None:
         if not text:
             return
         if message_id is None:
-            if not message_roles_seen:
-                text_parts.append(text)
-                return
-            if last_role_seen != "user":
+            if no_id_role == "assistant":
                 text_parts.append(text)
+            else:
+                pending_no_id.append(text)
             return
         role = message_roles.get(message_id)
         if role == "user":
@@ -832,26 +861,50 @@ async def collect_opencode_output_from_events(
             text_parts.extend(pending)
 
     def _flush_all_pending_text() -> None:
-        if not pending_text:
+        if pending_text:
+            for pending in list(pending_text.values()):
+                if pending:
+                    text_parts.extend(pending)
+            pending_text.clear()
+        if pending_no_id:
+            # If we have not seen a role yet, assume assistant for backwards
+            # compatibility with providers that omit roles entirely. Otherwise,
+            # only flush when we have already classified no-id text as assistant
+            # or when we have no other text (to avoid echoing user prompts).
+            if not message_roles_seen or no_id_role == "assistant" or not text_parts:
+                text_parts.extend(pending_no_id)
+            pending_no_id.clear()
+
+    def _handle_role_update(message_id: Optional[str], role: Optional[str]) -> None:
+        nonlocal no_id_role
+        if not role:
+            return
+        if role == "assistant":
+            _flush_pending_text(message_id)
+            _flush_pending_no_id_as_assistant()
             return
-        for pending in list(pending_text.values()):
-            if pending:
-                text_parts.extend(pending)
-        pending_text.clear()
+        if role == "user":
+            _flush_pending_text(message_id)
+            _discard_pending_no_id()
+            no_id_role = None
 
     async def _resolve_session_model_ids() -> tuple[Optional[str], Optional[str]]:
         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 +999,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 +1034,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,9 +1042,9 @@ 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:
+                    if not text_parts and (pending_text or pending_no_id):
                         _flush_all_pending_text()
                     break
                 if last_primary_completion_at is not None:
@@ -1000,7 +1054,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 +1069,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 +1077,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 or pending_no_id):
+                            _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)
@@ -1219,8 +1338,7 @@ async def collect_opencode_output_from_events(
             if event.event in ("message.updated", "message.completed"):
                 if is_primary_session:
                     msg_id, role = _register_message_role(payload)
-                    if role == "assistant":
-                        _flush_pending_text(msg_id)
+                    _handle_role_update(msg_id, role)
             if event.event == "message.part.updated":
                 properties = (
                     payload.get("properties") if isinstance(payload, dict) else None
@@ -1393,7 +1511,7 @@ async def collect_opencode_output_from_events(
             ):
                 if not is_primary_session:
                     continue
-                if not text_parts and pending_text:
+                if not text_parts and (pending_text or pending_no_id):
                     _flush_all_pending_text()
                 break
             if event.event == "message.completed" and is_primary_session:
@@ -1408,7 +1526,7 @@ async def collect_opencode_output_from_events(
             resolved_role = message_roles.get(msg_id)
         if resolved_role == "assistant":
             _append_text_for_message(msg_id, text)
-            if pending_text:
+            if pending_text or pending_no_id:
                 _flush_all_pending_text()
 
     return OpenCodeTurnOutput(text="".join(text_parts).strip(), error=error)
@@ -1419,6 +1537,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 +1546,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 +1558,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 +1592,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,
     )