Update gemini_agent.py

gemini_agent.py

@@ -125,8 +125,9 @@ class GeminiAgent:
     async def _google_search(self, query: str, num_results: int = 5, exact_terms: str = None, site_restrict: str = None) -> str:
         """Perform a Google search using the Custom Search API with enhanced options"""
         if not self.google_search_api_key or not self.google_search_cx:
-            print("Google Search API key or CX not configured, falling back to DuckDuckGo")
-            return self.ddg_tool.run(query)
+            print("Google Search API key or CX not configured, using direct search")
+            # Instead of falling back to DuckDuckGo, return a simple message
+            return f"Search for: {query} (API keys not configured)"
             
         try:
             url = "https://www.googleapis.com/customsearch/v1"
@@ -145,15 +146,16 @@ class GeminiAgent:
             if site_restrict:
                 params['siteSearch'] = site_restrict
             
-            response = requests.get(url, params=params)
+            # Add timeout to prevent hanging
+            response = requests.get(url, params=params, timeout=10)
             if response.status_code != 200:
                 print(f"Google Search API error: {response.status_code}")
-                return self.ddg_tool.run(query)  # Fall back to DuckDuckGo
+                return f"Search failed for: {query} (Status code: {response.status_code})"
                 
             results = response.json()
             if 'items' not in results:
                 print("No search results found")
-                return self.ddg_tool.run(query)  # Fall back to DuckDuckGo
+                return f"No search results found for: {query}"
                 
             # Extract and format search results
             formatted_results = ""
@@ -176,9 +178,13 @@ class GeminiAgent:
                 
             return formatted_results
             
+        except requests.exceptions.Timeout:
+            print(f"Google Search API timeout for query: {query}")
+            return f"Search timed out for: {query}"
+            
         except Exception as e:
             print(f"Google Search API error: {str(e)}")
-            return self.ddg_tool.run(query)  # Fall back to DuckDuckGo
+            return f"Search error for: {query} ({str(e)})"
         
     async def _handle_actor_show_question(self, question: str) -> str:
         """Handle questions about actors, TV shows, and movies with enhanced search"""
@@ -258,55 +264,52 @@ If the answer is a person's name, provide ONLY their first name as requested."""
     async def _multi_search(self, queries: list, num_results: int = 5, include_sites: list = None) -> str:
         """Perform multiple searches and combine the results with enhanced options"""
         combined_results = ""
+        success_count = 0
         
-        # Define authoritative sites for different domains
+        # Define authoritative sites for different domains - just use Wikipedia for now
         authoritative_sites = {
-            "music": ["grammy.org", "billboard.com", "allmusic.com", "musicbrainz.org"],
-            "competition": ["wikipedia.org", "britannica.com"],
-            "awards": ["nobelprize.org", "pulitzer.org", "oscars.org"],
-            "classical": ["classicalmusic.org", "gramophone.co.uk", "medici.tv"]
+            "competition": ["wikipedia.org"],
+            "awards": ["wikipedia.org"]
         }
         
-        # Process each query
-        for i, query in enumerate(queries):
-            print(f"Searching for query {i+1}/{len(queries)}: {query[:50]}...")
+        # Process each query - limit to max 3 queries to avoid timeouts
+        max_queries = min(3, len(queries))
+        for i, query in enumerate(queries[:max_queries]):
+            print(f"Searching for query {i+1}/{max_queries}: {query[:50]}...")
             try:
                 # Standard search
                 result = await self._google_search(query, num_results)
-                if result:
+                if result and not result.startswith("Search"):
                     combined_results += f"=== Results for query: {query} ===\n{result}\n\n"
+                    success_count += 1
                     
-                # If specific sites are provided, search those too
-                if include_sites:
-                    for site in include_sites:
-                        site_result = await self._google_search(query, num_results=3, site_restrict=site)
-                        if site_result and "no results" not in site_result.lower():
-                            combined_results += f"=== Results from {site} for: {query} ===\n{site_result}\n\n"
-                            
-                # For competition questions, try some authoritative sites
+                # If we already have good results, don't do site-specific searches
+                if success_count >= 2:
+                    continue
+                    
+                # For competition questions, try Wikipedia
                 if "competition" in query.lower() or "award" in query.lower() or "prize" in query.lower():
-                    for site in authoritative_sites["competition"] + authoritative_sites["awards"]:
-                        site_result = await self._google_search(query, num_results=2, site_restrict=site)
-                        if site_result and "no results" not in site_result.lower():
-                            combined_results += f"=== Results from {site} for: {query} ===\n{site_result}\n\n"
+                    site_result = await self._google_search(query, num_results=2, site_restrict="wikipedia.org")
+                    if site_result and not site_result.startswith("Search"):
+                        combined_results += f"=== Results from wikipedia.org for: {query} ===\n{site_result}\n\n"
+                        success_count += 1
                             
-                # For classical music questions, try classical music sites
-                if "classical" in query.lower() or "conductor" in query.lower() or "orchestra" in query.lower():
-                    for site in authoritative_sites["classical"]:
-                        site_result = await self._google_search(query, num_results=2, site_restrict=site)
-                        if site_result and "no results" not in site_result.lower():
-                            combined_results += f"=== Results from {site} for: {query} ===\n{site_result}\n\n"
-                            
-                # Try exact term matching for key entities
-                key_terms = self._extract_key_terms(query)
-                if key_terms:
-                    exact_result = await self._google_search(query, num_results=3, exact_terms=key_terms)
-                    if exact_result and "no results" not in exact_result.lower():
-                        combined_results += f"=== Results with exact match for '{key_terms}' ===\n{exact_result}\n\n"
+                # Try exact term matching for key entities if we still need results
+                if success_count < 2:
+                    key_terms = self._extract_key_terms(query)
+                    if key_terms:
+                        exact_result = await self._google_search(query, num_results=3, exact_terms=key_terms)
+                        if exact_result and not exact_result.startswith("Search"):
+                            combined_results += f"=== Results with exact match for '{key_terms}' ===\n{exact_result}\n\n"
+                            success_count += 1
                         
             except Exception as e:
                 print(f"Search failed for query {i+1}: {e}")
                 
+        # If we didn't get any results, add a fallback message
+        if not combined_results:
+            combined_results = "No search results found. Using model knowledge to answer the question."
+                
         return combined_results
         
     def _extract_key_terms(self, query: str) -> str: