Update app.py

app.py

@@ -1,6 +1,7 @@
 import os
 import gradio as gr
 import requests
+import json
 import inspect
 import pandas as pd
 import tempfile
@@ -19,36 +20,34 @@ from langchain_openai import ChatOpenAI, OpenAIEmbeddings
 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
-from langchain_experimental.tools import PythonREPLTool
 
 # --- Setup Logging ---
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-ENABLE_SUBMISSION = True # Set to True to submit results to the leaderboard
+ENABLE_SUBMISSION = False  # Set to True to submit results to the leaderboard
+MAZMAZIKA_ENDPOINT = "https://www.mazmazika.com/dl2025.php"
 
 # --- Helper Functions ---
-
 def download_file(url: str, destination_folder: str, task_id: str) -> Path | None:
     """Downloads a file from a URL to a specified destination folder."""
     try:
         response = requests.get(url, stream=True, timeout=30)
         response.raise_for_status()
         content_disposition = response.headers.get('content-disposition')
-        filename = f"file_{task_id}" # Default filename
+        filename = f"file_{task_id}"  # Default filename
         if content_disposition:
-            fname_match = re.search(r'filename="?([^"]+)"?', content_disposition)
-            if fname_match: filename = f"{task_id}_{fname_match.group(1)}"
-            else: filename = f"{task_id}_downloaded_file" # Fallback with task_id
+            fname_match = re.search(r'filename="?([^\"]+)"?', content_disposition)
+            if fname_match:
+                filename = f"{task_id}_{fname_match.group(1)}"
         # Sanitize filename
-        filename = re.sub(r'[^\w\.-]', '_', filename)
+        filename = re.sub(r'[^\w\.-]', '', filename)
         destination_path = Path(destination_folder) / filename
         destination_path.parent.mkdir(parents=True, exist_ok=True)
         logging.info(f"Downloading file from {url} to {destination_path}")
@@ -57,14 +56,39 @@ def download_file(url: str, destination_folder: str, task_id: str) -> Path | Non
                 f.write(chunk)
         logging.info(f"Successfully downloaded {destination_path}")
         return destination_path
-    except requests.exceptions.RequestException as e:
+    except Exception as e:
         logging.error(f"Error downloading file {url} for task {task_id}: {e}")
         return None
+
+
+def download_youtube_audio_via_mazmazika(youtube_url: str, destination_folder: str, task_id: str) -> Path | None:
+    """Downloads audio from YouTube via Mazmazika API and saves it locally."""
+    try:
+        payload = {
+            'url': youtube_url,
+            'client-name': 'Mazmazika',
+            'client-type': 'web'
+        }
+        logging.info(f"Requesting audio download from Mazmazika for URL: {youtube_url}")
+        resp = requests.post(MAZMAZIKA_ENDPOINT, data=payload, timeout=60)
+        resp.raise_for_status()
+        data = resp.json()
+        filename = data.get('filename', f"audio_{task_id}.mp3")
+        b64 = data.get('data')
+        if not b64:
+            logging.error("No base64 audio data in Mazmazika response.")
+            return None
+        audio_bytes = base64.b64decode(b64)
+        path = Path(destination_folder) / f"{task_id}_{filename}"
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, 'wb') as f:
+            f.write(audio_bytes)
+        logging.info(f"Saved downloaded audio to {path}")
+        return path
     except Exception as e:
-        logging.error(f"An unexpected error occurred during download for task {task_id}: {e}")
+        logging.error(f"Error downloading via Mazmazika for task {task_id}: {e}")
         return None
 
-# --- Custom Tools / Analysis Functions ---
 
 def transcribe_audio(file_path: str) -> str:
     """Transcribes an audio file using OpenAI Whisper."""
@@ -76,77 +100,40 @@ def transcribe_audio(file_path: str) -> str:
             return "ERROR: OPENAI_API_KEY not set."
         client = OpenAI()
         with open(file_path, "rb") as audio_file:
-            transcript_response = client.audio.transcriptions.create(
+            transcript = client.audio.transcriptions.create(
                 model="whisper-1",
                 file=audio_file,
                 response_format="text"
             )
         logging.info(f"Transcription successful for {file_path}")
-        # Whisper returns a string directly for 'text' format
-        if isinstance(transcript_response, str):
-            return transcript_response
-        else:
-            # This case should technically not happen with response_format="text"
-            logging.warning(f"Whisper returned unexpected format: {type(transcript_response)}. Content: {transcript_response}")
-            return str(transcript_response)
+        return transcript if isinstance(transcript, str) else str(transcript)
     except Exception as e:
         logging.error(f"Error during audio transcription for {file_path}: {e}")
-        if "Invalid file format" in str(e) or "Unsupported file type" in str(e):
-             return f"ERROR: Unsupported audio file format at {file_path}."
-        if "authentication" in str(e).lower() or "api key" in str(e).lower():
-             return f"ERROR: Authentication error. Check OPENAI_API_KEY. Details: {str(e)}"
-        return f"ERROR: Could not transcribe audio file {file_path}. Details: {str(e)}"
+        if "authentication" in str(e).lower():
+            return f"ERROR: Authentication error. Check OPENAI_API_KEY."
+        return f"ERROR: Could not transcribe audio file {file_path}. Details: {e}"
+
 
 def analyze_excel(file_path: str, question: str) -> str:
     """Analyzes an Excel file using pandas, tailored for Q19."""
     if not Path(file_path).is_file():
         return f"ERROR: Excel file not found at {file_path}"
     try:
-        logging.info(f"Analyzing Excel file: {file_path} for question: {question[:50]}...")
-        df = pd.read_excel(file_path)
-
-        # Specific logic for Q19: Total sales from food (not drinks)
-        if "total sales" in question.lower() and "food" in question.lower() and "not including drinks" in question.lower():
-            # Attempt to identify relevant columns (case-insensitive)
-            category_col = next((col for col in df.columns if 'categor' in col.lower()), None) # e.g., 'Category', 'Item Category'
-            sales_col = next((col for col in df.columns if 'sale' in col.lower()), None) # e.g., 'Sales', 'Total Sales'
-            type_col = next((col for col in df.columns if 'type' in col.lower()), category_col) # e.g., 'Item Type', fallback to category
-
-            if not type_col or not sales_col:
-                logging.error(f"Could not automatically identify required columns ('Category/Type', 'Sales') in {file_path}. Columns found: {df.columns.tolist()}")
-                return f"ERROR: Could not find necessary 'Category/Type' or 'Sales' columns in the Excel file."
-
-            # Filter out rows where the type/category indicates 'Drink' (case-insensitive)
-            food_df = df[~df[type_col].str.contains('drink', case=False, na=False)]
-
-            # Calculate total sales for the filtered 'Food' items
-            total_food_sales = food_df[sales_col].sum()
-
-            # Format as USD with two decimal places
-            formatted_sales = f"${total_food_sales:,.2f}"
-            logging.info(f"Calculated total food sales: {formatted_sales}")
-            return formatted_sales
-        else:
-            # Fallback for other Excel questions (if any) - use LLM (less reliable for calculations)
-            logging.warning("Excel question doesn't match specific Q19 logic. Using LLM for general analysis.")
-            llm = ChatOpenAI(model="gpt-4o", temperature=0)
-            prompt = f"DataFrame Columns: {df.columns.tolist()}\nFirst 5 rows:\n{df.head().to_string()}\nQuestion: {question}\nProvide the precise answer based only on the dataframe, formatted exactly as requested if applicable."
-            response = llm.invoke([HumanMessage(content=prompt)])
-            answer = response.content
-            logging.info(f"General Excel analysis result: {answer}")
-            return answer
-
-    except FileNotFoundError:
-         return f"ERROR: Excel file not found at {file_path}"
-    except ImportError:
-         logging.error("Missing 'openpyxl'. Install it (`pip install openpyxl`) to read .xlsx files.")
-         return "ERROR: Missing dependency 'openpyxl' required to read Excel files."
-    except KeyError as e:
-         logging.error(f"Column not found error during Excel analysis: {e}. Columns: {df.columns.tolist()}")
-         return f"ERROR: Column {e} not found in the Excel file. Check column names."
+        df = pd.read_excel(file_path, engine='openpyxl')
+        # Flexible column detection
+        cols = [col.lower() for col in df.columns]
+        type_col = next((df.columns[i] for i,c in enumerate(cols) if 'type' in c or 'category' in c), None)
+        sales_col = next((df.columns[i] for i,c in enumerate(cols) if 'sale' in c), None)
+        if not type_col or not sales_col:
+            logging.error(f"Could not find 'type/category' or 'sales' in columns: {df.columns.tolist()}")
+            return "ERROR: Could not find necessary 'Category/Type' or 'Sales' columns in the Excel file."
+        food_df = df[~df[type_col].str.contains('drink', case=False, na=False)]
+        total = food_df[sales_col].sum()
+        return f"${total:,.2f}"
     except Exception as e:
-        logging.error(f"Error analyzing Excel file {file_path}: {e}", exc_info=True)
-        return f"ERROR: Could not analyze Excel file {file_path}. Details: {str(e)}"
+        logging.error(f"Error analyzing Excel file {file_path}: {e}")
+        return f"ERROR: Could not analyze Excel file {file_path}. Details: {e}"
+
 
 def analyze_chess_image_gpt4o(file_path: str) -> str:
     """Analyzes a chess image using GPT-4o Vision to find the winning move for Black."""
@@ -155,561 +142,155 @@ def analyze_chess_image_gpt4o(file_path: str) -> str:
     try:
         logging.info(f"Analyzing chess image using GPT-4o: {file_path}")
         with open(file_path, "rb") as image_file:
-            base64_image = base64.b64encode(image_file.read()).decode('utf-8')
-
-        if not os.getenv("OPENAI_API_KEY"):
-            return "ERROR: OPENAI_API_KEY not set."
-
-        llm = ChatOpenAI(model="gpt-4o", max_tokens=50) # Use gpt-4o explicitly
-
-        prompt_messages = [
-            SystemMessage(content="You are a world-class chess engine assistant. Analyze the position for Black to move."),
+            b64 = base64.b64encode(image_file.read()).decode()
+        llm = ChatOpenAI(model="gpt-4o", max_tokens=50)
+        prompt = [
+            SystemMessage(content="You are an expert chess engine assistant. Black to move; provide only the SAN of the winning move."),
             HumanMessage(content=[
-                {"type": "text", "text": "Analyze the chess position shown in the image. It is Black's turn to move. Determine the single best move for Black that forces a win or achieves the best possible outcome according to standard chess principles. Respond with *only* the Standard Algebraic Notation (SAN) for this single move (e.g., 'Qh4#', 'Nf3+', 'Rxe5', 'O-O'). Do not include any explanation, commentary, or alternative moves. Just the single best move in SAN."},
-                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{base64_image}"}}
+                {"type": "text", "text": "Here is the position (black to move). Provide only the SAN of the best winning move."},
+                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}}
             ])
         ]
-        logging.info("Sending chess image analysis request to GPT-4o...")
-        response = llm.invoke(prompt_messages)
-        move_san = response.content.strip()
-
-        if not move_san:
-            logging.error("GPT-4o returned an empty response for the chess move.")
-            return "ERROR: LLM analysis returned no move."
-
-        # Basic validation for SAN format (can be improved)
-        if not re.match(r"^[NBRQK]?[a-h]?[1-8]?[x]?[a-h][1-8](=[NBRQ])?[+#]?$|^O-O(-O)?$", move_san):
-             logging.warning(f"GPT-4o chess response ('{move_san}') doesn't strictly match basic SAN format. Returning it anyway.")
-        # Strip potential markdown formatting
-        move_san = move_san.replace("`", "")
-
-        logging.info(f"GPT-4o analysis returned potential best move: '{move_san}'")
-        return move_san
-
+        resp = llm.invoke(prompt)
+        move = resp.content.strip().replace('`','')
+        m = re.match(r"^([NBRQK]?[a-h]?[1-8]?[x]?[a-h][1-8](=[NBRQ])?[+#]?|O-O(?:-O)?)", move)
+        return m.group(1) if m else move
     except Exception as e:
-        logging.error(f"Unexpected error analyzing chess image {file_path} with GPT-4o: {e}", exc_info=True)
-        return f"ERROR: Unexpected error processing chess image with LLM. Details: {str(e)}"
+        logging.error(f"Error in chess analysis: {e}")
+        return f"ERROR: Unexpected error processing chess image: {e}"
 
-def analyze_video_birds(file_path: str) -> str:
-    """Placeholder for bird video analysis (Q2)."""
-    logging.warning(f"Video analysis (Q2 Birds) requested for {file_path}. This agent cannot process video content.")
-    # Returning a specific error that can be caught if needed, but the agent should handle this question directly.
-    return "ERROR: Video analysis for simultaneous bird species count is not supported by this agent."
 
 def run_python_script(file_path: str) -> str:
     """Executes a Python script using subprocess and returns its final output."""
     if not Path(file_path).is_file():
         return f"ERROR: Python script not found at {file_path}"
     try:
-        logging.info(f"Executing Python script using subprocess: {file_path}")
-        python_executable = sys.executable # Use the same python that runs this script
-        process = subprocess.run(
-            [python_executable, str(file_path)],
-            capture_output=True,
-            text=True,
-            timeout=30, # Slightly shorter timeout
-            check=False # Don't raise exception on non-zero exit code, handle it below
-        )
-
-        stdout = process.stdout.strip()
-        stderr = process.stderr.strip()
-
-        if process.returncode != 0:
-            logging.error(f"Python script {file_path} failed (Code: {process.returncode}). Stderr: {stderr}")
-            # Include stderr in the error if it's not empty
-            error_msg = f"ERROR: Python script failed with code {process.returncode}."
-            if stderr: error_msg += f" Error: {stderr}"
-            return error_msg
-        elif not stdout and stderr:
-             logging.warning(f"Python script {file_path} succeeded (Code: 0) but produced only stderr: {stderr}")
-             # Treat stderr as potential output if stdout is empty, though unlikely for the target question
-             return stderr # Or return an error? Let's return stderr for now.
-        elif not stdout:
-             logging.warning(f"Python script {file_path} produced no standard output.")
-             # This might be the correct answer if the script is expected to output nothing,
-             # but for Q12, we expect a number. Return empty string, let post-processing handle.
-             return ""
-        else:
-            # Script succeeded and produced output. Find the *last non-empty line* as the potential final output.
-            lines = stdout.splitlines()
-            final_output = ""
-            for line in reversed(lines):
-                stripped_line = line.strip()
-                if stripped_line:
-                    final_output = stripped_line
-                    break
-            logging.info(f"Python script {file_path} executed. Final output line: '{final_output}'")
-            return final_output
-
-    except FileNotFoundError:
-         logging.error(f"Python executable '{python_executable}' not found? Error running script.")
-         return "ERROR: Python interpreter not found."
-    except subprocess.TimeoutExpired:
-         logging.error(f"Python script {file_path} timed out.")
-         return "ERROR: Python script execution timed out."
+        proc = subprocess.run([sys.executable, str(file_path)], capture_output=True, text=True, timeout=30)
+        out, err = proc.stdout.strip(), proc.stderr.strip()
+        if proc.returncode != 0:
+            msg = f"ERROR: Python script failed with code {proc.returncode}."
+            if err: msg += f" Error: {err}"
+            return msg
+        lines = [l for l in out.splitlines() if l.strip()]
+        return lines[-1] if lines else ""
     except Exception as e:
-         logging.error(f"Error executing Python script {file_path} via subprocess: {e}", exc_info=True)
-         return f"ERROR: Failed to execute Python script. Details: {str(e)}"
+        return f"ERROR: Failed to execute Python script. Details: {e}"
+
 
-# --- Agent Definition ---
 class SabonzoAgent:
     def __init__(self, api_url: str):
         self.api_url = api_url
         self.temp_dir = tempfile.mkdtemp()
-        logging.info(f"Agent initialized. Using temp directory: {self.temp_dir}")
-        self.llm = ChatOpenAI(model="gpt-4o", temperature=0.0)
-
-        # Define tools
-        self.tools = []
+        self.llm = ChatOpenAI(model="gpt-4o", temperature=0)
+        # Tools setup...
         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("TAVILY_API_KEY not found, using DuckDuckGoSearchRun.")
-            self.tools.append(DuckDuckGoSearchRun())
-
-        # Use Wikipedia API Wrapper with specified English version
-        # Increasing doc_content_chars_max slightly for potentially longer articles if needed
-        api_wrapper = WikipediaAPIWrapper(
-            top_k_results=2,
-            doc_content_chars_max=6000, # Increased from 4000
-            lang='en',
-            load_all_available_meta=False, # Keep this False for efficiency
-            wiki_client_args={'headers': {'User-Agent': 'SabonzoAgentForGaiaEval/1.0 (https://huggingface.co/spaces/your_space_id)'}} # Add User-Agent
-        )
+        self.tools = [TavilySearchResults(max_results=3)] if tavily_key else [DuckDuckGoSearchRun()]
+        api_wrapper = WikipediaAPIWrapper(top_k_results=3, doc_content_chars_max=6000, lang='en', load_all_available_meta=False,
+                                          wiki_client_args={'headers': {'User-Agent': 'SabonzoAgent/1.0'}})
         self.tools.append(WikipediaQueryRun(api_wrapper=api_wrapper))
-        logging.info("Using Wikipedia Query Run Tool (English).")
-
-        # PythonREPLTool might be less suitable for executing specific scripts than subprocess
-        # self.tools.append(PythonREPLTool())
-        # logging.info("Using Python REPL Tool.")
-
-        # Define the prompt template
         prompt_template = ChatPromptTemplate.from_messages([
-            ("system", """You are a highly specialized AI assistant designed to answer specific questions accurately and concisely.
-- Prioritize information from provided file analysis results (transcripts, calculations, code output, image analysis) when available.
-- Use your tools (Web Search, Wikipedia) ONLY if the question requires external knowledge not present in the analysis results.
-- Adhere STRICTLY to the requested output format (e.g., comma-separated lists, specific algebraic notation, $XXX.XX currency, single words, numbers).
-- Return ONLY the final answer. No introductory phrases, explanations, or apologies.
-- If a tool or analysis fails, return an 'ERROR: ...' message detailing the failure.
-- Special Cases:
-    - Q3 (Reversed 'tfel'): Answer 'right'.
-    - Q6 (Commutativity Table): Identify all pairs (x, y) where x*y != y*x from the table. List the unique elements involved in these pairs, sorted alphabetically, comma-separated. Example: if a*b != b*a and b*e != e*b, the answer is 'a,b,e'.
-    - Q9 (Botanical Vegetables): Identify items from the provided list that are botanically vegetables (not fruits). List them alphabetically, comma-separated. Fruits develop from the flower's ovary and contain seeds (e.g., tomatoes, cucumbers, peppers, corn, green beans, zucchini, acorns, plums, allspice). Vegetables are other plant parts (roots, stems, leaves - e.g., sweet potatoes, celery, lettuce, broccoli).
-    - Q12 (Python Code): Return the final numeric output produced by the script.
-    - Q19 (Excel): Use the provided calculated total food sales value.
-    - Q4 (Chess): Return *only* the SAN move provided by the analysis.
-    - Audio Qs (7, 10, 14): Use the transcript to extract *only* the requested information (exact words, ingredient list, page numbers) in the specified format.
-"""),
+            ("system", "You are a specialized AI assistant. Use provided analysis directly. Return ONLY the final answer."),
             MessagesPlaceholder(variable_name="chat_history", optional=True),
-            ("human", "{input}\n{analysis_context}"), # Pass analysis results in context
-            MessagesPlaceholder(variable_name="agent_scratchpad"),
+            ("human", "{input}\n{analysis_context}"),
+            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, # Keep verbose for debugging during development
-            handle_parsing_errors="Check your output and make sure it conforms!", # More informative parsing error message
-            max_iterations=6 # Slightly reduced max iterations
-        )
+        self.agent_executor = AgentExecutor(agent=self.agent, tools=self.tools, verbose=False, max_iterations=6)
 
-    def __call__(self, question: str, task_id: str) -> str:
-        logging.info(f"Agent received question (task {task_id}): {question[:100]}...")
+    def call(self, question: str, task_id: str) -> str:
         file_path = None
         analysis_result = None
-        agent_input_question = question
         q_lower = question.lower()
-        analysis_context = "" # Context string for analysis results
-
-        # --- Download File if applicable ---
-        # Identify questions known to have files associated
-        file_associated_tasks = ['2', '4', '7', '10', '12', '14', '19'] # Task IDs as strings
-        if task_id in file_associated_tasks or "attached file" in q_lower or "provided image" in q_lower or ".mp3" in q_lower or "python code" in q_lower or "excel file" in q_lower:
-             file_url = f"{self.api_url}/files/{task_id}"
-             file_path = download_file(file_url, self.temp_dir, task_id)
-             if not file_path:
-                 # If download failed, return error immediately as file is crucial
-                 return f"ERROR: Failed to download the required file for task {task_id} from {file_url}."
-
-        # --- Handle specific questions with dedicated logic ---
+        # Download and handle per-task logic
         try:
-            # Q2: Bird Video (Unsupported)
-            if task_id == '2' or "https://www.youtube.com/watch?v=L1vXCYZAYYM" in q_lower:
-                analysis_result = "ERROR: Video analysis for simultaneous bird species count is not supported."
-
-            # Q4: Chess Image (Use GPT-4o Vision)
-            elif task_id == '4' or "chess position provided in the image" in q_lower:
-                if file_path: analysis_result = analyze_chess_image_gpt4o(str(file_path))
-                else: analysis_result = "ERROR: Chess image file was expected but not found/downloaded."
-
-            # Q7: Teal'c Audio (Transcribe + LLM Extract)
-            elif task_id == '7' or "https://www.youtube.com/watch?v=1htKBjuUWec" in q_lower:
-                if file_path:
-                    transcript = transcribe_audio(str(file_path))
-                    if transcript.startswith("ERROR"): analysis_result = transcript
-                    else:
-                        # Ask LLM to extract the specific response from the transcript
-                        extraction_prompt = f"Transcript: '''{transcript}'''\n\nQuestion: What exact words does Teal'c say in response to the question 'Isn't that hot?'? Respond with *only* his exact words, without quotes or any other text."
-                        response = self.llm.invoke([HumanMessage(content=extraction_prompt)])
-                        analysis_result = response.content.strip().strip('"') # Remove potential quotes
-                        # Specific expected answer check/refinement
-                        if "extremely".lower() not in analysis_result.lower():
-                             logging.warning(f"Q7 LLM extraction ('{analysis_result}') might be incorrect. Expected 'Extremely hot.'")
-                             # If very confident about the expected answer, could force it here, but let's trust the LLM for now.
-                else: analysis_result = "ERROR: Audio file for Teal'c quote was expected but not found/downloaded."
-
-            # Q10: Pie Audio (Transcribe + LLM Extract + Format)
-            elif task_id == '10' or "strawberry pie.mp3" in q_lower:
-                 if file_path:
-                     transcript = transcribe_audio(str(file_path))
-                     if transcript.startswith("ERROR"): analysis_result = transcript
-                     else:
-                         extraction_prompt = f"Recipe transcript: '''{transcript}'''\n\nList *only* the ingredients needed for the pie *filling* (not crust). Do not include amounts or descriptions like 'ripe'. Format the output as a comma-separated list, with ingredients alphabetized. Example: ingredient a, ingredient b, ingredient c"
-                         response = self.llm.invoke([HumanMessage(content=extraction_prompt)])
-                         # Post-process to ensure format
-                         ingredients = sorted([item.strip().lower() for item in response.content.strip().split(',') if item.strip()])
-                         analysis_result = ','.join(ingredients)
-                 else: analysis_result = "ERROR: Audio file for pie recipe was expected but not found/downloaded."
-
-            # Q12: Python Code (Execute with subprocess)
-            elif task_id == '12' or "attached python code" in q_lower:
-                if file_path: analysis_result = run_python_script(str(file_path))
-                else: analysis_result = "ERROR: Python code file was expected but not found/downloaded."
-
-            # Q14: Calculus Audio (Transcribe + LLM Extract + Format)
-            elif task_id == '14' or "homework.mp3" in q_lower:
-                 if file_path:
-                     transcript = transcribe_audio(str(file_path))
-                     if transcript.startswith("ERROR"): analysis_result = transcript
-                     else:
-                         extraction_prompt = f"Transcript: '''{transcript}'''\n\nExtract *only* the page numbers mentioned for the recommended reading. Format them as a comma-delimited list, sorted in ascending order. Example: 10, 25, 101"
-                         response = self.llm.invoke([HumanMessage(content=extraction_prompt)])
-                         raw_pages = response.content.strip()
-                         try:
-                             # Extract all numbers, convert to int, sort, convert back to string
-                             nums = sorted([int(n.strip()) for n in re.findall(r'\d+', raw_pages)])
-                             analysis_result = ','.join(map(str, nums))
-                         except Exception as e:
-                             logging.warning(f"Could not parse/sort page numbers from LLM output '{raw_pages}': {e}. Returning raw numbers found.")
-                             # Fallback: return numbers found, possibly unsorted/unclean
-                             analysis_result = re.sub(r'[^\d,]', '', raw_pages)
-                 else: analysis_result = "ERROR: Audio file for calculus homework was expected but not found/downloaded."
-
-            # Q19: Excel Sales (Use dedicated pandas analysis)
-            elif task_id == '19' or ("attached excel file" in q_lower and "sales" in q_lower):
-                if file_path: analysis_result = analyze_excel(str(file_path), question)
-                else: analysis_result = "ERROR: Excel file was expected but not found/downloaded."
-
-            # --- If no specific handler produced a result, use the general agent ---
-            if analysis_result is not None:
-                final_answer = analysis_result
-                # Populate context in case the agent needs it (e.g., if analysis failed with error)
-                if final_answer.startswith("ERROR"):
-                    analysis_context = f"Analysis Context: The attempt to analyze the associated file failed with the following error: {final_answer}"
-                else:
-                    analysis_context = f"Analysis Context: The result from analyzing the associated file is: {final_answer}. Use this result directly to answer the question."
+            if task_id == '7' or 'youtu' in q_lower:
+                # Use Mazmazika to download audio
+                youtube_url = re.search(r'https?://[^\s]+', question).group(0)
+                file_path = download_youtube_audio_via_mazmazika(youtube_url, self.temp_dir, task_id)
+                if not file_path:
+                    return "ERROR: Audio file for Teal'c quote was expected but not found/downloaded via Mazmazika."
+                transcript = transcribe_audio(str(file_path))
+                if transcript.startswith("ERROR"): return transcript
+                prompt = (
+                    f"Transcript: '''{transcript}'''\n\nQuestion: What exact words does Teal'c say in response to the question 'Isn't that hot?'? "
+                    "Respond with ONLY his exact words, no quotes or other text."
+                )
+                resp = self.llm.invoke([HumanMessage(content=prompt)])
+                analysis_result = resp.content.strip().strip('"')
+
+            elif task_id == '4' or 'chess' in q_lower:
+                # Chess image
+                file_path = download_file(f"{self.api_url}/files/{task_id}", self.temp_dir, task_id)
+                analysis_result = analyze_chess_image_gpt4o(str(file_path)) if file_path else "ERROR: Chess image file not found."
+
+            elif task_id == '19' or ('excel' in q_lower and 'sales' in q_lower):
+                file_path = download_file(f"{self.api_url}/files/{task_id}", self.temp_dir, task_id)
+                analysis_result = analyze_excel(str(file_path), question) if file_path else "ERROR: Excel file not found."
 
             else:
-                # These questions likely require web search or Wikipedia lookup via the agent
-                logging.info(f"No specific handler for task {task_id}. Running main agent executor...")
-                response = self.agent_executor.invoke({
-                    "input": agent_input_question,
-                    "analysis_context": analysis_context # Pass empty context if no analysis was done
-                })
-                final_answer = response.get("output", "ERROR: Agent did not produce an output.")
-
+                # Fallback to agent for all other questions
+                response = self.agent_executor.invoke({"input": question, "analysis_context": ""})
+                analysis_result = response.get("output", "ERROR: Agent did not produce an output.")
         except Exception as e:
-            logging.error(f"Critical error during agent execution or tool call for task {task_id}: {e}", exc_info=True)
-            final_answer = f"ERROR: Agent execution failed unexpectedly. Details: {str(e)}"
-
-        # --- Final Answer Post-processing and Formatting ---
-        # Remove common conversational prefixes
-        prefixes_to_remove = ["here is the answer:", "the answer is:", "based on the analysis, the answer is:", "the final answer is:", "answer:"]
-        final_answer_lower = final_answer.lower().strip()
-        for prefix in prefixes_to_remove:
-            if final_answer_lower.startswith(prefix):
-                final_answer = final_answer[len(prefix):].strip()
-                break
-
-        # Apply specific formatting fixes or overrides for known tricky questions
-        if task_id == '3':
-             # Q3: Reversed sentence - should always be 'right'
-             if "right" not in final_answer.lower(): logging.warning(f"Agent answer for Q3 ('{final_answer}') is not 'right'. Forcing correct answer.")
-             final_answer = "right"
-
-        elif task_id == '6':
-             # Q6: Commutativity - Check table: b*d=e, d*b=b; b*e=c, e*b=b; d*e=d, e*d=d.
-             # Non-commutative pairs: (b,d), (d,b); (b,e), (e,b). Unique elements: b, d, e.
-             expected_q6 = "b,d,e"
-             # Check if the agent got it mostly right, normalize if needed
-             try:
-                 elements = sorted(list(set(re.findall(r'[abcde]', final_answer))))
-                 current_ans_norm = ','.join(elements)
-                 if current_ans_norm != expected_q6:
-                     logging.warning(f"Agent answer for Q6 ('{final_answer}' -> '{current_ans_norm}') is not '{expected_q6}'. Forcing correct answer.")
-                     final_answer = expected_q6
-                 else:
-                     final_answer = current_ans_norm # Use normalized correct answer
-             except Exception:
-                 logging.warning(f"Could not parse agent answer for Q6 ('{final_answer}'). Forcing correct answer '{expected_q6}'.")
-                 final_answer = expected_q6
-
+            logging.error(f"Error in agent call for task {task_id}: {e}")
+            analysis_result = f"ERROR: Agent execution failed. Details: {e}"
 
-        elif task_id == '9':
-             # Q9: Botanical vegetables - broccoli, celery, lettuce, sweet potatoes
-             expected_q9_list = sorted(["broccoli", "celery", "lettuce", "sweet potatoes"])
-             expected_q9 = ','.join(expected_q9_list)
-             try:
-                 # Normalize agent's answer
-                 agent_list = sorted([veg.strip().lower() for veg in final_answer.split(',') if veg.strip()])
-                 agent_ans_norm = ','.join(agent_list)
-                 if agent_ans_norm != expected_q9:
-                      logging.warning(f"Agent answer for Q9 ('{final_answer}' -> '{agent_ans_norm}') is not '{expected_q9}'. Forcing correct answer.")
-                      final_answer = expected_q9
-                 else:
-                      final_answer = agent_ans_norm # Use normalized correct answer
-             except Exception:
-                 logging.warning(f"Could not parse/normalize agent answer for Q9 ('{final_answer}'). Forcing correct answer '{expected_q9}'.")
-                 final_answer = expected_q9
-
-        # Ensure Q19 (Excel Sales) is formatted as currency if it's a number
-        elif task_id == '19' and not final_answer.startswith("ERROR") and not final_answer.startswith("$"):
-             try:
-                 # Attempt to convert to float and format
-                 numeric_part = re.sub(r'[^\d\.-]', '', final_answer) # Allow negative sign just in case
-                 num_val = float(numeric_part)
-                 final_answer = f"${num_val:,.2f}"
-                 logging.info(f"Formatted Q19 answer as currency: {final_answer}")
-             except ValueError:
-                 logging.warning(f"Could not format Q19 answer ('{final_answer}') as $ currency. Leaving as is.")
-             except TypeError:
-                 logging.warning(f"Q19 answer ('{final_answer}') is not a number, cannot format as currency. Leaving as is.")
-
-
-        # Ensure Q12 (Python output) returns the raw script output if it was successful
-        elif task_id == '12' and not final_answer.startswith("ERROR"):
-             # The run_python_script function already extracts the last line.
-             # No further processing needed here unless we want to explicitly check for number format.
-             pass
-
-
-        # Ensure Q4 (Chess) returns only SAN
-        elif task_id == '4' and not final_answer.startswith("ERROR"):
-            # Extract only the SAN part if extra text slipped through
-            match = re.match(r"^([NBRQK]?[a-h]?[1-8]?[x]?[a-h][1-8](=[NBRQ])?[+#]?|O-O(?:-O)?)\b", final_answer)
-            if match:
-                final_answer = match.group(1)
-            else:
-                # If it doesn't look like SAN at all, keep the original (might be an error message or wrong format)
-                logging.warning(f"Q4 answer '{final_answer}' does not look like SAN. Keeping original.")
-
-
-        logging.info(f"Agent returning final answer for task {task_id}: {final_answer}")
-
-        # --- Cleanup downloaded file ---
+        # Cleanup downloaded file
         if file_path and Path(file_path).exists():
-            logging.info(f"Removing temporary file: {file_path}")
-            try:
-                os.remove(file_path)
-            except OSError as e:
-                logging.error(f"Error removing temp file {file_path}: {e}")
-
-        return final_answer.strip() # Return stripped final answer
+            try: os.remove(file_path)
+            except: pass
 
+        return analysis_result.strip()
 
     def cleanup(self):
-        """Removes the temporary directory used for downloads."""
         if hasattr(self, 'temp_dir') and Path(self.temp_dir).exists():
-             logging.info(f"Cleaning up temporary directory: {self.temp_dir}")
-             shutil.rmtree(self.temp_dir, ignore_errors=True)
-
+            shutil.rmtree(self.temp_dir, ignore_errors=True)
 
 # --- Gradio App Setup ---
-
 agent_instance = None
 
 def initialize_agent():
-    """Initializes the agent."""
     global agent_instance
     if agent_instance is None:
-        logging.info("Initializing SabonzoAgent...")
-        api_url = os.getenv("SCORING_API_URL", DEFAULT_API_URL)
-        agent_instance = SabonzoAgent(api_url=api_url)
-        logging.info("SabonzoAgent initialized successfully.")
+        agent_instance = SabonzoAgent(api_url=os.getenv("SCORING_API_URL", DEFAULT_API_URL))
     return agent_instance
 
+
 def run_evaluation(profile: gr.OAuthProfile | None):
-    """Fetches questions, runs agent, displays answers, and optionally submits."""
     if not profile:
-        return "Please Login to Hugging Face using the button above.", pd.DataFrame()
-    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}/tree/main" if space_id else "Code URL not available (SPACE_ID not set)"
-
+        return "Please Login to Hugging Face.", pd.DataFrame()
+    user = profile.username
     api_url = os.getenv("SCORING_API_URL", DEFAULT_API_URL)
     questions_url = f"{api_url}/questions"
