Update app.py

app.py

@@ -3,673 +3,363 @@ import re
 import requests
 import gradio as gr
 import pandas as pd
-from smolagents import CodeAgent, tool, LiteLLMModel
+from smolagents import ToolCallingAgent, tool, LiteLLMModel
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 # ============================================
-# CUSTOM TOOLS FOR THE AGENT
+# TOOLS
 # ============================================
 
-@tool
-def calculator(expression: str) -> str:
-    """
-    Performs mathematical calculations safely.
-    
-    Args:
-        expression: A math expression like "2 + 2", "10 * 5 / 2", "2**10", "sqrt(16)"
-    
-    Returns:
-        The result of the calculation as a string
-    """
-    import math
-    try:
-        expression = expression.strip()
-        
-        safe_dict = {
-            "abs": abs, "round": round, "min": min, "max": max,
-            "sum": sum, "pow": pow, "len": len,
-            "sqrt": math.sqrt, "sin": math.sin, "cos": math.cos,
-            "tan": math.tan, "log": math.log, "log10": math.log10,
-            "pi": math.pi, "e": math.e, "floor": math.floor, "ceil": math.ceil,
-            "factorial": math.factorial,
-        }
-        
-        result = eval(expression, {"__builtins__": {}}, safe_dict)
-        return str(result)
-    except Exception as e:
-        return f"Calculation error: {str(e)}"
-
-
 @tool
 def web_search(query: str) -> str:
     """
-    Searches the web using DuckDuckGo and returns relevant results.
+    Searches the web and returns results.
     
     Args:
-        query: The search query string
+        query: What to search for
     
     Returns:
-        Search results with titles, URLs, and snippets
+        Search results
     """
     try:
         from duckduckgo_search import DDGS
-        
         with DDGS() as ddgs:
-            results = list(ddgs.text(query, max_results=5))
-        
+            results = list(ddgs.text(query, max_results=3))
         if not results:
-            return "No search results found."
-        
+            return "No results found."
         output = []
-        for i, r in enumerate(results, 1):
-            output.append(f"{i}. {r.get('title', 'No title')}")
-            output.append(f"   URL: {r.get('href', 'No URL')}")
-            output.append(f"   {r.get('body', 'No description')}")
-            output.append("")
-        
+        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: {str(e)}"
+        return f"Search error: {e}"
 
 
 @tool
 def visit_webpage(url: str) -> str:
     """
-    Visits a webpage and extracts its text content.
+    Gets text content from a webpage.
     
     Args:
-        url: The URL of the webpage to visit
+        url: The webpage URL
     
     Returns:
-        The text content of the webpage (truncated if too long)
+        Page text content
     """
     try:
         from bs4 import BeautifulSoup
-        
-        headers = {
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
-        }
-        
-        response = requests.get(url, headers=headers, timeout=15)
-        response.raise_for_status()
-        
+        headers = {"User-Agent": "Mozilla/5.0"}
+        response = requests.get(url, headers=headers, timeout=10)
         soup = BeautifulSoup(response.text, 'html.parser')
-        
-        for element in soup(['script', 'style', 'nav', 'footer', 'header']):
-            element.decompose()
-        
-        text = soup.get_text(separator='\n', strip=True)
-        
-        if len(text) > 10000:
-            text = text[:10000] + "\n...[truncated]"
-        
-        return text if text else "Could not extract text from webpage."
+        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
     except Exception as e:
-        return f"Error visiting webpage: {str(e)}"
+        return f"Error: {e}"
 
 
 @tool
-def wikipedia_search(query: str) -> str:
+def wikipedia_search(topic: str) -> str:
     """
-    Searches Wikipedia and returns article summary.
+    Searches Wikipedia for a topic.
     
     Args:
-        query: The topic to search on Wikipedia
+        topic: What to look up
     
     Returns:
-        Wikipedia article summary and key information
+        Wikipedia summary
     """
     try:
