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

webscout/Provider/OPENAI/{monochat.py → K2Think.py}

@@ -1,22 +1,27 @@
 import time
 import uuid
 import requests
-import json
 import re
+import json
 from typing import List, Dict, Optional, Union, Generator, Any
 
+# Import base classes and utility structures
 from webscout.Provider.OPENAI.base import OpenAICompatibleProvider, BaseChat, BaseCompletions
 from webscout.Provider.OPENAI.utils import (
     ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
     ChatCompletionMessage, CompletionUsage, count_tokens
 )
 
+# Import LitAgent
 from webscout.litagent import LitAgent
 
-# --- MonoChat Client ---
+# Import logger
+from webscout.Litlogger import Logger, LogLevel
+
+logger = Logger(name="K2Think", level=LogLevel.INFO)
 
 class Completions(BaseCompletions):
-    def __init__(self, client: 'MonoChat'):
+    def __init__(self, client: 'K2Think'):
         self._client = client
 
     def create(
@@ -29,77 +34,111 @@ class Completions(BaseCompletions):
         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]]:
         """
         Creates a model response for the given chat conversation.
         Mimics openai.chat.completions.create
         """
-        # Prepare the payload for MonoChat API
+        # Prepare the payload for K2Think API
         payload = {
+            "stream": stream,
+            "model": model,
             "messages": messages,
-            "model": model
+            "params": {}
         }
+
+        # Add optional parameters if provided
         if max_tokens is not None and max_tokens > 0:
-            payload["max_tokens"] = max_tokens
+            payload["params"]["max_tokens"] = max_tokens
+
         if temperature is not None:
-            payload["temperature"] = temperature
+            payload["params"]["temperature"] = temperature
+
         if top_p is not None:
-            payload["top_p"] = top_p
+            payload["params"]["top_p"] = top_p
+
+        # Add any additional parameters
         payload.update(kwargs)
 
         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)
+            return self._create_stream(request_id, created_time, model, payload, timeout)
         else:
-            return self._create_non_stream(request_id, created_time, model, payload, timeout, proxies)
+            return self._create_non_stream(request_id, created_time, model, payload, timeout)
 
     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
+        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any], timeout: Optional[int] = None
     ) -> Generator[ChatCompletionChunk, None, None]:
         try:
             response = self._client.session.post(
-                self._client.api_endpoint,
+                self._client.base_url,
                 headers=self._client.headers,
                 json=payload,
                 stream=True,
-                timeout=timeout or self._client.timeout,
-                proxies=proxies or getattr(self._client, "proxies", None)
+                timeout=timeout or self._client.timeout
             )
+
+            # Handle non-200 responses
             if not response.ok:
                 raise IOError(
                     f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
                 )
 
+            # Use count_tokens for prompt tokens
             prompt_tokens = count_tokens([msg.get("content", "") for msg in payload.get("messages", [])])
             completion_tokens = 0
             total_tokens = 0
+            seen_content = set()  # Track seen content to avoid duplicates
 
             for line in response.iter_lines():
                 if line:
                     decoded_line = line.decode('utf-8').strip()
-                    # MonoChat returns lines like: 0:"Hello" or 0:"!" etc.
-                    match = re.search(r'0:"(.*?)"', decoded_line)
-                    if match:
-                        content = match.group(1)
+
+                    # Extract content using regex patterns (similar to x0gpt)
+                    extract_regexes = [
+                        r'<answer>([\s\S]*?)<\/answer>',
+                    ]
+                    
+                    content = ""
+                    for regex in extract_regexes:
+                        match = re.search(regex, decoded_line)
+                        if match:
+                            content = match.group(1)
+                            break
+                    
+                    if content:
+                        # Format the content
                         content = self._client.format_text(content)
+                        
+                        # Skip if we've already seen this exact content
+                        if content in seen_content:
+                            continue
+                        
+                        seen_content.add(content)
+
+                        # Update token counts using count_tokens
                         completion_tokens += count_tokens(content)
                         total_tokens = prompt_tokens + completion_tokens
 
+                        # Create the delta object
                         delta = ChoiceDelta(
                             content=content,
                             role="assistant",
                             tool_calls=None
                         )
