TeLLMgramBot 3.4.0__tar.gz → 3.4.2__tar.gz

{tellmgrambot-3.4.0 → tellmgrambot-3.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TeLLMgramBot
-Version: 3.4.0
+Version: 3.4.2
 Summary: LLM-powered Telegram bot (OpenAI + Anthropic)
 Home-page: https://github.com/Digital-Heresy/TeLLMgramBot
 Author: Digital Heresy
@@ -144,14 +144,7 @@ Each file with the associated API key will update its respective environment var
 ## Commands and Interactions
 
 ### Read Receipt Acknowledgement (Group Chats Only)
-In group and supergroup chats, you can request the bot to acknowledge reading your message with a lightweight 👀 reaction instead of waiting for a full response. Simply mention the bot's username, nickname, or initials followed by an explicit request:
-
-- `@botname acknowledge`
-- `botname mark as read`
-- `BN did you read that?`
-- `botname confirm you received`
-
-The bot will respond with a 👀 reaction emoji on your message (if the Telegram client supports message reactions), or with a short "Got it!" reply as fallback. Read receipt requests are processed immediately without touching the conversation context, making them ideal for confirming the bot is online without disrupting group flow.
+In group and supergroup chats, whenever you mention the bot by username (`@botname`), nickname, or initials, the bot immediately responds with a 👀 reaction emoji on your message to confirm it is online, followed by a full LLM response. The reaction uses the Telegram message reaction API when available (👀 emoji), or falls back to a short "Got it!" text reply for older clients that don't support reactions.
 
 ## Bot Setup
 This library includes an example script `test_local.py`, which uses files from the folders `configs` and `prompts` for TeLLMgramBot to process.

{tellmgrambot-3.4.0 → tellmgrambot-3.4.2}/README.md

@@ -113,14 +113,7 @@ Each file with the associated API key will update its respective environment var
 ## Commands and Interactions
 
 ### Read Receipt Acknowledgement (Group Chats Only)
-In group and supergroup chats, you can request the bot to acknowledge reading your message with a lightweight 👀 reaction instead of waiting for a full response. Simply mention the bot's username, nickname, or initials followed by an explicit request:
-
-- `@botname acknowledge`
-- `botname mark as read`
-- `BN did you read that?`
-- `botname confirm you received`
-
-The bot will respond with a 👀 reaction emoji on your message (if the Telegram client supports message reactions), or with a short "Got it!" reply as fallback. Read receipt requests are processed immediately without touching the conversation context, making them ideal for confirming the bot is online without disrupting group flow.
+In group and supergroup chats, whenever you mention the bot by username (`@botname`), nickname, or initials, the bot immediately responds with a 👀 reaction emoji on your message to confirm it is online, followed by a full LLM response. The reaction uses the Telegram message reaction API when available (👀 emoji), or falls back to a short "Got it!" text reply for older clients that don't support reactions.
 
 ## Bot Setup
 This library includes an example script `test_local.py`, which uses files from the folders `configs` and `prompts` for TeLLMgramBot to process.

{tellmgrambot-3.4.0 → tellmgrambot-3.4.2}/TeLLMgramBot/TeLLMgramBot.py

@@ -27,10 +27,10 @@ from .database import (
     delete_messages_for_user,
     delete_messages_for_chat,
     delete_private_messages_for_user,
-    delete_paired_bot_replies,
+    delete_bot_replies_for_user,
 )
 from .models import TokenLimits
-from .message_handlers import handle_greetings, handle_common_queries, handle_url_ask, handle_read_receipt
+from .message_handlers import handle_greetings, handle_common_queries, handle_url_ask
 from .utils import read_yaml, read_text, exact_word_match, generate_error_path, log_error
 
 class TelegramBot:
@@ -108,19 +108,24 @@ class TelegramBot:
         """
         Remove conversation history from the database (behavior depends on chat type).
 
-        In private chats: deletes all messages in the private chat (including bot replies).
-        In group chats: deletes the user's rows across all chats (private included), then
-        deletes bot replies in the current chat that were paired with the user's messages
-        or were orphaned by a previous /forget call, leaving other users' conversations intact.
+        In private chats: deletes all bot replies whose reply_to_id points to this user's messages,
+        then deletes the user's rows across all chats (full wipe including group messages),
+        then deletes any remaining messages in the private chat (pre-migration rows with NULL reply_to_id).
+        In group chats: deletes bot replies linked to this user's messages, then deletes the user's
+        rows across all chats, leaving other users' messages intact.
 
         In both cases, evicts only the in-memory Conversation objects that contain this
         user's data - scoped to the current chat, the user's private chat, and any other
         chats where their context was previously merged. Other users' active sessions are
         not affected.
         """
-        user_id = update.message.from_user.id
-        chat_id = update.message.chat.id
-        chat_type = update.message.chat.type
+        validated = await self.tele_validate(update)
+        if not validated:
+            return
+        (msg, chat, user) = validated
+        user_id = user.id
+        chat_id = chat.id
+        chat_type = chat.type
 
         # Find all chat_ids where this user's context has been merged in memory,
         # identified by user_id being present in the Conversation's _context_cursor.
@@ -131,19 +136,21 @@ class TelegramBot:
         user_chat_ids.update({chat_id, user_id})
 
         if chat_type == 'private':
+            # Wipe bot replies linked to this user, then user's own rows across all chats,
+            # then any remaining bot replies in the private chat (pre-migration rows).
+            await delete_bot_replies_for_user(user_id)
+            await delete_messages_for_user(user_id)
             await delete_messages_for_chat(chat_id)
         else:
+            await delete_bot_replies_for_user(user_id)
             await delete_messages_for_user(user_id)
-            # Delete bot replies paired to this user's messages, plus any pre-existing
-            # orphaned assistant rows left by earlier /forget calls in this chat.
-            await delete_paired_bot_replies(chat_id, self.telegram['bot_id'])
 
         # Evict only the Conversations that contain this user's data, not all sessions.
         for evict_id in user_chat_ids:
             self.conversations.pop(evict_id, None)
             self.token_warning.pop(evict_id, None)
 
-        await update.message.reply_text("My memories of our conversations are wiped!")
+        await msg.reply_text("My memories of our conversations are wiped!")
 
     async def tele_private_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
         """
@@ -261,7 +268,7 @@ class TelegramBot:
         # 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
-        await conv.add_user_message(text, user_id, username, is_private)
+        user_msg_id = await conv.add_user_message(text, user_id, username, is_private)
 
         # Check if the user is asking about a [URL]
         url_match = re.search(r'\[http(s)?://\S+]', text)
@@ -293,7 +300,7 @@ class TelegramBot:
         # 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(
-            reply, self.telegram['bot_id'], self.telegram['username'], is_private
+            reply, self.telegram['bot_id'], self.telegram['username'], is_private, user_msg_id
         )
 
         # Recompute token count after full exchange is stored, then prune if needed
@@ -307,9 +314,10 @@ class TelegramBot:
         """
         Send a read receipt acknowledgement via message reaction.
 
-        Attempts to add a eyes-emoji reaction to the user's message to confirm the bot
-        read it, avoiding a full LLM response. If the message reaction API is unavailable
-        (e.g., older Telegram clients), falls back to a short "Got it!" text reply.
+        Attempts to add a 👀 emoji reaction to the user's message to confirm the bot
+        read it. If the message reaction API is unavailable (e.g., older Telegram clients),
+        falls back to a short "Got it!" text reply. Called unconditionally on every group
+        mention before the normal LLM response.
 
         Args:
             msg: The Telegram Message object to react to.
@@ -338,17 +346,13 @@ class TelegramBot:
             if exact_word_match(self.telegram['username'], msg.text):
                 pattern = r'@?\b' + re.escape(self.telegram['username']) + r'\b'
                 new_text = re.sub(pattern, '', msg.text).strip()
-                if handle_read_receipt(new_text):
-                    await self._send_read_receipt(msg, context)
-                    return
+                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)
             ):
