webscout 5.2__py3-none-any.whl → 5.4__py3-none-any.whl

webscout/AIauto.py

@@ -9,11 +9,8 @@ from webscout.Provider.Perplexity import Perplexity
 from webscout.Provider.Blackboxai import BLACKBOXAI
 from webscout.Provider.Blackboxai import AsyncBLACKBOXAI
 from webscout.Provider.Phind import PhindSearch
-from webscout.Provider.Phind import AsyncPhindSearch
 from webscout.Provider.Phind import Phindv2
-from webscout.Provider.Phind import AsyncPhindv2
 from webscout.Provider.yep import YEPCHAT
-from webscout.Provider.Berlin4h import Berlin4h
 from webscout.Provider.Poe import POE
 from webscout.Provider.BasedGPT import BasedGPT
 from webscout.Provider.Deepseek import DeepSeek
@@ -25,7 +22,7 @@ from webscout.Provider.DARKAI import DARKAI
 from webscout.Provider.koala import KOALA
 from webscout.Provider.RUBIKSAI import RUBIKSAI
 from webscout.Provider.meta import Meta
-from webscout.Provider.liaobots import LiaoBots
+
 from webscout.Provider.DiscordRocks import DiscordRocks
 from webscout.Provider.felo_search import Felo
 from webscout.Provider.xdash import XDASH
@@ -35,7 +32,7 @@ from webscout.Provider.Cloudflare import Cloudflare
 from webscout.Provider.turboseek import TurboSeek
 from webscout.Provider.NetFly import NetFly
 from webscout.Provider.EDITEE import Editee
-# from webscout.Provider.Chatify import Chatify # TODO: UNFINISHED
+from webscout.Provider.Chatify import Chatify
 from webscout.Provider.PI import PiAI 
 from webscout.g4f import GPT4FREE, AsyncGPT4FREE
 from webscout.g4f import TestProviders
@@ -58,7 +55,6 @@ provider_map: dict[
         PhindSearch,
         Phindv2,
         YEPCHAT,
-        Berlin4h,
         POE,
         BasedGPT,
         DeepSeek,
@@ -72,7 +68,7 @@ provider_map: dict[
         KOALA,
         RUBIKSAI,
         Meta,
-        LiaoBots,
+
         DiscordRocks,
         Felo,
         XDASH,
@@ -82,7 +78,7 @@ provider_map: dict[
         TurboSeek,
         NetFly,
         Editee,
-        # Chatify,
+        Chatify,
         PiAI,
     ],
 ] = {
@@ -94,7 +90,7 @@ provider_map: dict[
     "PhindSearch": PhindSearch,
     "Phindv2": Phindv2,
     "YEPCHAT": YEPCHAT,
-    "Berlin4h": Berlin4h,
+
     "POE": POE,
     "BasedGPT": BasedGPT,
     "DeepSeek": DeepSeek,
@@ -108,7 +104,7 @@ provider_map: dict[
     "koala": KOALA,
     "rubiksai": RUBIKSAI,
     "meta": Meta,
-    "liaobots": LiaoBots,
+
     "discordrocks": DiscordRocks,
     "felo": Felo,
     "xdash": XDASH,
@@ -160,7 +156,7 @@ class AUTO(Provider):
             PhindSearch,
             Phindv2,
             YEPCHAT,
-            Berlin4h,
+
             POE,
             BasedGPT,
             DeepSeek,
@@ -174,7 +170,7 @@ class AUTO(Provider):
             KOALA,
             RUBIKSAI,
             Meta,
-            LiaoBots,
+
             DiscordRocks,
             Felo,
             XDASH,

webscout/AIutel.py

@@ -594,16 +594,16 @@ w.print_weather(weather)
             interpreter (str, optional): Python's interpreter name. Defaults to Python.
             prettify (bool, optional): Prettify the code on stdout. Defaults to True.
         """
-        if not quiet:
-            print(
-                "Rawdog is an experimental tool that generates and auto-executes Python scripts in the cli.\n"
-                "To get the most out of Rawdog. Ensure the following are installed:\n"
-                " 1. Python 3.x\n"
-                " 2. Dependency:\n"
-                "  - Matplotlib\n"
-                "Be alerted on the risk posed! (Experimental)\n"
-                "Use '--quiet' to suppress this message and code/logs stdout.\n"
-            )
+        # if not quiet:
+        #     print(
+        #         "Rawdog is an experimental tool that generates and auto-executes Python scripts in the cli.\n"
+        #         "To get the most out of Rawdog. Ensure the following are installed:\n"
+        #         " 1. Python 3.x\n"
+        #         " 2. Dependency:\n"
+        #         "  - Matplotlib\n"
+        #         "Be alerted on the risk posed! (Experimental)\n"
+        #         "Use '--quiet' to suppress this message and code/logs stdout.\n"
+        #     )
         self.internal_exec = internal_exec
         self.confirm_script = confirm_script
         self.quiet = quiet

webscout/Agents/Onlinesearcher.py

@@ -10,7 +10,7 @@ import logging
 class WebSearchAgent:
     def __init__(self):
         self.webs = WEBS()
-        self.ai = LLAMA3(system="You are an advanced AI assistant specialized in generating optimal search queries and providing comprehensive answers based on web search results.")
+        self.ai = LLAMA3(system="You are an advanced AI assistant specialized in generating optimal search queries and providing comprehensive answers based on web search results.", is_conversation=False)
 
     def generate_search_queries(self, information, num_queries=3):
         prompt = f"""
@@ -94,8 +94,8 @@ class WebSearchAgent:
                 paragraphs = soup.find_all('p')
                 text = ' '.join([p.get_text() for p in paragraphs])
                 words = text.split()
-                if len(words) > 150:
-                    text = ' '.join(words[:150]) + '...'
+                if len(words) > 600:
+                    text = ' '.join(words[:600]) + '...'
                 return text
             else:
                 return f"Failed to fetch {url}: HTTP {response.status}"
@@ -112,7 +112,7 @@ class WebSearchAgent:
 class OnlineSearcher:
     def __init__(self):
         self.agent = WebSearchAgent()
-        self.ai = LLAMA3(system="You are an advanced AI assistant specialized in providing comprehensive and accurate answers based on web search results and your general knowledge.")
+        self.ai = LLAMA3(system="You are an advanced AI assistant specialized in providing comprehensive and accurate answers based on web search results and your general knowledge.", is_conversation=False)
 
     def answer_question(self, question: str):
         search_results = self.agent.search(question)
@@ -125,7 +125,7 @@ class OnlineSearcher:
 
         context += "Extracted webpage contents:\n"
         for i, webpage in enumerate(webpage_contents):
-            context += f"{i}. URL: {webpage['url']}\n   Content: {webpage['content'][:150]}...\n\n"
+            context += f"{i}. URL: {webpage['url']}\n   Content: {webpage['content'][:600]}...\n\n"
 
         prompt = f"""
         Task: Provide a comprehensive and accurate answer to the given question based on the provided web search results and your general knowledge.

webscout/Agents/functioncall.py

@@ -1,159 +1,170 @@
+from datetime import date
 import json
-import logging
+# import logging
 import time
 from typing import Any, Dict, Optional
-
 import requests
-from webscout import WEBS  # Import only WEBS from webscout
-
-class LLAMA3:
-
-    AVAILABLE_MODELS = ["llama3-70b", "llama3-8b", "llama3-405b"]
-
-    def __init__(
-        self,
-        is_conversation: bool = True,
-        max_tokens: int = 600,
-        timeout: int = 30,
-        model: str = "llama3-8b",  
-        system: str = "GPT syle",
-        proxies: dict = {},  # Add proxies parameter
-    ):
-        """Instantiates Snova
-
-        Args:
-            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True.
-            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
-            timeout (int, optional): Http request timeout. Defaults to 30.
-            model (str, optional): Snova model name. Defaults to "llama3-70b".
-            system (str, optional): System prompt for Snova. Defaults to "Answer as concisely as possible.".
-            proxies (dict, optional): Proxy settings for requests. Defaults to an empty dictionary.
-        """
-        if model not in self.AVAILABLE_MODELS:
-            raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
-
-        self.session = requests.Session()
-        self.is_conversation = is_conversation
-        self.max_tokens_to_sample = max_tokens
-        self.timeout = timeout
-        self.model = model
-        self.system = system
-        self.last_response = {}
-        self.env_type = "tp16405b" if "405b" in model else "tp16"
-        self.headers = {'content-type': 'application/json'}
-        self.session.headers.update(self.headers)
-        self.session.proxies = proxies
-
-    def chat(self, prompt: str) -> str:
-        data = {'body': {'messages': [{'role': 'system', 'content': self.system}, {'role': 'user', 'content': prompt}], 'stream': True, 'model': self.model}, 'env_type': self.env_type}
-        response = self.session.post('https://fast.snova.ai/api/completion', headers=self.headers, json=data, stream=True, timeout=self.timeout)
-        output = ''
-        for line in response.iter_lines(decode_unicode=True):
-            if line.startswith('data:'):
-                try:
-                    data = json.loads(line[len('data: '):])
-                    output += data.get("choices", [{}])[0].get("delta", {}).get("content", '')
-                except json.JSONDecodeError:
-                    if line[len('data: '):] == '[DONE]':
-                        break
-        return output
+from webscout import WEBS, Julius
 
 class FunctionCallingAgent:
-    def __init__(self, model: str = "llama3-8b", 
-                 system_prompt: str = 'You are a helpful assistant that will always answer what the user wants', 
+    def __init__(self, model: str = "GPT-4o", 
                  tools: list = None):
-        self.LLAMA3 = LLAMA3(model=model, system=system_prompt, timeout=300)
+        self.ai = Julius(model=model, timeout=300, intro=None)
         self.tools = tools if tools is not None else []
-        self.webs = WEBS()
+        self.knowledge_cutoff = "September 2022" 
 
     def function_call_handler(self, message_text: str) -> dict:
         system_message = self._generate_system_message(message_text)
-        response = self.LLAMA3.chat(system_message)
+        response = self.ai.chat(system_message)
         # logging.info(f"Raw response: {response}")
         return self._parse_function_call(response)
 
     def _generate_system_message(self, user_message: str) -> str:
-        tools_description = '\n'.join([f"- {tool['function']['name']}: {tool['function'].get('description', '')}" for tool in self.tools])
-        return (
-            "You are an AI assistant capable of understanding user requests and using tools to fulfill them. "
-            "Always respond using the JSON format specified below, even if you're not sure about the answer. "
-            f"Available tools:\n{tools_description}\n\n"
-            "Instructions:\n"
-            "1. Analyze the user's request.\n"
-            "2. Choose the most appropriate tool based on the request.\n"
-            "3. Respond ONLY with a JSON object in this exact format:\n"
-            "{\n"
-            '  "tool_name": "name_of_the_tool",\n'
-            '  "tool_input": {\n'
-            '    "param1": "value1",\n'
-            '    "param2": "value2"\n'
-            "  }\n"
-            "}\n\n"
-            "If you can't determine a suitable tool, use the 'general_ai' tool with the user's message as the 'question' parameter.\n\n"
-            f"User request: {user_message}\n\n"
-            "Your response (in JSON format):"
-        )
+        tools_description = ""
+        for tool in self.tools:
+            tools_description += f"- {tool['function']['name']}: {tool['function'].get('description', '')}\n"
+            tools_description += "    Parameters:\n"
+            for key, value in tool['function']['parameters']['properties'].items():
+                tools_description += f"      - {key}: {value.get('description', '')} ({value.get('type')})\n"
+        
+        current_date = date.today().strftime("%B %d, %Y")
+        return f"""Today is {current_date}. Your knowledge is current up to {self.knowledge_cutoff}.
+
+You are an advanced AI assistant tasked with analyzing user requests and determining the most appropriate action. You have access to the following tools:
+
+{tools_description}
+
+Instructions:
+1. Carefully analyze the user's request.
+2. If the user request is about controlling the web browser (opening websites, searching, playing videos, etc.), ALWAYS use the 'browser_control' tool.
+3. If the user request is something else, determine if any of the other provided tools are necessary to fulfill the request.
+4. If a tool is needed, select the MOST APPROPRIATE one. Do not use a tool if it's not directly relevant to the user's request.
+5. If you decide to use a tool, respond ONLY with a JSON object in this format:
+   {{
+     "tool_name": "name_of_the_tool",
+     "tool_input": {{
+       "param1": "value1",
+       "param2": "value2"
+     }}
+   }}
+
+   - Use the exact tool name as listed above.
+   - Include only the necessary parameters for the chosen tool.
+   - Do not include any explanations or additional text outside the JSON object.
+
+6. If no tool is needed and you can answer directly, respond with:
+   {{
+     "tool_name": "general_ai",
+     "tool_input": {{
+       "question": "user's original question"
+     }}
+   }}
+
+User Request: {user_message}
+
+Your Response (JSON only):"""
 
     def _parse_function_call(self, response: str) -> dict:
         try:
-            # Find the JSON-like part of the response
+            # Ensure to locate the start and end of the JSON structure
             start_idx = response.find("{")
             end_idx = response.rfind("}") + 1
 
             if start_idx == -1 or end_idx == -1:
                 raise ValueError("No valid JSON structure found in the response.")
 
+            # Extract the JSON string
             response_json_str = response[start_idx:end_idx]
-            
-            # Attempt to load the JSON string
-            return json.loads(response_json_str)
+
+            # Load the JSON string
+            parsed_response = json.loads(response_json_str)
+
+            # Check for the expected format
+            if "tool_name" in parsed_response and "tool_input" in parsed_response:
+                return parsed_response
+
+            # If not in the expected format, try to convert
+            for key, value in parsed_response.items():
+                if isinstance(value, dict):
+                    return {
+                        "tool_name": key,
+                        "tool_input": value
+                    }
+
+            # If the response structure is still incorrect
+            raise ValueError("Invalid response structure: missing required fields.")
 
         except (ValueError, json.JSONDecodeError) as e:
-            logging.error(f"Error parsing function call: {e}")
+            # logging.error(f"Error parsing function call: {e}")
             return {"error": str(e)}
 
+
     def execute_function(self, function_call_data: dict) -> str:
         function_name = function_call_data.get("tool_name")
         arguments = function_call_data.get("tool_input", {})
 
         if not isinstance(arguments, dict):
-            logging.error("Invalid arguments format.")
+            # logging.error("Invalid arguments format.")
             return "Invalid arguments format."
 
-        logging.info(f"Executing function: {function_name} with arguments: {arguments}")
+        # logging.info(f"Executing function: {function_name} with arguments: {arguments}")
 
 
 # Example usage
 if __name__ == "__main__":
+    # Configure logging
+    # logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
     tools = [
         {
             "type": "function",
             "function": {
                 "name": "web_search",
-                "description": "Search query on Google",
+                "description": "Search the web for current information on a given query",
                 "parameters": {
                     "type": "object",
                     "properties": {
                         "query": {
                             "type": "string",
-                            "description": "web search query"
+                            "description": "The search query to be executed"
                         }
                     },
                     "required": ["query"]
                 }
             }
         },
+        {
+            "type": "function",
+            "function": {
+                "name": "get_user_detail",
+                "description": "Get the user's name and age.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "name": {
+                            "type": "string",
+                            "description": "The user's name."
+                        },
+                        "age": {
+                            "type": "integer",
+                            "description": "The user's age."
+                        }
+                    },
+                    "required": ["name", "age"]
+                }
+            }
+        },
         {
             "type": "function",
             "function": {
                 "name": "general_ai",
-                "description": "Use AI to answer a general question",
+                "description": "Use AI to answer general questions or perform tasks not requiring external tools",
                 "parameters": {
                     "type": "object",
                     "properties": {
                         "question": {
                             "type": "string",
-                            "description": "The question to be answered by the AI"
+                            "description": "The question or task for the AI to process"
                         }
                     },
                     "required": ["question"]
@@ -163,10 +174,25 @@ if __name__ == "__main__":
     ]
 
     agent = FunctionCallingAgent(tools=tools)
-    message = "open yt"
-    function_call_data = agent.function_call_handler(message)
-    print(f"Function Call Data: {function_call_data}")
+    
+    # Test cases
+    test_messages = [
+        "What's the weather like in New York today?",
+        "Who won the last FIFA World Cup?",
+        "Can you explain quantum computing?",
+        "What are the latest developments in AI?",
+        "Tell me a joke about programming.",
+        "What's the meaning of life?",
+        "Get user details name as John and age as 30"
+    ]
+
+    for message in test_messages:
+        print(f"\nProcessing: {message}")
+        function_call_data = agent.function_call_handler(message)
+        print(f"Function Call Data: {function_call_data}")
 
-    if "error" not in function_call_data:
-        result = agent.execute_function(function_call_data)
-        print(f"Function Execution Result: {result}")
+        if "error" not in function_call_data:
+            result = agent.execute_function(function_call_data)
+            print(f"Function Execution Result: {result}")
+        else:
+            print(f"Error: {function_call_data['error']}")