+
+                        # Create the choice object
                         choice = Choice(
                             index=0,
                             delta=delta,
                             finish_reason=None,
                             logprobs=None
                         )
+
+                        # Create the chunk object
                         chunk = ChatCompletionChunk(
                             id=request_id,
                             choices=[choice],
@@ -107,12 +146,16 @@ class Completions(BaseCompletions):
                             model=model,
                             system_fingerprint=None
                         )
+
+                        # Set usage directly on the chunk object
                         chunk.usage = {
                             "prompt_tokens": prompt_tokens,
                             "completion_tokens": completion_tokens,
                             "total_tokens": total_tokens,
                             "estimated_cost": None
                         }
+
+                        # Return the chunk object with usage information
                         yield chunk
 
             # Final chunk with finish_reason="stop"
@@ -121,12 +164,14 @@ class Completions(BaseCompletions):
                 role=None,
                 tool_calls=None
             )
+
             choice = Choice(
                 index=0,
                 delta=delta,
                 finish_reason="stop",
                 logprobs=None
             )
+
             chunk = ChatCompletionChunk(
                 id=request_id,
                 choices=[choice],
@@ -134,63 +179,89 @@ class Completions(BaseCompletions):
                 model=model,
                 system_fingerprint=None
             )
+
+            # Set usage directly on the chunk object
             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 MonoChat stream request: {e}")
-            raise IOError(f"MonoChat request failed: {e}") from e
+            print(f"Error during K2Think stream request: {e}")
+            raise IOError(f"K2Think 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
+        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any], timeout: Optional[int] = None
     ) -> ChatCompletion:
         try:
             response = self._client.session.post(
-                self._client.api_endpoint,
+                self._client.base_url,
                 headers=self._client.headers,
                 json=payload,
                 stream=True,
-                timeout=timeout or self._client.timeout,
-                proxies=proxies or getattr(self._client, "proxies", None)
+                timeout=timeout or self._client.timeout
             )
+
+            # Handle non-200 responses
             if not response.ok:
                 raise IOError(
                     f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
                 )
 
+            # Collect the full response
             full_text = ""
+            seen_content_parts = set()  # Track seen content parts to avoid duplicates
+            
             for line in response.iter_lines(decode_unicode=True):
                 if line:
-                    match = re.search(r'0:"(.*?)"', line)
-                    if match:
-                        content = match.group(1)
-                        full_text += content
-
+                    # Extract content using regex patterns
+                    extract_regexes = [
+                        r'<answer>([\s\S]*?)<\/answer>',
+                    ]
+                    
+                    for regex in extract_regexes:
+                        match = re.search(regex, line)
+                        if match:
+                            content = match.group(1)
+                            # Only add if we haven't seen this exact content before
+                            if content not in seen_content_parts:
+                                seen_content_parts.add(content)
+                                full_text += content
+                            break
+
+            # Format the text
             full_text = self._client.format_text(full_text)
 
+            # Use count_tokens for accurate token counts
             prompt_tokens = count_tokens([msg.get("content", "") for msg in payload.get("messages", [])])
             completion_tokens = count_tokens(full_text)
             total_tokens = prompt_tokens + completion_tokens
 
+            # Create the message object
             message = ChatCompletionMessage(
                 role="assistant",
                 content=full_text
             )
+
+            # Create the choice object
             choice = Choice(
                 index=0,
                 message=message,
                 finish_reason="stop"
             )
+
+            # Create the usage object
             usage = CompletionUsage(
                 prompt_tokens=prompt_tokens,
                 completion_tokens=completion_tokens,
                 total_tokens=total_tokens
             )
+
+            # Create the completion object
             completion = ChatCompletion(
                 id=request_id,
                 choices=[choice],
@@ -198,83 +269,97 @@ class Completions(BaseCompletions):
                 model=model,
                 usage=usage,
             )
+
             return completion
 
         except Exception as e:
-            print(f"Error during MonoChat non-stream request: {e}")
-            raise IOError(f"MonoChat request failed: {e}") from e
+            print(f"Error during K2Think non-stream request: {e}")
+            raise IOError(f"K2Think request failed: {e}") from e
 
 class Chat(BaseChat):
-    def __init__(self, client: 'MonoChat'):
+    def __init__(self, client: 'K2Think'):
         self.completions = Completions(client)
 
