fix

app.py

@@ -1,348 +1,43 @@
 import os
 import gradio as gr
 import requests
+import inspect
 import pandas as pd
-import json
-import re
-import time
-from smolagents import CodeAgent, DuckDuckGoSearchTool, InferenceClientModel, tool
-from typing import Dict, Any, List
-import base64
-from io import BytesIO
-from PIL import Image
-import numpy as np
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Enhanced Knowledge Base ---
-KNOWLEDGE_BASE = {
-    "mercedes_sosa": {
-        "birthplace": "Tucumán",
-        "province": "Tucumán", 
-        "country": "Argentina",
-        "nickname": "La Negra",
-        "birth_year": 1935,
-        "death_year": 2009,
-        "genre": "Nueva Canción folk music"
-    },
-    "geography": {
-        "tucuman": "Tucumán is a province in northwestern Argentina, capital San Miguel de Tucumán",
-        "argentina_provinces": ["Buenos Aires", "Catamarca", "Chaco", "Chubut", "Córdoba", "Corrientes", "Entre Ríos", "Formosa", "Jujuy", "La Pampa", "La Rioja", "Mendoza", "Misiones", "Neuquén", "Río Negro", "Salta", "San Juan", "San Luis", "Santa Cruz", "Santa Fe", "Santiago del Estero", "Tierra del Fuego", "Tucumán"]
-    },
-    "botanical": {
-        "true_vegetables": ["artichoke", "asparagus", "beet", "broccoli", "brussels sprouts", "cabbage", "carrot", "cauliflower", "celery", "chard", "collard", "kale", "lettuce", "onion", "parsnip", "potato", "radish", "spinach", "sweet potato", "turnip"],
-        "fruits_used_as_vegetables": ["tomato", "pepper", "eggplant", "cucumber", "zucchini", "squash", "pumpkin", "okra", "avocado"]
-    },
-    "mathematics": {
-        "non_commutative_examples": ["matrix multiplication", "subtraction", "division", "function composition", "cross product"],
-        "commutative_examples": ["addition", "multiplication", "union", "intersection"]
-    }
-}
-
-# System prompt for better reasoning
-SYSTEM_PROMPT = """You are an expert AI agent solving GAIA benchmark questions. 
-
-CRITICAL RULES:
-1. For reversed text questions, ALWAYS reverse the text first to understand it
-2. For botanical questions, distinguish true vegetables from fruits used as vegetables
-3. For factual questions, use your knowledge base first, then search if needed
-4. For mathematical problems, provide concrete examples
-5. Give direct, precise answers - no unnecessary explanation
-
-KNOWLEDGE:
-- Mercedes Sosa was born in Tucumán province, Argentina
-- True vegetables: broccoli, celery, lettuce, carrot, onion, potato, etc.
-- Fruits used as vegetables: tomato, pepper, eggplant, cucumber
-- Non-commutative operations: subtraction, division, matrix multiplication
-"""
-
-# --- Enhanced Custom Tools ---
-
-@tool
-def enhanced_web_search(query: str) -> str:
-    """Advanced web search using Serper API with intelligent result processing
-    
-    Args:
-        query: The search query string
-        
-    Returns:
-        Processed search results with key information extracted
-    """
-    try:
-        api_key = os.getenv("SERPER_API_KEY")
-        if not api_key:
-            return "SERPER_API_KEY not found - using fallback search"
-            
-        url = "https://google.serper.dev/search"
-        payload = json.dumps({"q": query, "num": 8})
-        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 = []
-        
-        # Process knowledge graph first
-        if 'knowledgeGraph' in data:
-            kg = data['knowledgeGraph']
-            results.append(f"FACT: {kg.get('title', '')} - {kg.get('description', '')}")
-        
-        # Process organic results
-        if 'organic' in data:
-            for item in data['organic'][:4]:
-                title = item.get('title', '')
-                snippet = item.get('snippet', '')
-                results.append(f"{title}: {snippet}")
-        
-        return "\n".join(results) if results else "No search results found"
-        
-    except Exception as e:
-        return f"Search failed: {str(e)}"
-
-@tool
-def knowledge_lookup(topic: str) -> str:
-    """Look up information from curated knowledge base
-    
-    Args:
-        topic: Topic to search for in knowledge base
-        
-    Returns:
-        Relevant information from knowledge base
-    """
-    topic_lower = topic.lower()
-    
-    # Mercedes Sosa queries
-    if "mercedes sosa" in topic_lower:
-        if "born" in topic_lower or "birthplace" in topic_lower or "province" in topic_lower:
-            return f"Mercedes Sosa was born in {KNOWLEDGE_BASE['mercedes_sosa']['province']} province, Argentina in {KNOWLEDGE_BASE['mercedes_sosa']['birth_year']}"
-        return f"Mercedes Sosa (1935-2009) was an Argentine folk singer known as 'La Negra', born in Tucumán province"
-    
-    # Botanical classification
-    if "botanical" in topic_lower and "vegetable" in topic_lower:
-        true_vegs = KNOWLEDGE_BASE['botanical']['true_vegetables']
-        fruits_as_vegs = KNOWLEDGE_BASE['botanical']['fruits_used_as_vegetables']
-        return f"True vegetables: {', '.join(true_vegs[:10])}. Fruits used as vegetables: {', '.join(fruits_as_vegs[:5])}"
-    
-    # Mathematical operations
-    if "commutative" in topic_lower:
-        non_comm = KNOWLEDGE_BASE['mathematics']['non_commutative_examples']
-        return f"Non-commutative operations: {', '.join(non_comm)}. Example: 5-3=2 but 3-5=-2"
-    
-    return f"No specific knowledge found for: {topic}"
-
-@tool
-def text_reverser(text: str) -> str:
-    """Reverse text to decode reversed questions
-    
-    Args:
-        text: Text to reverse
-        
-    Returns:
-        Reversed text
-    """
-    return text[::-1]
+# --- Basic Agent Definition ---
+class BasicAgent:
+    def __init__(self):
+        from smolagents import CodeAgent, DuckDuckGoSearchTool, InferenceClientModel
 
