webscout 4.9__tar.gz → 5.0__tar.gz

{webscout-4.9/webscout.egg-info → webscout-5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: webscout
-Version: 4.9
+Version: 5.0
 Summary: Search for anything using Google, DuckDuckGo, brave, qwant,  phind.com, Contains AI models, can transcribe yt videos, temporary email and phone number generation, has TTS support, webai (terminal gpt and open interpreter) and offline LLMs and more
 Author: OEvortex
 Author-email: helpingai5@gmail.com

{webscout-4.9 → webscout-5.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", encoding="utf-8") as f:
 
 setup(
     name="webscout",
-    version="4.9",
+    version="5.0",
     description="Search for anything using Google, DuckDuckGo, brave, qwant,  phind.com, Contains AI models, can transcribe yt videos, temporary email and phone number generation, has TTS support, webai (terminal gpt and open interpreter) and offline LLMs and more",
     long_description=README,
     long_description_content_type="text/markdown",

webscout-5.0/webscout/Agents/functioncall.py

@@ -0,0 +1,142 @@
+import json
+import logging
+from webscout import LLAMA3, WEBS
+
+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', 
+                 tools: list = None):
+        self.LLAMA3 = LLAMA3(model=model, system=system_prompt, timeout=300)
+        self.tools = tools if tools is not None else []
+        self.webs = WEBS()
+
+    def function_call_handler(self, message_text: str) -> dict:
+        system_message = self._generate_system_message(message_text)
+        response = self.LLAMA3.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):"
+        )
+
+    def _parse_function_call(self, response: str) -> dict:
+        try:
+            # Find the JSON-like part of the response
+            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.")
+
+            response_json_str = response[start_idx:end_idx]
+            
+            # Attempt to load the JSON string
+            return json.loads(response_json_str)
+
+        except (ValueError, json.JSONDecodeError) as 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.")
+            return "Invalid arguments format."
+
+        logging.info(f"Executing function: {function_name} with arguments: {arguments}")
+
+    #     if function_name == "web_search":
+    #         return self._handle_web_search(arguments)
+    #     elif function_name == "general_ai":
+    #         return self._handle_general_ai(arguments)
+    #     else:
+    #         return f"Function '{function_name}' is not implemented."
+
+    # def _handle_web_search(self, arguments: dict) -> str:
+    #     query = arguments.get("query")
+    #     if not query:
+    #         return "Please provide a search query."
+
+    #     search_results = self.webs.text(query, max_results=3)
+    #     formatted_results = "\n\n".join(
+    #         f"{i+1}. {result['title']}\n{result['body']}\nURL: {result['href']}"
+    #         for i, result in enumerate(search_results)
+    #     )
+    #     return f"Here's what I found:\n\n{formatted_results}"
+
+    # def _handle_general_ai(self, arguments: dict) -> str:
+    #     question = arguments.get("question")
+    #     if not question:
+    #         return "Please provide a question for the AI to answer."
+
+    #     response = self.LLAMA3.chat(question)
+    #     return response
+
+# Example usage
+if __name__ == "__main__":
+    tools = [
+        {
+            "type": "function",
+            "function": {
+                "name": "web_search",
+                "description": "Search query on Google",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "query": {
+                            "type": "string",
+                            "description": "web search query"
+                        }
+                    },
+                    "required": ["query"]
+                }
+            }
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "general_ai",
+                "description": "Use AI to answer a general question",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "question": {
+                            "type": "string",
+                            "description": "The question to be answered by the AI"
+                        }
+                    },
+                    "required": ["question"]
+                }
+            }
+        }
+    ]
+
+    agent = FunctionCallingAgent(tools=tools)
+    message = "open yt"
+    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}")

{webscout-4.9 → webscout-5.0}/webscout/Provider/DiscordRocks.py

@@ -122,7 +122,7 @@ class DiscordRocks(Provider):
 
     def __init__(
         self,
-        model: str = "gpt-4o", 
+        model: str = "llama-3.1-405b-turbo", 
         max_tokens: int = 4096,
         temperature: float = 1,
         top_p: float = 1,
@@ -176,6 +176,7 @@ class DiscordRocks(Provider):
             "accept-language": "en-US,en;q=0.9,en-IN;q=0.8",
             "content-type": "application/json",
             "dnt": "1",
+            "authorization": "Bearer missing api key",
             "origin": "https://llmplayground.net",
             "priority": "u=1, i",
             "referer": "https://llmplayground.net/",

{webscout-4.9 → webscout-5.0/webscout.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: webscout
-Version: 4.9
+Version: 5.0
 Summary: Search for anything using Google, DuckDuckGo, brave, qwant,  phind.com, Contains AI models, can transcribe yt videos, temporary email and phone number generation, has TTS support, webai (terminal gpt and open interpreter) and offline LLMs and more
 Author: OEvortex
 Author-email: helpingai5@gmail.com

webscout-4.9/webscout/Agents/functioncall.py

@@ -1,186 +0,0 @@
-import json
-import logging
-from webscout import DeepInfra, WEBS
-
-class FunctionCallingAgent:
-    def __init__(self, model: str = "Qwen/Qwen2-72B-Instruct", 
-                 system_prompt: str = 'You are a helpful assistant that will always answer what the user wants', 
-                 tools: list = None):
-        """
-        Initialize the FunctionCallingAgent with the model, system prompt, and tools.
-
-        Args:
-            model (str): The model to use for deepinfra chat.
-            system_prompt (str): The system prompt to initialize the model.
-            tools (list): A list of tools the agent can use.
-        """
-        self.deepinfra = DeepInfra(model=model, system_prompt=system_prompt, timeout=300)
-        self.tools = tools if tools is not None else []
-
-
-    def function_call_handler(self, message_text: str) -> dict:
-        """
-        Handles function calls based on the provided message text.
-
-        Args:
-            message_text (str): The input message text from the user.
-
-        Returns:
-            dict: The extracted function call and arguments.
-        """
-        system_message = self._generate_system_message(message_text)
-        response = self.deepinfra.chat(system_message)
-        # logging.info(f"Raw response: {response}")
-
-        return self._parse_function_call(response)
-
-    def _generate_system_message(self, user_message: str) -> str:
-        """
-        Generates a system message incorporating the user message and available tools.
-
-        Args:
-            user_message (str): The input message from the user.
-
-        Returns:
-            str: The formatted system message.
-        """
-        tools_description = '\n'.join([f"{tool['function']['name']}: {tool['function'].get('description', '')}" for tool in self.tools])
-        return (
-            f"[SYSTEM] You are a helpful and capable AI assistant. "
-            "Your goal is to understand the user's request and provide accurate and relevant information. "
-            "You have access to the following tools:\n\n"
-            f"{tools_description}\n\n"
-            "To use a tool, please follow this format:\n\n"
-            "```json\n"
-            "{{ 'tool_name': 'tool_name', 'tool_input': {{ 'arg_1': 'value_1', 'arg_2': 'value_2', ... }} }}\n"
-            "```\n\n"
-            f"[USER] {user_message}"
-        )
-
-    def _parse_function_call(self, response: str) -> dict:
-        """
-        Parses the response from the model to extract the function call.
-
-        Args:
-            response (str): The raw response from the model.
-
-        Returns:
-            dict: A dictionary containing the function name and arguments.
-        """
-        try:
-            # Find the JSON-like part of the response
-            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.")
-
-            response_json_str = response[start_idx:end_idx]
-
-            # Replace single quotes with double quotes and remove extra braces
-            response_json_str = response_json_str.replace("'", '"')
-            response_json_str = response_json_str.replace("{{", "{").replace("}}", "}")
-            
-            # Remove any leading or trailing whitespace
-            response_json_str = response_json_str.strip()
-
-            # Attempt to load the JSON string
-            return json.loads(response_json_str)
-
-        except (ValueError, json.JSONDecodeError) as e:
-            logging.error(f"Error parsing function call: {e}")
-            return {"error": str(e)}
-
-    def execute_function(self, function_call_data: dict) -> str:
-        """
-        Executes the specified function with the provided arguments.
-
-        Args:
-            function_call_data (dict): A dictionary containing the function name and arguments.
-
-        Returns:
-            str: The result of the function execution.
-        """
-        function_name = function_call_data.get("tool_name")  # Use 'tool_name' instead of 'name'
-        arguments = function_call_data.get("tool_input", {})  # Use 'tool_input' instead of 'arguments'
-
-        if not isinstance(arguments, dict):
-            logging.error("Invalid arguments format.")
-            return "Invalid arguments format."
-
-        logging.info(f"Executing function: {function_name} with arguments: {arguments}")
-
-        if function_name == "web_search":
-            return self._handle_web_search(arguments)
-        else:
-            return f"Function '{function_name}' is not implemented."
-
-    # def _handle_web_search(self, arguments: dict) -> str:
-    #     """
-    #     Handles web search queries using the WEBS tool.
-
-    #     Args:
-    #         arguments (dict): A dictionary containing the query argument.
-
-    #     Returns:
-    #         str: The result of the web search.
-    #     """
-    #     query = arguments.get("query")
-    #     if not query:
-    #         return "Please provide a search query."
-
-    #     search_results = self.webs.text(query)
-    #     # Additional processing of search results can be done here if needed.
-    #     return f"Here's what I found:\n\n{search_results}"
-
-# Example usage
-if __name__ == "__main__":
-    tools = [
-        {
-            "type": "function",
-            "function": {
-                "name": "UserDetail",
-                "parameters": {
-                    "type": "object",
-                    "title": "UserDetail",
-                    "properties": {
-                        "name": {
-                            "title": "Name",
-                            "type": "string"
-                        },
-                        "age": {
-                            "title": "Age",
-                            "type": "integer"
-                        }
-                    },
-                    "required": ["name", "age"]
-                }
-            }
-        },
-        {
-            "type": "function",
-            "function": {
-                "name": "web_search",
-                "description": "Search query on google",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "query": {
-                            "type": "string",
-                            "description": "web search query"
-                        }
-                    },
-                    "required": ["query"]
-                }
-            }
-        }
-    ]
-
-    agent = FunctionCallingAgent(tools=tools)
-    message = "websearch about helpingai-9b"
-    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}")