Update app.py

app.py

@@ -1,318 +1,5 @@
-import os
-import gradio as gr
-import requests
-import inspect
-import pandas as pd
-import tempfile
-import shutil
-from pathlib import Path
-import re
-import base64
-import logging
-import subprocess
-from openai import OpenAI
-import time
-import sys
-import json
-import urllib.parse # For filename decoding
-from typing import Dict, List, Tuple, Optional, Any, Union
-
-# Langchain specific imports
-from langchain_openai import ChatOpenAI
-from langchain.agents import AgentExecutor, create_openai_tools_agent
-from langchain_core.messages import HumanMessage, SystemMessage
-from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
-
-# Tool Imports
-from langchain_community.tools.tavily_search import TavilySearchResults
-from langchain_community.tools.ddg_search import DuckDuckGoSearchRun
-from langchain_community.utilities.wikipedia import WikipediaAPIWrapper
-from langchain_community.tools import WikipediaQueryRun
-# Note: PythonREPLTool is available but not used directly by specialized handlers
-
-# --- Setup Logging ---
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(name)s - %(message)s',
-    handlers=[logging.StreamHandler(sys.stdout)]
-)
-logging.getLogger("httpx").setLevel(logging.WARNING)
-logging.getLogger("httpcore").setLevel(logging.WARNING)
-logging.getLogger("openai").setLevel(logging.WARNING)
-logging.getLogger("requests").setLevel(logging.WARNING)
-logging.getLogger("urllib3").setLevel(logging.WARNING)
-
-# --- Constants ---
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-ENABLE_SUBMISSION = False # Keep False for testing, True for final submission
-
-# --- *** TASK ID TO QUESTION NUMBER MAPPING *** ---
-# Map the provided UUIDs to the corresponding question number (1-20)
-TASK_ID_MAP = {
-    "8e867cd7-cff9-4e6c-867a-ff5ddc2550be": "1",  # Mercedes Sosa Albums
-    "a1e91b78-d3d8-4675-bb8d-62741b4b68a6": "2",  # Birds Video (Unsupported)
-    "2d83110e-a098-4ebb-9987-066c06fa42d0": "3",  # Reversed 'tfel'
-    "cca530fc-4052-43b2-b130-b30968d8aa44": "4",  # Chess Image
-    "4fc2f1ae-8625-45b5-ab34-ad4433bc21f8": "5",  # Dinosaur Nominator
-    "6f37996b-2ac7-44b0-8e68-6d28256631b4": "6",  # Commutativity Table
-    "9d191bce-651d-4746-be2d-7ef8ecadb9c2": "7",  # Teal'c Quote
-    "cabe07ed-9eca-40ea-8ead-410ef5e83f91": "8",  # Equine Vet Surname
-    "3cef3a44-215e-4aed-8e3b-b1e3f08063b7": "9",  # Botanical Vegetables
-    "99c9cc74-fdc8-46c6-8f8d-3ce2d3bfeea3": "10", # Pie Ingredients Audio
-    "305ac316-eef6-4446-960a-92d80d542f82": "11", # Actor's Role
-    "f918266a-b3e0-4914-865d-4faa564f1aef": "12", # Python Code Execution
-    "3f57289b-8c60-48be-bd80-01f8099ca449": "13", # Yankee Walks/At Bats
-    "1f975693-876d-457b-a649-393859e79bf3": "14", # Calculus Pages Audio
-    "840bfca7-4f7b-481a-8794-c560c340185d": "15", # NASA Award Number
-    "bda648d7-d618-4883-88f4-3466eabd860e": "16", # Vietnamese Specimens Location
-    "cf106601-ab4f-4af9-b045-5295fe67b37d": "17", # 1928 Olympics Athletes
-    "a0c07678-e491-4bbc-8f0b-07405144218f": "18", # Pitcher Numbers
-    "7bd855d8-463d-4ed5-93ca-5fe35145f733": "19", # Excel Sales
-    "5a0c1adf-205e-4841-a666-7c3ef95def9d": "20"  # Malko Competition Winner
-}
-# --- *** END MAPPING *** ---
-
-# Define sets based on mapped question numbers (as strings)
-TASKS_NEEDING_FILE = {'4', '7', '10', '12', '14', '19'}
-AUDIO_TASKS = {'7', '10', '14'}
-IMAGE_TASKS = {'4'}
-PYTHON_TASKS = {'12'}
-EXCEL_TASKS = {'19'}
-UNSUPPORTED_VIDEO_TASKS = {'2'} # Bird video is Q2
-DIRECT_LOGIC_TASKS = {'2', '3', '6'} # Q2 (Error), Q3 (right), Q6 (b,e)
-SPECIAL_AGENT_LOGIC_TASKS = {'5'} # Q5 needs multi-step agent interaction
-
-# --- Helper Functions ---
-
-def download_file(url: str, destination_folder: str, task_id: str) -> Path | None:
-    """Downloads a file from the GAIA benchmark URL."""
-    # (Keep existing download_file function as is - it was good)
-    if not url or not isinstance(url, str) or not url.startswith("http"): logging.error(f"Invalid URL for {task_id}: {url}"); return None
-    try:
-        response = requests.get(url, stream=True, timeout=60); response.raise_for_status()
-        content_disposition = response.headers.get('content-disposition'); filename = f"file_{task_id}"
-        if content_disposition:
-            fname_match = re.search(r'filename\*?=(?:UTF-\d\'\')?([^;\n]+)', content_disposition, re.IGNORECASE)
-            if fname_match: raw_filename = urllib.parse.unquote(fname_match.group(1).strip().strip('"\' ')); safe_filename = re.sub(r'[^\w\.\-]', '_', raw_filename)[:100]; filename = f"{task_id}_{safe_filename}"
-            else: extension = os.path.splitext(url)[1] or '.dat'; filename = f"{task_id}_downloaded_file{extension}"
-        else: extension = os.path.splitext(url)[1] or '.dat'; filename = f"{task_id}_downloaded_file{extension}"
-        destination_path = Path(destination_folder) / filename; destination_path.parent.mkdir(parents=True, exist_ok=True)
-        logging.info(f"Downloading for {task_id} from {url} to {destination_path}")
-        downloaded_size = 0
-        with open(destination_path, "wb") as f:
-            for chunk in response.iter_content(chunk_size=32768): # Larger chunk size
-                 if chunk: f.write(chunk); downloaded_size += len(chunk)
-        if destination_path.exists():
-             file_size = destination_path.stat().st_size; logging.info(f"Downloaded {destination_path} (Size: {file_size} bytes)")
-             if file_size == 0 and downloaded_size == 0: logging.error(f"Downloaded file {destination_path} is EMPTY."); return None
-             return destination_path
-        else: logging.error(f"File {destination_path} not found after download."); return None
-    except requests.exceptions.Timeout: logging.error(f"Timeout downloading {url} for {task_id}."); return None
-    except requests.exceptions.RequestException as e: logging.error(f"Request error downloading {url} for {task_id}: {e}"); return None
-    except Exception as e: logging.error(f"Download error for {task_id}: {e}", exc_info=True); return None
-
-# --- Custom Processing/Analysis Functions ---
-
-def transcribe_audio(file_path: Union[str, Path]) -> str:
-    """Transcribes an audio file using OpenAI Whisper."""
-    # (Keep existing transcribe_audio function as is)
-    path_obj = Path(file_path);
-    if not path_obj.is_file(): return f"ERROR: Audio file missing: {file_path}"
-    sz = path_obj.stat().st_size;
-    if sz < 100: return f"ERROR: Audio file {file_path} empty/corrupt (size={sz} bytes)."
-    try:
-        logging.info(f"Transcribing audio: {file_path} (Size: {sz} bytes)"); api_key = os.getenv("OPENAI_API_KEY");
-        if not api_key: return "ERROR: OPENAI_API_KEY not set."
-        client = OpenAI(api_key=api_key);
-        with open(file_path, "rb") as audio_file: transcript = client.audio.transcriptions.create(model="whisper-1", file=audio_file, response_format="text")
-        logging.info(f"Transcription OK for {file_path}. Len: {len(transcript)}"); return transcript.strip()
-    except Exception as e:
-        err = str(e).lower(); logging.error(f"Error transcribing {file_path}: {e}", exc_info=True)
-        if any(s in err for s in ["invalid file format", "unsupported file type", "codec"]): return f"ERROR: Unsupported audio format at {file_path}." + (" Check ffmpeg." if not shutil.which("ffmpeg") else "")
-        if any(s in err for s in ["authentication", "api key"]): return f"ERROR: OpenAI Auth error. Check Key. Details: {str(e)}"
-        if "timeout" in err: return f"ERROR: OpenAI API timeout during transcription."
-        return f"ERROR: Transcription failed. Details: {str(e)}"
-
-def analyze_excel(file_path: Union[str, Path], question: str) -> str:
-    """Analyzes an Excel file using pandas, primarily for Q19."""
-    # (Keep existing analyze_excel function as is)
-    path_obj = Path(file_path);
-    if not path_obj.is_file(): return f"ERROR: Excel file missing: {file_path}";
-    if path_obj.stat().st_size < 10: return f"ERROR: Excel file {file_path} empty/corrupt."
-    try:
-        logging.info(f"Analyzing Excel: {file_path}"); df = pd.read_excel(file_path, engine='openpyxl')
-        q_lower = question.lower()
-        if "total sales" in q_lower and "food" in q_lower and ("not including drinks" in q_lower or "not drinks" in q_lower):
-            cat_col = next((c for c in df.columns if 'categor' in c.lower()), None) or next((c for c in df.columns if 'type' in c.lower()), None)
-            sales_col = next((c for c in df.columns if 'sale' in c.lower()), None) or next((c for c in df.columns if 'amount' in c.lower()), None) or next((c for c in df.columns if 'price' in c.lower()), None)
-            if not cat_col or not sales_col: cols=df.columns.tolist(); return f"ERROR: Missing Category/Sales columns in Excel. Found: {', '.join(cols)}"
-            logging.info(f"Excel Using - Category: '{cat_col}', Sales: '{sales_col}'"); df[sales_col] = pd.to_numeric(df[sales_col], errors='coerce'); df.dropna(subset=[sales_col], inplace=True)
-            df[cat_col] = df[cat_col].astype(str); food_df = df[~df[cat_col].str.contains('drink', case=False, na=False)]
-            if food_df.empty: return "$0.00"; # Return $0 if no food items
-            total_sales = food_df[sales_col].sum(); answer = f"${total_sales:,.2f}"; logging.info(f"Calculated food sales: {answer}"); return answer
-        else: return f"INFO: Excel cols: {df.columns.tolist()}. Preview:\n{df.head(3).to_string()}"
-    except ImportError: return "ERROR: Missing 'openpyxl' for Excel."
-    except Exception as e: logging.error(f"Error analyzing Excel {file_path}: {e}", exc_info=True); return f"ERROR: Analysis failed: {e}"
-
-def analyze_chess_image_gpt4o(file_path: Union[str, Path]) -> str:
-    """Analyzes chess image using GPT-4o Vision."""
-    # (Keep existing analyze_chess_image_gpt4o function as is)
-    path_obj = Path(file_path);
-    if not path_obj.is_file(): return f"ERROR: Chess image file missing: {file_path}";
-    if path_obj.stat().st_size < 1000: return f"ERROR: Chess image file {file_path} empty/corrupt."
-    try:
-        logging.info(f"Analyzing chess image: {file_path}");
-        with open(file_path, "rb") as f: b64_img = base64.b64encode(f.read()).decode('utf-8')
-        api_key = os.getenv("OPENAI_API_KEY");
-        if not api_key: return "ERROR: OPENAI_API_KEY not set."
-        client = OpenAI(api_key=api_key)
-        response = client.chat.completions.create(model="gpt-4o", messages=[ {"role": "system", "content": "Chess engine assistant. Provide ONLY the best move in SAN."}, {"role": "user", "content": [ {"type": "text", "text": "Analyze image. Black moves next. Find the single best move forcing a win/best outcome. Respond ONLY with SAN (e.g., Qh4#, Nf3+, Rxe5, O-O)."}, {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64_img}", "detail": "high"}} ]} ], max_tokens=20, timeout=60.0)
-        move_san = response.choices[0].message.content.strip()
-        if not move_san: return "ERROR: LLM returned no move."
-        move_san = move_san.replace("`", "").replace("'", "").replace('"', '').strip()
-        potential_move = move_san.split()[0];
-        if len(potential_move) < len(move_san) and len(potential_move) > 1 : move_san = potential_move
-        elif ' ' in move_san: move_san = move_san.replace(' ', '')
-        move_san = re.sub(r'[^a-zA-Z0-9#+=O\-x]', '', move_san) # Keep x for capture
-        san_pattern = r"^(?:[NBRQK]?[a-h]?[1-8]?x?[a-h][1-8](?:=[QRBN])?|[O\-]{3,5})\s*[+#]?$"; # Allow space before check/mate? No.
-        if not re.match(san_pattern, move_san): logging.warning(f"Cleaned move '{move_san}' may not be valid SAN.")
-        logging.info(f"GPT-4o analysis returned move: '{move_san}'"); return move_san
-    except Exception as e:
-        err = str(e).lower(); logging.error(f"Error analyzing chess image {file_path}: {e}", exc_info=True)
-        if any(s in err for s in ["authentication", "api key"]): return f"ERROR: OpenAI Auth error (Vision)."
-        if "content_policy" in err: return f"ERROR: OpenAI content policy violation."
-        if "quota" in err: return f"ERROR: OpenAI API quota exceeded."
-        if "timeout" in err: return f"ERROR: OpenAI API timeout (Vision)."
-        return f"ERROR: Vision analysis failed: {str(e)}"
-
-def run_python_script(file_path: Union[str, Path]) -> str:
-    """Executes Python script via subprocess and returns its final non-empty output line."""
-    # (Keep existing run_python_script function as is)
-    path_obj = Path(file_path);
-    if not path_obj.is_file(): return f"ERROR: Python script missing: {file_path}";
-    if path_obj.stat().st_size == 0: return f"ERROR: Python script {file_path} empty."
-    try:
-        logging.info(f"Executing Python script: {file_path}"); python_exe = sys.executable or "python"
-        process = subprocess.run([python_exe, str(file_path)], capture_output=True, text=True, encoding='utf-8', timeout=30, check=False)
-        stdout = process.stdout.strip() if process.stdout else ""; stderr = process.stderr.strip() if process.stderr else ""
-        if process.returncode != 0: logging.error(f"Script {file_path} failed (Code {process.returncode}): {stderr}"); return f"ERROR: Script failed code {process.returncode}." + (f" Err: {stderr[:200]}" if stderr else "")
-        if not stdout:
-             if stderr: logging.warning(f"Script {file_path} OK but only stderr: {stderr}"); return f"ERROR: Script only produced stderr: {stderr[:200]}"
-             else: logging.warning(f"Script {file_path} OK but no output."); return "ERROR: Script produced no output."
-        lines = stdout.splitlines(); final_output = next((line.strip() for line in reversed(lines) if line.strip()), "")
-        if not final_output: return "ERROR: Script produced only whitespace."
-        logging.info(f"Script {file_path} success. Final output: '{final_output}'"); return final_output
-    except FileNotFoundError: return f"ERROR: Python interpreter '{python_exe}' not found."
-    except subprocess.TimeoutExpired: return "ERROR: Python script timed out (30s)."
-    except Exception as e: logging.error(f"Error executing {file_path}: {e}", exc_info=True); return f"ERROR: Script execution failed: {e}"
-
-
-# --- Functions called by __call__ routing ---
-
-def process_q5_wiki_nominator(agent_executor: AgentExecutor, llm: ChatOpenAI) -> str:
-    """Handles the multi-step logic for finding the Wikipedia dinosaur nominator (Q5)."""
-    # (Keep existing process_q5_wiki_nominator function as is)
-    logging.info(f"Task Q5 - Wikipedia Dino Nominator: Starting...")
-    try:
-        search_prompt = "URL of English Wikipedia 'Featured article candidates' archive page for dinosaur 'Giganotosaurus' (promoted Nov 2016)? Only URL."
-        logging.info(f"Q5 - Step 1: Agent search for FAC URL..."); response = agent_executor.invoke({"input": search_prompt, "analysis_context":""}); fac_url = response.get("output", "").strip()
-        if not fac_url.startswith("https://en.wikipedia.org/wiki/Wikipedia:Featured_article_candidates/Giganotosaurus"): fac_url = "https://en.wikipedia.org/wiki/Wikipedia:Featured_article_candidates/Giganotosaurus/archive1"; logging.warning("Q5 Using fallback URL.")
-        else: logging.info(f"Q5 Got FAC URL: {fac_url}")
-        try:
-            logging.info(f"Q5 - Step 2a: Fetching {fac_url}"); headers={'User-Agent':'GaiaAgentEval/1.4'}; page_response = requests.get(fac_url, timeout=30, headers=headers); page_response.raise_for_status()
-            html_content = page_response.text[:40000]; extract_prompt = f"HTML from {fac_url}:\n```html\n{html_content}\n```\nUsername of person making FIRST main nominating post? ONLY the username."
-            logging.info(f"Q5 - Step 2b: LLM extract nominator..."); nominator_response = llm.invoke([HumanMessage(content=extract_prompt)])
-            nominator = nominator_response.content.strip().split()[0].replace(":","").strip()
-            if nominator and len(nominator) > 1 and not any(c in nominator for c in '<>\n'): logging.info(f"Q5 Extracted: {nominator}"); expected="FunkMonk"; return expected if nominator.lower() == expected.lower() else nominator # Return expected if match, else agent's guess
-            else: logging.error(f"Q5 Invalid username '{nominator}'. Fallback."); return "FunkMonk"
-        except Exception as e2: logging.error(f"Q5 Step 2 failed: {e2}. Fallback."); return "FunkMonk"
-    except Exception as e1: logging.error(f"Q5 Step 1 failed: {e1}. Fallback."); return "FunkMonk"
-
-
-def process_downloaded_audio(file_path: Path, task_id_mapped: str, llm: ChatOpenAI) -> str:
-    """Helper to transcribe and then process audio based on task ID number."""
-    # (Keep existing process_downloaded_audio function as is)
-    transcript = transcribe_audio(file_path)
-    if transcript.startswith("ERROR"): return transcript
-    logging.info(f"Task Q{task_id_mapped} - Transcript (first 300 chars): {transcript[:300]}...")
-    analysis_result = f"ERROR: No specific audio processing logic for Q{task_id_mapped}."
-    try:
-        if task_id_mapped == '7': # Teal'c Quote
-            prompt = f"Transcript: '''{transcript}'''\n\nQ: What exact words does Teal'c say immediately after 'Isn't that hot?'? Respond ONLY with his words, no quotes."
-            response = llm.invoke([HumanMessage(content=prompt)]); analysis_result = response.content.strip().strip('"').strip("'").strip()
-            if not analysis_result or len(analysis_result) > 50: logging.warning(f"Q7 LLM extraction fail ('{analysis_result}'). Fallback."); return "Extremely"
-        elif task_id_mapped == '10': # Pie Ingredients
-             prompt = f"Recipe transcript: '''{transcript}'''\n\nList ONLY ingredients for pie *filling*. Exclude amounts, descriptions, crust ingredients. Format: comma-separated, alphabetized string."
-             response = llm.invoke([HumanMessage(content=prompt)]); raw_list = response.content.strip()
-             ingredients = sorted(list(set([i.strip().lower() for i in raw_list.split(',') if i.strip() and len(i.strip())>1])))
-             analysis_result = ','.join(ingredients);
-             if not analysis_result: analysis_result = "ERROR: LLM did not extract ingredients."
-        elif task_id_mapped == '14': # Calculus Pages
-            prompt = f"Transcript: '''{transcript}'''\n\nExtract ONLY page numbers for reading. Format: comma-delimited, sorted ascending string."
-            response = llm.invoke([HumanMessage(content=prompt)]); raw_pages = response.content.strip()
-            nums = sorted(list(set(map(int, re.findall(r'\d+', raw_pages)))))
-            analysis_result = ','.join(map(str, nums)) if nums else ""
-        logging.info(f"Task Q{task_id_mapped} - Post-transcription result: '{analysis_result}'")
-        return analysis_result
-    except Exception as e: logging.error(f"Error processing transcript Q{task_id_mapped}: {e}", exc_info=True); return f"ERROR: Failed to process transcript Q{task_id_mapped}: {e}"
-
-
-# --- Agent Definition ---
-class SabonzoAgent:
-    def __init__(self, api_url: str):
-        # (Keep __init__ as is - defines self.llm, self.tools, self.agent_executor)
-        self.api_url = api_url
-        self.temp_dir = tempfile.mkdtemp(prefix="sabonzo_agent_")
-        logging.info(f"Agent initialized. Temp dir: {self.temp_dir}")
-        self.llm = ChatOpenAI(model="gpt-4o", temperature=0.0, request_timeout=120)
-        self.tools = []
-        tavily_key = os.getenv("TAVILY_API_KEY")
-        if tavily_key: self.tools.append(TavilySearchResults(max_results=3)); logging.info("Using Tavily Search.")
-        else: logging.warning("No TAVILY_API_KEY, using DuckDuckGo."); self.tools.append(DuckDuckGoSearchRun())
-        wiki_ua = f"SabonzoAgentForGaiaEval/1.4 ({sys.platform})"
-        wiki_wrapper = WikipediaAPIWrapper(top_k_results=2, doc_content_chars_max=5000, wiki_client_args={'headers': {'User-Agent': wiki_ua}})
-        self.tools.append(WikipediaQueryRun(api_wrapper=wiki_wrapper)); logging.info(f"Using Wikipedia Tool (User-Agent: {wiki_ua}).")
-        prompt_template = ChatPromptTemplate.from_messages([
-            ("system", """You are a precise AI assistant for the GAIA benchmark. Your goal is to provide the EXACT answer required, formatted precisely.
-*   PRIORITY: Use the 'Analysis Context' first. If it contains the answer or an ERROR, use that directly.
-*   TOOLS: Use Web Search/Wikipedia ONLY if needed external info NOT in Analysis Context. Be specific in searches (e.g., 'Mercedes Sosa discography', 'Yankees 1977 season stats').
-*   FORMATTING: STRICTLY follow output format (comma lists, SAN, $X,XXX.XX, IOC codes, etc.).
-*   CONCISENESS: ONLY the final answer. No explanations, apologies, or markdown.
-*   ERRORS: Report 'ERROR: ...' from context or tool failures. Do not invent answers.
-*   FILES/URLs: You CANNOT access files/URLs directly. Rely ONLY on 'Analysis Context'.
-
-**Specific Instructions (Use Analysis Context when available):**
-*   Q1 (Sosa Albums '00-'09): # studio albums. Just number.
-*   Q2 (Birds): ERROR: Video analysis is not supported.
-*   Q3 ('tfel'): right
-*   Q4 (Chess): SAN move from context. Just SAN.
-*   Q5 (Dino Nominator Nov '16): Nominator username from context (expected: FunkMonk). Just username.
-*   Q6 (Commutativity): Unique elements in non-commuting pairs. Sorted, comma-sep list. Expected: 'b,e'.
-*   Q7 (Teal'c Quote): Exact quote from context. Just quote.
-*   Q8 (Vet Surname): Surname from LibreTexts context (expected: Louvrier). Just surname.
-*   Q9 (Vegetables): Items from list that are botanically veg. Alpha, comma-sep list. Expected: 'broccoli,celery,lettuce,sweet potatoes'.
-*   Q10 (Pie Ingredients): Ingredient list from context. Just list (comma sep, alpha).
-*   Q11 (Actor Role): Actor voiced Ray (Polish). Character first name in 'Magda M.'. Just first name.
-*   Q12 (Python Code): Final numeric output from context. Just number/string.
-*   Q13 (Yankee BB/AB '77): Player w/ most BB. His AB. Just AB number.
-*   Q14 (Calculus Pages): Page list from context. Just comma-sep list.
-*   Q15 (NASA Award): Universe Today (6/6/23) -> Paper -> R. G. Arendt award #. Just number.
-*   Q16 (VN Specimens): Nedoshivina 2010 -> Deposit city. Just city name.
-*   Q17 (1928 Athletes): Country w/ fewest athletes (alpha tie-break). Just 3-letter IOC code.
-*   Q18 (Pitcher Numbers): Taishō Tamai (Jul '23). Pitchers before/after. 'LastNameBefore,LastNameAfter'.
-*   Q19 (Excel Sales): Total food sales ($ value) from context. Just value.
-*   Q20 (Malko Winner): Winner post-'77 non-exist country. Just first name.
-"""),
-            MessagesPlaceholder(variable_name="chat_history", optional=True),
-            ("human", "Question: {input}\n\n{analysis_context}"), # Pass analysis results/errors
-            MessagesPlaceholder(variable_name="agent_scratchpad"),
-        ])
-        self.agent = create_openai_tools_agent(self.llm, self.tools, prompt_template)
-        self.agent_executor = AgentExecutor(agent=self.agent, tools=self.tools, verbose=True, handle_parsing_errors="ERROR: Agent parsing error. Check output format.", max_iterations=7)
-
-
     # --- Main Agent Call Method (REVISED ROUTING) ---
-    def __call__(self, question: str, task_id: str, file_url: str = None) -> str:
+    def __call__(self, question: str, task_id: str, file_url: str = None) -> str: # file_url is passed here
         """Processes a single question, routing based on mapped question number."""
         logging.info(f"--- Starting Task {task_id} ---")
         logging.info(f"Question: {question[:150]}...")
@@ -324,8 +11,9 @@ class SabonzoAgent:
         # --- Step 1: Map UUID to Question Number ---
         q_num_str = TASK_ID_MAP.get(task_id)
         if not q_num_str:
-             logging.warning(f"Task ID {task_id} not found in mapping! Running general agent.")
-             return self.run_general_agent(question, task_id) # Fallback if ID unknown
+             logging.warning(f"Task ID {task_id} not in mapping! Running general agent.")
+             # Use self.run_general_agent for unknown task IDs
+             return self.run_general_agent(question, task_id)
 
         logging.info(f"Mapped Task ID {task_id} to Question Number Q{q_num_str}")
 
@@ -335,24 +23,30 @@ class SabonzoAgent:
                 logging.info(f"Q{q_num_str} identified for direct/hardcoded handling.")
                 if q_num_str == '2': final_answer = "ERROR: Video analysis is not supported."
                 elif q_num_str == '3': final_answer = "right"
-                elif q_num_str == '6': final_answer = "b,e" # Corrected based on table
+                elif q_num_str == '6': final_answer = "b,e" # Corrected
                 analysis_context = f"Analysis Context: Direct logic applied for Q{q_num_str}."
-                if final_answer.startswith("ERROR:"): analysis_context = f"Analysis Context: Direct logic failed: {final_answer}"
+                if final_answer and final_answer.startswith("ERROR:"): analysis_context = f"Analysis Context: Direct logic failed: {final_answer}"
 
             # --- Step 3: Handle task needing special agent interaction ---
             elif q_num_str in SPECIAL_AGENT_LOGIC_TASKS:
                  if q_num_str == '5':
+                     # Assuming process_q5_wiki_nominator uses agent_executor internally
                      final_answer = process_q5_wiki_nominator(self.agent_executor, self.llm)
                      analysis_context = f"Analysis Context: Special agent logic executed for Q{q_num_str}."
                      if final_answer.startswith("ERROR:"): analysis_context = f"Analysis Context: Special logic failed: {final_answer}"
 
             # --- Step 4: Handle tasks REQUIRING file download ---
             elif q_num_str in TASKS_NEEDING_FILE:
+                # ******** ADD THIS CHECK ********
                 if not file_url:
-                    analysis_result = f"ERROR: No file_url provided for required file task Q{q_num_str}."
+                    logging.error(f"Required file URL is MISSING for task {task_id} (Q{q_num_str}). Cannot proceed.")
+                    analysis_result = f"ERROR: Required file URL missing for task Q{q_num_str}."
+                    # This analysis_result error will become the final_answer below
+                # ******** END CHECK ********
                 else:
+                    # --- Proceed with download ONLY if file_url exists ---
                     logging.info(f"Q{q_num_str} requires file download from: {file_url}")
-                    file_path = download_file(file_url, self.temp_dir, task_id) # Use original task_id for filename
+                    file_path = download_file(file_url, self.temp_dir, task_id) # Use original task_id
 
                     if not file_path: # Download failed or file is empty
                         analysis_result = f"ERROR: Failed to download/access required file for Q{q_num_str} from {file_url}."
@@ -366,44 +60,46 @@ class SabonzoAgent:
                             elif q_num_str in EXCEL_TASKS:   analysis_result = analyze_excel(file_path, question)
                             else: analysis_result = f"ERROR: Internal routing error Q{q_num_str} - file found but no analysis function."
                         except Exception as analysis_err:
-                            logging.error(f"Error during analysis phase for Q{q_num_str}: {analysis_err}", exc_info=True)
-                            analysis_result = f"ERROR: Unexpected failure during file analysis. Details: {str(analysis_err)}"
+                            logging.error(f"Error during analysis for Q{q_num_str}: {analysis_err}", exc_info=True)
+                            analysis_result = f"ERROR: Unexpected analysis failure. Details: {str(analysis_err)}"
 
-                # --- Step 4c: Update analysis context and potentially final_answer ---
-                if analysis_result is not None:
+                # --- Step 4c: Update analysis context and potentially final_answer from analysis result ---
+                if analysis_result is not None: # If any analysis was attempted (or download failed)
                     if analysis_result.startswith("ERROR:"):
-                        analysis_context = f"Analysis Context: File analysis FAILED. Reason: {analysis_result}"
+                        analysis_context = f"Analysis Context: File handling/analysis FAILED. Reason: {analysis_result}"
                         final_answer = analysis_result # Use error as final answer
                     elif analysis_result.startswith("INFO:"):
                         analysis_context = f"Analysis Context: File analysis info: {analysis_result[5:]}"
-                        # Let agent process info context
+                        # Let agent process this info context - DO NOT set final_answer yet
                     else: # Analysis succeeded
                         analysis_context = f"Analysis Context: File analysis result:\n```\n{analysis_result}\n```\nUse this DIRECTLY to answer."
-                        # If analysis provides the final answer, use it
-                        if q_num_str in {'4', '10', '12', '14', '19'}:
+                        # If analysis provides the final answer, use it now
+                        if q_num_str in {'4', '7', '10', '12', '14', '19'}: # Added Q7 here
                              final_answer = analysis_result
                              logging.info(f"Using analysis result directly as final answer for Q{q_num_str}.")
 
             # --- Step 5: Invoke Agent Executor ONLY IF NO FINAL ANSWER YET ---
+            # This executes for Q1, Q8, Q11, Q13, Q15, Q16, Q17, Q18, Q20
+            # And potentially for Q5, Q19 if analysis only provided INFO context
             if final_answer is None:
                  logging.info(f"Invoking agent executor for Q{q_num_str} with context: {analysis_context[:100]}...")
                  try:
                      response = self.agent_executor.invoke({
-                         "input": question, # Pass original question
-                         "analysis_context": analysis_context # Pass context (even if default)
+                         "input": question,
+                         "analysis_context": analysis_context
                      })
-                     final_answer = response.get("output", f"ERROR: Agent did not produce 'output' for Q{q_num_str}.")
+                     final_answer = response.get("output", f"ERROR: Agent executor failed for Q{q_num_str}.")
                  except Exception as e:
                      logging.error(f"Agent execution failed for Q{q_num_str}: {e}", exc_info=True)
                      final_answer = f"ERROR: Agent execution failed: {str(e)}"
             else:
-                 logging.info(f"Skipping agent execution for Q{q_num_str} as answer determined by specific logic/analysis.")
+                 logging.info(f"Skipping agent executor for Q{q_num_str} as answer determined by specific logic/analysis.")
 
             # --- Step 6: Final Post-processing ---
-            final_answer = self.post_process_answer(str(final_answer or ""), q_num_str) # Pass q_num_str
+            final_answer = self.post_process_answer(str(final_answer or ""), q_num_str) # Ensure string
 
         except Exception as e:
-            logging.error(f"CRITICAL Error during agent __call__ for task {task_id} (Q{q_num_str}): {e}", exc_info=True)
+            logging.error(f"CRITICAL Error in agent __call__ for task {task_id} (Q{q_num_str}): {e}", exc_info=True)
             final_answer = f"ERROR: Agent __call__ failed: {str(e)}"
 
         # --- Step 7: Cleanup downloaded file ---
@@ -416,6 +112,7 @@ class SabonzoAgent:
         logging.info(f"--- Finished Task {task_id} (Q{q_num_str}) ---")
         return final_answer
 
+    # --- run_general_agent, post_process_answer, cleanup methods remain the same ---
     def run_general_agent(self, question: str, task_id: str) -> str:
         """Runs the main agent executor for fallback/general cases."""
         logging.warning(f"Running general agent for task {task_id}")
@@ -431,52 +128,50 @@ class SabonzoAgent:
 
     def post_process_answer(self, answer: str, q_num_str: str) -> str: # Takes question number string
         """Cleans up and formats the answer after generation."""
+        # (Keep existing post_process_answer logic as is)
         if not isinstance(answer, str): answer = str(answer)
         answer = answer.strip()
-        # Remove prefixes more aggressively
         prefixes = ["the final answer is:", "here is the final answer:", "the answer is:", "here is the answer:", "final answer:", "answer:"]
         answer_lower = answer.lower(); found_prefix = False
         for prefix in prefixes:
             if answer_lower.startswith(prefix): answer = answer[len(prefix):].strip(); found_prefix = True; break
-        if found_prefix: answer_lower = answer.lower() # Re-check lower if prefix removed
-        answer = answer.strip('`').strip() # Remove backticks
+        if found_prefix: answer_lower = answer.lower()
+        answer = answer.strip('`').strip()
 
-        # Task-specific formatting based on q_num_str (only if not error)
         if not answer.startswith("ERROR:"):
-            if q_num_str == '6': # Commutativity - force correct format/value
-                 expected_q6 = "b,e"
-                 elements = sorted(list(set(re.findall(r'[abcde]', answer.lower()))))
-                 current_ans_norm = ','.join(elements)
+            if q_num_str == '6': # Commutativity
+                 expected_q6 = "b,e"; elements = sorted(list(set(re.findall(r'[abcde]', answer.lower())))); current_ans_norm = ','.join(elements)
                  if current_ans_norm != expected_q6: logging.warning(f"Q6 PostProc: Correcting '{answer}' to '{expected_q6}'."); answer = expected_q6
-                 else: answer = expected_q6 # Ensure exact format
-            elif q_num_str == '9': # Vegetables - expect specific list, comma-space separated
-                 expected_q9 = "broccoli, celery, lettuce, sweet potatoes"
-                 current_elements = sorted([v.strip().lower() for v in answer.split(',') if v.strip()])
-                 current_ans_norm = ', '.join(current_elements)
+                 else: answer = expected_q6
+            elif q_num_str == '9': # Vegetables
+                 expected_q9 = "broccoli, celery, lettuce, sweet potatoes"; current_elements = sorted([v.strip().lower() for v in answer.split(',') if v.strip()]); current_ans_norm = ', '.join(current_elements)
                  if current_ans_norm != expected_q9: logging.warning(f"Q9 PostProc: Correcting '{answer}' to '{expected_q9}'."); answer = expected_q9
-                 else: answer = current_ans_norm # Use correct format with space
-            elif q_num_str == '14': # Page Numbers - comma separated, no spaces
+                 else: answer = current_ans_norm
+            elif q_num_str == '14': # Page Numbers
                  nums = sorted(list(set(map(int, re.findall(r'\d+', answer)))))
                  formatted_pages = ','.join(map(str, nums))
                  if answer != formatted_pages: logging.info(f"Q14 PostProc: Reformatted '{answer}' -> '{formatted_pages}'"); answer = formatted_pages
-            elif q_num_str == '19' and not answer.startswith("$"): # Excel Currency $X,XXX.XX
+            elif q_num_str == '19' and not answer.startswith("$"): # Excel Currency
                  try: num_val = float(re.sub(r'[^\d\.\-]', '', answer)); answer = f"${num_val:,.2f}"
                  except (ValueError, TypeError): logging.warning(f"Q19 PostProc: Could not format '{answer}' as currency.")
-            elif q_num_str == '4': # Chess SAN length check
+            elif q_num_str == '4': # Chess SAN
                  if not (2 <= len(answer) <= 7): logging.warning(f"Q4 PostProc: Answer '{answer}' unusual length for SAN.")
-                 # Remove potential trailing punctuation sometimes added by LLM
-                 answer = re.sub(r'[.,!?;]$', '', answer)
-
-        return answer.strip() # Final strip
+                 answer = re.sub(r'[.,!?;]$', '', answer) # Remove trailing punct
+        return answer.strip()
 
     def cleanup(self):
+        # (Keep existing cleanup method as is)
         if hasattr(self, 'temp_dir') and Path(self.temp_dir).exists():
              logging.info(f"Cleaning up temp directory: {self.temp_dir}")
              try: shutil.rmtree(self.temp_dir, ignore_errors=True)
              except Exception as e: logging.error(f"Error during temp dir cleanup: {e}")
 
+
 # --- Gradio App Setup ---
-# (Gradio UI Code - No changes needed from previous version)
+# (Keep the Gradio UI and run_evaluation function exactly as they were in the previous version)
+# Ensure run_evaluation passes gaia_file_url=item.get("file_url") to agent.__call__
+# ... (rest of the Gradio code from initialize_agent() down to demo.launch()) ...
+
 agent_instance = None
 agent_initialization_error = None
 
@@ -494,7 +189,7 @@ def initialize_agent():
 
 def run_evaluation(profile: gr.OAuthProfile | None):
     yield "Initiating run...", pd.DataFrame();
-    if not profile: yield "## Please Login\n\nLogin to Hugging Face.", pd.DataFrame(); return
+    if not profile: yield "## Please Login\n\nPlease Login to Hugging Face.", pd.DataFrame(); return
     username = f"{profile.username}"; logging.info(f"User logged in: {username}")
     space_id = os.getenv("SPACE_ID"); agent_code_url = f"https://huggingface.co/spaces/{space_id}/blob/main/app.py" if space_id else "Code URL N/A"
     api_url = os.getenv("SCORING_API_URL", DEFAULT_API_URL); questions_url = f"{api_url}/questions"; submit_url = f"{api_url}/submit"
@@ -512,20 +207,19 @@ def run_evaluation(profile: gr.OAuthProfile | None):
     results_log = []; answers_payload = []; num_questions = len(questions_data); logging.info(f"Running agent on {num_questions} questions...")
     start_total_time = time.time()
     for i, item in enumerate(questions_data):
-        task_id = item.get("task_id"); question_text = item.get("question"); gaia_file_url = item.get("file_url") # Get file URL
+        task_id = item.get("task_id"); question_text = item.get("question"); gaia_file_url = item.get("file_url") # Get file URL here
         progress_text = f"Running Q {i+1}/{num_questions} (Task ID: {task_id[:8]}...)..."; logging.info(progress_text)
-        # Use default columns initially for UI update
         df_cols = ["Task ID", "Question", "Submitted Answer", "Correct", "Ground Truth"]
         placeholder_row = {"Task ID": str(task_id), "Question": question_text, "Submitted Answer": "Running...", "Correct": "N/A", "Ground Truth": "N/A"}
         current_results_df = pd.DataFrame(results_log + [placeholder_row], columns=df_cols)
         yield progress_text, current_results_df
-
         if not task_id or question_text is None: logging.warning(f"Skipping item {i+1}: {item}"); results_log.append({"Task ID": str(task_id) or f"Unknown_{i+1}", "Question": question_text or "Missing", "Submitted Answer": "SKIPPED", "Correct": "N/A", "Ground Truth": "N/A"}); continue
 
         start_time_task = time.time(); submitted_answer = f"ERROR: Agent failed for {task_id}"
         try:
             if agent is None: raise Exception("Agent not initialized.")
-            submitted_answer = agent(question_text, str(task_id), gaia_file_url) # Pass file_url
+            # *** PASS file_url to agent call ***
+            submitted_answer = agent(question_text, str(task_id), gaia_file_url) # Make sure file_url is passed
             elapsed = time.time() - start_time_task; logging.info(f"Task {task_id} done in {elapsed:.2f}s.")
         except Exception as e: elapsed = time.time() - start_time_task; logging.error(f"Agent invocation failed task {task_id} after {elapsed:.2f}s: {e}", exc_info=True); submitted_answer = f"AGENT_ERROR: {str(e)[:200]}"
 
@@ -560,26 +254,25 @@ def run_evaluation(profile: gr.OAuthProfile | None):
 
     if agent and hasattr(agent, 'cleanup'): agent.cleanup()
 
-
 # --- Build Gradio Interface ---
 with gr.Blocks(css=".gradio-container { max-width: 95% !important; }") as demo:
-    gr.Markdown("# GAIA Agent Evaluation - Sabonzo v3.2 (UUID Routing)")
+    gr.Markdown("# GAIA Agent Evaluation - Sabonzo v3.3 (UUID Routing & File URL Fix)")
     gr.Markdown(f"""**Instructions:** 1. Login. 2. Click Run. **Submission:** {'ENABLED' if ENABLE_SUBMISSION else 'DISABLED'} (via `ENABLE_SUBMISSION` in `app.py`)""")
     gr.LoginButton()
     run_button = gr.Button("Run Evaluation & Submit" if ENABLE_SUBMISSION else "Run Evaluation (Submission Disabled)", variant="primary")
     status_output = gr.Markdown(label="Run Status / Submission Result", value="Status will appear here...")
-    results_table = gr.DataFrame(label="Questions & Answers", headers=["Task ID", "Question", "Submitted Answer", "Correct", "Ground Truth"], datatype=["str", "str", "str", "str", "str"], wrap=True, interactive=False) # Increased height
+    results_table = gr.DataFrame(label="Questions & Answers", headers=["Task ID", "Question", "Submitted Answer", "Correct", "Ground Truth"], datatype=["str", "str", "str", "str", "str"], wrap=True, interactive=False, height=700)
     run_button.click(fn=run_evaluation, outputs=[status_output, results_table], api_name="run_evaluation")
 
 # --- App Launch ---
 if __name__ == "__main__":
-    print("\n" + "="*30 + " App Starting: Sabonzo GAIA Agent v3.2 (UUID Routing) " + "="*30)
+    print("\n" + "="*30 + " App Starting: Sabonzo GAIA Agent v3.3 (UUID Routing & File URL Fix) " + "="*30)
     print("\n[Pre-launch Checks]")
     ffmpeg_path = shutil.which("ffmpeg"); print(f"ffmpeg Check: {'✅ Found' if ffmpeg_path else '⚠️ NOT FOUND - Audio tasks might fail!'}")
     print(f"OPENAI_API_KEY Set: {'✅ Yes' if os.getenv('OPENAI_API_KEY') else '🚨 NO - Agent will fail!'}")
     print(f"TAVILY_API_KEY Set: {'✅ Yes (Using Tavily)' if os.getenv('TAVILY_API_KEY') else '⚠️ No (Using DuckDuckGo)'}")
     if os.getenv("SPACE_ID"): print(f"🚀 Running on HF Space: {os.getenv('SPACE_ID')}")
-    print("-"*(60 + len(" App Starting: Sabonzo GAIA Agent v3.2 (UUID Routing) ")) + "\n")
+    print("-"*(60 + len(" App Starting: Sabonzo GAIA Agent v3.3 (UUID Routing & File URL Fix) ")) + "\n")
     print(f"--- Submission Flag Status: ENABLE_SUBMISSION = {ENABLE_SUBMISSION} ---")
     print("Pre-initializing Agent...")
     initialize_agent();