TeLLMgramBot 3.9.2__tar.gz → 3.10.0__tar.gz

{tellmgrambot-3.9.2 → tellmgrambot-3.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TeLLMgramBot
-Version: 3.9.2
+Version: 3.10.0
 Summary: LLM-powered Telegram bot (OpenAI + Anthropic)
 Home-page: https://github.com/Digital-Heresy/TeLLMgramBot
 Author: Digital Heresy
@@ -44,7 +44,7 @@ The basic goal of this project is to create a bridge between a Telegram Bot and
   * This uses a separate model (configurable via `url_model`) to support more URL content with its higher token limit.
 * Ask questions about message history across all your chats using natural language via LLM tool calling.
   * Example: "Who said thanks for the breakdown?" or "What did George say about the project?" or "What did we discuss about DMs?" or simply "Show me the last few messages" without specifying a search query.
-  * The bot automatically searches your private chat and all shared groups (where both you and the bot are active), attributing messages to speakers and returning results from the full history (beyond the limited in-memory token budget). All search filters are optional - you can ask for recent messages broadly without specifying content or speakers. Chat title queries support colloquial terms like "DMs" (falls back to all accessible chats if no exact match is found). Results are ordered most-recent-first; configure `search_limit` to control how many results to return (default: 30).
+  * The bot automatically searches your private chat and all shared groups (where both you and the bot are active), attributing messages to speakers and returning results from the full history (beyond the limited in-memory token budget). Messages from other bots in group chats are also indexed for search, enabling discovery of bot summaries and responses. All search filters are optional - you can ask for recent messages broadly without specifying content or speakers. Chat title queries support colloquial terms like "DMs" (falls back to all accessible chats if no exact match is found). Results are ordered most-recent-first; configure `search_limit` to control how many results to return (default: 30).
 * Tokens are used to measure the length of all conversation messages between the Telegram bot assistant and the user. This is useful to:
   * Ensure the length does not go over the model limit. If it does, prune oldest messages to fit within the limit.
   * Remember past conversations when restarting: loads the user's full history across all chats (private and groups) plus all other participants' messages in the current chat, up to 50% of the token budget. In private chats, shared group context (messages from groups where both user and bot are active) fills the remaining budget, enabling the bot to reference group conversations from a private context. This eliminates amnesia when users switch between contexts.
@@ -154,14 +154,17 @@ Each file with the associated API key will update its respective environment var
 - `/nick <name>` - Set your personal nickname (for bot use in group chats).
 - `/forget` - Clear all of your conversation history. In private chats, clears everything. In group chats, removes only your messages.
 - `/private` - Toggle private mode (private chats only). When enabled, your messages are excluded from group context loading, providing selective privacy in shared groups.
+- `/wipe` - Permanently delete all conversation data from the database (owner-only, irreversible).
 - `/help` - Display all available commands and usage information.
 
 ### Group Chat Triggers
-In group and supergroup chats, the bot responds when any of the following conditions are met:
+In group and supergroup chats, the bot automatically captures and indexes messages from other bots, making them available via message history searches and conversation context. For example, you can ask "What did Bot B say about the project?" in a private chat and the bot will search across all shared groups.
+
+For non-bot messages, the bot responds when any of the following conditions are met:
 - You mention the bot by username (e.g., `@botname`)
-- You mention the bot by nickname (configured via `config.yaml`)
-- You mention the bot by initials (configured via `config.yaml`)
-- You directly reply to one of the bot's messages (Telegram reply-to feature)
+- You mention the bot by nickname (configured via `config.yaml`), unless the message explicitly @mentions another account
+- You mention the bot by initials (configured via `config.yaml`), unless the message explicitly @mentions another account
+- You directly reply to one of the bot's messages (Telegram reply-to feature), unless the message explicitly @mentions another account
 
 When a reply-to-bot message explicitly @mentions another account (e.g., "@otherbot please help" or "@alice can you help?"), the bot politely defers with "Looks like that message is for @otherbot!" rather than generating an LLM response. Note: Telegram does not distinguish bots from regular users in @mentions, so deflection fires for any foreign @mention. Deflections intentionally skip the read receipt.
 
@@ -186,12 +189,17 @@ This library includes an example script `test_local.py`, which uses files from t
        persona_prompt = <System prompt summarizing bot personality>
    )
    ```
-4. Turn on TeLLMgramBot by calling:
+4. **Disable group privacy mode in BotFather** to enable full group message capture (required for foreign bot message indexing and cross-chat context):
+   ```
+   /setprivacy -> select your bot -> Disable
+   ```
+   With privacy mode on (the default), Telegram only delivers messages that mention the bot, are replies to it, or are commands - other group messages including those from other bots are not delivered.
+5. Turn on TeLLMgramBot by calling:
    ```
    telegram_bot.start_polling()
    ```
    Once you see `TeLLMgramBot polling...`, the bot is online in Telegram.
-5. Converse! Type `/help` for all available commands.
+6. Converse! Type `/help` for all available commands.
 
 ## Resources
 * GitHub repository [python-telegram-bot](https://github.com/python-telegram-bot/python-telegram-bot) has guides to create a Telegram bot.

{tellmgrambot-3.9.2 → tellmgrambot-3.10.0}/README.md

@@ -12,7 +12,7 @@ The basic goal of this project is to create a bridge between a Telegram Bot and
   * This uses a separate model (configurable via `url_model`) to support more URL content with its higher token limit.
 * Ask questions about message history across all your chats using natural language via LLM tool calling.
   * Example: "Who said thanks for the breakdown?" or "What did George say about the project?" or "What did we discuss about DMs?" or simply "Show me the last few messages" without specifying a search query.
-  * The bot automatically searches your private chat and all shared groups (where both you and the bot are active), attributing messages to speakers and returning results from the full history (beyond the limited in-memory token budget). All search filters are optional - you can ask for recent messages broadly without specifying content or speakers. Chat title queries support colloquial terms like "DMs" (falls back to all accessible chats if no exact match is found). Results are ordered most-recent-first; configure `search_limit` to control how many results to return (default: 30).
+  * The bot automatically searches your private chat and all shared groups (where both you and the bot are active), attributing messages to speakers and returning results from the full history (beyond the limited in-memory token budget). Messages from other bots in group chats are also indexed for search, enabling discovery of bot summaries and responses. All search filters are optional - you can ask for recent messages broadly without specifying content or speakers. Chat title queries support colloquial terms like "DMs" (falls back to all accessible chats if no exact match is found). Results are ordered most-recent-first; configure `search_limit` to control how many results to return (default: 30).
 * Tokens are used to measure the length of all conversation messages between the Telegram bot assistant and the user. This is useful to:
   * Ensure the length does not go over the model limit. If it does, prune oldest messages to fit within the limit.
   * Remember past conversations when restarting: loads the user's full history across all chats (private and groups) plus all other participants' messages in the current chat, up to 50% of the token budget. In private chats, shared group context (messages from groups where both user and bot are active) fills the remaining budget, enabling the bot to reference group conversations from a private context. This eliminates amnesia when users switch between contexts.
@@ -122,14 +122,17 @@ Each file with the associated API key will update its respective environment var
 - `/nick <name>` - Set your personal nickname (for bot use in group chats).
 - `/forget` - Clear all of your conversation history. In private chats, clears everything. In group chats, removes only your messages.
 - `/private` - Toggle private mode (private chats only). When enabled, your messages are excluded from group context loading, providing selective privacy in shared groups.
+- `/wipe` - Permanently delete all conversation data from the database (owner-only, irreversible).
 - `/help` - Display all available commands and usage information.
 
 ### Group Chat Triggers
-In group and supergroup chats, the bot responds when any of the following conditions are met:
+In group and supergroup chats, the bot automatically captures and indexes messages from other bots, making them available via message history searches and conversation context. For example, you can ask "What did Bot B say about the project?" in a private chat and the bot will search across all shared groups.
+
+For non-bot messages, the bot responds when any of the following conditions are met:
 - You mention the bot by username (e.g., `@botname`)
-- You mention the bot by nickname (configured via `config.yaml`)
-- You mention the bot by initials (configured via `config.yaml`)
-- You directly reply to one of the bot's messages (Telegram reply-to feature)
+- You mention the bot by nickname (configured via `config.yaml`), unless the message explicitly @mentions another account
+- You mention the bot by initials (configured via `config.yaml`), unless the message explicitly @mentions another account
+- You directly reply to one of the bot's messages (Telegram reply-to feature), unless the message explicitly @mentions another account
 
 When a reply-to-bot message explicitly @mentions another account (e.g., "@otherbot please help" or "@alice can you help?"), the bot politely defers with "Looks like that message is for @otherbot!" rather than generating an LLM response. Note: Telegram does not distinguish bots from regular users in @mentions, so deflection fires for any foreign @mention. Deflections intentionally skip the read receipt.
 
@@ -154,12 +157,17 @@ This library includes an example script `test_local.py`, which uses files from t
        persona_prompt = <System prompt summarizing bot personality>
    )
    ```
