Update app.py

app.py

@@ -3,7 +3,7 @@ import re
 import requests
 import gradio as gr
 import pandas as pd
-from smolagents import ToolCallingAgent, tool, LiteLLMModel
+from smolagents import CodeAgent, DuckDuckGoSearchTool, InferenceClientModel, tool, VisitWebpageTool
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
@@ -13,50 +13,21 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 # ============================================
 
 @tool
-def web_search(query: str) -> str:
-    """
-    Searches the web and returns results.
-    
-    Args:
-        query: What to search for
-    
-    Returns:
-        Search results
-    """
-    try:
-        from duckduckgo_search import DDGS
-        with DDGS() as ddgs:
-            results = list(ddgs.text(query, max_results=3))
-        if not results:
-            return "No results found."
-        output = []
-        for r in results:
-            output.append(f"- {r.get('title', '')}: {r.get('body', '')}")
-        return "\n".join(output)
-    except Exception as e:
-        return f"Search error: {e}"
-
-
-@tool
-def visit_webpage(url: str) -> str:
+def calculator(expression: str) -> str:
     """
-    Gets text content from a webpage.
+    Calculates a math expression.
     
     Args:
-        url: The webpage URL
+        expression: Math expression like "2+2" or "10*5"
     
     Returns:
-        Page text content
+        Result as string
     """
+    import math
     try:
-        from bs4 import BeautifulSoup
-        headers = {"User-Agent": "Mozilla/5.0"}
-        response = requests.get(url, headers=headers, timeout=10)
-        soup = BeautifulSoup(response.text, 'html.parser')
-        for tag in soup(['script', 'style', 'nav', 'footer']):
-            tag.decompose()
-        text = soup.get_text(separator=' ', strip=True)
-        return text[:5000] if len(text) > 5000 else text
+        safe = {"sqrt": math.sqrt, "pow": pow, "abs": abs, "round": round,
+                "sin": math.sin, "cos": math.cos, "pi": math.pi, "log": math.log}
+        return str(eval(expression, {"__builtins__": {}}, safe))
     except Exception as e:
         return f"Error: {e}"
 
@@ -64,67 +35,29 @@ def visit_webpage(url: str) -> str:
 @tool
 def wikipedia_search(topic: str) -> str:
     """
-    Searches Wikipedia for a topic.
+    Gets Wikipedia summary for a topic.
     
     Args:
-        topic: What to look up
+        topic: What to search
     
     Returns:
-        Wikipedia summary
+        Wikipedia extract
     """
     try:
         url = "https://en.wikipedia.org/w/api.php"
-        params = {
-            "action": "query",
-            "list": "search",
-            "srsearch": topic,
-            "format": "json",
-            "srlimit": 1
-        }
-        response = requests.get(url, params=params, timeout=10)
-        data = response.json()
+        params = {"action": "query", "list": "search", "srsearch": topic, "format": "json", "srlimit": 1}
+        data = requests.get(url, params=params, timeout=10).json()
         
         if not data.get("query", {}).get("search"):
             return "No Wikipedia article found."
         
         title = data["query"]["search"][0]["title"]
-        
-        params2 = {
-            "action": "query",
-            "titles": title,
-            "prop": "extracts",
-            "exintro": True,
-            "explaintext": True,
-            "format": "json"
-        }
-        response = requests.get(url, params=params2, timeout=10)
-        pages = response.json().get("query", {}).get("pages", {})
+        params2 = {"action": "query", "titles": title, "prop": "extracts", "exintro": True, "explaintext": True, "format": "json"}
+        pages = requests.get(url, params=params2, timeout=10).json().get("query", {}).get("pages", {})
         
         for page in pages.values():
-            extract = page.get("extract", "")
-            return f"{title}: {extract[:3000]}"
-        return "Could not get content."
-    except Exception as e:
-        return f"Error: {e}"
-
-
-@tool
-def calculator(expression: str) -> str:
-    """
-    Calculates a math expression.
-    
-    Args:
-        expression: Math like "2+2" or "sqrt(16)"
-    
-    Returns:
-        The result
-    """
-    import math
-    try:
-        safe = {"sqrt": math.sqrt, "pow": pow, "abs": abs, "round": round,
-                "sin": math.sin, "cos": math.cos, "pi": math.pi, "e": math.e,
-                "log": math.log, "floor": math.floor, "ceil": math.ceil}
-        return str(eval(expression, {"__builtins__": {}}, safe))
+            return page.get("extract", "No content")[:3000]
+        return "No content"
     except Exception as e:
         return f"Error: {e}"
 