-        search_url = "https://en.wikipedia.org/w/api.php"
-        search_params = {
+        url = "https://en.wikipedia.org/w/api.php"
+        params = {
             "action": "query",
             "list": "search",
-            "srsearch": query,
+            "srsearch": topic,
             "format": "json",
-            "srlimit": 3
+            "srlimit": 1
         }
-        
-        response = requests.get(search_url, params=search_params, timeout=10)
+        response = requests.get(url, params=params, timeout=10)
         data = response.json()
         
         if not data.get("query", {}).get("search"):
-            return f"No Wikipedia articles found for: {query}"
+            return "No Wikipedia article found."
         
         title = data["query"]["search"][0]["title"]
         
-        content_params = {
+        params2 = {
             "action": "query",
             "titles": title,
             "prop": "extracts",
-            "exintro": False,
+            "exintro": True,
             "explaintext": True,
             "format": "json"
         }
+        response = requests.get(url, params=params2, timeout=10)
+        pages = response.json().get("query", {}).get("pages", {})
         
-        response = requests.get(search_url, params=content_params, timeout=10)
-        data = response.json()
-        
-        pages = data.get("query", {}).get("pages", {})
-        for page_id, page_data in pages.items():
-            extract = page_data.get("extract", "No content available")
-            if len(extract) > 5000:
-                extract = extract[:5000] + "...[truncated]"
-            return f"Wikipedia: {title}\n\n{extract}"
-        
-        return "Could not retrieve Wikipedia content."
+        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"Wikipedia error: {str(e)}"
+        return f"Error: {e}"
 
 
 @tool
-def get_gaia_file(task_id: str) -> str:
+def calculator(expression: str) -> str:
     """
-    Downloads a file associated with a GAIA task from the API.
-    Use this tool when the question mentions a file or attachment.
+    Calculates a math expression.
     
     Args:
-        task_id: The task ID to get the file for
+        expression: Math like "2+2" or "sqrt(16)"
     
     Returns:
-        Information about the file or its content if text-based
+        The result
     """
+    import math
     try:
-        api_url = f"https://agents-course-unit4-scoring.hf.space/files/{task_id}"
-        response = requests.get(api_url, timeout=30)
+        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))
+    except Exception as e:
+        return f"Error: {e}"
+
+
+@tool
+def get_task_file(task_id: str) -> str:
+    """
+    Gets the file attached to a GAIA task.
+    
+    Args:
+        task_id: The task ID
+    
+    Returns:
+        File content or description
+    """
+    try:
+        url = f"https://agents-course-unit4-scoring.hf.space/files/{task_id}"
+        response = requests.get(url, timeout=20)
         
         if response.status_code == 404:
-            return "No file associated with this task."
-        
-        response.raise_for_status()
+            return "No file for this task."
         
         content_type = response.headers.get('content-type', '').lower()
-        content_disp = response.headers.get('content-disposition', '')
+        disp = response.headers.get('content-disposition', '')
         
-        filename = "unknown"
-        if 'filename=' in content_disp:
-            filename = content_disp.split('filename=')[-1].strip('"\'')
+        filename = "file"
+        if 'filename=' in disp:
+            filename = disp.split('filename=')[-1].strip('"\'')
         
-        # Handle text files
-        if 'text' in content_type or filename.endswith(('.txt', '.csv', '.json', '.md')):
+        # Text files
+        if 'text' in content_type or filename.endswith(('.txt', '.csv', '.json', '.py', '.md')):
             content = response.text
-            if len(content) > 8000:
-                content = content[:8000] + "\n...[truncated]"
-            return f"File: {filename}\n\nContent:\n{content}"
+            return f"File '{filename}':\n{content[:6000]}"
         
-        # Handle Python files
-        elif filename.endswith('.py'):
-            content = response.text
-            if len(content) > 8000:
-                content = content[:8000] + "\n...[truncated]"
-            return f"Python File: {filename}\n\nCode:\n{content}"
-        
-        # Handle Excel files
-        elif filename.endswith(('.xlsx', '.xls')):
+        # Excel
+        if filename.endswith(('.xlsx', '.xls')):
             try:
-                import pandas as pd
                 from io import BytesIO
                 df = pd.read_excel(BytesIO(response.content))
-                return f"Excel File: {filename}\n\nData:\n{df.to_string()}"
+                return f"Excel '{filename}':\n{df.to_string()}"
             except:
-                return f"Excel File: {filename}\nNote: Could not parse Excel file."
-        
-        # Handle images
-        elif 'image' in content_type or filename.endswith(('.png', '.jpg', '.jpeg', '.gif')):
-            return f"File: {filename}\nType: Image ({content_type})\nNote: This is an image file. I cannot view images directly, but I can tell you it exists."
-        
-        # Handle audio
-        elif 'audio' in content_type or filename.endswith(('.mp3', '.wav', '.m4a')):
-            return f"File: {filename}\nType: Audio ({content_type})\nNote: This is an audio file. I cannot process audio directly."
+                return f"Excel file: {filename} (could not parse)"
         
