Update app.py

app.py

@@ -7,10 +7,12 @@ from PIL import Image, ImageDraw, ImageFont
 from huggingface_hub import login
 import requests 
 import json 
-import base64 # <-- ADDED IMPORT for image handling
-import re
+import base64 
+import re # For advanced string cleaning
 import time
-import pandas as pd
+import pandas as pd # For spreadsheet handling
+from io import StringIO # For capturing print output from exec
+
 # Attempt to login using environment token
 try:
     HF_TOKEN = os.environ.get("HUGGINGFACE_TOKEN")
@@ -155,38 +157,21 @@ def get_gaia_api_questions():
         return None, f"An unexpected error occurred: {e}"
 
 def get_gaia_file_data_for_task(task_id_for_file_fetch, associated_file_metadata_list):
-    """
-    Fetches the content of the primary file associated with a task_id from the GAIA API.
-    Returns raw_bytes, detected_mime_type, and file_name.
-    associated_file_metadata_list is the 'files' list from the question data.
-    """
-    # If no metadata, assume no file to fetch for this specialized getter.
-    # Or, if the API always serves THE file for task_id, then metadata is just for info.
-    # Let's assume the API /files/{task_id} always gives the relevant file if one exists for the task.
-    
     file_url = f"{GAIA_API_BASE_URL}/files/{task_id_for_file_fetch}"
     print(f"Attempting to fetch file for task {task_id_for_file_fetch} from {file_url}")
-    
     try:
         response = requests.get(file_url, timeout=30)
-        response.raise_for_status() # This will error if file not found (404) or other issues
-        
+        response.raise_for_status() 
         raw_bytes = response.content
         detected_mime_type = response.headers.get('Content-Type', '').split(';')[0].strip()
-        
-        # Try to get a filename from metadata if available, otherwise default
-        file_name = "attached_file"
+        file_name = "attached_file" # Default
         if associated_file_metadata_list and isinstance(associated_file_metadata_list, list) and len(associated_file_metadata_list) > 0:
-            # Assuming the first file in metadata is the one fetched, or provides its name
             first_file_meta = associated_file_metadata_list[0]
             if isinstance(first_file_meta, dict) and 'file_name' in first_file_meta:
                 file_name = first_file_meta['file_name']
-        
         print(f"File fetched for task {task_id_for_file_fetch}. Mime-type: {detected_mime_type}, Name: {file_name}, Size: {len(raw_bytes)} bytes")
         return raw_bytes, detected_mime_type, file_name
-        
     except requests.exceptions.HTTPError as http_err:
-        # Specifically handle 404 for "no file" vs other errors
         if http_err.response.status_code == 404:
             print(f"No file found (404) for task {task_id_for_file_fetch} at {file_url}.")
         else:
@@ -199,136 +184,225 @@ def get_gaia_file_data_for_task(task_id_for_file_fetch, associated_file_metadata
         print(f"Unexpected error fetching file for task {task_id_for_file_fetch}: {e_gen}")
         return None, None, None
 
+def execute_python_code(code_string: str):
+    """
+    Safely executes a string of Python code and captures its standard output.
+    Returns the captured output or an error message.
+    """
+    print(f"Attempting to execute Python code:\n{code_string[:500]}...") # Log first 500 chars
+    # Create a new StringIO object to capture stdout
+    old_stdout = sys.stdout
+    sys.stdout = captured_output = StringIO()
+    
+    execution_result = None
+    error_message = None
 
-def clean_final_answer(raw_text):
-    # Step 1: Extract FINAL ANSWER section if present
-    if "FINAL ANSWER:" in raw_text.upper():
-        match = re.search(r"FINAL ANSWER:\s*(.*)", raw_text, re.IGNORECASE | re.DOTALL)
-        if match:
-            answer = match.group(1).strip()
-        else:
-            answer = raw_text.strip()
+    try:
+        # Execute the code in a restricted namespace
+        # For safety, you might want to further restrict the available builtins/modules
+        # For this benchmark, we assume the provided Python code is generally safe.
+        local_namespace = {}
+        exec(code_string, {"__builtins__": __builtins__}, local_namespace)
+        
+        # Try to get a 'final_answer' variable if it exists, as some questions might expect it
+        if 'final_answer' in local_namespace:
+            execution_result = str(local_namespace['final_answer'])
+        
+    except Exception as e:
+        print(f"Error executing Python code: {e}")
+        error_message = f"Execution Error: {type(e).__name__}: {e}"
+    finally:
+        # Restore stdout
+        sys.stdout = old_stdout
+
+    # Get the content of captured_output
+    printed_output = captured_output.getvalue().strip()
+    
+    if execution_result:
+        # If 'final_answer' was found, prioritize it
+        return execution_result, None
+    elif printed_output:
+        # If 'final_answer' not found, but something was printed, return that
+        return printed_output, None
+    elif error_message:
+        # If there was an error during execution
+        return None, error_message
     else:
-        answer = raw_text.strip()
+        # If no 'final_answer', nothing printed, and no error (e.g., script only defines functions)
+        return "Python code executed without explicit output or 'final_answer' variable.", None
 
-    # Step 2: Remove wrapping quotes if any
-    if (answer.startswith('"') and answer.endswith('"')) or (answer.startswith("'") and answer.endswith("'")):
-        answer = answer[1:-1].strip()
 
-    # Step 3: Remove unwanted units unless explicitly required
-    # You may adjust this depending on the task
-    answer = answer.replace('%', '').replace('$', '').strip()
+def clean_final_answer(raw_text: str) -> str:
+    """More robustly cleans the raw text output from the LLM."""
+    if not isinstance(raw_text, str):
+        return "" # Should not happen, but good to be safe
 
-    # Step 4: Normalize spaces (e.g., for comma-separated answers)
-    answer = re.sub(r'\s*,\s*', ',', answer)
+    answer = raw_text.strip()
 
+    # Attempt to extract content after "FINAL ANSWER:" if it's still present
+    # This regex is more robust to variations in spacing and casing
+    final_answer_match = re.search(r"FINAL ANSWER:\s*(.*)", answer, re.IGNORECASE | re.DOTALL)
+    if final_answer_match:
+        answer = final_answer_match.group(1).strip()
+    
+    # Remove common conversational prefixes more aggressively
+    common_prefixes = [
+        "The answer is", "The final answer is", "So, the answer is", "Therefore, the answer is",
+        "Based on the information, the answer is", "The correct answer is", "My answer is",
+        "Okay, the answer is", "Sure, the answer is", "Here is the answer:", "The solution is",
+        "Answer:", "Result:"
+    ]
+    for prefix in common_prefixes:
+        if answer.lower().startswith(prefix.lower()):
+            answer = answer[len(prefix):].strip()
+            # Remove potential colon or period after prefix
+            if answer.startswith(":") or answer.startswith("."):
+                answer = answer[1:].strip()
+            break # Stop after first prefix match
+
+    # Remove wrapping quotes (single or double)
+    if len(answer) >= 2:
+        if (answer.startswith('"') and answer.endswith('"')) or \
+           (answer.startswith("'") and answer.endswith("'")):
+            answer = answer[1:-1].strip()
+
+    # Specific GAIA formatting: remove units like $ or % unless specified otherwise by the question
+    # This is tricky to do generally, as some questions might require them.
+    # The prompt already tells Gemini about this. This is a fallback.
+    # For now, let's keep it simple and rely on the prompt.
+    # If a question asks for "USD with two decimal places", the LLM should include '$'.
+    # answer = answer.replace('$', '').replace('%', '').strip() # Re-evaluating if this is too aggressive
+
+    # Normalize spaces around commas for comma-separated lists
+    answer = re.sub(r'\s*,\s*', ',', answer)
+    
+    # Remove trailing punctuation if it seems unintended (e.g. a lone period)
+    if len(answer) > 1 and answer.endswith(".") and not re.search(r"[a-zA-Z0-9]\.[a-zA-Z0-9]", answer): # Avoid stripping from e.g. "file.txt"
+        # Check if the part before the period is a number or a short phrase
+        # This is to avoid stripping periods from full sentences if the LLM disobeys "few words"
+        if not answer[:-1].strip().isdigit() and len(answer[:-1].strip().split()) > 3: 
+            pass # Likely a sentence, keep period
+        else:
+            answer = answer[:-1].strip()
+            
     return answer
-def my_agent_logic(task_id: str, question: str, files_metadata: list = None): # files_metadata is the list from task.get("files")
-    """
-    Uses the Gemini API, with GAIA-specific prompting and basic file handling, 
-    to generate an answer for the given question.
-    """
-    print(f"Agent (GAIA-Grounded Gemini) processing Task ID: {task_id}, Question: {question}")
-    if files_metadata: # This is the list of file metadata dicts
-        print(f"File metadata associated with this task: {files_metadata}")
+
+def my_agent_logic(task_id: str, question: str, files_metadata: list = None):
+    print(f"Agent (Enhanced Tools + Gemini) processing Task ID: {task_id}, Question: {question}")
+    if files_metadata:
+        print(f"File metadata associated: {files_metadata}")
 
     gemini_api_key = os.environ.get("GEMINI_API_KEY")
     if not gemini_api_key:
-        print("Error: GEMINI_API_KEY not found in environment variables. Please set it in Space Secrets.")
         return f"ERROR_GEMINI_KEY_MISSING_FOR_TASK_{task_id}"
 
-    # --- GAIA-specific System Prompt ---
-    # Adapted from Figure 2 of GAIA Paper [cite: 103, 104, 105, 106, 107, 108]
     system_prompt_lines = [
         "You are a general AI assistant. I will ask you a question.",
-        "Report your thoughts (for your own processing, not for the final answer), and finish your answer with the following template: FINAL ANSWER: [YOUR FINAL ANSWER].", # Instructing the LLM about the template it should "think" in
-        "However, your actual returned response to me (the user) should ONLY be [YOUR FINAL ANSWER] part, without the 'FINAL ANSWER:' prefix.", # Clarification for our use case
-        "YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list of numbers and/or strings.",
-        "If you are asked for a number, don't use comma to write your number neither use units such as $ or percent sign unless specified otherwise.",
+        "Your primary goal is to provide the single, exact, concise, and factual answer to the question.",
+        "Do not include any conversational fluff, disclaimers, explanations, or any introductory phrases like 'The answer is:'. Your response should be ONLY the answer itself.",
+        "Do not use markdown formatting unless the question explicitly asks for it.",
+        "If the question implies a specific format (e.g., a number, a date, a comma-separated list), provide the answer in that format.",
+        "Do NOT include the phrase 'FINAL ANSWER:' in your response to me.",
+        "If you are asked for a number, don't use comma to write your number neither use units such as $ or percent sign unless specified otherwise by the question.",
         "If you are asked for a string, don't use articles, neither abbreviations (e.g. for cities), and write the digits in plain text unless specified otherwise.",
         "If you are asked for a comma separated list, apply the above rules depending of whether the element to be put in the list is a number or a string.",
-        "Be precise and ensure the answer strictly adheres to any format requested in the question.",
-        "If external files are mentioned or provided, use their content if relevant and accessible to answer the question.",
+        "If external files or tool outputs are provided below, use their content if relevant and accessible to answer the question.",
     ]
-    # We won't send this as a separate "system" message in Gemini's typical API structure,
-    # but rather prepend it to the user question for a single turn.
     
-    # --- Prepare parts for Gemini API payload ---
+    user_question_text_for_gemini = "\n".join(system_prompt_lines) + f"\n\nGAIA Question: {question}"
     gemini_parts = []
-
-    # Prepend system prompt guidelines to the main question text part
-    user_question_text = "\n".join(system_prompt_lines) + f"\n\nGAIA Question: {question}"
     
-    # --- File Handling ---
+    # --- File & Tool Handling ---
+    tool_output_description = ""
     file_content_bytes, detected_mime_type, file_name = None, None, None
-    if files_metadata: # If the question has associated file(s) metadata
+
+    if files_metadata:
         file_content_bytes, detected_mime_type, file_name = get_gaia_file_data_for_task(task_id, files_metadata)
 
-    if file_content_bytes:
-        if detected_mime_type and detected_mime_type.startswith("image/"): # Handle images
-            try:
-                base64_image = base64.b64encode(file_content_bytes).decode('utf-8')
-                gemini_parts.append({"text": user_question_text}) # Question text first
-                gemini_parts.append({
-                    "inline_data": {
-                        "mime_type": detected_mime_type,
-                        "data": base64_image
-                    }
-                })
-                print(f"Added image {file_name} ({detected_mime_type}) to Gemini prompt for task {task_id}.")
-            except Exception as e_img:
-                print(f"Error processing image file {file_name} for task {task_id}: {e_img}")
-                gemini_parts.append({"text": user_question_text + f"\n[Agent note: An image file '{file_name}' was associated but could not be processed: {e_img}]"})
-        elif detected_mime_type and detected_mime_type == "text/plain": # Handle plain text files
-            try:
-                text_content = file_content_bytes.decode('utf-8')
-                user_question_text += f"\n\nContent of attached text file '{file_name}':\n{text_content}"
-                gemini_parts.append({"text": user_question_text})
-                print(f"Added text file content '{file_name}' to Gemini prompt for task {task_id}.")
-            except Exception as e_txt:
-                print(f"Error decoding text file {file_name} for task {task_id}: {e_txt}")
-                gemini_parts.append({"text": user_question_text + f"\n[Agent note: A text file '{file_name}' was associated but could not be decoded: {e_txt}]"})
-        ###########################################################################################################################
-        elif detected_mime_type in [
-            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", 
-            "application/vnd.ms-excel", 
-            "text/csv"]:
-            try:
-                from io import BytesIO
-                if "csv" in detected_mime_type:
-                    df = pd.read_csv(BytesIO(file_content_bytes))
-                else:
-                    df = pd.read_excel(BytesIO(file_content_bytes))
-        
-                preview = df.head(10).to_string(index=False)
-                user_question_text += f"\n\nContent preview from the attached spreadsheet '{file_name}':\n{preview}"
-                gemini_parts.append({"text": user_question_text})
-                print(f"Added spreadsheet content preview for {file_name} to Gemini prompt.")
-            except Exception as e_xls:
-                print(f"Error reading spreadsheet file {file_name} for task {task_id}: {e_xls}")
-                user_question_text += f"\n\n[Agent note: Unable to parse spreadsheet '{file_name}': {e_xls}]"
-                gemini_parts.append({"text": user_question_text})
+        if file_content_bytes:
+            if file_name and file_name.lower().endswith(".py") and detected_mime_type in ["text/x-python", "application/x-python-code", "text/plain"]:
+                print(f"Detected Python file: {file_name}")
+                try:
+                    python_code = file_content_bytes.decode('utf-8')
+                    execution_result, exec_error = execute_python_code(python_code)
+                    if exec_error:
+                        tool_output_description += f"\n\nExecution of Python file '{file_name}' failed: {exec_error}"
+                    elif execution_result:
+                        tool_output_description += f"\n\nOutput from executing Python file '{file_name}':\n{execution_result}"
+                    else:
+                        tool_output_description += f"\n\nPython file '{file_name}' executed without specific return or error."
+                except Exception as e_py_decode:
+                    tool_output_description += f"\n\nError decoding Python file '{file_name}': {e_py_decode}"
+            
+            elif detected_mime_type and detected_mime_type.startswith("image/"):
+                try:
+                    base64_image = base64.b64encode(file_content_bytes).decode('utf-8')
+                    gemini_parts.append({"inline_data": {"mime_type": detected_mime_type, "data": base64_image}})
+                    tool_output_description += f"\n\nAn image file '{file_name}' ({detected_mime_type}) is provided. Refer to it if relevant."
+                    print(f"Added image {file_name} to Gemini parts for task {task_id}.")
+                except Exception as e_img:
+                    tool_output_description += f"\n\n[Agent note: Error processing image file '{file_name}': {e_img}]"
+            
+            elif detected_mime_type and detected_mime_type.startswith("audio/"): # mp3, m4a, wav, etc.
+                try:
+                    base64_audio = base64.b64encode(file_content_bytes).decode('utf-8')
+                    gemini_parts.append({"inline_data": {"mime_type": detected_mime_type, "data": base64_audio}})
+                    tool_output_description += f"\n\nAn audio file '{file_name}' ({detected_mime_type}) is provided. Transcribe or analyze it if relevant to the question."
+                    print(f"Added audio {file_name} to Gemini parts for task {task_id}.")
+                except Exception as e_audio:
+                    tool_output_description += f"\n\n[Agent note: Error processing audio file '{file_name}': {e_audio}]"
+
+            elif detected_mime_type in ["application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "application/vnd.ms-excel", "text/csv"]:
+                try:
+                    if "csv" in detected_mime_type: df = pd.read_csv(io.BytesIO(file_content_bytes))
+                    else: df = pd.read_excel(io.BytesIO(file_content_bytes))
+                    
+                    # Provide a more comprehensive preview
+                    preview_rows = min(10, len(df))
+                    preview_cols = min(5, len(df.columns))
+                    preview_df = df.iloc[:preview_rows, :preview_cols]
+                    df_description = f"First {preview_rows} rows and first {preview_cols} columns (if available):\n{preview_df.to_string(index=True)}\nTotal rows: {len(df)}, Total columns: {len(df.columns)}."
+                    if len(df.columns) > preview_cols:
+                        df_description += f"\nOther columns include: {list(df.columns[preview_cols:])}"
+
+                    tool_output_description += f"\n\nData from spreadsheet '{file_name}':\n{df_description}"
+                    print(f"Added spreadsheet preview for {file_name} to tool output description.")
+                except Exception as e_xls:
+                    tool_output_description += f"\n\n[Agent note: Unable to parse spreadsheet '{file_name}': {e_xls}]"
+            
+            elif detected_mime_type == "text/plain":
+                try:
+                    text_content = file_content_bytes.decode('utf-8')
+                    tool_output_description += f"\n\nContent of attached text file '{file_name}':\n{text_content[:2000]}" # Limit length
+                    print(f"Added text file content '{file_name}' to tool output description.")
+                except Exception as e_txt:
+                    tool_output_description += f"\n\n[Agent note: A text file '{file_name}' was associated but could not be decoded: {e_txt}]"
+            else:
+                tool_output_description += f"\n\nNote: A file named '{file_name}' (type: {detected_mime_type or 'unknown'}) is associated. Its content could not be directly processed by current tools."
+        elif files_metadata : # File metadata exists but no bytes fetched (e.g. 404)
+             tool_output_description += f"\n\nNote: File(s) {files_metadata} were listed for this task, but could not be fetched or processed."
+
 
+    # Append the main question and any tool/file processing notes as a single text part if no multimodal data was added yet,
+    # or as the first text part if multimodal data (image/audio) is present.
+    final_user_text_for_gemini = user_question_text_for_gemini + tool_output_description
+    if not any(p.get("inline_data") for p in gemini_parts): # If no image/audio was added
+        gemini_parts.append({"text": final_user_text_for_gemini})
+    else: # If image/audio was added, insert text part at the beginning
+        gemini_parts.insert(0, {"text": final_user_text_for_gemini})
 
-        ###########################################################################################################################
-    else: # No file content fetched or no files associated
-        gemini_parts.append({"text": user_question_text})
 
     payload = {
         "contents": [{"role": "user", "parts": gemini_parts}],
-        "generationConfig": { 
-            "temperature": 0.2, # Lower temperature for more factual/deterministic GAIA answers
-            "maxOutputTokens": 300, # Increased slightly for potentially more complex answers
-        }
+        "generationConfig": {"temperature": 0.1, "maxOutputTokens": 350} # Very low temp for GAIA
     }
-
     api_url_with_key = f"{GEMINI_API_URL_BASE}?key={gemini_api_key}"
     agent_computed_answer = f"ERROR_CALLING_GEMINI_FOR_TASK_{task_id}" 
 
     try:
         headers = {"Content-Type": "application/json"}
-        print(f"Calling Gemini API for task {task_id}...")
-        response = requests.post(api_url_with_key, headers=headers, json=payload, timeout=60) 
+        print(f"Calling Gemini API for task {task_id} with payload structure: {[(k, type(v)) for p in payload['contents'] for part in p['parts'] for k,v in part.items()]}")
+        response = requests.post(api_url_with_key, headers=headers, json=payload, timeout=90) # Increased timeout slightly
         response.raise_for_status()  
         result = response.json()
         
@@ -336,34 +410,23 @@ def my_agent_logic(task_id: str, question: str, files_metadata: list = None): #
             result["candidates"][0].get("content") and
             result["candidates"][0]["content"].get("parts") and
             result["candidates"][0]["content"]["parts"][0].get("text")):
-            
-            raw_answer = result["candidates"][0]["content"]["parts"][0]["text"].strip()
-            print(f"Raw Gemini output: {raw_answer}")  # Debugging log
-            agent_computed_answer = clean_final_answer(raw_answer)
-
+            raw_answer_from_gemini = result["candidates"][0]["content"]["parts"][0]["text"].strip()
+            agent_computed_answer = clean_final_answer(raw_answer_from_gemini)
         else:
-            print(f"Warning: Unexpected response structure from Gemini API for task {task_id}: {result}")
+            print(f"Warning: Unexpected response structure from Gemini API for task {task_id}: {json.dumps(result, indent=2)}")
             if result.get("promptFeedback") and result["promptFeedback"].get("blockReason"):
                 block_reason = result["promptFeedback"]["blockReason"]
-                print(f"Gemini API blocked the prompt for task {task_id}. Reason: {block_reason}")
                 agent_computed_answer = f"ERROR_GEMINI_PROMPT_BLOCKED_{block_reason}_FOR_TASK_{task_id}"
             else:
                 agent_computed_answer = f"ERROR_PARSING_GEMINI_RESPONSE_FOR_TASK_{task_id}"
     except requests.exceptions.Timeout:
-        print(f"Timeout error calling Gemini API for task {task_id}.")
         agent_computed_answer = f"ERROR_GEMINI_TIMEOUT_FOR_TASK_{task_id}"
     except requests.exceptions.RequestException as e:
-        print(f"Error calling Gemini API for task {task_id}: {e}")
-        if e.response is not None:
-            print(f"Gemini API Error Response Status: {e.response.status_code}")
-            try: print(f"Gemini API Error Response Body: {e.response.json()}")
-            except json.JSONDecodeError: print(f"Gemini API Error Response Body (text): {e.response.text}")
+        if e.response is not None: print(f"Gemini API Error Response Status: {e.response.status_code}, Body: {e.response.text}")
         agent_computed_answer = f"ERROR_GEMINI_REQUEST_FAILED_FOR_TASK_{task_id}"
     except Exception as e:
-        print(f"An unexpected error occurred in my_agent_logic for task {task_id}: {e}")
         agent_computed_answer = f"ERROR_UNEXPECTED_IN_AGENT_LOGIC_FOR_TASK_{task_id}"
-
-    print(f"Agent (GAIA-Grounded Gemini) computed answer for Task ID {task_id}: {agent_computed_answer}")
+    print(f"Agent (Enhanced Tools + Gemini) computed answer for Task ID {task_id}: {agent_computed_answer}")
     return agent_computed_answer
 
 def run_agent_on_gaia(profile: gr.OAuthProfile, run_all_questions: bool = True):
@@ -389,20 +452,25 @@ def run_agent_on_gaia(profile: gr.OAuthProfile, run_all_questions: bool = True):
         log_messages.append(f"Processing 1 random question based on user choice.")
     elif run_all_questions:
         log_messages.append(f"Processing all {len(tasks_to_process)} questions.")
+    
+    # Need to import sys for execute_python_code's stdout capture
+    global sys 
+    import sys
+
     for task in tasks_to_process:
         task_id = task.get("task_id")
         question = task.get("question")
-        associated_files_metadata = task.get("files", []) # This is the list of file metadata dicts
+        associated_files_metadata = task.get("files", []) 
         if task_id and question:
             log_messages.append(f"\nProcessing Task ID: {task_id}")
             log_messages.append(f"Question: {question}")
             if associated_files_metadata:
                  log_messages.append(f"Associated files metadata: {associated_files_metadata}")
-            # Pass the files_metadata to the agent logic
             submitted_answer = my_agent_logic(task_id, question, associated_files_metadata)
             log_messages.append(f"Agent's Answer: {submitted_answer}")
             answers_to_submit.append({"task_id": task_id, "submitted_answer": submitted_answer})
-            time.sleep(2) 
+            if run_all_questions: # Add a small delay if processing all questions to be kind to APIs
+                time.sleep(1) # 1-second delay between processing each question
         else:
             log_messages.append(f"Skipping malformed task: {task}")
     if not answers_to_submit:
@@ -461,7 +529,7 @@ def submit_agent_answers(profile: gr.OAuthProfile, answers_for_submission_state)
         submission_log_messages.append(f"An unexpected error occurred during submission: {e}")
         return "\n".join(submission_log_messages)
 
-# --- Gradio Interface (largely unchanged from your latest version) ---
+# --- Gradio Interface (largely unchanged) ---
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
     gr.Markdown("# 🎓 Agents Course - Unit 4 Final Project")
     gr.Markdown("⚠️ **Note**: Due to high demand, you might experience occasional bugs. If something doesn't work, please try again after a moment!")
@@ -474,7 +542,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
     with gr.Tabs():
         with gr.TabItem("🤖 Run Agent on GAIA Benchmark"):
             gr.Markdown("## Step 1: Run Your Agent & Generate Answers")
-            gr.Markdown("This agent uses the Gemini API (with GAIA-specific prompting and basic file handling) to generate answers.")
+            gr.Markdown("This agent uses the Gemini API with enhanced tool handling (Python execution, audio, spreadsheets) to generate answers.")
             run_all_questions_checkbox = gr.Checkbox(label="Process all questions (unchecked processes 1 random question for testing)", value=True)
             run_agent_button = gr.Button("🔎 Fetch Questions & Run My Agent")
             gr.Markdown("### Agent Run Log & Generated Answers:")