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

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,5 +1,4 @@
 from typing import Union, Any, Dict
-import requests
 import re
 from uuid import uuid4
 
@@ -9,6 +8,9 @@ from webscout.AIutel import AwesomePrompts
 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,6 @@ class TypefullyAI(Provider):
             is_conversation, self.max_tokens_to_sample, filepath, update_file
         )
         self.conversation.history_offset = history_offset
-        self.session.proxies = proxies
 
     def ask(
         self,
@@ -156,31 +160,51 @@ 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_response = ""
+                # Iterate over bytes and decode manually
+                for line_bytes in response.iter_lines():
+                    if line_bytes:
+                        line = line_bytes.decode('utf-8') # Decode bytes
+                        match = re.search(r'0:"(.*?)"', line)
+                        if match:
+                            # Decode potential unicode escapes
+                            content = match.group(1).encode().decode('unicode_escape') 
+                            streaming_response += content
+                            # Yield dict or raw string
+                            yield content if raw else dict(text=content)
+                        elif line.startswith('e:') or line.startswith('d:'):
+                            # End of response
+                            break
+                # Update history and last response after stream finishes
+                self.last_response.update(dict(text=streaming_response))
+                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 +270,19 @@ 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
+        text = response.get("text", "")
+        try:
+            # Attempt to decode escapes, return original if fails
+            # Already decoded in ask method, just handle formatting
+            formatted_text = text.replace('\\n', '\n').replace('\\n\\n', '\n\n')
+            return formatted_text
+        except Exception: # Catch potential errors during formatting
+             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 +294,29 @@ 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)}")
-    
+

webscout/Provider/typegpt.py

@@ -1,7 +1,7 @@
-import requests
+from curl_cffi.requests import Session
+from curl_cffi import CurlError
 import json
 from typing import Union, Any, Dict, Generator
-import requests.exceptions
 
 from webscout.AIutel import Optimizers
 from webscout.AIutel import Conversation
@@ -35,7 +35,7 @@ class TypeGPT(Provider):
         proxies: dict = {},
         history_offset: int = 10250,
         act: str = None,
-        model: str = "gpt-4o",
+        model: str = "gpt-4o-mini-2024-07-18",
         system_prompt: str = "You are a helpful assistant.",
         temperature: float = 0.5,
         presence_penalty: int = 0,
@@ -46,7 +46,8 @@ class TypeGPT(Provider):
         if model not in self.AVAILABLE_MODELS:
             raise ValueError(f"Invalid model: {model}. Choose from: {', '.join(self.AVAILABLE_MODELS)}")
 
-        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://chat.typegpt.net/api/openai/v1/chat/completions"
@@ -82,6 +83,8 @@ class TypeGPT(Provider):
         )
         self.conversation = Conversation(is_conversation, self.max_tokens_to_sample, filepath, update_file)
         self.conversation.history_offset = history_offset
+        # Update curl_cffi session headers and proxies
+        self.session.headers.update(self.headers)
         self.session.proxies = proxies
 
     def ask(
@@ -120,12 +123,18 @@ class TypeGPT(Provider):
 
         def for_stream():
             try:
+                # Use curl_cffi session post with impersonate
                 response = self.session.post(
-                    self.api_endpoint, headers=self.headers, json=payload, stream=True, timeout=self.timeout
+                    self.api_endpoint, 
+                    headers=self.headers, 
+                    json=payload, 
+                    stream=True, 
+                    timeout=self.timeout,
+                    impersonate="chrome120"
                 )
-            except requests.exceptions.ConnectionError as ce:
+            except CurlError as ce:
                 raise exceptions.FailedToGenerateResponseError(
-                    f"Network connection failed. Check your firewall or antivirus settings. Original error: {ce}"
+                    f"Network connection failed (CurlError). Check your firewall or antivirus settings. Original error: {ce}"
                 ) from ce
 
             if not response.ok:
@@ -133,9 +142,10 @@ class TypeGPT(Provider):
                     f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
                 )
             message_load = ""
-            for line in response.iter_lines():
-                if line:
-                    line = line.decode("utf-8")
+            # Iterate over bytes and decode manually
+            for line_bytes in response.iter_lines():
+                if line_bytes:
+                    line = line_bytes.decode("utf-8")
                     if line.startswith("data: "):
                         line = line[6:]  # Remove "data: " prefix
                         # Skip [DONE] message
@@ -151,26 +161,52 @@ class TypeGPT(Provider):
                                     message_load += new_content
                                     # Yield only the new content
                                     yield dict(text=new_content) if not raw else new_content