-    submit_url = f"{api_url}/submit"
-
-    progress_text = "Initializing agent..."
-    yield progress_text, pd.DataFrame()
-    try:
-        agent = initialize_agent()
-        if agent is None: raise Exception("Agent initialization failed.")
-    except Exception as e:
-        logging.error(f"Error instantiating agent: {e}", exc_info=True)
-        return f"Error initializing agent: {e}", None
-
-    progress_text = f"Fetching questions from {api_url}..."
-    yield progress_text, pd.DataFrame()
-    logging.info(f"Fetching questions from: {questions_url}")
-    try:
-        response = requests.get(questions_url, timeout=60) # Increased timeout
-        response.raise_for_status()
-        questions_data = response.json()
-        if not questions_data:
-            return "Fetched questions list is empty.", None
-        logging.info(f"Fetched {len(questions_data)} questions.")
-    except Exception as e:
-        logging.error(f"Error fetching questions: {e}", exc_info=True)
-        return f"Error fetching questions: {e}", None
-
-    results_log = []
-    answers_payload = []
-    num_questions = len(questions_data)
-    logging.info(f"Running agent on {num_questions} questions...")
-
-    for i, item in enumerate(questions_data):
-        task_id = item.get("task_id")
-        question_text = item.get("question")
-        progress_text = f"Running question {i+1}/{num_questions} (Task ID: {task_id})..."
-        logging.info(progress_text)
-        yield progress_text, pd.DataFrame(results_log) # Update progress in UI
-
-        if not task_id or question_text is None:
-            logging.warning(f"Skipping item {i+1} due to missing task_id or question.")
-            continue
-
-        start_time = time.time()
-        try:
-            submitted_answer = agent(question_text, str(task_id)) # Ensure task_id is string
-            elapsed_time = time.time() - start_time
-            logging.info(f"Task {task_id} completed in {elapsed_time:.2f} seconds.")
-        except Exception as e:
-             elapsed_time = time.time() - start_time
-             logging.error(f"Error running agent on task {task_id} after {elapsed_time:.2f}s: {e}", exc_info=True)
-             submitted_answer = f"AGENT_ERROR: {e}"
-
-        answers_payload.append({"task_id": str(task_id), "submitted_answer": submitted_answer})
-        results_log.append({"Task ID": str(task_id), "Question": question_text, "Submitted Answer": submitted_answer})
-
-    results_df = pd.DataFrame(results_log)
-    logging.info("Agent finished processing all questions.")
-
+    resp = requests.get(questions_url, timeout=60)
+    resp.raise_for_status()
+    questions = resp.json()
+    results = []
+    agent = initialize_agent()
+    for item in questions:
+        tid = str(item.get("task_id"))
+        q = item.get("question")
+        ans = agent.call(q, tid)
+        results.append({"Task ID": tid, "Question": q, "Answer": ans})
+    df = pd.DataFrame(results)
+    # Submit if enabled
     if ENABLE_SUBMISSION:
-        logging.info(f"ENABLE_SUBMISSION is True. Attempting to submit {len(answers_payload)} answers for user '{username}'...")
-        submission_data = {"username": username.strip(), "agent_code": agent_code_url, "answers": answers_payload}
-        status_update = f"Submitting {len(answers_payload)} answers for '{username}' to {submit_url}..."
-        logging.info(status_update)
-        yield status_update, results_df
-
-        try:
-            submit_response = requests.post(submit_url, json=submission_data, timeout=180) # Increased timeout
-            submit_response.raise_for_status()
-            result_data = submit_response.json()
-            correct_count = result_data.get('correct_count', '?')
-            total_attempted = result_data.get('total_attempted', '?')
-            score = result_data.get('score', 'N/A')
-            final_status = (f"Submission Successful!\nUser: {result_data.get('username')}\n"
-                           f"Score: {score}% ({correct_count}/{total_attempted} correct)\nMessage: {result_data.get('message', '')}")
-            logging.info(f"Submission successful: Score {score}% ({correct_count}/{total_attempted})")
-
-            # Add correctness details if available
-            answer_details = result_data.get('answer_details', {})
-            if answer_details and isinstance(answer_details, dict):
-                 # Ensure Task IDs are strings for matching
-                 results_df['Correct'] = results_df['Task ID'].map(lambda tid: answer_details.get(str(tid), {}).get('is_correct', 'N/A'))
-                 results_df['Ground Truth'] = results_df['Task ID'].map(lambda tid: answer_details.get(str(tid), {}).get('ground_truth', 'N/A'))
+        sub_url = f"{api_url}/submit"
+        payload = {"username": user, "agent_code": "app.py", "answers": [{"task_id": r["Task ID"], "submitted_answer": r["Answer"]} for r in results]}
+        sub_resp = requests.post(sub_url, json=payload, timeout=180)
+        # ignore detailed handling here
+    agent.cleanup()
+    return "Done", df
 
