webscout 8.2.6__py3-none-any.whl → 8.2.8__py3-none-any.whl

webscout/Provider/OPENAI/chatgpt.py

@@ -547,3 +547,10 @@ class ChatGPT(OpenAICompatibleProvider):
         
         # Initialize chat interface
         self.chat = Chat(self)
+
+    @property
+    def models(self):
+        class _ModelList:
+            def list(inner_self):
+                return type(self).AVAILABLE_MODELS
+        return _ModelList()

webscout/Provider/OPENAI/chatgptclone.py

@@ -479,3 +479,10 @@ class ChatGPTClone(OpenAICompatibleProvider):
         # Default to the most capable model
         print(f"Warning: Unknown model '{model}'. Using 'gpt-4' instead.")
         return "gpt-4"
+
+    @property
+    def models(self):
+        class _ModelList:
+            def list(inner_self):
+                return type(self).AVAILABLE_MODELS
+        return _ModelList()

webscout/Provider/OPENAI/chatsandbox.py

@@ -0,0 +1,172 @@
+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 (
+    ChatCompletion,
+    ChatCompletionChunk,
+    Choice,
+    ChatCompletionMessage,
+    ChoiceDelta,
+    CompletionUsage,
+    format_prompt
+)
+import requests
+
+# ANSI escape codes for formatting
+BOLD = "\033[1m"
+RED = "\033[91m"
+RESET = "\033[0m"
+
+class Completions(BaseCompletions):
+    def __init__(self, client: 'ChatSandbox'):
+        self._client = client
+
+    def create(
+        self,
+        *,
+        model: str,
+        messages: List[Dict[str, str]],
+        max_tokens: Optional[int] = None,
+        stream: bool = False,
+        temperature: Optional[float] = None,
+        top_p: Optional[float] = None,
+        **kwargs: Any
+    ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
+        """
+        OpenAI-compatible chat/completions endpoint for ChatSandbox.
+        """
+        # 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)
+        payload = {
+            "messages": [question],
+            "character": model
+        }
+        request_id = f"chatcmpl-{int(time.time() * 1000)}"
+        created_time = int(time.time())
+        url = "https://chatsandbox.com/api/chat"
+        agent = LitAgent()
+        headers = {
+            'authority': 'chatsandbox.com',
+            'accept': '*/*',
+            'accept-encoding': 'gzip, deflate, br',
+            'accept-language': 'en-US,en;q=0.9',
+            'content-type': 'application/json',
+            'origin': 'https://chatsandbox.com',
+            'referer': f'https://chatsandbox.com/chat/{model}',
+            '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',
+            'user-agent': agent.random(),
+            'dnt': '1',
+            'sec-gpc': '1',
+        }
+        session = requests.Session()
+        session.headers.update(headers)
+        def for_stream():
+            try:
+                response = session.post(
+                    url,
+                    json=payload,
+                    stream=True,
+                    timeout=30
+                )
+                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,
+                    )
+                    yield chunk_obj
+                # Final chunk
+                delta = ChoiceDelta(content=None)
+                choice = Choice(index=0, delta=delta, finish_reason="stop")
+                chunk_obj = ChatCompletionChunk(
+                    id=request_id,
+                    choices=[choice],
+                    created=created_time,
+                    model=model,
+                )
+                yield chunk_obj
+            except Exception as e:
+                raise RuntimeError(f"ChatSandbox streaming request failed: {e}")
+        def for_non_stream():
+            try:
+                response = session.post(
+                    url,
+                    json=payload,
+                    timeout=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 = len(question) // 4
+                completion_tokens = len(content) // 4
+                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}")
+        return for_stream() if stream else for_non_stream()
+
+class Chat(BaseChat):
+    def __init__(self, client: 'ChatSandbox'):
+        self.completions = Completions(client)
+
+class ChatSandbox(OpenAICompatibleProvider):
+    AVAILABLE_MODELS = ["openai", "deepseek", "llama", "gemini", "mistral-large"]
+    chat: Chat
+    def __init__(self):
+        self.chat = Chat(self)
+    @property
+    def models(self):
+        class _ModelList:
+            def list(inner_self):
+                return type(self).AVAILABLE_MODELS
+        return _ModelList()
+    def convert_model_name(self, model: str) -> str:
+        if model in self.AVAILABLE_MODELS:
+            return model
+        for available_model in self.AVAILABLE_MODELS:
+            if model.lower() in available_model.lower():
+                return available_model
+        # Default to openai if no match
+        print(f"{RED}{BOLD}Warning: Model '{model}' not found, using default model 'openai'{RESET}")
+        return "openai"

