webscout 8.2.3__py3-none-any.whl → 8.2.5__py3-none-any.whl

webscout/conversation.py

@@ -86,8 +86,10 @@ class Conversation:
         self.status = status
         self.max_tokens_to_sample = max_tokens
         self.chat_history = ""  # Initialize as empty string
-        self.history_format = "\nUser : %(user)s\nLLM :%(llm)s"
-        self.tool_history_format = "\nUser : %(user)s\nLLM : [Tool Call: %(tool)s]\nTool : %(result)s"
+        # Updated history formats
+        self.history_format = "\nUser: %(user)s\nAssistant: %(llm)s"
+        # Tool format: Assistant outputs the tool call, then Tool provides the result
+        self.tool_history_format = "\nUser: %(user)s\nAssistant: <tool_call>%(tool_json)s</tool_call>\nTool: %(result)s"
         self.file = filepath
         self.update_file = update_file
         self.history_offset = 10250
@@ -245,10 +247,7 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
 3. Avoid *all* prohibited explanations/text.
 ''')
         
-        incomplete_chat_history = self.chat_history + self.history_format % {
-            "user": prompt,
-            "llm": ""
-        }
+        incomplete_chat_history = self.chat_history + "\nUser: " + prompt + "\nAssistant:" # Ensure it ends correctly
         complete_prompt = intro + self.__trim_chat_history(incomplete_chat_history, intro)
         return complete_prompt
 
@@ -274,6 +273,7 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
         if not self.status and not force:
             return
 
+        # Use the updated history_format
         new_history = self.history_format % {"user": prompt, "llm": response}
         
         if self.file and self.update_file:
@@ -290,31 +290,33 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
         # logger.info(f"Chat history updated with prompt: {prompt}")
 
     def update_chat_history_with_tool(
-        self, prompt: str, tool_name: str, tool_result: str, force: bool = False
+        self, prompt: str, tool_call_json: str, tool_result: str, force: bool = False # Changed tool_name to tool_call_json
     ) -> None:
         """Update chat history with a tool call and its result.
 
         This method:
-        - Adds tool call interaction to the history
+        - Adds tool call interaction to the history using the new format
         - Updates the file if needed
         - Maintains the conversation flow with tools
 
         Args:
             prompt (str): The user's message that triggered the tool call
-            tool_name (str): Name of the tool that was called
+            tool_call_json (str): The JSON string representing the tool call made by the assistant
             tool_result (str): Result returned by the tool
             force (bool): Force update even if history is off. Default: False
 
         Examples:
             >>> chat = Conversation()
-            >>> chat.update_chat_history_with_tool("What's the weather?", "weather_tool", "It's sunny, 75°F")
+            >>> tool_json = '{"name": "weather_tool", "arguments": {"location": "London"}}'
+            >>> chat.update_chat_history_with_tool("What's the weather?", tool_json, "It's sunny, 75°F")
         """
         if not self.status and not force:
             return
 
+        # Use the updated tool_history_format
         new_history = self.tool_history_format % {
             "user": prompt,
-            "tool": tool_name,
+            "tool_json": tool_call_json, # Use the JSON string
             "result": tool_result
         }
 
@@ -350,25 +352,33 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
         if not self.validate_message(role, content):
             raise ValueError("Invalid message role or content")
 
+        # Updated role formats to match User/Assistant
         role_formats = {
             "user": "User",
-            "llm": "LLM",
+            "assistant": "Assistant", # Changed from 'llm'
+            "llm": "Assistant", # Keep llm for backward compatibility? Or remove? Let's keep for now.
             "tool": "Tool",
-            "reasoning": "Reasoning"
+            "reasoning": "Reasoning" # Keep reasoning if used internally
         }
 
         if role in role_formats:
-            self.chat_history += f"\n{role_formats[role]} : {content}"
+            # Special handling for assistant's tool call output
+            if role == "assistant" and "<tool_call>" in content:
+                 # History format already includes the tags, just add the content
+                 self.chat_history += f"\n{role_formats[role]}: {content}"
+            elif role == "tool":
+                 # Tool results follow the Assistant's tool call
+                 self.chat_history += f"\n{role_formats[role]}: {content}"
+            else:
+                 # Standard user/assistant message
+                 self.chat_history += f"\n{role_formats[role]}: {content}"
         else:
             raise ValueError(f"Invalid role: {role}. Must be one of {list(role_formats.keys())}")
 
-    #     # Enhanced logging for message addition
-    #     logger.info(f"Added message from {role}: {content}")
-    #     logging.info(f"Message added: {role}: {content}")
-
     def validate_message(self, role: str, content: str) -> bool:
         """Validate the message role and content."""
-        valid_roles = {            'user', 'llm', 'tool', 'reasoning', 'function_call'        }
+        # Updated valid roles
+        valid_roles = {'user', 'assistant', 'llm', 'tool', 'reasoning'} # Changed 'llm' to 'assistant', kept 'llm' maybe?
         if role not in valid_roles:
             logging.error(f"Invalid role: {role}")
             return False
@@ -546,14 +556,16 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
             result = self.execute_function(function_call_data)
 
             # Add the result to chat history as a tool message
-            self.add_message("tool", result)
+            # The assistant's response (the tool call itself) should have been added before calling this
+            # Now we add the tool's result
+            self.add_message("tool", result) # This will now correctly add "\nTool: <result>"
 
             return {
                 "is_tool_call": True,
                 "success": True,
-                "result": result,
+                "result": result, # This is the tool's execution result
                 "tool_calls": function_call_data.get("tool_calls", []),
-                "original_response": response
+                "original_response": response # This is the LLM's response containing the <tool_call>
             }
 
         return {

webscout/exceptions.py

@@ -11,6 +11,26 @@ class WebscoutE(Exception):
     pass
 
 
+class ModelNotFoundError(WebscoutE):
+    """
+    Exception raised when a requested model is not found or available.
+
+    This exception is raised when the specified model cannot be located or accessed by the provider.
+    It indicates that the model name might be incorrect or the provider does not support it.
+    """
+    pass
+
+
+class MissingRequirementsError(WebscoutE):
+    """
+    Exception raised when required dependencies are missing.
+
+    This exception is raised when a feature requires certain libraries or packages that are not installed.
+    It indicates that the user needs to install the missing dependencies to use the feature.
+    """
+    pass
+
+
 class APIConnectionError(WebscoutE):
     """
     Exception raised when there are issues connecting to an API.
@@ -70,6 +90,9 @@ class FailedToGenerateResponseError(WebscoutE):
     """
     pass
 
+class InvalidAuthenticationError(Exception):
+    """Custom exception for authentication errors (e.g., invalid API key, cookies)."""
+    pass
 
 class AllProvidersFailure(WebscoutE):
     """

webscout/prompt_manager.py

@@ -2,7 +2,7 @@
 
 import os
 import json
-import requests
+from curl_cffi.requests import Session
 from typing import Optional, Dict, Union
 from rich.console import Console
 from rich.table import Table
@@ -12,12 +12,14 @@ console = Console()
 
 class AwesomePrompts:
     """The most awesome prompts manager you'll ever see fr fr! 🔥"""
-    
+
     def __init__(
         self,
         repo_url: str = "https://raw.githubusercontent.com/OE-LUCIFER/prompts/main/prompt.json",
         local_path: Optional[str] = None,
-        auto_update: bool = True
+        auto_update: bool = True,
+        timeout: int = 10,
+        impersonate: str = "chrome110"
     ):
         """Initialize them Awesome Prompts with style! 💫
 
@@ -25,6 +27,8 @@ class AwesomePrompts:
             repo_url (str): URL to fetch prompts from
             local_path (str, optional): Where to save them prompts locally
             auto_update (bool): Auto update prompts on init. Defaults to True
+            timeout (int): Timeout for HTTP requests. Defaults to 10.
+            impersonate (str): Browser profile for curl_cffi. Defaults to "chrome110".
         """
         self.repo_url = repo_url
         self.local_path = local_path or os.path.join(
@@ -34,14 +38,20 @@ class AwesomePrompts:
         )
         self._cache: Dict[Union[str, int], str] = {}
         self._last_update: Optional[datetime] = None
-        
+        self.timeout = timeout
+        # Initialize curl_cffi session
+        self.session = Session(
+            timeout=self.timeout,
+            impersonate=impersonate
+        )
+
         # Create directory if it doesn't exist
         os.makedirs(os.path.dirname(self.local_path), exist_ok=True)
-        
+
         # Load those prompts on init if auto_update is True
         if auto_update:
             self.update_prompts_from_online()
-    
+
     def _load_prompts(self) -> Dict[Union[str, int], str]:
         """Load prompts from the local file fr fr! 📂"""
         try:
@@ -52,7 +62,7 @@ class AwesomePrompts:
         except Exception as e:
             console.print(f"[red]❌ Error loading prompts: {str(e)}[/red]")
             return {}
-    
+
     def _save_prompts(self, prompts: Dict[Union[str, int], str]) -> None:
         """Save them prompts with style! 💾"""
         try:
@@ -62,7 +72,7 @@ class AwesomePrompts:
             console.print("[green]✨ Prompts saved successfully![/green]")
         except Exception as e:
             console.print(f"[red]❌ Error saving prompts: {str(e)}[/red]")
-    
+
     def update_prompts_from_online(self, force: bool = False) -> bool:
         """Update prompts from the repo! 🚀
 
@@ -78,34 +88,39 @@ class AwesomePrompts:
                (datetime.now() - self._last_update).total_seconds() < 3600:
                 console.print("[yellow]⚡ Prompts are already up to date![/yellow]")
                 return True
-                
+
             console.print("[cyan]🔄 Updating prompts...[/cyan]")
-            response = requests.get(self.repo_url, timeout=10)
+            # Use the curl_cffi session
+            response = self.session.get(self.repo_url)
             response.raise_for_status()
-            
+
             # Merge new prompts with existing ones
             new_prompts = response.json()
             existing_prompts = self._load_prompts()
             merged_prompts = {**existing_prompts, **new_prompts}
-            
+
             # Create a new dictionary for numeric indices
             indexed_prompts = merged_prompts.copy()
-            
+
             # Add indices for numeric access
             for i, (key, value) in enumerate(list(merged_prompts.items())):
                 if isinstance(key, str):
                     indexed_prompts[i] = value
-            
+
             self._save_prompts(indexed_prompts)
             self._last_update = datetime.now()
-            
+
             console.print("[green]✨ Prompts updated successfully![/green]")
             return True
-            
+
         except Exception as e:
-            console.print(f"[red]❌ Error updating prompts: {str(e)}[/red]")
+            # Provide more specific error context if possible
+            if hasattr(e, 'response') and e.response is not None:
+                 console.print(f"[red]❌ Error updating prompts with status {e.response.status_code}: {str(e)}[/red]")
+            else:
+                 console.print(f"[red]❌ Error updating prompts: {str(e)}[/red]")
             return False
-    
+
     def get_act(
         self,
         key: Union[str, int],
@@ -124,20 +139,20 @@ class AwesomePrompts:
             str: The prompt or default value
         """
         prompts = self._cache or self._load_prompts()
-        
+
         # Try direct access first
         if key in prompts:
             return prompts[key]
-            
+
         # Try case-insensitive search for string keys
         if isinstance(key, str) and case_insensitive:
             key_lower = key.lower()
             for k, v in prompts.items():
                 if isinstance(k, str) and k.lower() == key_lower:
                     return v
-        
+
         return default
-    
+
     def add_prompt(self, name: str, prompt: str) -> bool:
         """Add a new prompt to the collection! ✨
 
@@ -151,12 +166,12 @@ class AwesomePrompts:
         if not name or not prompt:
             console.print("[red]❌ Name and prompt cannot be empty![/red]")
             return False
-            
+
         prompts = self._cache or self._load_prompts()
         prompts[name] = prompt
         self._save_prompts(prompts)
         return True
-    
+
     def delete_prompt(
         self,
         name: Union[str, int],
@@ -174,13 +189,13 @@ class AwesomePrompts:
             bool: Success status
         """
         prompts = self._cache or self._load_prompts()
-        
+
         # Handle direct key match
         if name in prompts:
             del prompts[name]
             self._save_prompts(prompts)
             return True
-            
+
         # Handle case-insensitive match
         if isinstance(name, str) and case_insensitive:
             name_lower = name.lower()
@@ -189,12 +204,12 @@ class AwesomePrompts:
                     del prompts[k]
                     self._save_prompts(prompts)
                     return True
-        
+
         if raise_not_found:
             raise KeyError(f"Prompt '{name}' not found!")
         console.print(f"[yellow]⚠️ Prompt '{name}' not found![/yellow]")
         return False
-    
+
     @property
     def all_acts(self) -> Dict[Union[str, int], str]:
         """All them awesome prompts mapped with style! 📚
@@ -206,17 +221,17 @@ class AwesomePrompts:
         if not prompts:
             self.update_prompts_from_online()
             prompts = self._load_prompts()
-            
+
         # Create a new dictionary for the result
         result = prompts.copy()
-        
+
         # Add numeric indices to the copy
         for i, (key, value) in enumerate(list(prompts.items())):
             if isinstance(key, str):
                 result[i] = value
-                
+
         return result
-    
+
     def show_acts(self, search: Optional[str] = None) -> None:
         """Show all them awesome prompts with style! 📋
 
@@ -224,7 +239,7 @@ class AwesomePrompts:
             search: Optional search term to filter prompts
         """
         prompts = self.all_acts
-        
+
         # Create a fire table! 🔥
         table = Table(
             title="🚀 Awesome Prompts Collection",
@@ -234,21 +249,21 @@ class AwesomePrompts:
         table.add_column("Index", style="cyan", justify="right")
         table.add_column("Name", style="green")
         table.add_column("Preview", style="yellow")
-        
+
         for i, (key, value) in enumerate(prompts.items()):
             if isinstance(key, int):
                 continue  # Skip numeric keys as they're duplicates
-                
+
             # Filter by search term if provided
             if search and search.lower() not in key.lower() and \
                search.lower() not in value.lower():
                 continue
-                
+
             preview = value[:50] + "..." if len(value) > 50 else value
             table.add_row(str(i), str(key), preview)
-        
+
         console.print(table)
-    
+
     def get_random_act(self) -> Optional[str]:
         """Get a random prompt for that surprise factor! 🎲"""
         import random
@@ -261,14 +276,13 @@ class AwesomePrompts:
 if __name__ == "__main__":
     # Quick demo of the features! 🚀
     prompts = AwesomePrompts()
-    prompts.update_prompts_from_online()
     prompts.show_acts()
-    
+
     # Add a test prompt
     prompts.add_prompt("test_prompt", "This is a test prompt! 🔥")
-    
+
     # Show the new prompt
     print("\nTest Prompt:", prompts.get_act("test_prompt"))
-    
+
     # Clean up
     prompts.delete_prompt("test_prompt")

webscout/version.py

@@ -1,2 +1,2 @@
-__version__ = "8.2.3"
+__version__ = "8.2.5"
 __prog__ = "webscout"

webscout/webscout_search.py

@@ -17,7 +17,7 @@ from typing import Any, cast
 import os
 from typing import Literal, Iterator
 
-import primp  # type: ignore
+import curl_cffi.requests  # type: ignore
 
 try:
     from lxml.etree import _Element
@@ -46,18 +46,14 @@ class WEBS:
     """webscout class to get search results from duckduckgo.com."""
 
     _executor: ThreadPoolExecutor = ThreadPoolExecutor()
+    # curl_cffi supports different browser versions than primp
     _impersonates = (
-        "chrome_100", "chrome_101", "chrome_104", "chrome_105", "chrome_106", "chrome_107",
-        "chrome_108", "chrome_109", "chrome_114", "chrome_116", "chrome_117", "chrome_118",
-        "chrome_119", "chrome_120", "chrome_123", "chrome_124", "chrome_126", "chrome_127",
-        "chrome_128", "chrome_129", "chrome_130", "chrome_131", "chrome_133",
-        "safari_ios_16.5", "safari_ios_17.2", "safari_ios_17.4.1", "safari_ios_18.1.1",
-        "safari_15.3", "safari_15.5", "safari_15.6.1", "safari_16", "safari_16.5",
-        "safari_17.0", "safari_17.2.1", "safari_17.4.1", "safari_17.5",
-        "safari_18", "safari_18.2",
-        "safari_ipad_18",
-        "edge_101", "edge_122", "edge_127", "edge_131",
-        "firefox_109", "firefox_117", "firefox_128", "firefox_133", "firefox_135",
+        "chrome99", "chrome100", "chrome101", "chrome104", "chrome107", "chrome110",
+        "chrome116", "chrome119", "chrome120", "chrome123", "chrome124", "chrome131", "chrome133a",
+        "chrome99_android", "chrome131_android",
+        "safari15_3", "safari15_5", "safari17_0", "safari17_2_ios", "safari18_0", "safari18_0_ios",
+        "edge99", "edge101",
+        "firefox133", "firefox135",
     )  # fmt: skip
     _impersonates_os = ("android", "ios", "linux", "macos", "windows")
     _chat_models = {
@@ -109,15 +105,14 @@ class WEBS:
         self.headers = headers if headers else {}
         self.headers.update(default_headers)
 
-        self.client = primp.Client(
+        # curl_cffi has different parameters than primp
+        impersonate_browser = choice(self._impersonates)
+        self.client = curl_cffi.requests.Session(
             headers=self.headers,
-            proxy=self.proxy,
+            proxies={'http': self.proxy, 'https': self.proxy} if self.proxy else None,
             timeout=timeout,
-            cookie_store=True,
-            referer=True,
-            impersonate=choice(self._impersonates),
-            impersonate_os=choice(self._impersonates_os),
-            follow_redirects=False,
+            # curl_cffi doesn't accept cookies=True, it needs a dict or None
+            impersonate=impersonate_browser,
             verify=verify,
         )
         self.timeout = timeout
@@ -166,17 +161,33 @@ class WEBS:
     ) -> Any:
         self._sleep()
         try:
-            resp = self.client.request(
-                method,
-                url,
-                params=params,
-                content=content,
-                data=data,
-                headers=headers,
-                cookies=cookies,
-                json=json,
-                timeout=timeout or self.timeout,
-            )
+            # curl_cffi doesn't accept cookies=True in request methods
+            request_kwargs = {
+                "params": params,
+                "headers": headers,
+                "json": json,
+                "timeout": timeout or self.timeout,
+            }
+
+            # Add cookies if they're a dict, not a bool
+            if isinstance(cookies, dict):
+                request_kwargs["cookies"] = cookies
+
+            if method == "GET":
+                # curl_cffi uses data instead of content
+                if content:
+                    request_kwargs["data"] = content
+                resp = self.client.get(url, **request_kwargs)
+            elif method == "POST":
+                # handle both data and content
+                if data or content:
+                    request_kwargs["data"] = data or content
+                resp = self.client.post(url, **request_kwargs)
+            else:
+                # handle both data and content
+                if data or content:
+                    request_kwargs["data"] = data or content
+                resp = self.client.request(method, url, **request_kwargs)
         except Exception as ex:
             if "time" in str(ex).lower():
                 raise TimeoutE(f"{url} {type(ex).__name__}: {ex}") from ex
@@ -296,7 +307,8 @@ class WEBS:
                 self._chat_vqd_hash = resp.headers.get("x-vqd-hash-1", "")
                 chunks = []
 
-                for chunk in resp.stream():
+                # curl_cffi uses iter_content instead of stream
+                for chunk in resp.iter_content(chunk_size=1024):
                     lines = chunk.split(b"data:")
                     for line in lines:
                         if line := line.strip():
@@ -304,20 +316,24 @@ class WEBS:
                                 break
                             if line == b"[DONE][LIMIT_CONVERSATION]":
                                 raise ConversationLimitException("ERR_CONVERSATION_LIMIT")
-                            x = json_loads(line)
-                            if isinstance(x, dict):
-                                if x.get("action") == "error":
-                                    err_message = x.get("type", "")
-                                    if x.get("status") == 429:
-                                        raise (
-                                            ConversationLimitException(err_message)
-                                            if err_message == "ERR_CONVERSATION_LIMIT"
-                                            else RatelimitE(err_message)
-                                        )
-                                    raise WebscoutE(err_message)
-                                elif message := x.get("message"):
-                                    chunks.append(message)
-                                    yield message
+                            try:
+                                x = json_loads(line)
+                                if isinstance(x, dict):
+                                    if x.get("action") == "error":
+                                        err_message = x.get("type", "")
+                                        if x.get("status") == 429:
+                                            raise (
+                                                ConversationLimitException(err_message)
+                                                if err_message == "ERR_CONVERSATION_LIMIT"
+                                                else RatelimitE(err_message)
+                                            )
+                                        raise WebscoutE(err_message)
+                                    elif message := x.get("message"):
+                                        chunks.append(message)
+                                        yield message
+                            except Exception as e:
+                                # Skip invalid JSON data
+                                continue
 
                 # If we get here, the request was successful
                 result = "".join(chunks)
@@ -541,7 +557,8 @@ class WEBS:
                 return []
 
             page_results = []
-            tree = document_fromstring(resp_content, self.parser)
+            # curl_cffi returns bytes, not a file-like object
+            tree = document_fromstring(resp_content)
             elements = tree.xpath("//div[h2]")
             if not isinstance(elements, list):
                 return []
@@ -628,7 +645,8 @@ class WEBS:
                 return []
 
             page_results = []
-            tree = document_fromstring(resp_content, self.parser)
+            # curl_cffi returns bytes, not a file-like object
+            tree = document_fromstring(resp_content)
             elements = tree.xpath("//table[last()]//tr")
             if not isinstance(elements, list):
                 return []