TeLLMgramBot 3.2.0__tar.gz → 3.2.2__tar.gz

{tellmgrambot-3.2.0 → tellmgrambot-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TeLLMgramBot
-Version: 3.2.0
+Version: 3.2.2
 Summary: LLM-powered Telegram bot (OpenAI + Anthropic)
 Home-page: https://github.com/Digital-Heresy/TeLLMgramBot
 Author: Digital Heresy

{tellmgrambot-3.2.0 → tellmgrambot-3.2.2}/TeLLMgramBot/TeLLMgramBot.py

@@ -12,7 +12,7 @@ from .providers.factory import get_provider
 from .providers.base import ContextLengthExceededError, ProviderAuthError, ProviderConnectionError
 from .initialize import INIT_BOT_CONFIG, ApiKeyStatus, init_structure, init_bot_config, init_bot_prompt
 from .conversation import Conversation
-from .database import get_private_mode, set_private_mode, delete_messages_for_user, delete_messages_for_chat
+from .database import get_private_mode, set_private_mode, delete_messages_for_user, delete_messages_for_chat, delete_private_messages_for_user
 from .models import TokenLimits
 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
@@ -96,7 +96,7 @@ class TelegramBot:
         In group chats: deletes the user's rows across all chats (private included).
 
         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
+        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. All private-mode notices for this user are also cleared.
         """
@@ -128,15 +128,16 @@ class TelegramBot:
 
     async def tele_private_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
         """
-        Toggle private mode for the requesting user (private chats only).
+        Enable or disable private mode for the requesting user (private chats only).
 
         When private mode is ON, messages sent in private chats are flagged as is_private=1
-        in the database and excluded when building context for group conversations. This lets
-        users keep sensitive private exchanges out of shared group contexts.
+        in the database. These rows are excluded from all context loads - both group context
+        (cross-pollination) and private chat reloads. On /private off, they are permanently
+        deleted from the DB and purged from in-session memory (neuralyzer semantics).
 
         Usage:
-            /private       — toggles private mode on (if off) or off (if on)
-            /private off   — explicitly disables private mode
+            /private       - enables private mode (idempotent if already on)
+            /private off   - disables private mode and purges in-session private messages
 
         Only available in private chats; sending the command in a group returns an error.
         """
@@ -150,20 +151,26 @@ class TelegramBot:
             return
 
         user_id = user.id
+        chat_id = chat.id
         args = (msg.text or "").strip().split()
         force_off = len(args) > 1 and args[1].lower() == 'off'
-        current = await get_private_mode(user_id)
-        new_state = False if (force_off or current) else True
-        await set_private_mode(user_id, new_state)
 
-        if new_state:
+        if force_off:
+            # Neuralyzer: delete before flipping the mode flag so that if the delete
+            # fails, private mode stays ON and the user can safely retry /private off.
+            await delete_private_messages_for_user(user_id)
+            await set_private_mode(user_id, False)
+            # Also purge from in-memory conversation so the bot cannot reference them now.
+            if chat_id in self.conversations:
+                self.conversations[chat_id].purge_private_messages()
             await msg.reply_text(
-                "Private mode is ON. Future messages in this private chat will be excluded "
-                "from group conversation contexts. Use /private off to disable."
+                "Private mode is OFF. Future messages in this private chat will be included in group conversation contexts."
             )
         else:
+            await set_private_mode(user_id, True)
             await msg.reply_text(
-                "Private mode is OFF. Future messages in this private chat will be included in group conversation contexts."
+                "Private mode is ON. Future messages in this private chat will be excluded "
+                "from group conversation contexts. Use /private off to disable."
             )
 
     async def tele_handle_response(self, text: str, msg: Message) -> str:
@@ -223,16 +230,16 @@ class TelegramBot:
         token_budget = floor(self.chatgpt['prune_threshold'] / 2)
 
         if user_id not in conv._context_cursor:
-            # First appearance of this user in this session — load their cross-chat history.
+            # First appearance of this user in this session - load their cross-chat history.
             # Pass bot_id so private chats can also load shared group context.
             # If no history exists yet, the cursor stays unset so the next message retries.
             await conv.get_past_interaction(token_budget, user_id, self.telegram['bot_id'])
         else:
-            # Already loaded — check for new cross-chat messages since last load.
+            # Already loaded - check for new cross-chat messages since last load.
             await conv.refresh_user_context(user_id, token_budget)
 
         # Add the user's message to our conversation, respecting private mode
-        # Private mode only applies in private chats — group messages are never flagged private
+        # 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)
@@ -246,7 +253,7 @@ class TelegramBot:
             if warn_key not in self._private_mode_warned:
                 self._private_mode_warned.add(warn_key)
                 private_mode_notice = (
-                    "\n\n(Note: your private mode is ON — messages from our private chat "
+                    "\n\n(Note: your private mode is ON - messages from our private chat "
                     "are not included in this group's context. To disable, send /private off in our DMs.)"
                 )
 
@@ -281,7 +288,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.
+        # 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
         )

{tellmgrambot-3.2.0 → tellmgrambot-3.2.2}/TeLLMgramBot/conversation.py

@@ -52,17 +52,22 @@ class Conversation:
         self.system_model = TokenLimits(system_model)
         self.messages = [{"role": "system", "content": system_content}]
 
-        # Maps user_id → max message id at the time their cross-chat context was loaded.
+        # Maps user_id -> max message id at the time their cross-chat context was loaded.
         # Used for both per-user idempotency (is the user loaded?) and mid-session refresh
         # detection (have new cross-chat messages appeared since the last load?).
         self._context_cursor: dict[int, int] = {}
 
-        # Maps user_id → len(self.messages) after their history was loaded.
+        # Maps user_id -> len(self.messages) after their history was loaded.
         # Marks the boundary between historical context and live session messages so that
         # refresh_user_context() inserts delta rows at the right position (after history,
         # before live messages) rather than at index 1 (before all existing history).
         self._history_end: dict[int, int] = {}
 
+        # Set of id()s for message dicts added while private mode was ON.
+        # Used by purge_private_messages() to remove them from self.messages without
+        # touching the database. Cleared on purge or clear_interaction().
+        self._private_message_ids: set[int] = set()
+
     def set_system_content(self, new_content: str):
         """
         Replace the system content (bot's personality prompt) in the conversation.
@@ -83,9 +88,13 @@ class Conversation:
             content: The message text.
             user_id: Telegram user ID of the sender.
             username: Telegram username (display only, may be None).
-            is_private: If True, excludes this message from group context loading (used for /forget or private commands).
+            is_private: If True, flags this message as private-mode excluded from
+                        all context loads (user has /private ON in a private chat).
         """
-        self.messages.append({"role": "user", "content": content})
+        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)
 
     async def add_assistant_message(self, content: str, bot_user_id: int, bot_username: str | None, is_private: bool = False):
@@ -100,7 +109,10 @@ class Conversation:
                         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.
         """
-        self.messages.append({"role": "assistant", "content": content})
+        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)
 
     async def get_message_token_count(self) -> int:
@@ -124,7 +136,7 @@ class Conversation:
         Remove oldest user-assistant messages until token count is below threshold.
 
         Recursively removes messages starting from index 1 (preserving the system message at index 0)
-        until the conversation fits within the token limit. The database is not modified — pruning
+        until the conversation fits within the token limit. The database is not modified - pruning
         only affects the in-memory context window for the current session.
 
         Args:
@@ -138,6 +150,23 @@ class Conversation:
         except Exception as e:
             log_error(e, f"{type(e).__name__} pruning under {token_limit} tokens for {self.chat_print}", self.error_log)
 
+    def purge_private_messages(self):
+        """
+        Remove all in-session private-mode messages from the in-memory conversation.
+
+        Strips any messages added while private mode was ON from self.messages without
+        modifying the database. Called when a user disables private mode (/private off)
+        so the bot can no longer reference messages sent during the private session.
+
+        Side Effects:
+            - Modifies self.messages in-place, removing tracked private message dicts.
+            - Clears self._private_message_ids.
+        """
+        if not self._private_message_ids:
+            return
+        self.messages = [m for m in self.messages if id(m) not in self._private_message_ids]
+        self._private_message_ids.clear()
+
     async def get_past_interaction(self, token_limit: int, user_id: int, bot_id: int | None = None) -> bool:
         """
         Load past conversation messages from the database up to a token limit.
@@ -145,10 +174,9 @@ class Conversation:
         Implements bidirectional cross-pollination: loads all messages from the current chat
         (all participants) plus all messages from the user's private chat (both user and
         assistant turns), merged chronologically. This eliminates amnesia when a user switches
-        between private and group contexts.
-
-        For group and supergroup chats, messages marked as private (is_private=1) are excluded
-        so private-mode messages don't surface in shared contexts.
+        between private and group contexts. Messages marked as private (is_private=1) are
+        always excluded, regardless of chat type, ensuring private-mode exchanges never leak
+        into any session context.
 
         For private chats, if bot_id is provided and remaining token budget allows, also loads
         full message history from any groups shared between the user and the bot. This lets the
@@ -181,7 +209,7 @@ class Conversation:
             print(f"Context already loaded for User {user_id} in {self.chat_print}")
             return True
 
-        exclude_private = self.chat_type in ('group', 'supergroup')
+        exclude_private = True
         rows = await load_full_user_context(user_id, self.chat_id, exclude_private=exclude_private)
 
         token_limit_reached = False
@@ -231,7 +259,7 @@ class Conversation:
             label = "Full" if not token_limit_reached and not group_limit_reached else "Partial"
             group_note = f", plus {group_rows_inserted} group message(s)" if group_rows_inserted > 0 else ""
             print(
-                f"{label} context loaded for User {user_id} in {self.chat_print} — "
+                f"{label} context loaded for User {user_id} in {self.chat_print} - "
                 f"storing {token_count} token(s){group_note}"
             )
         else:
@@ -267,7 +295,7 @@ class Conversation:
         if user_id not in self._context_cursor:
             return False
 
-        exclude_private = self.chat_type in ('group', 'supergroup')
+        exclude_private = True
         current_max = await get_max_cross_chat_message_id(user_id, self.chat_id, exclude_private)
 
         if current_max <= self._context_cursor[user_id]:
@@ -314,11 +342,13 @@ class Conversation:
             - Clears self.messages to contain only the system message (index 0).
             - Resets self._context_cursor to empty dict.
             - Resets self._history_end to empty dict.
+            - Resets self._private_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()
         if self.chat_type == 'private':
             await delete_messages_for_chat(self.chat_id)
         else:

{tellmgrambot-3.2.0 → tellmgrambot-3.2.2}/TeLLMgramBot/database.py

@@ -48,7 +48,7 @@ def get_db_path() -> str:
 
     Reads TELLMGRAMBOT_DATA_PATH env var (directory path) and appends conversations.db.
     Falls back to data/conversations.db relative to the execution directory if unset.
-    Module-level _DB_PATH overrides everything — used by tests.
+    Module-level _DB_PATH overrides everything - used by tests.
     """
     if _DB_PATH:
         return _DB_PATH
@@ -59,7 +59,7 @@ 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.
+    Safe to call repeatedly - all statements use IF NOT EXISTS.
     """
     async with aiosqlite.connect(get_db_path()) as db:
         await db.executescript(_DDL)
@@ -160,26 +160,28 @@ async def load_full_user_context(
     In Telegram, a user's private chat_id always equals their user_id. Three arms cover
     all cross-context cases:
 
-      Arm 1 — chat_id = current_chat_id:
+      Arm 1 - chat_id = current_chat_id:
           All messages (user and bot) in the current chat. Always included.
 
-      Arm 2 — chat_id = user_id AND chat_id != current_chat_id:
+      Arm 2 - chat_id = user_id AND chat_id != current_chat_id:
           All messages (both sides) from the user's private chat, included when the
           current chat is a group. Pulling both sides restores proper role alternation
           that was broken when only the user's own rows were fetched.
 
-      Arm 3 — user_id = user_id AND chat_id != current_chat_id AND chat_id != user_id:
+      Arm 3 - user_id = user_id AND chat_id != current_chat_id AND chat_id != user_id:
           The requesting user's own messages from any other group chats (not the private
           chat, not the current chat). Covers group-to-private and group-to-group context.
           Only the user's own rows are fetched from other groups (not bot replies).
 
-    The exclude_private filter is applied globally when the current chat is a group.
+    The exclude_private flag is controlled by the caller and applies regardless of chat type.
+    Conversation.get_past_interaction always passes exclude_private=True so that is_private=1
+    rows are never rehydrated into any session context.
 
     Args:
         user_id: Telegram user ID of the requesting user.
         current_chat_id: The chat_id of the current conversation (negative for groups, positive for private).
-        exclude_private: If True, rows with is_private=1 are excluded from all chats.
-            Applied when the current chat is a group so private-mode messages
+        exclude_private: If True, rows with is_private=1 are excluded from all arms of the query.
+            Always passed as True by Conversation.get_past_interaction so that private-mode messages
             don't surface in shared contexts.
 
     Returns:
@@ -243,7 +245,7 @@ async def load_new_cross_chat_context(
     Args:
         user_id: Telegram user ID of the requesting user.
         current_chat_id: The chat_id of the current conversation.
-        since_id: Exclusive lower bound — only rows with id > since_id are returned.
+        since_id: Exclusive lower bound - only rows with id > since_id are returned.
         exclude_private: If True, rows with is_private=1 are excluded.
 
     Returns:
@@ -342,7 +344,7 @@ async def load_shared_group_context(
 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 in group chats - only the issuing user's rows are removed.
     """
     async with aiosqlite.connect(get_db_path()) as db:
         await db.execute("DELETE FROM messages WHERE user_id = ?", (user_id,))
@@ -357,6 +359,27 @@ async def delete_messages_for_chat(chat_id: int) -> None:
         await db.execute("DELETE FROM messages WHERE chat_id = ?", (chat_id,))
         await db.commit()
 
+async def delete_private_messages_for_user(user_id: int) -> None:
+    """
+    Delete all private-mode message rows for a user from their private chat.
+
+    Removes rows where chat_id = user_id (the user's Telegram private chat) AND
+    is_private = 1. This covers both the user's own messages and the bot's replies
+    stored in the same private chat, since assistant turns share the same chat_id.
+
+    Called when the user turns private mode off (/private off) to ensure that
+    private-mode messages do not resurface on the next session reload.
+
+    Args:
+        user_id: Telegram user ID; also serves as the private chat_id.
+    """
+    async with aiosqlite.connect(get_db_path()) as db:
+        await db.execute(
+            "DELETE FROM messages WHERE chat_id = ? AND is_private = 1",
+            (user_id,)
+        )
+        await db.commit()
+
 async def get_private_mode(user_id: int) -> bool:
     """
     Return whether private mode is currently enabled for this user.

{tellmgrambot-3.2.0 → tellmgrambot-3.2.2}/TeLLMgramBot/initialize.py

@@ -112,7 +112,7 @@ def init_keys() -> ApiKeyStatus:
     """
     Load API keys and return a ApiKeyStatus indicating which features are available.
 
-    Telegram key is always required — bot exits if missing or invalid.
+    Telegram key is always required - bot exits if missing or invalid.
     All other keys (OpenAI, Anthropic, VirusTotal) are optional: missing keys
     disable the associated features rather than exiting.
 
@@ -159,7 +159,7 @@ def init_keys() -> ApiKeyStatus:
                          f"url_model ({config.get('url_model', '?')})" if url_provider == key else None,
                          "VirusTotal integration" if key == 'virustotal' else None]
                 reason = ", ".join(w for w in which if w) or "related features"