@@ -132,13 +65,13 @@ def calculator(expression: str) -> str:
 @tool
 def get_task_file(task_id: str) -> str:
     """
-    Gets the file attached to a GAIA task.
+    Gets file content for a GAIA task.
     
     Args:
         task_id: The task ID
     
     Returns:
-        File content or description
+        File content
     """
     try:
         url = f"https://agents-course-unit4-scoring.hf.space/files/{task_id}"
@@ -148,37 +81,27 @@ def get_task_file(task_id: str) -> str:
             return "No file for this task."
         
         content_type = response.headers.get('content-type', '').lower()
-        disp = response.headers.get('content-disposition', '')
         
-        filename = "file"
-        if 'filename=' in disp:
-            filename = disp.split('filename=')[-1].strip('"\'')
+        if 'text' in content_type or 'json' in content_type:
+            return response.text[:5000]
         
-        # Text files
-        if 'text' in content_type or filename.endswith(('.txt', '.csv', '.json', '.py', '.md')):
-            content = response.text
-            return f"File '{filename}':\n{content[:6000]}"
-        
-        # Excel
-        if filename.endswith(('.xlsx', '.xls')):
+        if 'spreadsheet' in content_type or 'excel' in content_type:
             try:
                 from io import BytesIO
                 df = pd.read_excel(BytesIO(response.content))
-                return f"Excel '{filename}':\n{df.to_string()}"
+                return df.to_string()
             except:
-                return f"Excel file: {filename} (could not parse)"
-        
-        # Other
-        return f"File: {filename} ({content_type}, {len(response.content)} bytes)"
+                return "Excel file (cannot read)"
         
+        return f"Binary file: {content_type}"
     except Exception as e:
         return f"Error: {e}"
 
 
 @tool
-def reverse_string(text: str) -> str:
+def reverse_text(text: str) -> str:
     """
-    Reverses a string.
+    Reverses text.
     
     Args:
         text: Text to reverse
@@ -190,62 +113,62 @@ def reverse_string(text: str) -> str:
 
 
 # ============================================
-# AGENT
+# AGENT CLASS
 # ============================================
 
 class BasicAgent:
     def __init__(self):
-        print("Initializing agent with Groq...")
-        
-        api_key = os.environ.get("GROQ_API_KEY")
-        if not api_key:
-            raise ValueError("GROQ_API_KEY not found in environment!")
+        print("Initializing HuggingFace agent...")
         
-        self.model = LiteLLMModel(
-            model_id="groq/llama-3.3-70b-versatile",
-            api_key=api_key,
+        # Use Qwen 32B - good balance of speed and quality
+        self.model = InferenceClientModel(
+            model_id="Qwen/Qwen2.5-Coder-32B-Instruct",
+            token=os.environ.get("HF_TOKEN"),
+            timeout=60,
         )
         
-        self.agent = ToolCallingAgent(
+        self.agent = CodeAgent(
             model=self.model,
             tools=[
-                web_search,
-                visit_webpage,
+                DuckDuckGoSearchTool(),
+                VisitWebpageTool(),
                 wikipedia_search,
                 calculator,
                 get_task_file,
-                reverse_string,
+                reverse_text,
             ],
-            max_steps=8,
-            verbosity_level=1,
+            max_steps=5,  # Keep it short to avoid timeouts
+            verbosity_level=2,
         )
         print("Agent ready!")
     
     def __call__(self, question: str, task_id: str = None) -> str:
+        print(f"  Processing: {question[:60]}...")
+        
         try:
-            prompt = f"""Answer this question. Use tools if needed. Give ONLY the final answer, nothing else.
-
-If there's a file mentioned, use get_task_file("{task_id}") first.
+            prompt = f"""Answer this question concisely. Use tools if needed.
+If a file is mentioned, use get_task_file("{task_id}").
+Give ONLY the final answer.
 
 Question: {question}"""
 
             result = self.agent.run(prompt)
             answer = str(result).strip()
             
-            # Clean prefixes
-            for prefix in ["Answer:", "Final answer:", "The answer is:", "FINAL ANSWER:"]:
+            # Clean up
+            for prefix in ["Answer:", "Final answer:", "The answer is"]:
                 if answer.lower().startswith(prefix.lower()):
                     answer = answer[len(prefix):].strip()
             
-            # Remove quotes
             if answer.startswith('"') and answer.endswith('"'):
                 answer = answer[1:-1]
             
+            print(f"  Answer: {answer[:60]}")
             return answer
             
         except Exception as e:
-            print(f"Error: {e}")
-            return "Unable to determine answer"
+            print(f"  Error: {e}")
+            return "Unable to answer"
 
 
 # ============================================
