webscout 8.3.5__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",
@@ -261,7 +260,14 @@ class DeepInfra(OpenAICompatibleProvider):
         "mistralai/Mistral-Small-3.2-24B-Instruct-2506",
         "mistralai/Mixtral-8x7B-Instruct-v0.1",
         "nvidia/Llama-3.1-Nemotron-70B-Instruct",
+        "zai-org/GLM-4.5-Air",
+        "zai-org/GLM-4.5",
+        "zai-org/GLM-4.5V",
+        "openai/gpt-oss-120b",
+        "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"
@@ -306,4 +312,4 @@ if __name__ == "__main__":
         max_tokens=10000,
         stream=False
     )
-    print(response)
+    print(response.choices[0].message.content)

webscout/Provider/OPENAI/e2b.py

@@ -114,6 +114,35 @@ MODEL_PROMPT = {
             }
         }
     },
+    "claude-opus-4-1-20250805": {
+        "apiUrl": "https://fragments.e2b.dev/api/chat",
+        "id": "claude-opus-4-1-20250805",
+        "name": "Claude Opus 4.1",
+        "Knowledge": "2024-10",
+        "provider": "Anthropic",
+        "providerId": "anthropic",
+        "multiModal": True,
+        "templates": {
+            "system": {
+                "intro": "You are Claude Opus 4.1, Anthropic's most capable AI assistant for complex reasoning and analysis. You excel at sophisticated problem-solving, creative thinking, and providing nuanced insights across a wide range of domains. You can analyze images, code, and complex data to deliver comprehensive and thoughtful responses.",
+                "principles": ["honesty", "ethics", "diligence", "helpfulness", "accuracy", "thoughtfulness", "creativity"],
+                "latex": {
+                    "inline": "\\(\\nabla \\cdot \\vec{E} = \\frac{\\rho}{\\epsilon_0}\\)",
+                    "block": "\\begin{align}\n\\nabla \\cdot \\vec{E} &= \\frac{\\rho}{\\epsilon_0} \\\\\n\\nabla \\times \\vec{B} &= \\mu_0\\vec{J} + \\mu_0\\epsilon_0\\frac{\\partial\\vec{E}}{\\partial t} \\\\\nE &= mc^2 \\\\\n\\psi(x,t) &= Ae^{i(kx-\\omega t)}\n\\end{align}"
+                }
+            }
+        },
+        "requestConfig": {
+            "template": {
+                "txt": {
+                    "name": "chat with users and start role-playing, Above of all: Follow the latest news from users",
+                    "lib": [""],
+                    "file": "pages/ChatWithUsers.txt",
+                    "port": 3000
+                }
+            }
+        }
+    },
     "o1-mini": {
         "apiUrl": "https://fragments.e2b.dev/api/chat",
         "id": "o1-mini",
@@ -1013,6 +1042,10 @@ class Completions(BaseCompletions):
         """Enhanced request method with IP rotation, session rotation, and advanced rate limit bypass."""
         url = model_config["apiUrl"]
         target_origin = "https://fragments.e2b.dev"
+        
+        # Use client proxies if none provided
+        if proxies is None:
+            proxies = getattr(self._client, "proxies", None)
 
         for attempt in range(retries):
             try:
@@ -1055,13 +1088,13 @@ class Completions(BaseCompletions):
 
                 json_data = json.dumps(enhanced_request_body)
                 
-                # Use curl_cffi session with enhanced fingerprinting
+                # Use curl_cffi session with enhanced fingerprinting and proxy support
                 response = self._client.session.post(
                     url=url,
                     headers=headers,
                     data=json_data,
                     timeout=timeout or self._client.timeout,
-                    proxies=proxies or getattr(self._client, "proxies", None),
+                    proxies=proxies,
                     impersonate=self._client.impersonation
                 )
 
@@ -1225,17 +1258,21 @@ class E2B(OpenAICompatibleProvider):
         'deepseek-r1-instruct': 'deepseek-r1'
     }
 
-    def __init__(self, retries: int = 3):
+    def __init__(self, retries: int = 3, proxies: Optional[Dict[str, str]] = None, **kwargs):
         """
         Initialize the E2B client with curl_cffi and browser fingerprinting.
 
         Args:
             retries: Number of retries for failed requests.
+            proxies: Proxy configuration for requests.
+            **kwargs: Additional arguments passed to parent class.
         """
         self.timeout = 60  # Default timeout in seconds
-        self.proxies = None  # Default proxies
         self.retries = retries
-
+        
+        # Handle proxy configuration
+        self.proxies = proxies or {}
+        
         # Use LitAgent for user-agent
         self.headers = LitAgent().generate_fingerprint()
 
@@ -1243,6 +1280,20 @@ class E2B(OpenAICompatibleProvider):
         self.impersonation = curl_requests.impersonate.DEFAULT_CHROME
         self.session = curl_requests.Session()
         self.session.headers.update(self.headers)
+        
+        # Apply proxy configuration if provided
+        if self.proxies:
+            self.session.proxies.update(self.proxies)
+
+        # Initialize bypass session data
+        self._session_rotation_data = {}
+        self._last_rotation_time = 0
+        self._rotation_interval = 300  # Rotate session every 5 minutes
+        self._rate_limit_failures = 0
+        self._max_rate_limit_failures = 3
+
+        # Initialize the chat interface
+        self.chat = Chat(self)
 
         # Initialize bypass session data
         self._session_rotation_data = {}
@@ -1589,13 +1640,13 @@ if __name__ == "__main__":
     print("-" * 80)
     print(f"{'Model':<50} {'Status':<10} {'Response'}")
     print("-" * 80)
-    print("\n--- Streaming Simulation Test (gpt-4.1-mini) ---")
+    print("\n--- Streaming Simulation Test (claude-opus-4-1-20250805) ---")
     try:
         client_stream = E2B()
         stream = client_stream.chat.completions.create(
-            model="gpt-4.1-mini",
+            model="claude-opus-4-1-20250805",
             messages=[
-                {"role": "user", "content": "Write a poem about AI."}
+                {"role": "user", "content": "hi."}
             ],
             stream=True
         )
@@ -1607,6 +1658,7 @@ if __name__ == "__main__":
                 print(content, end="", flush=True)
                 full_stream_response += content
         print("\n--- End of Stream ---")
+        print(client_stream.proxies)
         if not full_stream_response:
              print(f"{RED}Stream test failed: No content received.{RESET}")
     except Exception as e:

webscout/Provider/OPENAI/flowith.py

@@ -150,8 +150,9 @@ class Chat(BaseChat):
 
 class Flowith(OpenAICompatibleProvider):
     AVAILABLE_MODELS = [
-        "gpt-4.1-mini", "deepseek-chat", "deepseek-reasoner", "claude-3.5-haiku",
-        "gemini-2.0-flash", "gemini-2.5-flash", "grok-3-mini"
+        "gpt-5-nano", "gpt-5-mini", "glm-4.5", "gpt-oss-120b", "gpt-oss-20b", "kimi-k2",
+        "gpt-4.1", "gpt-4.1-mini", "deepseek-chat", "deepseek-reasoner",
+        "gemini-2.5-flash", "grok-3-mini"
     ]
 
     chat: Chat
@@ -170,7 +171,7 @@ if __name__ == "__main__":
     client = Flowith()
     messages = [{"role": "user", "content": "Hello, how are you?"}]
     response = client.chat.completions.create(
-        model="gpt-4.1-mini",
+        model="gpt-5-nano",
         messages=messages,
         stream=True
     )

webscout/Provider/OPENAI/generate_api_key.py

