Update app.py

app.py

@@ -1,214 +1,154 @@
 import os
 import gradio as gr
 import requests
-import inspect
 import pandas as pd
-import json
-import re
-from typing import Dict, List, Any, Optional
-import asyncio
-from datetime import datetime
-import tempfile
-import base64
-from io import BytesIO
-from PIL import Image
-import numpy as np
-
-# Additional imports for enhanced capabilities
-try:
-    from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
-    import torch
-except ImportError:
-    print("Warning: transformers not available. Install with: pip install transformers torch")
-
-try:
-    from sentence_transformers import SentenceTransformer
-except ImportError:
-    print("Warning: sentence-transformers not available. Install with: pip install sentence-transformers")
-
-try:
-    import wikipediaapi
-except ImportError:
-    print("Warning: wikipedia-api not available. Install with: pip install wikipedia-api")
+from smolagents import ToolCallingAgent, tool
+import duckduckgo_search
+import math
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-class EnhancedGAIAAgent:
-    """
-    Enhanced agent for GAIA benchmark with multi-modal capabilities,
-    web search, RAG, and multiple reasoning strategies.
-    """
-    
+# --- Tools ---
+@tool
+def duck_search(query: str) -> str:
+    """Searches the web using DuckDuckGo and returns a short summary."""
+    try:
+        results = duckduckgo_search.ddg(query, max_results=3)
+        if results:
+            return "\n".join([f"{r['title']}: {r['body']}" for r in results])
+        else:
+            return "No results found."
+    except Exception as e:
+        return f"Search error: {e}"
+
+@tool
+def calculator(expression: str) -> str:
+    """Safely evaluates basic math expressions."""
+    try:
+        result = eval(expression, {"__builtins__": {}}, math.__dict__)
+        return str(result)
+    except Exception as e:
+        return f"Calculation error: {e}"
+
+# --- Agent Definition ---
+class WebSearchAgent:
     def __init__(self):
-        print("EnhancedGAIAAgent initializing...")
-        self.setup_models()
-        self.setup_tools()
-        self.knowledge_base = {}
-        print("EnhancedGAIAAgent initialized successfully.")
-    
-    def setup_models(self):
-        """Initialize models for different tasks"""
+        self.agent = ToolCallingAgent(
+            name="GAIAWebToolAgent",
+            description="An agent that answers questions using reasoning and tools like web search and calculator.",
+            tools=[duck_search, calculator],
+            step_limit=5,
+            system_prompt="You're a helpful agent tasked with answering general questions using reasoning and external tools if needed. Prioritize factual accuracy, logic, and concise answers."
+        )
+        print("✅ WebSearchAgent initialized.")
+
+    def __call__(self, question: str) -> str:
+        print(f"🔍 Agent received: {question}")
         try:
-            # Text generation model for reasoning
-            self.text_model = None  # Will lazy load when needed
-            
-            # Embedding model for RAG
-            try:
-                self.embedder = SentenceTransformer('all-MiniLM-L6-v2')
-                print("✅ Embedding model loaded")
-            except:
-                self.embedder = None
-                print("⚠️ Embedding model not available")
-            
-            # Vision model for image analysis
-            try:
-                self.vision_model = pipeline("image-to-text", model="Salesforce/blip-image-captioning-base")
-                print("✅ Vision model loaded")
-            except:
-                self.vision_model = None
-                print("⚠️ Vision model not available")
-                
+            return self.agent.run(question)
         except Exception as e:
-            print(f"Model setup error: {e}")
-    
-    def setup_tools(self):
-        """Initialize tools for web search and knowledge retrieval"""
-        try:
-            self.wiki = wikipediaapi.Wikipedia(
-                language='en',
-                extract_format=wikipediaapi.ExtractFormat.WIKI,
-                user_agent='GAIA-Agent/1.0'
-            )
-            print("✅ Wikipedia API initialized")
-        except:
-            self.wiki = None
-            print("⚠️ Wikipedia API not available")
-    
-    def web_search(self, query: str, max_results: int = 3) -> List[Dict]:
-        """
-        Simulate web search using multiple sources
-        """
-        results = []
-        
-        # Wikipedia search
-        if self.wiki:
-            try:
-                page = self.wiki.page(query)
-                if page.exists():
-                    results.append({
-                        'title': page.title,
-                        'content': page.text[:1000],
-                        'source': 'Wikipedia',
-                        'url': page.fullurl
-                    })
-            except:
-                pass
-        
-        # Add more search sources here (DuckDuckGo, etc.)
-        return results[:max_results]
-    
-    def extract_numbers_and_calculations(self, text: str) -> Dict:
-        """Extract numbers and perform calculations from text"""
-        numbers = re.findall(r'-?\d+\.?\d*', text)
-        calculations = {
-            'numbers_found': [float(n) for n in numbers if n],
-            'sum': sum(float(n) for n in numbers if n),
-            'count': len(numbers)
-        }
-        return calculations
-    
-    def analyze_image(self, image_path: str) -> str:
-        """Analyze image content"""
-        if not self.vision_model:
-            return "Image analysis not available"
-        
+            print(f"❌ Error: {e}")
+            return f"Error: {e}"
+
+# --- Main Evaluation Logic ---
+def run_and_submit_all(profile: gr.OAuthProfile | None):
+    space_id = os.getenv("SPACE_ID")
+    if profile:
+        username = profile.username
+        print(f"User logged in: {username}")
+    else:
+        return "Please login to Hugging Face first.", None
+
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    api_url = DEFAULT_API_URL
+    questions_url = f"{api_url}/questions"
+    submit_url = f"{api_url}/submit"
+
+    try:
+        agent = WebSearchAgent()
+    except Exception as e:
+        return f"Agent init error: {e}", None
+
+    try:
+        print("📥 Fetching questions...")
+        response = requests.get(questions_url, timeout=15)
+        response.raise_for_status()
+        questions_data = response.json()
+        if not questions_data:
+            return "Fetched questions list is empty or invalid format.", None
+        print(f"✅ Fetched {len(questions_data)} questions.")
+    except Exception as e:
+        return f"Error fetching questions: {e}", None
+
+    answers_payload = []
+    results_log = []
+    print("🚀 Running agent on questions...")
+    for item in questions_data:
+        task_id = item.get("task_id")
+        question_text = item.get("question")
+        if not task_id or not question_text:
+            continue
         try:
-            image = Image.open(image_path)
-            result = self.vision_model(image)
-            return result[0]['generated_text'] if result else "Could not analyze image"
+            submitted_answer = agent(question_text)
+            answers_payload.append({
+                "task_id": task_id,
+                "submitted_answer": submitted_answer
+            })
+            results_log.append({
+                "Task ID": task_id,
+                "Question": question_text,
+                "Submitted Answer": submitted_answer
+            })
         except Exception as e:
-            return f"Image analysis error: {e}"
-    
-    def rag_retrieval(self, query: str, context: str) -> str:
-        """Simple RAG-like retrieval and generation"""
-        if not self.embedder:
-            return context[:500]  # Return truncated context
-        
-        try:
-            # Split context into chunks
-            chunks = [context[i:i+200] for i in range(0, len(context), 200)]
-            
-            # Find most relevant chunk
-            query_embedding = self.embedder.encode([query])
-            chunk_embeddings = self.embedder.encode(chunks)
-            
-            similarities = np.dot(query_embedding, chunk_embeddings.T)[0]
-            best_chunk_idx = np.argmax(similarities)
-            
-            return chunks[best_chunk_idx]
-        except:
-            return context[:500]
-    
-    def mathematical_reasoning(self, question: str) -> str:
-        """Handle mathematical questions"""
-        # Extract mathematical expressions
-        math_patterns = [
-            r'(\d+(?:\.\d+)?)\s*[\+\-\*\/]\s*(\d+(?:\.\d+)?)',
-            r'(\d+)\s*percent|(\d+)%',
-            r'(\d+)\s*degrees?',
-        ]
-        
-        for pattern in math_patterns:
-            matches = re.findall(pattern, question)
-            if matches:
-                # Simple calculation handling
-                try:
-                    nums = self.extract_numbers_and_calculations(question)
-                    if nums['numbers_found']:
-                        return f"Based on the numbers found: {nums['numbers_found']}, the sum is {nums['sum']}"
-                except:
-                    pass
-        
-        return "Mathematical reasoning applied but no clear calculation found."
-    
-    def factual_qa(self, question: str) -> str:
-        """Handle factual questions using web search"""
-        search_results = self.web_search(question)
-        
-        if not search_results:
-            return "I couldn't find relevant information to answer this question."
-        
-        # Combine search results
-        combined_info = ""
-        for result in search_results:
-            combined_info += f"{result['content']}\n"
-        
-        # Use RAG to get most relevant information
-        relevant_info = self.rag_retrieval(question, combined_info)
-        
-        return f"Based on available information: {relevant_info}"
-    
-    def multi_step_reasoning(self, question: str) -> str:
-        """Handle complex multi-step questions"""
-        steps = []
-        
-        # Step 1: Identify question type
-        question_lower = question.lower()
-        
-        if any(word in question_lower for word in ['calculate', 'compute', 'math', 'number']):
-            steps.append("Identified as mathematical question")
-            result = self.mathematical_reasoning(question)
-        elif any(word in question_lower for word in ['when', 'where', 'who', 'what', 'how']):
-            steps.append("Identified as factual question")
-            result = self.factual_qa(question)
-        else:
-            steps.append("Using general reasoning")
-            result = self.general_reasoning(question)
-        
-        return result
-    
-    def general_reasoning(self, question: str) -> str:
-        """General reasoning for questions that don't fit other categories"""
-        # Try to extract key entities and concepts
-        key
+            error_msg = f"Agent error: {e}"
+            print(error_msg)
+            results_log.append({
+                "Task ID": task_id,
+                "Question": question_text,
+                "Submitted Answer": error_msg
+            })
+
+    if not answers_payload:
+        return "No answers to submit.", pd.DataFrame(results_log)
+
+    print("📤 Submitting answers...")
+    submission_data = {
+        "username": username.strip(),
+        "agent_code": agent_code,
+        "answers": answers_payload
+    }
+
+    try:
+        response = requests.post(submit_url, json=submission_data, timeout=60)
+        response.raise_for_status()
+        result = response.json()
+        final_status = (
+            f"✅ Submission Successful!\n"
+            f"User: {result.get('username')}\n"
+            f"Score: {result.get('score', 'N/A')}% "
+            f"({result.get('correct_count', '?')}/{result.get('total_attempted', '?')} correct)\n"
+            f"Message: {result.get('message', 'No message.')}"
+        )
+        return final_status, pd.DataFrame(results_log)
+    except Exception as e:
+        return f"Submission error: {e}", pd.DataFrame(results_log)
+
+# --- Gradio UI ---
+with gr.Blocks() as demo:
+    gr.Markdown("# 🧠 GAIA Agent with Web Search & Calculator")
+    gr.Markdown("""
+    1. Log in to Hugging Face.
+    2. Click **Run Evaluation** to fetch, run, and submit.
+    3. Your agent uses web search (DuckDuckGo) and math tools.
+    """)
+    gr.LoginButton()
+    run_button = gr.Button("🚀 Run Evaluation & Submit All Answers")
+    status_output = gr.Textbox(label="Status", lines=5)
+    results_table = gr.DataFrame(label="Answer Log")
+
+    run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
+
+if __name__ == "__main__":
+    print("🌍 Launching App...")
+    demo.launch(debug=True, share=False)