TeLLMgramBot 3.10.2__tar.gz → 3.10.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TeLLMgramBot
-Version: 3.10.2
+Version: 3.10.4
 Summary: LLM-powered Telegram bot (OpenAI + Anthropic)
 Home-page: https://github.com/Digital-Heresy/TeLLMgramBot
 Author: Digital Heresy
@@ -44,6 +44,7 @@ The basic goal of this project is to create a bridge between a Telegram Bot and
 * 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).
+  * Search automatically finds users and chats by their current or past names, so you can reference them however you remember them.
 * 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.
@@ -123,7 +124,7 @@ os.environ['TELLMGRAMBOT_VIRUSTOTAL_API_KEY'] = my_vault.get('virustotal_key')
 - `/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).
+- `/help` - Display available commands and usage information. In private chats, if you are a bot owner, also shows administrator-only commands (`/start`, `/stop`, `/wipe`).
 
 ### Group Chat Triggers
 The bot responds in groups when you:
@@ -143,7 +144,7 @@ When the bot is triggered in a group and about to respond (not deferring to anot
 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 `@`)
+   - `bot_owner`: Telegram username(s) with admin access (required, no `@`). Accepts a single string or a YAML list of usernames.
    - `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

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

@@ -12,6 +12,7 @@ The basic goal of this project is to create a bridge between a Telegram Bot and
 * 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).
+  * Search automatically finds users and chats by their current or past names, so you can reference them however you remember them.
 * 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.
@@ -91,7 +92,7 @@ os.environ['TELLMGRAMBOT_VIRUSTOTAL_API_KEY'] = my_vault.get('virustotal_key')
 - `/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).
+- `/help` - Display available commands and usage information. In private chats, if you are a bot owner, also shows administrator-only commands (`/start`, `/stop`, `/wipe`).
 
 ### Group Chat Triggers
 The bot responds in groups when you:
@@ -111,7 +112,7 @@ When the bot is triggered in a group and about to respond (not deferring to anot
 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 `@`)
+   - `bot_owner`: Telegram username(s) with admin access (required, no `@`). Accepts a single string or a YAML list of usernames.
    - `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

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

