TeLLMgramBot 3.10.1__tar.gz → 3.10.2__tar.gz

{tellmgrambot-3.10.1 → tellmgrambot-3.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TeLLMgramBot
-Version: 3.10.1
+Version: 3.10.2
 Summary: LLM-powered Telegram bot (OpenAI + Anthropic)
 Home-page: https://github.com/Digital-Heresy/TeLLMgramBot
 Author: Digital Heresy
@@ -72,7 +72,7 @@ Simply set `chat_model` (and optionally `url_model`) in your `config.yaml` to an
 TeLLMgramBot creates the following directories:
 
 - **`configs`** - Bot configuration and model parameters
-  - `config.yaml` - Bot settings: owner, model names, token limits, search limits, nickname/initials
+  - `config.yaml` - Bot settings: owner, model names, token limits, search limits, nickname/initials, database name
   - `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)
@@ -82,7 +82,7 @@ TeLLMgramBot creates the following directories:
   - 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
+- **`data`** - SQLite database (default `conversations.db`, customizable via `db_name` config) storing all messages, users, and chats
   - Users manage their data via `/forget` and `/private` commands.
 
 ### Environment Variables for Paths
@@ -133,10 +133,11 @@ The bot responds in groups when you:
 
 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.
+### Private Chat Behavior
+In private chats, the bot responds to all your messages. If you reply to an earlier message in the conversation that is not already in the bot's context window, that message is automatically surfaced as inline context so the bot can understand the full conversation thread.
 
 ### 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.
+When the bot is triggered in a group and about to respond (not deferring to another bot), it immediately sends a 👀 emoji reaction on your message as a read receipt acknowledgement (falls back to "Got it!" text reply on older Telegram clients). This confirmation arrives before the full LLM response, providing quick feedback that the bot received your message.
 
 ## Bot Setup
 1. Ensure API keys are set up and your Telegram bot is created via BotFather.
@@ -146,6 +147,7 @@ When triggered and not deferring, the bot immediately sends a 👀 reaction on y
    - `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
+   - `db_name`: Optional custom database filename without extension (e.g. `MyBot` creates `MyBot.db`); omit for default `conversations.db`. Use distinct names when running multiple bot instances in the same directory.
    - `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:**

{tellmgrambot-3.10.1 → tellmgrambot-3.10.2}/README.md

@@ -40,7 +40,7 @@ Simply set `chat_model` (and optionally `url_model`) in your `config.yaml` to an
 TeLLMgramBot creates the following directories:
 
 - **`configs`** - Bot configuration and model parameters
-  - `config.yaml` - Bot settings: owner, model names, token limits, search limits, nickname/initials
+  - `config.yaml` - Bot settings: owner, model names, token limits, search limits, nickname/initials, database name
   - `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)
@@ -50,7 +50,7 @@ TeLLMgramBot creates the following directories:
   - 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
+- **`data`** - SQLite database (default `conversations.db`, customizable via `db_name` config) storing all messages, users, and chats
   - Users manage their data via `/forget` and `/private` commands.
 
 ### Environment Variables for Paths
@@ -101,10 +101,11 @@ The bot responds in groups when you:
 
 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.
+### Private Chat Behavior
+In private chats, the bot responds to all your messages. If you reply to an earlier message in the conversation that is not already in the bot's context window, that message is automatically surfaced as inline context so the bot can understand the full conversation thread.
 
 ### 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.
+When the bot is triggered in a group and about to respond (not deferring to another bot), it immediately sends a 👀 emoji reaction on your message as a read receipt acknowledgement (falls back to "Got it!" text reply on older Telegram clients). This confirmation arrives before the full LLM response, providing quick feedback that the bot received your message.
 
 ## Bot Setup
 1. Ensure API keys are set up and your Telegram bot is created via BotFather.
@@ -114,6 +115,7 @@ When triggered and not deferring, the bot immediately sends a 👀 reaction on y
    - `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
+   - `db_name`: Optional custom database filename without extension (e.g. `MyBot` creates `MyBot.db`); omit for default `conversations.db`. Use distinct names when running multiple bot instances in the same directory.
    - `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:**

{tellmgrambot-3.10.1 → tellmgrambot-3.10.2}/TeLLMgramBot/TeLLMgramBot.py

@@ -23,7 +23,8 @@ from .database import (
     delete_private_messages_for_user,
     delete_bot_replies_for_user,
     get_shared_group_chat_ids,
-    prune_foreign_bot_messages,
+    message_id_exists,
+    update_message_tg_id,
     search_messages,
     upsert_chat,
     upsert_user,
@@ -43,8 +44,6 @@ from .utils import exact_word_match, log_error
 
 logger = logging.getLogger(__name__)
 
-_FOREIGN_BOT_MESSAGE_CAP = 50
-
 _SEARCH_TOOL = {
     "name": "search_messages",
     "description": (
@@ -68,6 +67,7 @@ _SEARCH_TOOL = {
     },
 }
 
+
 class TelegramBot:
     """
     The bridge between the Telegram interface and a Large Language Model (LLM).
@@ -75,6 +75,7 @@ class TelegramBot:
     - URLs in [square brackets] can be supplied on how the bot should interpret it.
     - For more information, see README or: https://github.com/Digital-Heresy/TeLLMgramBot
     """
+
     async def _tele_info(self):
         """Fetch the Telegram bot's information before running application."""
         try:
@@ -131,7 +132,6 @@ class TelegramBot:
         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):
@@ -149,7 +149,8 @@ class TelegramBot:
         result = pattern.search(msg.text or "")
         if result:
             prompt = f"Please refer to me by my nickname, {result.group(1).strip()}, rather than my user name."
-            await msg.reply_text(await self.tele_handle_response(prompt, msg))
+            response, _ = await self.tele_handle_response(prompt, msg)
+            await msg.reply_text(response)
         else:
             await msg.reply_text("Please provide a valid nickname after the command like \"/nick B0b #2\".")
 
@@ -248,7 +249,7 @@ class TelegramBot:
                 "from group conversation contexts. Use /private off to disable."
             )
 
-    async def tele_handle_response(self, text: str, msg: Message) -> str:
+    async def tele_handle_response(self, text: str, msg: Message, context_prefix: str = '') -> tuple[str, int | None]:
         """
         Primary function for handling any response including Generative AI, ensuring:
         - The owner started up the bot assistant for user interactions.
@@ -267,10 +268,14 @@ class TelegramBot:
         Args:
             text: The user's message text.
             msg: The Telegram Message object containing chat/user context.
+            context_prefix: Optional context prepended to the message before the live
+                           speaker annotation. Used for reply-to-thread context. Defaults to ''.
 
         Returns:
-            The bot's response string. If no handler matches or features are disabled,
-            returns a generic error message.
+            Tuple of (response_text, assistant_db_id). response_text is the bot's response
+            string (or generic error if no handler matches or features are disabled).
+            assistant_db_id is the database row id of the stored assistant message,
+            or None if the bot is offline.
 
         Side Effects:
             - Adds user message to conversation history (keyed by chat_id).
@@ -280,10 +285,11 @@ class TelegramBot:
             - Generates a token warning if conversation nears the limit.
             - Prunes conversation if token count exceeds the threshold.
             - Stores bot's response with bot identity and reply_to_id for tracking.
+            - Returns assistant_db_id so the caller can update tg_message_id after Telegram send completes.
         """
         # Starting ensures we get some kind of user account details for logging
         if not self._online:
-            return "I'd love to chat, but I am offline at the moment!"
+            return "I'd love to chat, but I am offline at the moment!", None
 
         # Extract identity and context from the message
         user_id    = msg.from_user.id
@@ -322,12 +328,17 @@ class TelegramBot:
             # Already loaded - check for new cross-chat messages since last load.
             await conv.refresh_user_context(user_id, token_budget)
 