@@ -253,33 +176,30 @@ Question: {question}"""
 # ============================================
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
-    space_id = os.getenv("SPACE_ID")
-
     if not profile:
         return "Please log in first.", None
 
     username = profile.username
+    space_id = os.getenv("SPACE_ID")
+    
+    print(f"\n{'='*50}")
     print(f"User: {username}")
-
-    # Check API key
-    if not os.environ.get("GROQ_API_KEY"):
-        return "ERROR: GROQ_API_KEY not set in Space secrets!", None
+    print(f"{'='*50}")
 
     # Init agent
     try:
         agent = BasicAgent()
     except Exception as e:
-        return f"Agent init failed: {e}", None
+        return f"Agent failed to init: {e}", None
 
     # Get questions
     try:
-        response = requests.get(f"{DEFAULT_API_URL}/questions", timeout=15)
-        questions = response.json()
-        print(f"Got {len(questions)} questions")
+        questions = requests.get(f"{DEFAULT_API_URL}/questions", timeout=15).json()
+        print(f"Fetched {len(questions)} questions\n")
     except Exception as e:
-        return f"Failed to get questions: {e}", None
+        return f"Failed to fetch questions: {e}", None
 
-    # Process questions
+    # Process each question
     results = []
     answers = []
     
@@ -287,21 +207,16 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         task_id = q.get("task_id")
         question = q.get("question", "")
         
-        print(f"\n[{i+1}/{len(questions)}] {question[:80]}...")
+        print(f"[{i+1}/{len(questions)}] {task_id}")
         
         try:
             answer = agent(question, task_id)
-            print(f"  → {answer[:80]}")
         except Exception as e:
-            answer = f"Error: {e}"
-            print(f"  → ERROR: {e}")
+            answer = "Error"
+            print(f"  Failed: {e}")
         
         answers.append({"task_id": task_id, "submitted_answer": answer})
-        results.append({
-            "Q#": i+1,
-            "Question": question[:60] + "...",
-            "Answer": answer[:100]
-        })
+        results.append({"#": i+1, "Question": question[:50]+"...", "Answer": answer[:80]})
 
     # Submit
     print(f"\nSubmitting {len(answers)} answers...")
@@ -312,19 +227,15 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             "agent_code": f"https://huggingface.co/spaces/{space_id}/tree/main",
             "answers": answers
         }
-        response = requests.post(f"{DEFAULT_API_URL}/submit", json=submission, timeout=60)
-        result = response.json()
+        result = requests.post(f"{DEFAULT_API_URL}/submit", json=submission, timeout=60).json()
         
         score = result.get('score', 0)
         correct = result.get('correct_count', 0)
         total = result.get('total_attempted', 0)
         
-        status = f"""✅ Submitted!
-
-Score: {score}% ({correct}/{total} correct)
-
-{"🎉 PASSED! You got 30%+" if score >= 30 else f"Need {30-score}% more to pass"}
-"""
+        status = f"✅ Done!\n\nScore: {score}% ({correct}/{total})\n\n"
+        status += "🎉 PASSED!" if score >= 30 else f"Need {30-score}% more to pass"
+        
         return status, pd.DataFrame(results)
         
     except Exception as e:
@@ -337,29 +248,16 @@ Score: {score}% ({correct}/{total} correct)
 
 with gr.Blocks() as demo:
     gr.Markdown("# 🎯 GAIA Agent - Unit 4")
-    gr.Markdown("""
-    **Powered by Groq + Llama 3.3 70B**
-    
-    1. Add `GROQ_API_KEY` to Space secrets
-    2. Log in below
-    3. Click Run
-    """)
+    gr.Markdown("Using **HuggingFace** + **Qwen 32B**")
 
     gr.LoginButton()
     run_btn = gr.Button("🚀 Run Evaluation", variant="primary")
-    status = gr.Textbox(label="Status", lines=6)
+    status = gr.Textbox(label="Status", lines=5)
     table = gr.DataFrame(label="Results")
 
     run_btn.click(run_and_submit_all, outputs=[status, table])
 
 if __name__ == "__main__":
-    print("=" * 50)
-    print("GAIA Agent Starting")
-    print("=" * 50)
-    
-    if os.environ.get("GROQ_API_KEY"):
-        print("✅ GROQ_API_KEY found")
-    else:
-        print("❌ GROQ_API_KEY missing!")
-    
+    print("Starting GAIA Agent (HuggingFace)...")
+    print(f"HF_TOKEN: {'✅ Found' if os.environ.get('HF_TOKEN') else '❌ Missing'}")
     demo.launch()