-class MonoChat(OpenAICompatibleProvider):
+class Models:
+    """Models class to mimic OpenAI models.list()"""
+    def __init__(self):
+        self.available_models = [
+            "MBZUAI-IFM/K2-Think",
+        ]
+    
+    def list(self):
+        """Return list of available models"""
+        return [
+            {
+                "id": model,
+                "object": "model",
+                "created": 0,
+                "owned_by": "k2think"
+            }
+            for model in self.available_models
+        ]
+
+class K2Think(OpenAICompatibleProvider):
     """
-    OpenAI-compatible client for MonoChat API.
+    OpenAI-compatible client for K2Think API.
 
     Usage:
-        client = MonoChat()
+        client = K2Think()
         response = client.chat.completions.create(
-            model="gpt-4.1",
+            model="MBZUAI-IFM/K2-Think",
             messages=[{"role": "user", "content": "Hello!"}]
         )
     """
 
-    AVAILABLE_MODELS = [
-        "deepseek-r1",
-        "deepseek-v3",
-        "uncensored-r1-32b",
-        "o3-pro",
-        "o4-mini",
-        "o3",
-        "gpt-4.5-preview",
-        "gpt-4.1",
-        "gpt-4.1-mini",
-        "gpt-4.1-nano",
-        "gpt-4o",
-        "gpt-4o-mini",
-        "gpt-4o-search-preview",
-        "gpt-4o-mini-search-preview",
-        "gpt-4-turbo"
-
-
-    ]
+    AVAILABLE_MODELS = ["MBZUAI-IFM/K2-Think"]
 
     def __init__(
         self,
-        browser: str = "chrome"
+        browser: str = "chrome",
+        proxies: Optional[dict] = None
     ):
         """
-        Initialize the MonoChat client.
+        Initialize the K2Think client.
 
         Args:
             browser: Browser to emulate in user agent
+            proxies: Optional proxy configuration dictionary
         """
-        self.timeout = None
-        self.api_endpoint = "https://gg.is-a-furry.dev/api/chat"
-        self.session = requests.Session()
+        super().__init__(proxies=proxies)
+        self.timeout = 30
+        self.base_url = "https://www.k2think.ai/api/guest/chat/completions"
 
+        # Initialize LitAgent for user agent generation
         agent = LitAgent()
         self.fingerprint = agent.generate_fingerprint(browser)
 
         self.headers = {
-            "accept": "*/*",
-            "accept-encoding": "gzip, deflate, br, zstd",
-            "accept-language": self.fingerprint["accept_language"],
-            "content-type": "application/json",
-            "origin": "https://gg.is-a-furry.dev",
-            "referer": "https://gg.is-a-furry.dev/",
-            "user-agent": self.fingerprint["user_agent"]
+            "Accept": "*/*",
+            "Accept-Encoding": "gzip, deflate, br, zstd",
+            "Accept-Language": self.fingerprint["accept_language"],
+            "Content-Type": "application/json",
+            "User-Agent": self.fingerprint["user_agent"],
+            "Origin": "https://www.k2think.ai",
+            "Referer": "https://www.k2think.ai/guest",
+            "Sec-Fetch-Dest": "empty",
+            "Sec-Fetch-Mode": "cors",
+            "Sec-Fetch-Site": "same-origin",
+            "Sec-Ch-Ua": '"Chromium";v="140", "Not=A?Brand";v="24", "Microsoft Edge";v="140"',
+            "Sec-Ch-Ua-Mobile": "?0",
+            "Sec-Ch-Ua-Platform": f'"{self.fingerprint["platform"]}"',
+            "Priority": "u=1, i"
         }
 
         self.session.headers.update(self.headers)
+
+        # Initialize the chat interface
         self.chat = Chat(self)
 
     @property
     def models(self):
         class _ModelList:
             def list(inner_self):
-                return MonoChat.AVAILABLE_MODELS
+                return K2Think.AVAILABLE_MODELS
         return _ModelList()
 
     def format_text(self, text: str) -> str:
