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

webscout/Provider/TwoAI.py

@@ -1,12 +1,12 @@
-import requests
+from curl_cffi.requests import Session
+from curl_cffi import CurlError
 import json
-import os
 from typing import Any, Dict, Optional, Generator, Union
 
 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.AIbase import Provider
 from webscout import exceptions
 from webscout.litagent import LitAgent
 class TwoAI(Provider):
@@ -47,9 +47,11 @@ class TwoAI(Provider):
             'Referer': 'https://api.two.app/'
         }
         
-        self.session = requests.Session()
+        # Initialize curl_cffi Session
+        self.session = Session()
+        # Update curl_cffi session headers and proxies
         self.session.headers.update(self.headers)
-        self.session.proxies.update(proxies)
+        self.session.proxies = proxies
 
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
@@ -90,9 +92,7 @@ class TwoAI(Provider):
         conversation_prompt = self.conversation.gen_complete_prompt(prompt)
         if optimizer:
             if optimizer in self.__available_optimizers:
-                conversation_prompt = getattr(Optimizers, optimizer)(
-                    conversation_prompt if conversationally else prompt
-                )
+                conversation_prompt = getattr(Optimizers, optimizer)(conversation_prompt if conversationally else prompt)
             else:
                 raise Exception(f"Optimizer is not one of {self.__available_optimizers}")
 
@@ -111,39 +111,65 @@ class TwoAI(Provider):
 
         def for_stream():
             try:
-                with self.session.post(self.url, json=payload, stream=True, timeout=self.timeout) as response:
-                    if response.status_code != 200:
-                        raise exceptions.FailedToGenerateResponseError(
-                            f"Request failed with status code {response.status_code}"
-                        )
-                    
-                    streaming_text = ""
-                    for line in response.iter_lines(decode_unicode=True):
-                        if line:
-                            try:
-                                chunk = json.loads(line)
-                                if chunk["typeName"] == "LLMChunk":
-                                    content = chunk["content"]
-                                    streaming_text += content
-                                    resp = dict(text=content)
-                                    yield resp if raw else resp
-                            except json.JSONDecodeError:
-                                continue
+                # Use curl_cffi session post with impersonate
+                response = self.session.post(
+                    self.url, 
+                    json=payload, 
+                    stream=True, 
+                    timeout=self.timeout,
+                    impersonate="chrome110" # Add impersonate
+                )
+                
+                if response.status_code != 200:
+                    raise exceptions.FailedToGenerateResponseError(
+                        f"Request failed with status code {response.status_code} - {response.text}"
+                    )
                     
-                    self.last_response = {"text": streaming_text}
-                    self.conversation.update_chat_history(prompt, streaming_text)
+                streaming_text = ""
+                # Iterate over bytes and decode manually
+                for line_bytes in response.iter_lines():
+                    if line_bytes:
+                        try:
+                            line = line_bytes.decode('utf-8') # Decode bytes
+                            chunk = json.loads(line)
+                            if chunk.get("typeName") == "LLMChunk": # Use .get for safety
+                                content = chunk.get("content", "") # Use .get for safety
+                                streaming_text += content
+                                resp = dict(text=content)
+                                # Yield dict or raw string
+                                yield resp if raw else resp
+                        except json.JSONDecodeError:
+                            continue
+                        except UnicodeDecodeError:
+                            continue
+                
+                # Update history and last response after stream finishes
+                self.last_response = {"text": streaming_text}
+                self.conversation.update_chat_history(prompt, streaming_text)
                     
-            except requests.RequestException as e:
-                raise exceptions.FailedToGenerateResponseError(f"Request failed: {str(e)}")
+            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():
+            # Non-stream requests might not work the same way if the API expects streaming.
+            # This implementation aggregates the stream.
             streaming_text = ""
-            for resp in for_stream():
-                streaming_text += resp["text"]
-            self.last_response = {"text": streaming_text}
-            return self.last_response
+            # Iterate through the generator provided by for_stream
+            for chunk_data in for_stream():
+                # Check if chunk_data is a dict (not raw) and has 'text'
+                if isinstance(chunk_data, dict) and "text" in chunk_data:
+                    streaming_text += chunk_data["text"]
+                # If raw=True, chunk_data is the string content itself
+                elif isinstance(chunk_data, str):
+                     streaming_text += chunk_data
+            # last_response and history are updated within for_stream
+            return self.last_response # Return the final aggregated response
 