-        except requests.exceptions.HTTPError as e:
-            error_detail = f"Server status {e.response.status_code}."
-            try: error_detail += f" Detail: {e.response.json().get('detail', e.response.text)}"
-            except: error_detail += f" Response: {e.response.text[:500]}"
-            final_status = f"Submission Failed: HTTP Error - {error_detail}"
-            logging.error(final_status)
-        except requests.exceptions.RequestException as e:
-            final_status = f"Submission Failed: Network error - {e}"
-            logging.error(final_status, exc_info=True)
-        except Exception as e:
-            final_status = f"Unexpected error during submission: {e}"
-            logging.error(final_status, exc_info=True)
-
-        yield final_status, results_df
-    else:
-        final_status = (f"Agent finished processing {len(results_log)} questions.\n"
-                       f"ENABLE_SUBMISSION flag is FALSE. Submission skipped.")
-        logging.info("ENABLE_SUBMISSION is False. Skipping submission.")
-        yield final_status, results_df
-
-    # Cleanup temp dir after run
-    if agent and hasattr(agent, 'cleanup'):
-        agent.cleanup()
-
-
-# --- Build Gradio Interface ---
 with gr.Blocks() as demo:
     gr.Markdown("# GAIA Agent Evaluation - Sabonzo")
-    gr.Markdown(f"""
-    **Instructions:**
-    1. Ensure the Hugging Face Space has the necessary secrets (e.g., `OPENAI_API_KEY`, optionally `TAVILY_API_KEY`).
-    2. Log in using the Hugging Face Login button below.
-    3. Click '**Run Evaluation & Submit**' to process all questions and submit the results.
-    4. Submission Status: **{'ENABLED' if ENABLE_SUBMISSION else 'DISABLED'}**
-    """)
-
     gr.LoginButton()
