TeLLMgramBot 3.9.1__tar.gz → 3.10.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TeLLMgramBot
-Version: 3.9.1
+Version: 3.10.0
 Summary: LLM-powered Telegram bot (OpenAI + Anthropic)
 Home-page: https://github.com/Digital-Heresy/TeLLMgramBot
 Author: Digital Heresy
@@ -43,8 +43,8 @@ The basic goal of this project is to create a bridge between a Telegram Bot and
   * Example: "What do you think of this article? [https://some_site/article]"
   * 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?"
-  * 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). Chat title queries support colloquial terms like "DMs" (falls back to all accessible chats if no exact match is found).
+  * 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). 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.
@@ -77,6 +77,7 @@ When initializing TeLLMgramBot, the following directories get created:
     * `chat_model` - the model used for normal conversation (e.g. `gpt-5-mini` or `claude-sonnet-4-6`).
     * `url_model` - the model used to read and summarize URL content, can differ from `chat_model`.
     * An empty `token_limit` will use the maximum tokens supported by the `chat_model`.
+    * `search_limit` - optional; maximum number of message history search results returned (default: 30). When the user asks "show me recent messages" or searches message history via natural language, this limits the number of results. Omit to use the default.
   * `models.yaml`
     * Contains token size parameters for all supported models.
     * On first run, GPT and Claude model families are pre-populated. Additional models can be added manually.
@@ -85,7 +86,7 @@ When initializing TeLLMgramBot, the following directories get created:
       * A sample prompt file defining the bot's personality: generic, helpful, and multi-provider-aware.
       * The prompt emphasizes the bot's ability to fetch and analyze URLs passed in square brackets `[]`.
       * The user can create more prompt files as needed for different personalities.
-      * At initialization, the bot automatically appends framework-owned behavioral guidance (system appendix) to teach the LLM how cross-chat memory works (cross-pollination, private mode, shared group context) without requiring persona authors to include this guidance.
+      * At initialization, the bot automatically appends framework-owned behavioral guidance (system appendix) to teach the LLM how cross-chat memory works (cross-pollination, private mode, shared group context) without requiring persona authors to include this guidance. The appendix includes two framework-managed injectable values: the current UTC datetime and the current user identity, refreshed on every message so the LLM always has accurate context.
     * `url_analysis.prmpt`
       * Prompt template used to analyze URL content passed in brackets `[]`.
 * `logs`
@@ -153,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.
 
@@ -185,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.1 → tellmgrambot-3.10.0}/README.md

@@ -11,8 +11,8 @@ The basic goal of this project is to create a bridge between a Telegram Bot and
   * Example: "What do you think of this article? [https://some_site/article]"
   * 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?"
-  * 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). Chat title queries support colloquial terms like "DMs" (falls back to all accessible chats if no exact match is found).
+  * 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). 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.
@@ -45,6 +45,7 @@ When initializing TeLLMgramBot, the following directories get created:
     * `chat_model` - the model used for normal conversation (e.g. `gpt-5-mini` or `claude-sonnet-4-6`).
     * `url_model` - the model used to read and summarize URL content, can differ from `chat_model`.
     * An empty `token_limit` will use the maximum tokens supported by the `chat_model`.
+    * `search_limit` - optional; maximum number of message history search results returned (default: 30). When the user asks "show me recent messages" or searches message history via natural language, this limits the number of results. Omit to use the default.
   * `models.yaml`
     * Contains token size parameters for all supported models.
     * On first run, GPT and Claude model families are pre-populated. Additional models can be added manually.
@@ -53,7 +54,7 @@ When initializing TeLLMgramBot, the following directories get created:
       * A sample prompt file defining the bot's personality: generic, helpful, and multi-provider-aware.
       * The prompt emphasizes the bot's ability to fetch and analyze URLs passed in square brackets `[]`.
       * The user can create more prompt files as needed for different personalities.
-      * At initialization, the bot automatically appends framework-owned behavioral guidance (system appendix) to teach the LLM how cross-chat memory works (cross-pollination, private mode, shared group context) without requiring persona authors to include this guidance.
+      * At initialization, the bot automatically appends framework-owned behavioral guidance (system appendix) to teach the LLM how cross-chat memory works (cross-pollination, private mode, shared group context) without requiring persona authors to include this guidance. The appendix includes two framework-managed injectable values: the current UTC datetime and the current user identity, refreshed on every message so the LLM always has accurate context.
     * `url_analysis.prmpt`
       * Prompt template used to analyze URL content passed in brackets `[]`.
 * `logs`
