webscout 8.3__py3-none-any.whl → 8.3.2__py3-none-any.whl

webscout/Litlogger/formats.py

@@ -1,4 +1,13 @@
 DEFAULT_FORMAT = "{time} | {level} | {name} | {message}"
 
+SIMPLE_FORMAT = "{level}: {message}"
+
+DETAILED_FORMAT = "{time} | {level} | {name} | {message} | Thread: {thread} | Process: {process}"
+
+JSON_FORMAT = '{{"time": "{time}", "level": "{level}", "name": "{name}", "message": "{message}"}}'
+
 class LogFormat:
     DEFAULT = DEFAULT_FORMAT
+    SIMPLE = SIMPLE_FORMAT
+    DETAILED = DETAILED_FORMAT
+    JSON = JSON_FORMAT

webscout/Litlogger/handlers.py

@@ -101,3 +101,21 @@ class TCPHandler(Handler):
             return
         with socket.create_connection((self.host, self.port), timeout=5) as sock:
             sock.sendall(message.encode() + b"\n")
+
+class JSONFileHandler(FileHandler):
+    def __init__(self, path: str, level: LogLevel = LogLevel.DEBUG, max_bytes: int = 0, backups: int = 0):
+        super().__init__(path, level, max_bytes, backups)
+
+    def emit(self, message: str, level: LogLevel):
+        # Expect message to be a JSON string or dict
+        if level < self.level:
+            return
+        import json
+        if isinstance(message, dict):
+            log_entry = json.dumps(message)
+        else:
+            log_entry = message
+        self._file.write(log_entry + "\n")
+        self._file.flush()
+        if self.max_bytes and self._file.tell() >= self.max_bytes:
+            self._rotate()

webscout/Litlogger/logger.py

@@ -16,16 +16,58 @@ class Logger:
         handlers: Optional[List[Handler]] = None,
         fmt: str = LogFormat.DEFAULT,  # <--- use LogFormat.DEFAULT
         async_mode: bool = False,
+        include_context: bool = False,  # New flag to include thread/process info
     ):
+        import threading
+        import multiprocessing
+
         self.name = name
         self.level = level
         self.format = fmt
         self.async_mode = async_mode
+        self.include_context = include_context
         self.handlers = handlers or [ConsoleHandler()]
+        self._thread = threading
+        self._multiprocessing = multiprocessing
 
     def _format(self, level: LogLevel, message: str) -> str:
         now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        return self.format.format(time=now, level=level.name, name=self.name, message=message)
+        if self.include_context:
+            thread_name = self._thread.current_thread().name
+            process_id = self._multiprocessing.current_process().pid
+            # Check if format is JSON format
+            if self.format.strip().startswith('{') and self.format.strip().endswith('}'):
+                # Format as JSON string with extra fields
+                return self.format.format(
+                    time=now,
+                    level=level.name,
+                    name=self.name,
+                    message=message,
+                    thread=thread_name,
+                    process=process_id
+                )
+            else:
+                # For non-JSON formats, add thread and process info if placeholders exist
+                try:
+                    return self.format.format(
+                        time=now,
+                        level=level.name,
+                        name=self.name,
+                        message=message,
+                        thread=thread_name,
+                        process=process_id
+                    )
+                except KeyError:
+                    # If thread/process placeholders not in format, append them manually
+                    base = self.format.format(time=now, level=level.name, name=self.name, message=message)
+                    return f"{base} | Thread: {thread_name} | Process: {process_id}"
+        else:
+            return self.format.format(time=now, level=level.name, name=self.name, message=message)
+
+    def set_format(self, fmt: str, include_context: bool = False):
+        """Dynamically change the log format and context inclusion."""
+        self.format = fmt
+        self.include_context = include_context
 
     def _should_log(self, level: LogLevel) -> bool:
         return level >= self.level

webscout/Provider/AISEARCH/genspark_search.py

@@ -201,12 +201,12 @@ class Genspark(AISearch):
                     json={},
                     stream=True,
                     timeout=self.timeout,