@@ -287,43 +372,61 @@ class MonoChat(OpenAICompatibleProvider):
         Returns:
             Formatted text
         """
+        # Use a more comprehensive approach to handle all escape sequences
         try:
+            # First handle double backslashes to avoid issues
             text = text.replace('\\\\', '\\')
+
+            # Handle common escape sequences
             text = text.replace('\\n', '\n')
             text = text.replace('\\r', '\r')
             text = text.replace('\\t', '\t')
             text = text.replace('\\"', '"')
             text = text.replace("\\'", "'")
+
+            # Handle any remaining escape sequences using JSON decoding
+            # This is a fallback in case there are other escape sequences
             try:
+                # Add quotes to make it a valid JSON string
                 json_str = f'"{text}"'
+                # Use json module to decode all escape sequences
                 decoded = json.loads(json_str)
                 return decoded
             except json.JSONDecodeError:
+                # If JSON decoding fails, return the text with the replacements we've already done
                 return text
         except Exception as e:
+            # If any error occurs, return the original text
             print(f"Warning: Error formatting text: {e}")
             return text
 
     def convert_model_name(self, model: str) -> str:
         """
-        Convert model names to ones supported by MonoChat.
+        Convert model names to ones supported by K2Think.
 
         Args:
             model: Model name to convert
 
         Returns:
-            MonoChat model name
+            K2Think model name
         """
+        # K2Think doesn't actually use model names, but we'll keep this for compatibility
         return model
 
+# Convenience function for backward compatibility
+def K2ThinkClient(**kwargs):
+    """Create a new K2Think client instance"""
+    return K2Think(**kwargs)
+
 if __name__ == "__main__":
-    client = MonoChat()
+    from rich import print
+    client = K2Think()
     response = client.chat.completions.create(
-        model="gpt-4.1",
-        messages=[{"role": "user", "content": "tell me about humans"}],
-        max_tokens=1000,
+        model="MBZUAI-IFM/K2-Think",
+        messages=[{"role": "user", "content": "Hello!"}],
         stream=True
     )
+
     for chunk in response:
-        if chunk.choices and hasattr(chunk.choices[0], "delta") and getattr(chunk.choices[0].delta, "content", None):
-            print(chunk.choices[0].delta.content, end="", flush=True)
+        if chunk.choices[0].delta.content:
+            print(chunk.choices[0].delta.content, end='', flush=True)

webscout/Provider/OPENAI/NEMOTRON.py

@@ -120,12 +120,9 @@ class NEMOTRON(OpenAICompatibleProvider):
     ]
     
     API_BASE_URL = "https://nemotron.one/api/chat"
-    def __init__(
-        self
-    ):
-        self.session = requests.Session()
+    def __init__(self, proxies: Optional[dict] = None):
+        super().__init__(proxies=proxies)
         self.timeout = 30
-        self.session.proxies = {}
         agent = LitAgent()
         user_agent = agent.random()
         self.base_headers = {
@@ -241,4 +238,4 @@ class NEMOTRON(OpenAICompatibleProvider):
         class _ModelList:
             def list(inner_self):
                 return type(self).AVAILABLE_MODELS
-        return _ModelList()
+        return _ModelList()

webscout/Provider/OPENAI/PI.py

@@ -289,12 +289,10 @@ class PiAI(OpenAICompatibleProvider):
             proxies: Proxy configuration
             **kwargs: Additional arguments
         """
+        super().__init__(proxies=proxies)
         self.timeout = timeout
         self.conversation_id = None
         
-        # Initialize curl_cffi Session
-        self.session = Session()
-        
         # Setup URLs
         self.primary_url = 'https://pi.ai/api/chat'
         self.fallback_url = 'https://pi.ai/api/v2/chat'
@@ -320,6 +318,9 @@ class PiAI(OpenAICompatibleProvider):
             '__cf_bm': uuid4().hex
         }
         
+        # Replace the base session with curl_cffi Session
+        self.session = Session()
+        
         # Configure session
         self.session.headers.update(self.headers)
         if proxies:
@@ -424,4 +425,4 @@ if __name__ == "__main__":
     )
     
     print(response.choices[0].message.content)
-    print(f"Usage: {response.usage}")
+    print(f"Usage: {response.usage}")

webscout/Provider/OPENAI/Qwen3.py

@@ -251,10 +251,9 @@ class Qwen3(OpenAICompatibleProvider):
         "qwen-3-0.6b": "qwen3-0.6b"
     }
 
