webscout 8.3.2__py3-none-any.whl → 8.3.4__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/granite.py

@@ -83,10 +83,12 @@ class IBMGranite(Provider):
         self.conversation.history_offset = history_offset
 
     @staticmethod
-    def _granite_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
-        """Extracts content from IBM Granite stream JSON lists [3, "text"]."""
-        if isinstance(chunk, list) and len(chunk) == 2 and chunk[0] == 3 and isinstance(chunk[1], str):
-            return chunk[1]
+    def _granite_extractor(chunk: Union[str, Dict[str, Any], list]) -> Optional[str]:
+        """Extracts content from IBM Granite stream JSON lists [6, "text"] or [3, "text"]."""
+        # Accept both [3, str] and [6, str] as content chunks
+        if isinstance(chunk, list) and len(chunk) == 2 and isinstance(chunk[1], str):
+            if chunk[0] in (3, 6):
+                return chunk[1]
         return None
 
     @staticmethod
@@ -157,73 +159,60 @@ class IBMGranite(Provider):
             payload["thinking"] = True
 
         def for_stream():
-            streaming_text = "" # Initialize outside try block
+            streaming_text = ""
             try:
-                # Use curl_cffi session post with impersonate
                 response = self.session.post(
                     self.api_endpoint, 
-                    # headers are set on the session
                     json=payload, 
                     stream=True, 
                     timeout=self.timeout,
-                    impersonate="chrome110" # Use a common impersonation profile
+                    impersonate="chrome110"
                 )
-                response.raise_for_status() # Check for HTTP errors
-
-                # Use sanitize_stream
+                response.raise_for_status()
                 processed_stream = sanitize_stream(
-                    data=response.iter_content(chunk_size=None), # Pass byte iterator
-                    intro_value=None, # No prefix
-                    to_json=True,     # Stream sends JSON lines (which are lists)
-                    content_extractor=self._granite_extractor, # Use the specific extractor
-                    yield_raw_on_error=False # Skip non-JSON lines or lines where extractor fails
+                    data=response.iter_content(chunk_size=None),
+                    intro_value=None,
+                    to_json=True,
+                    content_extractor=self._granite_extractor,
+                    yield_raw_on_error=False,
+                    raw=raw
                 )
-
                 for content_chunk in processed_stream:
-                    # content_chunk is the string extracted by _granite_extractor
-                    if content_chunk and isinstance(content_chunk, str):
-                        streaming_text += content_chunk
-                        resp = dict(text=content_chunk)
-                        yield resp if not raw else content_chunk
-                
-                # Update history after stream finishes
+                    if raw:
+                        if content_chunk and isinstance(content_chunk, str):
+                            streaming_text += content_chunk
+                        yield content_chunk
+                    else:
+                        if content_chunk and isinstance(content_chunk, str):
+                            streaming_text += content_chunk
+                            resp = dict(text=content_chunk)
+                            yield resp
                 self.last_response = dict(text=streaming_text)
                 self.conversation.update_chat_history(prompt, streaming_text)
-                
-            except CurlError as e: # Catch CurlError
+            except CurlError as e:
                 raise exceptions.ProviderConnectionError(f"Request failed (CurlError): {e}") from e
-            except json.JSONDecodeError as e: # Keep specific JSON error handling
+            except json.JSONDecodeError as e:
                 raise exceptions.InvalidResponseError(f"Failed to decode JSON response: {e}") from e
-            except Exception as e: # Catch other potential exceptions (like HTTPError)
+            except Exception as e:
                 err_text = getattr(e, 'response', None) and getattr(e.response, 'text', '')
-                # Use specific exception type if available, otherwise generic
                 ex_type = exceptions.FailedToGenerateResponseError if not isinstance(e, exceptions.ProviderConnectionError) else type(e)
                 raise ex_type(f"An unexpected error occurred ({type(e).__name__}): {e} - {err_text}") from e
 
-
         def for_non_stream():
-            # Aggregate the stream using the updated for_stream logic
             full_text = ""
             try:
-                # Ensure raw=False so for_stream yields dicts
                 for chunk_data in for_stream():
-                    if isinstance(chunk_data, dict) and "text" in chunk_data:
-                        full_text += chunk_data["text"]
-                    # Handle raw string case if raw=True was passed
-                    elif raw and isinstance(chunk_data, str):
-                         full_text += chunk_data
+                    if raw:
+                        if isinstance(chunk_data, str):
+                            full_text += chunk_data
+                    else:
+                        if isinstance(chunk_data, dict) and "text" in chunk_data:
+                            full_text += chunk_data["text"]
             except Exception as e:
-                 # If aggregation fails but some text was received, use it. Otherwise, re-raise.
-                 if not full_text:
-                     raise exceptions.FailedToGenerateResponseError(f"Failed to get non-stream response: {str(e)}") from e
-
-            # last_response and history are updated within for_stream
-            # Return the final aggregated response dict or raw string
+                if not full_text:
+                    raise exceptions.FailedToGenerateResponseError(f"Failed to get non-stream response: {str(e)}") from e
             return full_text if raw else self.last_response
 
-
-        # Since the API endpoint suggests streaming, always call the stream generator.
-        # The non-stream wrapper will handle aggregation if stream=False.
         return for_stream() if stream else for_non_stream()
 
     def chat(
@@ -232,25 +221,27 @@ class IBMGranite(Provider):
         stream: bool = False,
         optimizer: str = None,
         conversationally: bool = False,
+        raw: bool = False,
     ) -> Union[str, Generator[str, None, None]]:
         """Generate response as a string using chat method"""
         def for_stream_chat():
-            # ask() yields dicts or strings when streaming
             gen = self.ask(
-                prompt, stream=True, raw=False, # Ensure ask yields dicts
+                prompt, stream=True, raw=raw,
                 optimizer=optimizer, conversationally=conversationally
             )
-            for response_dict in gen:
-                yield self.get_message(response_dict) # get_message expects dict
-
+            for response in gen:
+                if raw:
+                    yield response
+                else:
+                    yield self.get_message(response)
         def for_non_stream_chat():
-            # ask() returns dict or str when not streaming
             response_data = self.ask(
-                prompt, stream=False, raw=False, # Ensure ask returns dict
+                prompt, stream=False, raw=raw,
                 optimizer=optimizer, conversationally=conversationally
             )
-            return self.get_message(response_data) # get_message expects dict
-
+            if raw:
+                return response_data if isinstance(response_data, str) else str(response_data)
+            return self.get_message(response_data)
         return for_stream_chat() if stream else for_non_stream_chat()
 
     def get_message(self, response: dict) -> str:
@@ -265,6 +256,6 @@ if __name__ == "__main__":
     ai = IBMGranite(
         thinking=True,
     )
-    response = ai.chat("How many r in strawberry", stream=True)
+    response = ai.chat("How many r in strawberry", stream=True, raw=False)
     for chunk in response:
-        print(chunk, end="", flush=True)
+        print(chunk, end="", flush=True)  # Print each chunk without newline