webscout 8.3.6__py3-none-any.whl → 8.3.7__py3-none-any.whl

webscout/Provider/cerebras.py

@@ -1,6 +1,6 @@
-
 import re
 
+
 # Import trio before curl_cffi to prevent eventlet socket monkey-patching conflicts
 # See: https://github.com/python-trio/trio/issues/3015
 try:
@@ -28,16 +28,69 @@ class Cerebras(Provider):
     """
     A class to interact with the Cerebras API using a cookie for authentication.
     """
-
+    required_auth = True
     AVAILABLE_MODELS = [
         "qwen-3-coder-480b",
         "qwen-3-235b-a22b-instruct-2507",
         "qwen-3-235b-a22b-thinking-2507",
         "qwen-3-32b",
         "llama-3.3-70b",
-        "llama-4-maverick-17b-128e-instruct"
+        "llama-4-maverick-17b-128e-instruct",
+        "gpt-oss-120b",
+        "llama-4-scout-17b-16e-instruct",
+        "llama3.1-8b"
     ]
 
+    @classmethod
+    def get_models(cls, api_key: str = None):
+        """Fetch available models from Cerebras API.
+        
+        Args:
+            api_key (str, optional): Cerebras API key. If not provided, returns default models.
+            
+        Returns:
+            list: List of available model IDs
+        """
+        if not api_key:
+            return cls.AVAILABLE_MODELS
+            
+        try:
+            # Use a temporary curl_cffi session for this class method
+            temp_session = Session()
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {api_key}",
+            }
+            
+            response = temp_session.get(
+                "https://api.cerebras.ai/v1/models",
+                headers=headers,
+                impersonate="chrome120"
+            )
+            
+            if response.status_code != 200:
+                return cls.AVAILABLE_MODELS
+                
+            data = response.json()
+            if "data" in data and isinstance(data["data"], list):
+                return [model['id'] for model in data['data']]
+            return cls.AVAILABLE_MODELS
+            
+        except Exception:
+            # Fallback to default models list if fetching fails
+            return cls.AVAILABLE_MODELS
+
+    @classmethod
+    def update_available_models(cls, api_key=None):
+        """Update the available models list from Cerebras API"""
+        try:
+            models = cls.get_models(api_key)
+            if models and len(models) > 0:
+                cls.AVAILABLE_MODELS = models
+        except Exception:
+            # Fallback to default models list if fetching fails
+            pass
+
     def __init__(
         self,
         cookie_path: str = None,
@@ -56,12 +109,6 @@ class Cerebras(Provider):
         temperature: float = 0.7,
         top_p: float = 0.8,
     ):
-        # Validate model choice
-        if model not in self.AVAILABLE_MODELS:
-            raise ValueError(
-                f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}"
-            )
-
         # Initialize basic settings first
         self.timeout = timeout
         self.model = model
@@ -89,6 +136,15 @@ class Cerebras(Provider):
         else:
             raise ValueError("Either api_key must be provided or cookie_path must be specified")
 
+        # Update available models from API
+        self.update_available_models(self.api_key)
+
+        # Validate model choice after updating models
+        if model not in self.AVAILABLE_MODELS:
+            raise ValueError(
+                f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}"
+            )
+
         # Initialize optimizers
         self.__available_optimizers = (
             method
@@ -112,6 +168,56 @@ class Cerebras(Provider):
         # Apply proxies to the session
         self.session.proxies = proxies
 
+    @classmethod
+    def get_models(cls, api_key: str = None):
+        """Fetch available models from Cerebras API.
+        
+        Args:
+            api_key (str, optional): Cerebras API key. If not provided, returns default models.
+            
+        Returns:
+            list: List of available model IDs
+        """
+        if not api_key:
+            return cls.AVAILABLE_MODELS
+            
+        try:
+            # Use a temporary curl_cffi session for this class method
+            temp_session = Session()
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {api_key}",
+            }
+            
+            response = temp_session.get(
+                "https://api.cerebras.ai/v1/models",
+                headers=headers,
+                impersonate="chrome120"
+            )
+            
+            if response.status_code != 200:
+                return cls.AVAILABLE_MODELS
+                
+            data = response.json()
+            if "data" in data and isinstance(data["data"], list):
+                return [model['id'] for model in data['data']]
+            return cls.AVAILABLE_MODELS
+            
+        except Exception:
+            # Fallback to default models list if fetching fails
+            return cls.AVAILABLE_MODELS
+
+    @classmethod
+    def update_available_models(cls, api_key=None):
+        """Update the available models list from Cerebras API"""
+        try:
+            models = cls.get_models(api_key)
+            if models and len(models) > 0:
+                cls.AVAILABLE_MODELS = models
+        except Exception:
+            # Fallback to default models list if fetching fails
+            pass
+
     # Rest of the class implementation remains the same...
     @staticmethod
     def extract_query(text: str) -> str:

webscout/Provider/chatglm.py

@@ -1,9 +1,7 @@
 from curl_cffi import CurlError
 from curl_cffi.requests import Session
-import json
 from typing import Any, Dict, Optional, Generator, List, Union
 import uuid
-
 from webscout.AIutel import Optimizers
 from webscout.AIutel import Conversation
 from webscout.AIutel import AwesomePrompts, sanitize_stream # Import sanitize_stream
@@ -11,11 +9,38 @@ from webscout.AIbase import Provider
 from webscout import exceptions
 from webscout.litagent import LitAgent
 
+
 class ChatGLM(Provider):
     """
-    A class to interact with the ChatGLM API.
+    A class to interact with the Z.AI Chat API (GLM-4.5).
     """
+    required_auth = False
+    url = "https://chat.z.ai"
+    # Model nickname mapping system
+    MODEL_MAPPING = {
+        "glm-4.5V": "glm-4.5v",
+        "glm-4-32B": "main_chat",
+        "glm-4.5-Air": "0727-106B-API",
+        "glm-4.5": "0727-360B-API",
+        # Add more nicknames as needed
+    }
+    # Reverse mapping: API format to nickname
+    GLM_TO_MODEL = {v: k for k, v in MODEL_MAPPING.items()}
+    AVAILABLE_MODELS = list(MODEL_MAPPING.keys()) + list(GLM_TO_MODEL.keys()) + ["0727-106B-API", "0727-360B-API", "glm-4.5v", "main_chat"]
 
+    @classmethod
+    def _resolve_model(cls, model: str) -> str:
+        """
+        Resolve a model nickname or API name to the API format.
+        """
+        if model in cls.GLM_TO_MODEL:
+            return model
+        if model in cls.MODEL_MAPPING:
+            return cls.MODEL_MAPPING[model]
+        # fallback to direct API name if present
+        if model in ["0727-106B-API", "0727-360B-API", "glm-4.5v", "main_chat"]:
+            return model
+        raise ValueError(f"Invalid model: {model}. Choose from: {cls.AVAILABLE_MODELS}")
     def __init__(
         self,
         is_conversation: bool = True,
@@ -27,36 +52,32 @@ class ChatGLM(Provider):
         proxies: dict = {},
         history_offset: int = 10250,
         act: str = None,
-        plus_model: bool = True,
+        model: str = "0727-106B-API",
     ):
-        """Initializes the ChatGLM API client."""
-        self.session = Session() # Use curl_cffi Session
+        """Initializes the Z.AI Chat API client."""
+        self.session = Session()
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
-        self.api_endpoint = "https://chatglm.cn/chatglm/mainchat-api/guest/stream"
-        self.stream_chunk_size = 64
         self.timeout = timeout
         self.last_response = {}
-        self.plus_model = plus_model
         self.headers = {
             'Accept-Language': 'en-US,en;q=0.9',
             'App-Name': 'chatglm',
-            'Authorization': 'undefined',
             'Content-Type': 'application/json',
-            'Origin': 'https://chatglm.cn',
+            'Origin': self.url,
             'User-Agent': LitAgent().random(),
             'X-App-Platform': 'pc',
             'X-App-Version': '0.0.1',
-            'X-Device-Id': '', #Will be generated each time
             'Accept': 'text/event-stream',
         }
+        self.api_endpoint = f"{self.url}/api/chat/completions" 
         self.__available_optimizers = (
             method
             for method in dir(Optimizers)
             if callable(getattr(Optimizers, method)) and not method.startswith("__")
         )
         self.session.headers.update(self.headers)
-        Conversation.intro = ( # type: ignore
+        Conversation.intro = (
             AwesomePrompts().get_act(
                 act, raise_not_found=True, default=None, case_insensitive=True
             )
@@ -67,16 +88,26 @@ class ChatGLM(Provider):
             is_conversation, self.max_tokens_to_sample, filepath, update_file
         )
         self.conversation.history_offset = history_offset
-        self.session.proxies = proxies # Assign proxies directly
+        self.session.proxies = proxies
+        # Use nickname resolution for model
+        self.model = self._resolve_model(model)
+
+    def _get_api_key(self):
+        if not hasattr(self, 'api_key') or not self.api_key:
+            response = self.session.get(f"{self.url}/api/v1/auths/")
+            self.api_key = response.json().get("token")
+        return self.api_key
+
+    def _get_cookie(self):
+        """Get authentication cookie from the site"""
+        if not hasattr(self, 'cookie') or not self.cookie:
+            response = self.session.get(f"{self.url}/")
+            self.cookie = response.headers.get('Set-Cookie', '')
+        return self.cookie
+
+
+    # _zai_extractor removed; use extract_regexes in sanitize_stream
 
-    @staticmethod
-    def _chatglm_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
-        """Extracts content from ChatGLM stream JSON objects."""
-        if isinstance(chunk, dict):
-            parts = chunk.get('parts', [])
-            if parts and isinstance(parts[0].get('content'), list) and parts[0]['content']:
-                return parts[0]['content'][0].get('text')
-        return None
 
     def ask(
         self,
@@ -86,13 +117,14 @@ class ChatGLM(Provider):
         optimizer: str = None,
         conversationally: bool = False,
     ) -> Union[Dict[str, Any], Generator[Any, None, None]]:
-        """Chat with AI
+        """Chat with Z.AI API
         Args:
             prompt (str): Prompt to be sent.
             stream (bool, optional): Flag for streaming response. Defaults to False.
             raw (bool, optional): Stream back raw response as received. Defaults to False.
-            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            optimizer (str, optional): Prompt optimizer name. Defaults to None.
             conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+            model (str, optional): Model name. Defaults to None.
         Returns:
             Union[Dict, Generator[Dict, None, None]]: Response generated
         """
@@ -106,110 +138,165 @@ class ChatGLM(Provider):
                 raise exceptions.FailedToGenerateResponseError(
                     f"Optimizer is not one of {self.__available_optimizers}"
                 )
-        device_id = str(uuid.uuid4()).replace('-', '')
-        self.session.headers.update({'X-Device-Id': device_id})
+        api_key = self._get_api_key()
         payload = {
-            "assistant_id": "65940acff94777010aa6b796",
-            "conversation_id": "",
-            "meta_data": {
-                "if_plus_model": self.plus_model,
-                "is_test": False,
-                "input_question_type": "xxxx",
-                "channel": "",
-                "draft_id": "",
-                "quote_log_id": "",
-                "platform": "pc",
-            },
+            "stream": True,
+            "model": self.model,  # Already resolved to API format
             "messages": [
-                {
-                    "role": "user",
-                    "content": [{"type": "text", "text": conversation_prompt}],
-                }
+                {"role": "user", "content": conversation_prompt}
             ],
+            "params": {},
+            "features": {"image_generation": False, "web_search": False, "auto_web_search": False, "preview_mode": True, "flags": [], "features": [{"type": "mcp", "server": "vibe-coding", "status": "hidden"}, {"type": "mcp", "server": "ppt-maker", "status": "hidden"}, {"type": "mcp", "server": "image-search", "status": "hidden"}], "enable_thinking": True},
+            "actions": [],
+            "tags": [],
+            "chat_id": "local",
+            "id": str(uuid.uuid4())
         }
 
         def for_stream():
-            streaming_text = "" # Initialize outside try block
-            last_processed_content = "" # Track the last processed content
+            streaming_text = ""
             try:
+                cookie = self._get_cookie()
                 response = self.session.post(
-                    self.api_endpoint, json=payload, stream=True, timeout=self.timeout,
-                    impersonate="chrome120" # Add impersonate
+                    self.api_endpoint,
+                    json=payload,
+                    stream=True,
+                    timeout=self.timeout,
+                    impersonate="chrome120",
+                    headers={
+                        "Authorization": f"Bearer {api_key}",
+                        "x-fe-version": "prod-fe-1.0.70",
+                    }
                 )
                 response.raise_for_status()
 
-                # Use sanitize_stream
+                def glm_content_extractor(chunk):
+                    if not isinstance(chunk, dict) or chunk.get("type") != "chat:completion":
+                        return None
+                    data = chunk.get("data", {})
+                    phase = data.get("phase")
+                    usage = data.get("usage")
+                    if usage:
+                        return None
+                    delta_content = data.get("delta_content")
+                    if delta_content:
+                        if phase == "thinking":
+                            # Remove details/summary tags if present
+                            split_text = delta_content.split("</summary>\n>")[-1]
+                            return {"reasoning_content": split_text}
+                        elif phase == "answer":
+                            return {"content": delta_content}
+                        else:
+                            return {"content": delta_content}
+                    return None
+
                 processed_stream = sanitize_stream(
-                    data=response.iter_content(chunk_size=None), # Pass byte iterator
+                    data=response.iter_content(chunk_size=None),
                     intro_value="data:",
-                    to_json=True,     # Stream sends JSON
-                    content_extractor=self._chatglm_extractor, # Use the specific extractor
-                    yield_raw_on_error=False # Skip non-JSON lines or lines where extractor fails
+                    to_json=True,
+                    content_extractor=glm_content_extractor,
+                    yield_raw_on_error=False,
+                    raw=False
                 )
-
-                for current_full_text in processed_stream:
-                    # current_full_text is the full text extracted by _chatglm_extractor
-                    if current_full_text and isinstance(current_full_text, str):
-                        new_text = current_full_text[len(last_processed_content):]
-                        if new_text: # Check for new content
-                            streaming_text += new_text
-                            last_processed_content = current_full_text # Update tracker
-                            yield new_text if raw else dict(text=new_text)
-
+                last_content = ""
+                last_reasoning = ""
+                in_think = False
+                for chunk in processed_stream:
+                    if not chunk:
+                        continue
+                    content = chunk.get('content') if isinstance(chunk, dict) else None
+                    reasoning = chunk.get('reasoning_content') if isinstance(chunk, dict) else None
+                    # Handle reasoning_content with <think> tags
+                    if reasoning and reasoning != last_reasoning:
+                        if not in_think:
+                            yield "<think>\n\n"
+                            in_think = True
+                        yield reasoning
+                        last_reasoning = reasoning
+                    # If we were in <think> and now have new content, close <think>
+                    if in_think and content and content != last_content:
+                        yield "\n</think>\n\n"
+                        in_think = False
+                    # Handle normal content
+                    if content and content != last_content:
+                        yield content
+                        streaming_text += content
+                        last_content = content
+                if not raw:
+                    self.last_response = {"text": content}
+                    self.conversation.update_chat_history(prompt, streaming_text)
             except CurlError as e:
-                raise exceptions.ProviderConnectionError(f"Request failed (CurlError): {e}") from e
+                raise exceptions.APIConnectionError(f"Request failed (CurlError): {e}") from e
             except Exception as e:
                 raise exceptions.FailedToGenerateResponseError(f"An unexpected error occurred ({type(e).__name__}): {e}") from e
-            finally:
-                # Update history after stream finishes or fails
-                if streaming_text:
-                    self.last_response.update(dict(text=streaming_text))
-                    self.conversation.update_chat_history(
-                        prompt, self.get_message(self.last_response)
-                    )
 
         def for_non_stream():
-            for _ in for_stream():
-                pass
-            return self.last_response
+            full_text = ""
+            try:
+                for chunk_data in for_stream():
+                    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 not full_text:
+                    raise exceptions.FailedToGenerateResponseError(f"Failed to get non-stream response: {str(e)}") from e
+            self.last_response = {"text": full_text}
+            return full_text if raw else 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]]:
         """Generate response `str`"""
 
         def for_stream():
             for response in self.ask(
-                prompt, True, optimizer=optimizer, conversationally=conversationally
+                prompt, True, raw=raw, optimizer=optimizer, conversationally=conversationally
             ):
-                yield self.get_message(response)
+                if raw:
+                    yield response
+                else:
+                    # Only call get_message on dicts, yield str directly
+                    if isinstance(response, dict):
+                        yield self.get_message(response)
+                    elif isinstance(response, str):
+                        yield response
 
         def for_non_stream():
-            return self.get_message(
-                self.ask(
-                    prompt,
-                    False,
-                    optimizer=optimizer,
-                    conversationally=conversationally,
-                )
+            result = self.ask(
+                prompt,
+                False,
+                raw=raw,
+                optimizer=optimizer,
+                conversationally=conversationally,
             )
+            if raw:
+                return result if isinstance(result, str) else self.get_message(result)
+            else:
+                return self.get_message(result)
 
         return for_stream() if stream else for_non_stream()
 
+
     def get_message(self, response: dict) -> str:
         """Retrieves message only from response"""
         assert isinstance(response, dict), "Response should be of dict data-type only"
-        return response["text"]
+        return response.get("text", "")
+
 
 
 if __name__ == "__main__":
     from rich import print
-    ai = ChatGLM()
-    response = ai.chat(input(">>> "), stream=True)
+    ai = ChatGLM(model="glm-4-32B")
+    response = ai.chat("hi", stream=True, raw=False)
     for chunk in response:
         print(chunk, end="", flush=True)

webscout/Provider/cleeai.py

@@ -1,5 +1,4 @@
 import requests
-import json
 from uuid import uuid4
 
 from webscout.AIutel import Optimizers
@@ -12,7 +11,7 @@ class Cleeai(Provider):
     """
     A class to interact with the Cleeai.com API.
     """
-
+    required_auth = False
     def __init__(
         self,
         is_conversation: bool = True,

webscout/Provider/deepseek_assistant.py

@@ -31,7 +31,7 @@ class DeepSeekAssistant(Provider):
     """
 
     AVAILABLE_MODELS = ["V3 model", "R1 model"]
-
+    required_auth = False
     @staticmethod
     def _deepseek_assistant_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
         """Extracts content from DeepSeek Assistant stream JSON objects."""

webscout/Provider/elmo.py

@@ -15,7 +15,7 @@ class Elmo(Provider):
     """
     A class to interact with the Elmo.chat API.
     """
-
+    required_auth = False
     def __init__(
         self,
         is_conversation: bool = True,

webscout/Provider/geminiapi.py

@@ -19,7 +19,7 @@ class GEMINIAPI(Provider):
     """
     A class to interact with the Gemini API using the google-generativeai library.
     """
-
+    required_auth = True
     def __init__(
         self,
         api_key,

webscout/Provider/granite.py

@@ -13,7 +13,7 @@ class IBMGranite(Provider):
     A class to interact with the IBM Granite API (accessed via d18n68ssusgr7r.cloudfront.net)
     using Lit agent for the user agent.
     """
-
+    required_auth = False
     AVAILABLE_MODELS = ["granite-3-8b-instruct", "granite-3-2-8b-instruct", "granite-3-3-8b-instruct"]
 
     def __init__(

webscout/Provider/hermes.py

@@ -2,20 +2,18 @@ from curl_cffi.requests import Session
 from curl_cffi import CurlError
 import json
 from typing import Union, Any, Dict, Generator, Optional
-
 from webscout.AIutel import Optimizers
 from webscout.AIutel import Conversation, sanitize_stream # Import sanitize_stream
 from webscout.AIutel import AwesomePrompts
 from webscout.AIbase import Provider
 from webscout import exceptions
-from webscout.litagent import LitAgent
 class NousHermes(Provider):
     """
     A class to interact with the Hermes API.
     """
 
     AVAILABLE_MODELS = ["Hermes-3-Llama-3.1-70B", "Hermes-3-Llama-3.1-8B"]
-
+    required_auth = False
     def __init__(
         self,
         cookies_path: str,

webscout/Provider/julius.py

@@ -12,6 +12,7 @@ from typing import Union, Any, AsyncGenerator, Dict
 
 
 class Julius(Provider):
+    required_auth = True
     AVAILABLE_MODELS = [
         "Llama 3",
         "GPT-4o",

webscout/Provider/learnfastai.py

@@ -16,7 +16,7 @@ class LearnFast(Provider):
     """
     A class to interact with the LearnFast.ai API.
     """
-
+    required_auth = False
     def __init__(
         self,
         is_conversation: bool = True,

webscout/Provider/llama3mitril.py

@@ -13,7 +13,7 @@ class Llama3Mitril(Provider):
     """
     A class to interact with the Llama3 Mitril API. Implements the WebScout provider interface.
     """
-
+    required_auth = False
     def __init__(
         self,
         is_conversation: bool = True,

webscout/Provider/llmchat.py

@@ -14,7 +14,7 @@ class LLMChat(Provider):
     """
     A class to interact with the LLMChat API
     """
-
+    required_auth = False
     AVAILABLE_MODELS = [
         "@cf/meta/llama-3.1-70b-instruct",
         "@cf/meta/llama-3.1-8b-instruct",

webscout/Provider/llmchatco.py

@@ -16,7 +16,7 @@ class LLMChatCo(Provider):
     """
     A class to interact with the LLMChat.co API
     """
-
+    required_auth = False
     AVAILABLE_MODELS = [
         "gemini-flash-2.0",        # Default model
         "llama-4-scout",