webscout 8.2.3__py3-none-any.whl → 8.2.4__py3-none-any.whl

webscout/Provider/OPENAI/multichat.py

@@ -0,0 +1,368 @@
+import time
+import uuid
+import json
+from datetime import datetime
+from typing import List, Dict, Optional, Union, Generator, Any
+
+# Import base classes and utility structures
+from .base import OpenAICompatibleProvider, BaseChat, BaseCompletions
+from .utils import (
+    ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
+    ChatCompletionMessage, CompletionUsage,
+    format_prompt
+)
+
+# Import curl_cffi for Cloudflare bypass
+from curl_cffi.requests import Session
+from curl_cffi import CurlError
+
+# Import LitAgent for user agent generation
+from webscout.litagent import LitAgent
+
+# ANSI escape codes for formatting
+BOLD = "\033[1m"
+RED = "\033[91m"
+RESET = "\033[0m"
+
+# Model configurations
+MODEL_CONFIGS = {
+    "llama": {
+        "endpoint": "https://www.multichatai.com/api/chat/meta",
+        "models": {
+            "llama-3.3-70b-versatile": {"contextLength": 131072},
+            "llama-3.2-11b-vision-preview": {"contextLength": 32768},
+            "deepseek-r1-distill-llama-70b": {"contextLength": 128000},
+        },
+    },
+    "cohere": {
+        "endpoint": "https://www.multichatai.com/api/chat/cohere",
+        "models": {
+            "command-r": {"contextLength": 128000},
+            "command": {"contextLength": 4096},
+        },
+    },
+    "google": {
+        "endpoint": "https://www.multichatai.com/api/chat/google",
+        "models": {
+            "gemini-1.5-flash-002": {"contextLength": 1048576},
+            "gemma2-9b-it": {"contextLength": 8192},
+            "gemini-2.0-flash": {"contextLength": 128000},
+        },
+        "message_format": "parts",
+    },
+    "deepinfra": {
+        "endpoint": "https://www.multichatai.com/api/chat/deepinfra",
+        "models": {
+            "Sao10K/L3.1-70B-Euryale-v2.2": {"contextLength": 8192},
+            "Gryphe/MythoMax-L2-13b": {"contextLength": 8192},
+            "nvidia/Llama-3.1-Nemotron-70B-Instruct": {"contextLength": 131072},
+            "deepseek-ai/DeepSeek-V3": {"contextLength": 32000},
+            "meta-llama/Meta-Llama-3.1-405B-Instruct": {"contextLength": 131072},
+            "NousResearch/Hermes-3-Llama-3.1-405B": {"contextLength": 131072},
+            "gemma-2-27b-it": {"contextLength": 8192},
+        },
+    },
+    "mistral": {
+        "endpoint": "https://www.multichatai.com/api/chat/mistral",
+        "models": {
+            "mistral-small-latest": {"contextLength": 32000},
+            "codestral-latest": {"contextLength": 32000},
+            "open-mistral-7b": {"contextLength": 8000},
+            "open-mixtral-8x7b": {"contextLength": 8000},
+        },
+    },
+    "alibaba": {
+        "endpoint": "https://www.multichatai.com/api/chat/alibaba",
+        "models": {
+            "Qwen/Qwen2.5-72B-Instruct": {"contextLength": 32768},
+            "Qwen/Qwen2.5-Coder-32B-Instruct": {"contextLength": 32768},
+            "Qwen/QwQ-32B-Preview": {"contextLength": 32768},
+        },
+    },
+}
+
+class Completions(BaseCompletions):
+    def __init__(self, client: 'MultiChatAI'):
+        self._client = client
+
+    def create(
+        self,
+        *,
+        model: str,
+        messages: List[Dict[str, str]],
+        max_tokens: Optional[int] = None,
+        stream: bool = False,
+        temperature: Optional[float] = None,
+        top_p: Optional[float] = None,
+        **kwargs: Any
+    ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
+        """
+        Create a chat completion using the MultiChatAI API.
+
+        Args:
+            model: The model to use
+            messages: A list of messages in the conversation
+            max_tokens: Maximum number of tokens to generate
+            stream: Whether to stream the response
+            temperature: Temperature for response generation
+            top_p: Top-p sampling parameter
+
+        Returns:
+            Either a ChatCompletion object or a generator of ChatCompletionChunk objects
+        """
+        try:
+            # Set client parameters based on function arguments
+            self._client.model = model
+            if temperature is not None:
+                self._client.temperature = temperature
+            if max_tokens is not None:
+                self._client.max_tokens_to_sample = max_tokens
+
+            # Extract system messages and set as system prompt
+            for message in messages:
+                if message.get("role") == "system":
+                    self._client.system_prompt = message.get("content", "")
+                    break
+
+            # Format all messages into a single prompt
+            user_message = format_prompt(messages)
+
+            # Generate a unique request ID
+            request_id = f"multichat-{str(uuid.uuid4())}"
+            created_time = int(time.time())
+
+            # Make the API request
+            response_text = self._client._make_api_request(user_message)
+
+            # If streaming is requested, simulate streaming with the full response
+            if stream:
+                def generate_chunks():
+                    # Create a single chunk with the full response
+                    delta = ChoiceDelta(content=response_text)
+                    choice = Choice(index=0, delta=delta, finish_reason="stop")
+                    chunk = ChatCompletionChunk(
+                        id=request_id,
+                        choices=[choice],
+                        created=created_time,
+                        model=model,
+                    )
+                    yield chunk
+
+                return generate_chunks()
+
+            # For non-streaming, create a complete response
+            message = ChatCompletionMessage(role="assistant", content=response_text)
+            choice = Choice(index=0, message=message, finish_reason="stop")
+
+            # Estimate token usage (this is approximate)
+            prompt_tokens = len(user_message) // 4  # Rough estimate
+            completion_tokens = len(response_text) // 4  # Rough estimate
+            total_tokens = prompt_tokens + completion_tokens
+
+            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],
+                created=created_time,
+                model=model,
+                usage=usage,
+            )
+
+            return completion
+
+        except Exception as e:
+            print(f"{RED}Error during MultiChatAI request: {e}{RESET}")
+            raise IOError(f"MultiChatAI request failed: {e}") from e
+
+class Chat(BaseChat):
+    def __init__(self, client: 'MultiChatAI'):
+        self.completions = Completions(client)
+
+class MultiChatAI(OpenAICompatibleProvider):
+    """
+    OpenAI-compatible client for MultiChatAI API.
+
+    Usage:
+        client = MultiChatAI()
+        response = client.chat.completions.create(
+            model="llama-3.3-70b-versatile",
+            messages=[{"role": "user", "content": "Hello!"}]
+        )
+        print(response.choices[0].message.content)
+    """
+
+    AVAILABLE_MODELS = [
+        # Llama Models
+        "llama-3.3-70b-versatile",
+        "llama-3.2-11b-vision-preview",
+        "deepseek-r1-distill-llama-70b",
+
+        # Google Models
+        "gemma2-9b-it",
+        "gemini-2.0-flash",
+
+        # DeepInfra Models
+        "Sao10K/L3.1-70B-Euryale-v2.2",
+        "Gryphe/MythoMax-L2-13b",
+        "nvidia/Llama-3.1-Nemotron-70B-Instruct",
+        "deepseek-ai/DeepSeek-V3",
+        "meta-llama/Meta-Llama-3.1-405B-Instruct",
+        "NousResearch/Hermes-3-Llama-3.1-405B",
+
+        # Alibaba Models
+        "Qwen/Qwen2.5-72B-Instruct",
+        "Qwen/Qwen2.5-Coder-32B-Instruct",
+        "Qwen/QwQ-32B-Preview"
+    ]
+
+    def __init__(
+        self,
+        timeout: int = 30,
+        proxies: dict = {},
+        model: str = "llama-3.3-70b-versatile",
+        system_prompt: str = "You are a friendly, helpful AI assistant.",
+        temperature: float = 0.5,
+        max_tokens: int = 4000
+    ):
+        """
+        Initialize the MultiChatAI client.
+
+        Args:
+            timeout: Request timeout in seconds
+            proxies: Optional proxy configuration
+            model: Default model to use
+            system_prompt: System prompt to use
+            temperature: Temperature for response generation
+            max_tokens: Maximum number of tokens to generate
+        """
+        if model not in self.AVAILABLE_MODELS:
+            raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
+
+        # Initialize curl_cffi Session
+        self.session = Session()
+        self.timeout = timeout
+        self.model = model
+        self.system_prompt = system_prompt
+        self.temperature = temperature
+        self.max_tokens_to_sample = max_tokens
+
+        # Initialize LitAgent for user agent generation
+        self.agent = LitAgent()
+
+        self.headers = {
+            "accept": "*/*",
+            "accept-language": "en-US,en;q=0.9",
+            "content-type": "text/plain;charset=UTF-8",
+            "origin": "https://www.multichatai.com",
+            "referer": "https://www.multichatai.com/",
+            "user-agent": self.agent.random(),
+        }
+
+        # Update curl_cffi session headers, proxies, and cookies
+        self.session.headers.update(self.headers)
+        self.session.proxies = proxies
+        self.session.cookies.set("session", uuid.uuid4().hex)
+
+        # Initialize the provider based on the model
+        self.provider = self._get_provider_from_model(self.model)
+        self.model_name = self.model
+
+        # Initialize the chat interface
+        self.chat = Chat(self)
+
+    def _get_endpoint(self) -> str:
+        """Get the API endpoint for the current provider."""
+        return MODEL_CONFIGS[self.provider]["endpoint"]
+
+    def _get_chat_settings(self) -> Dict[str, Any]:
+        """Get chat settings for the current model."""
+        base_settings = MODEL_CONFIGS[self.provider]["models"][self.model_name]
+        return {
+            "model": self.model,
+            "prompt": self.system_prompt,
+            "temperature": self.temperature,
+            "contextLength": base_settings["contextLength"],
+            "includeProfileContext": True,
+            "includeWorkspaceInstructions": True,
+            "embeddingsProvider": "openai"
+        }
+
+    def _get_system_message(self) -> str:
+        """Generate system message with current date."""
+        current_date = datetime.now().strftime("%d/%m/%Y")
+        return f"Today is {current_date}.\n\nUser Instructions:\n{self.system_prompt}"
+
+    def _build_messages(self, conversation_prompt: str) -> list:
+        """Build messages array based on provider type."""
+        if self.provider == "google":
+            return [
+                {"role": "user", "parts": self._get_system_message()},
+                {"role": "model", "parts": "I will follow your instructions."},
+                {"role": "user", "parts": conversation_prompt}
+            ]
+        else:
+            return [
+                {"role": "system", "content": self._get_system_message()},
+                {"role": "user", "content": conversation_prompt}
+            ]
+
+    def _get_provider_from_model(self, model: str) -> str:
+        """Determine the provider based on the model name."""
+        for provider, config in MODEL_CONFIGS.items():
+            if model in config["models"]:
+                return provider
+
+        available_models = []
+        for provider, config in MODEL_CONFIGS.items():
+            for model_name in config["models"].keys():
+                available_models.append(f"{provider}/{model_name}")
+
+        error_msg = f"Invalid model: {model}\nAvailable models: {', '.join(available_models)}"
+        raise ValueError(error_msg)
+
+    def _make_api_request(self, prompt: str) -> str:
+        """Make the API request with proper error handling."""
+        try:
+            payload = {
+                "chatSettings": self._get_chat_settings(),
+                "messages": self._build_messages(prompt),
+                "customModelId": "",
+            }
+
+            # Use curl_cffi session post with impersonate
+            response = self.session.post(
+                self._get_endpoint(),
+                json=payload,
+                timeout=self.timeout,
+                impersonate="chrome110"
+            )
+            response.raise_for_status()
+
+            # Return the response text
+            return response.text.strip()
+
+        except CurlError as e:
+            raise IOError(f"API request failed (CurlError): {e}") from e
+        except Exception as e:
+            err_text = getattr(e, 'response', None) and getattr(e.response, 'text', '')
+            raise IOError(f"API request failed ({type(e).__name__}): {e} - {err_text}") from e
+
+if __name__ == "__main__":
+    print(f"{BOLD}Testing MultiChatAI OpenAI-compatible provider{RESET}")
+
+    client = MultiChatAI()
+    response = client.chat.completions.create(
+        model="llama-3.3-70b-versatile",
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": "Say 'Hello' in one word"}
+        ]
+    )
+
+    print(f"Response: {response.choices[0].message.content}")