@@ -91,23 +91,49 @@ class TelegramBot:
             raise
 
     async def tele_commands(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
-        """Show all the commands available when the user sends `/help` to the bot."""
-        await update.message.reply_text("TeLLMgramBot commands:\n"
+        """
+        Show available commands when the user sends `/help` to the bot.
+
+        Displays general commands (/nick, /forget, /private, /help) to all users.
+        Admin commands (/start, /stop, /wipe) are shown only to usernames in bot_owner list,
+        and only in private chats (not in groups).
+
+        Args:
+            update: Telegram Update object containing the /help message.
+            context: Telegram context for sending the reply.
+        """
+        uname = update.message.from_user.username
+        chat_type = update.message.chat.type
+        text = (
+            "TeLLMgramBot commands:\n"
             "/nick - Set your nickname (e.g. \"/nick B0b #2\").\n"
-            "/forget - Clear all of your conversations.\n"
+            "/forget - Clear memories of all your conversations.\n"
             "/private - Toggle private mode (private chats only).\n"
-            "/help - Display this usage information.\n\n"
-            "Chat history will still show in your Telegram client.\n\n"
-            "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"
+            "/help - Display this usage information."
         )
+        if uname in self.telegram['owners'] and chat_type == 'private':
+            text += (
+                "\n\nAdmin 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)."
+            )
+        await update.message.reply_text(text)
 
     async def tele_start_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
-        """A bot_owner-only command to go online and handle any new messages."""
+        """
+        Start the bot and resume handling new messages (admin-only).
+
+        Only usernames in self.telegram['owners'] can execute this command.
+        If the sender is an owner, sets self._online to True and confirms via reply.
+        Otherwise, denies access with "Sorry, I can't do that for you."
+
+        Args:
+            update: Telegram Update object containing the /start message.
+            context: Telegram context for sending the reply.
+        """
         uname = update.message.from_user.username
-        if uname == self.telegram['owner']:
+        if uname in self.telegram['owners']:
             self._online = True
             greeting_text = f"Oh, hello {update.message.from_user.first_name}! Let me get to work!"
             await update.message.reply_text(greeting_text)
@@ -115,18 +141,41 @@ class TelegramBot:
             await update.message.reply_text("Sorry, I can't do that for you.")
 
     async def tele_stop_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
-        """A bot_owner-only command to go offline and not handle any new messages."""
+        """
+        Stop the bot and pause handling new messages (admin-only).
+
+        Only usernames in self.telegram['owners'] can execute this command.
+        If the sender is an owner, sets self._online to False and confirms via reply.
+        Otherwise, denies access with "Sorry, I can't do that for you."
+
+        Args:
+            update: Telegram Update object containing the /stop message.
+            context: Telegram context for sending the reply.
+        """
         uname = update.message.from_user.username
-        if uname == self.telegram['owner']:
+        if uname in self.telegram['owners']:
             self._online = False
             await update.message.reply_text("Sure thing boss, cutting out!")
         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."""
+        """
+        Permanently delete all conversation data from the database (admin-only).
+
+        Only usernames in self.telegram['owners'] can execute this command.
+        If the sender is an owner, deletes all messages, users, and chats via wipe_all_data(),
+        clears in-memory conversations and token warnings, and confirms via reply.
+        Otherwise, denies access with "Sorry, I can't do that for you."
+
+        This action is irreversible - all conversation history is permanently lost.
+
+        Args:
+            update: Telegram Update object containing the /wipe message.
+            context: Telegram context for sending the reply.
+        """
         uname = update.message.from_user.username
-        if uname != self.telegram['owner']:
+        if uname not in self.telegram['owners']:
             await update.message.reply_text("Sorry, I can't do that for you.")
             return
         await wipe_all_data()
@@ -759,7 +808,8 @@ class TelegramBot:
         Initialize the Telegram bot with LLM configuration and API keys.
 
         Args:
-            bot_owner: Telegram username of the bot owner (required, no `@`).
+            bot_owner: Telegram username(s) with admin access (no `@`).
+                       Accepts a single string or a list of strings; normalised to list[str] internally.
             bot_nickname: Nickname the bot responds to in group chats.
             bot_initials: Initials the bot responds to in group chats.
             chat_model: LLM model for conversation (e.g., 'gpt-5-mini', 'claude-sonnet-4-6').
@@ -771,6 +821,7 @@ class TelegramBot:
             key_status: ApiKeyStatus object indicating available features. If None, calls init_structure().
 
         Side Effects:
+            - Normalises bot_owner to list[str] and stores in self.telegram['owners'].
             - Fetches bot metadata (username, first_name, last_name, bot_id) from Telegram API via _tele_info().
             - Initializes command and message handlers for the Telegram application.
             - Sets self._online to True once initialization completes (ready for polling).
@@ -785,9 +836,10 @@ class TelegramBot:
         # Initialize some variables
         self.token_warning = {}  # Determines whether user has reached token limit by AI model
         self.conversations = {}  # Provides Conversation class per user based on bot response
+        owners = bot_owner if isinstance(bot_owner, list) else [bot_owner]
         self.telegram = {
             'bot_id'       : 0,  # overwritten by _tele_info(); 0 is a safe sentinel
-            'owner'        : bot_owner,
+            'owners'       : [str(u).strip() for u in owners if str(u).strip()],
             'nickname'     : bot_nickname,
             'initials'     : bot_initials,
             'username'     : None,

{tellmgrambot-3.10.2 → tellmgrambot-3.10.4}/TeLLMgramBot/database.py

@@ -6,6 +6,7 @@ searching message history, and retrieving conversation context. The schema inclu
 table (indexed by chat_id and user_id, with is_private flag), a users table (profile data
 and private_mode flag), and a chats table for speaker/chat resolution in search results.
 """
+import json
 import os
 from typing import Optional
 
@@ -42,19 +43,21 @@ CREATE INDEX IF NOT EXISTS idx_messages_chat_id ON messages(chat_id, created_at)
 CREATE INDEX IF NOT EXISTS idx_messages_user_id ON messages(user_id, created_at);
 
 CREATE TABLE IF NOT EXISTS users (
-    user_id      INTEGER PRIMARY KEY,
-    username     TEXT,
-    first_name   TEXT,
-    last_name    TEXT,
-    private_mode INTEGER NOT NULL DEFAULT 0,
-    updated_at   TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+    user_id        INTEGER PRIMARY KEY,
+    username       TEXT,
+    first_name     TEXT,
+    last_name      TEXT,
+    private_mode   INTEGER NOT NULL DEFAULT 0,
+    previous_names TEXT,
+    updated_at     TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
 );
 
 CREATE TABLE IF NOT EXISTS chats (
-    chat_id    INTEGER PRIMARY KEY,
-    chat_type  TEXT,
-    chat_title TEXT,
-    updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+    chat_id         INTEGER PRIMARY KEY,
+    chat_type       TEXT,
+    chat_title      TEXT,
+    previous_titles TEXT,
+    updated_at      TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
 );
 """
 
@@ -71,7 +74,7 @@ def set_db_filename(filename: str) -> None:
     Args:
         filename: DB filename, e.g. 'MyBot_conversations.db'. A '.db' suffix is
                   appended automatically if not already present. Must be a plain
-                  basename — path separators and absolute paths are rejected.
+                  basename - path separators and absolute paths are rejected.
 
     Raises:
         ValueError: If filename contains path components or is absolute.
@@ -133,14 +136,19 @@ async def init_db() -> None:
         # Migration: drop username column now stored in the normalized users table.
         if 'username' in existing:
             await db.execute("ALTER TABLE messages DROP COLUMN username")
-        # Migration: add chat_type to chats table if absent.
+        # Migration: add chat_type and previous_titles to chats table if absent.
         chats_cols = {row[1] async for row in await db.execute("PRAGMA table_info(chats)")}
         if 'chat_type' not in chats_cols:
             await db.execute("ALTER TABLE chats ADD COLUMN chat_type TEXT")
+        if 'previous_titles' not in chats_cols:
+            await db.execute("ALTER TABLE chats ADD COLUMN previous_titles TEXT")
         # Migration: merge private_mode table into users.private_mode and drop the old table.
+        # Also add previous_names column for name history tracking.
         users_cols = {row[1] async for row in await db.execute("PRAGMA table_info(users)")}
         if 'private_mode' not in users_cols:
             await db.execute("ALTER TABLE users ADD COLUMN private_mode INTEGER NOT NULL DEFAULT 0")
+        if 'previous_names' not in users_cols:
+            await db.execute("ALTER TABLE users ADD COLUMN previous_names TEXT")
         tables = {row[0] async for row in await db.execute("SELECT name FROM sqlite_master WHERE type='table'")}
         if 'private_mode' in tables:
             await db.execute(
@@ -595,7 +603,10 @@ async def upsert_user(
     Insert or update a user record in the users table.
 
     Always reflects the latest Telegram profile data. Called on every interaction
-    so that name changes are picked up automatically.
+    so that name changes are picked up automatically. When first/last name changes,
+    the old display name (first_name + space + last_name) is appended to the
+    previous_names column (JSON array, deduplicated) to enable search by
+    historical identities.
 
     Args:
         user_id: Telegram user ID.
@@ -604,13 +615,40 @@ async def upsert_user(
         last_name: Telegram last name, may be None.
     """
     async with aiosqlite.connect(get_db_path()) as db:
+        async with db.execute(
+            "SELECT first_name, last_name, previous_names FROM users WHERE user_id = ?",
+            (user_id,),
+        ) as cur:
+            existing = await cur.fetchone()
+
+        updated_prev = None
+        if existing is not None:
+            old_first, old_last, prev = existing
+            old_display = f"{old_first or ''} {old_last or ''}".strip()
+            new_display = f"{first_name or ''} {last_name or ''}".strip()
+            if old_display and old_display != new_display:
+                if prev:
+                    try:
+                        seen = json.loads(prev)
+                        if not isinstance(seen, list):
+                            seen = [seen] if seen else []
+                    except json.JSONDecodeError:
+                        seen = [n.strip() for n in prev.split(",") if n.strip()]
+                else:
+                    seen = []
+                if old_display not in seen:
+                    seen.append(old_display)
+                updated_prev = json.dumps(seen)
+            else:
+                updated_prev = prev
+
         await db.execute(
-            "INSERT INTO users (user_id, username, first_name, last_name) VALUES (?, ?, ?, ?) "
+            "INSERT INTO users (user_id, username, first_name, last_name, previous_names) VALUES (?, ?, ?, ?, ?) "
             "ON CONFLICT(user_id) DO UPDATE SET "
             "username = excluded.username, first_name = excluded.first_name, "
-            "last_name = excluded.last_name, "
+            "last_name = excluded.last_name, previous_names = excluded.previous_names, "
             "updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')",
-            (user_id, username, first_name, last_name),
+            (user_id, username, first_name, last_name, updated_prev),
         )
         await db.commit()
 
@@ -624,7 +662,9 @@ async def upsert_chat(
     Insert or update a chat record in the chats table.
 
     Always reflects the latest Telegram chat metadata. Called on every interaction
-    so that chat type and title changes are picked up automatically.
+    so that chat type and title changes are picked up automatically. When the
+    chat_title changes, the old title is appended to the previous_titles column
+    (JSON array, deduplicated) to enable search by historical identities.
 
     Args:
         chat_id: Telegram chat ID.
@@ -632,12 +672,38 @@ async def upsert_chat(
         chat_title: Display name of the group/channel, or None for private chats.
     """
     async with aiosqlite.connect(get_db_path()) as db:
+        async with db.execute(
+            "SELECT chat_title, previous_titles FROM chats WHERE chat_id = ?",
+            (chat_id,),
+        ) as cur:
+            existing = await cur.fetchone()
+
+        updated_prev = None
+        if existing is not None:
+            old_title, prev = existing
+            if old_title and old_title != chat_title:
+                if prev:
+                    try:
+                        seen = json.loads(prev)
+                        if not isinstance(seen, list):
+                            seen = [seen] if seen else []
+                    except json.JSONDecodeError:
+                        seen = [t.strip() for t in prev.split(",") if t.strip()]
+                else:
+                    seen = []
+                if old_title not in seen:
+                    seen.append(old_title)
+                updated_prev = json.dumps(seen)
+            else:
+                updated_prev = prev
+
         await db.execute(
-            "INSERT INTO chats (chat_id, chat_type, chat_title) VALUES (?, ?, ?) "
+            "INSERT INTO chats (chat_id, chat_type, chat_title, previous_titles) VALUES (?, ?, ?, ?) "
             "ON CONFLICT(chat_id) DO UPDATE SET "
             "chat_type = excluded.chat_type, chat_title = excluded.chat_title, "
+            "previous_titles = excluded.previous_titles, "
             "updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')",
-            (chat_id, chat_type, chat_title),
+            (chat_id, chat_type, chat_title, updated_prev),
         )
         await db.commit()
 
@@ -679,9 +745,12 @@ async def search_messages(
 
     Resolves speaker_query and chat_query using exact-match-first logic:
     1. Case-insensitive exact match - if exactly one entity matches, proceed.
-    2. Partial LIKE match - if exactly one accessible entity matches, proceed.
-       Zero matches: colloquial fallback (chat: all accessible; speaker: return empty).
-       Two or more matches: return an ambiguity sentinel dict instead of results.
+    2. Partial LIKE match (including historical names/titles) - if exactly one accessible
+       entity matches, proceed. Searches current username/first_name/last_name for speakers
+       and current chat_title for chats; falls back to previous_names and previous_titles
+       columns to find entities by their past identities. Zero matches: colloquial fallback
+       (chat: all accessible; speaker: return empty). Two or more matches: return an
+       ambiguity sentinel dict instead of results.
 
     Leading `@` is stripped from speaker_query automatically.
     Access control: results are always scoped to accessible_chat_ids (the caller's
@@ -716,7 +785,7 @@ async def search_messages(
         # Resolve speaker_query -> user_ids (exact match first, then LIKE)
         # Scoped to users who have at least one message in accessible_chat_ids (s3kp).
         # Batched over accessible_chat_ids to stay within SQLite's 999-parameter limit;
-        # each batch leaves 4 slots for name-matching params (exact: 3, partial: 4).
+        # each batch leaves 5 slots for name-matching params (exact: 3, partial: 5).
         speaker_ids: Optional[list[int]] = None
         speaker_amb: Optional[dict] = None
         if speaker_query:
@@ -746,8 +815,8 @@ async def search_messages(
             else:
                 like = f"%{q}%"
                 partial_seen: dict[int, tuple] = {}
-                for i in range(0, len(accessible_chat_ids), _SQLITE_MAX_PARAMS - 4):
-                    chunk = accessible_chat_ids[i:i + _SQLITE_MAX_PARAMS - 4]
+                for i in range(0, len(accessible_chat_ids), _SQLITE_MAX_PARAMS - 5):
+                    chunk = accessible_chat_ids[i:i + _SQLITE_MAX_PARAMS - 5]
                     chunk_ph = ','.join('?' * len(chunk))
                     async with db.execute(
                         f"SELECT DISTINCT u.user_id, "
@@ -756,8 +825,8 @@ async def search_messages(
                         f"FROM users u JOIN messages m ON m.user_id = u.user_id "
                         f"WHERE m.chat_id IN ({chunk_ph}) "
                         f"AND (u.username LIKE ? OR u.first_name LIKE ? OR u.last_name LIKE ? "
-                        f"OR (u.first_name || ' ' || u.last_name) LIKE ?)",
-                        (*chunk, like, like, like, like),
+                        f"OR (u.first_name || ' ' || u.last_name) LIKE ? OR u.previous_names LIKE ?)",
+                        (*chunk, like, like, like, like, like),
                     ) as cur:
                         for row in await cur.fetchall():
                             partial_seen.setdefault(row[0], row)
@@ -792,23 +861,23 @@ async def search_messages(
                 # Check for any global match first to distinguish colloquial fallback
                 # (zero global matches) from access-control rejection (global match, not accessible).
                 async with db.execute(
-                    "SELECT 1 FROM chats WHERE chat_title LIKE ? LIMIT 1",
-                    (like,),
+                    "SELECT 1 FROM chats WHERE chat_title LIKE ? OR previous_titles LIKE ? LIMIT 1",
+                    (like, like),
                 ) as cur:
                     has_global = await cur.fetchone() is not None
                 if not has_global:
                     pass  # Zero global matches: colloquial fallback (resolved_chat_ids stays None)
                 else:
                     # Batch accessible_chat_ids to stay within SQLite's 999-parameter limit;
-                    # reserve 1 slot for the LIKE parameter.
+                    # reserve 2 slots for the LIKE parameters (chat_title + previous_titles).
                     partial_accessible_seen: dict[int, tuple] = {}
-                    for i in range(0, len(accessible_chat_ids), _SQLITE_MAX_PARAMS - 1):
-                        chunk = accessible_chat_ids[i:i + _SQLITE_MAX_PARAMS - 1]
+                    for i in range(0, len(accessible_chat_ids), _SQLITE_MAX_PARAMS - 2):
+                        chunk = accessible_chat_ids[i:i + _SQLITE_MAX_PARAMS - 2]
                         chunk_ph = ','.join('?' * len(chunk))
                         async with db.execute(
                             f"SELECT chat_id, chat_title FROM chats "
-                            f"WHERE chat_title LIKE ? AND chat_id IN ({chunk_ph})",
-                            (like, *chunk),
+                            f"WHERE (chat_title LIKE ? OR previous_titles LIKE ?) AND chat_id IN ({chunk_ph})",
+                            (like, like, *chunk),
                         ) as cur:
                             for row in await cur.fetchall():
                                 partial_accessible_seen.setdefault(row[0], row)

{tellmgrambot-3.10.2 → tellmgrambot-3.10.4}/TeLLMgramBot/initialize.py

@@ -122,6 +122,7 @@ _SYSTEM_APPENDIX = (
     "Always invoke the search tool before concluding a message does not exist.\n"
     "Messages marked private are never shared between chats.\n"
     "Never reveal or repeat Telegram user IDs, chat IDs, or any other internal numeric identifiers in your responses.\n"
+    "When your context includes a '[Replying to Name, ...]' prefix indicating you were triggered via a reply, acknowledge the original author by name in your response.\n"
     "Current date and time: (not yet known)\n"
 )
 

{tellmgrambot-3.10.2 → tellmgrambot-3.10.4}/TeLLMgramBot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TeLLMgramBot
-Version: 3.10.2
+Version: 3.10.4
 Summary: LLM-powered Telegram bot (OpenAI + Anthropic)
 Home-page: https://github.com/Digital-Heresy/TeLLMgramBot
 Author: Digital Heresy
@@ -44,6 +44,7 @@ The basic goal of this project is to create a bridge between a Telegram Bot and
 * 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).
+  * Search automatically finds users and chats by their current or past names, so you can reference them however you remember them.
 * 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.
@@ -123,7 +124,7 @@ os.environ['TELLMGRAMBOT_VIRUSTOTAL_API_KEY'] = my_vault.get('virustotal_key')
 - `/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).
+- `/help` - Display available commands and usage information. In private chats, if you are a bot owner, also shows administrator-only commands (`/start`, `/stop`, `/wipe`).
 
 ### Group Chat Triggers
 The bot responds in groups when you:
@@ -143,7 +144,7 @@ When the bot is triggered in a group and about to respond (not deferring to anot
 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 `@`)
+   - `bot_owner`: Telegram username(s) with admin access (required, no `@`). Accepts a single string or a YAML list of usernames.
    - `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

{tellmgrambot-3.10.2 → tellmgrambot-3.10.4}/setup.py

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