@@ -0,0 +1,48 @@
+import random
+import string
+
+def generate_api_key_suffix(length: int = 4) -> str:
+    """Generate a random API key suffix like 'C1Z5'
+    
+    Args:
+        length: Length of the suffix (default: 4)
+    
+    Returns:
+        A random string with uppercase letters and digits
+    """
+    # Use uppercase letters and digits for the suffix
+    chars = string.ascii_uppercase + string.digits
+    return ''.join(random.choice(chars) for _ in range(length))
+
+def generate_full_api_key(prefix: str = "EU1CW20nX5oau42xBSgm") -> str:
+    """Generate a full API key with the given prefix pattern
+    
+    Args:
+        prefix: The base prefix to use (default uses the pattern from the example)
+    
+    Returns:
+        A full API key string with a random suffix like 'C1Z5'
+    """
+    # Generate the suffix (last 4 characters like C1Z5)
+    suffix = generate_api_key_suffix(4)
+    
+    # Combine prefix with the generated suffix
+    return prefix + suffix
+
+if __name__ == "__main__":
+    # Example usage
+    print("Generate API key suffix (like C1Z5):")
+    for i in range(5):
+        suffix = generate_api_key_suffix()
+        print(f"  {suffix}")
+    
+    print("\nGenerate full API key with prefix:")
+    for i in range(5):
+        api_key = generate_full_api_key()
+        print(f"  {api_key}")
+    
+    print("\nGenerate with custom prefix:")
+    custom_prefix = "EU1CW20nX5oau42xBSgm"
+    for i in range(3):
+        api_key = generate_full_api_key(custom_prefix)
+        print(f"  {api_key}")

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

@@ -4,10 +4,9 @@ import requests
 import json
 from typing import List, Dict, Optional, Union, Generator, Any
 
-from webscout.Provider.yep import T
 from webscout.litagent import LitAgent
-from .base import BaseChat, BaseCompletions, OpenAICompatibleProvider
-from .utils import (
+from webscout.Provider.OPENAI.base import BaseChat, BaseCompletions, OpenAICompatibleProvider
+from webscout.Provider.OPENAI.utils import (
     ChatCompletion,
     ChatCompletionChunk,
     Choice,
@@ -205,13 +204,11 @@ class Netwrck(OpenAICompatibleProvider):
 
     AVAILABLE_MODELS = [
         "thedrummer/valkyrie-49b-v1",
+        "thedrummer/skyfall-36b-v2",
         "sao10k/l3-euryale-70b",
         "deepseek/deepseek-chat",
         "deepseek/deepseek-r1",
-        "anthropic/claude-sonnet-4-20250514",
-        "openai/gpt-4.1-mini",
         "gryphe/mythomax-l2-13b",
-        "google/gemini-2.5-flash-preview-04-17",
         "nvidia/llama-3.1-nemotron-70b-instruct",
     ]
 
@@ -308,9 +305,9 @@ class Netwrck(OpenAICompatibleProvider):
             if model.lower() in available_model.lower():
                 return available_model
         
-        # Default to Claude if no match
-        print(f"{BOLD}Warning: Model '{model}' not found, using default model 'anthropic/claude-3-7-sonnet-20250219'{RESET}")
-        return "anthropic/claude-3-7-sonnet-20250219"
+        # Default to DeepSeek if no match
+        print(f"{BOLD}Warning: Model '{model}' not found, using default model 'deepseek/deepseek-r1'{RESET}")
+        return "deepseek/deepseek-r1"
 
     @property
     def models(self):
@@ -327,9 +324,9 @@ if __name__ == "__main__":
 
     # Test a subset of models to avoid excessive API calls
     test_models = [
-        "anthropic/claude-3-7-sonnet-20250219",
-        "openai/gpt-4o-mini",
-        "deepseek/deepseek-chat"
+        "deepseek/deepseek-r1",
+        "deepseek/deepseek-chat",
+        "gryphe/mythomax-l2-13b"
     ]
 
     for model in test_models: