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

webscout/Provider/OPENAI/kimi.py

@@ -0,0 +1,469 @@
+import requests
+import json
+import time
+import uuid
+import random
+from typing import List, Dict, Optional, Union, Generator, Any
+
+# Import curl_cffi for improved request handling
+from curl_cffi.requests import Session
+from curl_cffi import CurlError
+
+# Import base classes and utility structures
+from .base import OpenAICompatibleProvider, BaseChat, BaseCompletions
+from .utils import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    Choice,
+    ChatCompletionMessage,
+    ChoiceDelta,
+    CompletionUsage,
+    format_prompt,
+    get_system_prompt,
+    count_tokens
+)
+
+# Attempt to import LitAgent, fallback if not available
+try:
+    from webscout.litagent import LitAgent
+except ImportError:
+    pass
+
+from webscout import exceptions
+
+
+class Completions(BaseCompletions):
+    def __init__(self, client: 'Kimi'):
+        self._client = client
+
+    def create(
+        self,
+        *,
+        model: str,
+        messages: List[Dict[str, str]],
+        max_tokens: Optional[int] = 4000,
+        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]]:
+        """
+        Create a completion using the Kimi API.
+        
+        Args:
+            model: The model to use (k1.5, k2, k1.5-thinking)
+            messages: List of message dictionaries with 'role' and 'content'
+            max_tokens: Maximum tokens for response
+            stream: Whether to stream the response
+            temperature: Sampling temperature (not used by Kimi)
+            top_p: Top-p sampling (not used by Kimi)
+            timeout: Request timeout
+            proxies: Proxy configuration
+            
+        Returns:
+            ChatCompletion or generator of ChatCompletionChunk
+        """
+        # Validate model
+        if model not in self._client.AVAILABLE_MODELS:
+            raise ValueError(f"Invalid model: {model}. Choose from: {self._client.AVAILABLE_MODELS}")
+
+        # Ensure authentication and chat creation
+        self._client._authenticate()
+        self._client._create_chat()
+
+        # Format messages exactly like the original Kimi.py
+        # Use the first user message content directly, no formatting needed
+        user_content = ""
+        system_content = ""
+        
+        for msg in messages:
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+            if role == "system":
+                system_content = content
+            elif role == "user":
+                user_content = content
+        
+        # If we have system content, prepend it to user content
+        if system_content:
+            final_content = f"{system_content}\n\n{user_content}"
+        else:
+            final_content = user_content
+
+        # Create payload exactly like the original Kimi.py
+        payload = {
+            "kimiplus_id": "kimi",
+            "extend": {"sidebar": True},
+            "model": model,
+            "use_search": self._client.web_search,
+            "messages": [
+                {
+                    "role": "user",
+                    "content": final_content
+                }
+            ],
+            "refs": [],
+            "history": [],
+            "scene_labels": [],
+            "use_semantic_memory": False,
+            "use_deep_research": False
+        }
+
+        # Generate request ID and timestamp
+        request_id = f"chatcmpl-{uuid.uuid4().hex}"
+        created_time = int(time.time())
+
+        if stream:
+            return self._create_stream(request_id, created_time, model, messages, payload, timeout, proxies)
+        else:
+            return self._create_non_stream(request_id, created_time, model, messages, payload, timeout, proxies)
+
+    def _create_stream(
+        self, request_id: str, created_time: int, model: str, messages: List[Dict[str, str]], 
+        payload: Dict[str, Any], timeout: Optional[int] = None, proxies: Optional[Dict[str, str]] = None
+    ) -> Generator[ChatCompletionChunk, None, None]:
+        try:
+            response = self._client.session.post(
+                self._client.chat_completion_endpoint.format(chat_id=self._client.chat_id),
+                json=payload,
+                stream=True,
+                timeout=timeout or self._client.timeout,
+                impersonate="chrome110"
+            )
+            response.raise_for_status()
+
+            # Calculate prompt tokens using the messages parameter
+            prompt_tokens = count_tokens(messages)
+            completion_tokens = 0
+            total_tokens = prompt_tokens
+
+            for line in response.iter_lines(decode_unicode=True):
+                if line:
+                    if line.startswith("data: "):
+                        json_str = line[6:]
+                        if json_str == "[DONE]":
+                            break
+
+                        try:
+                            data = json.loads(json_str)
+                            if data.get("event") == "cmpl":
+                                content = data.get("text")
+                                if content:
+                                    completion_tokens += count_tokens(content)
+                                    total_tokens = prompt_tokens + completion_tokens
+
+                                    delta = ChoiceDelta(content=content, role=None, tool_calls=None)
+                                    choice = Choice(index=0, delta=delta, finish_reason=None, logprobs=None)
+                                    chunk = ChatCompletionChunk(
+                                        id=request_id,
+                                        choices=[choice],
+                                        created=created_time,
+                                        model=model,
+                                        system_fingerprint=None
+                                    )
+
+                                    # Add usage information
+                                    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, tool_calls=None)
+            choice = Choice(index=0, delta=delta, finish_reason="stop", logprobs=None)
+            chunk = ChatCompletionChunk(
+                id=request_id,
+                choices=[choice],
+                created=created_time,
+                model=model,
+                system_fingerprint=None
+            )
+            chunk.usage = {
+                "prompt_tokens": prompt_tokens,
+                "completion_tokens": completion_tokens,
+                "total_tokens": total_tokens,
+                "estimated_cost": None
+            }
+            yield chunk
+
+        except CurlError as e:
+            print(f"Error during Kimi stream request: {e}")
+            raise IOError(f"Kimi request failed: {e}") from e
+        except Exception as e:
+            print(f"Error processing Kimi stream: {e}")
+            raise
+
+    def _create_non_stream(
+        self, request_id: str, created_time: int, model: str, messages: List[Dict[str, str]],
+        payload: Dict[str, Any], timeout: Optional[int] = None, proxies: Optional[Dict[str, str]] = None
+    ) -> ChatCompletion:
+        try:
+            response = self._client.session.post(
+                self._client.chat_completion_endpoint.format(chat_id=self._client.chat_id),
+                json=payload,
+                timeout=timeout or self._client.timeout,
+                impersonate="chrome110",
+                stream=True
+            )
+            response.raise_for_status()
+
+            # Collect all streaming data
+            full_text = ""
+            for line in response.iter_lines():
+                if line:
+                    # Decode bytes to string if needed
+                    if isinstance(line, bytes):
+                        line = line.decode('utf-8')
+                    if line.startswith("data: "):
+                        json_str = line[6:]
+                        if json_str == "[DONE]":
+                            break
+
+                        try:
+                            data = json.loads(json_str)
+                            if data.get("event") == "cmpl":
+                                content = data.get("text")
+                                if content:
+                                    full_text += content
+                        except json.JSONDecodeError:
+                            continue
+
+            # 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 usage object with proper token counting
+            prompt_tokens = count_tokens(messages)
+            completion_tokens = count_tokens(full_text) if full_text else 0
+            usage = CompletionUsage(
+                prompt_tokens=prompt_tokens,
+                completion_tokens=completion_tokens,
+                total_tokens=prompt_tokens + completion_tokens
+            )
+
+            # Create the completion object
+            completion = ChatCompletion(
+                id=request_id,
+                choices=[choice],
+                created=created_time,
+                model=model,
+                usage=usage,
+            )
+            return completion
+
+        except CurlError as e:
+            print(f"Error during Kimi request: {e}")
+            raise IOError(f"Kimi request failed: {e}") from e
+        except Exception as e:
+            print(f"Error processing Kimi response: {e}")
+            raise
+
+
+class Chat(BaseChat):
+    def __init__(self, client: 'Kimi'):
+        self._client = client
+        self.completions = Completions(client)
+
+
+class Kimi(OpenAICompatibleProvider):
+    """
+    OpenAI-compatible Kimi provider.
+    
+    This provider implements the OpenAI API interface for Kimi models.
+    It supports the following models:
+    - k1.5
+    - k2
+    - k1.5-thinking
+    
+    Examples:
+        >>> from webscout.Provider.OPENAI.kimi import Kimi
+        >>> client = Kimi()
+        >>> response = client.chat.completions.create(
+        ...     model="k2",
+        ...     messages=[{"role": "user", "content": "Hello!"}]
+        ... )
+        >>> print(response.choices[0].message.content)
+    """
+    
+    AVAILABLE_MODELS = ["k1.5", "k2", "k1.5-thinking"]
+    
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        timeout: int = 30,
+        proxies: Optional[Dict[str, str]] = None,
+        browser: str = "chrome",
+        web_search: bool = False,
+        **kwargs
+    ):
+        """
+        Initialize the Kimi provider.
+        
+        Args:
+            api_key: Not used for Kimi (authentication is handled via device registration)
+            base_url: Not used for Kimi
+            timeout: Request timeout in seconds
+            proxies: Proxy configuration
+            browser: Browser to impersonate
+            web_search: Whether to enable web search
+            **kwargs: Additional arguments
+        """
+        super().__init__(api_key=api_key, base_url=base_url, timeout=timeout, **kwargs)
+        
+        self.timeout = timeout
+        self.proxies = proxies or {}
+        self.web_search = web_search
+        
+        # Kimi API endpoints
+        self.register_endpoint = "https://www.kimi.com/api/device/register"
+        self.chat_create_endpoint = "https://www.kimi.com/api/chat"
+        self.chat_completion_endpoint = "https://www.kimi.com/api/chat/{chat_id}/completion/stream"
+        
+        # Initialize session
+        self.session = Session()
+        self.session.proxies = self.proxies
+        
+        # Initialize LitAgent for browser fingerprinting
+        try:
+            self.agent = LitAgent()
+            self.fingerprint = self.agent.generate_fingerprint(browser)
+        except:
+            self.fingerprint = {
+                "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+                "accept_language": "en-US,en;q=0.9",
+                "sec_ch_ua": '"Not_A Brand";v="8", "Chromium";v="120", "Google Chrome";v="120"',
+                "platform": "Windows"
+            }
+        
+        # Generate device ID
+        self.device_id = str(random.randint(1000000000000000, 9999999999999999))
+        
+        # Headers for Kimi API
+        self.headers = {
+            "Accept": "text/event-stream",
+            "Accept-Language": self.fingerprint["accept_language"],
+            "Accept-Encoding": "gzip, deflate, br",
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "Content-Type": "application/json",
+            "DNT": "1",
+            "Origin": "https://www.kimi.com",
+            "Pragma": "no-cache",
+            "Referer": "https://www.kimi.com/",
+            "Sec-CH-UA": self.fingerprint["sec_ch_ua"],
+            "Sec-CH-UA-Mobile": "?0",
+            "Sec-CH-UA-Platform": f'"{self.fingerprint["platform"]}"',
+            "User-Agent": self.fingerprint["user_agent"],
+            "x-msh-device-id": self.device_id,
+            "x-msh-platform": "web",
+            "x-traffic-id": self.device_id,
+        }
+        
+        # Initialize authentication
+        self.access_token = None
+        self.chat_id = None
+        
+        # Update session headers
+        self.session.headers.update(self.headers)
+        
+        # Initialize chat and completions
+        self.chat = Chat(self)
+        self.completions = Completions(self)
+    
+    @property
+    def models(self):
+        """Property that returns an object with a .list() method returning available models."""
+        class _ModelList:
+            def list(inner_self):
+                return type(self).AVAILABLE_MODELS
+        return _ModelList()
+    
+    def _authenticate(self) -> str:
+        """Authenticate with Kimi API and get access token."""
+        if self.access_token:
+            return self.access_token
+        
+        max_retries = 3
+        last_exception = None
+        
+        for attempt in range(max_retries):
+            try:
+                response = self.session.post(
+                    self.register_endpoint,
+                    json={},
+                    timeout=self.timeout,
+                    impersonate="chrome110"
+                )
+                response.raise_for_status()
+                
+                data = response.json()
+                if not data.get("access_token"):
+                    raise exceptions.FailedToGenerateResponseError("No access token received")
+                    
+                self.access_token = data["access_token"]
+                self.session.headers["Authorization"] = f"Bearer {self.access_token}"
+                return self.access_token
+                
+            except CurlError as e:
+                last_exception = e
+                if attempt < max_retries - 1:
+                    continue
+                raise exceptions.FailedToGenerateResponseError(f"Authentication failed after {max_retries} attempts (CurlError): {e}")
+            except Exception as e:
+                last_exception = e
+                if attempt < max_retries - 1:
+                    continue
+                raise exceptions.FailedToGenerateResponseError(f"Authentication failed after {max_retries} attempts: {e}")
+    
+    def _create_chat(self) -> str:
+        """Create a new chat session and return chat ID."""
+        if self.chat_id:
+            return self.chat_id
+            
+        self._authenticate()
+        
+        try:
+            response = self.session.post(
+                self.chat_create_endpoint,
+                json={
+                    "name": "Unnamed Chat",
+                    "born_from": "home",
+                    "kimiplus_id": "kimi",
+                    "is_example": False,
+                    "source": "web",
+                    "tags": []
+                },
+                timeout=self.timeout,
+                impersonate="chrome110"
+            )
+            response.raise_for_status()
+            
+            data = response.json()
+            self.chat_id = data.get("id")
+            if not self.chat_id:
+                raise exceptions.FailedToGenerateResponseError("No chat ID received")
+                
+            return self.chat_id
+            
+        except CurlError as e:
+            raise exceptions.FailedToGenerateResponseError(f"Chat creation failed (CurlError): {e}")
+        except Exception as e:
+            raise exceptions.FailedToGenerateResponseError(f"Chat creation failed: {e}")

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,
@@ -208,10 +207,7 @@ class Netwrck(OpenAICompatibleProvider):
         "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 +304,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 +323,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: