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

webscout/Provider/TTI/monochat.py

@@ -175,15 +175,15 @@ class MonoChatAI(TTICompatibleProvider):
     AVAILABLE_MODELS = ["nextlm-image-1", "gpt-image-1", "dall-e-3", "dall-e-2"]
 
     def __init__(self):
-        self.api_endpoint = "https://www.chatwithmono.xyz/api"
+        self.api_endpoint = "https://gg.is-a-furry.dev/api"
         self.session = requests.Session()
         self._setup_session_with_retries()
         self.user_agent = LitAgent().random()
         self.headers = {
             "accept": "*/*",
             "content-type": "application/json",
-            "origin": "https://www.chatwithmono.xyz",
-            "referer": "https://www.chatwithmono.xyz/",
+            "origin": "https://gg.is-a-furry.dev",
+            "referer": "https://gg.is-a-furry.dev/",
             "user-agent": self.user_agent,
         }
         self.session.headers.update(self.headers)

webscout/Provider/TextPollinationsAI.py

@@ -18,25 +18,26 @@ class TextPollinationsAI(Provider):
         "openai",
         "openai-fast",
         "openai-large",
+        "openai-reasoning",
         "openai-roblox",
-        "qwen-coder",
-        "llama",
+        "openai-audio",
+        "deepseek",
+        "deepseek-reasoning",
+        "grok",
         "llamascout",
         "mistral",
-        "unity",
-        "mirexa",
-        "midijourney",
-        "rtist",
+        "phi",
+        "qwen-coder",
         "searchgpt",
+        "bidara",
+        "elixposearch",
         "evil",
-        "deepseek-reasoning",
-        "phi",
-        "hormoz",
         "hypnosis-tracy",
-        "deepseek",
+        "midijourney",
+        "mirexa",
+        "rtist",
         "sur",
-        "bidara",
-        "openai-audio",
+        "unity",
     ]
     _models_url = "https://text.pollinations.ai/models"
 

webscout/Provider/__init__.py

@@ -24,7 +24,6 @@ from .yep import *
 from .Cloudflare import *
 from .turboseek import *
 from .TeachAnything import *
-from .AI21 import *
 from .x0gpt import *
 from .cerebras import *
 from .geminiapi import *
@@ -52,7 +51,6 @@ from .AllenAI import *
 from .HeckAI import *
 from .TwoAI import *
 from .Venice import *
-from .HuggingFaceChat import *
 from .GithubChat import *
 from .copilot import *
 from .sonus import *
@@ -87,9 +85,13 @@ from .deepseek_assistant import DeepSeekAssistant
 from .GeminiProxy import GeminiProxy
 from .TogetherAI import TogetherAI
 from .MiniMax import MiniMax
