webscout 8.3.1__py3-none-any.whl → 8.3.3__py3-none-any.whl

webscout/Provider/OPENAI/GeminiProxy.py

@@ -0,0 +1,328 @@
+import json
+import time
+import uuid
+import base64
+from typing import List, Dict, Optional, Union, Generator, Any
+
+import requests
+from uuid import uuid4
+
+# Import base classes and utility structures
+from .base import OpenAICompatibleProvider, BaseChat, BaseCompletions
+from .utils import (
+    ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
+    ChatCompletionMessage, CompletionUsage, count_tokens
+)
+
+from webscout.litagent import LitAgent
+from webscout import exceptions
+
+
+class Completions(BaseCompletions):
+    def __init__(self, client: 'GeminiProxy'):
+        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,
+        timeout: Optional[int] = None,
+        proxies: Optional[dict] = None,
+        **kwargs: Any
+    ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
+        """
+        Create a chat completion with GeminiProxy API.
+        
+        Args:
+            model: The model to use (from AVAILABLE_MODELS)
+            messages: List of message dictionaries with 'role' and 'content'
+            max_tokens: Maximum number of tokens to generate
+            stream: Whether to stream the response (not supported by GeminiProxy)
+            temperature: Sampling temperature (0-1)
+            top_p: Nucleus sampling parameter (0-1)
+            timeout: Request timeout in seconds
+            proxies: Proxy configuration
+            **kwargs: Additional parameters to pass to the API
+            
+        Returns:
+            If stream=False, returns a ChatCompletion object
+            If stream=True, returns a Generator yielding ChatCompletionChunk objects
+        """
+        # Generate request ID and timestamp
+        request_id = str(uuid.uuid4())
+        created_time = int(time.time())
+        
+        # Extract image URL from kwargs if present
+        img_url = kwargs.get('img_url')
+        
+        # Convert messages to GeminiProxy format
+        conversation_prompt = self._format_messages(messages)
+        
+        # Prepare parts for the request
+        parts = []
+        if img_url:
+            parts.append({"inline_data": self._get_image(img_url, proxies, timeout)})
+        parts.append({"text": conversation_prompt})
+        
+        # Prepare the payload
+        payload = {
+            "model": model,
+            "contents": [{"parts": parts}]
+        }
+        
+        # GeminiProxy doesn't support streaming, so we always return non-streaming
+        if stream:
+            return self._create_streaming_fallback(
+                request_id=request_id,
+                created_time=created_time,
+                model=model,
+                payload=payload,
+                timeout=timeout,
+                proxies=proxies
+            )
+        
+        # Non-streaming implementation
+        return self._create_non_streaming(
+            request_id=request_id,
+            created_time=created_time,
+            model=model,
+            payload=payload,
+            timeout=timeout,
+            proxies=proxies
+        )
+    
+    def _format_messages(self, messages: List[Dict[str, str]]) -> str:
+        """Convert OpenAI messages format to a single conversation prompt."""
+        formatted_parts = []
+        
+        for message in messages:
+            role = message.get("role", "")
+            content = message.get("content", "")
+            
+            if role == "system":
+                formatted_parts.append(f"System: {content}")
+            elif role == "user":
+                formatted_parts.append(f"User: {content}")
+            elif role == "assistant":
+                formatted_parts.append(f"Assistant: {content}")
+        
+        return "\n".join(formatted_parts)
+    
+    def _get_image(self, img_url: str, proxies: Optional[dict] = None, timeout: Optional[int] = None) -> Dict[str, str]:
+        """Fetch and encode image from URL."""
+        try:
+            session = requests.Session()
+            if proxies:
+                session.proxies.update(proxies)
+            
+            response = session.get(
+                img_url, 
+                stream=True, 
+                timeout=timeout or self._client.timeout
+            )
+            response.raise_for_status()
+            
+            mime_type = response.headers.get("content-type", "application/octet-stream")
+            data = base64.b64encode(response.content).decode("utf-8")
+            return {"mime_type": mime_type, "data": data}
+        except Exception as e:
+            raise exceptions.FailedToGenerateResponseError(f"Error fetching image: {e}")
+    
+    def _create_non_streaming(
+        self,
+        *,
+        request_id: str,
+        created_time: int,
+        model: str,
+        payload: Dict[str, Any],
+        timeout: Optional[int] = None,
+        proxies: Optional[dict] = None
+    ) -> ChatCompletion:
+        """Implementation for non-streaming chat completions."""
+        original_proxies = self._client.session.proxies.copy()
+        if proxies is not None:
+            self._client.session.proxies.update(proxies)
+        
+        try:
+            response = self._client.session.post(
+                self._client.base_url,
+                json=payload,
+                headers=self._client.headers,
+                timeout=timeout if timeout is not None else self._client.timeout
+            )
+            response.raise_for_status()
+            data = response.json()
+            
+            # Extract content from GeminiProxy response
+            content = self._extract_content(data)
+            
+            # Create the completion message
+            message = ChatCompletionMessage(
+                role="assistant",
+                content=content
+            )
+            
+            # Create the choice
+            choice = Choice(
+                index=0,
+                message=message,
+                finish_reason="stop"
+            )
+            
+            # Estimate token usage
+            prompt_tokens = count_tokens([msg.get("content", "") for msg in payload.get("contents", [{}])[0].get("parts", [{}])])
+            completion_tokens = count_tokens(content)
+            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 Exception as e:
+            raise exceptions.FailedToGenerateResponseError(f"GeminiProxy request failed: {e}")
+        finally:
+            if proxies is not None:
+                self._client.session.proxies = original_proxies
+    
+    def _create_streaming_fallback(
+        self,
+        *,
+        request_id: str,
+        created_time: int,
+        model: str,
+        payload: Dict[str, Any],
+        timeout: Optional[int] = None,
+        proxies: Optional[dict] = None
+    ) -> Generator[ChatCompletionChunk, None, None]:
+        """Fallback streaming implementation that simulates streaming from non-streaming response."""
+        # Get the full response first
+        completion = self._create_non_streaming(
+            request_id=request_id,
+            created_time=created_time,
+            model=model,
+            payload=payload,
+            timeout=timeout,
+            proxies=proxies
+        )
+        
+        # Simulate streaming by yielding chunks
+        content = completion.choices[0].message.content
+        if content:
+            # Split content into chunks (simulate streaming)
+            chunk_size = max(1, len(content) // 10)  # Split into ~10 chunks
+            for i in range(0, len(content), chunk_size):
+                chunk_content = content[i:i + chunk_size]
+                
+                delta = ChoiceDelta(content=chunk_content)
+                choice = Choice(index=0, delta=delta, finish_reason=None)
+                
+                chunk = ChatCompletionChunk(
+                    id=request_id,
+                    choices=[choice],
+                    created=created_time,
+                    model=model
+                )
+                
+                yield chunk
+        
+        # Final chunk with finish_reason
+        delta = ChoiceDelta(content=None)
+        choice = Choice(index=0, delta=delta, finish_reason="stop")
+        chunk = ChatCompletionChunk(
+            id=request_id,
+            choices=[choice],
+            created=created_time,
+            model=model
+        )
+        
+        yield chunk
+    
+    def _extract_content(self, response: dict) -> str:
+        """Extract content from GeminiProxy response."""
+        try:
+            return response['candidates'][0]['content']['parts'][0]['text']
+        except (KeyError, IndexError, TypeError):
+            return str(response)
+
+
+class Chat(BaseChat):
+    def __init__(self, client: 'GeminiProxy'):
+        self.completions = Completions(client)
+
+
+class GeminiProxy(OpenAICompatibleProvider):
+    """
+    OpenAI-compatible client for GeminiProxy API.
+    
+    Usage:
+        client = GeminiProxy()
+        response = client.chat.completions.create(
+            model="gemini-2.0-flash-lite",
+            messages=[{"role": "user", "content": "Hello!"}]
+        )
+        print(response.choices[0].message.content)
+    """
+    
+    AVAILABLE_MODELS = [
+        "gemini-2.0-flash-lite",
+        "gemini-2.0-flash",
+        "gemini-2.5-pro-preview-06-05",
+        "gemini-2.5-pro-preview-05-06",
+        "gemini-2.5-flash-preview-04-17",
+        "gemini-2.5-flash-preview-05-20",
+    ]
+    
+    def __init__(
+        self,
+        api_key: Optional[str] = None,  # Not used but included for compatibility
+        browser: str = "chrome",
+        **kwargs: Any
+    ):
+        """
+        Initialize the GeminiProxy client.
+        
+        Args:
+            api_key: Not used but included for compatibility with OpenAI interface
+            browser: Browser type for fingerprinting
+            **kwargs: Additional parameters
+        """
+        super().__init__(api_key=api_key, **kwargs)
+        
+        self.timeout = 30
+        self.base_url = "https://us-central1-infinite-chain-295909.cloudfunctions.net/gemini-proxy-staging-v1"
+        
+        # Initialize LitAgent for fingerprinting
+        self.agent = LitAgent()
+        self.fingerprint = self.agent.generate_fingerprint(browser)
+        
+        # Initialize session
+        self.session = requests.Session()
+        self.headers = self.fingerprint.copy()
+        self.session.headers.update(self.headers)
+        self.session.proxies = {}
+        
+        # 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/MiniMax.py

@@ -0,0 +1,298 @@
+import os
+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, count_tokens
+)
+
+class Completions(BaseCompletions):
+    def __init__(self, client: 'MiniMax'):
+        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,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
+        stop: Optional[Union[str, List[str]]] = None,
+        **kwargs: Any
+    ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
+        """
+        Creates a model response for the given chat conversation.
+        Mimics openai.chat.completions.create
+        """
+        api_key = self._client.api_key
+        if not api_key:
+            raise Exception("MINIMAX_API_KEY not set in environment.")
+        model_name = self._client.convert_model_name(model)
+        payload = {
+            "model": model_name,
+            "messages": messages,
+            "stream": stream,
+        }
+        if max_tokens is not None:
+            payload["max_tokens"] = max_tokens
+        if temperature is not None:
+            payload["temperature"] = temperature
+        if top_p is not None:
+            payload["top_p"] = top_p
+        if stop is not None:
+            payload["stop"] = stop
+        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_name, payload, timeout, proxies)
+        else:
+            return self._create_non_stream(request_id, created_time, model_name, payload, timeout, proxies)
+
+    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
+    ) -> Generator[ChatCompletionChunk, None, None]:
+        try:
+            headers = {
+                'Content-Type': 'application/json',
+                'Authorization': f'Bearer {self._client.api_key}',
+            }
+            response = self._client.session.post(
+                self._client.api_endpoint,
+                headers=headers,
+                data=json.dumps(payload),
+                stream=True,
+                timeout=timeout or self._client.timeout,
+                proxies=proxies
+            )
+            response.raise_for_status()
+            prompt_tokens = count_tokens([msg.get("content", "") for msg in payload.get("messages", [])])
+            completion_tokens = 0
+            total_tokens = prompt_tokens
+            streaming_response = ""
+            last_content = ""
+            last_reasoning = ""
+            in_think = False
+            for line in response.iter_lines():
+                if line:
+                    line = line.decode('utf-8')
+                    if line.startswith('data: '):
+                        line = line[6:]
+                        if line.strip() == '[DONE]':
+                            break
+                        try:
+                            chunk_data = json.loads(line)
+                            if 'choices' in chunk_data and chunk_data['choices']:
+                                choice_data = chunk_data['choices'][0]
+                                delta = choice_data.get('delta', {})
+                                content = delta.get('content')
+                                reasoning_content = delta.get('reasoning_content')
+                                finish_reason = choice_data.get('finish_reason')
+                                # Only yield <think> and reasoning_content if reasoning_content is not empty
+                                if reasoning_content and reasoning_content.strip() and reasoning_content != last_reasoning:
+                                    if not in_think:
+                                        yield ChatCompletionChunk(
+                                            id=request_id,
+                                            choices=[Choice(index=0, delta=ChoiceDelta(content='<think>\n\n', role=None, tool_calls=None), finish_reason=None, logprobs=None)],
+                                            created=created_time,
+                                            model=model
+                                        )
+                                        in_think = True
+                                    yield ChatCompletionChunk(
+                                        id=request_id,
+                                        choices=[Choice(index=0, delta=ChoiceDelta(content=reasoning_content, role=None, tool_calls=None), finish_reason=None, logprobs=None)],
+                                        created=created_time,
+                                        model=model
+                                    )
+                                    last_reasoning = reasoning_content
+                                # Only yield </think> if we were in <think> and now have new content
+                                if in_think and content and content.strip() and content != last_content:
+                                    yield ChatCompletionChunk(
+                                        id=request_id,
+                                        choices=[Choice(index=0, delta=ChoiceDelta(content='</think>\n\n', role=None, tool_calls=None), finish_reason=None, logprobs=None)],
+                                        created=created_time,
+                                        model=model
+                                    )
+                                    in_think = False
+                                # Only yield content if it is not empty
+                                if content and content.strip() and content != last_content:
+                                    completion_tokens += count_tokens(content)
+                                    total_tokens = prompt_tokens + completion_tokens
+                                    choice_delta = ChoiceDelta(
+                                        content=content,
+                                        role=delta.get('role', 'assistant'),
+                                        tool_calls=delta.get('tool_calls')
+                                    )
+                                    choice = Choice(
+                                        index=0,
+                                        delta=choice_delta,
+                                        finish_reason=finish_reason,
+                                        logprobs=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
+                                    streaming_response += content
+                                    last_content = content
+                        except Exception:
+                            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
+            )
+            chunk.usage = {
+                "prompt_tokens": prompt_tokens,
+                "completion_tokens": completion_tokens,
+                "total_tokens": total_tokens,
+                "estimated_cost": None
+            }
+            yield chunk
+        except Exception as e:
+            raise IOError(f"MiniMax stream 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
+    ) -> ChatCompletion:
+        try:
+            headers = {
+                'Content-Type': 'application/json',
+                'Authorization': f'Bearer {self._client.api_key}',
+            }
+            payload_copy = payload.copy()
+            payload_copy["stream"] = False
+            response = self._client.session.post(
+                self._client.api_endpoint,
+                headers=headers,
+                data=json.dumps(payload_copy),
+                timeout=timeout or self._client.timeout,
+                proxies=proxies
+            )
+            response.raise_for_status()
+            data = response.json()
+            full_text = ""
+            finish_reason = "stop"
+            if 'choices' in data and data['choices']:
+                choice_data = data['choices'][0]
+                # MiniMax returns content in 'message' or directly in 'delta' for streaming
+                reasoning_content = ""
+                if 'message' in choice_data and choice_data['message']:
+                    full_text = choice_data['message'].get('content', '')
+                    reasoning_content = choice_data['message'].get('reasoning_content', '')
+                elif 'delta' in choice_data and choice_data['delta']:
+                    full_text = choice_data['delta'].get('content', '')
+                    reasoning_content = choice_data['delta'].get('reasoning_content', '')
+                finish_reason = choice_data.get('finish_reason', 'stop')
+                # If both are present, concatenate with <think> ... </think>
+                if reasoning_content and reasoning_content.strip():
+                    if full_text and full_text.strip():
+                        full_text = f"<think>\n\n{reasoning_content}</think>\n\n{full_text}"
+                    else:
+                        full_text = f"<think>\n\n{reasoning_content}</think>\n\n"
+            message = ChatCompletionMessage(
+                role="assistant",
+                content=full_text
+            )
+            choice = Choice(
+                index=0,
+                message=message,
+                finish_reason=finish_reason
+            )
+            prompt_tokens = count_tokens([msg.get("content", "") for msg in payload.get("messages", [])])
+            completion_tokens = count_tokens(full_text)
+            usage = CompletionUsage(
+                prompt_tokens=prompt_tokens,
+                completion_tokens=completion_tokens,
+                total_tokens=prompt_tokens + completion_tokens
+            )
+            completion = ChatCompletion(
+                id=request_id,
+                choices=[choice],
+                created=created_time,
+                model=model,
+                usage=usage,
+            )
+            return completion
+        except Exception as e:
+            raise IOError(f"MiniMax non-stream request failed: {e}") from e
+
+class Chat(BaseChat):
+    def __init__(self, client: 'MiniMax'):
+        self.completions = Completions(client)
+
+class MiniMax(OpenAICompatibleProvider):
+    """
+    OpenAI-compatible client for MiniMax API.
+    """
+    AVAILABLE_MODELS = [
+        "MiniMax-Reasoning-01"
+    ]
+    def __init__(self, timeout: int = 30):
+        self.timeout = timeout
+        self.api_endpoint = "https://api.minimaxi.chat/v1/text/chatcompletion_v2"
+        self.session = requests.Session()
+        self.api_key = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJHcm91cE5hbWUiOiJtbyBuaSIsIlVzZXJOYW1lIjoibW8gbmkiLCJBY2NvdW50IjoiIiwiU3ViamVjdElEIjoiMTg3NjIwMDY0ODA2NDYzNTI0MiIsIlBob25lIjoiIiwiR3JvdXBJRCI6IjE4NzYyMDA2NDgwNjA0NDA5MzgiLCJQYWdlTmFtZSI6IiIsIk1haWwiOiJuaW1vQHN1YnN1cC52aXAiLCJDcmVhdGVUaW1lIjoiMjAyNS0wMS0wNyAxMToyNzowNyIsIlRva2VuVHlwZSI6MSwiaXNzIjoibWluaW1heCJ9.Ge1ZnpFPUfXVdMini0P_qXbP_9VYwzXiffG9DsNQck4GtYEOs33LDeAiwrVsrrLZfvJ2icQZ4sRZS54wmPuWua_Dav6pYJty8ZtahmUX1IuhlUX5YErhhCRAIy3J1xB8FkLHLyylChuBHpkNz6O6BQLmPqmoa-cOYK9Qrc6IDeu8SX1iMzO9-MSkcWNvkvpCF2Pf9tekBVWNKMDK6IZoMEPbtkaPXdDyP6l0M0e2AlL_E0oM9exg3V-ohAi8OTPFyqM6dcd4TwF-b9DULxfIsRFw401mvIxcTDWa42u2LULewdATVRD2BthU65tuRqEiWeFWMvFlPj2soMze_QIiUA"
+        self.chat = Chat(self)
+
+    @property
+    def models(self):
+        class _ModelList:
+            def list(inner_self):
+                return MiniMax.AVAILABLE_MODELS
+        return _ModelList()
+
+    def convert_model_name(self, model: str) -> str:
+        if model in self.AVAILABLE_MODELS:
+            return model
+        return self.AVAILABLE_MODELS[0]
+
+if __name__ == "__main__":
+    from rich import print
+    client = MiniMax()
+    messages = [
+        {"role": "user", "content": "What is the capital of France?"}
+    ]
+    # Non-streaming example
+    response = client.chat.completions.create(
+        model="MiniMax-Reasoning-01",
+        messages=messages,
+        max_tokens=5000,
+        stream=False
+    )
+    print("Non-streaming response:")
+    print(response)
+    # Streaming example
+    print("\nStreaming response:")
+    stream = client.chat.completions.create(
+        model="MiniMax-Reasoning-01",
+        messages=messages,
+        max_tokens=5000,
+        stream=True
+    )
+    for chunk in stream:
+        if chunk.choices[0].delta and chunk.choices[0].delta.content:
+            print(chunk.choices[0].delta.content, end="")
+    print()