The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""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