-@tool
-def botanical_classifier(food_list: str) -> str:
-    """Classify foods into botanical categories
-    
-    Args:
-        food_list: Comma-separated list of foods
-        
-    Returns:
-        Botanically correct classification
-    """
-    items = [item.strip().lower() for item in food_list.split(',')]
-    true_vegetables = []
-    
-    for item in items:
-        # Check against true vegetables
-        if any(veg in item for veg in KNOWLEDGE_BASE['botanical']['true_vegetables']):
-            true_vegetables.append(item)
-    
-    true_vegetables.sort()
-    return ', '.join(true_vegetables)
+        # Initialize the search tool
+        search_tool = DuckDuckGoSearchTool()
 
-@tool
-def math_analyzer(problem: str) -> str:
-    """Analyze mathematical problems and provide solutions
-    
-    Args:
-        problem: Mathematical problem description
-        
-    Returns:
-        Mathematical analysis and solution
-    """
-    problem_lower = problem.lower()
-    
-    if "commutative" in problem_lower:
-        return "Matrix multiplication is not commutative. Example: If A=[[1,2],[3,4]] and B=[[5,6],[7,8]], then AB ≠ BA. Generally: AB ≠ BA for matrices."
-    
-    if "chess" in problem_lower:
-        return "In chess analysis: 1) Check for immediate threats 2) Look for tactical motifs (pins, forks, skewers) 3) Evaluate material and position 4) Calculate forcing moves"
-    
-    return f"Mathematical analysis needed for: {problem[:100]}"
+        # Initialize the model
+        model = InferenceClientModel()
 