-        return for_stream() if stream else for_non_stream()
+        # Ensure stream defaults to True if not provided, matching original behavior
+        effective_stream = stream if stream is not None else True
+        return for_stream() if effective_stream else for_non_stream()
 
     def chat(
         self,
@@ -154,30 +180,35 @@ class TwoAI(Provider):
         online_search: bool = True,
         reasoning_on: bool = False,
     ) -> str:
-        def for_stream():
-            for response in self.ask(
+        # Ensure stream defaults to True if not provided
+        effective_stream = stream if stream is not None else True
+
+        def for_stream_chat():
+            # ask() yields dicts when raw=False
+            for response_dict in self.ask(
                 prompt, 
-                True, 
+                stream=True, 
+                raw=False, # Ensure ask yields dicts
                 optimizer=optimizer, 
                 conversationally=conversationally,
                 online_search=online_search,
                 reasoning_on=reasoning_on
             ):
-                yield self.get_message(response)
+                yield self.get_message(response_dict)
         
-        def for_non_stream():
-            return self.get_message(
-                self.ask(
-                    prompt, 
-                    False, 
-                    optimizer=optimizer, 
-                    conversationally=conversationally,
-                    online_search=online_search,
-                    reasoning_on=reasoning_on
-                )
+        def for_non_stream_chat():
+            # ask() returns a dict when stream=False
+            response_dict = self.ask(
+                prompt, 
+                stream=False, 
+                optimizer=optimizer, 
+                conversationally=conversationally,
+                online_search=online_search,
+                reasoning_on=reasoning_on
             )
+            return self.get_message(response_dict)
         
-        return for_stream() if stream else for_non_stream()
+        return for_stream_chat() if effective_stream else for_non_stream_chat()
 
     def get_message(self, response: dict) -> str:
         assert isinstance(response, dict), "Response should be of dict data-type only"
@@ -186,14 +217,32 @@ class TwoAI(Provider):
 if __name__ == "__main__":
     from rich import print
 
-    api_key = ""
-    
-    ai = TwoAI(
-        api_key=api_key,
-        timeout=60,
-        system_message="You are an intelligent AI assistant. Be concise and helpful."
-    )
+    api_key = "" # Add your API key here or load from env
     
-    response = ai.chat("666+444=?", stream=True, reasoning_on=True)
-    for chunk in response:
-        print(chunk, end="", flush=True)
+    try: # Add try-except block for testing
+        ai = TwoAI(
+            api_key=api_key,
+            timeout=60,
+            system_message="You are an intelligent AI assistant. Be concise and helpful."
+        )
+        
+        print("[bold blue]Testing Stream:[/bold blue]")
+        response_stream = ai.chat("666+444=?", stream=True, reasoning_on=True)
+        full_stream_response = ""
+        for chunk in response_stream:
+            print(chunk, end="", flush=True)
+            full_stream_response += chunk
+        print("\n[bold green]Stream Test Complete.[/bold green]\n")
+
+        # 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 ValueError as e:
+         print(f"\n[bold red]Configuration Error:[/bold red] {e}")
+    except Exception as e:
+        print(f"\n[bold red]An unexpected error occurred:[/bold red] {e}")

webscout/Provider/Venice.py

@@ -1,11 +1,13 @@
-import requests
+from curl_cffi import CurlError
+from curl_cffi.requests import Session # Import Session
 import json
 from typing import Generator, Dict, Any, List, Union
 from uuid import uuid4
+import random
 
 from webscout.AIutel import Optimizers
 from webscout.AIutel import Conversation
-from webscout.AIutel import AwesomePrompts, sanitize_stream
+from webscout.AIutel import AwesomePrompts
 from webscout.AIbase import Provider
 from webscout import exceptions
 from webscout.litagent import LitAgent
@@ -17,6 +19,7 @@ class Venice(Provider):
     
     AVAILABLE_MODELS = [
         "mistral-31-24b",
+        "dolphin-3.0-mistral-24b",
         "llama-3.2-3b-akash",
         "qwen2dot5-coder-32b",
         "deepseek-coder-v2-lite",
@@ -28,23 +31,26 @@ class Venice(Provider):
         is_conversation: bool = True,
         max_tokens: int = 2000,
         timeout: int = 30,
-        temperature: float = 0.8,
-        top_p: float = 0.9,
+        temperature: float = 0.8, # Keep temperature, user might want to adjust
+        top_p: float = 0.9, # Keep top_p
         intro: str = None,
         filepath: str = None,
         update_file: bool = True,
         proxies: dict = {},
         history_offset: int = 10250,
         act: str = None,
-        model: str = "llama-3.3-70b",
-        system_prompt: str = "You are a helpful AI assistant."
+        model: str = "mistral-31-24b", 
+        # System prompt is empty in the example, but keep it configurable
+        system_prompt: str = "" 
     ):
         """Initialize Venice AI client"""
         if model not in self.AVAILABLE_MODELS:
             raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
             
-        self.api_endpoint = "https://venice.ai/api/inference/chat"
-        self.session = requests.Session()
+        # Update API endpoint
+        self.api_endpoint = "https://outerface.venice.ai/api/inference/chat" 
+        # Initialize curl_cffi Session
+        self.session = Session() 
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
         self.temperature = temperature
@@ -54,22 +60,29 @@ class Venice(Provider):
         self.system_prompt = system_prompt
         self.last_response = {}
         
-        # Headers for the request
+        # Update Headers based on successful request
         self.headers = {
-            "User-Agent": LitAgent().random(),
+            "User-Agent": LitAgent().random(), # Keep using LitAgent
             "accept": "*/*",
-            "accept-language": "en-US,en;q=0.9",
+            "accept-language": "en-US,en;q=0.9", # Keep existing
             "content-type": "application/json",
             "origin": "https://venice.ai",
-            "referer": "https://venice.ai/chat/",
-            "sec-ch-ua": '"Google Chrome";v="133", "Chromium";v="133", "Not?A_Brand";v="24"',
+            "referer": "https://venice.ai/", # Update referer
+            # Update sec-ch-ua to match example
+            "sec-ch-ua": '"Microsoft Edge";v="135", "Not-A.Brand";v="8", "Chromium";v="135"', 
             "sec-ch-ua-mobile": "?0",
             "sec-ch-ua-platform": '"Windows"',
             "sec-fetch-dest": "empty",
             "sec-fetch-mode": "cors",
-            "sec-fetch-site": "same-origin"
+            # Update sec-fetch-site to match example
+            "sec-fetch-site": "same-site", 
+            # Add missing headers from example
+            "priority": "u=1, i", 
+            "sec-gpc": "1",
+            "x-venice-version": "interface@20250424.065523+50bac27" # Add version header
         }
-        
+
+        # Update curl_cffi session headers and proxies
         self.session.headers.update(self.headers)
         self.session.proxies.update(proxies)
         
@@ -108,64 +121,87 @@ class Venice(Provider):
             else:
                 raise Exception(f"Optimizer is not one of {self.__available_optimizers}")
 
-        # Payload construction
+        # Update Payload construction based on successful request
         payload = {
-            "requestId": str(uuid4())[:7],
+            "requestId": str(uuid4())[:7], # Keep generating request ID
             "modelId": self.model,
             "prompt": [{"content": conversation_prompt, "role": "user"}],
-            "systemPrompt": self.system_prompt,
+            "systemPrompt": self.system_prompt, # Use configured system prompt
             "conversationType": "text",
-            "temperature": self.temperature,
-            "webEnabled": True,
-            "topP": self.top_p,
-            "includeVeniceSystemPrompt": False,
-            "isCharacter": False,
-            "clientProcessingTime": 2000
+            "temperature": self.temperature, # Use configured temperature
+            "webEnabled": True, # Keep webEnabled
+            "topP": self.top_p, # Use configured topP
+            "includeVeniceSystemPrompt": True, # Set to True as per example
+            "isCharacter": False, # Keep as False
+            # Add missing fields from example payload
+            "userId": "user_anon_" + str(random.randint(1000000000, 9999999999)), # Generate anon user ID
+            "isDefault": True, 
+            "textToSpeech": {"voiceId": "af_sky", "speed": 1},
+            "clientProcessingTime": random.randint(10, 50) # Randomize slightly
         }
 
         def for_stream():
             try:
-                with self.session.post(
+                # Use curl_cffi session post
+                response = self.session.post(
                     self.api_endpoint, 
                     json=payload, 
                     stream=True, 
-                    timeout=self.timeout
-                ) as response:
-                    if response.status_code != 200:
-                        raise exceptions.FailedToGenerateResponseError(
-                            f"Request failed with status code {response.status_code}"
-                        )
+                    timeout=self.timeout,
+                    impersonate="edge101" # Match impersonation closer to headers
+                ) 
+                # Check response status after the call
+                if response.status_code != 200:
+                    # Include response text in error
+                    raise exceptions.FailedToGenerateResponseError(
+                        f"Request failed with status code {response.status_code} - {response.text}"
+                    )
                     
-                    streaming_text = ""
-                    for line in response.iter_lines():
-                        if not line:
-                            continue
-                        
-                        try:
-                            # Decode bytes to string
-                            line_data = line.decode('utf-8').strip()
-                            if '"kind":"content"' in line_data:
-                                data = json.loads(line_data)
-                                if 'content' in data:
-                                    content = data['content']
-                                    streaming_text += content
-                                    resp = dict(text=content)
-                                    yield resp if raw else resp
-                        except json.JSONDecodeError:
-                            continue
-                        except UnicodeDecodeError:
-                            continue
+                streaming_text = ""
+                # Iterate over bytes and decode manually
+                for line in response.iter_lines(): # Removed decode_unicode
+                    if not line:
+                        continue
                     
-                    self.conversation.update_chat_history(prompt, streaming_text)
+                    try:
+                        # Decode bytes to string
+                        line_data = line.decode('utf-8').strip()
+                        if '"kind":"content"' in line_data:
+                            data = json.loads(line_data)
+                            if 'content' in data:
+                                content = data['content']
+                                streaming_text += content
+                                resp = dict(text=content)
+                                # Yield content or dict based on raw flag
+                                yield content if raw else resp 
+                    except json.JSONDecodeError:
+                        continue
+                    except UnicodeDecodeError:
+                        continue
+                
+                # Update history and last response after stream finishes
+                self.conversation.update_chat_history(prompt, streaming_text)
+                self.last_response = {"text": streaming_text} 
                     
-            except requests.RequestException as e:
-                raise exceptions.FailedToGenerateResponseError(f"Request failed: {str(e)}")
+            except CurlError as e: 
+                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}")
+            # Catch requests.exceptions.RequestException if needed, but CurlError is primary for curl_cffi
+            except Exception as e: 
+                raise exceptions.FailedToGenerateResponseError(f"An unexpected error occurred ({type(e).__name__}): {e}")
 
         def for_non_stream():
             full_text = ""
-            for chunk in for_stream():
-                full_text += chunk["text"]
-            return {"text": full_text}
+            # Iterate through the generator provided by for_stream
+            for chunk_data in for_stream(): 
+                # Check if chunk_data is a dict (not raw) and has 'text'
+                if isinstance(chunk_data, dict) and "text" in chunk_data:
+                    full_text += chunk_data["text"]
+                # If raw=True, chunk_data is the string content itself
+                elif isinstance(chunk_data, str): 
+                     full_text += chunk_data
+            # Update last_response after aggregation
+            self.last_response = {"text": full_text} 
+            return self.last_response 
 
         return for_stream() if stream else for_non_stream()
 
@@ -190,6 +226,7 @@ class Venice(Provider):
         return response["text"]
 
 if __name__ == "__main__":
+    # Ensure curl_cffi is installed
     print("-" * 80)
     print(f"{'Model':<50} {'Status':<10} {'Response'}")
     print("-" * 80)

webscout/Provider/VercelAI.py

@@ -1,6 +1,6 @@
 import re
 import time
-import requests
+from curl_cffi import requests
 import json
 from typing import Union, Any, Dict, Generator, Optional
 import uuid
@@ -231,4 +231,4 @@ if __name__ == "__main__":
                 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)}") 