-                if handle_read_receipt(msg.text):
-                    await self._send_read_receipt(msg, context)
-                    return
+                await self._send_read_receipt(msg, context)
                 response = await self.tele_handle_response(msg.text, msg)
             else:
                 return

{tellmgrambot-3.4.0 → tellmgrambot-3.4.2}/TeLLMgramBot/conversation.py

@@ -80,7 +80,7 @@ class Conversation:
         self.system_content = new_content
         self.messages[0] = {"role": "system", "content": new_content}
 
-    async def add_user_message(self, content: str, user_id: int, username: str | None, is_private: bool = False):
+    async def add_user_message(self, content: str, user_id: int, username: str | None, is_private: bool = False) -> int:
         """
         Add a user message to conversation memory and persist it to the database.
 
@@ -90,14 +90,17 @@ class Conversation:
             username: Telegram username (display only, may be None).
             is_private: If True, flags this message as private-mode excluded from
                         all context loads (user has /private ON in a private chat).
+
+        Returns:
+            The database id of the newly inserted row, for use as reply_to_id.
         """
         msg_dict = {"role": "user", "content": content}
         self.messages.append(msg_dict)
         if is_private:
             self._private_message_ids.add(id(msg_dict))
-        await insert_message(self.chat_id, user_id, username, "user", content, is_private)
+        return await insert_message(self.chat_id, user_id, username, "user", content, is_private)
 