-@tool
-def youtube_content_analyzer(url: str) -> str:
-    """Analyze YouTube video content and metadata
-    
-    Args:
-        url: YouTube video URL
-        
-    Returns:
-        Video analysis results
-    """
-    try:
-        # Extract video ID
-        video_id_match = re.search(r'(?:v=|\/)([0-9A-Za-z_-]{11})', url)
-        if not video_id_match:
-            return "Invalid YouTube URL format"
-        
-        video_id = video_id_match.group(1)
-        
-        # Use oEmbed API
-        oembed_url = f"https://www.youtube.com/oembed?url=https://www.youtube.com/watch?v={video_id}&format=json"
-        response = requests.get(oembed_url, timeout=15)
-        
-        if response.status_code == 200:
-            data = response.json()
-            return f"Video: {data.get('title', 'Unknown')} by {data.get('author_name', 'Unknown')}"
-        else:
-            return f"Could not analyze video {video_id}"
-            
-    except Exception as e:
-        return f"YouTube analysis error: {str(e)}"
-
-# --- Enhanced GAIA Agent ---
-class EnhancedGAIAAgent:
-    def __init__(self):
-        print("Initializing Enhanced GAIA Agent...")
-        
-        # Use a more reliable model
-        try:
-            self.model = InferenceClientModel(
-                model_id="HuggingFaceH4/zephyr-7b-beta",
-                token=os.getenv("HUGGINGFACE_INFERENCE_TOKEN")
-            )
-        except Exception as e:
-            print(f"Model initialization warning: {e}")
-            # Fallback model
-            self.model = InferenceClientModel(model_id="microsoft/DialoGPT-medium")
-        
-        # Define tools
-        self.tools = [
-            enhanced_web_search,
-            knowledge_lookup,
-            text_reverser,
-            botanical_classifier,
-            math_analyzer,
-            youtube_content_analyzer,
-            DuckDuckGoSearchTool()
-        ]
-        
-        # Create agent
+        # Create the agent
         self.agent = CodeAgent(
-            tools=self.tools,
-            model=self.model
+            model=model,
+            tools=[search_tool],
         )
-        
-        print("Enhanced GAIA Agent initialized.")
 
     def __call__(self, question: str) -> str:
-        print(f"Processing: {question[:80]}...")
-        
-        try:
-            # Pre-process question
-            question_lower = question.lower()
-            
-            # Handle reversed text immediately
-            if self._is_reversed_text(question):
-                return self._handle_reversed_text(question)
-            
-            # Handle specific question types
-            if "mercedes sosa" in question_lower and ("born" in question_lower or "province" in question_lower):
-                return knowledge_lookup("mercedes sosa birthplace")
-            
-            if "botanical" in question_lower and "vegetable" in question_lower:
-                return self._handle_botanical_question(question)
-            
-            if "commutative" in question_lower:
-                return math_analyzer("commutative operation example")
-            
-            if "youtube.com" in question:
-                return self._handle_youtube_question(question)
-            
-            # Default: use agent with search
-            try:
-                result = self.agent.run(question)
-                return str(result)
-            except Exception as e:
-                # Fallback to direct search
-                return enhanced_web_search(question)
-                
-        except Exception as e:
-            print(f"Agent error: {e}")
-            return f"Error processing question: {question[:50]}..."
-    
-    def _is_reversed_text(self, text: str) -> bool:
-        """Check if text contains reversed elements"""
-        reversed_indicators = ["ecnetnes", "dnatsrednu", "uoy fi", "thgir ro tfel"]
-        return any(indicator in text.lower() for indicator in reversed_indicators)
-    
-    def _handle_reversed_text(self, question: str) -> str:
-        """Handle reversed text questions"""
-        try:
-            # Find the reversed part (usually before a comma or question mark)
-            reversed_part = question.split(',')[0].split('?')[0]
-            normal_text = text_reverser(reversed_part.strip())
-            
-            # Check if it asks about left or right
-            if "left" in normal_text.lower():
-                return "right"
-            elif "right" in normal_text.lower():
-                return "left"
-            
-            return normal_text
-        except:
-            return "Could not process reversed text"
-    
-    def _handle_botanical_question(self, question: str) -> str:
-        """Handle botanical classification questions"""
-        try:
-            # Extract food list from question
-            list_pattern = r'(?:list|items?).*?:(.*?)(?:\.|$)'
-            match = re.search(list_pattern, question, re.IGNORECASE | re.DOTALL)
-            
-            if match:
-                food_list = match.group(1)
-                return botanical_classifier(food_list)
-            
-            # Fallback: common grocery items
-            common_items = "milk, tomatoes, bread, lettuce, peppers, eggs, broccoli, cheese, eggplant, celery"
-            return botanical_classifier(common_items)
-            
-        except:
-            return "broccoli, celery, lettuce"  # Safe fallback
-    
-    def _handle_youtube_question(self, question: str) -> str:
-        """Handle YouTube video questions"""
-        try:
-            url_match = re.search(r'https://www\.youtube\.com/watch\?v=[^\s,?.]+', question)
-            if url_match:
-                return youtube_content_analyzer(url_match.group(0))
-            return "No valid YouTube URL found"
-        except:
-            return "Could not analyze YouTube video"
+        print(f"Agent received question (first 50 chars): {question[:50]}...")
+        fixed_answer = "This is a default answer."
+        print(f"Agent returning fixed answer: {fixed_answer}")
+        return fixed_answer
+
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
-    """Run evaluation and submit all answers"""
+    """
+    Fetches all questions, runs the BasicAgent on them, submits all answers,
+    and displays the results.
+    """
     space_id = os.getenv("SPACE_ID")
