webscout 7.4__py3-none-any.whl → 7.6__py3-none-any.whl

webscout/Provider/llamatutor.py

@@ -1,4 +1,3 @@
-
 import requests
 import json
 
@@ -8,13 +7,12 @@ from webscout.AIutel import AwesomePrompts
 from webscout.AIbase import Provider
 from webscout import exceptions
 from webscout import LitAgent as Lit
-from webscout.Litlogger import Logger, LogFormat
 
 class LlamaTutor(Provider):
     """
-    A class to interact with the LlamaTutor API (Together.ai) with comprehensive logging.
+    A class to interact with the LlamaTutor API (Together.ai)
     """
-
+    AVAILABLE_MODELS = ["UNKNOWN"]
     def __init__(
         self,
         is_conversation: bool = True,
@@ -26,20 +24,11 @@ class LlamaTutor(Provider):
         proxies: dict = {},
         history_offset: int = 10250,
         act: str = None,
-        system_prompt: str = "You are a helpful AI assistant.",
-        logging: bool = False
+        system_prompt: str = "You are a helpful AI assistant."
     ):
         """
-        Initializes the LlamaTutor API with given parameters and logging capabilities.
+        Initializes the LlamaTutor API with given parameters.
         """
-        self.logger = Logger(
-            name="LlamaTutor",
-            format=LogFormat.MODERN_EMOJI,
-
-        ) if logging else None
-
-        if self.logger:
-            self.logger.info("Initializing LlamaTutor API")
 
         self.session = requests.Session()
         self.is_conversation = is_conversation
@@ -74,9 +63,6 @@ class LlamaTutor(Provider):
         )
         
         self.session.headers.update(self.headers)
