webscout 8.3.6__py3-none-any.whl → 8.3.7__py3-none-any.whl

webscout/Provider/OPENAI/base.py

@@ -1,6 +1,7 @@
 from abc import ABC, abstractmethod
 from typing import List, Dict, Optional, Union, Generator, Any, TypedDict, Callable
 import json
+import requests
 from dataclasses import dataclass
 
 # Import WebScout Litlogger instead of standard logging
@@ -8,13 +9,6 @@ from webscout.Litlogger import Logger, LogLevel
 
 logger = Logger(name="OpenAIBase", level=LogLevel.INFO)
 
-# Import the LitMeta metaclass from Litproxy
-try:
-    from litproxy import LitMeta 
-except ImportError:
-    from .autoproxy import ProxyAutoMeta as LitMeta
-
-
 # Import the utils for response structures
 from webscout.Provider.OPENAI.utils import ChatCompletion, ChatCompletionChunk
 
@@ -182,39 +176,25 @@ class BaseChat(ABC):
     completions: BaseCompletions
 
 
-class OpenAICompatibleProvider(ABC, metaclass=LitMeta):
+class OpenAICompatibleProvider(ABC):
     """
     Abstract Base Class for providers mimicking the OpenAI Python client structure.
     Requires a nested 'chat.completions' structure with tool support.
-    All subclasses automatically get proxy support via LitMeta.
-
-    # Available proxy helpers:
-    # - self.get_proxied_session() - returns a requests.Session with proxies
-    # - self.get_proxied_curl_session() - returns a curl_cffi.Session with proxies
-    # - self.get_proxied_curl_async_session() - returns a curl_cffi.AsyncSession with proxies
-
-    # Proxy support is automatically injected into:
-    # - requests.Session objects
-    # - httpx.Client objects
-    # - curl_cffi.requests.Session objects
-    # - curl_cffi.requests.AsyncSession objects
-    #
-    # Inbuilt auto-retry is also enabled for all requests.Session and curl_cffi.Session objects.
+    Users can provide their own proxies via the proxies parameter.
     """
     chat: BaseChat
     available_tools: Dict[str, Tool] = {}  # Dictionary of available tools
     supports_tools: bool = False  # Whether the provider supports tools
     supports_tool_choice: bool = False  # Whether the provider supports tool_choice
 
-    @abstractmethod
-    def __init__(self, api_key: Optional[str] = None, tools: Optional[List[Tool]] = None, proxies: Optional[dict] = None, disable_auto_proxy: bool = False, **kwargs: Any):
+    def __init__(self, api_key: Optional[str] = None, tools: Optional[List[Tool]] = None, proxies: Optional[dict] = None, **kwargs: Any):
         self.available_tools = {}
         if tools:
             self.register_tools(tools)
-        # self.proxies is set by ProxyAutoMeta
-        # Subclasses should use self.proxies for all network requests
-        # Optionally, use self.get_proxied_session() for a requests.Session with proxies
-        # The disable_auto_proxy parameter is handled by ProxyAutoMeta
+        self.proxies = proxies or {}
+        self.session = requests.Session()
+        if self.proxies:
+            self.session.proxies.update(self.proxies)
         # raise NotImplementedError  # <-- Commented out for metaclass test
 
     @property
@@ -266,4 +246,4 @@ class OpenAICompatibleProvider(ABC, metaclass=LitMeta):
                     updated_messages.append(tool_message)
                 break
         
-        return updated_messages
+        return updated_messages

webscout/Provider/OPENAI/chatgpt.py

@@ -558,11 +558,16 @@ class ChatGPT(OpenAICompatibleProvider):
     """
 
     def __init__(
-        self
+        self,
+        proxies: Optional[Dict[str, str]] = None
     ):
         """
         Initialize the ChatGPT client.