-
+    
     if profile:
         username = f"{profile.username}"
         print(f"User logged in: {username}")
@@ -354,14 +49,15 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # Initialize Enhanced Agent
+    # Instantiate Agent
     try:
-        agent = EnhancedGAIAAgent()
+        agent = BasicAgent()
     except Exception as e:
-        print(f"Agent initialization error: {e}")
+        print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
 
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    print(agent_code)
 
     # Fetch Questions
     print(f"Fetching questions from: {questions_url}")
@@ -370,111 +66,129 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         response.raise_for_status()
         questions_data = response.json()
         if not questions_data:
-            return "No questions received from server.", 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:
+    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: {e}")
+        print(f"Response text: {response.text[:500]}")
+        return f"Error decoding server response: {e}", None
+    except Exception as e:
+        print(f"Unexpected error: {e}")
+        return f"Unexpected error fetching questions: {e}", None
 
-    # Process Questions
+    # Run Agent
     results_log = []
     answers_payload = []
-    print(f"Processing {len(questions_data)} questions...")
-    
-    for i, item in enumerate(questions_data):
+    print(f"Running agent on {len(questions_data)} questions...")
+    for item in questions_data:
         task_id = item.get("task_id")
         question_text = item.get("question")
-        
         if not task_id or question_text is None:
-            print(f"Skipping invalid item: {item}")
+            print(f"Skipping item with missing task_id or question: {item}")
             continue
-            
-        print(f"Question {i+1}/{len(questions_data)}: {task_id}")
-        
         try:
-            # Process with enhanced agent
-            answer = agent(question_text)
-            
-            answers_payload.append({
-                "task_id": task_id, 
-                "submitted_answer": str(answer)
-            })
-            
-            results_log.append({
-                "Task ID": task_id,
-                "Question": question_text[:100] + "..." if len(question_text) > 100 else question_text,
-                "Answer": str(answer)[:200] + "..." if len(str(answer)) > 200 else str(answer)
-            })
-            
-            # Rate limiting
-            time.sleep(0.5)
-            
+            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:
-            print(f"Error processing {task_id}: {e}")
-            results_log.append({
-                "Task ID": task_id,
-                "Question": question_text[:100] + "...",
-                "Answer": f"ERROR: {str(e)}"
-            })
+            print(f"Error running agent on task {task_id}: {e}")
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
 
     if not answers_payload:
-        return "No answers generated to submit.", pd.DataFrame(results_log)
+        print("Agent did not produce any answers to submit.")
+        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
 
-    # Submit Results
+    # Prepare Submission
     submission_data = {
         "username": username.strip(),
         "agent_code": agent_code,
         "answers": answers_payload
     }
-    
-    print(f"Submitting {len(answers_payload)} answers...")
+    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
+    print(status_update)
+
+    # Submit Answers
+    print(f"Submitting to: {submit_url}")
     try:
-        response = requests.post(submit_url, json=submission_data, timeout=120)
+        response = requests.post(submit_url, json=submission_data, timeout=60)
         response.raise_for_status()
         result_data = response.json()
-        
         final_status = (
-            f"✅ Submission Successful!\n"
-            f"User: {result_data.get('username', username)}\n"
-            f"Score: {result_data.get('score', 'Unknown')}% "
+            f"Submission Successful!\n"
+            f"User: {result_data.get('username')}\n"
+            f"Overall Score: {result_data.get('score', 'N/A')}% "
             f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
-            f"Message: {result_data.get('message', 'Submission completed')}"
+            f"Message: {result_data.get('message', 'No message received.')}"
         )
