PyPI - TeLLMgramBot - Versions diffs - 2.3.0__tar.gz → 2.4.0__tar.gz - Mend

TeLLMgramBot 2.3.0tar.gz → 2.4.0tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (24) hide show

{tellmgrambot-2.3.0 → tellmgrambot-2.4.0}/PKG-INFO RENAMED Viewed

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: TeLLMgramBot
-Version: 2.3.0
-Summary: OpenAI GPT, driven by Telegram
+Version: 2.4.0
+Summary: LLM-powered Telegram bot (OpenAI + Anthropic)
 Home-page: https://github.com/Digital-Heresy/TeLLMgramBot
 Author: Digital Heresy
 Author-email: ronin.atx@gmail.com
@@ -10,6 +10,7 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: openai>2.0
+Requires-Dist: anthropic>=0.40
 Requires-Dist: PyYAML
 Requires-Dist: httpx
 Requires-Dist: beautifulsoup4
@@ -29,9 +30,9 @@ Dynamic: requires-python
 Dynamic: summary
 # TeLLMgramBot
-The basic goal of this project is to create a bridge between a Telegram Bot and a Large Langage Model (LLM), like OpenAI's GPT models.
+The basic goal of this project is to create a bridge between a Telegram Bot and a Large Language Model (LLM), supporting both OpenAI's GPT models and Anthropic's Claude models.
 * To use this library, you must have a Telegram account **with a user name**, not just a phone number. If you don't have one, [create one online](https://telegram.org/).
-* If added to a Telgram group, the bot must be [adminstrator](https://www.alphr.com/add-admin-telegram/) in order to respond to a user calling out its name, initials, or nickname.
+* If added to a Telegram group, the bot must be [administrator](https://www.alphr.com/add-admin-telegram/) in order to respond to a user calling out its name, initials, or nickname.
 <img src="assets/TeLLMgramBot_Logo.png" width=200 align=center />
 ## Telegram Bot + LLM Encapsulation
@@ -39,34 +40,45 @@ The basic goal of this project is to create a bridge between a Telegram Bot and
 * The more dynamic conversation gets handed off to the LLM to manage prompts and responses, and Telegram acts as the interaction broker.
 * Pass the URL in [square brackets] and mention how the bot should interpret it.
   * Example: "What do you think of this article? [https://some_site/article]"
-  * This uses another GPT model, preferably GPT-5 or GPT-4o, to support more URL content with its higher token limit.
+  * This uses a separate model (configurable via `url_model`) to support more URL content with its higher token limit.
 * Tokens are used to measure the length of all conversation messages between the Telegram bot assistant and the user. This is useful to:
   * Ensure the length does not go over the model limit. If it does, prune oldest messages to fit within the limit.
   * Remember 50% of the past conversations when starting up TeLLMgramBot again.
 * Users can also clear their conversation history for privacy.
 ## Why Telegram?
-Using Telegram as the interface not only solves "exposing" the interface, but gives you boadloads of interactivity over a standard Command Line interface, or trying to create a website with input boxes and submit buttons to try to handle everything:
+Using Telegram as the interface not only solves "exposing" the interface, but gives you boatloads of interactivity over a standard Command Line interface, or trying to create a website with input boxes and submit buttons to try to handle everything:
 1. Telegram already lets you paste in verbose, multiline messages.
 2. Telegram already lets you paste in pictures, videos, links, etc.
 3. Telegram already lets you react with emojis, stickers, etc.
+## Supported LLM Providers
+TeLLMgramBot selects the LLM provider automatically based on the model name:
+| Model prefix | Provider | Example models |
+|---|---|---|
+| `gpt-` | OpenAI | `gpt-4o`, `gpt-4o-mini`, `gpt-5-mini` |
+| `claude-` | Anthropic | `claude-sonnet-4-6`, `claude-haiku-4-5` |
+Simply set `chat_model` (and optionally `url_model`) in your `config.yaml` to any supported model and supply the corresponding API key — no other changes needed.
 ## Directories
 When initializing TeLLMgramBot, the following directories get created:
 * `configs` - Contains bot configuration files.
   * `config.yaml` (can be a different name)
-    * This file sets main OpenAI parameters like naming and GPT models to process.
-    * The parameter `url_model` is to read URL content, different than `chat_model` that the bot normally uses to interact with the user.
-    * An empty `token_limit` would do the maximum amount of tokens supported by the `chat_model` (e.g. 128000 for `gpt-4o-mini`).
+    * This file sets main bot parameters like naming and the LLM models to use.
+    * `chat_model` — the model used for normal conversation (e.g. `gpt-5-mini` or `claude-sonnet-4-6`).
+    * `url_model` — the model used to read and summarize URL content, can differ from `chat_model`.
+    * An empty `token_limit` will use the maximum tokens supported by the `chat_model`.
   * `tokenGPT.yaml`
-    * This important YAML file contains token size parameters for supported OpenAI models.
-    * If the first time, `gpt-5`, `gpt-5-mini`, `gpt-5-nano`, `gpt-4o`, and `gpt-4o-mini` get populated, but the user can specify more models with token size parameters as needed.
+    * Contains token size parameters for all supported models.
+    * On first run, GPT and Claude model families are pre-populated. Additional models can be added manually.
 * `prompts` - Contains prompt files for how the bot interacts with any user.
     * `test_personality.prmpt` (can be a different name)
-      * This is a sample prompt file as a basis to test this library.
-      * The user can create more prompt files as needed for different personalities. See [OpenAI Playground](https://platform.openai.com/playground) to test some ideas.
+      * A sample prompt file as a basis to test this library.
+      * The user can create more prompt files as needed for different personalities.
     * `url_analysis.prmpt`
-      * This is a crucial prompt file to analyze URL content in brackets `[]` in a different model (such as `gpt-4o` or `gpt-4.1`).
+      * Prompt template used to analyze URL content passed in brackets `[]`.
 * `errorlogs`
    * Contains a `tellmgrambot_error.log` file to investigate if there are problems during the interaction.
    * User will also get notified to contact the owner.
@@ -84,24 +96,27 @@ TeLLMgramBot also creates or utilizes the following environment variables that c
 If neither of these are defined, the initialization would use the top-level execution run directory.
 ## API Keys
-To operate TeLLMgramBot, three API keys are required:
-* [OpenAI](https://platform.openai.com/overview) - Drives the actual GPT AI.
-* [Telegram](https://core.telegram.org/api) - Offers a Bot API through BotFather for the messaging platform.
-* [VirusTotal](https://www.virustotal.com/gui/home/) - Performs safety checks on URLs.
+To operate TeLLMgramBot, the following API keys are required:
+* **[OpenAI](https://platform.openai.com/overview)** — required when using a `gpt-*` model.
+* **[Anthropic](https://console.anthropic.com/)** — required when using a `claude-*` model.
+* **[Telegram](https://core.telegram.org/api)** — always required; offers a Bot API through BotFather.
+* **[VirusTotal](https://www.virustotal.com/gui/home/)** — always required; performs safety checks on URLs.
 There are two ways to populate each API key: environment variables or `.key` files.
 ### Environment Variables
-TeLLMgramBot uses the following environment variables that can be pre-loaded with the three API keys respectively:
-1. `TELLMGRAMBOT_OPENAI_API_KEY`
-2. `TELLMGRAMBOT_TELEGRAM_API_KEY`
-3. `TELLMGRAMBOT_VIRUSTOTAL_API_KEY`
+TeLLMgramBot uses the following environment variables for API keys:
+1. `TELLMGRAMBOT_OPENAI_API_KEY` *(OpenAI models)*
+2. `TELLMGRAMBOT_ANTHROPIC_API_KEY` *(Anthropic models)*
+3. `TELLMGRAMBOT_TELEGRAM_API_KEY`
+4. `TELLMGRAMBOT_VIRUSTOTAL_API_KEY`
 During spin-up time, a user can call out `os.environ[env_var]` to set those variables, like the following example:
 ```
 my_keys = Some_Vault_Fetch_Function()
-os.environ['TELLMGRAMBOT_OPENAI_API_KEY']     = my_keys['GPTKey']
+os.environ['TELLMGRAMBOT_OPENAI_API_KEY']     = my_keys['OpenAIKey']
+os.environ['TELLMGRAMBOT_ANTHROPIC_API_KEY']  = my_keys['AnthropicKey']
 os.environ['TELLMGRAMBOT_TELEGRAM_API_KEY']   = my_keys['BotFatherToken']
 os.environ['TELLMGRAMBOT_VIRUSTOTAL_API_KEY'] = my_keys['VirusTotalToken']
 ```
@@ -109,15 +124,16 @@ os.environ['TELLMGRAMBOT_VIRUSTOTAL_API_KEY'] = my_keys['VirusTotalToken']
 This means the user can implement whatever key vault they want to fetch the keys at runtime, without needing files stored in the directory.
 ### API Key Files
-The other route is to create three files by the base path during execution or a specified environment variable `TELLMGRAMBOT_KEYS_PATH`. By default, three files are created for the user to input each API key:
+The other route is to create files by the base path during execution or a specified environment variable `TELLMGRAMBOT_KEYS_PATH`. By default, files are created for the user to input each API key:
 1. `openai.key`
-2. `telegram.key`
-3. `virustotal.key`
+2. `anthropic.key` _(planned — env var only for now; see Phase 3)_
+3. `telegram.key`
+4. `virustotal.key`
 Each file with the associated API key will update its respective environment variable if not defined.
 ## Bot Setup
-This library includes an example script `test_local.py`, which uses files from the folders `configs` and `prompts` for TeLLMgramBot to process. The bot communicates with OpenAI via the **Responses API**, which replaces the older Chat Completions endpoint.
+This library includes an example script `test_local.py`, which uses files from the folders `configs` and `prompts` for TeLLMgramBot to process.
 1. Ensure the previous sections are followed with the proper API keys and your Telegram bot set.
 2. Install this library via PIP (`pip install TeLLMgramBot`) and then import into your project.
 3. Instantiate the bot by passing in various configuration pieces needed below.
@@ -127,8 +143,8 @@ This library includes an example script `test_local.py`, which uses files from t
        bot_owner      = <Bot owner's Telegram username>,
        bot_nickname   = <Bot nickname like 'Botty'>,
        bot_initials   = <Bot initials like 'FB'>,
-       chat_model     = <Conversation model like 'gpt-4o-mini'>,
-       url_model      = <URL analysis model like 'gpt-4o'>,
+       chat_model     = <Conversation model like 'gpt-4o-mini' or 'claude-sonnet-4-6'>,
+       url_model      = <URL analysis model like 'gpt-4o' or 'claude-haiku-4-5'>,
        token_limit    = <Maximum token count set, by default chat_model max>,
        persona_temp   = <LLM factual to creative value [0-2], by default 1.0>,
        persona_prompt = <System prompt summarizing bot personality>
@@ -143,9 +159,11 @@ This library includes an example script `test_local.py`, which uses files from t
 ## Resources
 * GitHub repository [python-telegram-bot](https://github.com/python-telegram-bot/python-telegram-bot) has guides to create a Telegram bot.
-* For more information on OpenAI models like `gpt-4o` and token limits, see the following:
-  * [OpenAI model overview and maximum tokens](https://platform.openai.com/docs/models).
-  * [OpenAI message conversion to tokens](https://github.com/openai/openai-python).
-  * [OpenAI custom fine-tuning](https://platform.openai.com/docs/guides/model-optimization).
-  * [OpenAI's tiktoken library, including some helpful guides](https://github.com/openai/tiktoken/tree/main).
-* [OpenAI Playground](https://platform.openai.com/playground) is a great place to test out prompts and responses.
+* For more information on OpenAI models and token limits:
+  * [OpenAI model overview and maximum tokens](https://platform.openai.com/docs/models)
+  * [OpenAI message conversion to tokens](https://github.com/openai/openai-python)
+  * [OpenAI custom fine-tuning](https://platform.openai.com/docs/guides/model-optimization)
+  * [OpenAI's tiktoken library](https://github.com/openai/tiktoken/tree/main)
+* For more information on Anthropic Claude models:
+  * [Anthropic model overview and context windows](https://docs.anthropic.com/en/docs/about-claude/models)
+  * [Anthropic Python SDK](https://github.com/anthropic/anthropic-sdk-python)

{tellmgrambot-2.3.0 → tellmgrambot-2.4.0}/README.md RENAMED Viewed

@@ -1,7 +1,7 @@
 # TeLLMgramBot
-The basic goal of this project is to create a bridge between a Telegram Bot and a Large Langage Model (LLM), like OpenAI's GPT models.
+The basic goal of this project is to create a bridge between a Telegram Bot and a Large Language Model (LLM), supporting both OpenAI's GPT models and Anthropic's Claude models.
 * To use this library, you must have a Telegram account **with a user name**, not just a phone number. If you don't have one, [create one online](https://telegram.org/).
-* If added to a Telgram group, the bot must be [adminstrator](https://www.alphr.com/add-admin-telegram/) in order to respond to a user calling out its name, initials, or nickname.
+* If added to a Telegram group, the bot must be [administrator](https://www.alphr.com/add-admin-telegram/) in order to respond to a user calling out its name, initials, or nickname.
 <img src="assets/TeLLMgramBot_Logo.png" width=200 align=center />
 ## Telegram Bot + LLM Encapsulation
@@ -9,34 +9,45 @@ The basic goal of this project is to create a bridge between a Telegram Bot and
 * The more dynamic conversation gets handed off to the LLM to manage prompts and responses, and Telegram acts as the interaction broker.
 * Pass the URL in [square brackets] and mention how the bot should interpret it.
   * Example: "What do you think of this article? [https://some_site/article]"
-  * This uses another GPT model, preferably GPT-5 or GPT-4o, to support more URL content with its higher token limit.
+  * This uses a separate model (configurable via `url_model`) to support more URL content with its higher token limit.
 * Tokens are used to measure the length of all conversation messages between the Telegram bot assistant and the user. This is useful to:
   * Ensure the length does not go over the model limit. If it does, prune oldest messages to fit within the limit.
   * Remember 50% of the past conversations when starting up TeLLMgramBot again.
 * Users can also clear their conversation history for privacy.
 ## Why Telegram?
-Using Telegram as the interface not only solves "exposing" the interface, but gives you boadloads of interactivity over a standard Command Line interface, or trying to create a website with input boxes and submit buttons to try to handle everything:
+Using Telegram as the interface not only solves "exposing" the interface, but gives you boatloads of interactivity over a standard Command Line interface, or trying to create a website with input boxes and submit buttons to try to handle everything:
 1. Telegram already lets you paste in verbose, multiline messages.
 2. Telegram already lets you paste in pictures, videos, links, etc.
 3. Telegram already lets you react with emojis, stickers, etc.
+## Supported LLM Providers
+TeLLMgramBot selects the LLM provider automatically based on the model name:
+| Model prefix | Provider | Example models |
+|---|---|---|
+| `gpt-` | OpenAI | `gpt-4o`, `gpt-4o-mini`, `gpt-5-mini` |
+| `claude-` | Anthropic | `claude-sonnet-4-6`, `claude-haiku-4-5` |
+Simply set `chat_model` (and optionally `url_model`) in your `config.yaml` to any supported model and supply the corresponding API key — no other changes needed.
 ## Directories
 When initializing TeLLMgramBot, the following directories get created:
 * `configs` - Contains bot configuration files.
   * `config.yaml` (can be a different name)
-    * This file sets main OpenAI parameters like naming and GPT models to process.
-    * The parameter `url_model` is to read URL content, different than `chat_model` that the bot normally uses to interact with the user.
-    * An empty `token_limit` would do the maximum amount of tokens supported by the `chat_model` (e.g. 128000 for `gpt-4o-mini`).
+    * This file sets main bot parameters like naming and the LLM models to use.
+    * `chat_model` — the model used for normal conversation (e.g. `gpt-5-mini` or `claude-sonnet-4-6`).
+    * `url_model` — the model used to read and summarize URL content, can differ from `chat_model`.
+    * An empty `token_limit` will use the maximum tokens supported by the `chat_model`.
   * `tokenGPT.yaml`
-    * This important YAML file contains token size parameters for supported OpenAI models.
-    * If the first time, `gpt-5`, `gpt-5-mini`, `gpt-5-nano`, `gpt-4o`, and `gpt-4o-mini` get populated, but the user can specify more models with token size parameters as needed.
+    * Contains token size parameters for all supported models.
+    * On first run, GPT and Claude model families are pre-populated. Additional models can be added manually.
 * `prompts` - Contains prompt files for how the bot interacts with any user.
     * `test_personality.prmpt` (can be a different name)
-      * This is a sample prompt file as a basis to test this library.
-      * The user can create more prompt files as needed for different personalities. See [OpenAI Playground](https://platform.openai.com/playground) to test some ideas.
+      * A sample prompt file as a basis to test this library.
+      * The user can create more prompt files as needed for different personalities.
     * `url_analysis.prmpt`
-      * This is a crucial prompt file to analyze URL content in brackets `[]` in a different model (such as `gpt-4o` or `gpt-4.1`).
+      * Prompt template used to analyze URL content passed in brackets `[]`.
 * `errorlogs`
    * Contains a `tellmgrambot_error.log` file to investigate if there are problems during the interaction.
    * User will also get notified to contact the owner.
@@ -54,24 +65,27 @@ TeLLMgramBot also creates or utilizes the following environment variables that c
 If neither of these are defined, the initialization would use the top-level execution run directory.
 ## API Keys
-To operate TeLLMgramBot, three API keys are required:
-* [OpenAI](https://platform.openai.com/overview) - Drives the actual GPT AI.
-* [Telegram](https://core.telegram.org/api) - Offers a Bot API through BotFather for the messaging platform.
-* [VirusTotal](https://www.virustotal.com/gui/home/) - Performs safety checks on URLs.
+To operate TeLLMgramBot, the following API keys are required:
+* **[OpenAI](https://platform.openai.com/overview)** — required when using a `gpt-*` model.
+* **[Anthropic](https://console.anthropic.com/)** — required when using a `claude-*` model.
+* **[Telegram](https://core.telegram.org/api)** — always required; offers a Bot API through BotFather.
+* **[VirusTotal](https://www.virustotal.com/gui/home/)** — always required; performs safety checks on URLs.
 There are two ways to populate each API key: environment variables or `.key` files.
 ### Environment Variables
-TeLLMgramBot uses the following environment variables that can be pre-loaded with the three API keys respectively:
-1. `TELLMGRAMBOT_OPENAI_API_KEY`
-2. `TELLMGRAMBOT_TELEGRAM_API_KEY`
-3. `TELLMGRAMBOT_VIRUSTOTAL_API_KEY`
+TeLLMgramBot uses the following environment variables for API keys:
+1. `TELLMGRAMBOT_OPENAI_API_KEY` *(OpenAI models)*
+2. `TELLMGRAMBOT_ANTHROPIC_API_KEY` *(Anthropic models)*
+3. `TELLMGRAMBOT_TELEGRAM_API_KEY`
+4. `TELLMGRAMBOT_VIRUSTOTAL_API_KEY`
 During spin-up time, a user can call out `os.environ[env_var]` to set those variables, like the following example:
 ```
 my_keys = Some_Vault_Fetch_Function()
-os.environ['TELLMGRAMBOT_OPENAI_API_KEY']     = my_keys['GPTKey']
+os.environ['TELLMGRAMBOT_OPENAI_API_KEY']     = my_keys['OpenAIKey']
+os.environ['TELLMGRAMBOT_ANTHROPIC_API_KEY']  = my_keys['AnthropicKey']
 os.environ['TELLMGRAMBOT_TELEGRAM_API_KEY']   = my_keys['BotFatherToken']
 os.environ['TELLMGRAMBOT_VIRUSTOTAL_API_KEY'] = my_keys['VirusTotalToken']
 ```
@@ -79,15 +93,16 @@ os.environ['TELLMGRAMBOT_VIRUSTOTAL_API_KEY'] = my_keys['VirusTotalToken']
 This means the user can implement whatever key vault they want to fetch the keys at runtime, without needing files stored in the directory.
 ### API Key Files
-The other route is to create three files by the base path during execution or a specified environment variable `TELLMGRAMBOT_KEYS_PATH`. By default, three files are created for the user to input each API key:
+The other route is to create files by the base path during execution or a specified environment variable `TELLMGRAMBOT_KEYS_PATH`. By default, files are created for the user to input each API key:
 1. `openai.key`
-2. `telegram.key`
-3. `virustotal.key`
+2. `anthropic.key` _(planned — env var only for now; see Phase 3)_
+3. `telegram.key`
+4. `virustotal.key`
 Each file with the associated API key will update its respective environment variable if not defined.
 ## Bot Setup
-This library includes an example script `test_local.py`, which uses files from the folders `configs` and `prompts` for TeLLMgramBot to process. The bot communicates with OpenAI via the **Responses API**, which replaces the older Chat Completions endpoint.
+This library includes an example script `test_local.py`, which uses files from the folders `configs` and `prompts` for TeLLMgramBot to process.
 1. Ensure the previous sections are followed with the proper API keys and your Telegram bot set.
 2. Install this library via PIP (`pip install TeLLMgramBot`) and then import into your project.
 3. Instantiate the bot by passing in various configuration pieces needed below.
@@ -97,8 +112,8 @@ This library includes an example script `test_local.py`, which uses files from t
        bot_owner      = <Bot owner's Telegram username>,
        bot_nickname   = <Bot nickname like 'Botty'>,
        bot_initials   = <Bot initials like 'FB'>,
-       chat_model     = <Conversation model like 'gpt-4o-mini'>,
-       url_model      = <URL analysis model like 'gpt-4o'>,
+       chat_model     = <Conversation model like 'gpt-4o-mini' or 'claude-sonnet-4-6'>,
+       url_model      = <URL analysis model like 'gpt-4o' or 'claude-haiku-4-5'>,
        token_limit    = <Maximum token count set, by default chat_model max>,
        persona_temp   = <LLM factual to creative value [0-2], by default 1.0>,
        persona_prompt = <System prompt summarizing bot personality>
@@ -113,9 +128,11 @@ This library includes an example script `test_local.py`, which uses files from t
 ## Resources
 * GitHub repository [python-telegram-bot](https://github.com/python-telegram-bot/python-telegram-bot) has guides to create a Telegram bot.
-* For more information on OpenAI models like `gpt-4o` and token limits, see the following:
-  * [OpenAI model overview and maximum tokens](https://platform.openai.com/docs/models).
-  * [OpenAI message conversion to tokens](https://github.com/openai/openai-python).
-  * [OpenAI custom fine-tuning](https://platform.openai.com/docs/guides/model-optimization).
-  * [OpenAI's tiktoken library, including some helpful guides](https://github.com/openai/tiktoken/tree/main).
-* [OpenAI Playground](https://platform.openai.com/playground) is a great place to test out prompts and responses.
+* For more information on OpenAI models and token limits:
+  * [OpenAI model overview and maximum tokens](https://platform.openai.com/docs/models)
+  * [OpenAI message conversion to tokens](https://github.com/openai/openai-python)
+  * [OpenAI custom fine-tuning](https://platform.openai.com/docs/guides/model-optimization)
+  * [OpenAI's tiktoken library](https://github.com/openai/tiktoken/tree/main)
+* For more information on Anthropic Claude models:
+  * [Anthropic model overview and context windows](https://docs.anthropic.com/en/docs/about-claude/models)
+  * [Anthropic Python SDK](https://github.com/anthropic/anthropic-sdk-python)

{tellmgrambot-2.3.0 → tellmgrambot-2.4.0}/TeLLMgramBot/TeLLMgramBot.py RENAMED Viewed

@@ -8,9 +8,8 @@ from math import floor
 from telegram import Bot, Update, Message, Chat, User
 from telegram.constants import MessageLimit
 from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes
-import openai
-from .openai_singleton import OpenAIClientSingleton
+from .providers.factory import get_provider
+from .providers.base import ContextLengthExceededError, ProviderAuthError, ProviderConnectionError
 from .initialize import INIT_BOT_CONFIG, init_structure, init_bot_config, init_bot_prompt
 from .conversation import Conversation
 from .tokenGPT import TokenGPT
@@ -19,7 +18,7 @@ from .utils import read_yaml, read_text, exact_word_match, generate_error_path,
 class TelegramBot:
     """
-    The bridge between the Telegram interface and Large Langage Model (LLM) using OpenAI's GPT models.
+    The bridge between the Telegram interface and a Large Language Model (LLM).
     - Tokens help retain conversation messages between the Telegram bot assistant and the user.
     - 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
@@ -136,21 +135,18 @@ class TelegramBot:
         # Check if the user is asking about a [URL]
         url_match = re.search(r'\[http(s)?://\S+]', text)
-        # Form the assistant's message based on low level easy stuff or send to GPT
-        # OpenAI's Responses API relies on the maximum number of tokens the selected model can support
+        # 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:
-            # URL content is passed into another model to summarize (GPT-4 preferred)
             await msg.reply_text("Sure, give me a moment to look at that URL...")
             reply = await handle_url_ask(text, self.chatgpt['url_model'])
         elif self._online:
-            # This is essentially the transition point between quick Telegram replies and GPT
-            response = await self.gpt_completion(uname)
-            reply = response.choices[0].message.content
+            # This is the transition point between quick Telegram replies and the LLM
+            reply = await self.llm_completion(uname)
         # Calculate the total token count of our conversation messages via tiktoken
         token_count = self.conversations[uname].get_message_token_count()
@@ -246,34 +242,32 @@ class TelegramBot:
         if msg:
             await msg.reply_text("Sorry, I ran into an error! Please contact my creator.")
-    async def gpt_completion(self, uname: str):
-        """Get the OpenAI response based on bot configuration."""
+    async def llm_completion(self, uname: str, _retry: bool = True) -> str:
+        """
+        Get the LLM response for the given user.
+        Selects the provider (OpenAI or Anthropic) automatically based on the configured model.
+        On context length errors, prunes the conversation and retries once. Other errors are
+        logged and return a user-facing fallback string.
+        """
+        provider = get_provider(self.chatgpt['chat_model'])
         try:
-            client = OpenAIClientSingleton.get_instance()
-            response = await client.chat.completions.create(
-                model=self.chatgpt['chat_model'],
-                messages=self.conversations[uname].messages,
-            )
-            return response
-        except openai.AuthenticationError as e:
-            # Handle authentication error
-            log_error(e, error_type='OpenAI-Authentication', error_filename=self.error_log)
-        except openai.BadRequestError as e:
-            # Handle invalid request error
-            if re.search(r'maximum context.+reduce the length', str(e)):
-                # Remove older messages and try again since the model's maximum token limit reached
-                print(f"Response to {uname} reached maximum context length, pruning conversation")
-                self.conversations[uname].prune_conversation(self.chatgpt['prune_back_to'])
-                return await self.gpt_completion(uname)
-            else:
-                # Another error is actually invalid to investigate
-                log_error(e, error_type='OpenAI-BadRequest', error_filename=self.error_log)
-        except openai.APIConnectionError as e:
-            # Handle API connection error
-            log_error(e, error_type='OpenAI-APIConnection', error_filename=self.error_log)
+            return await provider.complete(self.chatgpt['chat_model'], self.conversations[uname].messages)
+        except ContextLengthExceededError:
+            if not _retry:
+                return "Sorry, your conversation is too long for me to respond to. Try /forget to start fresh."
+            print(f"Response to {uname} reached maximum context length, pruning conversation")
+            self.conversations[uname].prune_conversation(self.chatgpt['prune_back_to'])
+            return await self.llm_completion(uname, _retry=False)
+        except ProviderAuthError as e:
+            log_error(e, error_type='Authentication', error_filename=self.error_log)
+            return "Sorry, I'm having trouble authenticating with the AI provider. Please contact the bot owner."
+        except ProviderConnectionError as e:
+            log_error(e, error_type='Connection', error_filename=self.error_log)
+            return "Sorry, I couldn't reach the AI provider. Please try again in a moment."
         except Exception as e:
-            # Catch any other unexpected exceptions
             log_error(e, error_type='Other', error_filename=self.error_log)
+            return "Sorry, something went wrong on my end. Please try again."
     def start_polling(self):
         """The main polling "loop" the user interacts with via Telegram."""
@@ -344,7 +338,7 @@ class TelegramBot:
         self.chatgpt['prune_back_to'] = max(0, self.chatgpt['prune_threshold'] - 500)
         # Bot is now ready and active by default
-        self._online = True
+        self._online = True
     def set(config_file='config.yaml', prompt_file='test_personality.prmpt'):
         """Set TeLLMgramBot object based on its YAML configuration and prompt files."""

{tellmgrambot-2.3.0 → tellmgrambot-2.4.0}/TeLLMgramBot/conversation.py RENAMED Viewed

@@ -1,4 +1,4 @@
-# Provides TeLLMgramBot a way to store and retrieve conversation messages by the OpenAI model
+# Manages per-user conversation history, token counting, and session persistence for any LLM provider
 import os
 import re
 import sys
@@ -10,8 +10,8 @@ from .utils import get_safe_username, read_reverse_order, append_text_file_path,
 # noinspection RegExpRedundantEscape,PyTypeChecker
 class Conversation:
     """
-    Defines a user-assistant interaction based on the assistant's Generative AI model and prompt to contextualize
-    with message history. Like memory, if reaching the maximum amount of tokens, prunes earliest messages under limit.
+    Manages a user-assistant conversation including message history, token counting, and session log persistence.
+    Works with any LLM provider (OpenAI, Anthropic). When the token limit is approached, oldest messages are pruned.
     """
     def __init__(self, user_name: str, assist_name: str, system_content: str, system_model="gpt-4o-mini"):
         self.error_log = generate_error_path()
@@ -21,7 +21,7 @@ class Conversation:
         self.assist_name = assist_name
         self.names_print = f"User {self.user_name} & Assistant {self.assist_name}"
-        # System defines how the assistant will respond to the user by prompt and GPT model
+        # System defines how the assistant will respond to the user by prompt and LLM model
         self.system_content = system_content
         self.system_model = TokenGPT(system_model)
         self.messages = [{"role": "system", "content": system_content}]

{tellmgrambot-2.3.0 → tellmgrambot-2.4.0}/TeLLMgramBot/initialize.py RENAMED Viewed

@@ -50,13 +50,17 @@ def init_directories():
 def init_keys():
     """
-    TeLLMgramBot utilizes three API keys by environment variables:
-    - TELLMGRAMBOT_OPENAI_API_KEY
-    - TELLMGRAMBOT_TELEGRAM_API_KEY
-    - TELLMGRAMBOT_VIRUSTOTAL_API_KEY
+    TeLLMgramBot utilizes the following API keys via environment variables:
+    - TELLMGRAMBOT_OPENAI_API_KEY     (currently required at startup regardless of configured model; Phase 3 will make this conditional)
+    - TELLMGRAMBOT_TELEGRAM_API_KEY   (always required)
+    - TELLMGRAMBOT_VIRUSTOTAL_API_KEY (always required)
-    If neither one above exists, retrieve its key file by base execution path or
-    TELLMGRAMBOT_KEYS_PATH. If no such key file, request user input with resources.
+    The Anthropic key (TELLMGRAMBOT_ANTHROPIC_API_KEY) is read directly by
+    AnthropicProvider at call time and is required when using claude-* models.
+    Key file support (anthropic.key) is planned for Phase 3.
+    If an environment variable is not set, its key file is read from the base execution
+    path or TELLMGRAMBOT_KEYS_PATH. If no file exists, a placeholder is created.
     - openai.key
     - telegram.key
     - virustotal.key
@@ -128,22 +132,32 @@ def init_tokenGPT_config(file='tokenGPT.yaml') -> str:
     try:
         # Create a basic GPT configuration of token parameters by filename
         return generate_file_path(os.environ[env_var], file, "TokenGPT configuration",
-            "# Available parameters per base OpenAI model with default values:\n"
+            "# Available parameters per model with default values:\n"
             "#   max_tokens: 4097\n"
-            "#   tokens_per_message: 3\n"
-            "#   tokens_per_name: 1\n"
+            "#   tokens_per_message: 3  (OpenAI models only)\n"
+            "#   tokens_per_name: 1     (OpenAI models only)\n"
             "# For OpenAI's updated list of models, please see:\n"
             "#   https://platform.openai.com/docs/models\n"
+            "# For Anthropic's updated list of models, please see:\n"
+            "#   https://docs.anthropic.com/en/docs/about-claude/models\n"
             "'gpt-4o':\n"
             "  max_tokens: 128000\n"
             "'gpt-4o-mini':\n"
             "  max_tokens: 128000\n"
             "'gpt-5':\n"
             "  max_tokens: 400000\n"
-            "'gpt-5-mini':\n"
+            "'gpt-5-mini':\n"
             "  max_tokens: 400000\n"
             "'gpt-5-nano':\n"
             "  max_tokens: 400000\n"
+            "'claude-opus-4-6':\n"
+            "  max_tokens: 200000\n"
+            "'claude-sonnet-4-6':\n"
+            "  max_tokens: 200000\n"
+            "'claude-haiku-4-5':\n"
+            "  max_tokens: 200000\n"
+            "'claude-haiku-4-5-20251001':\n"
+            "  max_tokens: 200000\n"
         )
     except KeyError:
         sys.exit(f"{env_var} must be defined to create file '{file}'! Exiting...")
@@ -158,9 +172,9 @@ def init_bot_prompt(file='test_personality.prmpt') -> str:
     env_var = "TELLMGRAMBOT_PROMPTS_PATH"
     try:
         return generate_file_path(os.environ[env_var], file, "bot personality prompt",
-            "You are a test harness bot based on a GPT-5 mini model that can:\n"
-            "1. Fetch URLs, provided the user supply a URL in [square brackets].\n"
-            "2. Scrub URLs to ensure they are safe for work via the VirusTotal API.\n"
+            "You are a test harness bot that can:\n"
+            "1. Fetch and analyze URLs provided in [square brackets].\n"
+            "2. Safety-check URLs via VirusTotal.\n"
         )
     except KeyError:
         sys.exit(f"{env_var} must be defined to create file '{file}'! Exiting...")

{tellmgrambot-2.3.0 → tellmgrambot-2.4.0}/TeLLMgramBot/message_handlers.py RENAMED Viewed

@@ -6,7 +6,7 @@ import validators
 from .initialize import init_url_prompt
 from .tokenGPT import TokenGPT
 from .web_utils import fetch_url, strip_html_markup, InvalidURLException, InsecureURLException, SusURLException
-from .openai_singleton import OpenAIClientSingleton
+from .providers.factory import get_provider
 def handle_greetings(text: str) -> Optional[str]:
     """
@@ -55,7 +55,7 @@ async def handle_url_ask(text: str, model='gpt-4o') -> Optional[str]:
             if not validators.url(url):
                 raise InvalidURLException(f'Invalid URL parsed by message_handlers.handle_url_ask(): {url}')
-            # Let's begin by building the OpenAI messages to set:
+            # Build messages:
             # 1. URL content to be added into the system prompt template
             # 2. User message requesting URL in [square brackets]
             messages = [
@@ -86,16 +86,11 @@ async def handle_url_ask(text: str, model='gpt-4o') -> Optional[str]:
                 template = f.read()
             messages[0]["content"] = template.format(url_content=messages[0]["content"])
-            # Call OpenAI API for the response that summarizes URL content
-            client = OpenAIClientSingleton.get_instance()
+            # Call the LLM for the response that summarizes URL content
             try:
-                ask_results = await client.chat.completions.create(
-                    model=model,
-                    messages=messages
-                )
-                response = ask_results.choices[0].message.content
+                response = await get_provider(model).complete(model, messages)
             except Exception as e:
-                print(f"Error in calling OpenAI API: {e}")
+                print(f"Error calling LLM provider: {e}")
                 return "Something went wrong while fetching the URL. Please try again later."
             # If the URL content was too long, let the user know

tellmgrambot-2.4.0/TeLLMgramBot/providers/__init__.py ADDED Viewed

File without changes

tellmgrambot-2.4.0/TeLLMgramBot/providers/anthropic_provider.py ADDED Viewed

@@ -0,0 +1,53 @@
+import os
+import anthropic
+from anthropic import AsyncAnthropic
+from .base import LLMProvider, ContextLengthExceededError, ProviderAuthError, ProviderConnectionError
+# Safe default for max output tokens; configurable in Phase 3
+_DEFAULT_MAX_OUTPUT_TOKENS = 8192
+class AnthropicProvider(LLMProvider):
+    """LLM provider implementation for Anthropic Claude models."""
+    _client: AsyncAnthropic | None = None
+    def _get_client(self) -> AsyncAnthropic:
+        if AnthropicProvider._client is None:
+            if not (api_key := os.environ.get('TELLMGRAMBOT_ANTHROPIC_API_KEY')):
+                raise ProviderAuthError("Anthropic API key not set. Provide TELLMGRAMBOT_ANTHROPIC_API_KEY.")
+            AnthropicProvider._client = AsyncAnthropic(api_key=api_key)
+        return AnthropicProvider._client
+    async def complete(self, model: str, messages: list[dict]) -> str:
+        client = self._get_client()
+        # Anthropic takes system prompt as a separate parameter, not in the messages list
+        system = None
+        chat_messages = []
+        for msg in messages:
+            if msg['role'] == 'system':
+                system = msg['content']
+            else:
+                chat_messages.append(msg)
+        kwargs = {
+            'model': model,
+            'max_tokens': _DEFAULT_MAX_OUTPUT_TOKENS,
+            'messages': chat_messages,
+        }
+        if system:
+            kwargs['system'] = system
+        try:
+            response = await client.messages.create(**kwargs)
+            if not response.content or response.content[0].type != 'text':
+                return ""
+            return response.content[0].text
+        except anthropic.AuthenticationError as e:
+            raise ProviderAuthError(f"Anthropic authentication failed: {e}") from e
+        except anthropic.BadRequestError as e:
+            if 'too long' in str(e).lower() or 'context' in str(e).lower():
+                raise ContextLengthExceededError() from e
+            raise
+        except anthropic.APIConnectionError as e:
+            raise ProviderConnectionError(f"Anthropic connection error: {e}") from e

tellmgrambot-2.4.0/TeLLMgramBot/providers/base.py ADDED Viewed

@@ -0,0 +1,27 @@
+from abc import ABC, abstractmethod
+class ContextLengthExceededError(Exception):
+    """Raised when a request exceeds the model's context window."""
+    pass
+class ProviderAuthError(Exception):
+    """Raised when an API key is invalid or missing."""
+    pass
+class ProviderConnectionError(Exception):
+    """Raised when the provider's API cannot be reached."""
+    pass
+class LLMProvider(ABC):
+    """Abstract base class for LLM provider implementations."""
+    @abstractmethod
+    async def complete(self, model: str, messages: list[dict]) -> str:
+        """Send messages to the model and return the response text.
+        Raises:
+            ContextLengthExceededError: if the request exceeds the model's context window.
+            ProviderAuthError: if authentication fails.
+            ProviderConnectionError: if the API cannot be reached.
+        """
+        pass

tellmgrambot-2.4.0/TeLLMgramBot/providers/factory.py ADDED Viewed

@@ -0,0 +1,23 @@
+from .base import LLMProvider
+from .openai_provider import OpenAIProvider
+from .anthropic_provider import AnthropicProvider
+_providers: dict[str, LLMProvider] = {}
+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
+    """
+    if model.startswith('claude-'):
+        key = 'anthropic'
+        if key not in _providers:
+            _providers[key] = AnthropicProvider()
+        return _providers[key]
+    else:
+        key = 'openai'
+        if key not in _providers:
+            _providers[key] = OpenAIProvider()
+        return _providers[key]

tellmgrambot-2.4.0/TeLLMgramBot/providers/openai_provider.py ADDED Viewed

@@ -0,0 +1,34 @@
+import re
+import os
+import openai
+from openai import AsyncOpenAI
+from .base import LLMProvider, ContextLengthExceededError, ProviderAuthError, ProviderConnectionError
+class OpenAIProvider(LLMProvider):
+    """LLM provider implementation for OpenAI models."""
+    _client: AsyncOpenAI | None = None
+    def _get_client(self) -> AsyncOpenAI:
+        if OpenAIProvider._client is None:
+            if not (api_key := os.environ.get('TELLMGRAMBOT_OPENAI_API_KEY')):
+                raise ProviderAuthError("OpenAI API key not set. Provide TELLMGRAMBOT_OPENAI_API_KEY.")
+            OpenAIProvider._client = AsyncOpenAI(api_key=api_key)
+        return OpenAIProvider._client
+    async def complete(self, model: str, messages: list[dict]) -> str:
+        client = self._get_client()
+        try:
+            response = await client.chat.completions.create(
+                model=model,
+                messages=messages,
+            )
+            return response.choices[0].message.content
+        except openai.AuthenticationError as e:
+            raise ProviderAuthError(f"OpenAI authentication failed: {e}") from e
+        except openai.BadRequestError as e:
+            if re.search(r'maximum context.+reduce the length', str(e)):
+                raise ContextLengthExceededError() from e
+            raise
+        except openai.APIConnectionError as e:
+            raise ProviderConnectionError(f"OpenAI connection error: {e}") from e

{tellmgrambot-2.3.0 → tellmgrambot-2.4.0}/TeLLMgramBot/tokenGPT.py RENAMED Viewed

@@ -5,19 +5,19 @@ from .initialize import init_tokenGPT_config
 class TokenGPT:
     """
-    Define Generative AI model parameters and token count of messages using OpenAI's tiktoken library.
-    First-time execution creates a tokenGPT.yaml file with example Generative Pre-trained Transformer (GPT) models,
-    which can be expanded by the user for additional inputs or modifications like tokens per message.
+    Define LLM model parameters and token count of messages.
+    First-time execution creates a tokenGPT.yaml file with example models,
+    which can be expanded by the user for additional inputs or modifications like tokens per message.
+    OpenAI models use tiktoken for counting; other models use a character-based approximation.
     Sources:
     - https://platform.openai.com/docs/models
-    - https://github.com/openai/openai-python
-    - https://platform.openai.com/docs/guides/model-optimization
+    - https://docs.anthropic.com/en/docs/about-claude/models
     """
-    def __init__(self, openai_model="gpt-4o-mini", yaml_file="tokenGPT.yaml"):
-        # The OpenAI model name may also be a fine-tuned model, which has the base model
+    def __init__(self, model="gpt-4o-mini", yaml_file="tokenGPT.yaml"):
+        # The model name may also be an OpenAI fine-tuned model, which has the base model
         # after "ft:" up to the next colon (:), like "ft:gpt-4o-mini:..."
-        self.model = re.search("^ft:([^:]*)", openai_model).group(1) if openai_model.startswith("ft:") else openai_model
+        self.model = re.search("^ft:([^:]*)", model).group(1) if model.startswith("ft:") else model
         self.config_path = init_tokenGPT_config(yaml_file)
         # Get model parameters by configuration file for the:
@@ -27,18 +27,18 @@ class TokenGPT:
         self.param = None
         for key, param in read_yaml(self.config_path).items():
             # Set parameters if the configuration key matches either:
-            #  > Full OpenAI model name (an exact match to stop searching)
-            #  > Base model name after "ft:" up to next colon (:), part of the OpenAI model name
-            if key == openai_model or key == self.model:
+            #  > Full model name (an exact match to stop searching)
+            #  > Base model name after "ft:" up to next colon (:), for fine-tuned OpenAI models
+            if key == model or key == self.model:
                 self.param = param
-                if key == openai_model:
+                if key == model:
                     break
-        # If the parameters are not set, the OpenAI model name is invalid or
+        # If the parameters are not set, the model name is invalid or
         # has an undefined model configuration not set in the YAML file
         if self.param is None:
             raise ValueError(
-                f"OpenAI model \"{openai_model}\" is invalid or its base model is not in:\n{self.config_path}")
+                f"Model \"{model}\" is invalid or its base model is not in:\n{self.config_path}")
         # Set token model parameter defaults, unless defined in configuration:
         if 'max_tokens' not in self.param:
@@ -48,16 +48,20 @@ class TokenGPT:
         if 'tokens_per_name' not in self.param:
             self.param['tokens_per_name'] = 1
-        # Get OpenAI's tiktoken encoding of the base model name
-        try:
-            self.encoding = tiktoken.encoding_for_model(self.model)
-        except Exception:
-            fallback = "o200k_base" if re.search("^gpt-[45]", self.model) else "cl100k_base"
+        # Claude models are not supported by tiktoken; use a character-based approximation
+        # (~4 chars per token) instead. A future version may add SDK-native Anthropic counting.
+        self._use_char_approximation = self.model.startswith('claude-')
+        self.encoding = None
+        if not self._use_char_approximation:
             try:
-                self.encoding = tiktoken.get_encoding(fallback)
+                self.encoding = tiktoken.encoding_for_model(self.model)
             except Exception:
-                self.encoding = tiktoken.get_encoding("cl100k_base")
-            print(f"Warning: using {self.encoding.name} encoding for model \"{self.model}\"")
+                fallback = "o200k_base" if re.search("^gpt-[45]", self.model) else "cl100k_base"
+                try:
+                    self.encoding = tiktoken.get_encoding(fallback)
+                except Exception:
+                    self.encoding = tiktoken.get_encoding("cl100k_base")
+                print(f"Warning: using {self.encoding.name} encoding for model \"{self.model}\"")
     def max_tokens(self) -> int:
         """Query the Generative AI model's maximum amount of tokens."""
@@ -65,11 +69,16 @@ class TokenGPT:
     def num_tokens_from_messages(self, messages: dict[str, str]) -> int:
         """
-        Return the number of tokens based on a list of messages and the Generative AI model in use.
-        Each message size is determined by the number of tokens via OpenAI's tiktoken library.
+        Return the number of tokens based on a list of messages and the model in use.
+        For OpenAI models: uses tiktoken for an accurate count.
+        For Claude models: uses a character-based approximation (~4 chars per token).
         Source: https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb
         """
+        if self._use_char_approximation:
+            return sum(max(1, len(v) // 4) for msg in messages for v in msg.values())
         num_tokens = 0
         for message in messages:
             num_tokens += self.param['tokens_per_message']

{tellmgrambot-2.3.0 → tellmgrambot-2.4.0}/TeLLMgramBot/web_utils.py RENAMED Viewed

@@ -20,7 +20,6 @@ class SusURLException(Exception):
     """Exception raised for insecure URLs."""
     pass
 class FetchingError(Exception):
     """Exception raised for errors during fetching."""
     pass

{tellmgrambot-2.3.0 → tellmgrambot-2.4.0}/TeLLMgramBot.egg-info/PKG-INFO RENAMED Viewed

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: TeLLMgramBot
-Version: 2.3.0
-Summary: OpenAI GPT, driven by Telegram
+Version: 2.4.0
+Summary: LLM-powered Telegram bot (OpenAI + Anthropic)
 Home-page: https://github.com/Digital-Heresy/TeLLMgramBot
 Author: Digital Heresy
 Author-email: ronin.atx@gmail.com
@@ -10,6 +10,7 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: openai>2.0
+Requires-Dist: anthropic>=0.40
 Requires-Dist: PyYAML
 Requires-Dist: httpx
 Requires-Dist: beautifulsoup4
@@ -29,9 +30,9 @@ Dynamic: requires-python
 Dynamic: summary
 # TeLLMgramBot
-The basic goal of this project is to create a bridge between a Telegram Bot and a Large Langage Model (LLM), like OpenAI's GPT models.
+The basic goal of this project is to create a bridge between a Telegram Bot and a Large Language Model (LLM), supporting both OpenAI's GPT models and Anthropic's Claude models.
 * To use this library, you must have a Telegram account **with a user name**, not just a phone number. If you don't have one, [create one online](https://telegram.org/).
-* If added to a Telgram group, the bot must be [adminstrator](https://www.alphr.com/add-admin-telegram/) in order to respond to a user calling out its name, initials, or nickname.
+* If added to a Telegram group, the bot must be [administrator](https://www.alphr.com/add-admin-telegram/) in order to respond to a user calling out its name, initials, or nickname.
 <img src="assets/TeLLMgramBot_Logo.png" width=200 align=center />
 ## Telegram Bot + LLM Encapsulation
@@ -39,34 +40,45 @@ The basic goal of this project is to create a bridge between a Telegram Bot and
 * The more dynamic conversation gets handed off to the LLM to manage prompts and responses, and Telegram acts as the interaction broker.
 * Pass the URL in [square brackets] and mention how the bot should interpret it.
   * Example: "What do you think of this article? [https://some_site/article]"
-  * This uses another GPT model, preferably GPT-5 or GPT-4o, to support more URL content with its higher token limit.
+  * This uses a separate model (configurable via `url_model`) to support more URL content with its higher token limit.
 * Tokens are used to measure the length of all conversation messages between the Telegram bot assistant and the user. This is useful to:
   * Ensure the length does not go over the model limit. If it does, prune oldest messages to fit within the limit.
   * Remember 50% of the past conversations when starting up TeLLMgramBot again.
 * Users can also clear their conversation history for privacy.
 ## Why Telegram?
-Using Telegram as the interface not only solves "exposing" the interface, but gives you boadloads of interactivity over a standard Command Line interface, or trying to create a website with input boxes and submit buttons to try to handle everything:
+Using Telegram as the interface not only solves "exposing" the interface, but gives you boatloads of interactivity over a standard Command Line interface, or trying to create a website with input boxes and submit buttons to try to handle everything:
 1. Telegram already lets you paste in verbose, multiline messages.
 2. Telegram already lets you paste in pictures, videos, links, etc.
 3. Telegram already lets you react with emojis, stickers, etc.
+## Supported LLM Providers
+TeLLMgramBot selects the LLM provider automatically based on the model name:
+| Model prefix | Provider | Example models |
+|---|---|---|
+| `gpt-` | OpenAI | `gpt-4o`, `gpt-4o-mini`, `gpt-5-mini` |
+| `claude-` | Anthropic | `claude-sonnet-4-6`, `claude-haiku-4-5` |
+Simply set `chat_model` (and optionally `url_model`) in your `config.yaml` to any supported model and supply the corresponding API key — no other changes needed.
 ## Directories
 When initializing TeLLMgramBot, the following directories get created:
 * `configs` - Contains bot configuration files.
   * `config.yaml` (can be a different name)
-    * This file sets main OpenAI parameters like naming and GPT models to process.
-    * The parameter `url_model` is to read URL content, different than `chat_model` that the bot normally uses to interact with the user.
-    * An empty `token_limit` would do the maximum amount of tokens supported by the `chat_model` (e.g. 128000 for `gpt-4o-mini`).
+    * This file sets main bot parameters like naming and the LLM models to use.
+    * `chat_model` — the model used for normal conversation (e.g. `gpt-5-mini` or `claude-sonnet-4-6`).
+    * `url_model` — the model used to read and summarize URL content, can differ from `chat_model`.
+    * An empty `token_limit` will use the maximum tokens supported by the `chat_model`.
   * `tokenGPT.yaml`
-    * This important YAML file contains token size parameters for supported OpenAI models.
-    * If the first time, `gpt-5`, `gpt-5-mini`, `gpt-5-nano`, `gpt-4o`, and `gpt-4o-mini` get populated, but the user can specify more models with token size parameters as needed.
+    * Contains token size parameters for all supported models.
+    * On first run, GPT and Claude model families are pre-populated. Additional models can be added manually.
 * `prompts` - Contains prompt files for how the bot interacts with any user.
     * `test_personality.prmpt` (can be a different name)
-      * This is a sample prompt file as a basis to test this library.
-      * The user can create more prompt files as needed for different personalities. See [OpenAI Playground](https://platform.openai.com/playground) to test some ideas.
+      * A sample prompt file as a basis to test this library.
+      * The user can create more prompt files as needed for different personalities.
     * `url_analysis.prmpt`
-      * This is a crucial prompt file to analyze URL content in brackets `[]` in a different model (such as `gpt-4o` or `gpt-4.1`).
+      * Prompt template used to analyze URL content passed in brackets `[]`.
 * `errorlogs`
    * Contains a `tellmgrambot_error.log` file to investigate if there are problems during the interaction.
    * User will also get notified to contact the owner.
@@ -84,24 +96,27 @@ TeLLMgramBot also creates or utilizes the following environment variables that c
 If neither of these are defined, the initialization would use the top-level execution run directory.
 ## API Keys
-To operate TeLLMgramBot, three API keys are required:
-* [OpenAI](https://platform.openai.com/overview) - Drives the actual GPT AI.
-* [Telegram](https://core.telegram.org/api) - Offers a Bot API through BotFather for the messaging platform.
-* [VirusTotal](https://www.virustotal.com/gui/home/) - Performs safety checks on URLs.
+To operate TeLLMgramBot, the following API keys are required:
+* **[OpenAI](https://platform.openai.com/overview)** — required when using a `gpt-*` model.
+* **[Anthropic](https://console.anthropic.com/)** — required when using a `claude-*` model.
+* **[Telegram](https://core.telegram.org/api)** — always required; offers a Bot API through BotFather.
+* **[VirusTotal](https://www.virustotal.com/gui/home/)** — always required; performs safety checks on URLs.
 There are two ways to populate each API key: environment variables or `.key` files.
 ### Environment Variables
-TeLLMgramBot uses the following environment variables that can be pre-loaded with the three API keys respectively:
-1. `TELLMGRAMBOT_OPENAI_API_KEY`
-2. `TELLMGRAMBOT_TELEGRAM_API_KEY`
-3. `TELLMGRAMBOT_VIRUSTOTAL_API_KEY`
+TeLLMgramBot uses the following environment variables for API keys:
+1. `TELLMGRAMBOT_OPENAI_API_KEY` *(OpenAI models)*
+2. `TELLMGRAMBOT_ANTHROPIC_API_KEY` *(Anthropic models)*
+3. `TELLMGRAMBOT_TELEGRAM_API_KEY`
+4. `TELLMGRAMBOT_VIRUSTOTAL_API_KEY`
 During spin-up time, a user can call out `os.environ[env_var]` to set those variables, like the following example:
 ```
 my_keys = Some_Vault_Fetch_Function()
-os.environ['TELLMGRAMBOT_OPENAI_API_KEY']     = my_keys['GPTKey']
+os.environ['TELLMGRAMBOT_OPENAI_API_KEY']     = my_keys['OpenAIKey']
+os.environ['TELLMGRAMBOT_ANTHROPIC_API_KEY']  = my_keys['AnthropicKey']
 os.environ['TELLMGRAMBOT_TELEGRAM_API_KEY']   = my_keys['BotFatherToken']
 os.environ['TELLMGRAMBOT_VIRUSTOTAL_API_KEY'] = my_keys['VirusTotalToken']
 ```
@@ -109,15 +124,16 @@ os.environ['TELLMGRAMBOT_VIRUSTOTAL_API_KEY'] = my_keys['VirusTotalToken']
 This means the user can implement whatever key vault they want to fetch the keys at runtime, without needing files stored in the directory.
 ### API Key Files
-The other route is to create three files by the base path during execution or a specified environment variable `TELLMGRAMBOT_KEYS_PATH`. By default, three files are created for the user to input each API key:
+The other route is to create files by the base path during execution or a specified environment variable `TELLMGRAMBOT_KEYS_PATH`. By default, files are created for the user to input each API key:
 1. `openai.key`
-2. `telegram.key`
-3. `virustotal.key`
+2. `anthropic.key` _(planned — env var only for now; see Phase 3)_
+3. `telegram.key`
+4. `virustotal.key`
 Each file with the associated API key will update its respective environment variable if not defined.
 ## Bot Setup
-This library includes an example script `test_local.py`, which uses files from the folders `configs` and `prompts` for TeLLMgramBot to process. The bot communicates with OpenAI via the **Responses API**, which replaces the older Chat Completions endpoint.
+This library includes an example script `test_local.py`, which uses files from the folders `configs` and `prompts` for TeLLMgramBot to process.
 1. Ensure the previous sections are followed with the proper API keys and your Telegram bot set.
 2. Install this library via PIP (`pip install TeLLMgramBot`) and then import into your project.
 3. Instantiate the bot by passing in various configuration pieces needed below.
@@ -127,8 +143,8 @@ This library includes an example script `test_local.py`, which uses files from t
        bot_owner      = <Bot owner's Telegram username>,
        bot_nickname   = <Bot nickname like 'Botty'>,
        bot_initials   = <Bot initials like 'FB'>,
-       chat_model     = <Conversation model like 'gpt-4o-mini'>,
-       url_model      = <URL analysis model like 'gpt-4o'>,
+       chat_model     = <Conversation model like 'gpt-4o-mini' or 'claude-sonnet-4-6'>,
+       url_model      = <URL analysis model like 'gpt-4o' or 'claude-haiku-4-5'>,
        token_limit    = <Maximum token count set, by default chat_model max>,
        persona_temp   = <LLM factual to creative value [0-2], by default 1.0>,
        persona_prompt = <System prompt summarizing bot personality>
@@ -143,9 +159,11 @@ This library includes an example script `test_local.py`, which uses files from t
 ## Resources
 * GitHub repository [python-telegram-bot](https://github.com/python-telegram-bot/python-telegram-bot) has guides to create a Telegram bot.
-* For more information on OpenAI models like `gpt-4o` and token limits, see the following:
-  * [OpenAI model overview and maximum tokens](https://platform.openai.com/docs/models).
-  * [OpenAI message conversion to tokens](https://github.com/openai/openai-python).
-  * [OpenAI custom fine-tuning](https://platform.openai.com/docs/guides/model-optimization).
-  * [OpenAI's tiktoken library, including some helpful guides](https://github.com/openai/tiktoken/tree/main).
-* [OpenAI Playground](https://platform.openai.com/playground) is a great place to test out prompts and responses.
+* For more information on OpenAI models and token limits:
+  * [OpenAI model overview and maximum tokens](https://platform.openai.com/docs/models)
+  * [OpenAI message conversion to tokens](https://github.com/openai/openai-python)
+  * [OpenAI custom fine-tuning](https://platform.openai.com/docs/guides/model-optimization)
+  * [OpenAI's tiktoken library](https://github.com/openai/tiktoken/tree/main)
+* For more information on Anthropic Claude models:
+  * [Anthropic model overview and context windows](https://docs.anthropic.com/en/docs/about-claude/models)
+  * [Anthropic Python SDK](https://github.com/anthropic/anthropic-sdk-python)

{tellmgrambot-2.3.0 → tellmgrambot-2.4.0}/TeLLMgramBot.egg-info/SOURCES.txt RENAMED Viewed

@@ -6,7 +6,6 @@ TeLLMgramBot/__init__.py
 TeLLMgramBot/conversation.py
 TeLLMgramBot/initialize.py
 TeLLMgramBot/message_handlers.py
-TeLLMgramBot/openai_singleton.py
 TeLLMgramBot/tokenGPT.py
 TeLLMgramBot/utils.py
 TeLLMgramBot/web_utils.py
@@ -14,4 +13,9 @@ TeLLMgramBot.egg-info/PKG-INFO
 TeLLMgramBot.egg-info/SOURCES.txt
 TeLLMgramBot.egg-info/dependency_links.txt
 TeLLMgramBot.egg-info/requires.txt
-TeLLMgramBot.egg-info/top_level.txt
+TeLLMgramBot.egg-info/top_level.txt
+TeLLMgramBot/providers/__init__.py
+TeLLMgramBot/providers/anthropic_provider.py
+TeLLMgramBot/providers/base.py
+TeLLMgramBot/providers/factory.py
+TeLLMgramBot/providers/openai_provider.py

{tellmgrambot-2.3.0 → tellmgrambot-2.4.0}/TeLLMgramBot.egg-info/requires.txt RENAMED Viewed

@@ -1,4 +1,5 @@
 openai>2.0
+anthropic>=0.40
 PyYAML
 httpx
 beautifulsoup4

{tellmgrambot-2.3.0 → tellmgrambot-2.4.0}/setup.py RENAMED Viewed

@@ -5,17 +5,18 @@ with open("README.md", "r") as fh:
 setup(
     name='TeLLMgramBot',
-    version='2.3.0',
+    version='2.4.0',
     packages=find_packages(),
     license='MIT',
     author='Digital Heresy',
     author_email='ronin.atx@gmail.com',
-    description='OpenAI GPT, driven by Telegram',
+    description='LLM-powered Telegram bot (OpenAI + Anthropic)',
     long_description=long_description,
     long_description_content_type="text/markdown",
     url='https://github.com/Digital-Heresy/TeLLMgramBot',
     install_requires=[
         'openai>2.0',
+        'anthropic>=0.40',
         'PyYAML',
         'httpx',
         'beautifulsoup4',

tellmgrambot-2.3.0/TeLLMgramBot/openai_singleton.py DELETED Viewed

@@ -1,12 +0,0 @@
-import os
-from openai import AsyncOpenAI
-class OpenAIClientSingleton:
-    """Call the OpenAI Client API for processing every asynchronous function."""
-    _instance = None
-    @classmethod
-    def get_instance(cls):
-        if cls._instance is None:
-            cls._instance = AsyncOpenAI(api_key=os.environ['TELLMGRAMBOT_OPENAI_API_KEY'])
-        return cls._instance

{tellmgrambot-2.3.0 → tellmgrambot-2.4.0}/LICENSE RENAMED Viewed

File without changes

{tellmgrambot-2.3.0 → tellmgrambot-2.4.0}/TeLLMgramBot/__init__.py RENAMED Viewed

File without changes

{tellmgrambot-2.3.0 → tellmgrambot-2.4.0}/TeLLMgramBot/utils.py RENAMED Viewed

File without changes

{tellmgrambot-2.3.0 → tellmgrambot-2.4.0}/TeLLMgramBot.egg-info/dependency_links.txt RENAMED Viewed

File without changes

{tellmgrambot-2.3.0 → tellmgrambot-2.4.0}/TeLLMgramBot.egg-info/top_level.txt RENAMED Viewed

File without changes

{tellmgrambot-2.3.0 → tellmgrambot-2.4.0}/setup.cfg RENAMED Viewed

File without changes

TeLLMgramBot 2.3.0__tar.gz → 2.4.0__tar.gz

TeLLMgramBot 2.3.0tar.gz → 2.4.0tar.gz