-                ) as SearchResponse:
-                    if not SearchResponse.ok:
+                ) as resp:
+                    if not resp.ok:
                         raise exceptions.APIConnectionError(
-                            f"Failed to generate SearchResponse - ({SearchResponse.status_code}, {SearchResponse.reason}) - {SearchResponse.text}"
+                            f"Failed to generate SearchResponse - ({resp.status_code}, {resp.reason}) - {resp.text}"
                         )
-                    for line in SearchResponse.iter_lines(decode_unicode=True):
+                    for line in resp.iter_lines(decode_unicode=True):
                         if not line or not line.startswith("data: "):
                             continue
                         try:
@@ -287,7 +287,7 @@ class Genspark(AISearch):
                                     yield processed_event_payload
                         except json.JSONDecodeError:
                             continue
-            except cloudscraper.exceptions as e:
+            except cloudscraper.exceptions.CloudflareException as e:
                 raise exceptions.APIConnectionError(f"Request failed due to Cloudscraper issue: {e}")
             except requests.exceptions.RequestException as e:
                 raise exceptions.APIConnectionError(f"Request failed: {e}")
@@ -315,8 +315,8 @@ if __name__ == "__main__":
     from rich import print
     ai = Genspark()
     try:
-        SearchResponse = ai.search(input(">>> "), stream=True, raw=False)
-        for chunk in SearchResponse:
+        search_result_stream = ai.search(input(">>> "), stream=True, raw=False)
+        for chunk in search_result_stream:
             print(chunk, end="", flush=True)
     except KeyboardInterrupt:
         print("\nSearch interrupted by user.")

webscout/Provider/AISEARCH/scira_search.py

@@ -45,12 +45,13 @@ class Scira(AISearch):
     AVAILABLE_MODELS = {
         "scira-default": "Grok3-mini", # thinking model
         "scira-grok-3": "Grok3",
-        "scira-anthropic": "Sonnet 3.7 thinking",
+        "scira-anthropic": "Claude 4 Sonnet",
+        "scira-anthropic-thinking": "Claude 4 Sonnet Thinking", # thinking model
         "scira-vision" : "Grok2-Vision", # vision model
         "scira-4o": "GPT4o",
         "scira-qwq": "QWQ-32B",
         "scira-o4-mini": "o4-mini",
-        "scira-google": "gemini 2.5 flash",
+        "scira-google": "gemini 2.5 flash Thinking", # thinking model
         "scira-google-pro": "gemini 2.5 pro",
         "scira-llama-4": "llama 4 Maverick",
     }

webscout/Provider/GeminiProxy.py

@@ -0,0 +1,140 @@
+from typing import Any, Dict, Optional, Union, Generator
+import requests
+import base64
+from webscout.litagent import LitAgent
+from webscout.AIutel import Optimizers, AwesomePrompts
+from webscout.AIutel import Conversation
+from webscout.AIbase import Provider
+from webscout import exceptions
+
+class GeminiProxy(Provider):
+    """
+    GeminiProxy is a provider class for interacting with the Gemini API via a proxy endpoint.
+    """
+    AVAILABLE_MODELS = [
+        "gemini-2.0-flash-lite",
+        "gemini-2.0-flash",
+        "gemini-2.5-pro-preview-06-05",
+        "gemini-2.5-pro-preview-05-06",
+        "gemini-2.5-flash-preview-04-17",
+        "gemini-2.5-flash-preview-05-20",
+
+    ]
+
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 2048,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        model: str = "gemini-2.0-flash-lite",
+        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.base_url = "https://us-central1-infinite-chain-295909.cloudfunctions.net/gemini-proxy-staging-v1"
+        self.agent = LitAgent()
+        self.fingerprint = self.agent.generate_fingerprint(browser)
+        self.headers = self.fingerprint.copy()
+        self.session = requests.Session()
+        self.session.headers.update(self.headers)
+        self.session.proxies.update(proxies)
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.timeout = timeout
+        self.last_response = {}
+        self.model = model
+        self.system_prompt = system_prompt
+        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 get_image(self, img_url):
+        try:
+            response = self.session.get(img_url, stream=True, timeout=self.timeout)
+            response.raise_for_status()
+            mime_type = response.headers.get("content-type", "application/octet-stream")
+            data = base64.b64encode(response.content).decode("utf-8")
+            return {"mime_type": mime_type, "data": data}
+        except Exception as e:
+            raise exceptions.FailedToGenerateResponseError(f"Error fetching image: {e}")
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+        img_url: Optional[str] = None,
+    ) -> Union[Dict[str, Any], Generator]:
+        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}")
+        parts = []
+        if img_url:
+            parts.append({"inline_data": self.get_image(img_url)})
+        parts.append({"text": conversation_prompt})
+        request_data = {
+            "model": self.model,
+            "contents": [{"parts": parts}]
+        }
+        def for_non_stream():
+            try:
+                response = self.session.post(self.base_url, json=request_data, headers=self.headers, timeout=self.timeout)
+                response.raise_for_status()
+                data = response.json()
+                self.last_response = data
+                self.conversation.update_chat_history(prompt, self.get_message(data))
+                return data
+            except Exception as e:
+                raise exceptions.FailedToGenerateResponseError(f"Error during chat request: {e}")
+        # Gemini proxy does not support streaming, so only non-stream
+        return for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+        img_url: Optional[str] = None,
+    ) -> str:
+        data = self.ask(prompt, stream=stream, optimizer=optimizer, conversationally=conversationally, img_url=img_url)
+        return self.get_message(data)
+
+    def get_message(self, response: dict) -> str:
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        try:
+            return response['candidates'][0]['content']['parts'][0]['text']
+        except Exception:
+            return str(response)
+
+if __name__ == "__main__":
+    ai = GeminiProxy(timeout=30, model="gemini-2.5-flash-preview-05-20")
+    response = ai.chat("write a poem about AI")
+    print(response)

webscout/Provider/LambdaChat.py

@@ -23,11 +23,17 @@ class LambdaChat(Provider):
         "deepseek-llama3.3-70b",
         "apriel-5b-instruct",
         "deepseek-r1",
+        "deepseek-v3-0324",
+        "deepseek-r1-0528",
         "hermes-3-llama-3.1-405b-fp8",
         "llama3.1-nemotron-70b-instruct",
         "lfm-40b",
         "llama3.3-70b-instruct-fp8",
-        "qwen25-coder-32b-instruct"
+        "qwen25-coder-32b-instruct",
+        "qwen3-32b-fp8",
+        "llama-4-maverick-70b-128e-instruct-fp8",
+        "llama-4-scout-17b-16e-instruct"
+
     ]
     
     def __init__(

webscout/Provider/MCPCore.py

@@ -1,5 +1,7 @@
 import json
 import uuid
+import random
+import string
 from typing import Any, Dict, Generator, Union
 
 # Use curl_cffi for requests
@@ -21,37 +23,37 @@ class MCPCore(Provider):
 
     # Add more models if known, starting with the one from the example
     AVAILABLE_MODELS = [
-        "google/gemma-7b-it",
-        "deepseek-ai/deepseek-coder-33b-instruct",
-        "deepseek-ai/DeepSeek-R1",
-        "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B",
-        "deepseek-ai/DeepSeek-v3-0324",
-        "fixie-ai/ultravox-v0_4_1-llama-3_1-8b",
-        "meta-llama/Llama-3.3-70B-Instruct",
-        "meta-llama/Llama-4-Maverick-Instruct",
-        "mistralai/Mistral-7B-Instruct-v0.2",
-        "qwen-max-latest",
-        "qwen-plus-latest",
-        "qwen2.5-coder-32b-instruct",
-        "qwen-turbo-latest",
-        "qwen2.5-14b-instruct-1m",
-        "GLM-4-32B",
-        "Z1-32B",
-        "Z1-Rumination",
-        "arena-model",
-        "qvq-72b-preview-0310",
-        "qwq-32b",
-        "qwen3-235b-a22b",
-        "qwen3-30b-a3b",
-        "qwen3-32b",
-        "deepseek-flash",
-        "@cf/meta/llama-4-scout-17b-16e-instruct",
-        "任务专用",
+        "@cf/deepseek-ai/deepseek-math-7b-instruct",
+        "@cf/deepseek-ai/deepseek-r1-distill-qwen-32b",
+        "@cf/defog/sqlcoder-7b-2",
+        "@cf/fblgit/una-cybertron-7b-v2-bf16",
+        "@cf/google/gemma-3-12b-it",
+        "@cf/meta/llama-2-7b-chat-int8",
+        "@hf/thebloke/llama-2-13b-chat-awq",
+        "@hf/thebloke/llamaguard-7b-awq",
+        "@hf/thebloke/mistral-7b-instruct-v0.1-awq",
+        "@hf/thebloke/neural-chat-7b-v3-1-awq",
+        "anthropic/claude-3.5-haiku",
+        "anthropic/claude-3.5-sonnet",
+        "anthropic/claude-3.7-sonnet",
+        "anthropic/claude-3.7-sonnet:thinking",
+        "anthropic/claude-opus-4",
+        "anthropic/claude-sonnet-4",
+        "openai/chatgpt-4o-latest",
+        "openai/gpt-3.5-turbo",
+        "openai/gpt-4.1",
+        "openai/gpt-4.1-mini",
+        "openai/gpt-4.1-nano",
+        "openai/gpt-4o-mini-search-preview",
+        "openai/gpt-4o-search-preview",
+        "openai/o1-pro",
+        "openai/o3-mini",
+        "sarvam-m",
+        "x-ai/grok-3-beta",
     ]
 
     def __init__(
         self,
-        cookies_path: str,
         is_conversation: bool = True,
         max_tokens: int = 2048,
         timeout: int = 60,
@@ -70,46 +72,22 @@ class MCPCore(Provider):
 
         self.api_endpoint = "https://chat.mcpcore.xyz/api/chat/completions"
         
-        # Cache the user-agent at the class level
-        if not hasattr(MCPCore, '_cached_user_agent'):
-            MCPCore._cached_user_agent = LitAgent().random()
         self.model = model
         self.system_prompt = system_prompt
-        self.cookies_path = cookies_path
-        self.cookie_string, self.token = self._load_cookies()
 
         # Initialize curl_cffi Session
         self.session = Session()
 
         # Set up headers based on the provided request
         self.headers = {
-            'authority': 'chat.mcpcore.xyz',
-            'accept': '*/*',
-            'accept-language': 'en-US,en;q=0.9,en-IN;q=0.8',
-            **({'authorization': f'Bearer {self.token}'} if self.token else {}),
-            'content-type': 'application/json',
-            'dnt': '1',
+            **LitAgent().generate_fingerprint(),
             'origin': 'https://chat.mcpcore.xyz',
             'referer': 'https://chat.mcpcore.xyz/',
-            'priority': 'u=1, i',
-            'sec-ch-ua': '"Microsoft Edge";v="135", "Not-A.Brand";v="8", "Chromium";v="135"',
-            'sec-ch-ua-mobile': '?0',
-            'sec-ch-ua-platform': '"Windows"',
-            'sec-fetch-dest': 'empty',
-            'sec-fetch-mode': 'cors',
-            'sec-fetch-site': 'same-origin',
-            'sec-gpc': '1',
-            'user-agent': self._cached_user_agent,
         }
 
         # Apply headers, proxies, and cookies to the session
         self.session.headers.update(self.headers)
         self.session.proxies = proxies
-        self.cookies = {
-            'token': self.token,
-        }
-        for name, value in self.cookies.items():
-            self.session.cookies.set(name, value, domain="chat.mcpcore.xyz")
 
         # Provider settings
         self.is_conversation = is_conversation
@@ -136,27 +114,54 @@ class MCPCore(Provider):
         )
         self.conversation.history_offset = history_offset
 
-    def _load_cookies(self) -> tuple[str, str]:
-        """Load cookies from a JSON file and build a cookie header string."""
+        # Token handling: always auto-fetch token, no cookies logic
+        self.token = self._auto_fetch_token()
+
+        # Set the Authorization header for the session
+        self.session.headers.update({
+            'authorization': f'Bearer {self.token}',
+        })
+
+    def _auto_fetch_token(self):
+        """Automatically fetch a token from the signup endpoint."""
+        session = Session()
+        def random_string(length=8):
+            return ''.join(random.choices(string.ascii_lowercase, k=length))
+        name = random_string(6)
+        email = f"{random_string(8)}@gmail.com"
+        password = email
+        profile_image_url = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAABkCAYAAABw4pVUAAAAAXNSR0IArs4c6QAAAkRJREFUeF7tmDFOw0AUBdcSiIaKM3CKHIQ7UHEISq5AiUTFHYC0XADoTRsJEZFEjhFIaYAim92fjGFS736/zOTZzjavl0d98oMh0CgE4+IriEJYPhQC86EQhdAIwPL4DFEIjAAsjg1RCIwALI4NUQiMACyODVEIjAAsjg1RCIwALI4NUQiMACyODVEIjAAsjg1RCIwALI4NUQiMACyODVEIjAAsjg1RCIwALI4NUQiMACyODVEIjAAsjg1RCIwALI4NUQiMACyODVEIjAAsjg1RCIwALI4NUQiMACyODVEIjAAsjg2BCfkAIqwAA94KZ/EAAAAASUVORK5CYII="
+        payload = {
+            "name": name,
+            "email": email,
+            "password": password,
+            "profile_image_url": profile_image_url
+        }
+        headers = {
+            **LitAgent().generate_fingerprint(),
+            'origin': 'https://chat.mcpcore.xyz',
+            'referer': 'https://chat.mcpcore.xyz/auth',
+        }
         try:
-            with open(self.cookies_path, "r") as f:
-                cookies = json.load(f)
-            cookie_string = "; ".join(
-                f"{cookie['name']}={cookie['value']}" for cookie in cookies if 'name' in cookie and 'value' in cookie
-            )
-            token = next(
-                (cookie.get("value") for cookie in cookies if cookie.get("name") == "token"),
-                "",
-            )
-            return cookie_string, token
-        except FileNotFoundError:
-            raise exceptions.FailedToGenerateResponseError(
-                f"Error: Cookies file not found at {self.cookies_path}!"
-            )
-        except json.JSONDecodeError:
-            raise exceptions.FailedToGenerateResponseError(
-                f"Error: Invalid JSON format in cookies file: {self.cookies_path}!"
+            resp = session.post(
+                "https://chat.mcpcore.xyz/api/v1/auths/signup",
+                headers=headers,
+                json=payload,
+                timeout=30,
+                impersonate="chrome110"
             )
+            if resp.ok:
+                data = resp.json()
+                token = data.get("token")
+                if token:
+                    return token
+                # fallback: try to get from set-cookie
+                set_cookie = resp.headers.get("set-cookie", "")
+                if "token=" in set_cookie:
+                    return set_cookie.split("token=")[1].split(";")[0]
+            raise exceptions.FailedToGenerateResponseError(f"Failed to auto-fetch token: {resp.status_code} {resp.text}")
+        except Exception as e:
+            raise exceptions.FailedToGenerateResponseError(f"Token auto-fetch failed: {e}")
 
     def ask(
         self,
@@ -286,19 +291,17 @@ class MCPCore(Provider):
         assert isinstance(response, dict), "Response should be of dict data-type only"
         return response.get("text", "")
 
-# Example usage (remember to create a cookies.json file)
+# Example usage (no cookies file needed)
 if __name__ == "__main__":
     from rich import print
 
-    cookies_file_path = "cookies.json"
-
     print("-" * 80)
     print(f"{'Model':<50} {'Status':<10} {'Response'}")
     print("-" * 80)
 
     for model in MCPCore.AVAILABLE_MODELS:
         try:
-            test_ai = MCPCore(cookies_path=cookies_file_path, model=model, timeout=60)
+            test_ai = MCPCore(model=model, timeout=60)
             response = test_ai.chat("Say 'Hello' in one word", stream=True)
             response_text = ""
             # Accumulate the response text without printing in the loop