-                print(f"Warning: {key}.key not found — {reason} will be disabled.")
+                print(f"Warning: {key}.key not found - {reason} will be disabled.")
                 continue
             else:
                 os.environ[env_var] = read_text(path)
@@ -173,7 +173,7 @@ def init_keys() -> ApiKeyStatus:
                      f"url_model ({config.get('url_model', '?')})" if url_provider == key else None,
                      "VirusTotal integration" if key == 'virustotal' else None]
             reason = ", ".join(w for w in which if w) or "related features"
-            print(f"Warning: {env_var} is blank or invalid — {reason} will be disabled.")
+            print(f"Warning: {env_var} is blank or invalid - {reason} will be disabled.")
             continue
 
         available.add(key)
@@ -348,8 +348,8 @@ def init_structure() -> ApiKeyStatus:
     - Configuration files (config.yaml, models.yaml) with inline parameter descriptions.
     - System prompt files (test_personality.prmpt, url_analysis.prmpt).
 
-    Provider key requirements are inferred from config.yaml model prefixes (claude-* → Anthropic,
-    gpt-* → OpenAI, etc.) to streamline setup for single-provider deployments.
+    Provider key requirements are inferred from config.yaml model prefixes (claude-* -> Anthropic,
+    gpt-* -> OpenAI, etc.) to streamline setup for single-provider deployments.
 
     Returns:
         ApiKeyStatus indicating which features are available based on loaded API keys.

{tellmgrambot-3.2.0 → tellmgrambot-3.2.2}/TeLLMgramBot/providers/factory.py

@@ -9,8 +9,8 @@ def get_provider(model: str) -> LLMProvider:
     Return the appropriate LLM provider for the given model name.
 
     Provider is inferred from the model name prefix:
-      - 'claude-' → AnthropicProvider
-      - anything else → OpenAIProvider
+      - 'claude-' -> AnthropicProvider
+      - anything else -> OpenAIProvider
     """
     if model.startswith('claude-'):
         key = 'anthropic'

{tellmgrambot-3.2.0 → tellmgrambot-3.2.2}/TeLLMgramBot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TeLLMgramBot
-Version: 3.2.0
+Version: 3.2.2
 Summary: LLM-powered Telegram bot (OpenAI + Anthropic)
 Home-page: https://github.com/Digital-Heresy/TeLLMgramBot
 Author: Digital Heresy

{tellmgrambot-3.2.0 → tellmgrambot-3.2.2}/setup.py

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