+        
+        Args:
+            proxies: Optional proxy configuration dict, e.g. {"http": "http://proxy:8080", "https": "https://proxy:8080"}
         """
+        super().__init__(proxies=proxies)
         # Initialize chat interface
         self.chat = Chat(self)
 
@@ -585,4 +590,4 @@ if __name__ == "__main__":
         messages=[{"role": "user", "content": "How manr r in strawberry"}]
     )
     print(response.choices[0].message.content)
-    print()
+    print()

webscout/Provider/OPENAI/chatgptclone.py

@@ -373,7 +373,8 @@ class ChatGPTClone(OpenAICompatibleProvider):
     def __init__(
         self,
         browser: str = "chrome",
-        impersonate: str = "chrome120"
+        impersonate: str = "chrome120",
+        proxies: Optional[Dict[str, str]] = None
     ):
         """
         Initialize the ChatGPTClone client.
@@ -381,15 +382,13 @@ class ChatGPTClone(OpenAICompatibleProvider):
         Args:
             browser: Browser to emulate in user agent (for LitAgent fallback)
             impersonate: Browser impersonation for curl_cffi (default: chrome120)
+            proxies: Optional proxy configuration dict, e.g. {"http": "http://proxy:8080", "https": "https://proxy:8080"}
         """
+        super().__init__(proxies=proxies)
         self.timeout = 30
         self.temperature = 0.6  # Default temperature
         self.top_p = 0.7  # Default top_p
 
-        # Use curl_cffi for Cloudflare bypass and browser impersonation
-        self.session = Session(impersonate=impersonate)
-        self.session.proxies = {}
-
         # Use LitAgent for fingerprint if available, else fallback
         agent = LitAgent()
         self.fingerprint = agent.generate_fingerprint(browser)
@@ -520,5 +519,3 @@ if __name__ == "__main__":
     )
     print(response.choices[0].message.content)
     print()
-    print("Proxies on instance:", client.proxies)
-    print("Proxies on session:", client.session.proxies)

webscout/Provider/OPENAI/chatsandbox.py

@@ -2,8 +2,8 @@ from typing import List, Dict, Optional, Union, Generator, Any
 import time
 import json
 from webscout.litagent import LitAgent
-from .base import OpenAICompatibleProvider, BaseChat, BaseCompletions
-from .utils import (
+from webscout.Provider.OPENAI.base import OpenAICompatibleProvider, BaseChat, BaseCompletions
+from webscout.Provider.OPENAI.utils import (
     ChatCompletion,
     ChatCompletionChunk,
     Choice,
@@ -13,7 +13,10 @@ from .utils import (
     format_prompt,
     count_tokens
 )
-import requests
+from curl_cffi.requests import Session
+from curl_cffi.const import CurlHttpVersion
+from webscout.AIutel import sanitize_stream
+from webscout import exceptions
 
 # ANSI escape codes for formatting
 BOLD = "\033[1m"
@@ -24,6 +27,19 @@ class Completions(BaseCompletions):
     def __init__(self, client: 'ChatSandbox'):
         self._client = client
 
+    @staticmethod
+    def _chatsandbox_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
+        """Extracts content from the chatsandbox stream format."""
+        if isinstance(chunk, str):
+            try:
+                data = json.loads(chunk)
+                if isinstance(data, dict) and "reasoning_content" in data:
+                    return data["reasoning_content"]
+                return chunk
+            except json.JSONDecodeError:
+                return chunk
+        return None
+
     def create(
         self,
         *,
@@ -43,7 +59,7 @@ class Completions(BaseCompletions):
         # Use model name conversion for compatibility
         model = self._client.convert_model_name(model)
         # Compose the conversation prompt using format_prompt
-        question = format_prompt(messages, add_special_tokens=True)
+        question = format_prompt(messages, add_special_tokens=False, do_continue=True)
         payload = {
             "messages": [question],
             "character": model
@@ -70,7 +86,7 @@ class Completions(BaseCompletions):
             'dnt': '1',
             'sec-gpc': '1',
         }
-        session = requests.Session()
+        session = Session()
         session.headers.update(headers)
         session.proxies = proxies if proxies is not None else {}
         
@@ -80,29 +96,37 @@ class Completions(BaseCompletions):
                     url,
                     json=payload,
                     stream=True,
-                    timeout=timeout if timeout is not None else 30
+                    timeout=timeout if timeout is not None else 30,
+                    impersonate="chrome120",
+                    http_version=CurlHttpVersion.V1_1
                 )
-                response.raise_for_status()
-                streaming_text = ""
-                for chunk in response.iter_content(chunk_size=None):
-                    if not chunk:
-                        continue
-                    text = chunk.decode('utf-8', errors='replace')
-                    try:
-                        data = json.loads(text)
-                        content = data.get("reasoning_content", text)
-                    except Exception:
-                        content = text
-                    streaming_text += content
-                    delta = ChoiceDelta(content=content)
-                    choice = Choice(index=0, delta=delta, finish_reason=None)
-                    chunk_obj = ChatCompletionChunk(
-                        id=request_id,
-                        choices=[choice],
-                        created=created_time,
-                        model=model,
+                if not response.ok:
+                    raise exceptions.FailedToGenerateResponseError(
+                        f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
                     )
-                    yield chunk_obj
+                
+                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._chatsandbox_extractor  # Use the specific extractor
+                )
+
+                for content_chunk in processed_stream:
+                    if content_chunk and isinstance(content_chunk, str):
+                        streaming_text += content_chunk
+                        delta = ChoiceDelta(content=content_chunk)
+                        choice = Choice(index=0, delta=delta, finish_reason=None)
+                        chunk_obj = ChatCompletionChunk(
+                            id=request_id,
+                            choices=[choice],
+                            created=created_time,
+                            model=model,
+                        )
+                        yield chunk_obj
+
                 # Final chunk
                 delta = ChoiceDelta(content=None)
                 choice = Choice(index=0, delta=delta, finish_reason="stop")
@@ -116,39 +140,28 @@ class Completions(BaseCompletions):
             except Exception as e:
                 raise RuntimeError(f"ChatSandbox streaming request failed: {e}")
         def for_non_stream():
-            try:
-                response = session.post(
-                    url,
-                    json=payload,
-                    timeout=timeout if timeout is not None else 30
-                )
-                response.raise_for_status()
-                text = response.text
-                try:
-                    data = json.loads(text)
-                    content = data.get("reasoning_content", text)
-                except Exception:
-                    content = text
-                prompt_tokens = count_tokens(question)
-                completion_tokens = count_tokens(content)
-                total_tokens = prompt_tokens + completion_tokens
-                usage = CompletionUsage(
-                    prompt_tokens=prompt_tokens,
-                    completion_tokens=completion_tokens,
-                    total_tokens=total_tokens
-                )
-                message = ChatCompletionMessage(role="assistant", content=content)
-                choice = Choice(index=0, message=message, finish_reason="stop")
-                completion = ChatCompletion(
-                    id=request_id,
-                    choices=[choice],
-                    created=created_time,
-                    model=model,
-                    usage=usage,
-                )
-                return completion
-            except Exception as e:
-                raise RuntimeError(f"ChatSandbox request failed: {e}")
+            streaming_text = ""
+            for chunk_obj in for_stream():
+                if chunk_obj.choices[0].delta.content:
+                    streaming_text += chunk_obj.choices[0].delta.content
+            prompt_tokens = count_tokens(question)
+            completion_tokens = count_tokens(streaming_text)
+            total_tokens = prompt_tokens + completion_tokens
+            usage = CompletionUsage(
+                prompt_tokens=prompt_tokens,
+                completion_tokens=completion_tokens,
+                total_tokens=total_tokens
+            )
+            message = ChatCompletionMessage(role="assistant", content=streaming_text)
+            choice = Choice(index=0, message=message, finish_reason="stop")
+            completion = ChatCompletion(
+                id=request_id,
+                choices=[choice],
+                created=created_time,
+                model=model,
+                usage=usage,
+            )
+            return completion
         return for_stream() if stream else for_non_stream()
 
 class Chat(BaseChat):
@@ -175,3 +188,15 @@ class ChatSandbox(OpenAICompatibleProvider):
         # Default to openai if no match
         print(f"{RED}{BOLD}Warning: Model '{model}' not found, using default model 'openai'{RESET}")
         return "openai"
+
+if __name__ == "__main__":
+    client = ChatSandbox()
+    response = client.chat.completions.create(
+        model="openai",
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": "Explain the theory of relativity in simple terms."}
+        ],
+        stream=False
+    )
+    print(response.choices[0].message.content)

webscout/Provider/OPENAI/deepinfra.py

@@ -195,9 +195,10 @@ class Chat(BaseChat):
 
 class DeepInfra(OpenAICompatibleProvider):
     AVAILABLE_MODELS = [
-        "anthropic/claude-4-opus",
         "moonshotai/Kimi-K2-Instruct",
-        "anthropic/claude-4-sonnet",
+        "Qwen/Qwen3-Next-80B-A3B-Instruct",
+        "Qwen/Qwen3-Next-80B-A3B-Thinking",
+        "moonshotai/Kimi-K2-Instruct-0905",
         "deepseek-ai/DeepSeek-R1-0528-Turbo",
         "Qwen/Qwen3-235B-A22B-Thinking-2507",
         "Qwen/Qwen3-Coder-480B-A35B-Instruct",
@@ -217,14 +218,13 @@ class DeepInfra(OpenAICompatibleProvider):
         "mistralai/Mistral-Small-3.1-24B-Instruct-2503",
         "microsoft/phi-4-reasoning-plus",
         "Qwen/QwQ-32B",
-        "google/gemini-2.5-flash",
-        "google/gemini-2.5-pro",
         "google/gemma-3-27b-it",
         "google/gemma-3-12b-it",
         "google/gemma-3-4b-it",
         "microsoft/Phi-4-multimodal-instruct",
         "deepseek-ai/DeepSeek-R1-Distill-Llama-70B",
         "deepseek-ai/DeepSeek-V3",
+        "deepseek-ai/DeepSeek-V3.1",
         "meta-llama/Llama-3.3-70B-Instruct-Turbo",
         "meta-llama/Llama-3.3-70B-Instruct",
         "microsoft/phi-4",
@@ -238,7 +238,6 @@ class DeepInfra(OpenAICompatibleProvider):
         "Sao10K/L3-8B-Lunaris-v1-Turbo",
         "Sao10K/L3.1-70B-Euryale-v2.2",
         "Sao10K/L3.3-70B-Euryale-v2.3",
-        "anthropic/claude-3-7-sonnet-latest",
         "deepseek-ai/DeepSeek-R1",
         "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
         "deepseek-ai/DeepSeek-R1-Turbo",
@@ -268,6 +267,7 @@ class DeepInfra(OpenAICompatibleProvider):
         "openai/gpt-oss-20b",
         "allenai/olmOCR-7B-0725-FP8",
     ]
+
     def __init__(self, browser: str = "chrome", api_key: str = None):
         self.timeout = None
         self.base_url = "https://api.deepinfra.com/v1/openai/chat/completions"
@@ -312,4 +312,4 @@ if __name__ == "__main__":
         max_tokens=10000,
         stream=False
     )
-    print(response)
+    print(response.choices[0].message.content)

webscout/Provider/OPENAI/heckai.py

@@ -220,7 +220,10 @@ class HeckAI(OpenAICompatibleProvider):
         "openai/gpt-4o-mini",
         "openai/gpt-4.1-mini",
         "x-ai/grok-3-mini-beta",
-        "meta-llama/llama-4-scout"
+        "meta-llama/llama-4-scout",
+        "openai/gpt-5-mini",
+        "openai/gpt-5-nano"
+
     ]
 
     def __init__(

webscout/Provider/OPENAI/netwrck.py

@@ -204,6 +204,7 @@ class Netwrck(OpenAICompatibleProvider):
 
     AVAILABLE_MODELS = [
         "thedrummer/valkyrie-49b-v1",
+        "thedrummer/skyfall-36b-v2",
         "sao10k/l3-euryale-70b",
         "deepseek/deepseek-chat",
         "deepseek/deepseek-r1",

webscout/Provider/OPENAI/scirachat.py

@@ -336,6 +336,9 @@ class SciraChat(OpenAICompatibleProvider):
         "o3": "scira-o3",
         "qwen/qwen3-32b": "scira-qwen-32b",
         "qwen3-30b-a3b": "scira-qwen-30b",
+        "qwen3-4b": "scira-qwen-4b",
+        "qwen3-32b": "scira-qwen-32b",
+        "qwen3-4b-thinking": "scira-qwen-4b-thinking",
         "deepseek-v3-0324": "scira-deepseek-v3",
         "claude-3-5-haiku-20241022": "scira-haiku",
         "mistral-small-latest": "scira-mistral",
@@ -346,6 +349,7 @@ class SciraChat(OpenAICompatibleProvider):
         "claude-sonnet-4-20250514-thinking": "scira-anthropic-thinking",
         "claude-4-opus-20250514": "scira-opus",
         "claude-4-opus-20250514-pro": "scira-opus-pro",
+        "llama-4-maverick": "scira-llama-4",
         "meta-llama/llama-4-maverick-17b-128e-instruct": "scira-llama-4",
         "kimi-k2-instruct": "scira-kimi-k2",
         "scira-kimi-k2": "kimi-k2-instruct",
@@ -360,6 +364,8 @@ class SciraChat(OpenAICompatibleProvider):
     SCIRA_TO_MODEL["scira-nano"] = "gpt-4.1-nano"
     SCIRA_TO_MODEL["scira-qwen-32b"] = "qwen/qwen3-32b"
     SCIRA_TO_MODEL["scira-qwen-30b"] = "qwen3-30b-a3b"
+    SCIRA_TO_MODEL["scira-qwen-4b"] = "qwen3-4b"
+    SCIRA_TO_MODEL["scira-qwen-4b-thinking"] = "qwen3-4b-thinking"
     SCIRA_TO_MODEL["scira-deepseek-v3"] = "deepseek-v3-0324"
     SCIRA_TO_MODEL["scira-grok-4"] = "grok-4"
     SCIRA_TO_MODEL["scira-kimi-k2"] = "kimi-k2-instruct"

webscout/Provider/OPENAI/textpollinations.py

@@ -277,28 +277,20 @@ class TextPollinations(OpenAICompatibleProvider):
 
     AVAILABLE_MODELS = [
         "deepseek-reasoning",
-        "glm",
-        "gpt-5-nano",
-        "llama-fast-roblox",
-        "llama-roblox",
-        "llamascout",
+        "gemini",
         "mistral",
-        "mistral-nemo-roblox",
-        "mistral-roblox",
         "nova-fast",
         "openai",
         "openai-audio",
         "openai-fast",
-        "openai-large",
-        "openai-roblox",
+        "openai-reasoning",
         "qwen-coder",
+        "roblox-rp",
         "bidara",
         "evil",
-        "hypnosis-tracy",
         "midijourney",
         "mirexa",
         "rtist",
-        "sur",
         "unity",
     ]
 

webscout/Provider/OPENAI/toolbaz.py

@@ -291,27 +291,30 @@ class Toolbaz(OpenAICompatibleProvider):
 
     AVAILABLE_MODELS = [
         "gemini-2.5-flash",
+        "gemini-2.5-pro",
         "gemini-2.0-flash-thinking",
-        "sonar",
         "gemini-2.0-flash",
-        "gemini-1.5-flash",
+
+        "claude-sonnet-4",
+
+        "gpt-5",
+        "gpt-oss-120b",
         "o3-mini",
         "gpt-4o-latest",
-        "gpt-4o",
+
+        "toolbaz_v4",
+        "toolbaz_v3.5_pro",
+
         "deepseek-r1",
+        "deepseek-v3.1",
+        "deepseek-v3",
+
         "Llama-4-Maverick",
-        "Llama-4-Scout",
         "Llama-3.3-70B",
-        "gpt-oss-120b",
-        "Qwen2.5-72B",
-        "grok-2-1212",
-        "grok-3-beta",
-        "toolbaz_v3.5_pro",
-        "toolbaz_v3",
+        
         "mixtral_8x22b",
         "L3-70B-Euryale-v2.1",
         "midnight-rose",
-        "unity",
         "unfiltered_x"
     ]
 

webscout/Provider/OpenGPT.py

@@ -15,7 +15,7 @@ class OpenGPT(Provider):
     """
     A class to interact with the Open-GPT API.
     """
-
+    required_auth = False
     def __init__(
         self,
         is_conversation: bool = True,