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

codex_autorunner/integrations/telegram/api_schemas.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field
+
+__all__ = [
+    "BaseTelegramSchema",
+    "TelegramPhotoSizeSchema",
+    "TelegramDocumentSchema",
+    "TelegramAudioSchema",
+    "TelegramVoiceSchema",
+    "TelegramMessageEntitySchema",
+    "TelegramMessageSchema",
+    "TelegramCallbackQuerySchema",
+    "TelegramUpdateSchema",
+    "parse_update_payload",
+    "parse_message_payload",
+    "parse_callback_query_payload",
+]
+
+
+class BaseTelegramSchema(BaseModel):
+    model_config = {"extra": "ignore", "validate_assignment": False}
+
+
+class TelegramPhotoSizeSchema(BaseTelegramSchema):
+    file_id: str
+    file_unique_id: Optional[str] = None
+    width: int
+    height: int
+    file_size: Optional[int] = None
+
+
+class TelegramDocumentSchema(BaseTelegramSchema):
+    file_id: str
+    file_unique_id: Optional[str] = None
+    file_name: Optional[str] = None
+    mime_type: Optional[str] = None
+    file_size: Optional[int] = None
+
+
+class TelegramAudioSchema(BaseTelegramSchema):
+    file_id: str
+    file_unique_id: Optional[str] = None
+    duration: Optional[int] = None
+    file_name: Optional[str] = None
+    mime_type: Optional[str] = None
+    file_size: Optional[int] = None
+
+
+class TelegramVoiceSchema(BaseTelegramSchema):
+    file_id: str
+    file_unique_id: Optional[str] = None
+    duration: Optional[int] = None
+    mime_type: Optional[str] = None
+    file_size: Optional[int] = None
+
+
+class TelegramMessageEntitySchema(BaseTelegramSchema):
+    type: str
+    offset: int
+    length: int
+
+
+class TelegramMessageSchema(BaseTelegramSchema):
+    message_id: int
+    chat: dict[str, Any] = Field(default_factory=dict)
+    from_user: Optional[dict[str, Any]] = Field(default=None, alias="from")
+    message_thread_id: Optional[int] = None
+    date: Optional[int] = None
+    text: Optional[str] = None
+    caption: Optional[str] = None
+    entities: Optional[list[dict[str, Any]]] = None
+    caption_entities: Optional[list[dict[str, Any]]] = None
+    photo: Optional[list[dict[str, Any]]] = None
+    document: Optional[dict[str, Any]] = None
+    audio: Optional[dict[str, Any]] = None
+    voice: Optional[dict[str, Any]] = None
+    media_group_id: Optional[str] = None
+    is_topic_message: bool = False
+    reply_to_message: Optional[dict[str, Any]] = None
+
+
+class TelegramCallbackQuerySchema(BaseTelegramSchema):
+    id: str
+    from_user: dict[str, Any] = Field(alias="from")
+    data: Optional[str] = None
+    message: Optional[dict[str, Any]] = None
+
+
+class TelegramUpdateSchema(BaseTelegramSchema):
+    update_id: int
+    message: Optional[dict[str, Any]] = None
+    edited_message: Optional[dict[str, Any]] = Field(
+        default=None, alias="edited_message"
+    )
+    callback_query: Optional[dict[str, Any]] = Field(
+        default=None, alias="callback_query"
+    )
+
+
+def parse_update_payload(payload: dict[str, Any]) -> TelegramUpdateSchema:
+    return TelegramUpdateSchema.model_validate(payload)
+
+
+def parse_message_payload(payload: dict[str, Any]) -> Optional[TelegramMessageSchema]:
+    try:
+        return TelegramMessageSchema.model_validate(payload)
+    except Exception:
+        return None
+
+
+def parse_callback_query_payload(
+    payload: dict[str, Any],
+) -> Optional[TelegramCallbackQuerySchema]:
+    try:
+        return TelegramCallbackQuerySchema.model_validate(payload)
+    except Exception:
+        return None

codex_autorunner/integrations/telegram/config.py

@@ -8,6 +8,21 @@ from pathlib import Path
 from typing import Any, Iterable, Optional
 
 from .adapter import TelegramAllowlist
+from .constants import (
+    CACHE_CLEANUP_INTERVAL_SECONDS,
+    COALESCE_BUFFER_TTL_SECONDS,
+    DEFAULT_AGENT_TURN_TIMEOUT_SECONDS,
+    MEDIA_BATCH_BUFFER_TTL_SECONDS,
+    MODEL_PENDING_TTL_SECONDS,
+    OVERSIZE_WARNING_TTL_SECONDS,
+    PENDING_APPROVAL_TTL_SECONDS,
+    PENDING_QUESTION_TTL_SECONDS,
+    PROGRESS_STREAM_TTL_SECONDS,
+    REASONING_BUFFER_TTL_SECONDS,
+    SELECTION_STATE_TTL_SECONDS,
+    TURN_PREVIEW_TTL_SECONDS,
+    UPDATE_ID_PERSIST_INTERVAL_SECONDS,
+)
 from .state import APPROVAL_MODE_YOLO, normalize_approval_mode
 
 DEFAULT_ALLOWED_UPDATES = ("message", "edited_message", "callback_query")
@@ -17,6 +32,8 @@ DEFAULT_SAFE_APPROVAL_POLICY = "on-request"
 DEFAULT_YOLO_APPROVAL_POLICY = "never"
 DEFAULT_YOLO_SANDBOX_POLICY = "dangerFullAccess"
 DEFAULT_PARSE_MODE = "HTML"
+DEFAULT_TRIGGER_MODE = "all"
+TRIGGER_MODE_OPTIONS = {"all", "mentions"}
 DEFAULT_STATE_FILE = ".codex-autorunner/telegram_state.sqlite3"
 DEFAULT_APP_SERVER_COMMAND = ["codex", "app-server"]
 DEFAULT_APP_SERVER_MAX_HANDLES = 20
@@ -107,6 +124,22 @@ class TelegramBotShellConfig:
     max_output_chars: int
 
 
+@dataclass(frozen=True)
+class TelegramBotCacheConfig:
+    cleanup_interval_seconds: float
+    coalesce_buffer_ttl_seconds: float
+    media_batch_buffer_ttl_seconds: float
+    model_pending_ttl_seconds: float
+    pending_approval_ttl_seconds: float
+    pending_question_ttl_seconds: float
+    reasoning_buffer_ttl_seconds: float
+    selection_state_ttl_seconds: float
+    turn_preview_ttl_seconds: float
+    progress_stream_ttl_seconds: float
+    oversize_warning_ttl_seconds: float
+    update_id_persist_interval_seconds: float
+
+
 @dataclass(frozen=True)
 class TelegramBotCommandScope:
     scope: dict[str, Any]
@@ -150,12 +183,15 @@ class TelegramBotConfig:
     allowed_chat_ids: set[int]
     allowed_user_ids: set[int]
     require_topics: bool
+    trigger_mode: str
     defaults: TelegramBotDefaults
     concurrency: TelegramBotConcurrency
     media: TelegramBotMediaConfig
     shell: TelegramBotShellConfig
+    cache: TelegramBotCacheConfig
     progress_stream: TelegramBotProgressStreamConfig
     command_registration: TelegramBotCommandRegistration
+    opencode_command: list[str]
     state_file: Path
     app_server_command_env: str
     app_server_command: list[str]
@@ -164,6 +200,7 @@ class TelegramBotConfig:
     app_server_start_timeout_seconds: float
     app_server_start_max_attempts: Optional[int]
     app_server_turn_timeout_seconds: Optional[float]
+    agent_turn_timeout_seconds: dict[str, Optional[float]]
     poll_timeout_seconds: int
     poll_request_timeout_seconds: Optional[float]
     poll_allowed_updates: list[str]
@@ -171,6 +208,7 @@ class TelegramBotConfig:
     metrics_mode: str
     coalesce_window_seconds: float
     agent_binaries: dict[str, str]
+    ticket_flow_auto_resume: bool
 
     @classmethod
     def from_raw(
@@ -183,6 +221,16 @@ class TelegramBotConfig:
     ) -> "TelegramBotConfig":
         env = env or dict(os.environ)
         cfg: dict[str, Any] = raw if isinstance(raw, dict) else {}
+
+        def _positive_float(value: Any, default: float) -> float:
+            try:
+                parsed = float(value)
+            except (TypeError, ValueError):
+                return default
+            if parsed <= 0:
+                return default
+            return parsed
+
         enabled = bool(cfg.get("enabled", False))
         mode = str(cfg.get("mode", "polling"))
         bot_token_env = str(cfg.get("bot_token_env", "CAR_TELEGRAM_BOT_TOKEN"))
@@ -204,6 +252,10 @@ class TelegramBotConfig:
 
         require_topics = bool(cfg.get("require_topics", False))
 
+        trigger_mode = (
+            str(cfg.get("trigger_mode", DEFAULT_TRIGGER_MODE)).strip().lower()
+        )
+
         defaults_raw_value = cfg.get("defaults")
         defaults_raw: dict[str, Any] = (
             defaults_raw_value if isinstance(defaults_raw_value, dict) else {}
@@ -313,6 +365,81 @@ class TelegramBotConfig:
             timeout_ms=shell_timeout_ms,
             max_output_chars=shell_max_output_chars,
         )
+        cache_raw_value = cfg.get("cache")
+        cache_raw: dict[str, Any] = (
+            cache_raw_value if isinstance(cache_raw_value, dict) else {}
+        )
+        cache = TelegramBotCacheConfig(
+            cleanup_interval_seconds=_positive_float(
+                cache_raw.get(
+                    "cleanup_interval_seconds", CACHE_CLEANUP_INTERVAL_SECONDS
+                ),
+                CACHE_CLEANUP_INTERVAL_SECONDS,
+            ),
+            coalesce_buffer_ttl_seconds=_positive_float(
+                cache_raw.get(
+                    "coalesce_buffer_ttl_seconds", COALESCE_BUFFER_TTL_SECONDS
+                ),
+                COALESCE_BUFFER_TTL_SECONDS,
+            ),
+            media_batch_buffer_ttl_seconds=_positive_float(
+                cache_raw.get(
+                    "media_batch_buffer_ttl_seconds", MEDIA_BATCH_BUFFER_TTL_SECONDS
+                ),
+                MEDIA_BATCH_BUFFER_TTL_SECONDS,
+            ),
+            model_pending_ttl_seconds=_positive_float(
+                cache_raw.get("model_pending_ttl_seconds", MODEL_PENDING_TTL_SECONDS),
+                MODEL_PENDING_TTL_SECONDS,
+            ),
+            pending_approval_ttl_seconds=_positive_float(
+                cache_raw.get(
+                    "pending_approval_ttl_seconds", PENDING_APPROVAL_TTL_SECONDS
+                ),
+                PENDING_APPROVAL_TTL_SECONDS,
+            ),
+            pending_question_ttl_seconds=_positive_float(
+                cache_raw.get(
+                    "pending_question_ttl_seconds", PENDING_QUESTION_TTL_SECONDS
+                ),
+                PENDING_QUESTION_TTL_SECONDS,
+            ),
+            reasoning_buffer_ttl_seconds=_positive_float(
+                cache_raw.get(
+                    "reasoning_buffer_ttl_seconds", REASONING_BUFFER_TTL_SECONDS
+                ),
+                REASONING_BUFFER_TTL_SECONDS,
+            ),
+            selection_state_ttl_seconds=_positive_float(
+                cache_raw.get(
+                    "selection_state_ttl_seconds", SELECTION_STATE_TTL_SECONDS
+                ),
+                SELECTION_STATE_TTL_SECONDS,
+            ),
+            turn_preview_ttl_seconds=_positive_float(
+                cache_raw.get("turn_preview_ttl_seconds", TURN_PREVIEW_TTL_SECONDS),
+                TURN_PREVIEW_TTL_SECONDS,
+            ),
+            progress_stream_ttl_seconds=_positive_float(
+                cache_raw.get(
+                    "progress_stream_ttl_seconds", PROGRESS_STREAM_TTL_SECONDS
+                ),
+                PROGRESS_STREAM_TTL_SECONDS,
+            ),
+            oversize_warning_ttl_seconds=_positive_float(
+                cache_raw.get(
+                    "oversize_warning_ttl_seconds", OVERSIZE_WARNING_TTL_SECONDS
+                ),
+                OVERSIZE_WARNING_TTL_SECONDS,
+            ),
+            update_id_persist_interval_seconds=_positive_float(
+                cache_raw.get(
+                    "update_id_persist_interval_seconds",
+                    UPDATE_ID_PERSIST_INTERVAL_SECONDS,
+                ),
+                UPDATE_ID_PERSIST_INTERVAL_SECONDS,
+            ),
+        )
 
         progress_raw_value = cfg.get("progress_stream")
         progress_raw: dict[str, Any] = (
@@ -374,6 +501,11 @@ class TelegramBotConfig:
         if coalesce_window_seconds <= 0:
             coalesce_window_seconds = DEFAULT_COALESCE_WINDOW_SECONDS
 
+        ticket_flow_raw = (
+            cfg.get("ticket_flow") if isinstance(cfg.get("ticket_flow"), dict) else {}
+        )
+        ticket_flow_auto_resume = bool(ticket_flow_raw.get("auto_resume", False))
+
         agent_binaries = dict(agent_binaries or {})
         command_reg_raw_value = cfg.get("command_registration")
         command_reg_raw: dict[str, Any] = (
@@ -385,9 +517,21 @@ class TelegramBotConfig:
             enabled=command_reg_enabled, scopes=scopes
         )
 
+        opencode_command = []
+        opencode_env_command = env.get("CAR_OPENCODE_COMMAND")
+        if opencode_env_command:
+            opencode_command = _parse_command(opencode_env_command)
+        if not opencode_command:
+            opencode_command = _parse_command(cfg.get("opencode_command"))
+
         state_file = Path(cfg.get("state_file", DEFAULT_STATE_FILE))
         if not state_file.is_absolute():
             state_file = (root / state_file).resolve()
+        if state_file.suffix == ".json":
+            raise TelegramBotConfigError(
+                "telegram_bot.state_file must point to a SQLite database "
+                "(.sqlite3). Update your config to .codex-autorunner/telegram_state.sqlite3"
+            )
 
         app_server_command_env = str(
             cfg.get("app_server_command_env", "CAR_TELEGRAM_APP_SERVER_COMMAND")
@@ -440,6 +584,30 @@ class TelegramBotConfig:
             if app_server_turn_timeout_seconds <= 0:
                 app_server_turn_timeout_seconds = None
 
+        agent_timeouts_raw = cfg.get("agent_timeouts")
+        has_explicit_codex_timeout = False
+        agent_timeouts: dict[str, Optional[float]] = dict(
+            DEFAULT_AGENT_TURN_TIMEOUT_SECONDS
+        )
+        if isinstance(agent_timeouts_raw, dict):
+            for key, value in agent_timeouts_raw.items():
+                if str(key) == "codex":
+                    has_explicit_codex_timeout = True
+                if value is None:
+                    agent_timeouts[str(key)] = None
+                    continue
+                try:
+                    timeout_value = float(value)
+                except (TypeError, ValueError):
+                    continue
+                if timeout_value <= 0:
+                    agent_timeouts[str(key)] = None
+                else:
+                    agent_timeouts[str(key)] = timeout_value
+
+        if not has_explicit_codex_timeout:
+            agent_timeouts["codex"] = app_server_turn_timeout_seconds
+
         polling_raw_value = cfg.get("polling")
         polling_raw: dict[str, Any] = (
             polling_raw_value if isinstance(polling_raw_value, dict) else {}
@@ -472,12 +640,15 @@ class TelegramBotConfig:
             allowed_chat_ids=allowed_chat_ids,
             allowed_user_ids=allowed_user_ids,
             require_topics=require_topics,
+            trigger_mode=trigger_mode,
             defaults=defaults,
             concurrency=concurrency,
             media=media,
             shell=shell,
+            cache=cache,
             progress_stream=progress_stream,
             command_registration=command_registration,
+            opencode_command=opencode_command,
             state_file=state_file,
             app_server_command_env=app_server_command_env,
             app_server_command=app_server_command,
@@ -486,6 +657,7 @@ class TelegramBotConfig:
             app_server_start_timeout_seconds=app_server_start_timeout_seconds,
             app_server_start_max_attempts=app_server_start_max_attempts,
             app_server_turn_timeout_seconds=app_server_turn_timeout_seconds,
+            agent_turn_timeout_seconds=agent_timeouts,
             poll_timeout_seconds=poll_timeout_seconds,
             poll_request_timeout_seconds=poll_request_timeout_seconds,
             poll_allowed_updates=poll_allowed_updates,
@@ -493,6 +665,7 @@ class TelegramBotConfig:
             metrics_mode=metrics_mode,
             coalesce_window_seconds=coalesce_window_seconds,
             agent_binaries=agent_binaries,
+            ticket_flow_auto_resume=ticket_flow_auto_resume,
         )
 
     def validate(self) -> None:
@@ -516,6 +689,8 @@ class TelegramBotConfig:
             issues.append(
                 "poll_request_timeout_seconds must be greater than poll_timeout_seconds"
             )
+        if self.trigger_mode not in TRIGGER_MODE_OPTIONS:
+            issues.append(f"trigger_mode must be one of {sorted(TRIGGER_MODE_OPTIONS)}")
         if issues:
             raise TelegramBotConfigError("; ".join(issues))
 

codex_autorunner/integrations/telegram/constants.py

@@ -18,7 +18,12 @@ RESUME_REFRESH_LIMIT = 10
 TOKEN_USAGE_CACHE_LIMIT = 256
 TOKEN_USAGE_TURN_CACHE_LIMIT = 512
 DEFAULT_INTERRUPT_TIMEOUT_SECONDS = 30.0
-OPENCODE_TURN_TIMEOUT_SECONDS = 300.0
+
+
+DEFAULT_AGENT_TURN_TIMEOUT_SECONDS = {
+    "codex": 28800.0,
+    "opencode": 28800.0,
+}
 DEFAULT_WORKSPACE_STATE_ROOT = "~/.codex-autorunner/workspaces"
 DEFAULT_AGENT = "codex"
 APP_SERVER_START_BACKOFF_INITIAL_SECONDS = 1.0
@@ -100,6 +105,16 @@ TURN_PROGRESS_MAX_LEN = 160
 TURN_PROGRESS_MIN_EDIT_INTERVAL_SECONDS = 1.0
 TURN_PROGRESS_TTL_SECONDS = 900.0
 PROGRESS_HEARTBEAT_INTERVAL_SECONDS = 5.0
+COMPACT_MAX_ACTIONS = 10
+COMPACT_MAX_TEXT_LENGTH = 80
+STATUS_ICONS = {
+    "done": "✓",
+    "fail": "✗",
+    "warn": "⚠",
+    "running": "▸",
+    "update": "↻",
+    "thinking": "🧠",
+}
 COMMAND_DISABLED_TEMPLATE = "'/{name}' is disabled while a task is in progress."
 MAX_MENTION_BYTES = 200_000
 VALID_REASONING_EFFORTS = {"none", "minimal", "low", "medium", "high", "xhigh"}

codex_autorunner/integrations/telegram/dispatch.py

@@ -72,14 +72,26 @@ def _log_denied(handlers: Any, update: TelegramUpdate) -> None:
     chat_id = None
     user_id = None
     thread_id = None
+    message_id = None
+    update_id = None
+    conversation_id = None
     if update.message:
         chat_id = update.message.chat_id
         user_id = update.message.from_user_id
         thread_id = update.message.thread_id
+        message_id = update.message.message_id
+        update_id = update.message.update_id
     elif update.callback:
         chat_id = update.callback.chat_id
         user_id = update.callback.from_user_id
         thread_id = update.callback.thread_id
+        message_id = update.callback.message_id
+        update_id = update.callback.update_id
+    if chat_id is not None:
+        try:
+            conversation_id = topic_key(chat_id, thread_id)
+        except Exception:
+            conversation_id = None
     log_event(
         handlers._logger,
         logging.INFO,
@@ -87,6 +99,9 @@ def _log_denied(handlers: Any, update: TelegramUpdate) -> None:
         chat_id=chat_id,
         user_id=user_id,
         thread_id=thread_id,
+        message_id=message_id,
+        update_id=update_id,
+        conversation_id=conversation_id,
     )
 
 
@@ -172,6 +187,7 @@ async def dispatch_update(handlers: Any, update: TelegramUpdate) -> None:
             has_message=bool(update.message),
             has_callback=bool(update.callback),
             update_received_at=now_iso(),
+            conversation_id=conversation_id,
         )
         if (
             update.update_id is not None
@@ -188,6 +204,7 @@ async def dispatch_update(handlers: Any, update: TelegramUpdate) -> None:
                 chat_id=context.chat_id,
                 thread_id=context.thread_id,
                 message_id=context.message_id,
+                conversation_id=conversation_id,
             )
             return
         if not allowlist_allows(update, handlers._allowlist):

codex_autorunner/integrations/telegram/doctor.py

@@ -0,0 +1,47 @@
+"""Telegram integration doctor checks."""
+
+from typing import Any, Dict, Union
+
+from ...core.config import HubConfig, RepoConfig
+from ...core.engine import DoctorCheck
+from ...core.optional_dependencies import missing_optional_dependencies
+
+
+def telegram_doctor_checks(
+    config: Union[HubConfig, RepoConfig, Dict[str, Any]],
+) -> list[DoctorCheck]:
+    """Run Telegram-specific doctor checks.
+
+    Returns a list of DoctorCheck objects for Telegram integration.
+    Works with HubConfig, RepoConfig, or raw dict.
+    """
+    checks: list[DoctorCheck] = []
+    telegram_cfg = None
+
+    if isinstance(config, dict):
+        telegram_cfg = config.get("telegram_bot")
+    elif isinstance(config.raw, dict):
+        telegram_cfg = config.raw.get("telegram_bot")
+
+    if isinstance(telegram_cfg, dict) and telegram_cfg.get("enabled") is True:
+        missing_telegram = missing_optional_dependencies((("httpx", "httpx"),))
+        if missing_telegram:
+            deps_list = ", ".join(missing_telegram)
+            checks.append(
+                DoctorCheck(
+                    check_id="telegram.dependencies",
+                    status="error",
+                    message=f"Telegram is enabled but missing optional deps: {deps_list}",
+                    fix="Install with `pip install codex-autorunner[telegram]`.",
+                )
+            )
+        else:
+            checks.append(
+                DoctorCheck(
+                    check_id="telegram.dependencies",
+                    status="ok",
+                    message="Telegram dependencies are installed.",
+                )
+            )
+
+    return checks

codex_autorunner/integrations/telegram/handlers/callbacks.py

@@ -11,7 +11,6 @@ from ..adapter import (
     EffortCallback,
     ModelCallback,
     PageCallback,
-    PrFlowStartCallback,
     QuestionCancelCallback,
     QuestionCustomCallback,
     QuestionDoneCallback,
@@ -80,9 +79,6 @@ async def handle_callback(handlers: Any, callback: TelegramCallbackQuery) -> Non
     elif isinstance(parsed, ReviewCommitCallback):
         if key:
             await handlers._handle_review_commit_callback(key, callback, parsed)
-    elif isinstance(parsed, PrFlowStartCallback):
-        if key:
-            await handlers._handle_pr_flow_start_callback(key, callback, parsed)
     elif isinstance(parsed, CancelCallback):
         if key:
             if parsed.kind == "interrupt":

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

@@ -7,6 +7,7 @@ from ..commands_spec import CommandSpec, build_command_specs
 from .approvals import ApprovalsCommands
 from .execution import ExecutionCommands
 from .files import FilesCommands
+from .flows import FlowCommands
 from .formatting import FormattingHelpers
 from .github import GitHubCommands
 from .shared import SharedHelpers
@@ -19,6 +20,7 @@ __all__ = [
     "GitHubCommands",
     "FilesCommands",
     "VoiceCommands",
+    "FlowCommands",
     "ExecutionCommands",
     "ApprovalsCommands",
     "FormattingHelpers",