-        # Handle PDF
-        elif 'pdf' in content_type or filename.endswith('.pdf'):
-            return f"File: {filename}\nType: PDF document\nNote: This is a PDF file. I cannot read PDFs directly."
+        # Other
+        return f"File: {filename} ({content_type}, {len(response.content)} bytes)"
         
-        else:
-            return f"File: {filename}\nType: {content_type}\nSize: {len(response.content)} bytes"
-            
     except Exception as e:
-        return f"Error getting file: {str(e)}"
+        return f"Error: {e}"
 
 
 @tool
-def read_file_content(url: str) -> str:
+def reverse_string(text: str) -> str:
     """
-    Downloads and reads content from a file URL.
+    Reverses a string.
     
     Args:
-        url: The URL of the file to download and read
+        text: Text to reverse
     
     Returns:
-        The content of the file
-    """
-    try:
-        headers = {"User-Agent": "Mozilla/5.0"}
-        response = requests.get(url, headers=headers, timeout=30)
-        response.raise_for_status()
-        
-        content = response.text
-        if len(content) > 8000:
-            content = content[:8000] + "\n...[truncated]"
-        return content
-            
-    except Exception as e:
-        return f"Error reading file: {str(e)}"
-
-
-@tool
-def reverse_text(text: str) -> str:
-    """
-    Reverses the given text string character by character.
-    
-    Args:
-        text: The text to reverse
-    
-    Returns:
-        The reversed text
+        Reversed text
     """
     return text[::-1]
 
 
-@tool
-def count_items(text: str, item_type: str = "words") -> str:
-    """
-    Counts items in text (words, characters, lines, sentences).
-    
-    Args:
-        text: The text to analyze
-        item_type: What to count - "words", "characters", "lines", or "sentences"
-    
-    Returns:
-        The count as a string
-    """
-    item_type = item_type.lower().strip()
-    
-    if item_type == "words":
-        count = len(text.split())
-    elif item_type in ["characters", "chars", "char"]:
-        count = len(text)
-    elif item_type == "lines":
-        count = len(text.split('\n'))
-    elif item_type == "sentences":
-        count = len(re.split(r'[.!?]+', text.strip()))
-    else:
-        return f"Unknown item type: {item_type}. Use: words, characters, lines, or sentences."
-    
-    return str(count)
-
-
-@tool
-def extract_numbers(text: str) -> str:
-    """
-    Extracts all numbers from a text string.
-    
-    Args:
-        text: The text to extract numbers from
-    
-    Returns:
-        A list of all numbers found in the text
-    """
-    numbers = re.findall(r'-?\d+\.?\d*', text)
-    if not numbers:
-        return "No numbers found in the text."
-    return f"Numbers found: {', '.join(numbers)}"
-
-
-@tool
-def sort_list(items: str, order: str = "ascending") -> str:
-    """
-    Sorts a comma-separated list of items alphabetically or numerically.
-    
-    Args:
-        items: Comma-separated items to sort (e.g., "banana, apple, cherry")
-        order: "ascending" or "descending"
-    
-    Returns:
-        Sorted items as comma-separated string
-    """
-    item_list = [item.strip() for item in items.split(',')]
-    
-    try:
-        numeric_list = [float(item) for item in item_list]
-        sorted_list = sorted(numeric_list, reverse=(order.lower() == "descending"))
-        return ', '.join(str(int(x) if x == int(x) else x) for x in sorted_list)
-    except ValueError:
-        sorted_list = sorted(item_list, reverse=(order.lower() == "descending"))
-        return ', '.join(sorted_list)
-
-
-@tool
-def convert_units(value: float, from_unit: str, to_unit: str) -> str:
-    """
-    Converts between common units of measurement.
-    
-    Args:
-        value: The numeric value to convert
-        from_unit: The source unit (e.g., "km", "miles", "celsius", "kg")
-        to_unit: The target unit
-    
-    Returns:
-        The converted value with units
-    """
-    conversions = {
-        ("km", "miles"): lambda x: x * 0.621371,
-        ("miles", "km"): lambda x: x * 1.60934,
-        ("m", "feet"): lambda x: x * 3.28084,
-        ("feet", "m"): lambda x: x * 0.3048,
-        ("cm", "inches"): lambda x: x * 0.393701,
-        ("inches", "cm"): lambda x: x * 2.54,
-        ("celsius", "fahrenheit"): lambda x: (x * 9/5) + 32,
-        ("fahrenheit", "celsius"): lambda x: (x - 32) * 5/9,
-        ("celsius", "kelvin"): lambda x: x + 273.15,
-        ("kelvin", "celsius"): lambda x: x - 273.15,
-        ("kg", "lbs"): lambda x: x * 2.20462,
-        ("lbs", "kg"): lambda x: x * 0.453592,
-        ("g", "oz"): lambda x: x * 0.035274,
-        ("oz", "g"): lambda x: x * 28.3495,
-    }
-    
-    key = (from_unit.lower().strip(), to_unit.lower().strip())
-    if key in conversions:
-        result = conversions[key](value)
-        return f"{value} {from_unit} = {result:.6f} {to_unit}"
-    else:
-        return f"Conversion from {from_unit} to {to_unit} not supported."
-
-
-@tool
-def get_current_time() -> str:
-    """
-    Gets the current date and time in UTC.
-    
-    Returns:
-        The current date and time
-    """
-    from datetime import datetime
-    now = datetime.utcnow()
-    return f"Current UTC date/time: {now.strftime('%Y-%m-%d %H:%M:%S')}"
-
-
 # ============================================
