codex-autorunner 1.2.1__py3-none-any.whl → 1.3.0__py3-none-any.whl

codex_autorunner/integrations/agents/codex_backend.py

@@ -47,6 +47,7 @@ class CodexAppServerBackend(AgentBackend):
         restart_backoff_initial_seconds: Optional[float] = None,
         restart_backoff_max_seconds: Optional[float] = None,
         restart_backoff_jitter_ratio: Optional[float] = None,
+        output_policy: str = "final_only",
         notification_handler: Optional[NotificationHandler] = None,
         logger: Optional[logging.Logger] = None,
     ):
@@ -71,6 +72,7 @@ class CodexAppServerBackend(AgentBackend):
         self._restart_backoff_initial_seconds = restart_backoff_initial_seconds
         self._restart_backoff_max_seconds = restart_backoff_max_seconds
         self._restart_backoff_jitter_ratio = restart_backoff_jitter_ratio
+        self._output_policy = output_policy
         self._notification_handler = notification_handler
         self._logger = logger or _logger
 
@@ -102,6 +104,7 @@ class CodexAppServerBackend(AgentBackend):
                 restart_backoff_initial_seconds=self._restart_backoff_initial_seconds,
                 restart_backoff_max_seconds=self._restart_backoff_max_seconds,
                 restart_backoff_jitter_ratio=self._restart_backoff_jitter_ratio,
+                output_policy=self._output_policy,
                 logger=self._logger,
             )
             await self._client.start()
@@ -201,16 +204,18 @@ class CodexAppServerBackend(AgentBackend):
         yield AgentEvent.stream_delta(content=message, delta_type="user_message")
 
         result = await handle.wait(timeout=self._turn_timeout_seconds)
-
-        for msg in result.agent_messages:
-            yield AgentEvent.stream_delta(content=msg, delta_type="assistant_message")
+        final_text = str(getattr(result, "final_message", "") or "")
+        if not final_text.strip():
+            final_text = "\n\n".join(
+                msg.strip()
+                for msg in getattr(result, "agent_messages", [])
+                if isinstance(msg, str) and msg.strip()
+            )
 
         for event_data in result.raw_events:
             yield self._parse_raw_event(event_data)
 
-        yield AgentEvent.message_complete(
-            final_message="\n".join(result.agent_messages)
-        )
+        yield AgentEvent.message_complete(final_message=final_text)
 
     async def run_turn_events(
         self, session_id: str, message: str
@@ -283,11 +288,12 @@ class CodexAppServerBackend(AgentBackend):
                     if get_task in pending_set:
                         get_task.cancel()
                     result = wait_task.result()
-                    for msg in result.agent_messages:
-                        yield OutputDelta(
-                            timestamp=now_iso(),
-                            content=msg,
-                            delta_type="assistant_message",
+                    final_text = str(getattr(result, "final_message", "") or "")
+                    if not final_text.strip():
+                        final_text = "\n\n".join(
+                            msg.strip()
+                            for msg in getattr(result, "agent_messages", [])
+                            if isinstance(msg, str) and msg.strip()
                         )
                     # raw_events already contain the same notifications we streamed
                     # through _event_queue; skipping here avoids double-emitting.
@@ -297,7 +303,7 @@ class CodexAppServerBackend(AgentBackend):
                             yield extra
                     yield Completed(
                         timestamp=now_iso(),
-                        final_message="\n".join(result.agent_messages),
+                        final_message=final_text,
                     )
                     break
 

codex_autorunner/integrations/agents/wiring.py

@@ -106,6 +106,7 @@ class AgentBackendFactory:
                     restart_backoff_initial_seconds=self._config.app_server.client.restart_backoff_initial_seconds,
                     restart_backoff_max_seconds=self._config.app_server.client.restart_backoff_max_seconds,
                     restart_backoff_jitter_ratio=self._config.app_server.client.restart_backoff_jitter_ratio,
+                    output_policy=self._config.app_server.output.policy,
                     notification_handler=notification_handler,
                     logger=self._logger,
                 )
@@ -267,6 +268,7 @@ def build_app_server_supervisor_factory(
             restart_backoff_initial_seconds=config.app_server.client.restart_backoff_initial_seconds,
             restart_backoff_max_seconds=config.app_server.client.restart_backoff_max_seconds,
             restart_backoff_jitter_ratio=config.app_server.client.restart_backoff_jitter_ratio,
+            output_policy=config.app_server.output.policy,
         )
 
     return factory

codex_autorunner/integrations/app_server/client.py

@@ -62,6 +62,8 @@ _TURN_STALL_POLL_INTERVAL_SECONDS = 2.0
 _TURN_STALL_RECOVERY_MIN_INTERVAL_SECONDS = 10.0
 _MAX_TURN_RAW_EVENTS = 200
 _INVALID_JSON_PREVIEW_BYTES = 200
+_DEFAULT_OUTPUT_POLICY = "final_only"
+_OUTPUT_POLICIES = {"final_only", "all_agent_messages"}
 
 # Track live clients so tests/cleanup can cancel any background restart tasks.
 _CLIENT_INSTANCES: weakref.WeakSet = weakref.WeakSet()
@@ -108,6 +110,7 @@ class CodexAppServerProtocolError(CodexAppServerError, PermanentError):
 class TurnResult:
     turn_id: str
     status: Optional[str]
+    final_message: str
     agent_messages: list[str]
     errors: list[str]
     raw_events: list[Dict[str, Any]]
@@ -163,6 +166,7 @@ class CodexAppServerClient:
         restart_backoff_initial_seconds: Optional[float] = None,
         restart_backoff_max_seconds: Optional[float] = None,
         restart_backoff_jitter_ratio: Optional[float] = None,
+        output_policy: str = _DEFAULT_OUTPUT_POLICY,
         notification_handler: Optional[NotificationHandler] = None,
         logger: Optional[logging.Logger] = None,
     ) -> None:
@@ -217,6 +221,7 @@ class CodexAppServerClient:
             and restart_backoff_jitter_ratio >= 0
             else _RESTART_BACKOFF_JITTER_RATIO
         )
+        self._output_policy = _normalize_output_policy(output_policy)
 
         self._process: Optional[asyncio.subprocess.Process] = None
         self._reader_task: Optional[asyncio.Task] = None
@@ -558,6 +563,9 @@ class CodexAppServerClient:
             state.future.set_result(
                 TurnResult(
                     turn_id=state.turn_id,
+                    final_message=_final_message_for_result(
+                        state, policy=self._output_policy
+                    ),
                     agent_messages=_agent_messages_for_result(state),
                     errors=list(state.errors),
                     raw_events=list(state.raw_events),
@@ -1269,6 +1277,9 @@ class CodexAppServerClient:
                 TurnResult(
                     turn_id=target.turn_id,
                     status=target.status,
+                    final_message=_final_message_for_result(
+                        target, policy=self._output_policy
+                    ),
                     agent_messages=_agent_messages_for_result(target),
                     errors=list(target.errors),
                     raw_events=list(target.raw_events),
@@ -1366,6 +1377,9 @@ class CodexAppServerClient:
                 TurnResult(
                     turn_id=state.turn_id,
                     status=state.status,
+                    final_message=_final_message_for_result(
+                        state, policy=self._output_policy
+                    ),
                     agent_messages=_agent_messages_for_result(state),
                     errors=list(state.errors),
                     raw_events=list(state.raw_events),
@@ -1701,6 +1715,23 @@ def _agent_messages_for_result(state: _TurnState) -> list[str]:
     return _agent_message_deltas_as_list(state.agent_message_deltas)
 
 
+def _normalize_output_policy(policy: Optional[str]) -> str:
+    candidate = str(policy or "").strip().lower()
+    if candidate in _OUTPUT_POLICIES:
+        return candidate
+    return _DEFAULT_OUTPUT_POLICY
+
+
+def _final_message_for_result(state: _TurnState, *, policy: str) -> str:
+    messages = _agent_messages_for_result(state)
+    cleaned = [msg.strip() for msg in messages if isinstance(msg, str) and msg.strip()]
+    if not cleaned:
+        return ""
+    if policy == "all_agent_messages":
+        return "\n\n".join(cleaned)
+    return cleaned[-1]
+
+
 def _extract_status_value(value: Any) -> Optional[str]:
     if isinstance(value, str):
         return value

codex_autorunner/integrations/app_server/supervisor.py

@@ -47,6 +47,7 @@ class WorkspaceAppServerSupervisor:
         restart_backoff_initial_seconds: Optional[float] = None,
         restart_backoff_max_seconds: Optional[float] = None,
         restart_backoff_jitter_ratio: Optional[float] = None,
+        output_policy: str = "final_only",
         default_approval_decision: str = "cancel",
         max_handles: Optional[int] = None,
         idle_ttl_seconds: Optional[float] = None,
@@ -78,6 +79,7 @@ class WorkspaceAppServerSupervisor:
         self._restart_backoff_initial_seconds = restart_backoff_initial_seconds
         self._restart_backoff_max_seconds = restart_backoff_max_seconds
         self._restart_backoff_jitter_ratio = restart_backoff_jitter_ratio
+        self._output_policy = output_policy
         self._default_approval_decision = default_approval_decision
         self._max_handles = max_handles
         self._idle_ttl_seconds = idle_ttl_seconds
@@ -170,6 +172,7 @@ class WorkspaceAppServerSupervisor:
                 restart_backoff_initial_seconds=self._restart_backoff_initial_seconds,
                 restart_backoff_max_seconds=self._restart_backoff_max_seconds,
                 restart_backoff_jitter_ratio=self._restart_backoff_jitter_ratio,
+                output_policy=self._output_policy,
                 notification_handler=self._notification_handler,
                 logger=self._logger,
             )

codex_autorunner/integrations/telegram/constants.py

@@ -120,7 +120,7 @@ MAX_MENTION_BYTES = 200_000
 VALID_REASONING_EFFORTS = {"none", "minimal", "low", "medium", "high", "xhigh"}
 VALID_AGENT_VALUES = {"codex", "opencode"}
 DEFAULT_AGENT_MODELS = {
-    "codex": "gpt-5.2-codex",
+    "codex": "gpt-5.3-codex",
     "opencode": "zai-coding-plan/glm-4.7",
 }
 LEGACY_DEFAULT_AGENT_MODELS = DEFAULT_AGENT_MODELS

codex_autorunner/integrations/telegram/handlers/commands/execution.py

@@ -81,6 +81,7 @@ from ...helpers import (
     _set_thread_summary,
     _with_conversation_id,
     find_github_links,
+    format_public_error,
     is_interrupt_status,
 )
 from ...state import topic_key as build_topic_key
@@ -340,12 +341,12 @@ def _format_opencode_exception(exc: Exception) -> Optional[str]:
     if isinstance(exc, OpenCodeSupervisorError):
         detail = str(exc).strip()
         if detail:
-            return f"OpenCode backend unavailable ({detail})."
+            return f"OpenCode backend unavailable ({format_public_error(detail)})."
         return "OpenCode backend unavailable."
     if isinstance(exc, OpenCodeProtocolError):
         detail = str(exc).strip()
         if detail:
-            return f"OpenCode protocol error: {detail}"
+            return f"OpenCode protocol error: {format_public_error(detail)}"
         return "OpenCode protocol error."
     if isinstance(exc, json.JSONDecodeError):
         return "OpenCode returned invalid JSON."
@@ -356,15 +357,15 @@ def _format_opencode_exception(exc: Exception) -> Optional[str]:
         except Exception:
             detail = None
         if detail:
-            return f"OpenCode error: {detail}"
+            return f"OpenCode error: {format_public_error(detail)}"
         response_text = exc.response.text.strip()
         if response_text:
-            return f"OpenCode error: {response_text}"
+            return f"OpenCode error: {format_public_error(response_text)}"
         return f"OpenCode request failed (HTTP {exc.response.status_code})."
     if isinstance(exc, httpx.RequestError):
         detail = str(exc).strip()
         if detail:
-            return f"OpenCode request failed: {detail}"
+            return f"OpenCode request failed: {format_public_error(detail)}"
         return "OpenCode request failed."
     return None
 
@@ -399,15 +400,15 @@ def _format_httpx_exception(exc: Exception) -> Optional[str]:
                 payload.get("detail") or payload.get("message") or payload.get("error")
             )
             if isinstance(detail, str) and detail:
-                return detail
+                return format_public_error(detail)
         response_text = exc.response.text.strip()
         if response_text:
-            return response_text
+            return format_public_error(response_text)
         return f"Request failed (HTTP {exc.response.status_code})."
     if isinstance(exc, httpx.RequestError):
         detail = str(exc).strip()
         if detail:
-            return detail
+            return format_public_error(detail)
         return "Request failed."
     return None
 
@@ -424,10 +425,7 @@ def _iter_exception_chain(exc: BaseException) -> list[BaseException]:
 
 
 def _sanitize_error_detail(detail: str, *, limit: int = 200) -> str:
-    cleaned = " ".join(detail.split())
-    if len(cleaned) > limit:
-        return f"{cleaned[: limit - 3]}..."
-    return cleaned
+    return format_public_error(detail, limit=limit)
 
 
 def _format_telegram_download_error(exc: Exception) -> Optional[str]:
@@ -435,10 +433,10 @@ def _format_telegram_download_error(exc: Exception) -> Optional[str]:
         if isinstance(current, Exception):
             detail = _format_httpx_exception(current)
             if detail:
-                return _sanitize_error_detail(detail)
+                return format_public_error(detail)
             message = str(current).strip()
             if message and message not in _GENERIC_TELEGRAM_ERRORS:
-                return _sanitize_error_detail(message)
+                return format_public_error(message)
     return None
 
 
@@ -2386,7 +2384,10 @@ class ExecutionCommands(SharedHelpers):
             runtime.interrupt_requested = False
 
         response = _compose_agent_response(
-            result.agent_messages, errors=result.errors, status=result.status
+            getattr(result, "final_message", None),
+            messages=result.agent_messages,
+            errors=result.errors,
+            status=result.status,
         )
         if thread_id and result.agent_messages:
             assistant_preview = _preview_from_text(

codex_autorunner/integrations/telegram/handlers/commands/files.py

@@ -15,7 +15,7 @@ from .....core.logging_utils import log_event
 from .....core.state import now_iso
 from ...adapter import TelegramMessage
 from ...config import TelegramMediaCandidate
-from ...helpers import _path_within
+from ...helpers import _path_within, format_public_error
 from ...state import PendingVoiceRecord, TelegramTopicRecord
 from .. import messages as message_handlers
 from .shared import SharedHelpers
@@ -57,10 +57,7 @@ def _iter_exception_chain(exc: BaseException) -> list[BaseException]:
 
 
 def _sanitize_error_detail(detail: str, *, limit: int = 200) -> str:
-    cleaned = " ".join(detail.split())
-    if len(cleaned) > limit:
-        return f"{cleaned[: limit - 3]}..."
-    return cleaned
+    return format_public_error(detail, limit=limit)
 
 
 @dataclass
@@ -166,10 +163,10 @@ class FilesCommands(SharedHelpers):
             if isinstance(current, Exception):
                 detail = self._format_httpx_exception(current)
                 if detail:
-                    return _sanitize_error_detail(detail)
+                    return format_public_error(detail)
                 message = str(current).strip()
                 if message and message not in _GENERIC_TELEGRAM_ERRORS:
-                    return _sanitize_error_detail(message)
+                    return format_public_error(message)
         return None
 
     def _format_download_failure_response(
@@ -177,7 +174,7 @@ class FilesCommands(SharedHelpers):
     ) -> str:
         base = f"Failed to download {kind}."
         if detail:
-            return f"{base} Reason: {detail}"
+            return f"{base} Reason: {format_public_error(detail)}"
         return base
 
     def _format_media_batch_failure(

codex_autorunner/integrations/telegram/handlers/commands/github.py

@@ -57,6 +57,7 @@ from ...helpers import (
     _preview_from_text,
     _set_thread_summary,
     _with_conversation_id,
+    format_public_error,
     is_interrupt_status,
 )
 from ...types import ReviewCommitSelectionState, TurnContext
@@ -493,7 +494,10 @@ class GitHubCommands(SharedHelpers):
     ) -> None:
         """Handle successful Codex review completion."""
         response = _compose_agent_response(
-            result.agent_messages, errors=result.errors, status=result.status
+            getattr(result, "final_message", None),
+            messages=result.agent_messages,
+            errors=result.errors,
+            status=result.status,
         )
         if thread_id and result.agent_messages:
             assistant_preview = _preview_from_text(
@@ -1640,12 +1644,12 @@ def _format_opencode_exception(exc: Exception) -> Optional[str]:
     if isinstance(exc, OpenCodeSupervisorError):
         detail = str(exc).strip()
         if detail:
-            return f"OpenCode backend unavailable ({detail})."
+            return f"OpenCode backend unavailable ({format_public_error(detail)})."
         return "OpenCode backend unavailable."
     if isinstance(exc, OpenCodeProtocolError):
         detail = str(exc).strip()
         if detail:
-            return f"OpenCode protocol error: {detail}"
+            return f"OpenCode protocol error: {format_public_error(detail)}"
         return "OpenCode protocol error."
     if isinstance(exc, json.JSONDecodeError):
         return "OpenCode returned invalid JSON."
@@ -1656,15 +1660,15 @@ def _format_opencode_exception(exc: Exception) -> Optional[str]:
         except Exception:
             detail = None
         if detail:
-            return f"OpenCode error: {detail}"
+            return f"OpenCode error: {format_public_error(detail)}"
         response_text = exc.response.text.strip()
         if response_text:
-            return f"OpenCode error: {response_text}"
+            return f"OpenCode error: {format_public_error(response_text)}"
         return f"OpenCode request failed (HTTP {exc.response.status_code})."
     if isinstance(exc, httpx.RequestError):
         detail = str(exc).strip()
         if detail:
-            return f"OpenCode request failed: {detail}"
+            return f"OpenCode request failed: {format_public_error(detail)}"
         return "OpenCode request failed."
     return None
 

codex_autorunner/integrations/telegram/handlers/commands/shared.py

@@ -11,6 +11,7 @@ import httpx
 from .....agents.opencode.client import OpenCodeProtocolError
 from .....agents.opencode.supervisor import OpenCodeSupervisorError
 from ...adapter import InlineButton, build_inline_keyboard, encode_cancel_callback
+from ...helpers import format_public_error
 
 if TYPE_CHECKING:
     pass
@@ -60,15 +61,15 @@ class SharedHelpers:
                     or payload.get("error")
                 )
                 if isinstance(detail, str) and detail:
-                    return detail
+                    return format_public_error(detail)
             response_text = exc.response.text.strip()
             if response_text:
-                return response_text
+                return format_public_error(response_text)
             return f"Request failed (HTTP {exc.response.status_code})."
         if isinstance(exc, httpx.RequestError):
             detail = str(exc).strip()
             if detail:
-                return detail
+                return format_public_error(detail)
             return "Request failed."
         return None
 
@@ -84,12 +85,12 @@ class SharedHelpers:
         if isinstance(exc, OpenCodeSupervisorError):
             detail = str(exc).strip()
             if detail:
-                return f"OpenCode backend unavailable ({detail})."
+                return f"OpenCode backend unavailable ({format_public_error(detail)})."
             return "OpenCode backend unavailable."
         if isinstance(exc, OpenCodeProtocolError):
             detail = str(exc).strip()
             if detail:
-                return f"OpenCode protocol error: {detail}"
+                return f"OpenCode protocol error: {format_public_error(detail)}"
             return "OpenCode protocol error."
         if isinstance(exc, json.JSONDecodeError):
             return "OpenCode returned invalid JSON."
@@ -100,15 +101,15 @@ class SharedHelpers:
             except Exception:
                 detail = None
             if detail:
-                return f"OpenCode error: {detail}"
+                return f"OpenCode error: {format_public_error(detail)}"
             response_text = exc.response.text.strip()
             if response_text:
-                return f"OpenCode error: {response_text}"
+                return f"OpenCode error: {format_public_error(response_text)}"
             return f"OpenCode request failed (HTTP {exc.response.status_code})."
         if isinstance(exc, httpx.RequestError):
             detail = str(exc).strip()
             if detail:
-                return f"OpenCode request failed: {detail}"
+                return f"OpenCode request failed: {format_public_error(detail)}"
             return "OpenCode request failed."
         return None
 

codex_autorunner/integrations/telegram/handlers/commands/workspace.py

@@ -16,6 +16,7 @@ from .....core.utils import canonicalize_path, resolve_opencode_binary
 from .....manifest import load_manifest
 from ....app_server.client import (
     CodexAppServerClient,
+    CodexAppServerResponseError,
 )
 from ...adapter import (
     TelegramCallbackQuery,
@@ -112,6 +113,12 @@ class ResumeThreadData:
 
 
 class WorkspaceCommands(SharedHelpers):
+    def _is_missing_thread_error(self, exc: Exception) -> bool:
+        if not isinstance(exc, CodexAppServerResponseError):
+            return False
+        message = str(exc).lower()
+        return "thread not found" in message
+
     def _resolve_workspace_path(
         self,
         record: Optional["TelegramTopicRecord"],
@@ -390,6 +397,18 @@ class WorkspaceCommands(SharedHelpers):
         try:
             result = await client.thread_resume(thread_id)
         except Exception as exc:
+            if self._is_missing_thread_error(exc):
+                log_event(
+                    self._logger,
+                    logging.INFO,
+                    "telegram.thread.verify_missing",
+                    chat_id=message.chat_id,
+                    thread_id=message.thread_id,
+                    codex_thread_id=thread_id,
+                )
+                return await self._router.set_active_thread(
+                    message.chat_id, message.thread_id, None
+                )
             log_event(
                 self._logger,
                 logging.WARNING,
@@ -1113,7 +1132,25 @@ class WorkspaceCommands(SharedHelpers):
                     reply_to=message.message_id,
                 )
                 return
-            thread = await client.thread_start(record.workspace_path, agent=agent)
+            try:
+                thread = await client.thread_start(record.workspace_path, agent=agent)
+            except Exception as exc:
+                log_event(
+                    self._logger,
+                    logging.WARNING,
+                    "telegram.reset.failed",
+                    chat_id=message.chat_id,
+                    thread_id=message.thread_id,
+                    workspace_path=record.workspace_path,
+                    exc=exc,
+                )
+                await self._send_message(
+                    message.chat_id,
+                    "Failed to reset thread; check logs for details.",
+                    thread_id=message.thread_id,
+                    reply_to=message.message_id,
+                )
+                return
             if not await self._require_thread_workspace(
                 message, record.workspace_path, thread, action="thread_start"
             ):
@@ -1264,7 +1301,25 @@ class WorkspaceCommands(SharedHelpers):
                     reply_to=message.message_id,
                 )
                 return
-            thread = await client.thread_start(record.workspace_path, agent=agent)
+            try:
+                thread = await client.thread_start(record.workspace_path, agent=agent)
+            except Exception as exc:
+                log_event(
+                    self._logger,
+                    logging.WARNING,
+                    "telegram.new.failed",
+                    chat_id=message.chat_id,
+                    thread_id=message.thread_id,
+                    workspace_path=record.workspace_path,
+                    exc=exc,
+                )
+                await self._send_message(
+                    message.chat_id,
+                    "Failed to start a new thread; check logs for details.",
+                    thread_id=message.thread_id,
+                    reply_to=message.message_id,
+                )
+                return
             if not await self._require_thread_workspace(
                 message, record.workspace_path, thread, action="thread_start"
             ):
@@ -2044,6 +2099,34 @@ class WorkspaceCommands(SharedHelpers):
         try:
             result = await client.thread_resume(thread_id)
         except Exception as exc:
+            if self._is_missing_thread_error(exc):
+                log_event(
+                    self._logger,
+                    logging.INFO,
+                    "telegram.resume.missing_thread",
+                    topic_key=key,
+                    thread_id=thread_id,
+                )
+
+                def clear_stale(record: "TelegramTopicRecord") -> None:
+                    if record.active_thread_id == thread_id:
+                        record.active_thread_id = None
+                    if thread_id in record.thread_ids:
+                        record.thread_ids.remove(thread_id)
+                    record.thread_summaries.pop(thread_id, None)
+
+                await self._store.update_topic(key, clear_stale)
+                await self._answer_callback(callback, "Thread missing")
+                await self._finalize_selection(
+                    key,
+                    callback,
+                    _with_conversation_id(
+                        "Thread no longer exists. Cleared stale state; use /new to start a fresh thread.",
+                        chat_id=chat_id,
+                        thread_id=thread_id_val,
+                    ),
+                )
+                return
             log_event(
                 self._logger,
                 logging.WARNING,