+from .Qodo import *
+from .monochat import MonoChat
 __all__ = [
     'SCNet',
+    'MonoChat',
     'MiniMax',
+    'QodoAI',
     'GeminiProxy',
     'TogetherAI',
     'oivscode',
@@ -109,7 +111,6 @@ __all__ = [
     'Venice',
     'ExaAI',
     'Copilot',
-    'HuggingFaceChat',
     'TwoAI',
     'HeckAI',
     'AllenAI',
@@ -145,7 +146,6 @@ __all__ = [
     'Cloudflare',
     'TurboSeek',
     'TeachAnything',
-    'AI21',
     'X0GPT',
     'Cerebras',
     'GEMINIAPI',

webscout/Provider/copilot.py

@@ -112,10 +112,18 @@ class Copilot(Provider):
         raw: bool = False,
         optimizer: str = None,
         conversationally: bool = False,
-        images = None,
+        images=None,
         api_key: str = None,
         **kwargs
     ) -> Union[Dict[str, Any], Generator]:
+        """
+        Enhanced Copilot.ask with:
+        - return_conversation support
+        - multiple image upload
+        - event dispatch for websocket events
+        - suggested followups and metadata
+        - improved error handling
+        """
         conversation_prompt = self.conversation.gen_complete_prompt(prompt)
         if optimizer:
             if optimizer in self.__available_optimizers:
@@ -125,7 +133,33 @@ class Copilot(Provider):
             else:
                 raise Exception(f"Optimizer is not one of {self.__available_optimizers}")
 
-        # Main logic for calling Copilot API
+        def handle_event(msg, state):
+            event = msg.get("event")
+            if event == "appendText":
+                state["is_started"] = True
+                content = msg.get("text")
+                state["streaming_text"] += content
+                resp = {"text": content}
+                return resp if raw else resp
+            elif event == "generatingImage":
+                state["image_prompt"] = msg.get("prompt")
+            elif event == "imageGenerated":
+                return {"type": "image", "url": msg.get("url"), "prompt": state.get("image_prompt"), "preview": msg.get("thumbnailUrl")}
+            elif event == "done":
+                state["done"] = True
+            elif event == "suggestedFollowups":
+                return {"type": "suggested_followups", "suggestions": msg.get("suggestions")}
+            elif event == "replaceText":
+                content = msg.get("text")
+                state["streaming_text"] += content
+                resp = {"text": content}
+                return resp if raw else resp
+            elif event == "error":
+                raise exceptions.FailedToGenerateResponseError(f"Error: {msg}")
+            elif event not in ["received", "startMessage", "citation", "partCompleted"]:
+                pass
+            return None
+
         def for_stream():
             try:
                 if not has_curl_cffi:
@@ -133,15 +167,15 @@ class Copilot(Provider):
 
                 websocket_url = self.websocket_url
                 headers = None
-                
-                if images is not None:
+
+                # Auth logic (token/cookies)
+                if images is not None or api_key is not None:
                     if api_key is not None:
                         self._access_token = api_key
                     if self._access_token is None:
                         try:
                             self._access_token, self._cookies = readHAR(self.url)
                         except NoValidHarFileError as h:
-                            # print(f"Copilot: {h}")
                             if has_nodriver:
                                 yield {"type": "login", "provider": self.label, "url": os.environ.get("webscout_login", "")}
                                 self._access_token, self._cookies = asyncio.run(get_access_token_and_cookies(self.url, self.proxies.get("https")))
@@ -159,7 +193,7 @@ class Copilot(Provider):
                 ) as session:
                     if self._access_token is not None:
                         self._cookies = session.cookies.jar if hasattr(session.cookies, "jar") else session.cookies
-                    
+
                     response = session.get(f"{self.url}/c/api/user")
                     if response.status_code == 401:
                         raise exceptions.AuthenticationError("Status 401: Invalid access token")
@@ -168,9 +202,8 @@ class Copilot(Provider):
                     user = response.json().get('firstName')
                     if user is None:
                         self._access_token = None
-                    # print(f"Copilot: User: {user or 'null'}")
 
-                    # Create or use existing conversation
+                    # Conversation management
                     conversation = kwargs.get("conversation", None)
                     if conversation is None:
                         response = session.post(self.conversation_url)
@@ -180,30 +213,26 @@ class Copilot(Provider):
                         conversation = CopilotConversation(conversation_id)
                         if kwargs.get("return_conversation", False):
                             yield conversation
-                        # print(f"Copilot: Created conversation: {conversation_id}")
                     else:
                         conversation_id = conversation.conversation_id
-                        # print(f"Copilot: Use conversation: {conversation_id}")
 
-                    # Handle image uploads if any
+                    # Multiple image upload
                     uploaded_images = []
                     if images is not None:
-                        for image, _ in images:
+                        for image_tuple in images:
+                            image = image_tuple[0] if isinstance(image_tuple, (tuple, list)) else image_tuple
                             # Convert image to bytes if needed
                             if isinstance(image, str):
                                 if image.startswith("data:"):
-                                    # Data URL
                                     header, encoded = image.split(",", 1)
                                     data = base64.b64decode(encoded)
                                 else:
-                                    # File path or URL
                                     with open(image, "rb") as f:
                                         data = f.read()
                             else:
                                 data = image
-                                
                             # Get content type
-                            content_type = "image/jpeg"  # Default
+                            content_type = "image/jpeg"
                             if data[:2] == b'\xff\xd8':
                                 content_type = "image/jpeg"
                             elif data[:8] == b'\x89PNG\r\n\x1a\n':
@@ -212,7 +241,6 @@ class Copilot(Provider):
                                 content_type = "image/gif"
                             elif data[:2] in (b'BM', b'BA'):
                                 content_type = "image/bmp"
-                            
                             response = session.post(
                                 f"{self.url}/c/api/attachments",
                                 headers={"content-type": content_type},
@@ -220,12 +248,11 @@ class Copilot(Provider):
                             )
                             if response.status_code != 200:
                                 raise exceptions.APIConnectionError(f"Status {response.status_code}: {response.text}")
-                            uploaded_images.append({"type":"image", "url": response.json().get("url")})
-                            break
+                            uploaded_images.append({"type": "image", "url": response.json().get("url")})
 
-                    # Connect to WebSocket
+                    # WebSocket connection
                     wss = session.ws_connect(websocket_url)
-                    wss.send(json.dumps({"event":"setOptions","supportedCards":["weather","local","image","sports","video","ads","finance"],"ads":{"supportedTypes":["multimedia","product","tourActivity","propertyPromotion","text"]}}));
+                    wss.send(json.dumps({"event": "setOptions", "supportedCards": ["weather", "local", "image", "sports", "video", "ads", "finance"], "ads": {"supportedTypes": ["multimedia", "product", "tourActivity", "propertyPromotion", "text"]}}))
                     wss.send(json.dumps({
                         "event": "send",
                         "conversationId": conversation_id,
@@ -236,56 +263,26 @@ class Copilot(Provider):
                         "mode": "reasoning" if "Think" in self.model else "chat"
                     }).encode(), CurlWsFlag.TEXT)
 
-                    # Process response
-                    is_started = False
-                    msg = None
-                    image_prompt: str = None
+                    # Event-driven response loop
+                    state = {"is_started": False, "image_prompt": None, "done": False, "streaming_text": ""}
                     last_msg = None
-                    streaming_text = ""
-                    
                     try:
-                        while True:
+                        while not state["done"]:
                             try:
                                 msg = wss.recv()[0]
                                 msg = json.loads(msg)
-                            except:
+                            except Exception:
                                 break
                             last_msg = msg
-                            if msg.get("event") == "appendText":
-                                is_started = True
-                                content = msg.get("text")
-                                streaming_text += content
-                                resp = {"text": content}
-                                yield resp if raw else resp
-                            elif msg.get("event") == "generatingImage":
-                                image_prompt = msg.get("prompt")
-                            elif msg.get("event") == "imageGenerated":
-                                yield {"type": "image", "url": msg.get("url"), "prompt": image_prompt, "preview": msg.get("thumbnailUrl")}
-                            elif msg.get("event") == "done":
-                                break
-                            elif msg.get("event") == "suggestedFollowups":
-                                yield {"type": "suggested_followups", "suggestions": msg.get("suggestions")}
-                                break
-                            elif msg.get("event") == "replaceText":
-                                content = msg.get("text")
-                                streaming_text += content
-                                resp = {"text": content}
-                                yield resp if raw else resp
-                            elif msg.get("event") == "error":
-                                raise exceptions.FailedToGenerateResponseError(f"Error: {msg}")
-                            elif msg.get("event") not in ["received", "startMessage", "citation", "partCompleted"]:
-                                print(f"Copilot Message: {msg}")
-                        
-                        if not is_started:
+                            result = handle_event(msg, state)
+                            if result is not None:
+                                yield result
+                        if not state["is_started"]:
                             raise exceptions.FailedToGenerateResponseError(f"Invalid response: {last_msg}")
-                            
-                        # Update conversation history
-                        self.conversation.update_chat_history(prompt, streaming_text)
-                        self.last_response = {"text": streaming_text}
-                        
+                        self.conversation.update_chat_history(prompt, state["streaming_text"])
+                        self.last_response = {"text": state["streaming_text"]}
                     finally:
                         wss.close()
-                        
             except Exception as e:
                 raise exceptions.FailedToGenerateResponseError(f"Error: {str(e)}")
 

webscout/Provider/freeaichat.py

@@ -2,6 +2,8 @@ import re
 import requests
 import json
 import uuid
+import random
+import string
 from typing import Any, Dict, Optional, Generator, Union
 
 from webscout.AIutel import Optimizers
@@ -18,70 +20,74 @@ class FreeAIChat(Provider):
 
     AVAILABLE_MODELS = [
         # OpenAI Models
+        "Deepseek R1 Latest",
         "GPT 4o",
-        "GPT 4.5 Preview",
-        "GPT 4o Latest",
-        "GPT 4o mini",
-        "GPT 4o Search Preview",
-        "O1",
-        "O1 Mini",
-        "O3 Mini",
-        "O3 Mini High",
-        "O3 Mini Low",
         "O4 Mini",
         "O4 Mini High",
+        "QwQ Plus",
+        "Llama 4 Maverick",
+        "Grok 3",
+        "GPT 4o mini",
+        "Deepseek v3 0324",
+        "Grok 3 Mini",
         "GPT 4.1",
-        "o3",
         "GPT 4.1 Mini",
-
-
-        # Anthropic Models
-        "Claude 3.5 haiku",
-        "claude 3.5 sonnet",
-        "Claude 3.7 Sonnet",
         "Claude 3.7 Sonnet (Thinking)",
-
-        # Deepseek Models
-        "Deepseek R1",
-        "Deepseek R1 Fast",
-        "Deepseek V3",
-        "Deepseek v3 0324",
-
-        # Google Models
-        "Gemini 1.5 Flash",
-        "Gemini 1.5 Pro",
-        "Gemini 2.0 Flash",
-        "Gemini 2.0 Pro",
-        "Gemini 2.5 Pro",
-
-        # Llama Models
-        "Llama 3.1 405B",
-        "Llama 3.1 70B Fast",
-        "Llama 3.3 70B",
-        "Llama 3.2 90B Vision",
         "Llama 4 Scout",
-        "Llama 4 Maverick",
-
-        # Mistral Models
-        "Mistral Large",
-        "Mistral Nemo",
-        "Mixtral 8x22B",
-
-        # Qwen Models
-        "Qwen Max",
-        "Qwen Plus",
-        "Qwen Turbo",
-        "QwQ 32B",
-        "QwQ Plus",
-
-        # XAI Models
-        "Grok 2",
-        "Grok 3",
+        "O3 High",
+        "Gemini 2.5 Pro",
+        "Magistral Medium 2506",
+        "O3",
+        "Gemini 2.5 Flash",
+        "Qwen 3 235B A22B",
+        "Claude 4 Sonnet",
+        "Claude 4 Sonnet (Thinking)",
+        "Claude 4 Opus",
+        "Claude 4 Opus (Thinking)",
+        "Google: Gemini 2.5 Pro (thinking)",
     ]
 
+    def _auto_fetch_api_key(self, proxies=None, timeout=30):
+        """
+        Automatically register a new user and fetch an API key from FreeAIChat Playground.
+        """
+        session = requests.Session()
+        if proxies:
+            session.proxies.update(proxies)
+        def random_email():
+            user = ''.join(random.choices(string.ascii_lowercase + string.digits, k=12))
+            return f"{user}@bltiwd.com"
+        email = random_email()
+        payload = {"email": email, "password": email}
+        headers = {
+            'User-Agent': LitAgent().random(),
+            'Accept': '*/*',
+            'Content-Type': 'application/json',
+            'Origin': 'https://freeaichatplayground.com',
+            'Referer': 'https://freeaichatplayground.com/register',
+        }
+        try:
+            resp = session.post(
+                "https://freeaichatplayground.com/api/v1/auth/register",
+                headers=headers,
+                json=payload,
+                timeout=timeout
+            )
+            if resp.status_code == 201:
+                data = resp.json()
+                apikey = data.get("user", {}).get("apikey")
+                if apikey:
+                    return apikey
+                else:
+                    raise exceptions.FailedToGenerateResponseError("API key not found in registration response.")
+            else:
+                raise exceptions.FailedToGenerateResponseError(f"Registration failed: {resp.status_code} {resp.text}")
+        except Exception as e:
+            raise exceptions.FailedToGenerateResponseError(f"API key auto-fetch failed: {e}")
+
     def __init__(
         self,
-        api_key: str,
+        api_key: str = None,
         is_conversation: bool = True,
         max_tokens: int = 150,
         timeout: int = 30,
@@ -95,7 +101,7 @@ class FreeAIChat(Provider):
         system_prompt: str = "You are a helpful AI assistant.",
         temperature: float = 0.7,
     ):
-        """Initializes the FreeAIChat API client."""
+        """Initializes the FreeAIChat API client. If api_key is not provided, auto-register and fetch one."""
         if model not in self.AVAILABLE_MODELS:
             raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
 
@@ -120,7 +126,10 @@ class FreeAIChat(Provider):
         self.model = model
         self.system_prompt = system_prompt
         self.temperature = temperature
-        self.api_key = api_key
+        if not api_key:
+            self.api_key = self._auto_fetch_api_key(proxies=proxies, timeout=timeout)
+        else:
+            self.api_key = api_key
 
         self.__available_optimizers = (
             method