webscout 8.2.3__py3-none-any.whl → 8.2.5__py3-none-any.whl

webscout/Provider/turboseek.py

@@ -1,12 +1,13 @@
-import requests
+from curl_cffi.requests import Session
+from curl_cffi import CurlError
 import json
 
 from webscout.AIutel import Optimizers
 from webscout.AIutel import Conversation
-from webscout.AIutel import AwesomePrompts, sanitize_stream
-from webscout.AIbase import Provider, AsyncProvider
+from webscout.AIutel import AwesomePrompts, sanitize_stream # Import sanitize_stream
+from webscout.AIbase import Provider
 from webscout import exceptions
-from typing import Union, Any, AsyncGenerator, Dict
+from typing import Optional, Union, Any, AsyncGenerator, Dict
 from webscout.litagent import LitAgent
 
 class TurboSeek(Provider):
@@ -26,7 +27,7 @@ class TurboSeek(Provider):
         proxies: dict = {},
         history_offset: int = 10250,
         act: str = None,
-        model: str = "Llama 3.1 70B"
+        model: str = "Llama 3.1 70B" # Note: model parameter is not used by the API endpoint
     ):
         """Instantiates TurboSeek
 
@@ -41,7 +42,8 @@ class TurboSeek(Provider):
             history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
             act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
         """
-        self.session = requests.Session()
+        # Initialize curl_cffi Session
+        self.session = Session()
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
         self.chat_endpoint = "https://www.turboseek.io/api/getAnswer"
@@ -49,14 +51,9 @@ class TurboSeek(Provider):
         self.timeout = timeout
         self.last_response = {}
         self.headers = {
-            "authority": "www.turboseek.io",
-            "method": "POST",
-            "path": "/api/getAnswer",
-            "scheme": "https",
             "accept": "*/*",
             "accept-encoding": "gzip, deflate, br, zstd",
             "accept-language": "en-US,en;q=0.9,en-IN;q=0.8",
-            "content-length": "63",
             "content-type": "application/json",
             "dnt": "1",
             "origin": "https://www.turboseek.io",
@@ -76,7 +73,9 @@ class TurboSeek(Provider):
             for method in dir(Optimizers)
             if callable(getattr(Optimizers, method)) and not method.startswith("__")
         )
+        # Update curl_cffi session headers and proxies
         self.session.headers.update(self.headers)
+        self.session.proxies = proxies # Assign proxies directly
         Conversation.intro = (
             AwesomePrompts().get_act(
                 act, raise_not_found=True, default=None, case_insensitive=True
@@ -88,7 +87,13 @@ class TurboSeek(Provider):
             is_conversation, self.max_tokens_to_sample, filepath, update_file
         )
         self.conversation.history_offset = history_offset
-        self.session.proxies = proxies
+
+    @staticmethod
+    def _turboseek_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
+        """Extracts content from TurboSeek stream JSON objects."""
+        if isinstance(chunk, dict) and "text" in chunk:
+            return chunk.get("text") # json.loads already handles unicode escapes
+        return None
 
     def ask(
         self,
@@ -125,41 +130,69 @@ class TurboSeek(Provider):
                     f"Optimizer is not one of {self.__available_optimizers}"
                 )
 
-        self.session.headers.update(self.headers)
         payload = {
             "question": conversation_prompt,
             "sources": []
         }
 
         def for_stream():
-            response = self.session.post(
-                self.chat_endpoint, json=payload, stream=True, timeout=self.timeout
-            )
-            if not response.ok:
-                raise exceptions.FailedToGenerateResponseError(
-                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+            try: # Add try block for CurlError
+                # Use curl_cffi session post with impersonate
+                response = self.session.post(
+                    self.chat_endpoint, 
+                    json=payload, 
+                    stream=True, 
+                    timeout=self.timeout,
+                    impersonate="chrome120", # Try a different impersonation profile
                 )
-            streaming_text = ""
-            for value in response.iter_lines(
-                chunk_size=self.stream_chunk_size,
-            ):
-                try:
-                    if value and value.startswith(b"data: "): #Check for bytes and decode
-                        data = json.loads(value[6:].decode('utf-8')) # Decode manually
-                        if "text" in data:
-                            streaming_text += data["text"]
-                            resp = dict(text=data["text"])
-                            self.last_response.update(resp)
-                            yield value if raw else resp
-                except json.decoder.JSONDecodeError:
-                    pass
-            self.conversation.update_chat_history(
-                prompt, self.get_message(self.last_response)
-            )
+                if not response.ok:
+                    raise exceptions.FailedToGenerateResponseError(
+                        f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                    )
+
+                streaming_text = ""
+                # Use sanitize_stream with the custom extractor
+                processed_stream = sanitize_stream(
+                    data=response.iter_content(chunk_size=None), # Pass byte iterator
+                    intro_value="data:",
+                    to_json=True,     # Stream sends JSON
+                    content_extractor=self._turboseek_extractor, # Use the specific extractor
+                    yield_raw_on_error=False # Skip non-JSON lines or lines where extractor fails
+                )
+
+                for content_chunk in processed_stream:
+                    # content_chunk is the string extracted by _turboseek_extractor
+                    if content_chunk and isinstance(content_chunk, str):
+                        streaming_text += content_chunk
+                        self.last_response.update(dict(text=streaming_text)) # Update last_response incrementally
+                        yield dict(text=content_chunk) if not raw else content_chunk # Yield dict or raw string
+
+                # Update conversation history after stream finishes
+                if streaming_text: # Only update if content was received
+                    self.conversation.update_chat_history(
+                        prompt, streaming_text # Use the fully aggregated text
+                    )
+            except CurlError as e: # Catch CurlError
+                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}")
+            except Exception as e: # Catch other potential exceptions
+                raise exceptions.FailedToGenerateResponseError(f"An unexpected error occurred ({type(e).__name__}): {e}")
+
 
         def for_non_stream():
-            for _ in for_stream():
-                pass
+            # Aggregate the stream using the updated for_stream logic
+            full_text = ""
+            try:
+                # Ensure raw=False so for_stream yields dicts
+                for chunk_data in for_stream():
+                    if isinstance(chunk_data, dict) and "text" in chunk_data:
+                        full_text += chunk_data["text"]
+                    elif isinstance(chunk_data, str): # Handle case where raw=True was passed
+                        full_text += chunk_data
+            except Exception as e:
+                raise exceptions.FailedToGenerateResponseError(f"Failed to aggregate non-stream response: {e}") from e
+            # last_response and history are updated within for_stream
+            # Ensure last_response reflects the complete aggregated text
+            self.last_response = {"text": full_text} 
             return self.last_response
 
         return for_stream() if stream else for_non_stream()
@@ -209,11 +242,25 @@ class TurboSeek(Provider):
             str: Message extracted
         """
         assert isinstance(response, dict), "Response should be of dict data-type only"
-        return response["text"]
+        # Unicode escapes are handled by json.loads within sanitize_stream
+        return response.get("text", "") 
+
 if __name__ == '__main__':
+    # Ensure curl_cffi is installed
     from rich import print
-    ai = TurboSeek()
-    response = ai.chat("hello buddy", stream=True)
-    for chunk in response:
-        print(chunk, end="", flush=True)
+    try: # Add try-except block for testing
+        ai = TurboSeek(timeout=60)
+        print("[bold blue]Testing Stream:[/bold blue]")
+        response_stream = ai.chat("yooooooooooo", stream=True)
+        for chunk in response_stream:
+            print(chunk, end="", flush=True)
+        # Optional: Test non-stream
+        # print("[bold blue]Testing Non-Stream:[/bold blue]")
+        # response_non_stream = ai.chat("What is the capital of France?", stream=False)
+        # print(response_non_stream)
+        # print("[bold green]Non-Stream Test Complete.[/bold green]")
 
+    except exceptions.FailedToGenerateResponseError as e:
+        print(f"\n[bold red]API Error:[/bold red] {e}")
+    except Exception as e:
+        print(f"\n[bold red]An unexpected error occurred:[/bold red] {e}")

webscout/Provider/tutorai.py

@@ -1,4 +1,5 @@
-import requests
+from curl_cffi.requests import Session
+from curl_cffi import CurlError
 import os
 from typing import Union, List, Optional
 from string import punctuation
@@ -28,8 +29,6 @@ class TutorAI(Provider):
         proxies: dict = {},
         history_offset: int = 10250,
         act: str = None,
-        system_prompt: str = "You are a helpful AI assistant.",
-        model: str = "gpt-4o"
     ):
         """
         Initializes the TutorAI.me API with given parameters.
@@ -47,26 +46,19 @@ class TutorAI(Provider):
             system_prompt (str, optional): System prompt for TutorAI.
                                    Defaults to "You are a helpful AI assistant.".
         """
-        self.session = requests.Session()
+        # Initialize curl_cffi Session
+        self.session = Session()
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
         self.api_endpoint = "https://ai-tutor.ai/api/generate-homeworkify-response"
         self.stream_chunk_size = 1024
         self.timeout = timeout
         self.last_response = {}
-        self.system_prompt = system_prompt
+        # Remove Cookie header, curl_cffi doesn't use it directly like this
         self.headers = {
             "Accept": "*/*",
             "Accept-Encoding": "gzip, deflate, br, zstd",
             "Accept-Language": "en-US,en;q=0.9,en-IN;q=0.8",
-            "Cookie": (
-                "ARRAffinity=5ef5a1afbc0178c19fc7bc85047a2309cb69de3271923483302c69744e2b1d24; "
-                "ARRAffinitySameSite=5ef5a1afbc0178c19fc7bc85047a2309cb69de3271923483302c69744e2b1d24; "
-                "_ga=GA1.1.412867530.1726937399; "
-                "_clck=1kwy10j%7C2%7Cfpd%7C0%7C1725; "
-                "_clsk=1cqd2q1%7C1726937402133%7C1%7C1%7Cm.clarity.ms%2Fcollect; "
-                "_ga_0WF5W33HD7=GS1.1.1726937399.1.1.1726937459.0.0.0"
-            ),
             "DNT": "1",
             "Origin": "https://tutorai.me",
             "Priority": "u=1, i",
@@ -85,7 +77,9 @@ class TutorAI(Provider):
             for method in dir(Optimizers)
             if callable(getattr(Optimizers, method)) and not method.startswith("__")
         )
+        # Update curl_cffi session headers and proxies
         self.session.headers.update(self.headers)
+        self.session.proxies = proxies # Assign proxies directly
         Conversation.intro = (
             AwesomePrompts().get_act(
                 act, raise_not_found=True, default=None, case_insensitive=True
@@ -97,12 +91,11 @@ class TutorAI(Provider):
             is_conversation, self.max_tokens_to_sample, filepath, update_file
         )
         self.conversation.history_offset = history_offset
-        self.session.proxies = proxies
 
     def ask(
         self,
         prompt: str,
-        stream: bool = False,
+        stream: bool = False, # Note: API doesn't seem to truly stream text chunks
         raw: bool = False,
         optimizer: str = None,
         conversationally: bool = False,
@@ -140,68 +133,67 @@ class TutorAI(Provider):
             "attachmentsCount": "1" if attachment_path else "0"
         }
         files = {}
+        file_handle = None # To ensure file is closed
         if attachment_path:
             if not os.path.isfile(attachment_path):
                 raise FileNotFoundError(f"Error: The file '{attachment_path}' does not exist.")
             try:
-                files["attachment0"] = (os.path.basename(attachment_path), open(attachment_path, 'rb'), 'image/png')
+                # Open file handle to pass to curl_cffi
+                file_handle = open(attachment_path, 'rb')
+                files["attachment0"] = (os.path.basename(attachment_path), file_handle, 'image/png') # Adjust mime type if needed
             except Exception as e:
+                if file_handle: file_handle.close() # Close if opened
                 raise exceptions.FailedToGenerateResponseError(f"Error opening the file: {e}")
 
-        def for_stream():
+        # The API doesn't seem to support streaming text chunks based on the original code.
+        # Both stream=True and stream=False resulted in processing the full response.
+        # We will implement the non-stream logic for both cases.
+        try:
+            # Use curl_cffi session post with impersonate
+            # Pass data and files for multipart/form-data
+            response = self.session.post(
+                self.api_endpoint, 
+                # headers are set on the session
+                data=form_data, 
+                files=files, 
+                timeout=self.timeout,
+                impersonate="chrome120", # Try a different impersonation profile
+            )
+            response.raise_for_status() # Check for HTTP errors
+
             try:
-                with requests.post(self.api_endpoint, headers=self.headers, data=form_data, files=files, stream=True, timeout=self.timeout) as response:
-                    response.raise_for_status()
-                    response_chunks = []
-                    json_str = ''
-                    for chunk in response.iter_content(chunk_size=self.stream_chunk_size, decode_unicode=True):
-                        if chunk:
-                            response_chunks.append(chunk)
-                            yield chunk if raw else dict(text=chunk)
-                    json_str = ''.join(response_chunks)
-                    try:
-                        response_data = json.loads(json_str)
-                    except json.JSONDecodeError as json_err:
-                        raise exceptions.FailedToGenerateResponseError(f"\nError decoding JSON: {json_err}")
-                    homeworkify_html = response_data.get("homeworkifyResponse", "")
-                    if not homeworkify_html:
-                        raise exceptions.FailedToGenerateResponseError("\nNo 'homeworkifyResponse' found in the response.")
-                    clean_text = homeworkify_html  # Removed html_to_terminal call
-                    self.last_response.update(dict(text=clean_text))
-                    self.conversation.update_chat_history(
-                        prompt, self.get_message(self.last_response)
-                    )
-            except requests.exceptions.RequestException as e:
-                raise exceptions.FailedToGenerateResponseError(f"An error occurred: {e}")
-        
-        def for_non_stream():
-            response = self.session.post(self.api_endpoint, headers=self.headers, data=form_data, files=files, timeout=self.timeout)
-            if not response.ok:
-                raise Exception(
-                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
-                )
+                response_data = response.json()
+            except json.JSONDecodeError as json_err:
+                raise exceptions.FailedToGenerateResponseError(f"Error decoding JSON: {json_err} - Response text: {response.text}")
 
-            # Parse the entire JSON response
-            response_data = response.json()
             homeworkify_html = response_data.get("homeworkifyResponse", "")
             if not homeworkify_html:
-                return {"text": "No content found in the response"}  # Default in case content not found
-            clean_text = homeworkify_html  # Removed html_to_terminal call
+                 # Return empty if no content, consistent with original non-stream logic
+                clean_text = ""
+            else:
+                # Assuming the response is HTML that needs cleaning/parsing
+                # For now, just return the raw HTML content as text
+                clean_text = homeworkify_html 
 
-            # Simulate streaming by yielding chunks of the content
-            chunk_size = self.stream_chunk_size
-            for i in range(0, len(clean_text), chunk_size):
-                chunk = clean_text[i:i + chunk_size]
-                self.last_response.update(dict(text=chunk))
-                yield chunk if raw else dict(text=chunk)
-            return self.last_response
+            self.last_response = {"text": clean_text}
+            self.conversation.update_chat_history(prompt, clean_text)
+            return self.last_response # Return the full response content
+
+        except CurlError as e: # Catch CurlError
+            raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}")
+        except Exception as e: # Catch other potential exceptions
+            # Include response text if available in HTTP errors
+            err_text = getattr(e, 'response', None) and getattr(e.response, 'text', '')
+            raise exceptions.FailedToGenerateResponseError(f"An unexpected error occurred ({type(e).__name__}): {e} - {err_text}")
+        finally:
+            if file_handle: # Ensure file is closed
+                file_handle.close()
 
-        return for_stream() if stream else for_non_stream()
 
     def chat(
         self,
         prompt: str,
-        stream: bool = False,
+        stream: bool = False, # Keep stream param for interface consistency, though API might not support it
         optimizer: str = None,
         conversationally: bool = False,
         attachment_path: Optional[str] = None,
@@ -246,7 +238,33 @@ class TutorAI(Provider):
 if __name__ == "__main__":
     from rich import print
 
-    ai = TutorAI()
-    response = ai.chat("hello buddy", attachment_path=None)
-    for chunk in response:
-        print(chunk, end="", flush=True)
+    try: # Add try-except block for testing
+        ai = TutorAI(timeout=120) # Increased timeout for potential uploads
+        # Test without attachment first
+        print("[bold blue]Testing Text Prompt:[/bold blue]")
+        response_gen = ai.chat("hello buddy", stream=True) # Test stream interface
+        full_response = ""
+        for chunk in response_gen:
+            print(chunk, end="", flush=True)
+            full_response += chunk
+        print("\n[bold green]Text Test Complete.[/bold green]\n")
+
+        # Optional: Test with attachment (replace with a valid image path)
+        # attachment_file = "path/to/your/image.png" 
+        # if os.path.exists(attachment_file):
+        #     print(f"[bold blue]Testing with Attachment ({attachment_file}):[/bold blue]")
+        #     response_gen_attach = ai.chat("Describe this image", stream=True, attachment_path=attachment_file)
+        #     full_response_attach = ""
+        #     for chunk in response_gen_attach:
+        #         print(chunk, end="", flush=True)
+        #         full_response_attach += chunk
+        #     print("\n[bold green]Attachment Test Complete.[/bold green]")
+        # else:
+        #      print(f"[bold yellow]Skipping attachment test: File not found at {attachment_file}[/bold yellow]")
+
+    except exceptions.FailedToGenerateResponseError as e:
+        print(f"\n[bold red]API Error:[/bold red] {e}")
+    except FileNotFoundError as e:
+         print(f"\n[bold red]File Error:[/bold red] {e}")
+    except Exception as e:
+        print(f"\n[bold red]An unexpected error occurred:[/bold red] {e}")

webscout/Provider/typefully.py

@@ -1,14 +1,16 @@
-from typing import Union, Any, Dict
-import requests
+from typing import Optional, Union, Any, Dict
 import re
 from uuid import uuid4
 
 from webscout.AIutel import Optimizers
 from webscout.AIutel import Conversation
-from webscout.AIutel import AwesomePrompts
+from webscout.AIutel import AwesomePrompts, sanitize_stream # Import sanitize_stream
 from webscout.AIbase import Provider
 from webscout import exceptions
 from webscout.litagent import LitAgent
+# Replace requests with curl_cffi
+from curl_cffi.requests import Session # Import Session
+from curl_cffi import CurlError # Import CurlError
 
 class TypefullyAI(Provider):
     """
@@ -63,7 +65,8 @@ class TypefullyAI(Provider):
             >>> print(ai.system_prompt)
             'You are a friendly assistant.'
         """
-        self.session = requests.Session()
+        # Initialize curl_cffi Session
+        self.session = Session()
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
         self.api_endpoint = "https://typefully.com/tools/ai/api/completion"
@@ -96,7 +99,9 @@ class TypefullyAI(Provider):
             for method in dir(Optimizers)
             if callable(getattr(Optimizers, method)) and not method.startswith("__")
         )
+        # Update curl_cffi session headers and proxies
         self.session.headers.update(self.headers)
+        self.session.proxies = proxies # Use proxies directly, not session.proxies.update
         Conversation.intro = (
             AwesomePrompts().get_act(
                 act, raise_not_found=True, default=None, case_insensitive=True
@@ -108,7 +113,17 @@ class TypefullyAI(Provider):
             is_conversation, self.max_tokens_to_sample, filepath, update_file
         )
         self.conversation.history_offset = history_offset
-        self.session.proxies = proxies
+
+    @staticmethod
+    def _typefully_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
+        """Extracts content from the Typefully stream format '0:"..."'."""
+        if isinstance(chunk, str):
+            match = re.search(r'0:"(.*?)"(?=,|$)', chunk) # Look for 0:"...", possibly followed by comma or end of string
+            if match:
+                # Decode potential unicode escapes like \u00e9 and handle escaped quotes/backslashes
+                content = match.group(1).encode().decode('unicode_escape')
+                return content.replace('\\\\', '\\').replace('\\"', '"')
+        return None
 
     def ask(
         self,
@@ -156,31 +171,50 @@ class TypefullyAI(Provider):
         }
 
         def for_stream():
-            response = self.session.post(self.api_endpoint, headers=self.headers, json=payload, stream=True, timeout=self.timeout)
-            if not response.ok:
-                raise exceptions.FailedToGenerateResponseError(
-                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+            try: # Add try block for CurlError
+                # Use curl_cffi session post with impersonate
+                response = self.session.post(
+                    self.api_endpoint, 
+                    headers=self.headers, 
+                    json=payload, 
+                    stream=True, 
+                    timeout=self.timeout,
+                    impersonate="chrome120" # Add impersonate
                 )
-            streaming_response = ""
-            for line in response.iter_lines(decode_unicode=True):
-                if line:
-                    match = re.search(r'0:"(.*?)"', line)
-                    if match:
-                        content = match.group(1)
-                        streaming_response += content
-                        yield content if raw else dict(text=content)
-                    elif line.startswith('e:') or line.startswith('d:'):
-                        # End of response
-                        break
-            self.last_response.update(dict(text=streaming_response))
-            self.conversation.update_chat_history(
-                prompt, self.get_message(self.last_response)
-            )
+                if not response.ok:
+                    raise exceptions.FailedToGenerateResponseError(
+                        f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                    )
+                streaming_text = ""
+                # Use sanitize_stream with the custom extractor
+                processed_stream = sanitize_stream(
+                    data=response.iter_content(chunk_size=None), # Pass byte iterator
+                    intro_value=None, # No simple prefix
+                    to_json=False,    # Content is not JSON
+                    content_extractor=self._typefully_extractor, # Use the specific extractor
+                    end_marker="e:", # Stop processing if "e:" line is encountered (adjust if needed)
+                )
+
+                for content_chunk in processed_stream:
+                    if content_chunk and isinstance(content_chunk, str):
+                        streaming_text += content_chunk
+                        yield content_chunk if raw else dict(text=content_chunk)
+                # Update history and last response after stream finishes
+                self.last_response.update(dict(text=streaming_text))
+                self.conversation.update_chat_history(
+                    prompt, self.get_message(self.last_response)
+                )
+            except CurlError as e: # Catch CurlError
+                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}")
+            except Exception as e: # Catch other potential exceptions
+                raise exceptions.FailedToGenerateResponseError(f"An unexpected error occurred ({type(e).__name__}): {e}")
 
         def for_non_stream():
+            # This function implicitly uses the updated for_stream
             for _ in for_stream():
                 pass
-            return self.last_response
+            # Ensure last_response is updated by for_stream before returning
+            return self.last_response 
 
         return for_stream() if stream else for_non_stream()
 
@@ -246,10 +280,18 @@ class TypefullyAI(Provider):
             'Why did the scarecrow win an award? Because he was outstanding in his field!'
         """
         assert isinstance(response, dict), "Response should be of dict data-type only"
-        formatted_text = response["text"].replace('\\n', '\n').replace('\\n\\n', '\n\n')
-        return formatted_text
+        # Handle potential unicode escapes in the final text
+        # Formatting is now handled by the extractor
+        text = response.get("text", "")
+        try:
+            formatted_text = text.replace('\\n', '\n').replace('\\n\\n', '\n\n')
+            return formatted_text
+        except Exception: # Catch potential errors during newline replacement
+             return text # Return original text if formatting fails
+
 
 if __name__ == "__main__":
+    # Ensure curl_cffi is installed
     print("-" * 80)
     print(f"{'Model':<50} {'Status':<10} {'Response'}")
     print("-" * 80)
@@ -261,20 +303,28 @@ if __name__ == "__main__":
     for model in TypefullyAI.AVAILABLE_MODELS:
         try:
             test_ai = TypefullyAI(model=model, timeout=60)
-            response = test_ai.chat("Say 'Hello' in one word", stream=True)
+            # Test stream first
+            response_stream = test_ai.chat("Say 'Hello' in one word", stream=True)
             response_text = ""
-            for chunk in response:
+            print(f"\r{model:<50} {'Streaming...':<10}", end="", flush=True)
+            for chunk in response_stream:
                 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()
+                # Clean and truncate response
+                clean_text = response_text.strip() # Already formatted in get_message
+                display_text = clean_text[:50] + "..." if len(clean_text) > 50 else clean_text
             else:
-                status = "✗"
-                display_text = "Empty or invalid response"
+                status = "✗ (Stream)"
+                display_text = "Empty or invalid stream response"
             print(f"\r{model:<50} {status:<10} {display_text}")
+            
+            # Optional: Add non-stream test if needed
+            # print(f"\r{model:<50} {'Non-Stream...':<10}", end="", flush=True)
+            # response_non_stream = test_ai.chat("Say 'Hi' again", stream=False)
+            # if not response_non_stream or len(response_non_stream.strip()) == 0:
+            #      print(f"\r{model:<50} {'✗ (Non-Stream)':<10} Empty non-stream response")
+
         except Exception as e:
             print(f"\r{model:<50} {'✗':<10} {str(e)}")
-