-    async def add_assistant_message(self, content: str, bot_user_id: int, bot_username: str | None, is_private: bool = False):
+    async def add_assistant_message(self, content: str, bot_user_id: int, bot_username: str | None, is_private: bool = False, reply_to_id: int | None = None):
         """
         Add an assistant message to conversation memory and persist it to the database.
 
@@ -108,12 +111,13 @@ class Conversation:
             is_private: If True, excludes this reply from group context loading. Should match
                         the is_private flag of the user message it responds to, so that both
                         sides of a private-mode exchange are excluded from shared contexts.
+            reply_to_id: Database id of the user message this reply responds to.
         """
         msg_dict = {"role": "assistant", "content": content}
         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, bot_username, "assistant", content, is_private)
+        await insert_message(self.chat_id, bot_user_id, bot_username, "assistant", content, is_private, reply_to_id)
 
     async def get_message_token_count(self) -> int:
         """

{tellmgrambot-3.4.0 → tellmgrambot-3.4.2}/TeLLMgramBot/database.py

@@ -22,14 +22,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,
-    username   TEXT,
-    role       TEXT NOT NULL CHECK(role IN ('user', 'assistant', 'system')),
-    content    TEXT NOT NULL,
-    is_private INTEGER NOT NULL DEFAULT 0,
-    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,
+    username     TEXT,
+    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'))
 );
 
 CREATE INDEX IF NOT EXISTS idx_messages_chat_id ON messages(chat_id, created_at);
@@ -60,9 +61,14 @@ async def init_db() -> None:
     Create the messages and private_mode tables if they do not exist.
     Enables WAL journal mode for safe concurrent reads and writes.
     Safe to call repeatedly - all statements use IF NOT EXISTS.
+    Migrates existing databases by adding reply_to_id if not present.
     """
     async with aiosqlite.connect(get_db_path()) as db:
         await db.executescript(_DDL)
+        # Migration: add reply_to_id to existing databases that predate this column.
+        existing = {row[1] async for row in await db.execute("PRAGMA table_info(messages)")}
+        if 'reply_to_id' not in existing:
+            await db.execute("ALTER TABLE messages ADD COLUMN reply_to_id INTEGER")
         await db.commit()
 
 async def insert_message(
@@ -72,9 +78,10 @@ async def insert_message(
     role: str,
     content: str,
     is_private: bool = False,
-) -> None:
+    reply_to_id: Optional[int] = None,
+) -> int:
     """
-    Persist a single message row.
+    Persist a single message row and return its database id.
 
     Args:
         chat_id: Telegram chat ID (negative for groups, positive/==user_id for private).
@@ -83,14 +90,19 @@ async def insert_message(
         role: 'user', 'assistant', or 'system'.
         content: Message text.
         is_private: If True, this message is excluded from group context loading.
+        reply_to_id: Database id of the message this is a reply to (None if not a reply).
+
+    Returns:
+        The integer id of the newly inserted row.
     """
     async with aiosqlite.connect(get_db_path()) as db:
-        await db.execute(
-            "INSERT INTO messages (chat_id, user_id, username, role, content, is_private) "
-            "VALUES (?, ?, ?, ?, ?, ?)",
-            (chat_id, user_id, username, role, content, int(is_private)),
+        cursor = await db.execute(
+            "INSERT INTO messages (chat_id, user_id, username, role, content, is_private, reply_to_id) "
+            "VALUES (?, ?, ?, ?, ?, ?, ?)",
+            (chat_id, user_id, username, role, content, int(is_private), reply_to_id),
         )
         await db.commit()
+        return cursor.lastrowid
 
 async def load_messages_for_chat(
     chat_id: int,
@@ -338,51 +350,30 @@ async def load_shared_group_context(
     all_rows.sort(key=lambda r: (r[2], r[3]))
     return [{"role": row[0], "content": row[1]} for row in all_rows]
 
-async def delete_paired_bot_replies(chat_id: int, bot_id: int) -> None:
-    """
-    Delete bot reply rows in a group chat that are paired with deleted user messages or orphaned.
 
-    Handles two cases in one pass:
-    1. Paired bot replies: after delete_messages_for_user() removes a user's rows, the bot
-       replies that immediately followed those messages become orphaned (no user row before
-       them). These are caught by the orphan query below.
-    2. Pre-existing orphans: assistant rows left behind by earlier /forget calls that deleted
-       user rows but not their paired replies. Cleaned up opportunistically on every group
-       /forget to heal historical debris.
+async def delete_bot_replies_for_user(user_id: int) -> None:
+    """
+    Delete assistant rows whose reply_to_id references any message from this user.
 
-    Both cases are unified by a single query: delete assistant rows whose immediately preceding
-    message in the same chat is not a user message. Reliable because the bot processes messages
-    sequentially - each reply is stored immediately after its user message, so the immediately
-    preceding row unambiguously identifies the pairing. Other users' conversations are unaffected
-    as long as their user rows remain (their user rows serve as the preceding message for their
-    own bot replies).
+    Must be called before delete_messages_for_user so that the user's message ids
+    still exist for the subquery to match against. Rows with reply_to_id = NULL
+    (pre-migration messages) are unaffected.
 
     Args:
-        chat_id: Telegram chat ID of the group chat to clean up.
-        bot_id: Telegram user ID of the bot account (identifies assistant rows by user_id).
+        user_id: Telegram user ID whose bot replies should be removed.
     """
     async with aiosqlite.connect(get_db_path()) as db:
         await db.execute(
-            "DELETE FROM messages "
-            "WHERE chat_id = ? AND role = 'assistant' AND user_id = ? "
-            "AND NOT EXISTS ("
-            "    SELECT 1 FROM messages prev "
-            "    WHERE prev.chat_id = messages.chat_id "
-            "      AND prev.id = ("
-            "          SELECT MAX(m2.id) FROM messages m2 "
-            "          WHERE m2.chat_id = messages.chat_id "
-            "            AND m2.id < messages.id"
-            "      ) "
-            "      AND prev.role = 'user'"
-            ")",
-            (chat_id, bot_id),
+            "DELETE FROM messages WHERE role = 'assistant' "
+            "AND reply_to_id IN (SELECT id FROM messages WHERE user_id = ?)",
+            (user_id,),
         )
         await db.commit()
 
 async def delete_messages_for_user(user_id: int) -> None:
     """
     Delete all message rows for a given user_id across all chats.
-    Used by /forget in group chats - only the issuing user's rows are removed.
+    Used by /forget - call delete_bot_replies_for_user first to clean up linked bot replies.
     """
     async with aiosqlite.connect(get_db_path()) as db:
         await db.execute("DELETE FROM messages WHERE user_id = ?", (user_id,))

{tellmgrambot-3.4.0 → tellmgrambot-3.4.2}/TeLLMgramBot/message_handlers.py

@@ -27,27 +27,6 @@ def handle_greetings(text: str) -> Optional[str]:
         return f'{word}!'
     return None
 
-def handle_read_receipt(text: str) -> bool:
-    """
-    Detect explicit user requests for read receipt acknowledgement.
-
-    Matches explicit acknowledgement trigger phrases: "acknowledge", "acknowledged", "mark as read",
-    "read receipt", "did you read", "did you get that", and "confirm you received". Uses word-boundary
-    matching to avoid false positives from casual conversation (e.g., "unacknowledged" does not match).
-
-    Args:
-        text: The message text to analyze (typically after bot mention/nickname stripped).
-
-    Returns:
-        True if the message matches a read receipt trigger phrase; False otherwise.
-    """
-    text_clean = re.sub(r'[^\w\s]', '', text.lower().strip())
-    triggers = {
-        'acknowledge', 'acknowledged', 'mark as read',
-        'read receipt', 'did you read', 'did you get that',
-        'confirm you received',
-    }
-    return any(re.search(rf'\b{re.escape(t)}\b', text_clean) is not None for t in triggers)
 
 def handle_common_queries(text: str) -> Optional[str]:
     """

{tellmgrambot-3.4.0 → tellmgrambot-3.4.2}/TeLLMgramBot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TeLLMgramBot
-Version: 3.4.0
+Version: 3.4.2
 Summary: LLM-powered Telegram bot (OpenAI + Anthropic)
 Home-page: https://github.com/Digital-Heresy/TeLLMgramBot
 Author: Digital Heresy
@@ -144,14 +144,7 @@ Each file with the associated API key will update its respective environment var
 ## Commands and Interactions
 
 ### Read Receipt Acknowledgement (Group Chats Only)
-In group and supergroup chats, you can request the bot to acknowledge reading your message with a lightweight 👀 reaction instead of waiting for a full response. Simply mention the bot's username, nickname, or initials followed by an explicit request:
-
-- `@botname acknowledge`
-- `botname mark as read`
-- `BN did you read that?`
-- `botname confirm you received`
-
-The bot will respond with a 👀 reaction emoji on your message (if the Telegram client supports message reactions), or with a short "Got it!" reply as fallback. Read receipt requests are processed immediately without touching the conversation context, making them ideal for confirming the bot is online without disrupting group flow.
+In group and supergroup chats, whenever you mention the bot by username (`@botname`), nickname, or initials, the bot immediately responds with a 👀 reaction emoji on your message to confirm it is online, followed by a full LLM response. The reaction uses the Telegram message reaction API when available (👀 emoji), or falls back to a short "Got it!" text reply for older clients that don't support reactions.
 
 ## Bot Setup
 This library includes an example script `test_local.py`, which uses files from the folders `configs` and `prompts` for TeLLMgramBot to process.

{tellmgrambot-3.4.0 → tellmgrambot-3.4.2}/setup.py

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