-# BASIC AGENT CLASS - USING GROQ
+# AGENT
 # ============================================
 
 class BasicAgent:
     def __init__(self):
-        print("Initializing BasicAgent with Groq + Llama 3.3 70B...")
+        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!")
         
-        # Use Groq with Llama 3.3 70B - fast and smart!
         self.model = LiteLLMModel(
             model_id="groq/llama-3.3-70b-versatile",
-            api_key=os.environ.get("GROQ_API_KEY"),
+            api_key=api_key,
         )
         
-        # Create the agent with all tools
-        self.agent = CodeAgent(
+        self.agent = ToolCallingAgent(
             model=self.model,
             tools=[
                 web_search,
                 visit_webpage,
                 wikipedia_search,
                 calculator,
-                get_gaia_file,
-                read_file_content,
-                reverse_text,
-                count_items,
-                extract_numbers,
-                sort_list,
-                convert_units,
-                get_current_time,
+                get_task_file,
+                reverse_string,
             ],
-            max_steps=15,
+            max_steps=8,
             verbosity_level=1,
         )
-        
-        print("BasicAgent initialized successfully with Groq!")
+        print("Agent ready!")
     
     def __call__(self, question: str, task_id: str = None) -> str:
-        print(f"Agent processing: {question[:100]}...")
-        
         try:
-            # Build the prompt with clear instructions
-            file_instruction = ""
-            if task_id:
-                file_instruction = f"""
-IMPORTANT: This question may have an associated file. 
-To check for and read the file, use: get_gaia_file("{task_id}")
-Always check for a file first if the question mentions any attachment, file, document, image, or data."""
-
-            enhanced_prompt = f"""You are solving a GAIA benchmark question. Follow these rules:
-
-1. THINK step by step before answering
-2. USE TOOLS when you need information:
-   - web_search() for current info or facts
-   - wikipedia_search() for encyclopedic knowledge  
-   - visit_webpage() to read full webpage content
-   - calculator() for any math
-   - get_gaia_file("{task_id}") if there's an attached file
-3. VERIFY your answer before submitting
-4. Give ONLY the final answer - no explanation
-5. Be PRECISE - answers are graded by exact match
-{file_instruction}
-
-Question: {question}
-
-Solve this step-by-step, then give your final answer."""
-
-            # Run the agent
-            answer = self.agent.run(enhanced_prompt)
-            
-            # Clean up answer
-            answer = str(answer).strip()
+            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.
+
+Question: {question}"""
+
+            result = self.agent.run(prompt)
+            answer = str(result).strip()
             
-            # Remove common prefixes
-            prefixes = [
-                "The answer is: ", "The answer is ",
-                "Answer: ", "Final answer: ", "Final Answer: ",
-                "The final answer is: ", "The final answer is ",
-                "FINAL ANSWER: ", "FINAL ANSWER ",
-            ]
-            for prefix in prefixes:
-                if answer.startswith(prefix):
-                    answer = answer[len(prefix):].strip()
-                elif answer.lower().startswith(prefix.lower()):
+            # Clean prefixes
+            for prefix in ["Answer:", "Final answer:", "The answer is:", "FINAL ANSWER:"]:
+                if answer.lower().startswith(prefix.lower()):
                     answer = answer[len(prefix):].strip()
             
-            # Remove quotes if wrapped
-            if (answer.startswith('"') and answer.endswith('"')) or \
-               (answer.startswith("'") and answer.endswith("'")):
+            # Remove quotes
+            if answer.startswith('"') and answer.endswith('"'):
                 answer = answer[1:-1]
             
-            print(f"Final answer: {answer[:200]}")
             return answer
             
         except Exception as e:
-            print(f"Agent error: {e}")
-            return f"Error: {str(e)}"
+            print(f"Error: {e}")
+            return "Unable to determine answer"
 
 
 # ============================================
-# RUN AND SUBMIT FUNCTION
+# MAIN FUNCTION
 # ============================================
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
-    """
-    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}")
-    else:
-        print("User not logged in.")
-        return "Please Login to Hugging Face with the button.", None
+    if not profile:
+        return "Please log in first.", None
 