+            print(f"\r{model:<50} {'✗':<10} {str(e)}")

webscout/Provider/WiseCat.py

@@ -1,11 +1,12 @@
 import re
-import requests
 import json
 from typing import Union, Any, Dict, Generator, Optional
+from curl_cffi import CurlError 
+from curl_cffi.requests import Session
 
 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
@@ -18,12 +19,11 @@ class WiseCat(Provider):
 
     AVAILABLE_MODELS = [
         "chat-model-small",
-        "chat-model-large",
+        # "chat-model-large", # >>> NOT WORKING <<<
         "chat-model-reasoning",
     ]
 
-    def __init__(
-        self,
+    def __init__(self,
         is_conversation: bool = True,
         max_tokens: int = 600,
         timeout: int = 30,
@@ -41,17 +41,21 @@ class WiseCat(Provider):
         if model not in self.AVAILABLE_MODELS:
             raise ValueError(f"Invalid model: {model}. Choose from: {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://wise-cat-groq.vercel.app/api/chat"
-        self.stream_chunk_size = 64
+        # stream_chunk_size is not directly applicable to curl_cffi iter_lines
+        # self.stream_chunk_size = 64 
         self.timeout = timeout
         self.last_response = {}
         self.model = model
         self.system_prompt = system_prompt
         self.litagent = LitAgent()
-        self.headers = self.litagent.generate_fingerprint()
+        # Generate headers using LitAgent, but apply them to the curl_cffi session
+        self.headers = self.litagent.generate_fingerprint() 
+        # Update curl_cffi session headers and proxies
         self.session.headers.update(self.headers)
         self.session.proxies = proxies
 
@@ -72,6 +76,17 @@ class WiseCat(Provider):
         )
         self.conversation.history_offset = history_offset
 
+    @staticmethod
+    def _wisecat_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
+        """Extracts content from the WiseCat stream format '0:"..."'."""
+        if isinstance(chunk, str):
+            match = re.search(r'0:"(.*?)"', chunk)
+            if match:
+                # Decode potential unicode escapes like \u00e9
+                content = match.group(1).encode().decode('unicode_escape')
+                return content.replace('\\\\', '\\').replace('\\"', '"') # Handle escaped backslashes and quotes
+        return None
+
     def ask(
         self,
         prompt: str,
@@ -108,27 +123,46 @@ class WiseCat(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:
-                error_msg = f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
-                raise exceptions.FailedToGenerateResponseError(error_msg)
-
-            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)
-            self.last_response.update(dict(text=streaming_response))
-            self.conversation.update_chat_history(
-                prompt, self.get_message(self.last_response)
-            )
+            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
+                )
+                if not response.ok:
+                    error_msg = f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                    raise exceptions.FailedToGenerateResponseError(error_msg)
+
+                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 remove here
+                    to_json=False,    # Content is not JSON
+                    content_extractor=self._wisecat_extractor # Use the specific extractor
+                )
+
+                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)
+
+                self.last_response.update(dict(text=streaming_text)) # Use streaming_text here
+                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
@@ -164,9 +198,12 @@ class WiseCat(Provider):
     def get_message(self, response: dict) -> str:
         """Retrieves message only from response"""
         assert isinstance(response, dict), "Response should be of dict data-type only"
-        return response["text"].replace('\\n', '\n').replace('\\n\\n', '\n\n')
+        # Formatting (like unicode escapes) is handled by the extractor now.
+        # Keep newline replacement if needed for display.
+        return response.get("text", "").replace('\\n', '\n').replace('\\n\\n', '\n\n')
 
 if __name__ == "__main__":
+    # Ensure curl_cffi is installed
     print("-" * 80)
     print(f"{'Model':<50} {'Status':<10} {'Response'}")
     print("-" * 80)