TeLLMgramBot 3.13.7__tar.gz → 3.14.0__tar.gz

{tellmgrambot-3.13.7 → tellmgrambot-3.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TeLLMgramBot
-Version: 3.13.7
+Version: 3.14.0
 Summary: LLM-powered Telegram bot (OpenAI + Anthropic)
 Home-page: https://github.com/Digital-Heresy/TeLLMgramBot
 Author: Digital Heresy
@@ -135,7 +135,7 @@ The bot responds in groups when you:
 - Mention the bot by nickname or initials (configured via `config.yaml`)
 - Reply directly to one of the bot's messages
 
-If a message explicitly @mentions another account, the bot defers with "Looks like that's for @OtherBot!" instead.
+When multiple bots are @mentioned in the same message, the bot coexists: if you mention the bot's nickname or initials, or reply to its message, the bot always engages (you may be intentionally addressing both bots). If the only trigger is a reply to the bot's message AND the message exclusively addresses a different bot via @mention (no mention of this bot), the bot yields silently - this supports threaded context without redundant responses.
 
 ### Private Chat Behavior
 In private chats, the bot responds to all your messages. If you reply to an earlier message in the conversation that is not already in the bot's context window, that message is automatically surfaced as inline context so the bot can understand the full conversation thread.

{tellmgrambot-3.13.7 → tellmgrambot-3.14.0}/README.md

@@ -103,7 +103,7 @@ The bot responds in groups when you:
 - Mention the bot by nickname or initials (configured via `config.yaml`)
 - Reply directly to one of the bot's messages
 
-If a message explicitly @mentions another account, the bot defers with "Looks like that's for @OtherBot!" instead.
+When multiple bots are @mentioned in the same message, the bot coexists: if you mention the bot's nickname or initials, or reply to its message, the bot always engages (you may be intentionally addressing both bots). If the only trigger is a reply to the bot's message AND the message exclusively addresses a different bot via @mention (no mention of this bot), the bot yields silently - this supports threaded context without redundant responses.
 
 ### Private Chat Behavior
 In private chats, the bot responds to all your messages. If you reply to an earlier message in the conversation that is not already in the bot's context window, that message is automatically surfaced as inline context so the bot can understand the full conversation thread.

{tellmgrambot-3.13.7 → tellmgrambot-3.14.0}/TeLLMgramBot/TeLLMgramBot.py

@@ -27,6 +27,7 @@ from .database import (
     get_shared_group_chat_ids,
     message_id_exists,
     update_message_tg_id,
+    prune_bot_messages,
     search_messages,
     upsert_chat,
     upsert_user,
@@ -67,9 +68,9 @@ _SEARCH_TOOL = {
         "Search the full message history across the user's private chat and shared group chats. "
         "Results include both raw messages and archived summaries of older content. "
         "Use whenever the user asks who said something, what someone said, or what was discussed. "
-        "Always search before claiming a person has no message history -- do not assume from context alone. "
-        "Run the search immediately when it would help answer the question -- do not ask the user for permission to search. "
-        "All filters are optional -- omit them to retrieve recent messages broadly. "
+        "Always search before claiming a person has no message history - do not assume from context alone. "
+        "Run the search immediately when it would help answer the question - do not ask the user for permission to search. "
+        "All filters are optional - omit them to retrieve recent messages broadly. "
         "Results are ordered most-recent-first by default; use ascending=true for oldest-first."
     ),
     "parameters": {
@@ -180,11 +181,13 @@ class TelegramBot:
 
     async def tele_tools_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
         """
-        List all registered tools available to this bot instance (admin-only, private chat only).
+        List tools available to this bot instance (admin-only, private/group/supergroup).
 
         Shows name and description for every tool the bot exposes, including the built-in
         search_messages tool and any webhook tools defined in bot config. Restricted to
-        bot_owner in a private chat; any other caller receives a generic denial.
+        usernames in bot_owner list. Works in private, group, and supergroup chats;
+        channels always receive an admin-only denial. In group/supergroup chats, only
+        tools with allow_groups=True are shown.
 
         Args:
             update: Telegram Update object containing the /tools message.
@@ -192,15 +195,15 @@ class TelegramBot:
         """
         uname = update.message.from_user.username
         chat_type = update.message.chat.type
-        if uname not in self.telegram['owners'] or chat_type != 'private':
+        if uname not in self.telegram['owners'] or chat_type not in ('private', 'group', 'supergroup'):
             await update.message.reply_text(_MSG_ADMIN_ONLY)
             return
+
         def _first_sentence(text: str) -> str:
             return text.split('. ')[0].rstrip('.!?') + '.'
 
         lines = ["Registered tools:"]
-        lines.append(f"- search_messages - {_first_sentence(_SEARCH_TOOL['description'])}")
-        for schema in self.webhook_schemas:
+        for schema in self._build_tool_list(chat_type, uname):
             lines.append(f"- {schema['name']} - {_first_sentence(schema['description'])}")
         await update.message.reply_text('\n'.join(lines))
 
@@ -555,7 +558,12 @@ class TelegramBot:
         with speaker name and timestamp if the replied-to message is not in context, or an
         empty string if already present.
 
-        Uses a two-tier check to avoid redundant prepends:
+        Deduplication applies only to our own bot's replies (to avoid repeating content
+        already visible in context). For all other senders - foreign bots and human users -
+        the prefix is always prepended so the LLM has an explicit anchor to the referenced
+        message regardless of whether it appears elsewhere in the loaded context.
+
+        Own-bot dedup uses two tiers:
         1. Memory - reply_to_message.message_id in conv._loaded_message_ids (O(1)).
            In-session bot replies are added here immediately after each send.
         2. DB fallback - query for tg_message_id in the messages table.
@@ -563,6 +571,8 @@ class TelegramBot:
            stored for assistant messages after each send.
 
         Fires in all chat types (group and private) when reply_to_message exists and has text.
+        from_user is not required — messages from channel-linked bots or anonymous admins
+        may omit it; sender_chat.title or 'unknown' is used as the name fallback.
         Correctly re-surfaces bot messages that are no longer in context (e.g. post-/forget).
 
         Args:
@@ -574,61 +584,98 @@ class TelegramBot:
             or empty string if the replied-to message is already in context.
         """
         reply = msg.reply_to_message
-        if not reply or not reply.text or not reply.from_user:
+        if not reply or not reply.text:
             return ''
 
         r_tg_id = reply.message_id
-
-        # Tier 1: memory check
         conv = self.conversations.get(msg.chat.id)
-        if conv and r_tg_id in conv._loaded_message_ids:
-            return ''
-
-        # Tier 2: DB fallback
-        if await message_id_exists(msg.chat.id, r_tg_id):
-            return ''
+        is_our_reply = (
+            reply.from_user is not None and
+            reply.from_user.id == self.telegram['bot_id']
+        )
 
-        # Not in context - build the annotated prefix and mark the ID as seen so
-        # subsequent replies to the same foreign message skip the prepend.
-        if conv:
+        if is_our_reply:
+            # Dedup only our own bot's replies to avoid repeating content already visible.
+            # Tier 1: in-session check via loaded message ID set
+            if conv and r_tg_id in conv._loaded_message_ids:
+                return ''
+            # Tier 2: DB fallback for cross-session bot replies
+            if await message_id_exists(msg.chat.id, r_tg_id):
+                return ''
+
+        # For own-bot replies, mark as seen to skip dedup on subsequent replies
+        # to the same message within the session. Foreign/human IDs are tracked
+        # by tele_handle_message after the response is sent.
+        if is_our_reply and conv:
             conv._loaded_message_ids.add(r_tg_id)
-        sender = reply.from_user
-        name_parts = [p for p in [sender.first_name, sender.last_name] if p]
-        name = ' '.join(name_parts) if name_parts else (sender.username or 'unknown')
+        if reply.from_user:
+            sender = reply.from_user
+            name_parts = [p for p in [sender.first_name, sender.last_name] if p]
+            name = ' '.join(name_parts) if name_parts else (sender.username or 'unknown')
+        elif reply.sender_chat:
+            name = reply.sender_chat.title or reply.sender_chat.username or 'unknown'
+        else:
+            name = 'unknown'
         dt = format_dt(reply.date)
         return f"[Replying to {name}, {dt}]: {reply.text}\n"
 
-    def _foreign_bot_mention(self, msg: Message) -> str | None:
+    async def _store_bot_message(self, msg: Message) -> None:
         """
-        Return the @username of the first explicitly @mentioned account that is not us, or None.
+        Persist a foreign bot's message to the DB for ambient group context.
 
-        Inspects MessageEntity.MENTION entities in msg.entities. Used to detect when a
-        reply-to-bot message explicitly @mentions another account (bot or user), so we can
-        defer politely instead of responding as if the message was meant for us. Note that
-        Telegram does not distinguish bots from regular users in MENTION entities; this
-        method detects any foreign @mention. Deflections skip the read receipt -- the 👀
-        reaction is only sent when we are going to generate a full response.
+        Registers the bot as a user (is_bot=True) and its chat, inserts the message
+        with role='user', then prunes the per-chat bot message cap. Skips if the
+        message has no text or is already stored (tg_message_id dedup).
 
-        Uses msg.parse_entity() for correct UTF-16 offset handling (Telegram offsets are
-        UTF-16 code units, which can differ from Python str indices for non-BMP characters
-        such as emoji appearing before the @mention).
+        Args:
+            msg: The Telegram Message from a foreign bot (msg.from_user.is_bot must be True).
+        """
+        if not msg.text:
+            return
+        bot_user = msg.from_user
+        await upsert_user(bot_user.id, bot_user.username, bot_user.first_name, bot_user.last_name, is_bot=True)
+        await upsert_chat(msg.chat.id, msg.chat.type, msg.chat.title or msg.chat.username or '')
+        existing = await message_id_exists(msg.chat.id, msg.message_id)
+        if not existing:
+            await insert_message(
+                chat_id=msg.chat.id,
+                user_id=bot_user.id,
+                role='user',
+                content=msg.text,
+                is_private=False,
+                tg_message_id=msg.message_id,
+            )
+            await prune_bot_messages(msg.chat.id)
+
+    def _exclusive_foreign_mention(self, msg: Message) -> str | None:
+        """
+        Return the first foreign @mention if all @mention entities are exclusively foreign.
+
+        Used in the reply-to-bot path: when the user threads Kowi's message but addresses
+        a different account via @mention, return that account's username so the caller can
+        detect a redirect. Returns None when we are also @mentioned (co-mention),
+        when there are no @mention entities, or when msg.entities is absent.
 
         Args:
             msg: The incoming Telegram Message object.
 
         Returns:
-            The @username string (with leading @) of the first foreign mention, or None if
-            the message contains no @mentions of other accounts.
+            The first foreign @username string (with leading @) if all @mentions are
+            foreign, or None if we are co-mentioned or no @mention entities exist.
         """
         if not msg.entities:
             return None
         our_username = self.telegram['username'].lower()
+        first_foreign = None
         for entity in msg.entities:
             if entity.type == MessageEntity.MENTION:
                 mentioned = msg.parse_entity(entity)
-                if mentioned.lstrip('@').lower() != our_username:
-                    return mentioned
-        return None
+                if mentioned.lstrip('@').lower() == our_username:
+                    return None
+                if first_foreign is None:
+                    first_foreign = mentioned
+        return first_foreign
+
 
     async def _send_read_receipt(self, msg: Message, context: ContextTypes.DEFAULT_TYPE):
         """
@@ -662,6 +709,11 @@ class TelegramBot:
         - User mentions the bot by initials (set via config)
         - User directly replies to one of the bot's messages (Telegram reply-to feature)
 
+        Path A - foreign bot message (standalone update): Stores the message for ambient context and returns without LLM response.
+        Path B - human reply to foreign bot: Stores the replied-to message before normal routing (fires regardless of whether we are triggered).
+        Nickname/initials triggers always engage even when foreign bots are also @mentioned.
+        Reply-to-bot trigger yields silently when the message is exclusively addressed to a foreign @account.
+
         In private chats, the bot responds to all messages (Telegram does not deliver bot-to-bot DMs).
 
         When the triggering message is itself a reply to a non-bot message not already in context,
@@ -680,10 +732,23 @@ class TelegramBot:
             return
         (msg, chat, user) = validated
 
-        # Ignore messages from other bots in group chats - no response or storage needed.
+        # Path A: foreign bot message delivered directly as a standalone update (rare).
+        # Store for ambient context and return - no LLM response triggered by bot messages.
         if user.is_bot and user.id != self.telegram['bot_id'] and chat.type in ('group', 'supergroup'):
+            await self._store_bot_message(msg)
             return
 
+        # Path B: capture a foreign bot's message when a human replies to it.
+        # Fires regardless of whether the reply also triggers us.
+        if (
+            chat.type in ('group', 'supergroup') and
+            msg.reply_to_message is not None and
+            msg.reply_to_message.from_user is not None and
+            msg.reply_to_message.from_user.is_bot and
+            msg.reply_to_message.from_user.id != self.telegram['bot_id']
+        ):
+            await self._store_bot_message(msg.reply_to_message)
+
         # If it's a group text, only reply if the bot is named
         # The real magic of how the bot behaves is in tele_handle_response()
         response = _MSG_PROCESS_ERROR
@@ -697,7 +762,7 @@ class TelegramBot:
             )
             if exact_word_match(self.telegram['username'], msg.text):
                 # Explicit @username mention: strongest signal - respond even if another
-                # account is also @mentioned (both bots may be intentionally addressed).
+                # bot is also @mentioned (both may be intentionally addressed).
                 pattern = r'@?\b' + re.escape(self.telegram['username']) + r'\b'
                 new_text = re.sub(pattern, '', msg.text).strip()
                 reply_context = await self._build_reply_context(msg)
@@ -705,14 +770,17 @@ class TelegramBot:
                 response, assistant_db_id = await self.tele_handle_response(new_text, msg, reply_context)
             elif (
                 exact_word_match(self.telegram['nickname'], msg.text) or
-                exact_word_match(self.telegram['initials'], msg.text) or
-                is_reply_to_bot
+                exact_word_match(self.telegram['initials'], msg.text)
             ):
-                # Weaker trigger (nickname, initials, or reply): check for a foreign
-                # @mention first. If present, the message is likely for another account.
-                foreign = self._foreign_bot_mention(msg)
-                if foreign:
-                    await msg.reply_text(f"Looks like that message is for {foreign}!")
+                # Nickname/initials: always engage - no reliable way to distinguish
+                # our name as addressee vs topic from text position alone.
+                reply_context = await self._build_reply_context(msg)
+                await self._send_read_receipt(msg, context)
+                response, assistant_db_id = await self.tele_handle_response(msg.text, msg, reply_context)
+            elif is_reply_to_bot:
+                # Reply-to-bot: weaker signal - yield silently if the message is
+                # exclusively addressed to a foreign account via @mention.
+                if self._exclusive_foreign_mention(msg):
                     return
                 reply_context = await self._build_reply_context(msg)
                 await self._send_read_receipt(msg, context)
@@ -892,7 +960,7 @@ class TelegramBot:
         Builds an ephemeral message slice that appends a placeholder assistant acknowledgement
         and a user message containing the tool results to conv.messages, then calls the
         provider for a final natural-language answer. The ephemeral messages are not stored
-        in conv.messages -- only the final answer is persisted by the caller.
+        in conv.messages - only the final answer is persisted by the caller.
 
         Args:
             tool_call: The ToolCall returned by the first LLM call.
@@ -1088,6 +1156,21 @@ class TelegramBot:
         self.llm['prune_threshold'] = floor(0.95 * self.llm['token_limit'])
         self.llm['prune_back_to'] = max(0, self.llm['prune_threshold'] - 500)
 
+        # Patch identity placeholders now that both self.llm and self.telegram are set.
+        # _tele_info() has already populated username, nickname, and initials.
+        identity_line = (
+            f"\n- Your Telegram username is @{self.telegram['username']}, "
+            f"nickname '{self.telegram['nickname']}', "
+            f"initials '{self.telegram['initials']}'. "
+            "Users in group chats may address you by any of these. "
+            "Do not sign or close your messages with your name, initials, or username."
+        )
+        self.llm['prompt'] = re.sub(
+            r'\n-?\s*Your Telegram username is.*',
+            identity_line,
+            self.llm['prompt'],
+        )
+
         # Bot is now ready and active by default
         self._online = True
 

{tellmgrambot-3.13.7 → tellmgrambot-3.14.0}/TeLLMgramBot/database.py

@@ -47,6 +47,7 @@ CREATE TABLE IF NOT EXISTS users (
     username       TEXT,
     first_name     TEXT,
     last_name      TEXT,
+    is_bot         INTEGER NOT NULL DEFAULT 0,
     private_mode   INTEGER NOT NULL DEFAULT 0,
     previous_names TEXT,
     updated_at     TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
@@ -117,7 +118,7 @@ async def init_db() -> None:
     Migrations applied to existing databases:
       messages         - adds reply_to_id, tg_message_id, archived_at; drops username, is_foreign_bot.
       chats            - adds chat_type, previous_titles.
-      users            - adds private_mode, previous_names; merges and drops legacy private_mode table.
+      users            - adds private_mode, previous_names, is_bot; merges and drops legacy private_mode table.
       summary_archive  - created (tier 1 and 2 conversation summaries).
     """
     async with aiosqlite.connect(get_db_path()) as db:
@@ -158,6 +159,8 @@ async def init_db() -> None:
             await db.execute("ALTER TABLE users ADD COLUMN private_mode INTEGER NOT NULL DEFAULT 0")
         if 'previous_names' not in users_cols:
             await db.execute("ALTER TABLE users ADD COLUMN previous_names TEXT")
+        if 'is_bot' not in users_cols:
+            await db.execute("ALTER TABLE users ADD COLUMN is_bot INTEGER NOT NULL DEFAULT 0")
         tables = {row[0] async for row in await db.execute("SELECT name FROM sqlite_master WHERE type='table'")}
         if 'private_mode' in tables:
             await db.execute(
@@ -207,6 +210,40 @@ async def insert_message(
         return cursor.lastrowid
 
 
+async def prune_bot_messages(chat_id: int, cap: int = 50) -> None:
+    """
+    Delete the oldest bot-authored rows for a chat when the per-chat cap is exceeded.
+
+    Called after every bot message insert to keep ambient peer bot context from growing
+    unboundedly. Deletes rows where the sender is marked is_bot=1 in the users table,
+    oldest first, until at most `cap` such rows remain for the chat.
+
+    Args:
+        chat_id: Telegram chat ID to prune.
+        cap: Maximum number of bot message rows to retain per chat.
+    """
+    async with aiosqlite.connect(get_db_path()) as db:
+        async with db.execute(
+            "SELECT COUNT(*) FROM messages m "
+            "JOIN users u ON m.user_id = u.user_id "
+            "WHERE m.chat_id = ? AND u.is_bot = 1",
+            (chat_id,),
+        ) as cur:
+            (count,) = await cur.fetchone()
+        if count > cap:
+            excess = count - cap
+            await db.execute(
+                "DELETE FROM messages WHERE id IN ("
+                "  SELECT m.id FROM messages m "
+                "  JOIN users u ON m.user_id = u.user_id "
+                "  WHERE m.chat_id = ? AND u.is_bot = 1 "
+                "  ORDER BY m.created_at ASC, m.id ASC LIMIT ?"
+                ")",
+                (chat_id, excess),
+            )
+            await db.commit()
+
+
 async def update_message_tg_id(db_id: int, tg_message_id: int) -> None:
     """
     Store the Telegram message ID on an assistant row after send.
@@ -603,6 +640,7 @@ async def upsert_user(
     username: Optional[str],
     first_name: Optional[str],
     last_name: Optional[str],
+    is_bot: bool = False,
 ) -> None:
     """
     Insert or update a user record. Called on every interaction to capture name changes.
@@ -615,6 +653,7 @@ async def upsert_user(
         username: @handle without @, may be None.
         first_name: Telegram first name, may be None.
         last_name: Telegram last name, may be None.
+        is_bot: True for Telegram bot accounts; stored so context loaders can label them.
     """
     async with aiosqlite.connect(get_db_path()) as db:
         async with db.execute(
@@ -645,12 +684,12 @@ async def upsert_user(
                 updated_prev = prev
 
         await db.execute(
-            "INSERT INTO users (user_id, username, first_name, last_name, previous_names) VALUES (?, ?, ?, ?, ?) "
+            "INSERT INTO users (user_id, username, first_name, last_name, is_bot, previous_names) VALUES (?, ?, ?, ?, ?, ?) "
             "ON CONFLICT(user_id) DO UPDATE SET "
             "username = excluded.username, first_name = excluded.first_name, "
-            "last_name = excluded.last_name, previous_names = excluded.previous_names, "
-            "updated_at = ?",
-            (user_id, username, first_name, last_name, updated_prev, now_iso()),
+            "last_name = excluded.last_name, is_bot = excluded.is_bot, "
+            "previous_names = excluded.previous_names, updated_at = ?",
+            (user_id, username, first_name, last_name, int(is_bot), updated_prev, now_iso()),
         )
         await db.commit()
 

{tellmgrambot-3.13.7 → tellmgrambot-3.14.0}/TeLLMgramBot/initialize.py

@@ -127,6 +127,7 @@ INIT_BOT_CONFIG_COMMENTS = {
 # Teaches an LLM how cross-chat memory works without requiring persona authors to include it.
 _SYSTEM_APPENDIX = (
     "## System\n"
+    "- Your Telegram username is @(not yet known), nickname '(not yet known)', initials '(not yet known)'. Users in group chats may address you by any of these. Do not sign or close your messages with your name, initials, or username.\n"
     "- You have access to past messages across chats and a search tool - use them to inform your responses, but never quote or volunteer content from other chats unprompted, especially in group settings.\n"
     "- Always invoke the search tool before concluding a message does not exist.\n"
     "- Messages marked private are never shared between chats.\n"

{tellmgrambot-3.13.7 → tellmgrambot-3.14.0}/TeLLMgramBot/tools.py

@@ -11,7 +11,7 @@ import logging
 import os
 import re
 import socket
-from urllib.parse import quote, urlparse, urlunparse
+from urllib.parse import parse_qs, quote, urlparse, urlunparse
 
 import httpx
 
@@ -591,7 +591,11 @@ async def execute_webhook(tool_def: dict, arguments: dict) -> str:
     try:
         async with httpx.AsyncClient(timeout=15.0) as client:
             if method == 'GET':
-                resp = await client.get(url, params=args if args else None, headers=headers)
+                # Merge any static query params already in the URL (e.g. ?appid=KEY) with runtime args -
+                # httpx replaces the query string when 'params=' is passed separately, dropping static ones.
+                url_params = {k: v[0] for k, v in parse_qs(parsed.query).items()}
+                merged = {**url_params, **args}
+                resp = await client.get(base_url, params=merged if merged else None, headers=headers)
             else:
                 resp = await client.request(method, url, json=args if args else None, headers=headers)
 

{tellmgrambot-3.13.7 → tellmgrambot-3.14.0}/TeLLMgramBot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TeLLMgramBot
-Version: 3.13.7
+Version: 3.14.0
 Summary: LLM-powered Telegram bot (OpenAI + Anthropic)
 Home-page: https://github.com/Digital-Heresy/TeLLMgramBot
 Author: Digital Heresy
@@ -135,7 +135,7 @@ The bot responds in groups when you:
 - Mention the bot by nickname or initials (configured via `config.yaml`)
 - Reply directly to one of the bot's messages
 
-If a message explicitly @mentions another account, the bot defers with "Looks like that's for @OtherBot!" instead.
+When multiple bots are @mentioned in the same message, the bot coexists: if you mention the bot's nickname or initials, or reply to its message, the bot always engages (you may be intentionally addressing both bots). If the only trigger is a reply to the bot's message AND the message exclusively addresses a different bot via @mention (no mention of this bot), the bot yields silently - this supports threaded context without redundant responses.
 
 ### Private Chat Behavior
 In private chats, the bot responds to all your messages. If you reply to an earlier message in the conversation that is not already in the bot's context window, that message is automatically surfaced as inline context so the bot can understand the full conversation thread.

{tellmgrambot-3.13.7 → tellmgrambot-3.14.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setup(
     name='TeLLMgramBot',
-    version='3.13.7',
+    version='3.14.0',
     packages=find_packages(),
     license='MIT',
     author='Digital Heresy',