codex-autorunner 0.1.0__py3-none-any.whl

codex_autorunner/integrations/telegram/notifications.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+import logging
+import time
+from typing import Any, Optional
+
+from ...core.logging_utils import log_event
+from .constants import (
+    STREAM_PREVIEW_PREFIX,
+    TELEGRAM_MAX_MESSAGE_LENGTH,
+    THINKING_PREVIEW_MAX_LEN,
+    THINKING_PREVIEW_MIN_EDIT_INTERVAL_SECONDS,
+    TOKEN_USAGE_CACHE_LIMIT,
+    TOKEN_USAGE_TURN_CACHE_LIMIT,
+)
+from .helpers import (
+    _coerce_id,
+    _extract_first_bold_span,
+    _extract_turn_thread_id,
+    _truncate_text,
+)
+
+
+class TelegramNotificationHandlers:
+    async def _handle_app_server_notification(self, message: dict[str, Any]) -> None:
+        method = message.get("method")
+        params_raw = message.get("params")
+        params: dict[str, Any] = params_raw if isinstance(params_raw, dict) else {}
+        if method == "car/app_server/oversizedMessageDropped":
+            turn_id = _coerce_id(params.get("turnId"))
+            thread_id = params.get("threadId")
+            turn_key = (
+                self._resolve_turn_key(turn_id, thread_id=thread_id)
+                if turn_id
+                else None
+            )
+            if turn_key is None and len(self._turn_contexts) == 1:
+                turn_key = next(iter(self._turn_contexts.keys()))
+            if turn_key is None:
+                log_event(
+                    self._logger,
+                    logging.WARNING,
+                    "telegram.app_server.oversize.context_missing",
+                    inferred_turn_id=turn_id,
+                    inferred_thread_id=thread_id,
+                )
+                return
+            if turn_key in self._oversize_warnings:
+                return
+            ctx = self._turn_contexts.get(turn_key)
+            if ctx is None:
+                return
+            self._oversize_warnings.add(turn_key)
+            self._touch_cache_timestamp("oversize_warnings", turn_key)
+            byte_limit = params.get("byteLimit")
+            limit_mb = None
+            if isinstance(byte_limit, int) and byte_limit > 0:
+                limit_mb = max(1, byte_limit // (1024 * 1024))
+            limit_text = f"{limit_mb}MB" if limit_mb else "the size limit"
+            aborted = bool(params.get("aborted"))
+            if aborted:
+                warning = (
+                    f"Warning: Codex output exceeded {limit_text} and kept growing, "
+                    "so CAR restarted the app-server to recover. Avoid huge stdout "
+                    "(use head/tail, filters, or redirect to a file)."
+                )
+            else:
+                warning = (
+                    f"Warning: Codex output exceeded {limit_text} and was dropped to "
+                    "keep the session alive. Avoid huge stdout (use head/tail, "
+                    "filters, or redirect to a file)."
+                )
+            if len(warning) > TELEGRAM_MAX_MESSAGE_LENGTH:
+                warning = warning[: TELEGRAM_MAX_MESSAGE_LENGTH - 3].rstrip() + "..."
+            await self._send_message_with_outbox(
+                ctx.chat_id,
+                warning,
+                thread_id=ctx.thread_id,
+                reply_to=ctx.reply_to_message_id,
+                placeholder_id=ctx.placeholder_message_id,
+            )
+            return
+        if method == "thread/tokenUsage/updated":
+            thread_id = params.get("threadId")
+            turn_id = _coerce_id(params.get("turnId"))
+            token_usage = params.get("tokenUsage")
+            if not isinstance(thread_id, str) or not isinstance(token_usage, dict):
+                return
+            self._token_usage_by_thread[thread_id] = token_usage
+            self._token_usage_by_thread.move_to_end(thread_id)
+            while len(self._token_usage_by_thread) > TOKEN_USAGE_CACHE_LIMIT:
+                self._token_usage_by_thread.popitem(last=False)
+            if turn_id:
+                self._token_usage_by_turn[turn_id] = token_usage
+                self._token_usage_by_turn.move_to_end(turn_id)
+                while len(self._token_usage_by_turn) > TOKEN_USAGE_TURN_CACHE_LIMIT:
+                    self._token_usage_by_turn.popitem(last=False)
+            return
+        if method == "item/reasoning/summaryTextDelta":
+            item_id = _coerce_id(params.get("itemId"))
+            turn_id = _coerce_id(params.get("turnId"))
+            thread_id = _extract_turn_thread_id(params)
+            delta = params.get("delta")
+            if not item_id or not turn_id or not isinstance(delta, str):
+                return
+            buffer = self._reasoning_buffers.get(item_id, "")
+            buffer = f"{buffer}{delta}"
+            self._reasoning_buffers[item_id] = buffer
+            self._touch_cache_timestamp("reasoning_buffers", item_id)
+            preview = _extract_first_bold_span(buffer)
+            if preview:
+                await self._update_placeholder_preview(
+                    turn_id, preview, thread_id=thread_id
+                )
+            return
+        if method == "item/reasoning/summaryPartAdded":
+            item_id = _coerce_id(params.get("itemId"))
+            if not item_id:
+                return
+            buffer = self._reasoning_buffers.get(item_id, "")
+            buffer = f"{buffer}\n\n"
+            self._reasoning_buffers[item_id] = buffer
+            self._touch_cache_timestamp("reasoning_buffers", item_id)
+            return
+        if method == "item/completed":
+            item = params.get("item") if isinstance(params, dict) else None
+            if not isinstance(item, dict) or item.get("type") != "reasoning":
+                return
+            item_id = _coerce_id(item.get("id") or params.get("itemId"))
+            if item_id:
+                self._reasoning_buffers.pop(item_id, None)
+            return
+
+    async def _update_placeholder_preview(
+        self, turn_id: str, preview: str, *, thread_id: Optional[str] = None
+    ) -> None:
+        turn_key = self._resolve_turn_key(turn_id, thread_id=thread_id)
+        if turn_key is None:
+            return
+        ctx = self._turn_contexts.get(turn_key)
+        if ctx is None or ctx.placeholder_message_id is None:
+            return
+        normalized = " ".join(preview.split()).strip()
+        if not normalized:
+            return
+        normalized = _truncate_text(normalized, THINKING_PREVIEW_MAX_LEN)
+        if normalized == self._turn_preview_text.get(turn_key):
+            return
+        now = time.monotonic()
+        last_updated = self._turn_preview_updated_at.get(turn_key, 0.0)
+        if (now - last_updated) < THINKING_PREVIEW_MIN_EDIT_INTERVAL_SECONDS:
+            return
+        self._turn_preview_text[turn_key] = normalized
+        self._turn_preview_updated_at[turn_key] = now
+        self._touch_cache_timestamp("turn_preview", turn_key)
+        if STREAM_PREVIEW_PREFIX:
+            message_text = f"{STREAM_PREVIEW_PREFIX} {normalized}"
+        else:
+            message_text = normalized
+        await self._edit_message_text(
+            ctx.chat_id,
+            ctx.placeholder_message_id,
+            message_text,
+        )

codex_autorunner/integrations/telegram/outbox.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Awaitable, Callable, Optional
+
+from ...core.logging_utils import log_event
+from ...core.state import now_iso
+from .constants import (
+    OUTBOX_IMMEDIATE_RETRY_DELAYS,
+    OUTBOX_MAX_ATTEMPTS,
+    OUTBOX_RETRY_INTERVAL_SECONDS,
+)
+from .state import OutboxRecord, TelegramStateStore
+
+SendMessageFn = Callable[..., Awaitable[None]]
+EditMessageFn = Callable[..., Awaitable[bool]]
+DeleteMessageFn = Callable[..., Awaitable[bool]]
+
+
+class TelegramOutboxManager:
+    def __init__(
+        self,
+        store: TelegramStateStore,
+        *,
+        send_message: SendMessageFn,
+        edit_message_text: EditMessageFn,
+        delete_message: DeleteMessageFn,
+        logger: logging.Logger,
+    ) -> None:
+        self._store = store
+        self._send_message = send_message
+        self._edit_message_text = edit_message_text
+        self._delete_message = delete_message
+        self._logger = logger
+        self._inflight: set[str] = set()
+        self._lock: Optional[asyncio.Lock] = None
+
+    def start(self) -> None:
+        self._inflight = set()
+        self._lock = asyncio.Lock()
+
+    async def restore(self) -> None:
+        records = self._store.list_outbox()
+        if not records:
+            return
+        log_event(
+            self._logger,
+            logging.INFO,
+            "telegram.outbox.restore",
+            count=len(records),
+        )
+        await self._flush(records)
+
+    async def run_loop(self) -> None:
+        while True:
+            await asyncio.sleep(OUTBOX_RETRY_INTERVAL_SECONDS)
+            try:
+                records = self._store.list_outbox()
+                if records:
+                    await self._flush(records)
+            except Exception as exc:
+                log_event(
+                    self._logger,
+                    logging.WARNING,
+                    "telegram.outbox.flush_failed",
+                    exc=exc,
+                )
+
+    async def send_message_with_outbox(
+        self,
+        record: OutboxRecord,
+    ) -> bool:
+        self._store.enqueue_outbox(record)
+        log_event(
+            self._logger,
+            logging.INFO,
+            "telegram.outbox.enqueued",
+            record_id=record.record_id,
+            chat_id=record.chat_id,
+            thread_id=record.thread_id,
+        )
+        for delay in OUTBOX_IMMEDIATE_RETRY_DELAYS:
+            if await self._attempt_send(record):
+                return True
+            current = self._store.get_outbox(record.record_id)
+            if current is None:
+                return False
+            if current.attempts >= OUTBOX_MAX_ATTEMPTS:
+                return False
+            await asyncio.sleep(delay)
+        return False
+
+    async def _flush(self, records: list[OutboxRecord]) -> None:
+        for record in records:
+            if record.attempts >= OUTBOX_MAX_ATTEMPTS:
+                log_event(
+                    self._logger,
+                    logging.WARNING,
+                    "telegram.outbox.gave_up",
+                    record_id=record.record_id,
+                    chat_id=record.chat_id,
+                    thread_id=record.thread_id,
+                    attempts=record.attempts,
+                )
+                self._store.delete_outbox(record.record_id)
+                if record.placeholder_message_id is not None:
+                    await self._edit_message_text(
+                        record.chat_id,
+                        record.placeholder_message_id,
+                        "Delivery failed after retries. Please resend.",
+                    )
+                continue
+            await self._attempt_send(record)
+
+    async def _attempt_send(self, record: OutboxRecord) -> bool:
+        current = self._store.get_outbox(record.record_id)
+        if current is None:
+            return False
+        record = current
+        if not await self._mark_inflight(record.record_id):
+            return False
+        try:
+            await self._send_message(
+                record.chat_id,
+                record.text,
+                thread_id=record.thread_id,
+                reply_to=record.reply_to_message_id,
+            )
+        except Exception as exc:
+            record.attempts += 1
+            record.last_error = str(exc)[:500]
+            record.last_attempt_at = now_iso()
+            self._store.update_outbox(record)
+            log_event(
+                self._logger,
+                logging.WARNING,
+                "telegram.outbox.send_failed",
+                record_id=record.record_id,
+                chat_id=record.chat_id,
+                thread_id=record.thread_id,
+                attempts=record.attempts,
+                exc=exc,
+            )
+            return False
+        finally:
+            await self._clear_inflight(record.record_id)
+        self._store.delete_outbox(record.record_id)
+        if record.placeholder_message_id is not None:
+            await self._delete_message(record.chat_id, record.placeholder_message_id)
+        log_event(
+            self._logger,
+            logging.INFO,
+            "telegram.outbox.delivered",
+            record_id=record.record_id,
+            chat_id=record.chat_id,
+            thread_id=record.thread_id,
+        )
+        return True
+
+    async def _mark_inflight(self, record_id: str) -> bool:
+        if self._lock is None:
+            self._lock = asyncio.Lock()
+        async with self._lock:
+            if record_id in self._inflight:
+                return False
+            self._inflight.add(record_id)
+            return True
+
+    async def _clear_inflight(self, record_id: str) -> None:
+        if self._lock is None:
+            return
+        async with self._lock:
+            self._inflight.discard(record_id)

codex_autorunner/integrations/telegram/rendering.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import html
+import re
+
+_CODE_BLOCK_RE = re.compile(r"```(?:[^\n`]*)\n(.*?)```", re.DOTALL)
+_INLINE_CODE_RE = re.compile(r"`([^`\n]+)`")
+_BOLD_RE = re.compile(r"\*\*(.+?)\*\*")
+_MARKDOWN_ESCAPE_RE = re.compile(r"([_*\[\]\(\)`])")
+_MARKDOWN_V2_ESCAPE_RE = re.compile(r"([_*\[\]\(\)~`>#+\-=|{}.!\\])")
+
+
+def _format_telegram_html(text: str) -> str:
+    if not text:
+        return ""
+    parts: list[str] = []
+    last = 0
+    for match in _CODE_BLOCK_RE.finditer(text):
+        parts.append(_format_telegram_inline(text[last : match.start()]))
+        code = match.group(1)
+        parts.append("<pre><code>")
+        parts.append(html.escape(code, quote=False))
+        parts.append("</code></pre>")
+        last = match.end()
+    parts.append(_format_telegram_inline(text[last:]))
+    return "".join(parts)
+
+
+def _format_telegram_inline(text: str) -> str:
+    if not text:
+        return ""
+    placeholders: list[str] = []
+
+    def _replace_code(match: re.Match[str]) -> str:
+        placeholders.append(html.escape(match.group(1), quote=False))
+        return f"\x00CODE{len(placeholders) - 1}\x00"
+
+    text = _INLINE_CODE_RE.sub(_replace_code, text)
+    escaped = html.escape(text, quote=False)
+    escaped = _BOLD_RE.sub(lambda match: f"<b>{match.group(1)}</b>", escaped)
+    for idx, code in enumerate(placeholders):
+        token = f"\x00CODE{idx}\x00"
+        escaped = escaped.replace(token, f"<code>{code}</code>")
+    return escaped
+
+
+def _escape_markdown_text(text: str, *, version: str) -> str:
+    if not text:
+        return ""
+    if version == "MarkdownV2":
+        return _MARKDOWN_V2_ESCAPE_RE.sub(r"\\\1", text)
+    return _MARKDOWN_ESCAPE_RE.sub(r"\\\1", text)
+
+
+def _escape_markdown_code(text: str, *, version: str) -> str:
+    if not text:
+        return ""
+    if version == "MarkdownV2":
+        return text.replace("\\", "\\\\").replace("`", "\\`")
+    return text.replace("`", "\\`")
+
+
+def _format_telegram_markdown(text: str, version: str) -> str:
+    if not text:
+        return ""
+    parts: list[str] = []
+    last = 0
+    for match in _CODE_BLOCK_RE.finditer(text):
+        parts.append(
+            _format_telegram_markdown_inline(text[last : match.start()], version)
+        )
+        code = _escape_markdown_code(match.group(1), version=version)
+        parts.append(f"```\n{code}\n```")
+        last = match.end()
+    parts.append(_format_telegram_markdown_inline(text[last:], version))
+    return "".join(parts)
+
+
+def _format_telegram_markdown_inline(text: str, version: str) -> str:
+    if not text:
+        return ""
+    code_placeholders: list[str] = []
+    bold_placeholders: list[str] = []
+
+    def _replace_code(match: re.Match[str]) -> str:
+        code_placeholders.append(_escape_markdown_code(match.group(1), version=version))
+        return f"\x00CODE{len(code_placeholders) - 1}\x00"
+
+    def _replace_bold(match: re.Match[str]) -> str:
+        bold_placeholders.append(_escape_markdown_text(match.group(1), version=version))
+        return f"\x00BOLD{len(bold_placeholders) - 1}\x00"
+
+    text = _INLINE_CODE_RE.sub(_replace_code, text)
+    text = _BOLD_RE.sub(_replace_bold, text)
+    escaped = _escape_markdown_text(text, version=version)
+    for idx, bold in enumerate(bold_placeholders):
+        token = f"\x00BOLD{idx}\x00"
+        escaped = escaped.replace(token, f"*{bold}*")
+    for idx, code in enumerate(code_placeholders):
+        token = f"\x00CODE{idx}\x00"
+        escaped = escaped.replace(token, f"`{code}`")
+    return escaped

codex_autorunner/integrations/telegram/retry.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+import httpx
+
+
+def _extract_retry_after_seconds(exc: Exception) -> Optional[int]:
+    current: Optional[BaseException] = exc
+    while current is not None:
+        if isinstance(current, httpx.HTTPStatusError):
+            header = current.response.headers.get("Retry-After")
+            if header and header.isdigit():
+                return int(header)
+            try:
+                payload = current.response.json()
+            except Exception:
+                payload = None
+            if isinstance(payload, dict):
+                parameters = payload.get("parameters")
+                if isinstance(parameters, dict):
+                    retry_after = parameters.get("retry_after")
+                    if isinstance(retry_after, int):
+                        return retry_after
+            message = (
+                str(payload.get("description")) if isinstance(payload, dict) else ""
+            )
+            match = re.search(r"retry after (\d+)", message.lower())
+            if match:
+                return int(match.group(1))
+        message = str(current)
+        match = re.search(r"retry after (\d+)", message.lower())
+        if match:
+            return int(match.group(1))
+        current = current.__cause__ or current.__context__
+    return None