+        # Short-circuit for trivial greetings/queries - not persisted to conversation history
+        quick_reply = handle_greetings(text) or handle_common_queries(text)
+        if quick_reply:
+            return quick_reply, None
+
         # Add the user's message to our conversation, respecting private mode
         # Private mode only applies in private chats - group messages are never flagged private
         user_private_mode = await get_private_mode(user_id)
         is_private = (chat_type == 'private') and user_private_mode
         user_msg_id = await conv.add_user_message(
-            text, user_id, username, first_name, last_name, is_private
+            text, user_id, username, first_name, last_name, is_private, context_prefix, msg.message_id
         )
 
         # Check if the user is asking about a [URL]
@@ -335,11 +346,7 @@ class TelegramBot:
 
         # Form the assistant's message based on low level easy stuff or send to the LLM
         reply = "Sorry, I couldn't process your message! Please contact my creator."
-        if handle_greetings(text):
-            reply = handle_greetings(text)
-        elif handle_common_queries(text):
-            reply = handle_common_queries(text)
-        elif url_match and self.key_status.url_analysis_enabled:
+        if url_match and self.key_status.url_analysis_enabled:
             await msg.reply_text("Sure, give me a moment to look at that URL...")
             reply = await handle_url_ask(text, self.llm['url_model'])
         elif self._online and self.key_status.chat_enabled:
@@ -364,7 +371,7 @@ class TelegramBot:
         # Add the full reply (including any warning) to the conversation.
         # Propagate is_private so bot replies in private-mode exchanges are also excluded
         # from group context loading - otherwise the assistant's half of the conversation leaks.
-        await conv.add_assistant_message(
+        assistant_db_id = await conv.add_assistant_message(
             reply,
             self.telegram['bot_id'],
             self.telegram['username'],
@@ -379,31 +386,59 @@ class TelegramBot:
         if token_count > self.llm['prune_threshold']:
             await conv.prune_conversation(self.llm['prune_back_to'])
 
-        return reply
+        return reply, assistant_db_id
 
-    async def _store_foreign_bot_message(self, msg: Message, chat: Chat) -> None:
+    async def _build_reply_context(self, msg: Message) -> str:
         """
-        Persist a group message from another bot to the database.
+        Build an inline context prefix when the user is replying to another message.
+
+        Used to surface context when the triggering message is a reply-to another message
+        not already in the conversation's memory window. Returns an annotated prefix string
+        with speaker name and timestamp if the replied-to message is not in context, or an
+        empty string if already present.
 
-        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.
+        Uses a two-tier check to avoid redundant prepends:
+        1. Memory - reply_to_message.message_id in conv._loaded_message_ids (O(1)).
+           In-session bot replies are added here immediately after each send.
+        2. DB fallback - query for tg_message_id in the messages table.
+           Cross-session bot replies are findable here since tg_message_id is now
+           stored for assistant messages after each send.
+
+        Fires in all chat types (group and private) when reply_to_message exists and has text.
+        Correctly re-surfaces bot messages that are no longer in context (e.g. post-/forget).
 
         Args:
-            msg: The incoming Telegram Message from the foreign bot.
-            chat: The group chat the message was sent in.
+            msg: The incoming Telegram Message that triggered the bot.
+
+        Returns:
+            Formatted prefix string, e.g.
+            "[BotB, 2026-04-05 14:30 UTC]: The ancient sword was forged in...\n"
+            or empty string if the replied-to message is already in context.
         """
-        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)
+        reply = msg.reply_to_message
+        if not reply or not reply.text or not reply.from_user:
+            return ''
+
+        r_tg_id = reply.message_id
+
+        # Tier 1: memory check
+        conv = self.conversations.get(msg.chat.id)
+        if conv and r_tg_id in conv._loaded_message_ids:
+            return ''
+
+        # Tier 2: DB fallback
+        if await message_id_exists(msg.chat.id, r_tg_id):
+            return ''
+
+        # Not in context - build the annotated prefix and mark the ID as seen so
+        # subsequent replies to the same foreign message skip the prepend.
+        if conv:
+            conv._loaded_message_ids.add(r_tg_id)
+        sender = reply.from_user
+        name_parts = [p for p in [sender.first_name, sender.last_name] if p]
+        name = ' '.join(name_parts) if name_parts else (sender.username or 'unknown')
+        dt = format_dt(reply.date)
+        return f"[Replying to {name}, {dt}]: {reply.text}\n"
 
     def _foreign_bot_mention(self, msg: Message) -> str | None:
         """
@@ -463,22 +498,21 @@ class TelegramBot:
         """
         Route incoming Telegram messages to appropriate handlers based on chat type and trigger conditions.
 
-        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:
+        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)
         - User directly replies to one of the bot's messages (Telegram reply-to feature)
 