-4. Turn on TeLLMgramBot by calling:
+4. **Disable group privacy mode in BotFather** to enable full group message capture (required for foreign bot message indexing and cross-chat context):
+   ```
+   /setprivacy -> select your bot -> Disable
+   ```
+   With privacy mode on (the default), Telegram only delivers messages that mention the bot, are replies to it, or are commands - other group messages including those from other bots are not delivered.
+5. Turn on TeLLMgramBot by calling:
    ```
    telegram_bot.start_polling()
    ```
    Once you see `TeLLMgramBot polling...`, the bot is online in Telegram.
-5. Converse! Type `/help` for all available commands.
+6. Converse! Type `/help` for all available commands.
 
 ## Resources
 * GitHub repository [python-telegram-bot](https://github.com/python-telegram-bot/python-telegram-bot) has guides to create a Telegram bot.

{tellmgrambot-3.9.2 → tellmgrambot-3.10.0}/TeLLMgramBot/TeLLMgramBot.py

@@ -17,12 +17,17 @@ from .utils import format_dt
 from .database import (
     get_private_mode,
     set_private_mode,
+    insert_message,
     delete_messages_for_user,
     delete_messages_for_chat,
     delete_private_messages_for_user,
     delete_bot_replies_for_user,
     get_shared_group_chat_ids,
+    prune_foreign_bot_messages,
     search_messages,
+    upsert_chat,
+    upsert_user,
+    wipe_all_data,
 )
 from .initialize import (
     INIT_BOT_CONFIG,
@@ -38,11 +43,15 @@ from .utils import exact_word_match, log_error
 
 logger = logging.getLogger(__name__)
 
+_FOREIGN_BOT_MESSAGE_CAP = 50
+
 _SEARCH_TOOL = {
     "name": "search_messages",
     "description": (
         "Search the full message history across the user's private chat and shared group chats. "
         "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. "
         "Results are ordered most-recent-first; to find the earliest message, look at the last result."
     ),
@@ -91,6 +100,7 @@ class TelegramBot:
             "Administrator-only commands:\n"
             "/start - Go online to receive new responses (default).\n"
             "/stop - Go offline to prevent new responses.\n"
+            "/wipe - Permanently delete all conversation data (irreversible).\n"
         )
 
     async def tele_start_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
@@ -112,6 +122,18 @@ class TelegramBot:
         else:
             await update.message.reply_text("Sorry, I can't do that for you.")
 
+    async def tele_wipe_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
+        """A bot_owner-only command to permanently delete all messages, users, and chats from the database."""
+        uname = update.message.from_user.username
+        if uname != self.telegram['owner']:
+            await update.message.reply_text("Sorry, I can't do that for you.")
+            return
+        await wipe_all_data()
+        self.conversations.clear()
+        self.token_warning.clear()
+        context.application.bot_data.pop('_foreign_bot_reply_seen', None)
+        await update.message.reply_text("All conversation data wiped.")
+
     async def tele_nick_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
         """
         Let bot assistant know to call the user by a different name other than the Telegram username.
@@ -360,6 +382,31 @@ class TelegramBot:
 
         return reply
 
+    async def _store_foreign_bot_message(self, msg: Message, chat: Chat) -> None:
+        """
+        Persist a group message from another bot to the database.
+
+        Called when a bot message is received in a group chat. Stores the message with
+        is_foreign_bot=True so it is searchable via the LLM search tool. Enforces the
+        per-chat cap (_FOREIGN_BOT_MESSAGE_CAP) by pruning the oldest rows after insert.
+
+        Args:
+            msg: The incoming Telegram Message from the foreign bot.
+            chat: The group chat the message was sent in.
+        """
+        bot = msg.from_user
+        speaker = bot.first_name or (f'@{bot.username}' if bot.username else 'Bot')
+        await upsert_user(bot.id, bot.username, bot.first_name, bot.last_name)
+        await upsert_chat(chat.id, chat.type, chat.title)
+        await insert_message(
+            chat_id=chat.id,
+            user_id=bot.id,
+            role='user',
+            content=f'[{speaker}]: {msg.text}',
+            is_foreign_bot=True,
+        )
+        await prune_foreign_bot_messages(chat.id, _FOREIGN_BOT_MESSAGE_CAP)
+
     def _foreign_bot_mention(self, msg: Message) -> str | None:
         """
         Return the @username of the first explicitly @mentioned account that is not us, or None.
@@ -418,7 +465,12 @@ class TelegramBot:
         """
         Route incoming Telegram messages to appropriate handlers based on chat type and trigger conditions.
 
-        In group/supergroup chats, the bot responds when any of the following conditions are met:
+        In group/supergroup chats, messages from other bots (user.is_bot=True, user.id != our bot_id)
+        are immediately persisted to the database via _store_foreign_bot_message() and the handler returns
+        without generating an LLM response. This makes foreign bot messages searchable via the search tool.
+
+        For non-bot messages in group/supergroup chats, the bot responds when any of the following
+        conditions are met:
         - User mentions the bot by @username
         - User mentions the bot by nickname (set via config)
         - User mentions the bot by initials (set via config)
@@ -427,7 +479,7 @@ class TelegramBot:
         In all matching group scenarios, a read receipt acknowledgement (👀 reaction or "Got it!" fallback)
         is sent immediately via _send_read_receipt() before generating the full LLM response.
 
-        In private chats, the bot responds to all messages.
+        In private chats, the bot responds to all messages (Telegram does not deliver bot-to-bot DMs).
 
         Args:
             update: The Telegram Update object containing the incoming message.
@@ -438,6 +490,41 @@ class TelegramBot:
             return
         (msg, chat, user) = validated
 
+        # Store foreign bot messages in group chats and return - no LLM response needed.
+        if (
+            user.is_bot and
+            user.id != self.telegram['bot_id'] and
+            msg.text and
+            chat.type in ('group', 'supergroup')
+        ):
+            await self._store_foreign_bot_message(msg, chat)
+            return
+
+        # Opportunistically capture foreign bot messages via reply_to_message.
+        # Telegram does not deliver bot messages as standalone updates; this extracts
+        # them when a user replies to another bot so they become searchable.
+        # Deduplicate: multiple users replying to the same bot message would each
+        # trigger capture; use a short-lived in-memory set keyed by (chat, bot, msg_id).
+        reply = msg.reply_to_message
+        if (
+            reply and
+            reply.from_user and
+            reply.from_user.is_bot and
+            reply.from_user.id != self.telegram['bot_id'] and
+            reply.text and
+            chat.type in ('group', 'supergroup')
+        ):
+            recently_seen = context.application.bot_data.setdefault('_foreign_bot_reply_seen', {})
+            dedupe_key = (chat.id, reply.from_user.id, reply.message_id)
+            now = datetime.datetime.now(datetime.timezone.utc)
+            cutoff = now - datetime.timedelta(hours=1)
+            stale = [k for k, seen_at in recently_seen.items() if seen_at < cutoff]
+            for k in stale:
+                recently_seen.pop(k, None)
+            if dedupe_key not in recently_seen:
+                recently_seen[dedupe_key] = now
+                await self._store_foreign_bot_message(reply, chat)
+
         # 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 = "Sorry, I couldn't process your message! Please contact my creator."
@@ -448,21 +535,21 @@ class TelegramBot:
                 msg.reply_to_message.from_user.id == self.telegram['bot_id']
             )
             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).
                 pattern = r'@?\b' + re.escape(self.telegram['username']) + r'\b'
                 new_text = re.sub(pattern, '', msg.text).strip()
                 await self._send_read_receipt(msg, context)
                 response = await self.tele_handle_response(new_text, msg)
             elif (
                 exact_word_match(self.telegram['nickname'], msg.text) or
-                exact_word_match(self.telegram['initials'], msg.text)
+                exact_word_match(self.telegram['initials'], msg.text) or
+                is_reply_to_bot
             ):
-                await self._send_read_receipt(msg, context)
-                response = await self.tele_handle_response(msg.text, msg)
-            elif is_reply_to_bot:
+                # 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:
-                    # The reply is directed at a different account - deflect without
-                    # sending a read receipt, since we are not handling this message.
                     await msg.reply_text(f"Looks like that message is for {foreign}!")
                     return
                 await self._send_read_receipt(msg, context)
@@ -630,7 +717,10 @@ class TelegramBot:
     def start_polling(self):
         """The main polling "loop" the user interacts with via Telegram."""
         logger.info(f"TeLLMgramBot {self.telegram['username']} polling...")
-        self.telegram['app'].run_polling(poll_interval=self.telegram['pollinterval'])
+        self.telegram['app'].run_polling(
+            poll_interval=self.telegram['pollinterval'],
+            allowed_updates=Update.ALL_TYPES,
+        )
         logger.info(f"TeLLMgramBot {self.telegram['username']} polling ended.")
 
     # Initialization
@@ -702,6 +792,7 @@ class TelegramBot:
         self.telegram['app'].add_handler(CommandHandler('help', self.tele_commands))
         self.telegram['app'].add_handler(CommandHandler('start', self.tele_start_command))
         self.telegram['app'].add_handler(CommandHandler('stop', self.tele_stop_command))
+        self.telegram['app'].add_handler(CommandHandler('wipe', self.tele_wipe_command))
         self.telegram['app'].add_handler(CommandHandler('nick', self.tele_nick_command))
         self.telegram['app'].add_handler(CommandHandler('forget', self.tele_forget_command))
         self.telegram['app'].add_handler(CommandHandler('private', self.tele_private_command))

{tellmgrambot-3.9.2 → tellmgrambot-3.10.0}/TeLLMgramBot/database.py

@@ -2,9 +2,10 @@
 SQLite-backed conversation storage for TeLLMgramBot.
 
 Provides async helpers for persisting and loading messages, managing per-user private mode,
-searching message history, and retrieving conversation context. The schema includes a messages
-table (indexed by chat_id and user_id), a users table (profile data and private_mode flag),
-and a chats table for speaker/chat resolution in search results.
+searching message history, and retrieving conversation context. Supports foreign bot message
+storage with per-chat pruning. The schema includes a messages table (indexed by chat_id and
+user_id, with is_foreign_bot and is_private flags), a users table (profile data and
+private_mode flag), and a chats table for speaker/chat resolution in search results.
 """
 import os
 from typing import Optional
@@ -23,14 +24,15 @@ _DDL = """
 PRAGMA journal_mode=WAL;
 
 CREATE TABLE IF NOT EXISTS messages (
-    id           INTEGER PRIMARY KEY AUTOINCREMENT,
-    chat_id      INTEGER NOT NULL,
-    user_id      INTEGER NOT NULL,
-    role         TEXT NOT NULL CHECK(role IN ('user', 'assistant', 'system')),
-    content      TEXT NOT NULL,
-    is_private   INTEGER NOT NULL DEFAULT 0,
-    reply_to_id  INTEGER,
-    created_at   TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+    id             INTEGER PRIMARY KEY AUTOINCREMENT,
+    chat_id        INTEGER NOT NULL,
+    user_id        INTEGER NOT NULL,
+    role           TEXT NOT NULL CHECK(role IN ('user', 'assistant', 'system')),
+    content        TEXT NOT NULL,
+    is_private     INTEGER NOT NULL DEFAULT 0,
+    is_foreign_bot INTEGER NOT NULL DEFAULT 0,
+    reply_to_id    INTEGER,
+    created_at     TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
 );
 
 CREATE INDEX IF NOT EXISTS idx_messages_chat_id ON messages(chat_id, created_at);
@@ -77,6 +79,7 @@ async def init_db() -> None:
     - Drops username column from messages table (now in normalized users table).
     - Adds chat_type column to chats table.
     - Adds private_mode column to users table and merges legacy private_mode table into it.
+    - Adds is_foreign_bot column to messages table for foreign bot message storage.
     """
     async with aiosqlite.connect(get_db_path()) as db:
         await db.executescript(_DDL)
@@ -84,6 +87,9 @@ async def init_db() -> None:
         # Migration: add reply_to_id to existing databases that predate this column.
         if 'reply_to_id' not in existing:
             await db.execute("ALTER TABLE messages ADD COLUMN reply_to_id INTEGER")
+        # Migration: add is_foreign_bot to existing databases that predate this column.
+        if 'is_foreign_bot' not in existing:
+            await db.execute("ALTER TABLE messages ADD COLUMN is_foreign_bot INTEGER NOT NULL DEFAULT 0")
         # Migration: drop username column now stored in the normalized users table.
         if 'username' in existing:
             await db.execute("ALTER TABLE messages DROP COLUMN username")
@@ -115,6 +121,7 @@ async def insert_message(
     content: str,
     is_private: bool = False,
     reply_to_id: Optional[int] = None,
+    is_foreign_bot: bool = False,
 ) -> int:
     """
     Persist a single message row and return its database id.
@@ -124,17 +131,18 @@ async def insert_message(
         user_id: Telegram user ID of the sender.
         role: 'user', 'assistant', or 'system'.
         content: Message text.
-        is_private: If True, this message is excluded from group context loading.
+        is_private: If True, this message is excluded from all context loading.
         reply_to_id: Database id of the message this is a reply to (None if not a reply).
+        is_foreign_bot: If True, marks this as a message from another bot for search indexing.
 
     Returns:
         The integer id of the newly inserted row.
     """
     async with aiosqlite.connect(get_db_path()) as db:
         cursor = await db.execute(
-            "INSERT INTO messages (chat_id, user_id, role, content, is_private, reply_to_id) "
-            "VALUES (?, ?, ?, ?, ?, ?)",
-            (chat_id, user_id, role, content, int(is_private), reply_to_id),
+            "INSERT INTO messages (chat_id, user_id, role, content, is_private, reply_to_id, is_foreign_bot) "
+            "VALUES (?, ?, ?, ?, ?, ?, ?)",
+            (chat_id, user_id, role, content, int(is_private), reply_to_id, int(is_foreign_bot)),
         )
         await db.commit()
         return cursor.lastrowid
@@ -696,6 +704,28 @@ async def search_messages(
         })
     return results
 
+async def prune_foreign_bot_messages(chat_id: int, cap: int) -> None:
+    """
+    Enforce a per-chat cap on foreign bot messages.
+
+    Deletes the oldest is_foreign_bot=1 rows for this chat when the count exceeds cap,
+    keeping the most recent `cap` rows. No-ops when the count is at or below the cap.
+
+    Args:
+        chat_id: Telegram chat ID of the group to prune.
+        cap: Maximum number of foreign bot messages to retain per chat.
+    """
+    async with aiosqlite.connect(get_db_path()) as db:
+        await db.execute(
+            "DELETE FROM messages WHERE chat_id = ? AND is_foreign_bot = 1 "
+            "AND id NOT IN ("
+            "  SELECT id FROM messages WHERE chat_id = ? AND is_foreign_bot = 1 "
+            "  ORDER BY created_at DESC, id DESC LIMIT ?"
+            ")",
+            (chat_id, chat_id, cap),
+        )
+        await db.commit()
+
 async def delete_bot_replies_for_user(user_id: int) -> None:
     """
     Delete assistant rows whose reply_to_id references any message from this user.
@@ -754,6 +784,19 @@ async def delete_private_messages_for_user(user_id: int) -> None:
         )
         await db.commit()
 
+async def wipe_all_data() -> None:
+    """
+    Delete all rows from the messages, users, and chats tables.
+
+    Irreversible. Used by the /wipe admin command to reset the bot's
+    conversation database entirely. Schema and indexes are preserved.
+    """
+    async with aiosqlite.connect(get_db_path()) as db:
+        await db.execute("DELETE FROM messages")
+        await db.execute("DELETE FROM users")
+        await db.execute("DELETE FROM chats")
+        await db.commit()
+
 async def get_private_mode(user_id: int) -> bool:
     """
     Return whether private mode is currently enabled for this user.

{tellmgrambot-3.9.2 → tellmgrambot-3.10.0}/TeLLMgramBot/initialize.py

@@ -121,8 +121,8 @@ _SYSTEM_APPENDIX = (
     "- Group chats may include the user's private history; private chats may include shared group history.\n"
     "- /private mode excludes that user's messages from group contexts only; don't generalize it to deny other context.\n\n"
     "Date/time:\n"
-    "- The injected UTC datetime at the end of this prompt is authoritative. Use it for all time questions and relative references. Always reproduce it verbatim (YYYY/MM/DD HH:MM:SS AM/PM UTC) — never reformat.\n"
-    "- State UTC time and stop. Never offer, suggest, or ask about timezone conversion — not even based on prior context. Convert only when the user explicitly requests it in the current message.\n"
+    "- The injected UTC datetime at the end of this prompt is authoritative. Use it for all time questions and relative references. When stating the time, reproduce it verbatim (YYYY/MM/DD HH:MM:SS AM/PM UTC) - never reformat. Do not include the current time in responses unless the user asks.\n"
+    "- State UTC time and stop. Never offer, suggest, or ask about timezone conversion - not even based on prior context. Convert only when the user explicitly requests it in the current message.\n"
     "- Decline requests to set a timezone; explain UTC is always used.\n\n"
     "Current user: (not yet known)\n"
 )

{tellmgrambot-3.9.2 → tellmgrambot-3.10.0}/TeLLMgramBot/providers/anthropic_provider.py

@@ -7,6 +7,31 @@ from .base import LLMProvider, ContextLengthExceededError, ProviderAuthError, Pr
 # Safe default for max output tokens; configurable in Phase 3
 _DEFAULT_MAX_OUTPUT_TOKENS = 8192
 
+
+def _merge_consecutive_roles(messages: list[dict]) -> list[dict]:
+    """
+    Merge consecutive messages with the same role into a single message.
+
+    Anthropic requires strictly alternating user/assistant turns. When foreign bot messages
+    stored as role='user' appear immediately before the triggering user's reply, this
+    produces two consecutive user messages, which the API rejects. This function merges
+    them by concatenating their content with a blank line separator.
+
+    Args:
+        messages: List of message dicts with 'role' and 'content' keys.
+
+    Returns:
+        A new list with consecutive same-role messages merged.
+    """
+    merged: list[dict] = []
+    for m in messages:
+        if merged and merged[-1]['role'] == m['role']:
+            merged[-1]['content'] += f'\n\n{m["content"]}'
+        else:
+            merged.append(dict(m))
+    return merged
+
+
 class AnthropicProvider(LLMProvider):
     """LLM provider implementation for Anthropic Claude models."""
     _client: AsyncAnthropic | None = None
@@ -32,6 +57,11 @@ class AnthropicProvider(LLMProvider):
             else:
                 chat_messages.append(msg)
 
+        # Anthropic requires strictly alternating user/assistant turns. Merge consecutive
+        # messages of the same role (e.g. a foreign bot's user-role message immediately
+        # followed by the actual user's message) by concatenating their content.
+        chat_messages = _merge_consecutive_roles(chat_messages)
+
         kwargs = {
             'model': model,
             'max_tokens': _DEFAULT_MAX_OUTPUT_TOKENS,
@@ -98,6 +128,7 @@ class AnthropicProvider(LLMProvider):
                 chat_messages.append(msg)
         if not chat_messages:
             return 0
+        chat_messages = _merge_consecutive_roles(chat_messages)
         kwargs = {'model': model, 'messages': chat_messages}
         if system:
             kwargs['system'] = system

{tellmgrambot-3.9.2 → tellmgrambot-3.10.0}/TeLLMgramBot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TeLLMgramBot
-Version: 3.9.2
+Version: 3.10.0
 Summary: LLM-powered Telegram bot (OpenAI + Anthropic)
 Home-page: https://github.com/Digital-Heresy/TeLLMgramBot
 Author: Digital Heresy
@@ -44,7 +44,7 @@ The basic goal of this project is to create a bridge between a Telegram Bot and
   * This uses a separate model (configurable via `url_model`) to support more URL content with its higher token limit.
 * Ask questions about message history across all your chats using natural language via LLM tool calling.
   * Example: "Who said thanks for the breakdown?" or "What did George say about the project?" or "What did we discuss about DMs?" or simply "Show me the last few messages" without specifying a search query.
-  * The bot automatically searches your private chat and all shared groups (where both you and the bot are active), attributing messages to speakers and returning results from the full history (beyond the limited in-memory token budget). All search filters are optional - you can ask for recent messages broadly without specifying content or speakers. Chat title queries support colloquial terms like "DMs" (falls back to all accessible chats if no exact match is found). Results are ordered most-recent-first; configure `search_limit` to control how many results to return (default: 30).
+  * The bot automatically searches your private chat and all shared groups (where both you and the bot are active), attributing messages to speakers and returning results from the full history (beyond the limited in-memory token budget). Messages from other bots in group chats are also indexed for search, enabling discovery of bot summaries and responses. All search filters are optional - you can ask for recent messages broadly without specifying content or speakers. Chat title queries support colloquial terms like "DMs" (falls back to all accessible chats if no exact match is found). Results are ordered most-recent-first; configure `search_limit` to control how many results to return (default: 30).
 * Tokens are used to measure the length of all conversation messages between the Telegram bot assistant and the user. This is useful to:
   * Ensure the length does not go over the model limit. If it does, prune oldest messages to fit within the limit.
   * Remember past conversations when restarting: loads the user's full history across all chats (private and groups) plus all other participants' messages in the current chat, up to 50% of the token budget. In private chats, shared group context (messages from groups where both user and bot are active) fills the remaining budget, enabling the bot to reference group conversations from a private context. This eliminates amnesia when users switch between contexts.
@@ -154,14 +154,17 @@ Each file with the associated API key will update its respective environment var
 - `/nick <name>` - Set your personal nickname (for bot use in group chats).
 - `/forget` - Clear all of your conversation history. In private chats, clears everything. In group chats, removes only your messages.
 - `/private` - Toggle private mode (private chats only). When enabled, your messages are excluded from group context loading, providing selective privacy in shared groups.
+- `/wipe` - Permanently delete all conversation data from the database (owner-only, irreversible).
 - `/help` - Display all available commands and usage information.
 
 ### Group Chat Triggers
-In group and supergroup chats, the bot responds when any of the following conditions are met:
+In group and supergroup chats, the bot automatically captures and indexes messages from other bots, making them available via message history searches and conversation context. For example, you can ask "What did Bot B say about the project?" in a private chat and the bot will search across all shared groups.
+
+For non-bot messages, the bot responds when any of the following conditions are met:
 - You mention the bot by username (e.g., `@botname`)
-- You mention the bot by nickname (configured via `config.yaml`)
-- You mention the bot by initials (configured via `config.yaml`)
-- You directly reply to one of the bot's messages (Telegram reply-to feature)
+- You mention the bot by nickname (configured via `config.yaml`), unless the message explicitly @mentions another account
+- You mention the bot by initials (configured via `config.yaml`), unless the message explicitly @mentions another account
+- You directly reply to one of the bot's messages (Telegram reply-to feature), unless the message explicitly @mentions another account
 
 When a reply-to-bot message explicitly @mentions another account (e.g., "@otherbot please help" or "@alice can you help?"), the bot politely defers with "Looks like that message is for @otherbot!" rather than generating an LLM response. Note: Telegram does not distinguish bots from regular users in @mentions, so deflection fires for any foreign @mention. Deflections intentionally skip the read receipt.
 
@@ -186,12 +189,17 @@ This library includes an example script `test_local.py`, which uses files from t
        persona_prompt = <System prompt summarizing bot personality>
    )
    ```
-4. Turn on TeLLMgramBot by calling:
+4. **Disable group privacy mode in BotFather** to enable full group message capture (required for foreign bot message indexing and cross-chat context):
+   ```
+   /setprivacy -> select your bot -> Disable
+   ```
+   With privacy mode on (the default), Telegram only delivers messages that mention the bot, are replies to it, or are commands - other group messages including those from other bots are not delivered.
+5. Turn on TeLLMgramBot by calling:
    ```
    telegram_bot.start_polling()
    ```
    Once you see `TeLLMgramBot polling...`, the bot is online in Telegram.
-5. Converse! Type `/help` for all available commands.
+6. Converse! Type `/help` for all available commands.
 
 ## Resources
 * GitHub repository [python-telegram-bot](https://github.com/python-telegram-bot/python-telegram-bot) has guides to create a Telegram bot.

{tellmgrambot-3.9.2 → tellmgrambot-3.10.0}/setup.py

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