codex-autorunner 1.0.0__py3-none-any.whl → 1.2.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/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

@@ -21,6 +21,7 @@ class OpenCodeApiProfile:
 
     supports_prompt_async: bool = True
     supports_global_endpoints: bool = True
+    max_text_chars: Optional[int] = None
     spec_fetched: bool = False
 
 
@@ -83,6 +84,7 @@ class OpenCodeClient:
         *,
         auth: Optional[tuple[str, str]] = None,
         timeout: Optional[float] = None,
+        max_text_chars: Optional[int] = None,
         logger: Optional[logging.Logger] = None,
     ) -> None:
         self._client = httpx.AsyncClient(
@@ -93,6 +95,10 @@ class OpenCodeClient:
         self._logger = logger or logging.getLogger(__name__)
         self._api_profile: Optional[OpenCodeApiProfile] = None
         self._api_profile_lock = asyncio.Lock()
+        self._max_text_chars_override = (
+            int(max_text_chars) if isinstance(max_text_chars, int) else None
+        )
+        self._max_text_chars_cache: Optional[int] = None
 
     async def close(self) -> None:
         await self._client.aclose()
@@ -121,6 +127,7 @@ class OpenCodeClient:
                     profile.supports_global_endpoints = self.has_endpoint(
                         spec, "get", "/global/health"
                     ) or self.has_endpoint(spec, "get", "/global/event")
+                    profile.max_text_chars = self._extract_max_text_chars(spec)
 
                 log_event(
                     self._logger,
@@ -147,6 +154,103 @@ class OpenCodeClient:
             return OpenCodeApiProfile()
         return self._api_profile
 
+    @staticmethod
+    def _extract_max_text_chars(spec: dict[str, Any]) -> Optional[int]:
+        if not isinstance(spec, dict):
+            return None
+        components = spec.get("components")
+        if not isinstance(components, dict):
+            return None
+        schemas = components.get("schemas")
+        if not isinstance(schemas, dict):
+            return None
+        candidates: list[int] = []
+        for schema in schemas.values():
+            max_len = OpenCodeClient._find_text_max_length(schema)
+            if isinstance(max_len, int) and max_len > 0:
+                candidates.append(max_len)
+        return min(candidates) if candidates else None
+
+    @staticmethod
+    def _find_text_max_length(schema: Any) -> Optional[int]:
+        if not isinstance(schema, dict):
+            return None
+        candidates: list[int] = []
+        properties = schema.get("properties")
+        if isinstance(properties, dict) and "text" in properties:
+            text_schema = properties.get("text")
+            if isinstance(text_schema, dict):
+                max_len = text_schema.get("maxLength")
+                if isinstance(max_len, int) and max_len > 0:
+                    candidates.append(max_len)
+        for key in ("allOf", "anyOf", "oneOf"):
+            seq = schema.get(key)
+            if isinstance(seq, list):
+                for item in seq:
+                    item_len = OpenCodeClient._find_text_max_length(item)
+                    if isinstance(item_len, int) and item_len > 0:
+                        candidates.append(item_len)
+        return min(candidates) if candidates else None
+
+    def set_max_text_chars(self, value: Optional[int]) -> None:
+        self._max_text_chars_override = int(value) if isinstance(value, int) else None
+        self._max_text_chars_cache = None
+
+    async def _resolve_max_text_chars(
+        self, profile: Optional[OpenCodeApiProfile] = None
+    ) -> Optional[int]:
+        if self._max_text_chars_cache is not None:
+            return self._max_text_chars_cache
+        if profile is None:
+            profile = await self.detect_api_shape()
+        detected = (
+            profile.max_text_chars
+            if isinstance(profile.max_text_chars, int) and profile.max_text_chars > 0
+            else None
+        )
+        override = (
+            self._max_text_chars_override
+            if isinstance(self._max_text_chars_override, int)
+            and self._max_text_chars_override > 0
+            else None
+        )
+        if override is None:
+            resolved = detected
+        elif detected is None:
+            resolved = override
+        else:
+            resolved = min(override, detected)
+        self._max_text_chars_cache = resolved
+        return resolved
+
+    @staticmethod
+    def _split_text(text: str, max_chars: int) -> list[str]:
+        if max_chars <= 0 or len(text) <= max_chars:
+            return [text]
+        parts: list[str] = []
+        start = 0
+        length = len(text)
+        while start < length:
+            end = min(start + max_chars, length)
+            if end < length:
+                split = text.rfind("\n", start, end)
+                if split <= start:
+                    split = text.rfind(" ", start, end)
+                if split > start:
+                    end = split + 1
+            parts.append(text[start:end])
+            start = end
+        return [part for part in parts if part]
+
+    async def _build_text_parts(
+        self, message: str, profile: Optional[OpenCodeApiProfile] = None
+    ) -> list[dict[str, str]]:
+        limit = await self._resolve_max_text_chars(profile)
+        if limit is None:
+            return [{"type": "text", "text": message}]
+        chunks = self._split_text(message, limit)
+        return [{"type": "text", "text": chunk} for chunk in chunks]
+
     def _dir_params(self, directory: Optional[str]) -> dict[str, str]:
         return {"directory": directory} if directory else {}
 
@@ -275,8 +379,10 @@ class OpenCodeClient:
         model: Optional[dict[str, str]] = None,
         variant: Optional[str] = None,
     ) -> Any:
+        profile = await self.detect_api_shape()
+        parts = await self._build_text_parts(message, profile)
         payload: dict[str, Any] = {
-            "parts": [{"type": "text", "text": message}],
+            "parts": parts,
         }
         if agent:
             payload["agent"] = agent
@@ -300,8 +406,10 @@ class OpenCodeClient:
         model: Optional[dict[str, str]] = None,
         variant: Optional[str] = None,
     ) -> Any:
+        profile = await self.detect_api_shape()
+        parts = await self._build_text_parts(message, profile)
         payload: dict[str, Any] = {
-            "parts": [{"type": "text", "text": message}],
+            "parts": parts,
         }
         if agent:
             payload["agent"] = agent
@@ -310,7 +418,6 @@ class OpenCodeClient:
         if variant:
             payload["variant"] = variant
 
-        profile = await self.detect_api_shape()
         if profile.supports_prompt_async:
             return await self._request(
                 "POST",
@@ -335,8 +442,10 @@ class OpenCodeClient:
         model: Optional[dict[str, str]] = None,
         variant: Optional[str] = None,
     ) -> Any:
+        profile = await self.detect_api_shape()
+        parts = await self._build_text_parts(message, profile)
         payload: dict[str, Any] = {
-            "parts": [{"type": "text", "text": message}],
+            "parts": parts,
         }
         if agent:
             payload["agent"] = agent

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

@@ -122,6 +122,12 @@ 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:
@@ -132,6 +138,12 @@ def extract_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"):
@@ -757,8 +769,9 @@ 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
@@ -793,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")
@@ -806,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":
@@ -839,12 +861,32 @@ 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
@@ -1002,7 +1044,7 @@ async def collect_opencode_output_from_events(
                         status_type=status_type,
                         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:
@@ -1079,7 +1121,7 @@ async def collect_opencode_output_from_events(
                             status_type=status_type,
                             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:
@@ -1296,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
@@ -1470,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:
@@ -1485,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)

codex_autorunner/agents/opencode/supervisor.py

@@ -55,6 +55,7 @@ class OpenCodeSupervisor:
         base_url: Optional[str] = None,
         subagent_models: Optional[Mapping[str, str]] = None,
         session_stall_timeout_seconds: Optional[float] = None,
+        max_text_chars: Optional[int] = None,
     ) -> None:
         self._command = [str(arg) for arg in command]
         self._logger = logger or logging.getLogger(__name__)