-    api_url = DEFAULT_API_URL
-    questions_url = f"{api_url}/questions"
-    submit_url = f"{api_url}/submit"
+    username = profile.username
+    print(f"User: {username}")
 
-    # 1. Instantiate Agent
+    # Check API key
+    if not os.environ.get("GROQ_API_KEY"):
+        return "ERROR: GROQ_API_KEY not set in Space secrets!", None
+
+    # Init agent
     try:
         agent = BasicAgent()
     except Exception as 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(f"Agent code URL: {agent_code}")
+        return f"Agent init failed: {e}", None
 
-    # 2. Fetch Questions
-    print(f"Fetching questions from: {questions_url}")
+    # Get questions
     try:
-        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.", None
-        print(f"Fetched {len(questions_data)} questions.")
+        response = requests.get(f"{DEFAULT_API_URL}/questions", timeout=15)
+        questions = response.json()
+        print(f"Got {len(questions)} questions")
     except Exception as e:
-        print(f"Error fetching questions: {e}")
-        return f"Error fetching questions: {e}", None
-
-    # 3. Run Agent on all questions
-    results_log = []
-    answers_payload = []
-    print(f"\n{'='*60}")
-    print(f"Running agent on {len(questions_data)} questions...")
-    print(f"{'='*60}\n")
+        return f"Failed to get questions: {e}", None
+
+    # Process questions
+    results = []
+    answers = []
     
-    for i, item in enumerate(questions_data):
-        task_id = item.get("task_id")
-        question_text = item.get("question")
-        
-        if not task_id or question_text is None:
-            continue
+    for i, q in enumerate(questions):
+        task_id = q.get("task_id")
+        question = q.get("question", "")
         
-        print(f"\n[{i+1}/{len(questions_data)}] Task: {task_id}")
-        print(f"Question: {question_text[:150]}{'...' if len(question_text) > 150 else ''}")
+        print(f"\n[{i+1}/{len(questions)}] {question[:80]}...")
         
         try:
-            submitted_answer = agent(question_text, task_id=task_id)
-            answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
-            results_log.append({
-                "Task ID": task_id,
-                "Question": question_text[:100] + "..." if len(question_text) > 100 else question_text,
-                "Answer": submitted_answer[:200] if len(submitted_answer) > 200 else submitted_answer
-            })
-            print(f"✓ Answer: {submitted_answer[:100]}")
+            answer = agent(question, task_id)
+            print(f"  → {answer[:80]}")
         except Exception as e:
-            print(f"✗ Error: {e}")
-            results_log.append({
-                "Task ID": task_id,
-                "Question": question_text[:100] + "...",
-                "Answer": f"ERROR: {e}"
-            })
-
-    if not answers_payload:
-        return "Agent did not produce any answers.", pd.DataFrame(results_log)
-
-    # 4. Submit answers
-    submission_data = {
-        "username": username.strip(),
-        "agent_code": agent_code,
-        "answers": answers_payload
-    }
-    
-    print(f"\n{'='*60}")
-    print(f"Submitting {len(answers_payload)} answers...")
-    print(f"{'='*60}\n")
+            answer = f"Error: {e}"
+            print(f"  → ERROR: {e}")
+        
+        answers.append({"task_id": task_id, "submitted_answer": answer})
+        results.append({
+            "Q#": i+1,
+            "Question": question[:60] + "...",
+            "Answer": answer[:100]
+        })
 
+    # Submit
+    print(f"\nSubmitting {len(answers)} answers...")
+    
     try:
-        response = requests.post(submit_url, json=submission_data, timeout=120)
-        response.raise_for_status()
-        result_data = response.json()
-        
-        score = result_data.get('score', 'N/A')
-        correct = result_data.get('correct_count', '?')
-        total = result_data.get('total_attempted', '?')
-        
-        final_status = (
-            f"✅ Submission Successful!\n\n"
-            f"👤 User: {result_data.get('username')}\n"
-            f"🎯 Score: {score}% ({correct}/{total} correct)\n\n"
-            f"📝 {result_data.get('message', '')}"
-        )
+        submission = {
+            "username": username,
+            "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()
         
-        if float(score) >= 30:
-            final_status += "\n\n🎉 CONGRATULATIONS! You passed the 30% threshold!"
-        else:
-            final_status += f"\n\n📈 Need {30 - float(score)}% more to reach 30% passing score."
+        score = result.get('score', 0)
+        correct = result.get('correct_count', 0)
+        total = result.get('total_attempted', 0)
         
-        print(final_status)
-        return final_status, pd.DataFrame(results_log)
+        status = f"""✅ Submitted!
+
+Score: {score}% ({correct}/{total} correct)
+
+{"🎉 PASSED! You got 30%+" if score >= 30 else f"Need {30-score}% more to pass"}
+"""
+        return status, pd.DataFrame(results)
         
     except Exception as e:
-        status_message = f"Submission Failed: {e}"
-        print(status_message)
-        return status_message, pd.DataFrame(results_log)
+        return f"Submit failed: {e}", pd.DataFrame(results)
 
 
 # ============================================
-# GRADIO INTERFACE
+# UI
 # ============================================
 
 with gr.Blocks() as demo:
-    gr.Markdown("# 🎯 GAIA Agent Evaluation Runner")
-    gr.Markdown(
-        """
-        **Unit 4 Final Project - HuggingFace AI Agents Course**
-        
-        This agent uses **Groq + Llama 3.3 70B** with the following tools:
-        
-        | Category | Tools |
-        |----------|-------|
-        | 🔍 **Search** | Web Search, Wikipedia, Visit Webpage |
-        | 🧮 **Math** | Calculator, Unit Converter |
-        | 📁 **Files** | GAIA File Reader, URL File Reader |
-        | 📝 **Text** | Reverse, Count Items, Extract Numbers, Sort List |
-        | 🕐 **Utility** | Current Time |
-        
-        ---
-        **Instructions:**
-        1. Make sure `GROQ_API_KEY` is set in Space secrets
-        2. Log in with your Hugging Face account  
-        3. Click the button and wait (~10-15 mins)
-        4. You need **30%** to pass!
-        """
-    )
-
-    gr.LoginButton()
+    gr.Markdown("# 🎯 GAIA Agent - Unit 4")
+    gr.Markdown("""
+    **Powered by Groq + Llama 3.3 70B**
     
-    run_button = gr.Button("🚀 Run Evaluation & Submit All Answers", variant="primary", size="lg")
+    1. Add `GROQ_API_KEY` to Space secrets
+    2. Log in below
+    3. Click Run
+    """)
 
-    status_output = gr.Textbox(label="Status", lines=8, interactive=False)
-    results_table = gr.DataFrame(label="Results", wrap=True)
+    gr.LoginButton()
+    run_btn = gr.Button("🚀 Run Evaluation", variant="primary")
+    status = gr.Textbox(label="Status", lines=6)
+    table = gr.DataFrame(label="Results")
 
-    run_button.click(
-        fn=run_and_submit_all,
-        outputs=[status_output, results_table]
-    )
+    run_btn.click(run_and_submit_all, outputs=[status, table])
 
 if __name__ == "__main__":
-    print("\n" + "="*60)
-    print("🎯 GAIA Agent - Powered by Groq + Llama 3.3 70B")
-    print("="*60)
+    print("=" * 50)
+    print("GAIA Agent Starting")
+    print("=" * 50)
     
-    # Check for API key
     if os.environ.get("GROQ_API_KEY"):
         print("✅ GROQ_API_KEY found")
     else:
-        print("⚠️  GROQ_API_KEY not found - add it to Space secrets!")
-    
-    space_id = os.getenv("SPACE_ID")
-    if space_id:
-        print(f"✅ Space: https://huggingface.co/spaces/{space_id}")
-    
-    print("="*60 + "\n")
+        print("❌ GROQ_API_KEY missing!")
     
-    demo.launch(debug=True, share=False)
+    demo.launch()