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

webscout/Provider/OPENAI/__init__.py

@@ -1,12 +1,11 @@
 # This file marks the directory as a Python package.
 from .deepinfra import *
-from .glider import *
+## glider import removed
 from .chatgptclone import *
 from .x0gpt import *
 from .wisecat import *
 from .venice import *
 from .exaai import *
-from .typegpt import *
 from .scirachat import *
 from .llmchatco import *
 from .yep import * # Add YEPCHAT
@@ -17,7 +16,6 @@ from .netwrck import *
 from .standardinput import *
 from .writecream import *
 from .toolbaz import *
-from .uncovrAI import *
 from .opkfc import *
 from .chatgpt import *
 from .textpollinations import *
@@ -28,7 +26,6 @@ from .ai4chat import * # Add AI4Chat
 from .mcpcore import *
 from .flowith import *
 from .chatsandbox import *
-from .c4ai import *
 from .flowith import *
 from .Cloudflare import *
 from .NEMOTRON import *
@@ -46,6 +43,9 @@ from .friendli import *
 from .monochat import *
 from .MiniMax import *  # Add MiniMaxAI provider
 from .qodo import *  # Add QodoAI provider
+from .kimi import *  # Add Kimi provider
+from .gptoss import *  # Add GPT-OSS provider
+from .refact import *  # Add Refact provider
 # Export auto-proxy functionality
 from .autoproxy import (
     get_auto_proxy,

webscout/Provider/OPENAI/copilot.py

@@ -87,12 +87,22 @@ class Completions(BaseCompletions):
                 images.append({"type": "image", "url": r.json().get("url")})
 
             ws = s.ws_connect(self._client.websocket_url)
-            mode = "reasoning" if "Think" in model else "chat"
+            # Map alias to real model name if needed
+            real_model = Copilot.MODEL_ALIASES.get(model, model)
+            if real_model not in Copilot.AVAILABLE_MODELS:
+                raise RuntimeError(f"Invalid model: {model}. Choose from: {Copilot.AVAILABLE_MODELS}")
+            if real_model == "Smart":
+                mode = "smart"
+            elif "Think" in real_model:
+                mode = "reasoning"
+            else:
+                mode = "chat"
             ws.send(json.dumps({
                 "event": "send",
                 "conversationId": conv_id,
                 "content": images + [{"type": "text", "text": prompt_text}],
-                "mode": mode
+                "mode": mode,
+                "model": real_model
             }).encode(), CurlWsFlag.TEXT)
 
             prompt_tokens = count_tokens(prompt_text)
@@ -281,8 +291,14 @@ class Copilot(OpenAICompatibleProvider):
     url = "https://copilot.microsoft.com"
     conversation_url = f"{url}/c/api/conversations"
     websocket_url = "wss://copilot.microsoft.com/c/api/chat?api-version=2"
-    
-    AVAILABLE_MODELS = ["Copilot", "Think Deeper"]
+
+    AVAILABLE_MODELS = ["Copilot", "Think Deeper", "Smart"]
+    MODEL_ALIASES = {
+        "gpt-4o": "Copilot",
+        "o4-mini": "Think Deeper",
+        "gpt-5": "Smart",
+
+    }
 
     def __init__(self, browser: str = "chrome", tools: Optional[List] = None, **kwargs):
         self.timeout = 900

webscout/Provider/OPENAI/deepinfra.py

@@ -196,8 +196,13 @@ class Chat(BaseChat):
 class DeepInfra(OpenAICompatibleProvider):
     AVAILABLE_MODELS = [
         "anthropic/claude-4-opus",
+        "moonshotai/Kimi-K2-Instruct",
         "anthropic/claude-4-sonnet",
         "deepseek-ai/DeepSeek-R1-0528-Turbo",
+        "Qwen/Qwen3-235B-A22B-Thinking-2507",
+        "Qwen/Qwen3-Coder-480B-A35B-Instruct",
+        "Qwen/Qwen3-Coder-480B-A35B-Instruct-Turbo",
+        "Qwen/Qwen3-235B-A22B-Instruct-2507",
         "Qwen/Qwen3-235B-A22B",
         "Qwen/Qwen3-30B-A3B",
         "Qwen/Qwen3-32B",
@@ -249,12 +254,19 @@ class DeepInfra(OpenAICompatibleProvider):
         "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
         "microsoft/WizardLM-2-8x22B",
         "mistralai/Devstral-Small-2505",
+        "mistralai/Devstral-Small-2507",
         "mistralai/Mistral-7B-Instruct-v0.3",
         "mistralai/Mistral-Nemo-Instruct-2407",
         "mistralai/Mistral-Small-24B-Instruct-2501",
         "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

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/gptoss.py

@@ -0,0 +1,288 @@
+import requests
+import json
+import time
+import uuid
+from typing import List, Dict, Optional, Union, Generator, Any
+
+from webscout.Provider.OPENAI.base import OpenAICompatibleProvider, BaseChat, BaseCompletions
+from webscout.Provider.OPENAI.utils import (
+    ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
+    ChatCompletionMessage, CompletionUsage, format_prompt, count_tokens
+)
+
+try:
+    from webscout.litagent import LitAgent
+except ImportError:
+    pass
+
+class Completions(BaseCompletions):
+    def __init__(self, client: 'GptOss'):
+        self._client = client
+
+    def create(
+        self,
+        *,
+        model: str,
+        messages: List[Dict[str, str]],
+        max_tokens: Optional[int] = 600,
+        stream: bool = False,
+        temperature: Optional[float] = None,
+        top_p: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
+        **kwargs: Any
+    ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
+        # Format messages into conversation prompt
+        conversation_prompt = format_prompt(messages, add_special_tokens=False, do_continue=True)
+        
+        # Count tokens for usage tracking
+        prompt_tokens = count_tokens(conversation_prompt)
+        
+        payload = {
+            "op": "threads.create",
+            "params": {
+                "input": {
+                    "text": conversation_prompt,
+                    "content": [{"type": "input_text", "text": conversation_prompt}],
+                    "quoted_text": "",
+                    "attachments": []
+                }
+            }
+        }
+        
+        request_id = f"chatcmpl-{uuid.uuid4()}"
+        created_time = int(time.time())
+        
+        if stream:
+            return self._create_stream(request_id, created_time, model, payload, timeout, proxies, prompt_tokens)
+        else:
+            return self._create_non_stream(request_id, created_time, model, payload, timeout, proxies, prompt_tokens)
+
+    def _create_stream(
+        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any],
+        timeout: Optional[int] = None, proxies: Optional[Dict[str, str]] = None,
+        prompt_tokens: int = 0
+    ) -> Generator[ChatCompletionChunk, None, None]:
+        try:
+            response = self._client.session.post(
+                self._client.base_url,
+                headers=self._client.headers,
+                json=payload,
+                stream=True,
+                timeout=timeout or self._client.timeout,
+                proxies=proxies
+            )
+            response.raise_for_status()
+            
+            completion_tokens = 0
+            total_tokens = prompt_tokens
+            
+            for line in response.iter_lines(decode_unicode=True):
+                if line and line.startswith("data: "):
+                    json_str = line[6:]
+                    if json_str == "[DONE]":
+                        break
+                    try:
+                        data = json.loads(json_str)
+                        
+                        # Extract content from GptOss response format
+                        content = None
+                        if (data.get('type') == 'thread.item_updated' and 
+                            data.get('update', {}).get('type') == 'assistant_message.content_part.text_delta'):
+                            content = data.get('update', {}).get('delta')
+                        
+                        if content:
+                            # Count tokens in the content chunk
+                            chunk_tokens = count_tokens(content)
+                            completion_tokens += chunk_tokens
+                            total_tokens = prompt_tokens + completion_tokens
+                            
+                            delta = ChoiceDelta(
+                                content=content,
+                                role="assistant"
+                            )
+                            choice = Choice(
+                                index=0,
+                                delta=delta,
+                                finish_reason=None
+                            )
+                            chunk = ChatCompletionChunk(
+                                id=request_id,
+                                choices=[choice],
+                                created=created_time,
+                                model=model
+                            )
+                            chunk.usage = {
+                                "prompt_tokens": prompt_tokens,
+                                "completion_tokens": completion_tokens,
+                                "total_tokens": total_tokens,
+                                "estimated_cost": None
+                            }
+                            yield chunk
+                    except json.JSONDecodeError:
+                        continue
+            
+            # Final chunk with finish_reason="stop"
+            delta = ChoiceDelta(content=None, role=None)
+            choice = Choice(index=0, delta=delta, finish_reason="stop")
+            chunk = ChatCompletionChunk(
+                id=request_id,
+                choices=[choice],
+                created=created_time,
+                model=model
+            )
+            chunk.usage = {
+                "prompt_tokens": prompt_tokens,
+                "completion_tokens": completion_tokens,
+                "total_tokens": total_tokens,
+                "estimated_cost": None
+            }
+            yield chunk
+            
+        except Exception as e:
+            print(f"Error during GptOss stream request: {e}")
+            raise IOError(f"GptOss request failed: {e}") from e
+
+    def _create_non_stream(
+        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any],
+        timeout: Optional[int] = None, proxies: Optional[Dict[str, str]] = None,
+        prompt_tokens: int = 0
+    ) -> ChatCompletion:
+        try:
+            response = self._client.session.post(
+                self._client.base_url,
+                headers=self._client.headers,
+                json=payload,
+                stream=True,  # GptOss API is event-stream only
+                timeout=timeout or self._client.timeout,
+                proxies=proxies
+            )
+            response.raise_for_status()
+            
+            # Collect all chunks to form complete response
+            full_content = ""
+            completion_tokens = 0
+            
+            for line in response.iter_lines(decode_unicode=True):
+                if line and line.startswith("data: "):
+                    json_str = line[6:]
+                    if json_str == "[DONE]":
+                        break
+                    try:
+                        data = json.loads(json_str)
+                        
+                        # Extract content from GptOss response format
+                        if (data.get('type') == 'thread.item_updated' and 
+                            data.get('update', {}).get('type') == 'assistant_message.content_part.text_delta'):
+                            content = data.get('update', {}).get('delta')
+                            if content:
+                                full_content += content
+                    except json.JSONDecodeError:
+                        continue
+            
+            # Count tokens in the complete response
+            completion_tokens = count_tokens(full_content)
+            total_tokens = prompt_tokens + completion_tokens
+            
+            message = ChatCompletionMessage(
+                role="assistant",
+                content=full_content
+            )
+            choice = Choice(
+                index=0,
+                message=message,
+                finish_reason="stop"
+            )
+            usage = CompletionUsage(
+                prompt_tokens=prompt_tokens,
+                completion_tokens=completion_tokens,
+                total_tokens=total_tokens
+            )
+            completion = ChatCompletion(
+                id=request_id,
+                choices=[choice],
+                created=created_time,
+                model=model,
+                usage=usage
+            )
+            return completion
+            
+        except Exception as e:
+            print(f"Error during GptOss non-stream request: {e}")
+            raise IOError(f"GptOss request failed: {e}") from e
+
+class Chat(BaseChat):
+    def __init__(self, client: 'GptOss'):
+        self.completions = Completions(client)
+
+class GptOss(OpenAICompatibleProvider):
+    AVAILABLE_MODELS = ["gpt-oss-20b", "gpt-oss-120b"]
+    
+    def __init__(
+        self, 
+        browser: str = "chrome", 
+        api_key: str = None,
+        model: str = "gpt-oss-120b",
+        reasoning_effort: str = "high",
+        timeout: int = 30,
+        **kwargs
+    ):
+        super().__init__(api_key=api_key, **kwargs)
+        self.timeout = timeout
+        self.base_url = "https://api.gpt-oss.com/chatkit"
+        self.model = model if model in self.AVAILABLE_MODELS else self.AVAILABLE_MODELS[0]
+        self.reasoning_effort = reasoning_effort
+        self.session = requests.Session()
+        
+        # Generate headers using LitAgent
+        try:
+            agent = LitAgent()
+            fingerprint = agent.generate_fingerprint(browser)
+            self.headers = {
+                "Accept": "text/event-stream",
+                "Accept-Encoding": fingerprint.get("accept_encoding", "gzip, deflate, br"),
+                "Accept-Language": fingerprint.get("accept_language", "en-US,en;q=0.9"),
+                "Content-Type": "application/json",
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "Pragma": "no-cache",
+                "User-Agent": fingerprint.get("user_agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"),
+                "x-reasoning-effort": self.reasoning_effort,
+                "x-selected-model": self.model,
+                "x-show-reasoning": "true"
+            }
+        except:
+            # Fallback headers if LitAgent fails
+            self.headers = {
+                "Accept": "text/event-stream",
+                "Accept-Encoding": "gzip, deflate, br",
+                "Accept-Language": "en-US,en;q=0.9",
+                "Content-Type": "application/json",
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "Pragma": "no-cache",
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+                "x-reasoning-effort": self.reasoning_effort,
+                "x-selected-model": self.model,
+                "x-show-reasoning": "true"
+            }
+        
+        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()
+
+if __name__ == "__main__":
+    client = GptOss()
+    response = client.chat.completions.create(
+        model="gpt-oss-120b",
+        messages=[{"role": "user", "content": "Hello, how are you?"}],
+        max_tokens=100,
+        stream=False
+    )
+    print(response)