@@ -121,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.
 
@@ -153,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.1 → 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,18 +43,23 @@ 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. "
-        "At least one of content_query or speaker_query must be provided."
+        "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."
     ),
     "parameters": {
         "type": "object",
         "properties": {
             "content_query": {"type": "string", "description": "Text to search for in message content"},
-            "speaker_query": {"type": "string", "description": "Name or @username of the person who sent the message. Use the exact name or @username if known. If multiple users match, the search will return an ambiguity error asking you to clarify."},
+            "speaker_query": {"type": "string", "description": "Name or @username of the person who sent the message. When the user refers to their own messages ('I said', 'my messages', 'what did I say'), use the current user's name or @username from the system prompt. If multiple users match, the search will return an ambiguity error asking you to clarify."},
             "chat_query": {"type": "string", "description": "Name of the group chat to search within. Use the exact chat title if known. If multiple chats match, the search will return an ambiguity error asking you to clarify."},
             "date_from": {"type": "string", "description": "ISO date string (YYYY-MM-DD) for start of range"},
             "date_to": {"type": "string", "description": "ISO date string (YYYY-MM-DD) for end of range"},
@@ -90,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):
@@ -111,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.
@@ -285,8 +308,9 @@ class TelegramBot:
 
         conv = self.conversations[chat_id]
 
-        # Refresh datetime on every message so timestamps stay accurate across long sessions
+        # Refresh datetime and current user identity on every message
         conv.update_datetime()
+        conv.update_current_user(first_name, last_name, username)
 
         token_budget = floor(self.llm['prune_threshold'] / 2)
 
@@ -358,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.
@@ -416,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)
@@ -425,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.
@@ -436,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."
@@ -446,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)
@@ -544,6 +633,7 @@ class TelegramBot:
                 args.get('chat_query'),
                 args.get('date_from'),
                 args.get('date_to'),
+                self.llm['search_limit'],
             )
             if isinstance(results, list):
                 for r in results:
@@ -627,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
@@ -638,6 +731,7 @@ class TelegramBot:
         chat_model     = INIT_BOT_CONFIG['chat_model'],
         url_model      = INIT_BOT_CONFIG['url_model'],
         token_limit    = INIT_BOT_CONFIG['token_limit'],
+        search_limit   = INIT_BOT_CONFIG['search_limit'],
         persona_temp   = INIT_BOT_CONFIG['persona_temp'],
         persona_prompt = INIT_BOT_CONFIG['persona_prompt'],
         key_status: ApiKeyStatus | None = None,
@@ -653,6 +747,7 @@ class TelegramBot:
             chat_model: LLM model for conversation (e.g., 'gpt-5-mini', 'claude-sonnet-4-6').
             url_model: LLM model for URL analysis (can differ from chat_model).
             token_limit: Maximum tokens for conversations. If None, uses the chat_model default.
+            search_limit: Maximum results returned by message search. If None, defaults to 30.
             persona_temp: LLM temperature (0.0-2.0). If None, defaults to 1.0.
             persona_prompt: System prompt defining the bot's behavior and personality.
             key_status: ApiKeyStatus object indicating available features. If None, calls init_structure().
@@ -697,12 +792,24 @@ 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))
         self.telegram['app'].add_handler(MessageHandler(filters.TEXT & ~filters.UpdateType.EDITED_MESSAGE, self.tele_handle_message))
         self.telegram['app'].add_error_handler(self.tele_error)
 
+        # Validate optional config values before storing; warn and fall back to defaults on bad input
+        if token_limit is not None and not (isinstance(token_limit, int) and token_limit > 0):
+            logger.warning(f"Invalid token_limit '{token_limit}' (must be a positive integer), using model default")
+            token_limit = None
+        if search_limit is not None and not (isinstance(search_limit, int) and search_limit > 0):
+            logger.warning(f"Invalid search_limit '{search_limit}' (must be a positive integer), using default 30")
+            search_limit = None
+        if persona_temp is not None and not (isinstance(persona_temp, (int, float)) and 0.0 <= persona_temp <= 2.0):
+            logger.warning(f"Invalid persona_temp '{persona_temp}' (must be a decimal between 0.0 and 2.0), using default 1.0")
+            persona_temp = None
+
         # Get our LLM spun up with defaults if not defined by user input
         # Tokens as integers measure the length of conversation messages
         self.llm = {
@@ -710,6 +817,7 @@ class TelegramBot:
             'chat_model'  : chat_model,
             'url_model'   : url_model,
             'token_limit' : token_limit or TokenLimits(chat_model).max_tokens(),
+            'search_limit': search_limit or 30,
             'temperature' : persona_temp or 1.0,
             'top_p'       : 0.9
         }
@@ -756,6 +864,7 @@ class TelegramBot:
             chat_model     = config['chat_model'],
             url_model      = config['url_model'],
             token_limit    = config['token_limit'],
+            search_limit   = config['search_limit'],
             persona_temp   = config['persona_temp'],
             persona_prompt = prompt,
             key_status     = key_status,

{tellmgrambot-3.9.1 → tellmgrambot-3.10.0}/TeLLMgramBot/conversation.py

@@ -105,6 +105,30 @@ class Conversation:
         )
         self.set_system_content(new_content)
 
+    def update_current_user(self, first_name: str | None, last_name: str | None, username: str | None) -> None:
+        """
+        Refresh the 'Current user:' line in the active system prompt.
+
+        Called on every incoming message so the LLM always knows who it is talking to,
+        enabling it to use the correct name in speaker_query without asking the user.
+
+        Args:
+            first_name: Telegram first name of the current user, may be None.
+            last_name: Telegram last name of the current user, may be None.
+            username: Telegram @handle (without @) of the current user, may be None.
+        """
+        name = ' '.join(filter(None, [first_name, last_name]))
+        if username:
+            label = f"{name} (@{username})" if name else f"@{username}"
+        else:
+            label = name or "unknown"
+        new_content = re.sub(
+            r'\nCurrent user:.*',
+            f'\nCurrent user: {label}',
+            self.system_content,
+        )
+        self.set_system_content(new_content)
+
     async def add_user_message(
         self,
         content: str,

{tellmgrambot-3.9.1 → 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
@@ -466,11 +474,15 @@ async def search_messages(
     chat_query: Optional[str] = None,
     date_from: Optional[str] = None,
     date_to: Optional[str] = None,
-    limit: int = 20,
+    limit: int = 30,
 ) -> list[dict] | dict:
     """
     Search message history across accessible chats with optional filters.
 
+    All filters (content_query, speaker_query, chat_query, date_from, date_to) are
+    optional. If all filters are omitted, returns recent messages from all accessible
+    chats, ordered most-recent-first. Filters are combined as AND conditions.
+
     Resolves speaker_query and chat_query using exact-match-first logic:
     1. Case-insensitive exact match - if exactly one entity matches, proceed.
     2. Partial LIKE match - if exactly one accessible entity matches, proceed.
@@ -483,15 +495,15 @@ async def search_messages(
 
     Args:
         accessible_chat_ids: Chat IDs the caller is allowed to search within.
-        content_query: Text to search for in message content (LIKE match).
+        content_query: Text to search for in message content (LIKE match). Optional.
         speaker_query: Name or @handle to resolve to a set of user_ids. Exact match
-                       is tried first; falls back to LIKE. Leading `@` stripped.
+                       is tried first; falls back to LIKE. Leading `@` stripped. Optional.
         chat_query: Chat title to resolve to a set of chat_ids. Exact match tried first;
                     falls back to LIKE. Zero global matches fall back to all accessible.
-                    If a matching chat is found but not accessible, returns empty.
-        date_from: ISO date string (YYYY-MM-DD) for start of range (inclusive).
-        date_to: ISO date string (YYYY-MM-DD) for end of range (inclusive).
-        limit: Maximum number of results to return (default 20).
+                    If a matching chat is found but not accessible, returns empty. Optional.
+        date_from: ISO date string (YYYY-MM-DD) for start of range (inclusive). Optional.
+        date_to: ISO date string (YYYY-MM-DD) for end of range (inclusive). Optional.
+        limit: Maximum number of results to return (default 30).
 
     Returns:
         List of result dicts with keys: speaker, chat, chat_id, content, timestamp (normal case).
@@ -501,8 +513,6 @@ async def search_messages(
         and a 'message' string for the LLM to surface as a disambiguation prompt.
         Ordered by created_at DESC (most recent first).
     """
-    if not content_query and not speaker_query:
-        return []
     if not accessible_chat_ids:
         return []
 
@@ -694,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.
@@ -752,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.1 → tellmgrambot-3.10.0}/TeLLMgramBot/initialize.py

@@ -101,12 +101,14 @@ INIT_BOT_CONFIG = {
     'chat_model': 'gpt-5-mini',
     'url_model': 'gpt-5',
     'token_limit': None,
+    'search_limit': None,
     'persona_temp': None,
     'persona_prompt': 'You are a generic test bot powered by a user-configured LLM.'
 }
 
 INIT_BOT_CONFIG_COMMENTS = {
     'token_limit': '# Optional, overrides the chat_model\'s default max token limit',
+    'search_limit': '# Optional, max results returned by message search (default: 30)',
     'persona_temp': '# Optional, LLM temperature 0.0-2.0 (default: model\'s default)',
 }
 
@@ -119,9 +121,10 @@ _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"
-    "- Decline requests to set a timezone; explain UTC is always used.\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"
 )
 
 def init_logging(log_name: str = 'tellmgrambot'):
@@ -393,7 +396,8 @@ def init_bot_config(file: str = 'config.yaml') -> dict:
         for parameter, value in INIT_BOT_CONFIG.items():
             if parameter != 'persona_prompt' and parameter not in config:
                 config[parameter] = value
-                logger.warning(f"Configuration '{parameter}' not defined, set to '{value}'")
+                if value is not None:
+                    logger.warning(f"Configuration '{parameter}' not defined, set to '{value}'")
         return config
     except KeyError:
         sys.exit(f"{env_var} must be defined to create file '{file}'! Exiting...")

{tellmgrambot-3.9.1 → 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.1 → tellmgrambot-3.10.0}/TeLLMgramBot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TeLLMgramBot
-Version: 3.9.1
+Version: 3.10.0
 Summary: LLM-powered Telegram bot (OpenAI + Anthropic)
 Home-page: https://github.com/Digital-Heresy/TeLLMgramBot
 Author: Digital Heresy
@@ -43,8 +43,8 @@ The basic goal of this project is to create a bridge between a Telegram Bot and
   * Example: "What do you think of this article? [https://some_site/article]"
   * 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?"
-  * 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). Chat title queries support colloquial terms like "DMs" (falls back to all accessible chats if no exact match is found).
+  * 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). 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.
@@ -77,6 +77,7 @@ When initializing TeLLMgramBot, the following directories get created:
     * `chat_model` - the model used for normal conversation (e.g. `gpt-5-mini` or `claude-sonnet-4-6`).
     * `url_model` - the model used to read and summarize URL content, can differ from `chat_model`.
     * An empty `token_limit` will use the maximum tokens supported by the `chat_model`.
+    * `search_limit` - optional; maximum number of message history search results returned (default: 30). When the user asks "show me recent messages" or searches message history via natural language, this limits the number of results. Omit to use the default.
   * `models.yaml`
     * Contains token size parameters for all supported models.
     * On first run, GPT and Claude model families are pre-populated. Additional models can be added manually.
@@ -85,7 +86,7 @@ When initializing TeLLMgramBot, the following directories get created:
       * A sample prompt file defining the bot's personality: generic, helpful, and multi-provider-aware.
       * The prompt emphasizes the bot's ability to fetch and analyze URLs passed in square brackets `[]`.
       * The user can create more prompt files as needed for different personalities.
-      * At initialization, the bot automatically appends framework-owned behavioral guidance (system appendix) to teach the LLM how cross-chat memory works (cross-pollination, private mode, shared group context) without requiring persona authors to include this guidance.
+      * At initialization, the bot automatically appends framework-owned behavioral guidance (system appendix) to teach the LLM how cross-chat memory works (cross-pollination, private mode, shared group context) without requiring persona authors to include this guidance. The appendix includes two framework-managed injectable values: the current UTC datetime and the current user identity, refreshed on every message so the LLM always has accurate context.
     * `url_analysis.prmpt`
       * Prompt template used to analyze URL content passed in brackets `[]`.
 * `logs`
@@ -153,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.
 
@@ -185,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.1 → tellmgrambot-3.10.0}/setup.py

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