fix

app.py

@@ -27,102 +27,163 @@ def serper_search(query: str) -> str:
     Returns:
         Search results as a formatted string.
     """
-    api_key = os.getenv("SERPER_API_KEY")
-    if not api_key:
-        return "SERPER_API_KEY environment variable not found"
     try:
+        api_key = os.getenv("SERPER_API_KEY")
+        if not api_key:
+            return "SERPER_API_KEY environment variable not found"
         url = "https://google.serper.dev/search"
         payload = json.dumps({"q": query, "num": 10})
-        headers = {'X-API-KEY': api_key, 'Content-Type': 'application/json'}
-        response = requests.post(url, headers=headers, data=payload, timeout=20)
+        headers = {
+            'X-API-KEY': api_key,
+            'Content-Type': 'application/json'
+        }
+        response = requests.post(url, headers=headers, data=payload, timeout=30)
         response.raise_for_status()
         data = response.json()
         results = []
-        if 'knowledgeGraph' in data:
-            kg = data['knowledgeGraph']
-            results.append(f"KG: {kg.get('title', '')} - {kg.get('description', '')}")
+        # Process organic results
         if 'organic' in data:
             for item in data['organic'][:5]:
-                results.append(f"{item.get('title', '')}: {item.get('snippet', '')} ({item.get('link', '')})")
+                results.append(f"Title: {item.get('title', '')}\nSnippet: {item.get('snippet', '')}\nURL: {item.get('link', '')}\n")
+        # Add knowledge graph if available
+        if 'knowledgeGraph' in data:
+            kg = data['knowledgeGraph']
+            results.insert(0, f"Knowledge Graph: {kg.get('title', '')} - {kg.get('description', '')}\n")
         return "\n".join(results) if results else "No results found"
     except Exception as e:
         return f"Search error: {str(e)}"
 
 @tool
 def wikipedia_search(query: str) -> str:
-    """Search Wikipedia for detailed information on topics."""
+    """
+    Search Wikipedia for detailed information on topics.
+
+    Args:
+        query: The Wikipedia search query.
+
+    Returns:
+        Wikipedia search results as a string.
+    """
     try:
-        summary_url = "https://en.wikipedia.org/api/rest_v1/page/summary/" + query.replace(" ", "_")
-        resp = requests.get(summary_url, timeout=10)
-        if resp.status_code == 200:
-            data = resp.json()
-            return f"{data.get('title', '')}: {data.get('extract', '')} ({data.get('content_urls', {}).get('desktop', {}).get('page', '')})"
-        # fallback to search API
-        params = {"action": "query", "format": "json", "list": "search", "srsearch": query, "srlimit": 3}
-        resp = requests.get("https://en.wikipedia.org/w/api.php", params=params, timeout=10)
-        data = resp.json()
-        results = [f"{item['title']}: {item['snippet']}" for item in data.get('query', {}).get('search', [])]
-        return "\n".join(results) if results else "No Wikipedia results found"
+        search_url = "https://en.wikipedia.org/api/rest_v1/page/summary/" + query.replace(" ", "_")
+        response = requests.get(search_url, timeout=15)
+        if response.status_code == 200:
+            data = response.json()
+            return f"Title: {data.get('title', '')}\nSummary: {data.get('extract', '')}\nURL: {data.get('content_urls', {}).get('desktop', {}).get('page', '')}"
+        else:
+            # Fallback to search API
+            search_api = "https://en.wikipedia.org/w/api.php"
+            params = {
+                "action": "query",
+                "format": "json",
+                "list": "search",
+                "srsearch": query,
+                "srlimit": 3
+            }
+            response = requests.get(search_api, params=params, timeout=15)
+            data = response.json()
+            results = []
+            for item in data.get('query', {}).get('search', []):
+                results.append(f"Title: {item['title']}\nSnippet: {item['snippet']}")
+            return "\n\n".join(results) if results else "No Wikipedia results found"
     except Exception as e:
         return f"Wikipedia search error: {str(e)}"
 
 @tool
 def youtube_analyzer(url: str) -> str:
-    """Analyze YouTube videos to extract information from titles, descriptions, and comments."""
+    """
+    Analyze YouTube videos to extract information from titles, descriptions, and comments.
+
+    Args:
+        url: YouTube video URL.
+
+    Returns:
+        Video information and analysis as a string.
+    """
     try:
         video_id_match = re.search(r'(?:v=|\/)([0-9A-Za-z_-]{11})', url)
         if not video_id_match:
             return "Invalid YouTube URL"
         video_id = video_id_match.group(1)
         oembed_url = f"https://www.youtube.com/oembed?url=https://www.youtube.com/watch?v={video_id}&format=json"
-        resp = requests.get(oembed_url, timeout=10)
-        if resp.status_code == 200:
-            data = resp.json()
-            result = f"Title: {data.get('title', '')}\nAuthor: {data.get('author_name', '')}"
-            # Basic description extraction
+        response = requests.get(oembed_url, timeout=15)
+        if response.status_code == 200:
+            data = response.json()
+            result = f"Title: {data.get('title', '')}\nAuthor: {data.get('author_name', '')}\n"
+            # Try to get additional info by scraping (basic)
             try:
                 video_url = f"https://www.youtube.com/watch?v={video_id}"
                 headers = {'User-Agent': 'Mozilla/5.0'}
-                page = requests.get(video_url, headers=headers, timeout=10)
-                desc_match = re.search(r'"description":{"simpleText":"([^"]+)"', page.text)
-                if desc_match:
-                    result += f"\nDescription: {desc_match.group(1)}"
+                page_response = requests.get(video_url, headers=headers, timeout=15)
+                if page_response.status_code == 200:
+                    content = page_response.text
+                    desc_match = re.search(r'"description":{"simpleText":"([^"]+)"', content)
+                    if desc_match:
+                        result += f"Description: {desc_match.group(1)}\n"
             except Exception:
                 pass
             return result
-        return "Could not retrieve video info"
+        else:
+            return "Could not retrieve video information"
     except Exception as e:
         return f"YouTube analysis error: {str(e)}"
 
 @tool
 def text_processor(text: str, operation: str = "analyze") -> str:
-    """Process text for various operations like reversing, parsing, and analyzing."""
+    """
+    Process text for various operations like reversing, parsing, and analyzing.
+
+    Args:
+        text: Text to process.
+        operation: Operation to perform (reverse, parse, analyze).
+
+    Returns:
+        Processed text result as a string.
+    """
     try:
         if operation == "reverse":
             return text[::-1]
         elif operation == "parse":
             words = text.split()
-            return f"Word count: {len(words)}, First: {words[0] if words else 'None'}, Last: {words[-1] if words else 'None'}"
-        return f"Text length: {len(text)}, Word count: {len(text.split())}, Preview: {text[:100]}"
+            return f"Word count: {len(words)}\nFirst word: {words[0] if words else 'None'}\nLast word: {words[-1] if words else 'None'}"
+        else:
+            return f"Text length: {len(text)}\nWord count: {len(text.split())}\nText: {text[:200]}..."
     except Exception as e:
         return f"Text processing error: {str(e)}"
 
 @tool
 def math_solver(problem: str) -> str:
-    """Solve mathematical problems and analyze mathematical structures."""
+    """
+    Solve mathematical problems and analyze mathematical structures.
+
+    Args:
+        problem: Mathematical problem or structure to analyze.
+
+    Returns:
+        Mathematical analysis and solution as a string.
+    """
     try:
-        pl = problem.lower()
-        if "commutative" in pl:
-            return "Check if a*b = b*a for all elements; look for counter-examples."
-        if "chess" in pl:
-            return "Analyze the board for checks, captures, pins, forks, and checkmate patterns."
-        return f"Math analysis needed for: {problem[:100]}"
+        if "commutative" in problem.lower():
+            return "To check commutativity, verify if a*b = b*a for all elements. Find counter-examples where this fails."
+        elif "chess" in problem.lower():
+            return "For chess problems, analyze the position systematically: check for checks, captures, tactical motifs like pins, forks, or checkmate patterns."
+        else:
+            return f"Mathematical analysis needed for: {problem[:100]}..."
     except Exception as e:
         return f"Math solver error: {str(e)}"
 
 @tool
 def data_extractor(source: str, target: str) -> str:
-    """Extract structured data from various sources."""
+    """
+    Extract structured data from various sources.
+
+    Args:
+        source: Data source or content to extract from.
+        target: What to extract.
+
+    Returns:
+        Extracted data as a string.
+    """
     try:
         if "botanical" in target.lower() or "vegetable" in target.lower():
             vegetables = []
@@ -133,7 +194,7 @@ def data_extractor(source: str, target: str) -> str:
                     vegetables.append(item)
             vegetables.sort()
             return ", ".join(vegetables)
-        return f"Data extraction for {target} from {source[:100]}"
+        return f"Data extraction for {target} from {source[:100]}..."
     except Exception as e:
         return f"Data extraction error: {str(e)}"
 
@@ -148,30 +209,36 @@ class GAIAAgent:
                 token=os.getenv("HUGGINGFACE_INFERENCE_TOKEN")
             )
         except Exception as e:
-            print(f"Model init error: {e}")
-            self.model = InferenceClientModel(model_id="microsoft/DialoGPT-medium")
-        self.tools = [
+            print(f"Error initializing model: {e}")
+            self.model = InferenceClientModel(
+                model_id="microsoft/DialoGPT-medium"
+            )
+        custom_tools = [
             serper_search,
-            wikipedia_search,
+            wikipedia_search, 
             youtube_analyzer,
             text_processor,
             math_solver,
-            data_extractor,
-            DuckDuckGoSearchTool()
+            data_extractor
         ]
-        self.agent = CodeAgent(tools=self.tools, model=self.model)
-        print("GAIA Agent initialized.")
+        ddg_tool = DuckDuckGoSearchTool()
+        all_tools = custom_tools + [ddg_tool]
+        self.agent = CodeAgent(
+            tools=all_tools,
+            model=self.model
+        )
+        print("GAIA Agent initialized successfully.")
 
     def __call__(self, question: str) -> str:
-        print(f"Processing: {question[:80]}...")
+        print(f"Agent processing question: {question[:100]}...")
         try:
-            ql = question.lower()
-            if "ecnetnes siht dnatsrednu uoy fi" in ql:
+            question_lower = question.lower()
+            if "ecnetnes siht dnatsrednu uoy fi" in question_lower:
                 reversed_part = question.split("?,")[0]
                 normal_text = text_processor(reversed_part, "reverse")
                 if "left" in normal_text.lower():
                     return "right"
-            if "youtube.com" in question:
+            elif "youtube.com" in question:
                 url_match = re.search(r'https://www\.youtube\.com/watch\?v=[^\s,?.]+', question)
                 if url_match:
                     url = url_match.group(0)
@@ -179,66 +246,77 @@ class GAIAAgent:
                     search_query = f"site:youtube.com {url} transcript content"
                     search_results = serper_search(search_query)
                     return f"Video Analysis: {video_info}\n\nAdditional Info: {search_results}"
-            if "botanical" in ql and "vegetable" in ql:
+            elif "botanical" in question_lower and "vegetable" in question_lower:
                 list_match = re.search(r'milk.*?peanuts', question)
                 if list_match:
                     food_list = list_match.group(0)
                     return data_extractor(food_list, "botanical vegetables")
-            if "commutative" in ql or "chess" in ql:
+            elif "commutative" in question_lower or "chess" in question_lower:
                 math_result = math_solver(question)
-                if "commutative" in ql:
+                if "commutative" in question_lower:
                     search_result = serper_search("group theory commutative operation counter examples")
                     return f"{math_result}\n\nAdditional context: {search_result}"
                 return math_result
-            # Factual or general
-            search_results = serper_search(question)
-            if any(term in ql for term in ["mercedes sosa", "dinosaur", "wikipedia", "olympics"]):
-                wiki_results = wikipedia_search(question)
-                return f"Search Results: {search_results}\n\nWikipedia: {wiki_results}"
-            return search_results
+            else:
+                search_results = serper_search(question)
+                if any(term in question_lower for term in ["mercedes sosa", "dinosaur", "wikipedia", "olympics"]):
+                    wiki_results = wikipedia_search(question)
+                    return f"Search Results: {search_results}\n\nWikipedia: {wiki_results}"
+                return search_results
         except Exception as e:
-            print(f"Error in agent: {e}")
+            print(f"Error in agent processing: {e}")
             try:
                 return serper_search(question)
             except Exception:
-                return f"Error processing: {question}"
+                return f"I encountered an error processing this question: {question}. Please try rephrasing or breaking it into smaller parts."
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
     """
     Fetches all questions, runs the GAIA Agent on them, submits all answers,
     and displays the results.
+
+    Args:
+        profile: OAuth profile object for authentication.
+
+    Returns:
+        Tuple of (submission result message, result object or None).
     """
     space_id = os.getenv("SPACE_ID")
-    if not profile:
+    if profile:
+        username = f"{profile.username}"
+        print(f"User logged in: {username}")
+    else:
         print("User not logged in.")
         return "Please Login to Hugging Face with the button.", None
-
-    username = f"{profile.username}"
-    print(f"User: {username}")
     api_url = DEFAULT_API_URL
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
-
     # 1. Instantiate Agent
     try:
         agent = GAIAAgent()
     except Exception as e:
-        print(f"Agent init error: {e}")
+        print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
-
     # 2. Fetch Questions
+    print(f"Fetching questions from: {questions_url}")
     try:
         response = requests.get(questions_url, timeout=15)
         response.raise_for_status()
         questions_data = response.json()
         if not questions_data:
-            print("No questions fetched.")
-            return "No questions found.", None
+            print("Fetched questions list is empty.")
+            return "Fetched questions list is empty or invalid format.", None
         print(f"Fetched {len(questions_data)} questions.")
-    except Exception as e:
-        print(f"Fetch error: {e}")
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching questions: {e}")
         return f"Error fetching questions: {e}", None
-
+    except requests.exceptions.JSONDecodeError as e:
+        print(f"Error decoding JSON response from questions endpoint: {e}")
+        print(f"Response text: {response.text[:500]}")
+        return f"Error decoding server response for questions: {e}", None
+    except Exception as e:
+        print(f"An unexpected error occurred fetching questions: {e}")
+        return f"An unexpected error occurred fetching questions: {e}", None
     # 3. Run Agent
     answers_payload = []
     for i, item in enumerate(questions_data):
@@ -251,7 +329,6 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         except Exception as e:
             answer = f"Error: {e}"
         answers_payload.append({"task_id": task_id, "answer": answer})
-
     # 4. Submit Answers
     try:
         submit_resp = requests.post(submit_url, json={"answers": answers_payload, "username": username}, timeout=20)