-        
-        if self.logger:
-            self.logger.debug("Headers configured and session updated")
 
         Conversation.intro = (
             AwesomePrompts().get_act(
@@ -92,9 +78,6 @@ class LlamaTutor(Provider):
         self.conversation.history_offset = history_offset
         self.session.proxies = proxies
 
-        if self.logger:
-            self.logger.info("LlamaTutor initialized successfully")
-
     def ask(
         self,
         prompt: str,
@@ -103,10 +86,7 @@ class LlamaTutor(Provider):
         optimizer: str = None,
         conversationally: bool = False,
     ) -> dict:
-        """Chat with LlamaTutor with logging capabilities"""
-        if self.logger:
-            self.logger.debug(f"Processing request - Prompt: {prompt[:50]}...")
-            self.logger.debug(f"Stream: {stream}, Optimizer: {optimizer}")
+        """Chat with LlamaTutor"""
 
         conversation_prompt = self.conversation.gen_complete_prompt(prompt)
         if optimizer:
@@ -114,11 +94,7 @@ class LlamaTutor(Provider):
                 conversation_prompt = getattr(Optimizers, optimizer)(
                     conversation_prompt if conversationally else prompt
                 )
-                if self.logger:
-                    self.logger.debug(f"Applied optimizer: {optimizer}")
             else:
-                if self.logger:
-                    self.logger.error(f"Invalid optimizer requested: {optimizer}")
                 raise Exception(f"Optimizer is not one of {self.__available_optimizers}")
         
         payload = {
@@ -136,8 +112,6 @@ class LlamaTutor(Provider):
 
         def for_stream():
             try:
-                if self.logger:
-                    self.logger.debug("Initiating streaming request to API")
 
                 response = requests.post(
                     self.api_endpoint,
@@ -148,9 +122,6 @@ class LlamaTutor(Provider):
                 )
                 response.raise_for_status()
                 
-                if self.logger:
-                    self.logger.info(f"API connection established successfully. Status: {response.status_code}")
-                
                 full_response = ''
                 for line in response.iter_lines(decode_unicode=True):
                     if line:
@@ -162,8 +133,6 @@ class LlamaTutor(Provider):
                                     full_response += json_data["text"]
                                     yield json_data["text"] if raw else dict(text=json_data["text"])
                         except json.JSONDecodeError as e:
-                            if self.logger:
-                                self.logger.warning(f"Failed to parse response line: {e}")
                             continue
 
                 self.last_response.update(dict(text=full_response))
@@ -172,17 +141,11 @@ class LlamaTutor(Provider):
                 )
 
             except requests.exceptions.HTTPError as http_err:
-                if self.logger:
-                    self.logger.error(f"HTTP error occurred: {http_err}")
                 raise exceptions.FailedToGenerateResponseError(f"HTTP error occurred: {http_err}")
             except requests.exceptions.RequestException as err:
-                if self.logger:
-                    self.logger.error(f"Request error occurred: {err}")
                 raise exceptions.FailedToGenerateResponseError(f"An error occurred: {err}")
 
         def for_non_stream():
-            if self.logger:
-                self.logger.debug("Processing non-streaming request")
             for _ in for_stream():
                 pass
             return self.last_response
@@ -196,9 +159,7 @@ class LlamaTutor(Provider):
         optimizer: str = None,
         conversationally: bool = False,
     ) -> str:
-        """Generate response with logging capabilities"""
-        if self.logger:
-            self.logger.debug(f"Chat request initiated - Prompt: {prompt[:50]}...")
+        """Generate response"""
 
         def for_stream():
             for response in self.ask(
@@ -225,8 +186,7 @@ class LlamaTutor(Provider):
 
 if __name__ == "__main__":
     from rich import print
-    # Enable logging for testing
-    ai = LlamaTutor(logging=True)
+    ai = LlamaTutor()
     response = ai.chat("Write a poem about AI", stream=True)
     for chunk in response:
         print(chunk, end="", flush=True)

webscout/Provider/llmchat.py

@@ -1,4 +1,3 @@
-
 import requests
 import json
 from typing import Any, Dict, Optional, Generator, List
@@ -8,21 +7,20 @@ from webscout.AIutel import Conversation
 from webscout.AIutel import AwesomePrompts
 from webscout.AIbase import Provider
 from webscout import exceptions
-from webscout.Litlogger import Logger, LogFormat
 from webscout import LitAgent as Lit
 
 class LLMChat(Provider):
     """
-    A class to interact with the LLMChat API with comprehensive logging.
+    A class to interact with the LLMChat API
     """
 
     AVAILABLE_MODELS = [
         "@cf/meta/llama-3.1-70b-instruct",
         "@cf/meta/llama-3.1-8b-instruct",
         "@cf/meta/llama-3.2-3b-instruct",
-        "@cf/meta/llama-3.2-1b-instruct"
-        "@cf/meta/llama-3.3-70b-instruct-fp8-fast"
-        "@cf/deepseek-ai/deepseek-r1-distill-qwen-32b"
+        "@cf/meta/llama-3.2-1b-instruct",
+        "@cf/meta/llama-3.3-70b-instruct-fp8-fast",
+        "@cf/deepseek-ai/deepseek-r1-distill-qwen-32b",
     ]
 
     def __init__(
@@ -37,23 +35,13 @@ class LLMChat(Provider):
         history_offset: int = 10250,
         act: str = None,
         model: str = "@cf/meta/llama-3.1-70b-instruct",
-        system_prompt: str = "You are a helpful assistant.",
-        logging: bool = False
+        system_prompt: str = "You are a helpful assistant."
     ):
         """
-        Initializes the LLMChat API with given parameters and logging capabilities.
+        Initializes the LLMChat API with given parameters.
         """
-        self.logger = Logger(
-            name="LLMChat",
-            format=LogFormat.MODERN_EMOJI,
-        ) if logging else None
-
-        if self.logger:
-            self.logger.info(f"Initializing LLMChat with model: {model}")
 
         if model not in self.AVAILABLE_MODELS:
-            if self.logger:
-                self.logger.error(f"Invalid model selected: {model}")
             raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
 
         self.session = requests.Session()
@@ -93,9 +81,6 @@ class LLMChat(Provider):
         self.conversation.history_offset = history_offset
         self.session.proxies = proxies
 
-        if self.logger:
-            self.logger.info("LLMChat initialized successfully")
-
     def ask(
         self,
         prompt: str,
@@ -105,9 +90,6 @@ class LLMChat(Provider):
         conversationally: bool = False,
     ) -> Dict[str, Any]:
         """Chat with LLMChat with logging capabilities"""
-        if self.logger:
-            self.logger.debug(f"Processing request - Prompt: {prompt[:50]}...")
-            self.logger.debug(f"Stream: {stream}, Optimizer: {optimizer}")
 
         conversation_prompt = self.conversation.gen_complete_prompt(prompt)
         if optimizer:
@@ -115,11 +97,7 @@ class LLMChat(Provider):
                 conversation_prompt = getattr(Optimizers, optimizer)(
                     conversation_prompt if conversationally else prompt
                 )
-                if self.logger:
-                    self.logger.debug(f"Applied optimizer: {optimizer}")
             else:
-                if self.logger:
-                    self.logger.error(f"Invalid optimizer requested: {optimizer}")
                 raise exceptions.FailedToGenerateResponseError(
                     f"Optimizer is not one of {self.__available_optimizers}"
                 )
@@ -136,14 +114,9 @@ class LLMChat(Provider):
 
         def for_stream():
             try:
-                if self.logger:
-                    self.logger.debug("Initiating streaming request to API")
 
                 with requests.post(url, json=payload, headers=self.headers, stream=True, timeout=self.timeout) as response:
                     response.raise_for_status()
-                    
-                    if self.logger:
-                        self.logger.info(f"API connection established successfully. Status: {response.status_code}")
 
                     full_response = ""
                     for line in response.iter_lines():
@@ -158,9 +131,7 @@ class LLMChat(Provider):
                                         yield response_text if raw else dict(text=response_text)
                                 except json.JSONDecodeError:
                                     if line.strip() != 'data: [DONE]':
-                                        if self.logger:
-                                            self.logger.warning(f"Failed to parse line: {line}")
-                                    continue
+                                        continue
 
                     self.last_response.update(dict(text=full_response))
                     self.conversation.update_chat_history(
@@ -168,21 +139,14 @@ class LLMChat(Provider):
                     )
 
             except requests.exceptions.RequestException as e:
-                if self.logger:
-                    self.logger.error(f"API request failed: {str(e)}")
                 raise exceptions.FailedToGenerateResponseError(f"Request failed: {e}")
         
         def for_non_stream():
-            if self.logger:
-                self.logger.debug("Processing non-streaming request")
-            
+
             full_response = ""
             for line in for_stream():
                 full_response += line['text'] if not raw else line
-            
-            if self.logger:
-                self.logger.debug("Response processing completed")
-            
+
             return dict(text=full_response)
 
         return for_stream() if stream else for_non_stream()
@@ -195,8 +159,6 @@ class LLMChat(Provider):
         conversationally: bool = False,
     ) -> str | Generator[str, None, None]:
         """Generate response with logging capabilities"""
-        if self.logger:
-            self.logger.debug(f"Chat request initiated - Prompt: {prompt[:50]}...")
 
         def for_stream():
             for response in self.ask(
@@ -222,9 +184,30 @@ class LLMChat(Provider):
         return response["text"]
 
 if __name__ == "__main__":
-    from rich import print
-    # Enable logging for testing
-    ai = LLMChat(model='@cf/meta/llama-3.1-70b-instruct', logging=True)
-    response = ai.chat("What's the meaning of life?", stream=True)
-    for chunk in response:
-        print(chunk, end="", flush=True)
+    print("-" * 80)
+    print(f"{'Model':<50} {'Status':<10} {'Response'}")
+    print("-" * 80)
+    
+    # Test all available models
+    working = 0
+    total = len(LLMChat.AVAILABLE_MODELS)
+    
+    for model in LLMChat.AVAILABLE_MODELS:
+        try:
+            test_ai = LLMChat(model=model, timeout=60)
+            response = test_ai.chat("Say 'Hello' in one word", stream=True)
+            response_text = ""
+            for chunk in response:
+                response_text += chunk
+                print(f"\r{model:<50} {'Testing...':<10}", end="", flush=True)
+            
+            if response_text and len(response_text.strip()) > 0:
+                status = "✓"
+                # Truncate response if too long
+                display_text = response_text.strip()[:50] + "..." if len(response_text.strip()) > 50 else response_text.strip()
+            else:
+                status = "✗"
+                display_text = "Empty or invalid response"
+            print(f"\r{model:<50} {status:<10} {display_text}")
+        except Exception as e:
+            print(f"\r{model:<50} {'✗':<10} {str(e)}")

webscout/Provider/multichat.py

@@ -6,7 +6,6 @@ from datetime import datetime
 from webscout.AIutel import Optimizers, Conversation, AwesomePrompts
 from webscout.AIbase import Provider
 from webscout import exceptions
-from webscout.Litlogger import Logger, LogFormat
 from webscout.litagent import LitAgent 
 
 # Model configurations
@@ -21,14 +20,18 @@ MODEL_CONFIGS = {
     },
     "cohere": {
         "endpoint": "https://www.multichatai.com/api/chat/cohere",
-        "models": {"command-r": {"contextLength": 128000}},
+        "models": {
+            "command-r": {"contextLength": 128000},
+            "command": {"contextLength": 4096},
+        },
     },
     "google": {
         "endpoint": "https://www.multichatai.com/api/chat/google",
         "models": {
             "gemini-1.5-flash-002": {"contextLength": 1048576},
             "gemma2-9b-it": {"contextLength": 8192},
-        },
+            "gemini-2.0-flash": {"contextLength": 128000},
+                    },
         "message_format": "parts",
     },
     "deepinfra": {
@@ -38,6 +41,9 @@ MODEL_CONFIGS = {
             "Gryphe/MythoMax-L2-13b": {"contextLength": 8192},
             "nvidia/Llama-3.1-Nemotron-70B-Instruct": {"contextLength": 131072},
             "deepseek-ai/DeepSeek-V3": {"contextLength": 32000},
+            "meta-llama/Meta-Llama-3.1-405B-Instruct": {"contextLength": 131072},
+            "NousResearch/Hermes-3-Llama-3.1-405B": {"contextLength": 131072},
+            "gemma-2-27b-it": {"contextLength": 8192},
         },
     },
     "mistral": {
@@ -49,9 +55,56 @@ MODEL_CONFIGS = {
             "open-mixtral-8x7b": {"contextLength": 8000},
         },
     },
+    "alibaba": {
+        "endpoint": "https://www.multichatai.com/api/chat/alibaba",
+        "models": {
+            "Qwen/Qwen2.5-72B-Instruct": {"contextLength": 32768},
+            "Qwen/Qwen2.5-Coder-32B-Instruct": {"contextLength": 32768},
+            "Qwen/QwQ-32B-Preview": {"contextLength": 32768},
+        },
+    },
 }
 
 class MultiChatAI(Provider):
+    """
+    A class to interact with the MultiChatAI API.
+    """
+    AVAILABLE_MODELS = [
+        # Llama Models
+        "llama-3.3-70b-versatile",
+        "llama-3.2-11b-vision-preview",
+        "deepseek-r1-distill-llama-70b",
+        
+        # Cohere Models
+        # "command-r", >>>> NOT WORKING
+        # "command", >>>> NOT WORKING
+        
+        # Google Models
+        # "gemini-1.5-flash-002", >>>> NOT WORKING
+        "gemma2-9b-it",
+        "gemini-2.0-flash",
+        
+        # DeepInfra Models
+        "Sao10K/L3.1-70B-Euryale-v2.2",
+        "Gryphe/MythoMax-L2-13b",
+        "nvidia/Llama-3.1-Nemotron-70B-Instruct",
+        "deepseek-ai/DeepSeek-V3",
+        "meta-llama/Meta-Llama-3.1-405B-Instruct",
+        "NousResearch/Hermes-3-Llama-3.1-405B",
+        # "gemma-2-27b-it", >>>> NOT WORKING
+        
+        # Mistral Models
+        # "mistral-small-latest", >>>> NOT WORKING
+        # "codestral-latest", >>>> NOT WORKING
+        # "open-mistral-7b", >>>> NOT WORKING
+        # "open-mixtral-8x7b", >>>> NOT WORKING
+        
+        # Alibaba Models
+        "Qwen/Qwen2.5-72B-Instruct",
+        "Qwen/Qwen2.5-Coder-32B-Instruct",
+        "Qwen/QwQ-32B-Preview"
+    ]
+
     def __init__(
         self,
         is_conversation: bool = True,
@@ -68,20 +121,11 @@ class MultiChatAI(Provider):
         temperature: float = 0.5,
         presence_penalty: int = 0,
         frequency_penalty: int = 0,
-        top_p: float = 1,
-        logging: bool = False,
+        top_p: float = 1
     ):
