Update app.py

app.py

@@ -6,17 +6,16 @@ from smolagents import ToolCallingAgent, tool
 from duckduckgo_search import DDGS
 import math
 import re
-from datetime import datetime, timedelta
-import time
+from datetime import datetime
 
-# --- Enhanced Tools with Proper Error Handling ---
+# --- Tools with Proper Docstrings ---
 @tool
-def duck_search(query: str) -> str:
-    """Searches the web using DuckDuckGo.
+def web_search(query: str) -> str:
+    """Performs a web search using DuckDuckGo.
     
     Args:
         query: The search query string.
-    
+        
     Returns:
         A formatted string with search results.
     """
@@ -31,45 +30,40 @@ def duck_search(query: str) -> str:
         return f"Search error: {str(e)}"
 
 @tool
-def advanced_calculator(expression: str) -> str:
+def calculate(expression: str) -> str:
     """Evaluates mathematical expressions.
     
     Args:
         expression: The math expression to evaluate.
-    
+        
     Returns:
-        The result as a string.
+        The result as a string or error message.
     """
     try:
         # Safe evaluation environment
-        safe_dict = {k: v for k, v in math.__dict__.items() if not k.startswith("__")}
+        safe_dict = {k: v for k, v in math.__dict__.items() 
+                    if not k.startswith("__")}
         safe_dict.update({
             '__builtins__': None,
             'abs': abs,
-            'round': round,
-            'min': min,
-            'max': max
+            'round': round
         })
-        
-        # Handle percentage expressions
-        if '%' in expression:
-            expression = expression.replace('%', '/100')
-            
         result = eval(expression, {'__builtins__': None}, safe_dict)
         return str(result)
     except Exception as e:
         return f"Calculation error: {str(e)}"
 
-# --- Simplified Agent Class ---
+# --- Robust Agent Class ---
 class GAIAAgent:
     def __init__(self):
+        """Initialize the agent with proper error handling."""
         try:
             self.agent = ToolCallingAgent(
-                name="GAIA_Agent",
+                name="GAIA_Submission_Agent",
                 description="Agent for GAIA benchmark tasks",
-                tools=[duck_search, advanced_calculator],
-                model="gpt-3.5-turbo",  # Use this as default
-                planning_interval=5
+                tools=[web_search, calculate],
+                model="gpt-3.5-turbo",
+                planning_interval=3  # Changed from max_iterations
             )
             print("✅ Agent initialized successfully")
         except Exception as e:
@@ -79,77 +73,59 @@ class GAIAAgent:
     def __call__(self, question: str) -> str:
         """Process a question with proper error handling."""
         try:
-            # Simple preprocessing
-            question = question.strip()
-            
+            if not question or not isinstance(question, str):
+                return "Invalid question format"
+                
             # Run the agent
             response = self.agent.run(question)
             
-            # Basic post-processing
-            if not response:
-                return "Could not generate an answer."
-                
-            return str(response)[:1000]  # Limit response length
-            
+            # Ensure we return a string
+            if response is None:
+                return "No response generated"
+            return str(response)
         except Exception as e:
             print(f"⚠️ Processing error: {str(e)}")
             return f"Error processing question: {str(e)}"
 
-# --- Evaluation & Submission ---
-def run_and_submit_all(profile: gr.OAuthProfile | None):
+# --- Submission Logic ---
+def submit_answers(profile: gr.OAuthProfile | None):
     if not profile:
-        return "Please login to Hugging Face.", None
+        return "Please login to Hugging Face", None
 
     try:
         agent = GAIAAgent()
-    except Exception as e:
-        return f"Agent initialization failed: {str(e)}", None
-
-    try:
         response = requests.get(
             "https://agents-course-unit4-scoring.hf.space/questions",
-            timeout=30
+            timeout=20
         )
         questions = response.json()
+        
         if not questions:
-            return "No questions received.", None
-    except Exception as e:
-        return f"Failed to fetch questions: {str(e)}", None
-
-    results = []
-    answers = []
-    
-    for item in questions[:20]:  # Process first 20 questions for testing
-        task_id = item.get("task_id")
-        question = item.get("question")
+            return "No questions received", None
+            
+        answers = []
+        results = []
         
-        if not task_id or not question:
-            continue
+        for item in questions[:15]:  # Process first 15 for testing
+            task_id = item.get("task_id")
+            question = item.get("question")
             
-        try:
+            if not task_id or not question:
+                continue
+                
             answer = agent(question)
             answers.append({
                 "task_id": task_id,
-                "submitted_answer": answer
+                "submitted_answer": answer[:1000]  # Limit answer length
             })
             results.append({
                 "Task ID": task_id,
                 "Question": question[:100],
                 "Answer": answer[:200]
             })
-        except Exception as e:
-            answers.append({
-                "task_id": task_id,
-                "submitted_answer": f"Error: {str(e)}"
-            })
-            results.append({
-                "Task ID": task_id,
-                "Question": question[:100],
-                "Answer": f"Error: {str(e)}"
-            })
-
-    try:
-        response = requests.post(
+            
+        # Submit answers
+        submit_response = requests.post(
             "https://agents-course-unit4-scoring.hf.space/submit",
             json={
                 "username": profile.username,
@@ -158,27 +134,28 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             },
             timeout=60
         )
-        data = response.json()
+        data = submit_response.json()
+        
         return (
             f"Submitted {len(answers)} answers\n"
             f"Score: {data.get('score', 'N/A')}%\n"
-            f"Correct: {data.get('correct_count', 0)}/{data.get('total_attempted', 0)}\n"
-            f"Message: {data.get('message', '')}",
+            f"Correct: {data.get('correct_count', 0)}/{len(answers)}",
             pd.DataFrame(results)
         )
+        
     except Exception as e:
-        return f"Submission failed: {str(e)}", pd.DataFrame(results)
+        return f"Error: {str(e)}", None
 
 # --- Gradio Interface ---
 with gr.Blocks() as demo:
-    gr.Markdown("# GAIA Agent")
+    gr.Markdown("# GAIA Submission Agent")
     gr.LoginButton()
-    submit_btn = gr.Button("Run & Submit", variant="primary")
+    submit_btn = gr.Button("Run Evaluation", variant="primary")
     output = gr.Textbox(label="Results")
     table = gr.DataFrame(label="Details")
     
     submit_btn.click(
-        fn=run_and_submit_all,
+        fn=submit_answers,
         outputs=[output, table]
     )