-        
-        print("Submission successful!")
-        return final_status, pd.DataFrame(results_log)
-        
+        print("Submission successful.")
+        results_df = pd.DataFrame(results_log)
+        return final_status, results_df
+    except requests.exceptions.HTTPError as e:
+        error_detail = f"HTTP {e.response.status_code}: "
+        try:
+            error_json = e.response.json()
+            error_detail += f"{error_json.get('detail', e.response.text)}"
+        except:
+            error_detail += f"{e.response.text[:500]}"
+        print(error_detail)
+        return f"Submission Failed: {error_detail}", pd.DataFrame(results_log)
+    except requests.exceptions.Timeout:
+        return "Submission Failed: Request timed out.", pd.DataFrame(results_log)
+    except requests.exceptions.RequestException as e:
+        return f"Submission Failed: Network error - {e}", pd.DataFrame(results_log)
     except Exception as e:
-        error_msg = f"❌ Submission Failed: {str(e)}"
-        print(error_msg)
-        return error_msg, pd.DataFrame(results_log)
+        return f"Unexpected error during submission: {e}", pd.DataFrame(results_log)
+
+
+# --- Build Gradio Interface using Blocks ---
+with gr.Blocks() as demo:
+    gr.Markdown("# Basic Agent Evaluation Runner")
+    gr.Markdown(
+        """
+        **Instructions:**
+        1. Clone this space and modify the code to define your agent's logic, tools, and dependencies.
+        2. Log in using the button below. Your Hugging Face username is required for submission.
+        3. Click 'Run Evaluation & Submit All Answers' to test your agent and get a score.
+        ---
+        **Note:** The submission process may take time. You are encouraged to optimize your implementation.
+        """
+    )
 
-# --- Gradio Interface (Simple as requested) ---
-with gr.Blocks(title="GAIA Agent") as demo:
-    gr.Markdown("# 🧠 Enhanced GAIA Benchmark Agent")
-    gr.Markdown("**Improved agent with better reasoning and knowledge base**")
-    
     gr.LoginButton()
-    
-    run_button = gr.Button("🚀 Run Evaluation & Submit", variant="primary", size="lg")
-    
-    status_output = gr.Textbox(label="Status", lines=5, interactive=False)
-    results_table = gr.DataFrame(label="Results")
+    run_button = gr.Button("Run Evaluation & Submit All Answers")
+    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
+    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
 
     run_button.click(
         fn=run_and_submit_all,
         outputs=[status_output, results_table]
     )
 
+
+# --- Entry Point ---
 if __name__ == "__main__":
-    print("🚀 Starting Enhanced GAIA Agent...")
-    
-    # Environment check
-    required_vars = ["SPACE_ID", "SERPER_API_KEY", "HUGGINGFACE_INFERENCE_TOKEN"]
-    for var in required_vars:
-        if os.getenv(var):
-            print(f"✅ {var} found")
-        else:
-            print(f"⚠️ {var} missing")
+    print("\n" + "-" * 30 + " App Starting " + "-" * 30)
     
-    demo.launch(debug=True, share=False)
+    space_host = os.getenv("SPACE_HOST")
+    space_id = os.getenv("SPACE_ID")
+
+    if space_host:
+        print(f"✅ SPACE_HOST: {space_host}")
+        print(f"   Runtime URL: https://{space_host}.hf.space")
+    else:
+        print("ℹ️  SPACE_HOST not found (running locally?).")
+
+    if space_id:
+        print(f"✅ SPACE_ID: {space_id}")
+        print(f"   Repo URL: https://huggingface.co/spaces/{space_id}")
+        print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id}/tree/main")
+    else:
+        print("ℹ️  SPACE_ID not found (running locally?).")
+
+    print("-" * (60 + len(" App Starting ")) + "\n")
+    print("Launching Gradio Interface for Basic Agent Evaluation...")
+    demo.launch(debug=True, share=False)

txt.txt

@@ -1,5 +1,6 @@
 "90f426e61bed9f1ffce51a95b98945531c35279a"
 
+
 import os
 import gradio as gr
 import requests