-                                    self.last_response = dict(text=message_load)
+                                    # Update last_response incrementally for potential non-stream use later
+                                    self.last_response = dict(text=message_load) 
                         except json.JSONDecodeError:
                             continue
-            self.conversation.update_chat_history(prompt, self.get_message(self.last_response))
+            # Update conversation history after stream finishes
+            if message_load: # Only update if something was received
+                 self.conversation.update_chat_history(prompt, message_load)
+
 
         def for_non_stream():
             try:
-                response = self.session.post(self.api_endpoint, headers=self.headers, json=payload, timeout=self.timeout)
-            except requests.exceptions.ConnectionError as ce:
+                # Use curl_cffi session post with impersonate
+                response = self.session.post(
+                    self.api_endpoint, 
+                    headers=self.headers, 
+                    json=payload, 
+                    timeout=self.timeout,
+                    impersonate="chrome120"
+                )
+            except CurlError as ce:
                 raise exceptions.FailedToGenerateResponseError(
-                    f"Network connection failed. Check your firewall or antivirus settings. Original error: {ce}"
+                    f"Network connection failed (CurlError). Check your firewall or antivirus settings. Original error: {ce}"
                 ) from ce
 
             if not response.ok:
                 raise exceptions.FailedToGenerateResponseError(
                     f"Request failed - {response.status_code}: {response.text}"
                 )
-            self.last_response = response.json()
-            self.conversation.update_chat_history(prompt, self.get_message(self.last_response))
-            return self.last_response
+            
+            try:
+                # curl_cffi response.json() handles decoding
+                response_data = response.json() 
+                # Extract the message content for history and return value
+                if 'choices' in response_data and len(response_data['choices']) > 0:
+                    message = response_data['choices'][0].get('message', {})
+                    content = message.get('content', '')
+                    self.last_response = {"text": content} # Store in expected format
+                    self.conversation.update_chat_history(prompt, content)
+                    return self.last_response
+                else:
+                     # Handle cases where response structure is unexpected
+                     self.last_response = {"text": ""} 
+                     return self.last_response
+            except json.JSONDecodeError as je:
+                 raise exceptions.FailedToGenerateResponseError(f"Failed to decode JSON response: {je} - Response text: {response.text}")
+
 
         return for_stream() if stream else for_non_stream()
 
@@ -183,23 +219,36 @@ class TypeGPT(Provider):
     ) -> Union[str, Generator[str, None, None]]:
         """Generate response string or stream."""
         if stream:
+            # ask() yields dicts or strings when streaming
             gen = self.ask(
-                prompt, stream=True, optimizer=optimizer, conversationally=conversationally
+                prompt, stream=True, raw=False, # Ensure ask yields dicts
+                optimizer=optimizer, conversationally=conversationally
             )
-            for chunk in gen:
-                yield self.get_message(chunk)  # Extract text from streamed chunks
+            for chunk_dict in gen:
+                 # get_message expects a dict
+                yield self.get_message(chunk_dict) 
         else:
-            return self.get_message(self.ask(prompt, stream=False, optimizer=optimizer, conversationally=conversationally))
+            # ask() returns a dict when not streaming
+            response_dict = self.ask(
+                prompt, stream=False, 
+                optimizer=optimizer, conversationally=conversationally
+            )
+            return self.get_message(response_dict)
 
     def get_message(self, response: Dict[str, Any]) -> str:
         """Retrieves message from response."""
-        if isinstance(response, str):  # Handle raw responses
-            return response
-        elif isinstance(response, dict):
+        if isinstance(response, dict):
             assert isinstance(response, dict), "Response should be of dict data-type only"
-            return response.get("text", "")  # Extract text from dictionary response
+            # Handle potential unicode escapes in the final text
+            text = response.get("text", "")
+            try:
+                # Attempt to decode escapes, return original if fails
+                return text.encode('utf-8').decode('unicode_escape')
+            except UnicodeDecodeError:
+                return text 
         else:
-            raise TypeError("Invalid response type. Expected str or dict.")
+            # This case should ideally not be reached if ask() behaves as expected
+            raise TypeError(f"Invalid response type: {type(response)}. Expected dict.")
 
 if __name__ == "__main__":
     print("-" * 80)
@@ -213,20 +262,32 @@ if __name__ == "__main__":
     for model in TypeGPT.AVAILABLE_MODELS:
         try:
             test_ai = TypeGPT(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)
+                # Optional: print chunks as they arrive for visual feedback
+                # print(chunk, 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 decoded 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, but stream test covers basic functionality
+            # 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)}")
-    
+