-    def __init__(self):
+    def __init__(self, proxies: Optional[Dict[str, str]] = None):
+        super().__init__(proxies=proxies)
         self.timeout = 30
-        self.session = requests.Session()
-        self.session.proxies = {}
         self.headers = {
             'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:136.0) Gecko/20100101 Firefox/136.0',
             'Accept': '*/*',

webscout/Provider/OPENAI/TogetherAI.py

@@ -267,11 +267,11 @@ class TogetherAI(OpenAICompatibleProvider):
         "zai-org/GLM-4.5-Air-FP8"
     ]
 
-    def __init__(self, browser: str = "chrome"):
+    def __init__(self, browser: str = "chrome", proxies: Optional[Dict[str, str]] = None):
+        super().__init__(proxies=proxies)
         self.timeout = 60
         self.api_endpoint = "https://api.together.xyz/v1/chat/completions"
         self.activation_endpoint = "https://www.codegeneration.ai/activate-v2"
-        self.session = requests.Session()
         self.headers = LitAgent().generate_fingerprint(browser=browser)
         self.session.headers.update(self.headers)
         self.chat = Chat(self)

webscout/Provider/OPENAI/TwoAI.py

@@ -394,13 +394,12 @@ class TwoAI(OpenAICompatibleProvider):
             raise RuntimeError("Failed to get API key from confirmation email")
         return api_key
 
-    def __init__(self, browser: str = "chrome"):
+    def __init__(self, browser: str = "chrome", proxies: Optional[Dict[str, str]] = None):
+        super().__init__(proxies=proxies)
         api_key = self.get_cached_api_key()
         self.timeout = 30
         self.base_url = "https://api.two.ai/v2/chat/completions"
         self.api_key = api_key
-        self.session = Session()
-        self.session.proxies = {}
 
         headers: Dict[str, str] = {
             "Content-Type": "application/json",
@@ -464,4 +463,4 @@ if __name__ == "__main__":
         stream=True
     )
     for chunk in resp:
-        print(chunk, end="")
+        print(chunk, end="")

webscout/Provider/OPENAI/__init__.py

@@ -1,59 +1,18 @@
 # This file marks the directory as a Python package.
-from .deepinfra import *
-## glider import removed
-from .chatgptclone import *
-from .x0gpt import *
-from .wisecat import *
-from .venice import *
-from .exaai import *
-from .scirachat import *
-from .llmchatco import *
-from .yep import * # Add YEPCHAT
-from .heckai import *
-from .sonus import *
-from .exachat import *
-from .netwrck import *
-from .standardinput import *
-from .writecream import *
-from .toolbaz import *
-from .opkfc import *
-from .chatgpt import *
-from .textpollinations import *
-from .typefully import * # Add TypefullyAI
-from .e2b import *
-from .multichat import * # Add MultiChatAI
-from .ai4chat import * # Add AI4Chat
-from .mcpcore import *
-from .flowith import *
-from .chatsandbox import *
-from .flowith import *
-from .Cloudflare import *
-from .NEMOTRON import *
-from .BLACKBOXAI import *
-from .copilot import * # Add Microsoft Copilot
-from .TwoAI import *
-from .oivscode import * # Add OnRender provider
-from .Qwen3 import *
-from .FalconH1 import *
-from .PI import *  # Add PI.ai provider
-from .TogetherAI import *  # Add TogetherAI provider
-from .xenai import *  # Add XenAI provider
-from .GeminiProxy import *  # Add GeminiProxy provider
-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,
-    get_proxy_dict,
-    get_working_proxy,
-    test_proxy,
-    get_proxy_stats,
-    refresh_proxy_cache,
-    set_proxy_cache_duration,
-    ProxyAutoMeta
-)
+
+import os
+import importlib
+from pathlib import Path
+
+# Get current directory
+current_dir = Path(__file__).parent
+
+# Auto-import all .py files (except __init__.py)
+for file_path in current_dir.glob("*.py"):
+    if file_path.name != "__init__.py":
+        module_name = file_path.stem
+        try:
+            module = importlib.import_module(f".{module_name}", package=__name__)
+            globals().update(vars(module))
+        except ImportError:
+            pass  # Skip files that can't be imported