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

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

@@ -1370,7 +1370,7 @@ class TelegramBotClient:
         return bool(result) if isinstance(result, bool) else False
 
     async def download_file(
-        self, file_path: str, max_size_bytes: int = 50 * 1024 * 1024
+        self, file_path: str, max_size_bytes: int = 100 * 1024 * 1024
     ) -> bytes:
         safe_path = file_path.lstrip("/")
         url = f"{self._file_base_url}/{safe_path}"

codex_autorunner/integrations/telegram/config.py

@@ -44,7 +44,7 @@ DEFAULT_APP_SERVER_TURN_TIMEOUT_SECONDS = 28800
 DEFAULT_APPROVAL_TIMEOUT_SECONDS = 300.0
 DEFAULT_MEDIA_MAX_IMAGE_BYTES = 10 * 1024 * 1024
 DEFAULT_MEDIA_MAX_VOICE_BYTES = 10 * 1024 * 1024
-DEFAULT_MEDIA_MAX_FILE_BYTES = 10 * 1024 * 1024
+DEFAULT_MEDIA_MAX_FILE_BYTES = 100 * 1024 * 1024
 DEFAULT_MEDIA_IMAGE_PROMPT = (
     "The user sent an image with no caption. Use it to continue the "
     "conversation; if no clear task, describe the image and ask what they want."

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,

codex_autorunner/integrations/telegram/handlers/commands_runtime.py

@@ -18,6 +18,7 @@ import httpx
 from ....agents.opencode.client import OpenCodeProtocolError
 from ....agents.opencode.supervisor import OpenCodeSupervisorError
 from ....core.logging_utils import log_event
+from ....core.pma_sink import PmaActiveSinkStore
 from ....core.state import now_iso
 from ....core.update import _normalize_update_target, _spawn_update_process
 from ....core.update_paths import resolve_update_paths
@@ -81,6 +82,7 @@ from ..helpers import (
     _with_conversation_id,
     derive_codex_features_command,
     format_codex_features,
+    format_public_error,
     parse_codex_features_list,
 )
 from ..state import (
@@ -158,12 +160,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."
@@ -174,15 +176,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
 
@@ -239,15 +241,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
 
@@ -1202,6 +1204,25 @@ class TelegramCommandHandlers(
             message.thread_id,
             apply_pma,
         )
+        try:
+            sink_store = PmaActiveSinkStore(Path(self._hub_root))
+            if enabled:
+                sink_store.set_telegram(
+                    chat_id=message.chat_id,
+                    thread_id=message.thread_id,
+                    topic_key=topic_key(message.chat_id, message.thread_id),
+                )
+            else:
+                sink_store.clear()
+        except Exception:
+            log_event(
+                self._logger,
+                logging.WARNING,
+                "telegram.pma.active_sink.update_failed",
+                chat_id=message.chat_id,
+                thread_id=message.thread_id,
+                enabled=enabled,
+            )
         status = "enabled" if enabled else "disabled"
         if enabled:
             hint = "Use /pma off to exit. Previous repo binding saved."

codex_autorunner/integrations/telegram/handlers/messages.py

@@ -859,7 +859,10 @@ async def handle_media_message(
                 best = photos[0]
                 try:
                     file_info = await handlers._bot.get_file(best.file_id)
-                    data = await handlers._bot.download_file(file_info.file_path)
+                    data = await handlers._bot.download_file(
+                        file_info.file_path,
+                        max_size_bytes=handlers._config.media.max_image_bytes,
+                    )
                     filename = f"photo_{best.file_id}.jpg"
                     files.append((filename, data))
                 except Exception as exc:
@@ -868,7 +871,10 @@ async def handle_media_message(
         elif message.document:
             try:
                 file_info = await handlers._bot.get_file(message.document.file_id)
-                data = await handlers._bot.download_file(file_info.file_path)
+                data = await handlers._bot.download_file(
+                    file_info.file_path,
+                    max_size_bytes=handlers._config.media.max_file_bytes,
+                )
                 filename = (
                     message.document.file_name or f"document_{message.document.file_id}"
                 )

codex_autorunner/integrations/telegram/helpers.py

@@ -9,6 +9,7 @@ from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any, Callable, Iterable, Optional, Sequence
 
+from ...core.redaction import redact_text
 from ...core.state_roots import resolve_global_state_root
 from ...core.utils import (
     RepoNotFoundError,
@@ -2009,12 +2010,17 @@ def _extract_first_bold_span(text: str) -> Optional[str]:
 
 
 def _compose_agent_response(
-    messages: list[str],
+    final_message: Optional[str] = None,
     *,
+    messages: Optional[list[str]] = None,
     errors: Optional[list[str]] = None,
     status: Optional[str] = None,
 ) -> str:
-    cleaned = [msg.strip() for msg in messages if isinstance(msg, str) and msg.strip()]
+    if isinstance(final_message, str) and final_message.strip():
+        return final_message.strip()
+    cleaned = [
+        msg.strip() for msg in (messages or []) if isinstance(msg, str) and msg.strip()
+    ]
     if not cleaned:
         cleaned_errors = [
             err.strip()
@@ -2183,3 +2189,25 @@ def _format_selection_prompt(base: str, page: int, total_pages: int) -> str:
         return base
     trimmed = base.rstrip(".")
     return f"{trimmed} (page {page + 1}/{total_pages})."
+
+
+def format_public_error(detail: str, *, limit: int = 200) -> str:
+    """Format error detail for public Telegram messages with redaction and truncation.
+
+    This helper ensures all user-visible error text sent via Telegram is:
+    - Short and readable
+    - Redacted for known secret patterns
+    - Does not include raw file contents or stack traces
+
+    Args:
+        detail: Error detail string to format.
+        limit: Maximum length of output (default 200).
+
+    Returns:
+        Formatted error string with secrets redacted and length limited.
+    """
+    normalized = " ".join(detail.split())
+    redacted = redact_text(normalized)
+    if len(redacted) > limit:
+        return f"{redacted[: limit - 3]}..."
+    return redacted