webscout/Provider/OPENAI/netwrck.py

@@ -203,12 +203,14 @@ class Netwrck(OpenAICompatibleProvider):
         "x-ai/grok-2",
         "anthropic/claude-3-7-sonnet-20250219",
         "sao10k/l3-euryale-70b",
-        "openai/gpt-4o-mini",
+        "openai/gpt-4.1-mini",
         "gryphe/mythomax-l2-13b",
         "google/gemini-pro-1.5",
+        "google/gemini-2.5-flash-preview-04-17",
         "nvidia/llama-3.1-nemotron-70b-instruct",
         "deepseek/deepseek-r1",
         "deepseek/deepseek-chat"
+
     ]
 
     # Default greeting used by Netwrck

webscout/Provider/OpenGPT.py

@@ -1,4 +1,5 @@
-import requests
+from curl_cffi.requests import Session
+from curl_cffi import CurlError
 import json
 from typing import Dict, Generator, Union
 
@@ -9,6 +10,7 @@ from webscout.AIbase import Provider
 from webscout import exceptions
 from webscout.litagent import LitAgent
 
+
 class OpenGPT(Provider):
     """
     A class to interact with the Open-GPT API.
@@ -17,7 +19,7 @@ class OpenGPT(Provider):
     def __init__(
         self,
         is_conversation: bool = True,
-        max_tokens: int = 600,
+        max_tokens: int = 600, # Note: max_tokens is not used by this API
         timeout: int = 30,
         intro: str = None,
         filepath: str = None,
@@ -41,8 +43,9 @@ class OpenGPT(Provider):
             act (str, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
             app_id (str, optional): The OpenGPT application ID. Defaults to "clf3yg8730000ih08ndbdi2v4".
         """
-        self.session = requests.Session()
-        self.agent = LitAgent()
+        # Initialize curl_cffi Session
+        self.session = Session()
+        self.agent = LitAgent() # Keep for potential future use or other headers
         
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
@@ -50,15 +53,17 @@ class OpenGPT(Provider):
         self.last_response = {}
         self.app_id = app_id
         
-        # Set up headers with dynamic user agent
+        # Set up headers (remove User-Agent if using impersonate)
         self.headers = {
             "Content-Type": "application/json",
-            "User-Agent": self.agent.random(),
-            "Referer": f"https://open-gpt.app/id/app/{app_id}"
+            # "User-Agent": self.agent.random(), # Removed, handled by impersonate
+            "Referer": f"https://open-gpt.app/id/app/{self.app_id}",
+            # Add sec-ch-ua headers if needed for impersonation consistency
         }
         
+        # Update curl_cffi session headers and proxies
         self.session.headers.update(self.headers)
-        self.session.proxies.update(proxies)
+        self.session.proxies = proxies # Assign proxies directly
         
         # Initialize optimizers
         self.__available_optimizers = (
@@ -82,7 +87,7 @@ class OpenGPT(Provider):
     def ask(
         self,
         prompt: str,
-        stream: bool = False,
+        stream: bool = False, # Note: API does not support streaming
         raw: bool = False,
         optimizer: str = None,
         conversationally: bool = False,
@@ -117,31 +122,34 @@ class OpenGPT(Provider):
             "userKey": ""  # Assuming userKey is meant to be empty as in the original code
         }
         
+        # API does not stream, implement non-stream logic directly
         def for_non_stream():
             try:
+                # Use curl_cffi session post with impersonate
                 response = self.session.post(
                     "https://open-gpt.app/api/generate",
-                    data=json.dumps(payload),
-                    timeout=self.timeout
+                    # headers are set on the session
+                    data=json.dumps(payload), # Keep data as JSON string
+                    timeout=self.timeout,
+                    # proxies are set on the session
+                    impersonate="chrome110" # Use a common impersonation profile
                 )
                 
-                # Raise an exception for bad status codes
-                response.raise_for_status()
+                response.raise_for_status() # Check for HTTP errors
                 
+                # Use response.text which is already decoded
                 response_text = response.text
                 self.last_response = {"text": response_text}
                 self.conversation.update_chat_history(prompt, response_text)
                 
-                return {"text": response_text} if not raw else {"raw": response_text}
+                # Return dict or raw string based on raw flag
+                return {"raw": response_text} if raw else {"text": response_text}
                 
-            except requests.exceptions.RequestException as e:
-                # Handle potential errors during the request
-                error_msg = f"Error fetching data: {e}"
-                raise exceptions.FailedToGenerateResponseError(error_msg)
-            except Exception as e:
-                # Catch any other unexpected errors
-                error_msg = f"An unexpected error occurred: {e}"
-                raise exceptions.FailedToGenerateResponseError(error_msg)
+            except CurlError as e: # Catch CurlError
+                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}") from e
+            except Exception as e: # Catch other potential exceptions (like HTTPError, JSONDecodeError)
+                err_text = getattr(e, 'response', None) and getattr(e.response, 'text', '')
+                raise exceptions.FailedToGenerateResponseError(f"An unexpected error occurred ({type(e).__name__}): {e} - {err_text}") from e
         
         # This provider doesn't support streaming, so just return non-stream
         return for_non_stream()
@@ -149,7 +157,7 @@ class OpenGPT(Provider):
     def chat(
         self,
         prompt: str,
-        stream: bool = False,
+        stream: bool = False, # Keep stream param for interface consistency
         optimizer: str = None,
         conversationally: bool = False,
     ) -> Union[str, Generator[str, None, None]]:
@@ -165,10 +173,22 @@ class OpenGPT(Provider):
         Returns:
             A string with the response text.
         """
-        response = self.ask(
-            prompt, False, optimizer=optimizer, conversationally=conversationally
+        # Since ask() now handles both stream=True/False by returning the full response dict:
+        response_data = self.ask(
+            prompt, 
+            stream=False, # Call ask in non-stream mode internally
+            raw=False, # Ensure ask returns dict with 'text' key
+            optimizer=optimizer, 
+            conversationally=conversationally
         )
-        return self.get_message(response)
+        # If stream=True was requested, simulate streaming by yielding the full message at once
+        if stream:
+            def stream_wrapper():
+                yield self.get_message(response_data)
+            return stream_wrapper()
+        else:
+            # If stream=False, return the full message directly
+            return self.get_message(response_data)
 
     def get_message(self, response: dict) -> str:
         """
@@ -185,15 +205,5 @@ class OpenGPT(Provider):
 
 
 if __name__ == "__main__":
-    # Test the provider
-    print("-" * 80)
-    print("Testing OpenGPT provider")
-    print("-" * 80)
-    
-    try:
-        test_ai = OpenGPT()
-        response = test_ai.chat("Explain quantum physics simply.")
-        print(response)
-    except Exception as e:
-        print(f"Error: {e}")
-
+    ai = OpenGPT()
+    print(ai.chat("Hello, how are you?"))