TeLLMgramBot 3.9.2__tar.gz → 3.10.1__tar.gz

tellmgrambot-3.10.1/PKG-INFO

@@ -0,0 +1,174 @@
+Metadata-Version: 2.4
+Name: TeLLMgramBot
+Version: 3.10.1
+Summary: LLM-powered Telegram bot (OpenAI + Anthropic)
+Home-page: https://github.com/Digital-Heresy/TeLLMgramBot
+Author: Digital Heresy
+Author-email: ronin.atx@gmail.com
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai>2.0
+Requires-Dist: anthropic>=0.40
+Requires-Dist: PyYAML
+Requires-Dist: httpx
+Requires-Dist: beautifulsoup4
+Requires-Dist: validators
+Requires-Dist: tiktoken>=0.12
+Requires-Dist: python-telegram-bot>=20.8
+Requires-Dist: aiosqlite>=0.19
+Requires-Dist: tzdata>=2025.2
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# TeLLMgramBot
+The basic goal of this project is to create a bridge between a Telegram Bot and a Large Language Model (LLM), supporting both OpenAI's GPT models and Anthropic's Claude models.
+* To use this library, you must have a Telegram account **with a user name**, not just a phone number. If you don't have one, [create one online](https://telegram.org/).
+* If added to a Telegram group, the bot must be [administrator](https://www.alphr.com/add-admin-telegram/) in order to respond to a user calling out its name, initials, or nickname.
+<img src="assets/TeLLMgramBot_Logo.png" width=200 align=center />
+
+## Telegram Bot + LLM Encapsulation
+* The Telegram interface handles special commands and basic "chatty" responses that don't require an LLM, like "Hello". Dynamic conversations are handed off to the LLM while Telegram acts as the interaction broker.
+* Pass URLs in [square brackets] and mention how the bot should interpret them.
+  * Example: "What do you think of this article? [https://some_site/article]"
+  * Uses a separate model (configurable via `url_model`) to handle larger URL content.
+* Ask questions about message history across all your chats using natural language; the bot will search, attribute messages to speakers, and include messages from other bots.
+  * Example: "Who said thanks for the breakdown?" or "What did George say about the project?" or "Show me the last few messages."
+  * All search filters (speaker, chat, date) are optional. Results are ordered most-recent-first. Configure `search_limit` to control how many results to return (default: 30).
+* Token limits measure conversation length and determine when to prune oldest messages to stay within model limits.
+  * The bot loads the user's full history across all chats up to 50% of the token budget. In private chats, shared group context fills the remaining budget, enabling the bot to reference group conversations from a private context.
+  * This eliminates amnesia when switching between private and group chats.
+* Users can manage privacy via two commands:
+  * `/forget` - In private chats, clears your full conversation and resets all active sessions. In group chats, removes only your messages and cleans up paired bot replies.
+  * `/private` - Toggle private mode (private chats only). When ON, your messages in private chats are excluded from group conversation contexts, enabling selective privacy even in shared groups.
+
+## Why Telegram?
+Using Telegram as the interface not only solves "exposing" the interface, but gives you boatloads of interactivity over a standard Command Line interface, or trying to create a website with input boxes and submit buttons to try to handle everything:
+1. Telegram already lets you paste in verbose, multiline messages.
+2. Telegram already lets you paste in pictures, videos, links, etc.
+3. Telegram already lets you react with emojis, stickers, etc.
+4. Telegram message reactions (👀) provide a lightweight read receipt without breaking conversation flow.
+
+## Supported LLM Providers
+TeLLMgramBot selects the LLM provider automatically based on the model name:
+
+| Model prefix | Provider | Example models |
+|---|---|---|
+| `gpt-` | OpenAI | `gpt-4o`, `gpt-4o-mini`, `gpt-5-mini` |
+| `claude-` | Anthropic | `claude-sonnet-4-6`, `claude-haiku-4-5` |
+
+Simply set `chat_model` (and optionally `url_model`) in your `config.yaml` to any supported model and supply the corresponding API key - no other changes needed.
+
+## Directories
+TeLLMgramBot creates the following directories:
+
+- **`configs`** - Bot configuration and model parameters
+  - `config.yaml` - Bot settings: owner, model names, token limits, search limits, nickname/initials
+  - `models.yaml` - Token limits for each LLM model (pre-populated on first run)
+- **`prompts`** - Bot personas and URL analysis templates
+  - `test_personality.prmpt` - Sample bot personality (multi-provider, can be renamed)
+  - `url_analysis.prmpt` - URL summarization prompt template
+  - A system appendix is automatically appended to every persona at runtime, teaching the LLM about cross-chat memory and search behavior. User messages include speaker annotations with chat context and timestamps so the LLM always knows who is speaking, in which chat, and when.
+- **`logs`** - Bot instance logs (one per startup, e.g. `tellmgrambot_2026-03-29_10-30-45.log`)
+  - Logs include anonymized Telegram IDs for privacy. Console shows INFO-level TeLLMgramBot messages only.
+  - Bot keeps the 10 most recent logs, automatically pruning older ones.
+  - Pass `-v` or `--verbose` on startup for DEBUG-level logging.
+- **`data`** - SQLite database (`conversations.db`) storing all messages, users, and chats
+  - Users manage their data via `/forget` and `/private` commands.
+
+### Environment Variables for Paths
+Override default directory locations by setting these environment variables (useful for containerized deployments):
+
+| Variable | Purpose | Default |
+|----------|---------|---------|
+| `TELLMGRAMBOT_CONFIGS_PATH` | Directory containing `config.yaml` and `models.yaml` | `{exec_dir}/configs` |
+| `TELLMGRAMBOT_PROMPTS_PATH` | Directory containing prompt files | `{exec_dir}/prompts` |
+| `TELLMGRAMBOT_LOGS_PATH` | Directory for log files | `{exec_dir}/logs` |
+| `TELLMGRAMBOT_DATA_PATH` | Directory containing `conversations.db` | `{exec_dir}/data` |
+
+If unset, all paths default to subdirectories of the execution directory (the directory containing your entry-point script).
+
+## API Keys
+TeLLMgramBot supports four API keys, each loadable from environment variables or `.key` files:
+
+| Key | Env Var | File | When required |
+|-----|---------|------|---------------|
+| [OpenAI](https://platform.openai.com/api-keys) | `TELLMGRAMBOT_OPENAI_API_KEY` | `openai.key` | For `gpt-*` models |
+| [Anthropic](https://console.anthropic.com/settings/keys) | `TELLMGRAMBOT_ANTHROPIC_API_KEY` | `anthropic.key` | For `claude-*` models |
+| [Telegram](https://t.me/BotFather) | `TELLMGRAMBOT_TELEGRAM_API_KEY` | `telegram.key` | Always required |
+| [VirusTotal](https://www.virustotal.com/gui/my-apikey) | `TELLMGRAMBOT_VIRUSTOTAL_API_KEY` | `virustotal.key` | For URL analysis |
+
+Missing provider keys (OpenAI or Anthropic) disable chat and URL analysis but allow the bot to start. Missing VirusTotal disables URL analysis. Telegram key is required - the bot will not start without it.
+
+Key files are created in the execution directory (or `TELLMGRAMBOT_KEYS_PATH` for legacy deployments). Alternatively, set environment variables before launching, e.g.:
+```python
+os.environ['TELLMGRAMBOT_OPENAI_API_KEY'] = my_vault.get('openai_key')
+os.environ['TELLMGRAMBOT_ANTHROPIC_API_KEY'] = my_vault.get('anthropic_key')
+os.environ['TELLMGRAMBOT_TELEGRAM_API_KEY'] = my_vault.get('telegram_key')
+os.environ['TELLMGRAMBOT_VIRUSTOTAL_API_KEY'] = my_vault.get('virustotal_key')
+```
+
+## Commands and Interactions
+
+### Available Commands
+- `/nick <name>` - Set your nickname (for bot use in group chats).
+- `/forget` - Clear your conversation history. In private chats, clears everything and resets all active sessions. In group chats, removes only your messages.
+- `/private` - Toggle private mode (private chats only). When ON, your messages are excluded from group context loading.
+- `/help` - Display all available commands and usage information (includes administrator-only commands).
+
+### Group Chat Triggers
+The bot responds in groups when you:
+- Mention the bot by username (e.g., `@botname`)
+- Mention the bot by nickname or initials (configured via `config.yaml`)
+- Reply directly to one of the bot's messages
+
+If a message explicitly @mentions another account, the bot defers with "Looks like that's for @OtherBot!" instead.
+
+The bot also automatically captures and indexes messages from other bots in the group, making them searchable and available as context in private chats. For example, you can ask "What did Bot B say about the project?" and the bot will search across all shared groups.
+
+### Read Receipt (Group Chats Only)
+When triggered and not deferring, the bot immediately sends a 👀 reaction on your message (falls back to "Got it!" on older clients) before generating the full LLM response.
+
+## Bot Setup
+1. Ensure API keys are set up and your Telegram bot is created via BotFather.
+2. Install TeLLMgramBot: `pip install TeLLMgramBot`
+3. Configure the bot via `config.yaml` (created on first run):
+   - `bot_owner`: Your Telegram username (required, no `@`)
+   - `chat_model`: LLM model for conversation (e.g. `gpt-4o-mini` or `claude-sonnet-4-6`)
+   - `url_model`: LLM model for URL analysis (e.g. `gpt-4o` or `claude-haiku-4-5`)
+   - `bot_nickname` / `bot_initials`: Names the bot responds to in groups
+   - `token_limit`: Max tokens (optional; defaults to model's maximum)
+   - `search_limit`: Max search results (optional; defaults to 30)
+4. **Disable group privacy mode in BotFather:**
+   ```
+   /setprivacy -> select your bot -> Disable
+   ```
+   With privacy mode enabled (default), the bot won't receive group messages that don't mention it, so it can't index other bots or load cross-chat context.
+5. Run the bot:
+   ```python
+   from TeLLMgramBot import TelegramBot
+   telegram_bot = TelegramBot.set()
+   telegram_bot.start_polling()
+   ```
+   Once you see `TeLLMgramBot polling...`, the bot is online.
+6. Type `/help` in Telegram to see 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.
+* For more information on OpenAI models and token limits:
+  * [OpenAI model overview and maximum tokens](https://platform.openai.com/docs/models)
+  * [OpenAI message conversion to tokens](https://github.com/openai/openai-python)
+  * [OpenAI custom fine-tuning](https://platform.openai.com/docs/guides/model-optimization)
+  * [OpenAI's tiktoken library](https://github.com/openai/tiktoken/tree/main)
+* For more information on Anthropic Claude models:
+  * [Anthropic model overview and context windows](https://docs.anthropic.com/en/docs/about-claude/models)
+  * [Anthropic Python SDK](https://github.com/anthropic/anthropic-sdk-python)

tellmgrambot-3.10.1/README.md

@@ -0,0 +1,142 @@
+# TeLLMgramBot
+The basic goal of this project is to create a bridge between a Telegram Bot and a Large Language Model (LLM), supporting both OpenAI's GPT models and Anthropic's Claude models.
+* To use this library, you must have a Telegram account **with a user name**, not just a phone number. If you don't have one, [create one online](https://telegram.org/).
+* If added to a Telegram group, the bot must be [administrator](https://www.alphr.com/add-admin-telegram/) in order to respond to a user calling out its name, initials, or nickname.
+<img src="assets/TeLLMgramBot_Logo.png" width=200 align=center />
+
+## Telegram Bot + LLM Encapsulation
+* The Telegram interface handles special commands and basic "chatty" responses that don't require an LLM, like "Hello". Dynamic conversations are handed off to the LLM while Telegram acts as the interaction broker.
+* Pass URLs in [square brackets] and mention how the bot should interpret them.
+  * Example: "What do you think of this article? [https://some_site/article]"
+  * Uses a separate model (configurable via `url_model`) to handle larger URL content.
+* Ask questions about message history across all your chats using natural language; the bot will search, attribute messages to speakers, and include messages from other bots.
+  * Example: "Who said thanks for the breakdown?" or "What did George say about the project?" or "Show me the last few messages."
+  * All search filters (speaker, chat, date) are optional. Results are ordered most-recent-first. Configure `search_limit` to control how many results to return (default: 30).
+* Token limits measure conversation length and determine when to prune oldest messages to stay within model limits.
+  * The bot loads the user's full history across all chats up to 50% of the token budget. In private chats, shared group context fills the remaining budget, enabling the bot to reference group conversations from a private context.
+  * This eliminates amnesia when switching between private and group chats.
+* Users can manage privacy via two commands:
+  * `/forget` - In private chats, clears your full conversation and resets all active sessions. In group chats, removes only your messages and cleans up paired bot replies.
+  * `/private` - Toggle private mode (private chats only). When ON, your messages in private chats are excluded from group conversation contexts, enabling selective privacy even in shared groups.
+
+## Why Telegram?
+Using Telegram as the interface not only solves "exposing" the interface, but gives you boatloads of interactivity over a standard Command Line interface, or trying to create a website with input boxes and submit buttons to try to handle everything:
+1. Telegram already lets you paste in verbose, multiline messages.
+2. Telegram already lets you paste in pictures, videos, links, etc.
+3. Telegram already lets you react with emojis, stickers, etc.
+4. Telegram message reactions (👀) provide a lightweight read receipt without breaking conversation flow.
+
+## Supported LLM Providers
+TeLLMgramBot selects the LLM provider automatically based on the model name:
+
+| Model prefix | Provider | Example models |
+|---|---|---|
+| `gpt-` | OpenAI | `gpt-4o`, `gpt-4o-mini`, `gpt-5-mini` |
+| `claude-` | Anthropic | `claude-sonnet-4-6`, `claude-haiku-4-5` |
+
+Simply set `chat_model` (and optionally `url_model`) in your `config.yaml` to any supported model and supply the corresponding API key - no other changes needed.
+
+## Directories
+TeLLMgramBot creates the following directories:
+
+- **`configs`** - Bot configuration and model parameters
+  - `config.yaml` - Bot settings: owner, model names, token limits, search limits, nickname/initials
+  - `models.yaml` - Token limits for each LLM model (pre-populated on first run)
+- **`prompts`** - Bot personas and URL analysis templates
+  - `test_personality.prmpt` - Sample bot personality (multi-provider, can be renamed)
+  - `url_analysis.prmpt` - URL summarization prompt template
+  - A system appendix is automatically appended to every persona at runtime, teaching the LLM about cross-chat memory and search behavior. User messages include speaker annotations with chat context and timestamps so the LLM always knows who is speaking, in which chat, and when.
+- **`logs`** - Bot instance logs (one per startup, e.g. `tellmgrambot_2026-03-29_10-30-45.log`)
+  - Logs include anonymized Telegram IDs for privacy. Console shows INFO-level TeLLMgramBot messages only.
+  - Bot keeps the 10 most recent logs, automatically pruning older ones.
+  - Pass `-v` or `--verbose` on startup for DEBUG-level logging.
+- **`data`** - SQLite database (`conversations.db`) storing all messages, users, and chats
+  - Users manage their data via `/forget` and `/private` commands.
+
+### Environment Variables for Paths
+Override default directory locations by setting these environment variables (useful for containerized deployments):
+
+| Variable | Purpose | Default |
+|----------|---------|---------|
+| `TELLMGRAMBOT_CONFIGS_PATH` | Directory containing `config.yaml` and `models.yaml` | `{exec_dir}/configs` |
+| `TELLMGRAMBOT_PROMPTS_PATH` | Directory containing prompt files | `{exec_dir}/prompts` |
+| `TELLMGRAMBOT_LOGS_PATH` | Directory for log files | `{exec_dir}/logs` |
+| `TELLMGRAMBOT_DATA_PATH` | Directory containing `conversations.db` | `{exec_dir}/data` |
+
+If unset, all paths default to subdirectories of the execution directory (the directory containing your entry-point script).
+
+## API Keys
+TeLLMgramBot supports four API keys, each loadable from environment variables or `.key` files:
+
+| Key | Env Var | File | When required |
+|-----|---------|------|---------------|
+| [OpenAI](https://platform.openai.com/api-keys) | `TELLMGRAMBOT_OPENAI_API_KEY` | `openai.key` | For `gpt-*` models |
+| [Anthropic](https://console.anthropic.com/settings/keys) | `TELLMGRAMBOT_ANTHROPIC_API_KEY` | `anthropic.key` | For `claude-*` models |
+| [Telegram](https://t.me/BotFather) | `TELLMGRAMBOT_TELEGRAM_API_KEY` | `telegram.key` | Always required |
+| [VirusTotal](https://www.virustotal.com/gui/my-apikey) | `TELLMGRAMBOT_VIRUSTOTAL_API_KEY` | `virustotal.key` | For URL analysis |
+
+Missing provider keys (OpenAI or Anthropic) disable chat and URL analysis but allow the bot to start. Missing VirusTotal disables URL analysis. Telegram key is required - the bot will not start without it.
+
+Key files are created in the execution directory (or `TELLMGRAMBOT_KEYS_PATH` for legacy deployments). Alternatively, set environment variables before launching, e.g.:
+```python
+os.environ['TELLMGRAMBOT_OPENAI_API_KEY'] = my_vault.get('openai_key')
+os.environ['TELLMGRAMBOT_ANTHROPIC_API_KEY'] = my_vault.get('anthropic_key')
+os.environ['TELLMGRAMBOT_TELEGRAM_API_KEY'] = my_vault.get('telegram_key')
+os.environ['TELLMGRAMBOT_VIRUSTOTAL_API_KEY'] = my_vault.get('virustotal_key')
+```
+
+## Commands and Interactions
+
+### Available Commands
+- `/nick <name>` - Set your nickname (for bot use in group chats).
+- `/forget` - Clear your conversation history. In private chats, clears everything and resets all active sessions. In group chats, removes only your messages.
+- `/private` - Toggle private mode (private chats only). When ON, your messages are excluded from group context loading.
+- `/help` - Display all available commands and usage information (includes administrator-only commands).
+
+### Group Chat Triggers
+The bot responds in groups when you:
+- Mention the bot by username (e.g., `@botname`)
+- Mention the bot by nickname or initials (configured via `config.yaml`)
+- Reply directly to one of the bot's messages
+
+If a message explicitly @mentions another account, the bot defers with "Looks like that's for @OtherBot!" instead.
+
+The bot also automatically captures and indexes messages from other bots in the group, making them searchable and available as context in private chats. For example, you can ask "What did Bot B say about the project?" and the bot will search across all shared groups.
+
+### Read Receipt (Group Chats Only)
+When triggered and not deferring, the bot immediately sends a 👀 reaction on your message (falls back to "Got it!" on older clients) before generating the full LLM response.
+
+## Bot Setup
+1. Ensure API keys are set up and your Telegram bot is created via BotFather.
+2. Install TeLLMgramBot: `pip install TeLLMgramBot`
+3. Configure the bot via `config.yaml` (created on first run):
+   - `bot_owner`: Your Telegram username (required, no `@`)
+   - `chat_model`: LLM model for conversation (e.g. `gpt-4o-mini` or `claude-sonnet-4-6`)
+   - `url_model`: LLM model for URL analysis (e.g. `gpt-4o` or `claude-haiku-4-5`)
+   - `bot_nickname` / `bot_initials`: Names the bot responds to in groups
+   - `token_limit`: Max tokens (optional; defaults to model's maximum)
+   - `search_limit`: Max search results (optional; defaults to 30)
+4. **Disable group privacy mode in BotFather:**
+   ```
+   /setprivacy -> select your bot -> Disable
+   ```
+   With privacy mode enabled (default), the bot won't receive group messages that don't mention it, so it can't index other bots or load cross-chat context.
+5. Run the bot:
+   ```python
+   from TeLLMgramBot import TelegramBot
+   telegram_bot = TelegramBot.set()
+   telegram_bot.start_polling()
+   ```
+   Once you see `TeLLMgramBot polling...`, the bot is online.
+6. Type `/help` in Telegram to see 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.
+* For more information on OpenAI models and token limits:
+  * [OpenAI model overview and maximum tokens](https://platform.openai.com/docs/models)
+  * [OpenAI message conversion to tokens](https://github.com/openai/openai-python)
+  * [OpenAI custom fine-tuning](https://platform.openai.com/docs/guides/model-optimization)
+  * [OpenAI's tiktoken library](https://github.com/openai/tiktoken/tree/main)
+* For more information on Anthropic Claude models:
+  * [Anthropic model overview and context windows](https://docs.anthropic.com/en/docs/about-claude/models)
+  * [Anthropic Python SDK](https://github.com/anthropic/anthropic-sdk-python)

{tellmgrambot-3.9.2 → tellmgrambot-3.10.1}/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."
     ),
@@ -52,8 +61,8 @@ _SEARCH_TOOL = {
             "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. 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"},
+            "date_from": {"type": "string", "description": "Start of time range as ISO datetime (YYYY-MM-DDTHH:MM). For a full day, use T00:00."},
+            "date_to": {"type": "string", "description": "End of time range as ISO datetime (YYYY-MM-DDTHH:MM). For a full day, use T23:59."},
         },
         "required": [],
     },
@@ -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.
@@ -286,9 +308,8 @@ class TelegramBot:
 
         conv = self.conversations[chat_id]
 
-        # Refresh datetime and current user identity on every message
+        # Refresh datetime on every message
         conv.update_datetime()
-        conv.update_current_user(first_name, last_name, username)
 
         token_budget = floor(self.llm['prune_threshold'] / 2)
 
@@ -360,6 +381,30 @@ 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
+        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=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 +463,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 +477,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 +488,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 +533,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 +715,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 +790,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))