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

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

webscout/Provider/monochat.py

@@ -0,0 +1,275 @@
+from typing import Generator, Optional, Union, Any, Dict
+from uuid import uuid4
+from curl_cffi import CurlError
+from curl_cffi.requests import Session
+import re
+
+from webscout.AIutel import Optimizers
+from webscout.AIutel import Conversation
+from webscout.AIutel import AwesomePrompts, sanitize_stream
+from webscout.AIbase import Provider
+from webscout import exceptions
+from webscout.litagent import LitAgent
+
+class MonoChat(Provider):
+    """
+    MonoChat provider for interacting with the gg.is-a-furry.dev API (OpenAI-compatible).
+    """
+    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"
+    ]
+
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 2049,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        model: str = "gpt-4.1",
+        system_prompt: str = "You are a helpful assistant.",
+        browser: str = "chrome"
+    ):
+        if model not in self.AVAILABLE_MODELS:
+            raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
+        self.session = Session()
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.api_endpoint = "https://gg.is-a-furry.dev/api/chat"
+        self.timeout = timeout
+        self.last_response = {}
+        self.model = model
+        self.system_prompt = system_prompt
+        self.agent = LitAgent()
+        self.fingerprint = self.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"]
+        }
+        self.session.headers.update(self.headers)
+        self.session.proxies = proxies
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+
+    def refresh_identity(self, browser: str = None):
+        browser = browser or self.fingerprint.get("browser_type", "chrome")
+        self.fingerprint = self.agent.generate_fingerprint(browser)
+        self.headers.update({
+            "accept-language": self.fingerprint["accept_language"],
+            "user-agent": self.fingerprint["user_agent"]
+        })
+        self.session.headers.update(self.headers)
+        return self.fingerprint
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> Union[Dict[str, Any], Generator]:
+        """
+        Sends a prompt to the gg.is-a-furry.dev API and returns the response.
+
+        Args:
+            prompt (str): The prompt to send to the API.
+            stream (bool): Whether to stream the response.
+            raw (bool): Whether to return the raw response.
+            optimizer (str): Optimizer to use for the prompt.
+            conversationally (bool): Whether to generate the prompt conversationally.
+
+        Returns:
+            Dict[str, Any]: The API response.
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        payload = {
+            "messages": [
+                {"role": "system", "content": self.system_prompt},
+                {"role": "user", "content": conversation_prompt}
+            ],
+            "model": self.model,
+            "max_tokens": self.max_tokens_to_sample
+        }
+
+        def for_stream():
+            try:
+                response = self.session.post(
+                    self.api_endpoint,
+                    headers=self.headers,
+                    json=payload,
+                    stream=True,
+                    timeout=self.timeout
+                )
+                if not response.ok:
+                    raise exceptions.FailedToGenerateResponseError(
+                        f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                    )
+                streaming_response = ""
+                # Use sanitize_stream with regex-based extraction and filtering (like x0gpt)
+                processed_stream = sanitize_stream(
+                    data=response.iter_content(chunk_size=None),
+                    intro_value=None,
+                    to_json=False,
+                    extract_regexes=[r'0:"(.*?)"'],
+                    skip_regexes=[
+                        r'^f:',
+                        r'^e:',
+                        r'^d:',
+                        r'^\s*$',
+                        r'data:\s*\[DONE\]',
+                        r'event:\s*',
+                        r'^\d+:\s*$',
+                        r'^:\s*$',
+                        r'^\s*[\x00-\x1f]+\s*$',
+                    ],
+                    raw=raw
+                )
+
+                for content_chunk in processed_stream:
+                    if isinstance(content_chunk, bytes):
+                        content_chunk = content_chunk.decode('utf-8', errors='ignore')
+                    if raw:
+                        yield content_chunk
+                    else:
+                        if content_chunk and isinstance(content_chunk, str):
+                            try:
+                                clean_content = content_chunk.encode().decode('unicode_escape')
+                                clean_content = clean_content.replace('\\\\', '\\').replace('\\"', '"')
+                                streaming_response += clean_content
+                                yield dict(text=clean_content)
+                            except (UnicodeDecodeError, UnicodeEncodeError):
+                                streaming_response += content_chunk
+                                yield dict(text=content_chunk)
+
+                self.last_response.update(dict(text=streaming_response))
+                self.conversation.update_chat_history(
+                    prompt, self.get_message(self.last_response)
+                )
+            except CurlError as e:
+                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}")
+            except Exception as e:
+                raise exceptions.FailedToGenerateResponseError(f"An unexpected error occurred ({type(e).__name__}): {e}")
+
+        def for_non_stream():
+            if stream:
+                return for_stream()
+            for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+        raw: bool = False,
+    ) -> Union[str, Generator[str, None, None]]:
+        """
+        Generates a response from the MonoChat API.
+
+        Args:
+            prompt (str): The prompt to send to the API.
+            stream (bool): Whether to stream the response.
+            optimizer (str): Optimizer to use for the prompt.
+            conversationally (bool): Whether to generate the prompt conversationally.
+            raw (bool): Whether to return raw response chunks.
+
+        Returns:
+            str: The API response.
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, raw=raw, optimizer=optimizer, conversationally=conversationally
+            ):
+                if raw:
+                    yield response
+                else:
+                    yield self.get_message(response)
+
+        def for_non_stream():
+            result = self.ask(
+                prompt,
+                False,
+                raw=raw,
+                optimizer=optimizer,
+                conversationally=conversationally,
+            )
+            if raw:
+                return result
+            else:
+                return self.get_message(result)
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """
+        Extracts the message from the API response.
+
+        Args:
+            response (dict): The API response.
+
+        Returns:
+            str: The message content.
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        text = response.get("text", "")
+        return text
+
+if __name__ == "__main__":
+    from rich import print
+    ai = MonoChat(timeout=60)
+    response = ai.chat("In points tell me about humans", stream=True, raw=False)
+    for chunk in response:
+        print(chunk, end="", flush=True)