"""Route a client-created Telegram DM topic's thread-less opener into that topic (#136567). Telegram for Android (13.0.x) delivers the opening message of a topic created from the "All messages" view with no ``message_thread_id``. The ``Message`` carrying ``forum_topic_created`` is then the only update that names the new topic (``ForumTopicCreated`` itself has only name/icon fields). Recording authorized, non-bot private-chat creations lets the thread-less messages that follow adopt the new topic instead of arriving lobby-shaped, where gateway topic recovery would pin them to the most recently bound topic. Adoption follows time and per-chat order, never message-id adjacency: private-chat message ids come from one sequence shared by every private chat of the bot account (bot replies included), so a send elsewhere between the creation and the opener breaks ``creation + 1``. Per-chat FIFO update processing guarantees nothing from this chat lands in between. """ import logging import time from typing import Any, Optional logger = logging.getLogger("plugins.platforms.telegram.adapter") class TelegramTopicRoutingMixin: """Topic-creation bookkeeping for ``TelegramAdapter`` (relies on its ``_chat_type_str``/``_chat_id_str``).""" # A thread-less message from the creator adopts the new topic while it was SENT within this many # seconds of the creation or of the previous adopted message (the client sends the opener # ~0.2-1 s after the creation; a split long text or an album follows within the same second). # Measured on Telegram's ``Message.date`` stamps, never on handler time: per-chat FIFO holds a # follow-up behind the previous handler (a photo download, STT), and it must not age out there. _NEW_TOPIC_FOLLOW_SECONDS = 5.0 _NEW_TOPIC_OPENER_MAX_PENDING = 256 # Memory bound only (local clock), far above any handler backlog; adoption never reads it. _NEW_TOPIC_RECORD_TTL_SECONDS = 600.0 @staticmethod def _creator_key(message) -> str: return str(getattr(getattr(message, "from_user", None), "id", "")) @staticmethod def _sent_at(message) -> Optional[float]: """Telegram's send stamp (whole seconds); an edit keeps its message's original ``date``.""" date = getattr(message, "date", None) return date.timestamp() if hasattr(date, "timestamp") else None async def _handle_forum_topic_created(self, update: Any, context: Any) -> None: """Record an authorized, non-bot private-chat topic creation (#136567). Routing signal only, never an agent turn. The user-chosen name is NOT cached in ``_dm_topics``: entries there mark operator-declared topics, which session-title auto-rename skips. """ message = getattr(update, "effective_message", None) if message is None or getattr(message, "forum_topic_created", None) is None: return # Private chats only: in a forum group a thread-less message is General, never an opener. if self._chat_type_str(getattr(message, "chat", None)) != "private": return thread_id = getattr(message, "message_thread_id", None) sender = getattr(message, "from_user", None) sent_at = self._sent_at(message) if thread_id is None or sent_at is None or sender is None or getattr(sender, "is_bot", False) is True: return if not self._is_user_authorized_from_message(message): return pending = self.__dict__.setdefault("_pending_created_topics", {}) now = time.monotonic() for key in [k for k, rec in pending.items() if now - rec[2] > self._NEW_TOPIC_RECORD_TTL_SECONDS]: del pending[key] while len(pending) >= self._NEW_TOPIC_OPENER_MAX_PENDING: del pending[min(pending, key=lambda k: pending[k][2])] chat_id = self._chat_id_str(message) pending[(chat_id, self._creator_key(message))] = (str(thread_id), sent_at, now) logger.debug("[%s] Recorded new Telegram topic %s (chat=%s)", self.name, thread_id, chat_id) def _adopt_created_topic_thread(self, message: Any, chat_type: str, thread_id: Optional[str]) -> Optional[str]: """Thread id of the topic this sender just created, for its thread-less follow-up messages. A threaded message (the topic now routes normally) or a send gap longer than ``_NEW_TOPIC_FOLLOW_SECONDS`` ends the follow; each adoption extends it, so every chunk of a split opener lands in the same topic. """ # .get: adapters built without __init__ (object.__new__ in tests) have no store yet. pending = self.__dict__.get("_pending_created_topics") if chat_type != "dm" or not pending: return thread_id key = (self._chat_id_str(message), self._creator_key(message)) record = pending.get(key) sent_at = self._sent_at(message) # An edit of a message sent before the creation stays where that message lived and leaves # the record for the real opener. if record is None or sent_at is None or sent_at < record[1]: return thread_id del pending[key] if thread_id is not None or getattr(message, "message_thread_id", None) is not None: return thread_id created_thread_id, last_sent_at, _recorded = record if sent_at - last_sent_at > self._NEW_TOPIC_FOLLOW_SECONDS: return thread_id pending[key] = (created_thread_id, sent_at, time.monotonic()) logger.info("[%s] Thread-less message %s adopted by new Telegram topic %s (chat=%s)", self.name, getattr(message, "message_id", "?"), created_thread_id, key[0]) return created_thread_id