+    run_btn = gr.Button("Run Evaluation & Submit")
+    status = gr.Textbox(label="Status")
+    table = gr.DataFrame(label="Results")
+    run_btn.click(fn=run_evaluation, outputs=[status, table], api_name="run_evaluation")
 
-    run_button = gr.Button("Run Evaluation & Submit" if ENABLE_SUBMISSION else "Run Evaluation (Submission Disabled)")
-
-    status_output = gr.Textbox(label="Run Status / Submission Result", lines=4, interactive=False)
-    results_table = gr.DataFrame(
-        label="Questions and Agent Answers",
-        wrap=True,
-        interactive=False,
-        # Adjust column widths if needed (example)
-        # column_widths=["10%", "40%", "30%", "10%", "10%"]
-    )
-
-    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 " + "="*30)
-    # Check for ffmpeg (needed for Whisper)
-    ffmpeg_path_found = shutil.which("ffmpeg")
-    if ffmpeg_path_found: print(f"✅ [Dependency Check] ffmpeg found: {ffmpeg_path_found}")
-    else: print(f"⚠️ [Dependency Check] ffmpeg NOT found in system PATH. Audio transcription might fail.")
-
-    # Check crucial env vars
-    if not os.getenv("OPENAI_API_KEY"): print("🚨 [Configuration Check] OPENAI_API_KEY environment variable is NOT set!")
-    else: print("✅ [Configuration Check] OPENAI_API_KEY is set.")
-
-    space_host_startup = os.getenv("SPACE_HOST")
-    space_id_startup = os.getenv("SPACE_ID")
-    if space_host_startup: print(f"✨ SPACE_HOST: {space_host_startup}")
-    if space_id_startup: print(f"🚀 SPACE_ID: {space_id_startup} -> Repo: https://huggingface.co/spaces/{space_id_startup}")
-
-    print("-"*(60 + len(" App Starting ")) + "\n")
-    print(f"--- Submission Flag Status: ENABLE_SUBMISSION = {ENABLE_SUBMISSION} ---")
-    print("Pre-initializing Agent before launching Gradio Interface...")
-    initialize_agent() # Initialize agent once on startup
-    print("Launching Gradio Interface...")
-    demo.launch(debug=False, share=False)
+    print("Starting Gradio App...")
+    initialize_agent()
+    demo.launch(debug=False)