-        """Initializes the MultiChatAI API client with logging capabilities."""
-        # Initialize logger first
-        self.logger = Logger(
-            name="MultiChatAI",
-            format=LogFormat.MODERN_EMOJI,
-
-        ) if logging else None
-
-        if self.logger:
-            self.logger.debug("Initializing MultiChatAI")
-
+        """Initializes the MultiChatAI API client."""
+        if model not in self.AVAILABLE_MODELS:
+            raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
         self.session = requests.Session()
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
@@ -106,9 +150,6 @@ class MultiChatAI(Provider):
             "user-agent": self.agent.random(),
         }
         
-        if self.logger:
-            self.logger.debug(f"Setting up session with headers: {self.headers}")
-        
         self.session.headers.update(self.headers)
         self.session.proxies = proxies
         self.session.cookies.update({"session": uuid.uuid4().hex})
@@ -131,24 +172,17 @@ class MultiChatAI(Provider):
         )
         self.conversation.history_offset = history_offset
 
-        # Get provider after logger initialization
         self.provider = self._get_provider_from_model(self.model)
         self.model_name = self.model
 
-        if self.logger:
-            self.logger.info(f"MultiChatAI initialized with model: {self.model}")
-
     def _get_endpoint(self) -> str:
         """Get the API endpoint for the current provider."""
-        endpoint = MODEL_CONFIGS[self.provider]["endpoint"]
-        if self.logger:
-            self.logger.debug(f"Using endpoint: {endpoint}")
-        return endpoint
+        return MODEL_CONFIGS[self.provider]["endpoint"]
 
     def _get_chat_settings(self) -> Dict[str, Any]:
         """Get chat settings for the current model."""
         base_settings = MODEL_CONFIGS[self.provider]["models"][self.model_name]
-        settings = {
+        return {
             "model": self.model,
             "prompt": self.system_prompt,
             "temperature": self.temperature,
@@ -157,45 +191,30 @@ class MultiChatAI(Provider):
             "includeWorkspaceInstructions": True,
             "embeddingsProvider": "openai"
         }
-        if self.logger:
-            self.logger.debug(f"Chat settings: {settings}")
-        return settings
 
     def _get_system_message(self) -> str:
         """Generate system message with current date."""
         current_date = datetime.now().strftime("%d/%m/%Y")
-        message = f"Today is {current_date}.\n\nUser Instructions:\n{self.system_prompt}"
-        if self.logger:
-            self.logger.debug(f"System message: {message}")
-        return message
+        return f"Today is {current_date}.\n\nUser Instructions:\n{self.system_prompt}"
 
     def _build_messages(self, conversation_prompt: str) -> list:
         """Build messages array based on provider type."""
         if self.provider == "google":
-            messages = [
+            return [
                 {"role": "user", "parts": self._get_system_message()},
                 {"role": "model", "parts": "I will follow your instructions."},
                 {"role": "user", "parts": conversation_prompt}
             ]
         else:
-            messages = [
+            return [
                 {"role": "system", "content": self._get_system_message()},
                 {"role": "user", "content": conversation_prompt}
             ]
-        
-        if self.logger:
-            self.logger.debug(f"Built messages: {messages}")
-        return messages
 
     def _get_provider_from_model(self, model: str) -> str:
         """Determine the provider based on the model name."""
-        if self.logger:
-            self.logger.debug(f"Getting provider for model: {model}")
-            
         for provider, config in MODEL_CONFIGS.items():
             if model in config["models"]:
-                if self.logger:
-                    self.logger.info(f"Found provider: {provider} for model: {model}")
                 return provider
         
         available_models = []
@@ -204,16 +223,10 @@ class MultiChatAI(Provider):
                 available_models.append(f"{provider}/{model_name}")
         
         error_msg = f"Invalid model: {model}\nAvailable models: {', '.join(available_models)}"
-        if self.logger:
-            self.logger.error(error_msg)
         raise ValueError(error_msg)
 
     def _make_request(self, payload: Dict[str, Any]) -> requests.Response:
-        """Make the API request with proper error handling and logging."""
-        if self.logger:
-            self.logger.debug(f"Making request to endpoint: {self._get_endpoint()}")
-            self.logger.debug(f"Request payload: {json.dumps(payload, indent=2)}")
-
+        """Make the API request with proper error handling."""
         try:
             response = self.session.post(
                 self._get_endpoint(),
@@ -222,15 +235,8 @@ class MultiChatAI(Provider):
                 timeout=self.timeout,
             )
             response.raise_for_status()
-            
-            if self.logger:
-                self.logger.info(f"Request successful: {response.status_code}")
-                self.logger.debug(f"Response content: {response.text[:200]}...")
-                
             return response
         except requests.exceptions.RequestException as e:
-            if self.logger:
-                self.logger.error(f"Request failed: {str(e)}")
             raise exceptions.FailedToGenerateResponseError(f"API request failed: {e}") from e
 
     def ask(
@@ -241,21 +247,14 @@ class MultiChatAI(Provider):
         conversationally: bool = False,
     ) -> Dict[str, Any]:
         """Sends a prompt to the MultiChatAI API and returns the response."""
-        if self.logger:
-            self.logger.debug(f"ask() called with prompt: {prompt}")
-            
         conversation_prompt = self.conversation.gen_complete_prompt(prompt)
         if optimizer:
             if optimizer in self.__available_optimizers:
-                if self.logger:
-                    self.logger.info(f"Applying optimizer: {optimizer}")
                 conversation_prompt = getattr(Optimizers, optimizer)(
                     conversation_prompt if conversationally else prompt
                 )
             else:
                 error_msg = f"Optimizer is not one of {self.__available_optimizers}"
-                if self.logger:
-                    self.logger.error(error_msg)
                 raise exceptions.FailedToGenerateResponseError(error_msg)
 
         payload = {
@@ -269,15 +268,8 @@ class MultiChatAI(Provider):
             full_response = response.text.strip()
             self.last_response = {"text": full_response}
             self.conversation.update_chat_history(prompt, full_response)
-            
-            if self.logger:
-                self.logger.info("Successfully processed response")
-                self.logger.debug(f"Final response: {full_response[:200]}...")
-                
             return self.last_response
         except json.JSONDecodeError as e:
-            if self.logger:
-                self.logger.error(f"Failed to decode JSON response: {e}")
             raise exceptions.FailedToGenerateResponseError(f"Invalid JSON response: {e}") from e
 
     def chat(
@@ -286,17 +278,10 @@ class MultiChatAI(Provider):
         optimizer: str = None,
         conversationally: bool = False,
     ) -> str:
-        """Generate response with logging."""
-        if self.logger:
-            self.logger.debug(f"chat() called with prompt: {prompt}")
-            
+        """Generate response."""
         response = self.ask(
             prompt, optimizer=optimizer, conversationally=conversationally
         )
-        
-        if self.logger:
-            self.logger.info("Chat response generated successfully")
-            
         return self.get_message(response)
 
     def get_message(self, response: Dict[str, Any] | str) -> str:
@@ -309,23 +294,32 @@ class MultiChatAI(Provider):
         Returns:
             str: The extracted message text
         """
-        if self.logger:
-            self.logger.debug(f"Extracting message from response type: {type(response)}")
-            
         if isinstance(response, dict):
-            message = response.get("text", "")
-            if self.logger:
-                self.logger.debug(f"Extracted message from dict: {message[:200]}...")
-            return message
+            return response.get("text", "")
         return str(response)
 
 if __name__ == "__main__":
-    from rich import print
-
-    # Example usage with logging enabled
-    ai = MultiChatAI(model="deepseek-r1-distill-llama-70b", logging=False)
-    try:
-        response = ai.chat("What is quantum computing?")
-        print(response)
-    except Exception as e:
-        print(f"Error: {str(e)}")
+    print("-" * 80)
+    print(f"{'Model':<50} {'Status':<10} {'Response'}")
+    print("-" * 80)
+    
+    # Test all available models
+    working = 0
+    total = len(MultiChatAI.AVAILABLE_MODELS)
+    
+    for model in MultiChatAI.AVAILABLE_MODELS:
+        try:
+            test_ai = MultiChatAI(model=model, timeout=60)
+            response = test_ai.chat("Say 'Hello' in one word")
+            response_text = response
+            
+            if response_text and len(response_text.strip()) > 0:
+                status = "✓"
+                # Truncate response if too long
+                display_text = response_text.strip()[:50] + "..." if len(response_text.strip()) > 50 else response_text.strip()
+            else:
+                status = "✗"
+                display_text = "Empty or invalid response"
+            print(f"{model:<50} {status:<10} {display_text}")
+        except Exception as e:
+            print(f"{model:<50} {'✗':<10} {str(e)}")

webscout/Provider/talkai.py

@@ -9,6 +9,7 @@ from webscout.AIutel import AwesomePrompts
 from webscout.AIbase import Provider
 from webscout import exceptions
 from webscout.litagent import LitAgent
+
 class Talkai(Provider):
     """
     A class to interact with the Talkai.info API.