Update app.py

app.py

@@ -3,268 +3,12 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
-
-# Try to import Google ADK components, fallback to simple agent if not available
-try:
-    from google.genai import types
-    from agent import session_service, APP_NAME, USER_ID, SESSION_ID, runner
-    GOOGLE_ADK_AVAILABLE = True
-    print("✅ Google ADK components loaded successfully")
-except ImportError as e:
-    print(f"⚠️ Google ADK not available: {e}")
-    print("🔄 Falling back to simple HTTP-based agent")
-    GOOGLE_ADK_AVAILABLE = False
+from agent import BasicAgent
 
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Fallback Simple Agent for when Google ADK is not available ---
-class SimpleAgent:
-    def __init__(self):
-        print("SimpleAgent initialized - using basic HTTP requests")
-
-    def __call__(self, question: str) -> str:
-        print(f"SimpleAgent received question (first 50 chars): {question[:50]}...")
-
-        try:
-            # Analyze the question to understand what's needed
-            question_lower = question.lower()
-
-            # Detect GAIA-style complex questions
-            if self._is_complex_gaia_question(question):
-                return self._handle_complex_question(question)
-
-            # Check if it's a math question
-            elif any(word in question_lower for word in ['calculate', 'sum', 'total', 'add', 'multiply', 'divide']):
-                return self._try_basic_math(question)
-
-            # Check if it's asking for a count or number
-            elif any(word in question_lower for word in ['how many', 'count', 'number of']):
-                return "I would need to analyze the data to count the items. [SimpleAgent - limited capabilities]"
-
-            # Check if it's asking about a file
-            elif 'file' in question_lower or 'excel' in question_lower or 'csv' in question_lower:
-                return "I would need to download and analyze the file to answer this question. [SimpleAgent - limited capabilities]"
-
-            # Check if it's asking about a person or entity
-            elif any(word in question_lower for word in ['who is', 'who are', 'what is']):
-                return "I would need to search for information about this topic. [SimpleAgent - limited capabilities]"
-
-            # Default response
-            else:
-                return f"I received your question but need more advanced capabilities to answer it properly. Question: {question[:200]}... [SimpleAgent - Google ADK not available]"
-
-        except Exception as e:
-            return f"Error processing question: {str(e)} [SimpleAgent]"
-
-    def _is_complex_gaia_question(self, question):
-        """Detect if this is a complex GAIA-style question requiring multiple steps"""
-        indicators = [
-            'painting', 'film', 'movie', 'ocean liner', 'ship', 'menu',
-            'clockwise', 'order', 'arrangement', 'position',
-            'comma-separated', 'list', 'plural form',
-            'served as part of', 'later used as', 'floating prop'
-        ]
-        question_lower = question.lower()
-        return sum(1 for indicator in indicators if indicator in question_lower) >= 3
-
-    def _handle_complex_question(self, question):
-        """Handle complex GAIA questions with basic analysis"""
-        question_lower = question.lower()
-
-        # Identify what the question is asking for
-        steps_needed = []
-
-        if 'painting' in question_lower:
-            steps_needed.append("🎨 Analyze painting/image")
-        if any(word in question_lower for word in ['film', 'movie']):
-            steps_needed.append("🎬 Research film information")
-        if any(word in question_lower for word in ['ocean liner', 'ship']):
-            steps_needed.append("🚢 Research ship/vessel details")
-        if 'menu' in question_lower:
-            steps_needed.append("📋 Find historical menu information")
-        if any(word in question_lower for word in ['clockwise', 'order', 'arrangement']):
-            steps_needed.append("🔄 Analyze spatial arrangement")
-
-        analysis = f"This appears to be a complex GAIA question requiring multiple steps:\n"
-        for i, step in enumerate(steps_needed, 1):
-            analysis += f"{i}. {step}\n"
-
-        analysis += "\nI would need advanced capabilities including:\n"
-        analysis += "- Image analysis for visual content\n"
-        analysis += "- Web search for historical/factual information\n"
-        analysis += "- Multi-step reasoning to connect different pieces of information\n"
-        analysis += "\n[SimpleAgent - Complex GAIA question detected but cannot solve]"
-
-        return analysis
-
-    def _try_basic_math(self, question):
-        """Try to extract and solve basic math from the question"""
-        try:
-            # Very basic math extraction - look for numbers
-            import re
-            numbers = re.findall(r'\d+\.?\d*', question)
-            if len(numbers) >= 2:
-                nums = [float(n) for n in numbers[:2]]
-                if 'add' in question.lower() or 'sum' in question.lower():
-                    result = nums[0] + nums[1]
-                    return f"Basic calculation: {nums[0]} + {nums[1]} = {result} [SimpleAgent - basic math]"
-                elif 'multiply' in question.lower():
-                    result = nums[0] * nums[1]
-                    return f"Basic calculation: {nums[0]} × {nums[1]} = {result} [SimpleAgent - basic math]"
-
-            return "I can see this involves math but need more advanced capabilities to solve it. [SimpleAgent - limited math]"
-        except:
-            return "I can see this involves math but couldn't parse it. [SimpleAgent - limited math]"
-
-# --- Google ADK Agent Wrapper ---
-# ----- USING THE ACTUAL GOOGLE ADK AGENT FROM AGENT.PY ------
-class GoogleADKAgent:
-    def __init__(self):
-        print("GoogleADKAgent initialized with Google ADK runner and agents.")
-
-        try:
-            # Use the pre-configured runner and root_agent from agent.py
-            self.runner = runner
-            self.session_service = session_service
-            self.app_name = APP_NAME
-            self.user_id = USER_ID
-            self.question_counter = 0  # To create unique session IDs for each question
-            self.initialized = True
-            print("✅ Google ADK Agent successfully initialized using pre-configured runner")
-
-        except Exception as e:
-            print(f"❌ Failed to initialize Google ADK Agent: {e}")
-            self.initialized = False
-            raise e
-
-    def __call__(self, question: str) -> str:
-        print(f"Agent received question (first 50 chars): {question[:50]}...")
-
-        if not self.initialized:
-            return "Google ADK Agent not properly initialized"
-
-        try:
-            # Use the default session instead of creating new ones
-            # This avoids the async session creation issue
-            session_id_to_use = SESSION_ID
-            print(f"🚀 Using default session: {session_id_to_use}")
-
-            # Create the query content
-            query_content = types.Content(
-                role='user',
-                parts=[types.Part(text=question)]
-            )
-
-            # Run the agent synchronously using the runner with correct parameters
-            events = list(self.runner.run(
-                user_id=self.user_id,
-                session_id=session_id_to_use,
-                new_message=query_content
-            ))
-
-            print(f"📊 Generated {len(events)} events")
-
-            # Debug: Print event details
-            for i, event in enumerate(events):
-                print(f"Event {i}: author={getattr(event, 'author', 'unknown')}, content_type={type(getattr(event, 'content', None))}")
-                if hasattr(event, 'content') and event.content and hasattr(event.content, 'parts'):
-                    for j, part in enumerate(event.content.parts):
-                        if hasattr(part, 'text') and part.text:
-                            print(f"  Part {j}: {part.text[:100]}...")
-
-            # Extract the final answer from the events
-            final_answer = "No response generated."
-
-            # Extract the final answer with GAIA-specific processing
-            final_answer = self._extract_gaia_answer(events)
-
-            # Clean up the answer for exact matching
-            final_answer = self._clean_answer_for_exact_match(final_answer)
-
-            print(f"Agent returning answer: {final_answer[:100]}...")
-            return final_answer
-
-        except Exception as e:
-            error_msg = f"Error running Google ADK agent: {str(e)}"
-            print(error_msg)
-            return error_msg
-
-    def _extract_gaia_answer(self, events):
-        """Extract the final answer from events with GAIA-specific logic"""
-        final_answer = "No response generated."
-
-        # Collect all text responses from the agent
-        all_responses = []
-        for event in events:
-            if event.content and event.content.parts:
-                for part in event.content.parts:
-                    if part.text and part.text.strip():
-                        text = part.text.strip()
-                        # Skip system messages and tool calls, but keep substantial responses
-                        if (not text.startswith("I'll") and
-                            not text.startswith("Let me") and
-                            not text.startswith("I need to") and
-                            len(text) > 10):
-                            all_responses.append(text)
-
-        # For GAIA questions, prefer the last substantial response
-        if all_responses:
-            # Look for responses that seem like final answers
-            for response in reversed(all_responses):
-                # Skip responses that are clearly intermediate steps
-                if not any(phrase in response.lower() for phrase in [
-                    "let me", "i need to", "first", "next", "then", "now i'll"
-                ]):
-                    final_answer = response
-                    break
-
-            # If no clear final answer, use the last response
-            if final_answer == "No response generated.":
-                final_answer = all_responses[-1]
-        else:
-            # Fallback: get any text response
-            for event in reversed(events):
-                if event.content and event.content.parts:
-                    for part in event.content.parts:
-                        if part.text and part.text.strip():
-                            final_answer = part.text.strip()
-                            break
-                    if final_answer != "No response generated.":
-                        break
-
-        return final_answer
-
-    def _clean_answer_for_exact_match(self, answer):
-        """Clean the answer for exact matching requirements"""
-        if not answer or answer == "No response generated.":
-            return answer
-
-        # Remove common prefixes that agents might add
-        prefixes_to_remove = [
-            "The answer is: ",
-            "Answer: ",
-            "Final answer: ",
-            "FINAL ANSWER: ",
-            "Based on my analysis, ",
-            "The result is: ",
-        ]
-
-        cleaned = answer
-        for prefix in prefixes_to_remove:
-            if cleaned.startswith(prefix):
-                cleaned = cleaned[len(prefix):]
-
-        # Remove trailing explanations in brackets or parentheses
-        import re
-        cleaned = re.sub(r'\s*\[.*?\]\s*$', '', cleaned)
-        cleaned = re.sub(r'\s*\(.*?\)\s*$', '', cleaned)
-
-        # Clean up whitespace
-        cleaned = cleaned.strip()
-
-        return cleaned
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
@@ -287,21 +31,10 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
     # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        if GOOGLE_ADK_AVAILABLE:
-            agent = GoogleADKAgent()
-            print("✅ Using Google ADK Agent")
-        else:
-            agent = SimpleAgent()
-            print("⚠️ Using Simple Agent (Google ADK not available)")
+        agent = BasicAgent()
     except Exception as e:
         print(f"Error instantiating agent: {e}")
-        # Fallback to simple agent if Google ADK fails
-        try:
-            agent = SimpleAgent()
-            print("🔄 Fallback to Simple Agent due to error")
-        except Exception as e2:
-            print(f"Error with fallback agent: {e2}")
-            return f"Error initializing any agent: {e}, {e2}", None
+        return f"Error initializing agent: {e}", None
     # In the case of an app running as a hugging Face space, this link points toward your codebase ( usefull for others so please keep it public)
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
     print(agent_code)
@@ -334,20 +67,17 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     for item in questions_data:
         task_id = item.get("task_id")
         question_text = item.get("question")
-        file_name = item.get("file_name", "")
-
         if not task_id or question_text is None:
             print(f"Skipping item with missing task_id or question: {item}")
             continue
-
-        # Enhance question with file information if available
-        enhanced_question = question_text
+        file_name = item.get("file_name")
+        file_ext = None
+        file_url = None
         if file_name:
-            file_url = f"https://agents-course-unit4-scoring.hf.space/files/{task_id}"
-            enhanced_question = f"{question_text}\n\nFile available at: {file_url}"
-
+            file_ext = file_name.split(".")[-1]
+            file_url = f"{api_url}/files/{task_id}"
         try:
-            submitted_answer = agent(enhanced_question)
+            submitted_answer = agent(question_text, file_url, file_ext)
             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:
@@ -409,42 +139,17 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
 # --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
-    gr.Markdown("# 🤖 GAIA Benchmark Agent Evaluation")
-
-    # Add dynamic status message based on agent availability
-    if GOOGLE_ADK_AVAILABLE:
-        status_msg = "✅ **Google ADK Agent Active** - Full capabilities for complex GAIA questions including multi-step reasoning, web search, code execution, file analysis, and multimodal understanding."
-    else:
-        status_msg = "⚠️ **Simple Agent Active** - Limited capabilities. Google ADK not available in this environment. Can detect GAIA question types but cannot solve them."
-
-    gr.Markdown(f"**Agent Status:** {status_msg}")
-
+    gr.Markdown("# Basic Agent Evaluation Runner")
     gr.Markdown(
         """
-        ## About GAIA Benchmark
-
-        This evaluation uses questions from the **GAIA benchmark** - a challenging dataset that tests AI agents on:
-        - 🔍 **Multi-step reasoning** across different domains
-        - 🖼️ **Multimodal understanding** (text, images, files)
-        - 🔗 **Multi-hop information retrieval**
-        - 📊 **Structured output formatting**
-        - 🎯 **Exact answer matching**
-
-        **Example GAIA Question:**
-        *"Which of the fruits shown in the 2008 painting 'Embroidery from Uzbekistan' were served as part of the October 1949 breakfast menu for the ocean liner that was later used as a floating prop for the film 'The Last Voyage'?"*
-
-        ---
-
         **Instructions:**
-        1. **Clone this space** and customize the agent code for your approach
-        2. **Log in** to your Hugging Face account using the button below
-        3. **Run Evaluation** to test your agent on 20 filtered GAIA questions
-        4. **Submit answers** for scoring with exact match evaluation
-
-        **Target:** Aim for ~30% accuracy on Level 1 GAIA questions (current benchmark performance)
-
+        1.  Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ...
+        2.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
+        3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
         ---
-        **Note:** Evaluation may take several minutes as the agent processes complex multi-step questions.
+        **Disclaimers:**
+        Once clicking on the "submit button, it can take quite some time ( this is the time for the agent to go through all the questions).
+        This space provides a basic setup and is intentionally sub-optimal to encourage you to develop your own, more robust solution. For instance for the delay process of the submit button, a solution could be to cache the answers and submit in a seperate action or even to answer the questions in async.
         """
     )
 
@@ -483,4 +188,4 @@ if __name__ == "__main__":
     print("-"*(60 + len(" App Starting ")) + "\n")
 
     print("Launching Gradio Interface for Basic Agent Evaluation...")
-    demo.launch(debug=True, share=True)
+    demo.launch(debug=True, share=False)