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

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 typing import Generator, Dict, Any, List, Optional, 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, sanitize_stream # Import sanitize_stream
 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)
         
@@ -91,6 +104,14 @@ class Venice(Provider):
         )
         self.conversation.history_offset = history_offset
 
+    @staticmethod
+    def _venice_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
+        """Extracts content from Venice stream JSON objects."""
+        if isinstance(chunk, dict) and chunk.get("kind") == "content":
+            return chunk.get("content")
+        return None
+
+
     def ask(
         self,
         prompt: str,
@@ -108,64 +129,81 @@ 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
-                    
-                    self.conversation.update_chat_history(prompt, streaming_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=True,     # Each line is JSON
+                    content_extractor=self._venice_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 _venice_extractor
+                    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.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 +228,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,13 +1,13 @@
 import re
 import time
-import requests
+from curl_cffi import requests
 import json
 from typing import Union, Any, Dict, Generator, Optional
 import uuid
 
 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
@@ -111,6 +111,17 @@ class VercelAI(Provider):
         )
         self.conversation.history_offset = history_offset
 
+    @staticmethod
+    def _vercelai_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
+        """Extracts content from the VercelAI 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,
         prompt: str,
@@ -153,15 +164,21 @@ class VercelAI(Provider):
                 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))
+            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._vercelai_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))
             self.conversation.update_chat_history(
                 prompt, self.get_message(self.last_response)
             )
@@ -201,8 +218,10 @@ class VercelAI(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')
+        assert isinstance(response, dict), "Response should be of dict data-type only" 
+        # Formatting is handled by the extractor now
+        text = response.get("text", "")
+        return text.replace('\\n', '\n').replace('\\n\\n', '\n\n') # Keep newline replacement if needed
 
 if __name__ == "__main__":
     print("-" * 80)
@@ -231,4 +250,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)

webscout/Provider/Writecream.py

@@ -1,10 +1,11 @@
-import requests
+from curl_cffi import CurlError 
+from curl_cffi.requests import Session # Keep Session import
 import json
 from typing import Any, Dict, Optional, Generator, Union
 
 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
@@ -29,7 +30,6 @@ class Writecream(Provider):
         act: str = None,
         system_prompt: str = "You are a helpful and informative AI assistant.",
         base_url: str = "https://8pe3nv3qha.execute-api.us-east-1.amazonaws.com/default/llm_chat",
-        user_agent: str = "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Mobile Safari/537.36",
         referer: str = "https://www.writecream.com/chatgpt-chat/",
         link: str = "writecream.com",
         model: str = "writecream-gpt"
@@ -40,7 +40,8 @@ class Writecream(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.base_url = base_url
@@ -48,13 +49,16 @@ class Writecream(Provider):
         self.last_response = {}
         self.system_prompt = system_prompt
         self.model = model
-        self.user_agent = user_agent
+        # Initialize LitAgent
+        self.agent = LitAgent()
         self.referer = referer
         self.link = link
 
         self.headers = {
-            "User-Agent": self.user_agent,
+            # Use LitAgent for User-Agent
+            "User-Agent": self.agent.random(),
             "Referer": self.referer
+            # Add other headers if needed by curl_cffi impersonation or API
         }
 
         self.__available_optimizers = (
@@ -63,6 +67,7 @@ class Writecream(Provider):
             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.update(proxies)
 
@@ -123,20 +128,40 @@ class Writecream(Provider):
 
         def for_non_stream():
             try:
-                response = self.session.get(self.base_url, params=params, timeout=self.timeout)
+                # Use curl_cffi session.get with impersonate
+                response = self.session.get(
+                    self.base_url,
+                    params=params,
+                    timeout=self.timeout,
+                    impersonate="chrome120" # Add impersonate
+                )
                 response.raise_for_status()
-                data = response.json()
+                response_text = response.text # Get the raw text
+
+                # Use sanitize_stream to process the non-streaming text
+                # It will try to parse the whole text as JSON because to_json=True
+                processed_stream = sanitize_stream(
+                    data=response_text,
+                    to_json=True, # Attempt to parse the whole response text as JSON
+                    intro_value=None, # No prefix expected on the full response
+                    content_extractor=lambda chunk: chunk.get("response", chunk.get("response_content", "")) if isinstance(chunk, dict) else None
+                )
 
-                # Extract the response content
-                response_content = data.get("response", data.get("response_content", ""))
+                # Extract the single result from the generator
+                response_content = ""
+                for content in processed_stream:
+                    response_content = content if isinstance(content, str) else ""
 
                 # Update conversation history
                 self.last_response = {"text": response_content}
                 self.conversation.update_chat_history(prompt, response_content)
 
                 return {"text": response_content}
+            except CurlError as e: # Catch CurlError
+                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}")
             except Exception as e:
-                raise exceptions.FailedToGenerateResponseError(f"Failed to get response from the chat API: {e}")
+                # Include original exception type
+                raise exceptions.FailedToGenerateResponseError(f"Failed to get response ({type(e).__name__}): {e}")
 
         # Currently, Writecream API doesn't support streaming, so we always return non-streaming response
         return for_non_stream()
@@ -188,6 +213,7 @@ class Writecream(Provider):
 
 
 if __name__ == "__main__":
+    # Ensure curl_cffi is installed
     print("-" * 80)
     print(f"{'Model':<30} {'Status':<10} {'Response'}")
     print("-" * 80)