@@ -70,6 +71,7 @@ class OpenCodeSupervisor:
         self._base_env = base_env
         self._base_url = base_url
         self._subagent_models = subagent_models or {}
+        self._max_text_chars = max_text_chars
         self._handles: dict[str, OpenCodeHandle] = {}
         self._lock: Optional[asyncio.Lock] = None
 
@@ -275,6 +277,7 @@ class OpenCodeSupervisor:
                 base_url,
                 auth=self._auth,
                 timeout=self._request_timeout,
+                max_text_chars=self._max_text_chars,
                 logger=self._logger,
             )
             try:
@@ -344,6 +347,7 @@ class OpenCodeSupervisor:
                 base_url,
                 auth=self._auth,
                 timeout=self._request_timeout,
+                max_text_chars=self._max_text_chars,
                 logger=self._logger,
             )
             try:

codex_autorunner/agents/registry.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import importlib.metadata
 import logging
+import threading
 from dataclasses import dataclass
 from typing import Any, Callable, Iterable, Literal, Optional
 
@@ -102,6 +103,9 @@ _BUILTIN_AGENTS: dict[str, AgentDescriptor] = {
 # Lazy-loaded cache of built-in + plugin agents.
 _AGENT_CACHE: Optional[dict[str, AgentDescriptor]] = None
 
+# Lock to protect cache initialization and reload from concurrent access.
+_AGENT_CACHE_LOCK = threading.Lock()
+
 
 def _select_entry_points(group: str) -> Iterable[importlib.metadata.EntryPoint]:
     """Compatibility wrapper for `importlib.metadata.entry_points()` across py versions."""
@@ -163,14 +167,36 @@ def _load_agent_plugins() -> dict[str, AgentDescriptor]:
             )
             continue
 
-        if descriptor.plugin_api_version != CAR_PLUGIN_API_VERSION:
+        api_version_raw = getattr(descriptor, "plugin_api_version", None)
+        if api_version_raw is None:
+            api_version = None
+        else:
+            try:
+                api_version = int(api_version_raw)
+            except Exception:
+                api_version = None
+        if api_version is None:
             _logger.warning(
-                "Ignoring agent plugin %s (api_version=%s): expected %s",
+                "Ignoring agent plugin %s: invalid api_version %s",
                 agent_id,
-                descriptor.plugin_api_version,
+                api_version_raw,
+            )
+            continue
+        if api_version > CAR_PLUGIN_API_VERSION:
+            _logger.warning(
+                "Ignoring agent plugin %s (api_version=%s) requires newer core (%s)",
+                agent_id,
+                api_version,
                 CAR_PLUGIN_API_VERSION,
             )
             continue
+        if api_version < CAR_PLUGIN_API_VERSION:
+            _logger.info(
+                "Loaded agent plugin %s with older api_version=%s (current=%s)",
+                agent_id,
+                api_version,
+                CAR_PLUGIN_API_VERSION,
+            )
 
         if agent_id in _BUILTIN_AGENTS:
             _logger.warning(
@@ -196,9 +222,11 @@ def _load_agent_plugins() -> dict[str, AgentDescriptor]:
 def _all_agents() -> dict[str, AgentDescriptor]:
     global _AGENT_CACHE
     if _AGENT_CACHE is None:
-        agents = _BUILTIN_AGENTS.copy()
-        agents.update(_load_agent_plugins())
-        _AGENT_CACHE = agents
+        with _AGENT_CACHE_LOCK:
+            if _AGENT_CACHE is None:
+                agents = _BUILTIN_AGENTS.copy()
+                agents.update(_load_agent_plugins())
+                _AGENT_CACHE = agents
     return _AGENT_CACHE
 
 
@@ -209,7 +237,8 @@ def reload_agents() -> dict[str, AgentDescriptor]:
     """
 
     global _AGENT_CACHE
-    _AGENT_CACHE = None
+    with _AGENT_CACHE_LOCK:
+        _AGENT_CACHE = None
     return get_registered_agents()