-        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 (Telegram does not deliver bot-to-bot DMs).
 
+        When the triggering message is itself a reply to a non-bot message not already in context,
+        the replied-to message is prepended as inline context for the LLM via _build_reply_context().
+        This applies to both group and private chat contexts.
+
+        In all group matching scenarios, a read receipt acknowledgement (👀 reaction or "Got it!" fallback)
+        is sent immediately via _send_read_receipt() before generating the full LLM response.
+
         Args:
             update: The Telegram Update object containing the incoming message.
             context: The Telegram context for sending replies.
@@ -488,44 +522,15 @@ 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)
+        # Ignore messages from other bots in group chats - no response or storage needed.
+        if user.is_bot and user.id != self.telegram['bot_id'] and chat.type in ('group', 'supergroup'):
             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."
+        assistant_db_id = None
+        reply_context = ''
         if chat.type == 'supergroup' or chat.type == 'group':
             is_reply_to_bot = (
                 msg.reply_to_message is not None and
@@ -537,8 +542,9 @@ class TelegramBot:
                 # 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()
+                reply_context = await self._build_reply_context(msg)
                 await self._send_read_receipt(msg, context)
-                response = await self.tele_handle_response(new_text, msg)
+                response, assistant_db_id = await self.tele_handle_response(new_text, msg, reply_context)
             elif (
                 exact_word_match(self.telegram['nickname'], msg.text) or
                 exact_word_match(self.telegram['initials'], msg.text) or
@@ -550,19 +556,36 @@ class TelegramBot:
                 if foreign:
                     await msg.reply_text(f"Looks like that message is for {foreign}!")
                     return
+                reply_context = await self._build_reply_context(msg)
                 await self._send_read_receipt(msg, context)
-                response = await self.tele_handle_response(msg.text, msg)
+                response, assistant_db_id = await self.tele_handle_response(msg.text, msg, reply_context)
             else:
                 return
         elif chat.type == 'private':
-            response = await self.tele_handle_response(msg.text, msg)
+            reply_context = await self._build_reply_context(msg)
+            response, assistant_db_id = await self.tele_handle_response(msg.text, msg, reply_context)
         else:
             return
 
         # Split into smaller chunks since Telegram messages have a maximum text length (likely 4096)
         chunk_length = MessageLimit.MAX_TEXT_LENGTH - 1
-        for chunk in [response[i:i+chunk_length] for i in range(0, len(response), chunk_length)]:
-            await msg.reply_text(chunk)
+        chunks = [response[i:i+chunk_length] for i in range(0, len(response), chunk_length)]
+        conv = self.conversations.get(msg.chat.id)
+        # If reply context was surfaced on the first interaction (conv was None when
+        # _build_reply_context ran), record the ID now that the conversation exists.
+        if conv and reply_context and msg.reply_to_message:
+            conv._loaded_message_ids.add(msg.reply_to_message.message_id)
+        for chunk in chunks:
+            sent = await msg.reply_text(chunk)
+            if sent:
+                if conv:
+                    conv._loaded_message_ids.add(sent.message_id)
+                # Persist this chunk's Telegram message ID on the assistant row.
+                # Each call overwrites the previous, so only the last chunk's ID is
+                # retained for cross-session tier 2 dedup. Tier 1 covers all chunks
+                # in-session via _loaded_message_ids.
+                if assistant_db_id:
+                    await update_message_tg_id(assistant_db_id, sent.message_id)
             await asyncio.sleep(0.12)  # small pause to reduce risk of rate limiting
 
     async def tele_validate(self, update: Update) -> tuple[Message, Chat, User] | None:
@@ -715,10 +738,7 @@ 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'],
-            allowed_updates=Update.ALL_TYPES,
-        )
+        self.telegram['app'].run_polling(poll_interval=self.telegram['pollinterval'])
         logger.info(f"TeLLMgramBot {self.telegram['username']} polling ended.")
 
     # Initialization

{tellmgrambot-3.10.1 → tellmgrambot-3.10.2}/TeLLMgramBot/conversation.py

@@ -30,6 +30,7 @@ logger = logging.getLogger(__name__)
 # already fills nearly the entire budget.
 MIN_GROUP_CONTEXT_TOKENS = 500
 
+
 class Conversation:
     """
     Manages a chat conversation including message history, token counting, and SQLite persistence.
@@ -38,6 +39,7 @@ class Conversation:
     Works with any LLM provider (OpenAI, Anthropic). When the token limit is approached, oldest
     messages are pruned from memory; the database retains the full history.
     """
+
     def __init__(
         self,
         chat_id: int,
@@ -81,6 +83,13 @@ class Conversation:
         # touching the database. Cleared on purge or clear_interaction().
         self._private_message_ids: set[int] = set()
 
+        # Set of Telegram message IDs (tg_message_id) present in the loaded context.
+        # Populated by get_past_interaction() and refresh_user_context() from DB rows,
+        # and by add_user_message() for live session messages. Used as the memory-tier
+        # check before prepending reply-to-thread context: if reply_to_message.message_id
+        # is in this set, the message is already in context and no prepend is needed.
+        self._loaded_message_ids: set[int] = set()
+
     def set_system_content(self, new_content: str):
         """
         Replace the system content (bot's personality prompt) in the conversation.
@@ -143,6 +152,8 @@ class Conversation:
         first_name: str | None = None,
         last_name: str | None = None,
         is_private: bool = False,
+        context_prefix: str = '',
+        tg_message_id: int | None = None,
     ) -> int:
         """
         Add a user message to conversation memory and persist it to the database.
@@ -164,6 +175,10 @@ class Conversation:
             is_private: If True, marks the message as private-mode (excluded from all context
                         loads) and flags it in the speaker annotation so the LLM understands
                         it should not reference this in group contexts.
+            context_prefix: Optional inline context prepended to the in-memory message before
+                            the live prefix (e.g. reply-to-thread annotation). Not persisted to DB.
+            tg_message_id: Telegram message ID; added to _loaded_message_ids so future
+                           reply-to-thread checks know this message is already in context.
 
         Returns:
             The database id of the newly inserted row, for use as reply_to_id.
@@ -171,11 +186,13 @@ class Conversation:
         await upsert_user(user_id, username, first_name, last_name)
         await upsert_chat(self.chat_id, self.chat_type, self.chat_title)
         prefix = self._live_prefix(first_name, last_name, username, is_private)
-        msg_dict = {"role": "user", "content": prefix + content}
+        msg_dict = {"role": "user", "content": context_prefix + prefix + content}
         self.messages.append(msg_dict)
         if is_private:
             self._private_message_ids.add(id(msg_dict))
-        return await insert_message(self.chat_id, user_id, "user", content, is_private)
+        if tg_message_id is not None:
+            self._loaded_message_ids.add(tg_message_id)
+        return await insert_message(self.chat_id, user_id, "user", content, is_private, tg_message_id=tg_message_id)
 
     async def add_assistant_message(
         self,
@@ -186,7 +203,7 @@ class Conversation:
         bot_last_name: str | None = None,
         is_private: bool = False,
         reply_to_id: int | None = None,
-    ):
+    ) -> int:
         """
         Add an assistant message to conversation memory and persist it to the database.
 
@@ -205,6 +222,10 @@ class Conversation:
             is_private: If True, marks the message as private-mode (excluded from all context
                         loads). Should match the is_private flag of the user message it responds to.
             reply_to_id: Database id of the user message this reply responds to.
+
+        Returns:
+            The database id (int) of the newly inserted assistant message row. Used by
+            callers to update tg_message_id after the Telegram send completes.
         """
         await upsert_user(bot_user_id, bot_username, bot_first_name, bot_last_name)
         await upsert_chat(self.chat_id, self.chat_type, self.chat_title)
@@ -212,7 +233,7 @@ class Conversation:
         self.messages.append(msg_dict)
         if is_private:
             self._private_message_ids.add(id(msg_dict))
-        await insert_message(self.chat_id, bot_user_id, "assistant", content, is_private, reply_to_id)
+        return await insert_message(self.chat_id, bot_user_id, "assistant", content, is_private, reply_to_id)
 
     async def get_message_token_count(self) -> int:
         """
@@ -320,6 +341,7 @@ class Conversation:
         rows_inserted = 0
 
         for row in reversed(rows):
+            tg_id = row.pop('_tg_id', None)
             self.messages.insert(1, row)
             token_count = await self.get_message_token_count()
             if token_count > token_limit:
@@ -328,6 +350,8 @@ class Conversation:
                 token_limit_reached = True
                 break
             rows_inserted += 1
+            if tg_id is not None:
+                self._loaded_message_ids.add(tg_id)
 
         # Load shared group context for private chats when token budget allows.
         # Private context fills the primary budget; group context fills the remainder.
@@ -343,6 +367,7 @@ class Conversation:
                     group_rows = await load_shared_group_context(shared_groups, exclude_private=True)
                     insert_at = 1 + rows_inserted
                     for row in reversed(group_rows):
+                        tg_id = row.pop('_tg_id', None)
                         self.messages.insert(insert_at, row)
                         token_count = await self.get_message_token_count()
                         if token_count > token_limit:
@@ -351,6 +376,8 @@ class Conversation:
                             group_limit_reached = True
                             break
                         group_rows_inserted += 1
+                        if tg_id is not None:
+                            self._loaded_message_ids.add(tg_id)
 
         has_context = rows_inserted > 0 or group_rows_inserted > 0
 
@@ -394,6 +421,7 @@ class Conversation:
             - Modifies self.messages in-place, inserting new rows at self._history_end[user_id]
               (after historical context, before any live session messages).
             - Advances self._context_cursor[user_id] and self._history_end[user_id] on success.
+            - Updates self._loaded_message_ids with tg_message_id values from merged rows.
         """
         if user_id not in self._context_cursor:
             return False
@@ -416,12 +444,15 @@ class Conversation:
         insert_pos = self._history_end.get(user_id, 1)
         rows_inserted = 0
         for row in reversed(new_rows):
+            tg_id = row.pop('_tg_id', None)
             self.messages.insert(insert_pos, row)
             token_count = await self.get_message_token_count()
             if token_count > token_limit:
                 self.messages.pop(insert_pos)
                 break
             rows_inserted += 1
+            if tg_id is not None:
+                self._loaded_message_ids.add(tg_id)
 
         if rows_inserted > 0:
             self._context_cursor[user_id] = current_max
@@ -445,12 +476,14 @@ class Conversation:
             - Resets self._context_cursor to empty dict.
             - Resets self._history_end to empty dict.
             - Resets self._private_message_ids to empty set.
+            - Resets self._loaded_message_ids to empty set.
             - Deletes all messages for this chat (private) or this user (group) from database.
         """
         self.messages = [self.messages[0]]
         self._context_cursor = {}
         self._history_end = {}
         self._private_message_ids = set()
+        self._loaded_message_ids = set()
         if self.chat_type == 'private':
             await delete_messages_for_chat(self.chat_id)
         else: