Update agent_tools.py

agent_tools.py

@@ -1,145 +1,129 @@
 import requests
 import json
 from bs4 import BeautifulSoup
+import os
 
-
-def duckduckgo_search(query: str, count: int = 3) -> list:
+def search_duckduckgo(query: str, max_results: int = 3) -> list:
     """
-    Perform a search using DuckDuckGo and return the results.
+    Execute a DuckDuckGo search and retrieve snippets from results.
 
     Args:
-        query: The search query string
-        count: Maximum number of results to return (default: 3)
+        query (str): The search term to look up.
+        max_results (int): Maximum number of result snippets to return. Default is 3.
 
     Returns:
-        List of search results
+        list: A list of result snippets (strings).
     """
-    print(f"Performing DuckDuckGo search for: {query}")
+    print(f"Searching DuckDuckGo for: '{query}'")
 
     try:
         headers = {
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+            "User-Agent": (
+                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+                "AppleWebKit/537.36 (KHTML, like Gecko) "
+                "Chrome/91.0.4472.124 Safari/537.36"
+            )
         }
 
-        # Format the query for the URL
-        formatted_query = query.replace(' ', '+')
-        # Format the URL with query and parameter to increase snippet size
-        url = f"https://html.duckduckgo.com/html/?q={formatted_query}&kl=wt-wt"
+        search_term = query.replace(" ", "+")
+        search_url = f"https://html.duckduckgo.com/html/?q={search_term}&kl=wt-wt"
 
-        # Send the request
-        response = requests.get(url, headers=headers, timeout=10)
+        response = requests.get(search_url, headers=headers, timeout=10)
         response.raise_for_status()
 
-        # Parse the HTML response
-        soup = BeautifulSoup(response.text, 'html.parser')
-
-        # Extract search results
-        results = []
-        for result in soup.select('.result'):
-            title_elem = result.select_one('.result__title')
-            link_elem = result.select_one('.result__url')
-            snippet_elem = result.select_one('.result__snippet')
-
-            if title_elem and link_elem:
-                title = title_elem.get_text(strip=True)
-                url = link_elem.get('href') if link_elem.get('href') else link_elem.get_text(strip=True)
-                snippet = snippet_elem.get_text(strip=True) if snippet_elem else ""
+        soup = BeautifulSoup(response.text, "html.parser")
+        snippets = []
 
-                # results.append({
-                #    "title": title,
-                #    "url": url,
-                #    "snippet": snippet
-                # })
+        for result in soup.select(".result"):
+            title = result.select_one(".result__title")
+            url = result.select_one(".result__url")
+            summary = result.select_one(".result__snippet")
 
-                results.append(snippet)
+            if title and url:
+                snippet_text = summary.get_text(strip=True) if summary else ""
+                snippets.append(snippet_text)
 
-                if len(results) >= count:
+                if len(snippets) >= max_results:
                     break
 
-        print(f"DuckDuckGo results: {results}")
-        return results
-    except Exception as e:
-        print(f"Error during DuckDuckGo search: {e}")
+        print(f"DuckDuckGo snippets retrieved: {snippets}")
+        return snippets
+
+    except Exception as error:
+        print(f"Failed to fetch DuckDuckGo results: {error}")
         return []
 
 
-def langsearch_search(query: str, count: int = 5) -> list:
+def search_langsearch(query: str, max_items: int = 5) -> list:
     """
-    Perform a search using LangSearch API and return the results.
+    Use the LangSearch API to perform a web search and return summaries.
 
     Args:
-        query: The search query string
-        count: Maximum number of results to return (default: 5)
-        api_key: LangSearch API key (default: None, will look for env variable)
+        query (str): The search phrase.
+        max_items (int): Number of results to return. Defaults to 5.
 
     Returns:
-        List of search results
+        list: A list of summarized search results.
     """
-    print(f"Performing LangSearch search for: {query}")
+    print(f"Using LangSearch API for: '{query}'")
 
     try:
-        import os
-        # Use API key from parameters or environment variable
-        api_key = os.environ.get("LS_TOKEN")
+        token = os.getenv("LS_TOKEN")
 
-        if not api_key:
-            print("Warning: No LangSearch API key provided. Set LS_TOKEN environment variable.")
+        if not token:
+            print("LangSearch token not found. Set LS_TOKEN environment variable.")
             return []
 
         headers = {
             "Content-Type": "application/json",
-            "Authorization": f"Bearer {api_key}"
+            "Authorization": f"Bearer {token}"
         }
 
-        payload = json.dumps({
+        body = json.dumps({
             "query": query,
             "freshness": "noLimit",
             "summary": True,
-            "count": count
+            "count": max_items
         })
 
-        url = "https://api.langsearch.com/v1/web-search"
+        endpoint = "https://api.langsearch.com/v1/web-search"
+        res = requests.post(endpoint, headers=headers, data=body, timeout=30)
+        res.raise_for_status()
 
-        response = requests.post(url, headers=headers, data=payload, timeout=30)
-        response.raise_for_status()
-        if response.status_code != 200:
-            print(f"LangSearch API error: {response.text}")
-            return []
-        response = response.json()
-        results = []
-        for result in response["data"]["webPages"]["value"]:
-            results.append(result["summary"])
-        #print(f"LangSearch results: {results}")
-        return results
-    except Exception as e:
-        print(f"Error during LangSearch search: {e}")
+        data = res.json()
+        summaries = [entry["summary"] for entry in data.get("data", {}).get("webPages", {}).get("value", [])]
+
+        return summaries
+
+    except Exception as error:
+        print(f"Error during LangSearch API call: {error}")
         return []
 
 
-# Dictionary mapping tool names to their functions
-TOOLS_MAPPING = {
-    "duckduckgo_search": duckduckgo_search,
-    "langsearch_search": langsearch_search
+# Map available tools to their corresponding function handlers
+SEARCH_TOOLS = {
+    "search_duckduckgo": search_duckduckgo,
+    "search_langsearch": search_langsearch
 }
 
-# Tool definitions for LLM API
-TOOLS_DEFINITION = [
+# Definitions for LLM-compatible function tools
+LLM_TOOL_DEFINITIONS = [
     {
         "type": "function",
         "function": {
-            "name": "duckduckgo_search",
-            "description": "Search the web using DuckDuckGo and return relevant results",
+            "name": "search_duckduckgo",
+            "description": "Query DuckDuckGo to retrieve short summaries of search results.",
             "parameters": {
                 "type": "object",
                 "properties": {
                     "query": {
                         "type": "string",
-                        "description": "The search query string"
+                        "description": "Search term for the web query"
                     },
-                    "num_results": {
+                    "max_results": {
                         "type": "integer",
-                        "description": "Maximum number of results to return",
-                        "default": 5
+                        "description": "Limit of results to return",
+                        "default": 3
                     }
                 },
                 "required": ["query"]
@@ -149,23 +133,23 @@ TOOLS_DEFINITION = [
     {
         "type": "function",
         "function": {
-            "name": "langsearch_search",
-            "description": "Search the web using LangSearch API for more relevant results with deeper context",
+            "name": "search_langsearch",
+            "description": "Use the LangSearch API to find and summarize relevant web content.",
             "parameters": {
                 "type": "object",
                 "properties": {
                     "query": {
                         "type": "string",
-                        "description": "The search query string"
+                        "description": "Text to search using LangSearch"
                     },
-                    "top_k": {
+                    "max_items": {
                         "type": "integer",
-                        "description": "Maximum number of results to return",
+                        "description": "Number of search results to return",
                         "default": 5
                     },
                     "api_key": {
                         "type": "string",
-                        "description": "LangSearch API key (optional, will use LANGSEARCH_API_KEY env var if not provided)"
+                        "description": "Optional LangSearch API key (uses LS_TOKEN from environment if not given)"
                     }
                 },
                 "required": ["query"]