webscout/Provider/OPENAI/deepinfra.py

@@ -221,6 +221,7 @@ class Chat(BaseChat):
         self.completions = Completions(client)
 
 class DeepInfra(OpenAICompatibleProvider):
+    
     AVAILABLE_MODELS = [
         # "anthropic/claude-3-7-sonnet-latest",  # >>>> NOT WORKING
 
@@ -229,12 +230,32 @@ class DeepInfra(OpenAICompatibleProvider):
         "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
         "deepseek-ai/DeepSeek-R1-Turbo",
         "deepseek-ai/DeepSeek-V3",
-
+        "deepseek-ai/DeepSeek-Prover-V2-671B",
         "google/gemma-2-27b-it",
         "google/gemma-2-9b-it",
-        "google/gemma-3-27b-it",
         "google/gemma-3-12b-it",
+        "google/gemma-3-27b-it",
         "google/gemma-3-4b-it",
+        "meta-llama/Llama-3.3-70B-Instruct",
+        "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+        "meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8",
+        "meta-llama/Llama-4-Scout-17B-16E-Instruct",
+        "meta-llama/Llama-Guard-4-12B",
+        "meta-llama/Meta-Llama-3.1-8B-Instruct",
+        "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
+        "microsoft/Phi-4-multimodal-instruct",
+        "microsoft/WizardLM-2-8x22B",
+        "microsoft/phi-4",
+        "microsoft/phi-4-reasoning-plus",
+        "mistralai/Mistral-Small-24B-Instruct-2501",
+        "nvidia/Llama-3.1-Nemotron-70B-Instruct",
+        "Qwen/QwQ-32B",
+        "Qwen/Qwen2.5-72B-Instruct",
+        "Qwen/Qwen2.5-Coder-32B-Instruct",
+        "Qwen/Qwen3-14B",
+        "Qwen/Qwen3-30B-A3B",
+        "Qwen/Qwen3-32B",
+        "Qwen/Qwen3-235B-A22B",
         # "google/gemini-1.5-flash",  # >>>> NOT WORKING
         # "google/gemini-1.5-flash-8b",  # >>>> NOT WORKING
         # "google/gemini-2.0-flash-001",  # >>>> NOT WORKING
@@ -243,37 +264,19 @@ class DeepInfra(OpenAICompatibleProvider):
 
         # "meta-llama/Llama-3.2-1B-Instruct",  # >>>> NOT WORKING
         # "meta-llama/Llama-3.2-3B-Instruct",  # >>>> NOT WORKING
-        "meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8",
-        "meta-llama/Llama-4-Scout-17B-16E-Instruct",
         # "meta-llama/Llama-3.2-90B-Vision-Instruct",  # >>>> NOT WORKING
         # "meta-llama/Llama-3.2-11B-Vision-Instruct",  # >>>> NOT WORKING
-        "meta-llama/Llama-3.3-70B-Instruct",
-        "meta-llama/Llama-3.3-70B-Instruct-Turbo",
         # "meta-llama/Meta-Llama-3-70B-Instruct",  # >>>> NOT WORKING
         # "meta-llama/Meta-Llama-3-8B-Instruct",  # >>>> NOT WORKING
         # "meta-llama/Meta-Llama-3.1-70B-Instruct",  # >>>> NOT WORKING
         # "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo",  # >>>> NOT WORKING
-        "meta-llama/Meta-Llama-3.1-8B-Instruct",
-        "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
         # "meta-llama/Meta-Llama-3.1-405B-Instruct",  # >>>> NOT WORKING
-
-        "microsoft/phi-4",
-        "microsoft/Phi-4-multimodal-instruct",
-        "microsoft/WizardLM-2-8x22B",
         # "mistralai/Mixtral-8x7B-Instruct-v0.1",  # >>>> NOT WORKING
         # "mistralai/Mistral-7B-Instruct-v0.3",  # >>>> NOT WORKING
         # "mistralai/Mistral-Nemo-Instruct-2407",  # >>>> NOT WORKING
-        "mistralai/Mistral-Small-24B-Instruct-2501",
-        "nvidia/Llama-3.1-Nemotron-70B-Instruct",
         # "NousResearch/Hermes-3-Llama-3.1-405B",  # >>>> NOT WORKING
         # "NovaSky-AI/Sky-T1-32B-Preview",  # >>>> NOT WORKING
-        "Qwen/QwQ-32B",
         # "Qwen/Qwen2.5-7B-Instruct",  # >>>> NOT WORKING
-        "Qwen/Qwen2.5-72B-Instruct",
-        "Qwen/Qwen2.5-Coder-32B-Instruct",
-        "Qwen/Qwen3-14B",
-        "Qwen/Qwen3-30B-A3B",
-        "Qwen/Qwen3-32B",
         # "Sao10K/L3.1-70B-Euryale-v2.2",  # >>>> NOT WORKING
         # "Sao10K/L3.3-70B-Euryale-v2.3",  # >>>> NOT WORKING
     ]
@@ -307,3 +310,10 @@ class DeepInfra(OpenAICompatibleProvider):
         }
         self.session.headers.update(self.headers)
         self.chat = Chat(self)
+
+    @property
+    def models(self):
+        class _ModelList:
+            def list(inner_self):
+                return type(self).AVAILABLE_MODELS
+        return _ModelList()

webscout/Provider/OPENAI/e2b.py

@@ -1158,6 +1158,12 @@ class E2B(OpenAICompatibleProvider):
         # Initialize the chat interface
         self.chat = Chat(self)
 
+    @property
+    def models(self):
+        class _ModelList:
+            def list(inner_self):
+                return type(self).AVAILABLE_MODELS
+        return _ModelList()
     def convert_model_name(self, model: str) -> str:
         """Normalize and validate model name."""
         normalized_model = self.MODEL_NAME_NORMALIZATION.get(model, model)

webscout/Provider/OPENAI/exaai.py

@@ -402,3 +402,10 @@ class ExaAI(OpenAICompatibleProvider):
         # ExaAI only supports O3-Mini, regardless of the input model
         print(f"Note: ExaAI only supports O3-Mini model. Ignoring provided model '{model}'.")
         return "O3-Mini"
+    
+    @property
+    def models(self):
+        class _ModelList:
+            def list(inner_self):
+                return type(self).AVAILABLE_MODELS
+        return _ModelList()

webscout/Provider/OPENAI/exachat.py

@@ -365,6 +365,12 @@ class ExaChat(OpenAICompatibleProvider):
         # Initialize the chat interface
         self.chat = Chat(self)
 
+    @property
+    def models(self):
+        class _ModelList:
+            def list(inner_self):
+                return type(self).AVAILABLE_MODELS
+        return _ModelList()
     def _get_endpoint(self, provider: str) -> str:
         """Get the API endpoint for the specified provider."""
         return MODEL_CONFIGS[provider]["endpoint"]

webscout/Provider/OPENAI/flowith.py

@@ -0,0 +1,162 @@
+from typing import List, Dict, Optional, Union, Generator, Any
+import time
+import json
+
+# Import base classes and utility structures
+from .base import OpenAICompatibleProvider, BaseChat, BaseCompletions
+from .utils import (
+    ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
+    ChatCompletionMessage, CompletionUsage
+)
+
+# Import requests for HTTP requests (instead of curl_cffi)
+import requests
+import zstandard as zstd
+import uuid
+
+# Attempt to import LitAgent, fallback if not available
+try:
+    from webscout.litagent import LitAgent
+except ImportError:
+    class LitAgent:
+        def generate_fingerprint(self, browser):
+            return {"user_agent": "Mozilla/5.0"}
+
+# --- Flowith OpenAI-Compatible Client ---
+
+class Completions(BaseCompletions):
+    def __init__(self, client: 'Flowith'):
+        self.client = client
+
+    def create(
+        self,
+        *,
+        model: str,
+        messages: List[Dict[str, str]],
+        max_tokens: Optional[int] = 2048,
+        stream: bool = False,
+        temperature: Optional[float] = None,
+        top_p: Optional[float] = None,
+        **kwargs: Any
+    ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
+        """
+        Implements OpenAI-compatible chat/completions endpoint for Flowith.
+        """
+        url = "https://edge.flowith.net/ai/chat?mode=general"
+        agent = LitAgent()
+        fingerprint = agent.generate_fingerprint("chrome")
+        headers = {
+            "accept": "*/*",
+            "accept-encoding": "gzip, deflate, br, zstd",
+            "accept-language": "en-US,en;q=0.9,en-IN;q=0.8",
+            "content-type": "application/json",
+            "origin": "https://flowith.io",
+            "referer": "https://edge.flowith.net/",
+            "user-agent": fingerprint["user_agent"],
+            "dnt": "1",
+            "sec-gpc": "1"
+        }
+        session = requests.Session()
+        session.headers.update(headers)
+        node_id = str(uuid.uuid4())
+        request_id = f"chatcmpl-{uuid.uuid4()}"
+        created_time = int(time.time())
+        payload = {
+            "model": model,
+            "messages": messages,
+            "stream": stream,
+            "nodeId": node_id
+        }
+        payload.update(kwargs)
+
+        def for_stream():
+            try:
+                print(f"[DEBUG] Sending streaming request to {url} with payload: {payload}")
+                response = session.post(
+                    url,
+                    json=payload,
+                    stream=True,
+                    timeout=30
+                )
+                print(f"[DEBUG] Response status: {response.status_code}")
+                response.raise_for_status()
+                for chunk in response.iter_content(chunk_size=4096):
+                    if not chunk:
+                        break
+                    text = chunk.decode('utf-8', errors='replace')
+                    print(f"[DEBUG] Stream chunk: {repr(text)}")
+                    delta = ChoiceDelta(content=text, role="assistant")
+                    choice = Choice(index=0, delta=delta)
+                    chunk_obj = ChatCompletionChunk(
+                        id=request_id,
+                        choices=[choice],
+                        created=created_time,
+                        model=model,
+                        system_fingerprint=None
+                    )
+                    yield chunk_obj
+            except Exception as e:
+                print(f"[DEBUG] Streaming error: {e}")
+                raise RuntimeError(f"Flowith streaming request failed: {e}")
+
+        def for_non_stream():
+            try:
+                print(f"[DEBUG] Sending non-stream request to {url} with payload: {payload}")
+                response = session.post(
+                    url,
+                    json=payload,
+                    timeout=30
+                )
+                print(f"[DEBUG] Response status: {response.status_code}")
+                response.raise_for_status()
+                encoding = response.headers.get('Content-Encoding', '').lower()
+                print(f"[DEBUG] Response encoding: {encoding}")
+                if encoding == 'zstd':
+                    dctx = zstd.ZstdDecompressor()
+                    with dctx.stream_reader(response.raw) as reader:
+                        decompressed = reader.read()
+                        text = decompressed.decode('utf-8', errors='replace')
+                else:
+                    text = response.text
+                print(f"[DEBUG] Raw response text: {repr(text)}")
+                # Flowith returns raw text, not JSON
+                content = text.strip()
+                print(f"[DEBUG] Final content for ChatCompletion: {repr(content)}")
+                message = ChatCompletionMessage(role="assistant", content=content)
+                choice = Choice(index=0, message=message, finish_reason="stop")
+                usage = CompletionUsage(prompt_tokens=0, completion_tokens=0, total_tokens=0)
+                completion = ChatCompletion(
+                    id=request_id,
+                    choices=[choice],
+                    created=created_time,
+                    model=model,
+                    usage=usage
+                )
+                print(f"[DEBUG] Returning ChatCompletion: {completion}")
+                return completion
+            except Exception as e:
+                print(f"[DEBUG] Non-streaming error: {e}")
+                raise RuntimeError(f"Flowith request failed: {e}")
+
+        return for_stream() if stream else for_non_stream()
+
+class Chat(BaseChat):
+    def __init__(self, client: 'Flowith'):
+        self.completions = Completions(client)
+
+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"
+    ]
+
+    chat: Chat
+    def __init__(self):
+        self.chat = Chat(self)
+
+    @property
+    def models(self):
+        class _ModelList:
+            def list(inner_self):
+                return type(self).AVAILABLE_MODELS
+        return _ModelList()