Update app.py

app.py

@@ -1,206 +1,1426 @@
 import os
+import io
+import json
+import re
+import traceback
+import contextlib
+import uuid
+import time
+import ast
+from typing import List, Optional, TypedDict, Annotated, Dict
+from pathlib import Path
+from collections import Counter
 import gradio as gr
-import requests
-import inspect
 import pandas as pd
-from smolagents import CodeAgent, DuckDuckGoSearchTool, OpenAIServerModel
-# (Keep Constants as is)
-# --- Constants ---
+import numpy as np
+import torch
+from pydantic import BaseModel, Field
+
+# Multimodal & Web Tools
+from transformers import pipeline
+from youtube_transcript_api import YouTubeTranscriptApi
+from bs4 import BeautifulSoup
+import requests
+
+# LangChain & LangGraph
+from langgraph.graph.message import add_messages
+from langchain_core.messages import HumanMessage, AIMessage, ToolMessage, SystemMessage, AnyMessage, ToolCall
+from langchain_core.tools import tool
+from langgraph.prebuilt import ToolNode
+from langgraph.graph import START, END, StateGraph
+from langchain_groq import ChatGroq
+
+# RAG
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import FAISS
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_community.tools import DuckDuckGoSearchRun
+from langchain_core.documents import Document
+
+# =============================================================================
+# CONFIGURATION
+# =============================================================================
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+MAX_TURNS = 25
+MAX_MESSAGE_LENGTH = 8000
+REFLECT_EVERY_N_TURNS = 5
 
+# =============================================================================
+# GLOBAL RAG COMPONENTS
+# =============================================================================
+global_embeddings = None
+global_text_splitter = None
 
-# --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-class BasicAgent:
-    def __init__(self):
-        print("BasicAgent initialized.")
-        # Initialize the model
-        #model = HfApiModel()
-        model = OpenAIServerModel(model_id="gpt-4o")
-        # Initialize the search tool
-        search_tool = DuckDuckGoSearchTool()
-        # Initialize Agent
-        self.agent = CodeAgent(
-            model = model,
-            tools=[search_tool]
+def initialize_rag_components():
+    """Initialize RAG components globally."""
+    global global_embeddings, global_text_splitter
+    
+    if global_embeddings is None:
+        print("Initializing RAG embeddings...")
+        try:
+            global_embeddings = HuggingFaceEmbeddings(
+                model_name="sentence-transformers/all-MiniLM-L6-v2",
+                model_kwargs={'device': 'cpu'}
+            )
+            print("✅ Embeddings initialized.")
+        except Exception as e:
+            print(f"⚠️ Failed to initialize embeddings: {e}")
+            return False
+    
+    if global_text_splitter is None:
+        print("Initializing text splitter...")
+        global_text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=1000,
+            chunk_overlap=200,
+            length_function=len,
+            separators=["\n\n", "\n", ". ", " ", ""]
         )
-    def __call__(self, question: str) -> str:
-        print(f"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer =self.agent.run(question)
-        print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_answer
+        print("✅ Text splitter initialized.")
+    
+    return True
 
-def run_and_submit_all( profile: gr.OAuthProfile | None):
+# =============================================================================
+# ASR INITIALIZATION
+# =============================================================================
+asr_pipeline = None
+try:
+    print("Loading ASR (Whisper) pipeline globally...")
+    device = 0 if torch.cuda.is_available() else -1
+    device_name = "cuda:0" if device == 0 else "cpu"
+    print(f"Attempting to use device: {device_name} for ASR.")
+    asr_pipeline = pipeline(
+        "automatic-speech-recognition",
+        model="openai/whisper-base",
+        torch_dtype=torch.float16 if device == 0 else torch.float32,
+        device=device
+    )
+    print("✅ ASR (Whisper) pipeline loaded successfully.")
+except Exception as e:
+    print(f"⚠️ Warning: Could not load ASR pipeline globally. Error: {e}")
+    asr_pipeline = None
+
+# =============================================================================
+# UTILITY FUNCTIONS
+# =============================================================================
+def remove_fences_simple(text):
+    """Remove code fences from text."""
+    original_text = text
+    text = text.strip()
+    if text.startswith("```") and text.endswith("```"):
+        text = text[3:-3].strip()
+        if '\n' in text:
+            first_line, rest = text.split('\n', 1)
+            if first_line.strip().replace('_','').isalnum() and len(first_line.strip()) < 15:
+                text = rest.strip()
+        return text
+    return original_text
+
+def truncate_if_needed(content: str, max_length: int = MAX_MESSAGE_LENGTH) -> str:
+    """Truncate content if it exceeds max length."""
+    if len(content) > max_length:
+        return content[:max_length] + f"\n...[truncated, {len(content)} total chars]"
+    return content
+
+def find_file(path: str) -> Optional[Path]:
+    """Find a file by trying multiple path variations."""
+    script_dir = Path.cwd()
+    safe_path = Path(path).as_posix()
+    
+    paths_to_try = [
+        script_dir / safe_path,
+        Path(safe_path),
+        script_dir / Path(path).name
+    ]
+    
+    for attempt_path in paths_to_try:
+        if attempt_path.exists():
+            return attempt_path
+    
+    return None
+
+# =============================================================================
+# PLANNING & REFLECTION TOOLS
+# =============================================================================
+
+class ThinkInput(BaseModel):
+    reasoning: str = Field(description="Brief reasoning summary (under 150 chars)")
+
+@tool(args_schema=ThinkInput)
+def think_through_logic(reasoning: str) -> str:
     """
-    Fetches all questions, runs the BasicAgent on them, submits all answers,
-    and displays the results.
+    Use this to work through logic puzzles, riddles, or reasoning problems.
+    
+    Call this when:
+    - The question is a riddle or brain teaser
+    - You need to reason through a logical problem
+    - No external information is needed, just thinking
+    
+    After thinking, use calculator if math is involved, then validate and submit answer.
     """
-    # --- Determine HF Space Runtime URL and Repo URL ---
-    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
+    print(f"🧠 Thinking: {reasoning[:100]}...")
+    
+    return f"""✅ Logic reasoning recorded.
+
+Next steps:
+1. If math needed → use calculator()
+2. Once you have answer → use validate_answer()
+3. Then → use final_answer_tool()
+
+Remember: You MUST call another tool. Do not output reasoning text."""
+
+
+class PlanInput(BaseModel):
+    task_summary: str = Field(description="Very brief task summary (under 80 chars)")
+
+@tool(args_schema=PlanInput)
+def create_plan(task_summary: str) -> str:
+    """
+    Creates a plan for multi-step questions. Use for complex tasks only.
+    Keep the summary VERY brief to avoid errors.
+    """
+    print(f"📋 Planning: {task_summary[:80]}...")
+    
+    return f"""✅ Plan created for: {task_summary}
+
+FRAMEWORK:
+1. What info do I need?
+2. What tools will I use?
+3. In what order?
+
+Now execute step 1. You MUST call a tool next."""
+
+
+class ReflectInput(BaseModel):
+    situation: str = Field(description="Brief situation summary (under 80 chars)")
+
+@tool(args_schema=ReflectInput)
+def reflect_on_progress(situation: str) -> str:
+    """
+    Reflects on progress when stuck. Use after 5+ turns without progress.
+    Keep situation summary VERY brief.
+    """
+    print(f"🤔 Reflecting: {situation[:80]}...")
+    
+    return f"""🔍 REFLECTION on: {situation}
+
+QUESTIONS:
+1. Am I using the right approach?
+2. Should I try a different tool?
+3. Do I actually have the answer already?
+
+Take a DIFFERENT approach now. You MUST call a tool next."""
+
+
+class ValidateInput(BaseModel):
+    proposed_answer: str = Field(description="The answer to validate")
+    original_question: str = Field(description="Original question (first 100 chars)")
+
+@tool(args_schema=ValidateInput)
+def validate_answer(proposed_answer: str, original_question: str) -> str:
+    """
+    Validates answer format before submission. ALWAYS use before final_answer_tool.
+    """
+    print(f"✓ Validating: '{proposed_answer[:50]}...'")
+    
+    issues = []
+    warnings = []
+    
+    # Check for conversational fluff
+    fluff = ["the answer is", "based on", "according to", "i found", "here is"]
+    if any(p in proposed_answer.lower() for p in fluff):
+        issues.append("❌ Remove conversational text. Answer only.")
+    
+    # Check for code fences
+    if "```" in proposed_answer:
+        issues.append("❌ Remove code fences (```).")
+    
+    # Check length
+    if len(proposed_answer) > 500:
+        warnings.append("⚠️ Answer very long. Just the answer?")
+    
+    # Check for number questions
+    if any(k in original_question.lower() for k in ["how many", "what number", "count"]):
+        if not any(c.isdigit() for c in proposed_answer):
+            warnings.append("⚠️ Question asks for number but answer has no digits.")
+    
+    if issues:
+        return "🚫 VALIDATION FAILED:\n" + "\n".join(issues) + "\n\nFix then retry."
+    
+    if warnings:
+        return "⚠️ WARNINGS:\n" + "\n".join(warnings) + "\n\nConsider fixing, or proceed if confident."
+    
+    return "✅ VALIDATION PASSED! Now call final_answer_tool() with this answer."
 
-    if profile:
-        username= f"{profile.username}"
-        print(f"User logged in: {username}")
-    else:
-        print("User not logged in.")
-        return "Please Login to Hugging Face with the button.", None
 
-    api_url = DEFAULT_API_URL
-    questions_url = f"{api_url}/questions"
-    submit_url = f"{api_url}/submit"
+# =============================================================================
+# CORE TOOLS
+# =============================================================================
 
-    # 1. Instantiate Agent ( modify this part to create your agent)
+class SearchInput(BaseModel):
+    query: str = Field(description="Search query (concise)")
+
+@tool(args_schema=SearchInput)
+def search_tool(query: str) -> str:
+    """Searches web via DuckDuckGo. Use for facts, recent info."""
+    if not isinstance(query, str) or not query.strip():
+        return "Error: Invalid query."
+    
+    print(f"🔍 Searching: {query}")
     try:
-        agent = BasicAgent()
+        search = DuckDuckGoSearchRun()
+        result = search.run(query)
+        return truncate_if_needed(result)
     except Exception as e:
-        print(f"Error instantiating agent: {e}")
-        return f"Error initializing agent: {e}", None
-    # In the case of an app running as a hugging Face space, this link points toward your codebase ( usefull for others so please keep it public)
-    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
-    print(agent_code)
-
-    # 2. Fetch Questions
-    print(f"Fetching questions from: {questions_url}")
+        return f"Search error: {str(e)}"
+
+
+class CalcInput(BaseModel):
+    expression: str = Field(description="Math expression (e.g., '2+2', 'sqrt(16)')")
+
+@tool(args_schema=CalcInput)
+def calculator(expression: str) -> str:
+    """
+    Evaluates math expressions. Use for ANY calculations.
+    Supports: +, -, *, /, **, sqrt, sin, cos, log, pi, e, etc.
+    """
+    if not isinstance(expression, str) or not expression.strip():
+        return "Error: Invalid expression."
+    
+    print(f"🧮 Calculating: {expression}")
+    
     try:
-        response = requests.get(questions_url, timeout=15)
-        response.raise_for_status()
-        questions_data = response.json()
-        if not questions_data:
-             print("Fetched questions list is empty.")
-             return "Fetched questions list is empty or invalid format.", None
-        print(f"Fetched {len(questions_data)} questions.")
-    except requests.exceptions.RequestException as e:
-        print(f"Error fetching questions: {e}")
-        return f"Error fetching questions: {e}", None
-    except requests.exceptions.JSONDecodeError as e:
-         print(f"Error decoding JSON response from questions endpoint: {e}")
-         print(f"Response text: {response.text[:500]}")
-         return f"Error decoding server response for questions: {e}", None
+        import math
+        safe_dict = {
+            'sqrt': math.sqrt, 'sin': math.sin, 'cos': math.cos, 'tan': math.tan,
+            'log': math.log, 'log10': math.log10, 'exp': math.exp,
+            'pi': math.pi, 'e': math.e, 'abs': abs, 'round': round,
+            'pow': pow, 'sum': sum, 'min': min, 'max': max
+        }
+        
+        result = eval(expression, {"__builtins__": {}}, safe_dict)
+        return str(result)
     except Exception as e:
-        print(f"An unexpected error occurred fetching questions: {e}")
-        return f"An unexpected error occurred fetching questions: {e}", None
-
-    # 3. Run your Agent
-    results_log = []
-    answers_payload = []
-    print(f"Running agent on {len(questions_data)} questions...")
-    for item in questions_data:
-        task_id = item.get("task_id")
-        question_text = item.get("question")
-        if not task_id or question_text is None:
-            print(f"Skipping item with missing task_id or question: {item}")
-            continue
-        try:
-            submitted_answer = agent(question_text)
-            answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
-            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
-        except Exception as e:
-             print(f"Error running agent on task {task_id}: {e}")
-             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
+        return f"Calculation error for '{expression}': {str(e)}"
+
+
+class CodeInput(BaseModel):
+    code: str = Field(description="Python code (MUST include print() for output)")
+
+@tool(args_schema=CodeInput)
+def code_interpreter(code: str) -> str:
+    """
+    Executes Python code. Use for data processing, complex logic.
+    Available: pandas, numpy, json, re, datetime
+    CRITICAL: Always use print() to output results!
+    """
+    if not isinstance(code, str):
+        return "Error: code must be string."
+    
+    # Safety checks
+    dangerous = ['__import__', 'eval(', 'compile(', 'subprocess', 'os.system', 'exec(']
+    if any(d in code.lower() for d in dangerous):
+        return f"Error: Dangerous operation not allowed."
+    
+    if 'open(' in code.lower() and any(m in code for m in ["'w'", '"w"', "'a'", '"a"']):
+        return "Error: File writing not allowed. Use write_file tool."
+    
+    print(f"💻 Executing code ({len(code)} chars)...")
+    output_stream = io.StringIO()
+    error_stream = io.StringIO()
+    
+    try:
+        with contextlib.redirect_stdout(output_stream), contextlib.redirect_stderr(error_stream):
+            safe_globals = {
+                "pd": pd,
+                "np": np,
+                "json": json,
+                "re": re,
+                "__builtins__": __builtins__
+            }
+            exec(code, safe_globals, {})
+            
+        stdout = output_stream.getvalue()
+        stderr = error_stream.getvalue()
+        
+        if stderr:
+            return f"Error:\n{stderr}\n\nStdout:\n{stdout}"
+        
+        if stdout:
+            return truncate_if_needed(stdout)
+        
+        return "Code executed but no output. Remember to use print()!"
+        
+    except Exception as e:
+        return f"Execution failed:\n{traceback.format_exc()}"
+
+
+class ReadFileInput(BaseModel):
+    path: str = Field(description="File path")
+
+@tool(args_schema=ReadFileInput)
+def read_file(path: str) -> str:
+    """Reads file content."""
+    if not isinstance(path, str) or not path.strip():
+        return "Error: Invalid path."
+    
+    print(f"📄 Reading: {path}")
+    
+    file_path = find_file(path)
+    if not file_path:
+        return f"Error: File not found: '{path}'\nCWD files: {os.listdir('.')}"
+    
+    try:
+        content = file_path.read_text(encoding='utf-8')
+        return truncate_if_needed(content)
+    except UnicodeDecodeError:
+        return f"Error: Binary file. Size: {file_path.stat().st_size} bytes. Try audio_transcription_tool for audio."
+    except Exception as e:
+        return f"Read error: {str(e)}"
+
+
+class WriteFileInput(BaseModel):
+    path: str = Field(description="File path")
+    content: str = Field(description="Content to write")
+
+@tool(args_schema=WriteFileInput)
+def write_file(path: str, content: str) -> str:
+    """Writes content to file."""
+    if not path or not isinstance(content, str):
+        return "Error: Invalid inputs."
+    
+    print(f"✍️ Writing: {path}")
+    
+    try:
+        file_path = Path.cwd() / path
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+        file_path.write_text(content, encoding='utf-8')
+        return f"Wrote {len(content)} chars to '{path}'."
+    except Exception as e:
+        return f"Write error: {str(e)}"
+
+
+class ListDirInput(BaseModel):
+    path: str = Field(description="Directory path", default=".")
+
+@tool(args_schema=ListDirInput)
+def list_directory(path: str = ".") -> str:
+    """Lists directory contents."""
+    print(f"📁 Listing: {path}")
+    
+    try:
+        dir_path = Path.cwd() / path if path != "." else Path.cwd()
+        
+        if not dir_path.is_dir():
+            return f"Error: '{path}' not a directory."
+        
+        items = sorted(dir_path.iterdir())
+        
+        if not items:
+            return f"Directory '{path}' is empty."
+        
+        files, dirs = [], []
+        
+        for item in items:
+            if item.is_dir():
+                dirs.append(f"📁 {item.name}/")
+            else:
+                files.append(f"📄 {item.name} ({item.stat().st_size} bytes)")
+        
+        result = f"Contents of '{path}':\n\n"
+        if dirs:
+            result += "Directories:\n" + "\n".join(dirs) + "\n\n"
+        if files:
+            result += "Files:\n" + "\n".join(files)
+        
+        return result
+    except Exception as e:
+        return f"List error: {str(e)}"
+
+
+class AudioInput(BaseModel):
+    file_path: str = Field(description="Audio file path")
+
+@tool(args_schema=AudioInput)
+def audio_transcription_tool(file_path: str) -> str:
+    """Transcribes audio using Whisper."""
+    if not file_path:
+        return "Error: Invalid file path."
+    
+    print(f"🎤 Transcribing: {file_path}")
+    
+    if asr_pipeline is None:
+        return "Error: ASR not available."
+    
+    audio_path = find_file(file_path)
+    if not audio_path:
+        return f"Error: Audio file not found: '{file_path}'"
+    
+    try:
+        transcription = asr_pipeline(str(audio_path))
+        result_text = transcription.get("text", "")
+        
+        if not result_text:
+            return "Error: Transcription empty."
+        
+        return f"Transcription:\n{truncate_if_needed(result_text)}"
+    except Exception as e:
+        return f"Transcription error: {str(e)}"
+
+
+class YoutubeInput(BaseModel):
+    video_url: str = Field(description="YouTube URL")
+
+@tool(args_schema=YoutubeInput)
+def get_youtube_transcript(video_url: str) -> str:
+    """Fetches YouTube video transcript."""
+    if not video_url:
+        return "Error: Invalid URL."
+    
+    print(f"📺 YouTube transcript: {video_url}")
+    
+    try:
+        video_id = None
+        if "watch?v=" in video_url:
+            video_id = video_url.split("v=")[1].split("&")[0]
+        elif "youtu.be/" in video_url:
+            video_id = video_url.split("youtu.be/")[1].split("?")[0]
+        
+        if not video_id:
+            return f"Error: Could not extract video ID."
+            
+        transcript_list = YouTubeTranscriptApi.get_transcript(video_id)
+        
+        if not transcript_list:
+            return "Error: No transcript found."
+            
+        full_transcript = " ".join([item["text"] for item in transcript_list])
+        return f"Transcript:\n{truncate_if_needed(full_transcript)}"
+    except Exception as e:
+        return f"Transcript error: {str(e)}"
+
 
-    if not answers_payload:
-        print("Agent did not produce any answers to submit.")
-        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+class ScrapeInput(BaseModel):
+    url: str = Field(description="URL (must start with http:// or https://)")
+    query: str = Field(description="What to find on the page")
 
-    # 4. Prepare Submission 
-    submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
-    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
-    print(status_update)
+@tool(args_schema=ScrapeInput)
+def scrape_and_retrieve(url: str, query: str) -> str:
+    """
+    Scrapes webpage and uses RAG to find relevant info.
+    Use when you need specific info from a known URL.
+    """
+    if not url.startswith(('http://', 'https://')):
+        return f"Error: Invalid URL format."
+    if not query:
+        return "Error: Query required."
+    
+    if global_embeddings is None or global_text_splitter is None:
+        if not initialize_rag_components():
+            return "Error: RAG not initialized."
 
-    # 5. Submit
-    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
+    print(f"🌐 Scraping: {url}")
+    
     try:
-        response = requests.post(submit_url, json=submission_data, timeout=60)
+        headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'}
+        response = requests.get(url, headers=headers, timeout=20)
         response.raise_for_status()
-        result_data = response.json()
-        final_status = (
-            f"Submission Successful!\n"
-            f"User: {result_data.get('username')}\n"
-            f"Overall Score: {result_data.get('score', 'N/A')}% "
-            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
-            f"Message: {result_data.get('message', 'No message received.')}"
-        )
-        print("Submission successful.")
-        results_df = pd.DataFrame(results_log)
-        return final_status, results_df
-    except requests.exceptions.HTTPError as e:
-        error_detail = f"Server responded with status {e.response.status_code}."
-        try:
-            error_json = e.response.json()
-            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
-        except requests.exceptions.JSONDecodeError:
-            error_detail += f" Response: {e.response.text[:500]}"
-        status_message = f"Submission Failed: {error_detail}"
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
-    except requests.exceptions.Timeout:
-        status_message = "Submission Failed: The request timed out."
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
-    except requests.exceptions.RequestException as e:
-        status_message = f"Submission Failed: Network error - {e}"
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
+        
+        soup = BeautifulSoup(response.text, 'html.parser')
+        
+        for tag in soup(["script", "style", "nav", "footer", "aside", "header", "iframe"]):
+            tag.extract()
+        
+        main = soup.find('main') or soup.find('article') or soup.body
+        
+        if not main:
+            return "Error: No main content found."
+        
+        text = main.get_text(separator='\n', strip=True)
+        lines = [l.strip() for l in text.splitlines() if l.strip()]
+        text = '\n'.join(lines)
+        
+        if len(text) < 50:
+            return f"Error: Content too short ({len(text)} chars)."
+        
+        chunks = global_text_splitter.split_text(text)
+        
+        if not chunks:
+            return "Error: Could not chunk text."
+        
+        docs = [Document(page_content=c, metadata={"source": url}) for c in chunks]
+        
+        db = FAISS.from_documents(docs, global_embeddings)
+        retriever = db.as_retriever(search_kwargs={"k": 5})
+        retrieved = retriever.invoke(query)
+        
+        if not retrieved:
+            return f"No relevant info found for: '{query}'"
+        
+        context = "\n\n---\n\n".join([f"[Chunk {i+1}]\n{d.page_content}" for i, d in enumerate(retrieved)])
+        
+        return truncate_if_needed(f"From {url}:\n\n{context}")
+
+    except requests.RequestException as e:
+        return f"Fetch error: {str(e)}"
     except Exception as e:
-        status_message = f"An unexpected error occurred during submission: {e}"
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
+        return f"Scrape error: {str(e)}\n{traceback.format_exc()}"
 
 
-# --- Build Gradio Interface using Blocks ---
-with gr.Blocks() as demo:
-    gr.Markdown("# Basic Agent Evaluation Runner")
-    gr.Markdown(
-        """
-        **Instructions:**
-        1.  Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ...
-        2.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
-        3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
-        ---
-        **Disclaimers:**
-        Once clicking on the "submit button, it can take quite some time ( this is the time for the agent to go through all the questions).
-        This space provides a basic setup and is intentionally sub-optimal to encourage you to develop your own, more robust solution. For instance for the delay process of the submit button, a solution could be to cache the answers and submit in a seperate action or even to answer the questions in async.
-        Please note that this version requires an OpenAI Key to run.
-        """
-    )
+class FinalAnswerInput(BaseModel):
+    answer: str = Field(description="Final answer - EXACTLY what was asked, nothing more")
 
-    gr.LoginButton()
+@tool(args_schema=FinalAnswerInput)
+def final_answer_tool(answer: str) -> str:
+    """
+    Submit final answer. CRITICAL RULES:
+    1. ALWAYS call validate_answer() first
+    2. Answer must be EXACTLY what was asked
+    3. NO conversational text
+    4. NO explanations
+    5. Match requested format exactly
+    """
+    if not isinstance(answer, str):
+        answer = str(answer)
+    
+    print(f"✅ FINAL ANSWER SUBMITTED: {answer}")
+    return answer
 
-    run_button = gr.Button("Run Evaluation & Submit All Answers")
 
-    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
-    # Removed max_rows=10 from DataFrame constructor
-    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
+# =============================================================================
+# DEFINED TOOLS LIST
+# =============================================================================
+defined_tools = [
+    # Planning & Reflection
+    think_through_logic,
+    create_plan,
+    reflect_on_progress,
+    validate_answer,
+    
+    # Core tools
+    search_tool,
+    calculator,
+    code_interpreter,
+    
+    # File operations
+    read_file,
+    write_file,
+    list_directory,
+    
+    # Specialized
+    audio_transcription_tool,
+    get_youtube_transcript,
+    scrape_and_retrieve,
+    
+    # Final
+    final_answer_tool
+]
 
-    run_button.click(
-        fn=run_and_submit_all,
-        outputs=[status_output, results_table]
-    )
 
-if __name__ == "__main__":
-    print("\n" + "-"*30 + " App Starting " + "-"*30)
-    # Check for SPACE_HOST and SPACE_ID at startup for information
-    space_host_startup = os.getenv("SPACE_HOST")
-    space_id_startup = os.getenv("SPACE_ID") # Get SPACE_ID at startup
+# =============================================================================
+# AGENT STATE
+# =============================================================================
+class AgentState(TypedDict):
+    messages: Annotated[List[AnyMessage], add_messages]
+    turn: int
+    has_plan: bool
+    consecutive_errors: int
+    tool_history: List[str]
+    last_tool_was_thinking: bool
 
-    if space_host_startup:
-        print(f"✅ SPACE_HOST found: {space_host_startup}")
-        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
-    else:
-        print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
 
-    if space_id_startup: # Print repo URLs if SPACE_ID is found
-        print(f"✅ SPACE_ID found: {space_id_startup}")
-        print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
-        print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
+# =============================================================================
+# ENHANCED FALLBACK PARSER
+# =============================================================================
+def parse_tool_call_from_string(content: str, tools: List) -> List[ToolCall]:
+    """Enhanced parser with multiple strategies."""
+    print(f"🔧 Fallback parsing (first 300 chars):\n{content[:300]}")
+    
+    tool_name = None
+    tool_input = None
+    
+    # STRATEGY 1: Groq's <function=name{...}> format
+    groq_match = re.search(r"<function=(\w+)\s*(\{.*?\})\s*(?:>|</function>)", content, re.DOTALL)
+    if groq_match:
+        try:
+            tool_name = groq_match.group(1).strip()
+            json_str = groq_match.group(2).strip()
+            json_str = json_str.encode().decode('unicode_escape')
+            tool_input = json.loads(json_str)
+            print(f"✓ Parsed Groq format: {tool_name}")
+        except:
+            tool_name = None
+    
+    # STRATEGY 2: Standard <function(name)>{...} format
+    if not tool_name:
+        func_match = re.search(r"<function[(=]\s*([^)]+)\s*[)>](.*)", content, re.DOTALL | re.IGNORECASE)
+        if func_match:
+            try:
+                tool_name = func_match.group(1).strip().replace("'", "").replace('"', '')
+                remaining = func_match.group(2)
+                json_start = remaining.find('{')
+                if json_start != -1:
+                    json_str = remaining[json_start:].strip().rstrip(',')
+                    tool_input = json.loads(json_str)
+                    print(f"✓ Parsed standard format: {tool_name}")
+            except:
+                tool_name = None
+    
+    # STRATEGY 3: Tool mention with code block → wrap in code_interpreter
+    if not tool_name and "```python" in content:
+        try:
+            code_match = re.search(r"```python\n(.*?)```", content, re.DOTALL)
+            if code_match:
+                code = code_match.group(1).strip()
+                tool_name = "code_interpreter"
+                tool_input = {"code": code}
+                print(f"✓ Extracted Python code → code_interpreter")
+        except:
+            pass
+    
+    # STRATEGY 4: Direct tool mention → create minimal valid call
+    if not tool_name:
+        for tool in tools:
+            if tool.name.lower() in content.lower():
+                tool_name = tool.name
+                tool_input = {}
+                
+                # Try to extract arguments from content
+                if tool.args_schema:
+                    schema = tool.args_schema.model_json_schema()
+                    for prop in schema.get('properties', {}).keys():
+                        if prop in schema.get('required', []):
+                            # Use placeholder
+                            tool_input[prop] = "auto_extracted"
+                
+                print(f"✓ Found mention of '{tool_name}' → creating default call")
+                break
+    
+    # STRATEGY 5: Emergency - if no tool detected, force a reasonable one
+    if not tool_name:
+        # If content looks like reasoning, use think_through_logic
+        if len(content) > 50 and not any(kw in content.lower() for kw in ["error", "failed", "invalid"]):
+            tool_name = "think_through_logic"
+            tool_input = {"reasoning": content[:150]}
+            print(f"⚠️ No tool detected → forcing think_through_logic")
+    
+    # Validate and create tool call
+    if tool_name and tool_input is not None:
+        matching_tools = [t for t in tools if t.name == tool_name]
+        if matching_tools:
+            return [ToolCall(name=tool_name, args=tool_input, id=str(uuid.uuid4()))]
+        else:
+            print(f"❌ Tool '{tool_name}' not in available tools")
+    
+    print("❌ All parsing strategies failed")
+    return []
+
+
+# =============================================================================
+# CONDITIONAL EDGE FUNCTION (FIXED)
+# =============================================================================
+def should_continue(state: AgentState):
+    """Decide next step with robust logic."""
+    messages = state.get('messages', [])
+    if not messages:
+        return "agent"
+    
+    last_message = messages[-1]
+    current_turn = state.get('turn', 0)
+    
+    # Debug: Print what we're checking
+    msg_type = type(last_message).__name__
+    print(f"📍 Conditional check - Turn {current_turn}, Last msg type: {msg_type}")
+    
+    # 1. Check turn limit
+    if current_turn >= MAX_TURNS:
+        print(f"🛑 Max turns ({MAX_TURNS}) reached")
+        return END
+    
+    # 2. If last message is ToolMessage, agent needs to process it
+    if isinstance(last_message, ToolMessage):
+        print(f"📨 Tool result received from '{last_message.name}' → back to agent")
+        return "agent"
+    
+    # 3. If last message is AIMessage with tool calls
+    if isinstance(last_message, AIMessage) and last_message.tool_calls:
+        # Only check the FIRST tool call, not all of them
+        first_tool = last_message.tool_calls[0]
+        tool_name = first_tool.get("name", "")
+        
+        if tool_name == "final_answer_tool":
+            return END
+        else:
+            return "tools"
+    
+    # 4. If AIMessage but no tool calls (reasoning text)
+    if isinstance(last_message, AIMessage) and not last_message.tool_calls:
+        # Check for consecutive AI messages (loop)
+        if len(messages) >= 2 and isinstance(messages[-2], AIMessage) and not messages[-2].tool_calls:
+            print(f"⚠️ Loop detected: 2 consecutive AI messages without tools")
+            return END
+        
+        print(f"💭 AI message without tool call → continuing to agent (will force tool)")
+        return "agent"
+    
+    # 5. Default: continue to agent
+    print(f"🔄 Default → continuing to agent")
+    return "agent"
+
+
+# =============================================================================
+# ENHANCED AGENT CLASS
+# =============================================================================
+class PlanningReflectionAgent:
+    def __init__(self):
+        print("🧠 PlanningReflectionAgent initializing...")
+        
+        GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+        if not GROQ_API_KEY:
+            raise ValueError("GROQ_API_KEY not set!")
+        HUGGINGFACEHUB_API_TOKEN = os.getenv("HUGGINGFACEHUB_API_TOKEN")
+        if not HUGGINGFACEHUB_API_TOKEN:
+            raise ValueError("HUGGINGFACEHUB_API_TOKEN secret is not set! Please add it to your Space secrets.")
+
+        self.tools = defined_tools
+        
+        # Initialize RAG
+        if not initialize_rag_components():
+            print("⚠️ RAG components failed to initialize.")
+        
+        # Build tool descriptions
+        tool_desc_list = []
+        for tool in self.tools:
+            if tool.args_schema:
+                schema = tool.args_schema.model_json_schema()
+                args_desc = [f"  - {p}: {d.get('description', '')}" 
+                            for p, d in schema.get('properties', {}).items()]
+                desc = f"- {tool.name}:\n  {tool.description}\n" + "\n".join(args_desc)
+            else:
+                desc = f"- {tool.name}: {tool.description}"
+            tool_desc_list.append(desc)
+        tool_descriptions = "\n".join(tool_desc_list)
+
+        # ULTRA-AGGRESSIVE SYSTEM PROMPT
+        self.system_prompt = f"""You are an elite AI agent for GAIA benchmark. Your ONLY job: provide the EXACT answer requested.
+
+═══════════════════════════════════════════════════════════════
+⚠️ ABSOLUTE RULES - VIOLATE THESE AND YOU FAIL:
+═══════════════════════════════════════════════════════════════
+
+1. **EVERY TURN MUST CALL EXACTLY ONE TOOL** - No exceptions
+2. **NEVER OUTPUT REASONING TEXT WITHOUT A TOOL CALL** - You will fail
+3. **IDENTIFY QUESTION TYPE FIRST** - Logic? Factual? Data? Math?
+4. **LOGIC PUZZLES**: think_through_logic → calculator (if needed) → validate → final_answer
+5. **FACTUAL QUESTIONS**: search_tool → validate → final_answer
+6. **DATA QUESTIONS**: read_file → code_interpreter → validate → final_answer
+7. **ALWAYS VALIDATE**: Call validate_answer() before final_answer_tool()
+8. **FINAL ANSWER FORMAT**: EXACTLY what was asked. NO "The answer is..." or explanations
+
+═══════════════════════════════════════════════════════════════
+📋 QUESTION TYPE GUIDE:
+═══════════════════════════════════════════════════════════════
+
+**RIDDLES/LOGIC PUZZLES** (No web search needed):
+- Brain teasers, puzzles, logical deduction
+- Strategy: think_through_logic → calculator (if math) → validate → final_answer
+- Example: "If 200 coins, 30 face-down, divide into equal piles..."
+  Turn 1: think_through_logic("Adventurer takes 30 coins and flips them")
+  Turn 2: calculator("30") [if needed]
+  Turn 3: validate_answer("30", question)
+  Turn 4: final_answer_tool("30")
+
+**FACTUAL/RESEARCH** (Need web):
+- Who, what, when, where questions
+- Strategy: search_tool → scrape_and_retrieve → validate → final_answer
+- Example: "What was Einstein's birthplace population in 1900?"
+  Turn 1: search_tool("Albert Einstein birthplace")
+  Turn 2: search_tool("Ulm Germany population 1900")
+  Turn 3: validate_answer("50000", question)
+  Turn 4: final_answer_tool("50000")
+
+**DATA ANALYSIS** (Need files):
+- CSV/Excel questions
+- Strategy: list_directory → read_file → code_interpreter → validate → final_answer
+
+**SIMPLE MATH**:
+- Calculations
+- Strategy: calculator() → validate_answer() → final_answer_tool()
+
+═══════════════════════════════════════════════════════════════
+🎓 CRITICAL EXAMPLES:
+═══════════════════════════════════════════════════════════════
+
+Example 1: Logic Puzzle
+Q: "Coin riddle with 200 coins, 30 face-down..."
+✅ CORRECT:
+  Turn 1: think_through_logic("Take 30 coins, flip all")
+  Turn 2: validate_answer("30", "coin riddle...")
+  Turn 3: final_answer_tool("30")
+
+❌ WRONG:
+  Turn 1: [reasoning text without tool] ← FAILS!
+
+Example 2: Letter Bank Puzzle
+Q: "Use letters to spell sentences, which letters need changing?"
+✅ CORRECT:
+  Turn 1: code_interpreter("code to count letters...")
+  Turn 2: validate_answer("A, B, C", question)
+  Turn 3: final_answer_tool("A, B, C")
+
+Example 3: Math Problem
+Q: "System of equations to solve..."
+✅ CORRECT:
+  Turn 1: code_interpreter("import numpy; solve equations...")
+  Turn 2: validate_answer("0, 1, 2", question)
+  Turn 3: final_answer_tool("0, 1, 2")
+
+═══════════════════════════════════════════════════════════════
+📚 AVAILABLE TOOLS:
+═══════════════════════════════════════════════════════════════
+
+{tool_descriptions}
+
+═══════════════════════════════════════════════════════════════
+⚡ EXECUTION RULES:
+═══════════════════════════════════════════════════════════════
+
+- If you output text without a tool call, you have FAILED
+- If you're unsure, use think_through_logic() to organize thoughts
+- ALWAYS call a tool - preferably the right one for the question type
+- After EVERY tool result, decide: "Do I have the answer? → validate → submit"
+- If stuck after 3 turns: call reflect_on_progress()
+
+REMEMBER: One tool per turn. No reasoning without tools. Exact answer format.
+═══════════════════════════════════════════════════════════════
+"""
+
+        print("Initializing Groq LLM...")
+        try:
+        #. Initialize the LLM ()
+            #self.llm_with_tools = HuggingFaceEndpoint(
+            #    repo_id="HuggingFaceH4/zephyr-7b-beta", # Changed model
+            #    huggingfacehub_api_token=HUGGINGFACEHUB_API_TOKEN,
+            #    max_new_tokens=2048, # Increased token limit for potentially longer reasoning/tool use
+            #    temperature=0.01, # Keep temperature low for factual tasks     
+            #Use tool_choice="any" to FORCE tool usage
+            self.llm_with_tools = ChatGroq(
+                temperature=0,
+                groq_api_key=GROQ_API_KEY,
+                model_name="llama-3.3-70b-versatile",
+                max_tokens=4096,
+                timeout=60
+                ).bind_tools(self.tools, tool_choice="auto")  
+            print("✅ LLM initialized without FORCED tool usage.")
+
+        except Exception as e:
+            print(f"❌ Error initializing HuggingFace: {e}")
+            raise
+        
+        # Agent Node with AGGRESSIVE tool forcing
+        def agent_node(state: AgentState):
+            current_turn = state.get('turn', 0) + 1
+            print(f"\n{'='*70}")
+            print(f"🤖 AGENT TURN {current_turn}/{MAX_TURNS}")
+            print('='*70)
+            
+            if current_turn > MAX_TURNS:
+                return {
+                    "messages": [SystemMessage(content="Max turns reached.")],
+                    "turn": current_turn
+                }
+
+            # Check if we should force reflection
+            consecutive_errors = state.get('consecutive_errors', 0)
+            should_reflect = (current_turn > 5 and current_turn % REFLECT_EVERY_N_TURNS == 0) or consecutive_errors >= 3
+            
+            messages_to_send = state["messages"].copy()
+            
+            # Add tool-forcing message if last turn had no tool call
+            if len(messages_to_send) >= 2:
+                last_msg = messages_to_send[-1]
+                if isinstance(last_msg, AIMessage) and not last_msg.tool_calls:
+                    force_msg = SystemMessage(
+                        content="⚠️ CRITICAL: You MUST call a tool this turn. NO reasoning text. Pick the most appropriate tool and call it now."
+                    )
+                    messages_to_send.append(force_msg)
+                    print("🚨 Injecting tool-forcing message")
+            
+            # Add reflection hint if needed
+            if should_reflect:
+                hint = SystemMessage(
+                    content="⚠️ HINT: Multiple turns without progress. Consider calling reflect_on_progress() or try a different approach."
+                )
+                messages_to_send.append(hint)
+                print("🤔 Injecting reflection hint")
+            
+            # Invoke LLM with retries and fallback
+            max_retries = 3
+            ai_message = None
+            
+            for attempt in range(max_retries):
+                try:
+                    ai_message = self.llm_with_tools.invoke(messages_to_send)
+                    
+                    # If we got a valid response with tool calls, break
+                    if ai_message.tool_calls:
+                        break
+                    
+                    # If no tool calls, this is a problem
+                    print(f"⚠️ LLM returned no tool calls on attempt {attempt+1}")
+                    
+                except Exception as e:
+                    error_str = str(e)
+                    print(f"⚠️ LLM attempt {attempt+1}/{max_retries} failed: {error_str[:200]}")
+                    
+                    # If tool_use_failed, try without strict binding
+                    if "tool_use_failed" in error_str and attempt < max_retries - 1:
+                        print("🔧 Trying without strict tool enforcement...")
+                        try:
+                            simple_llm = ChatGroq(
+                                temperature=0,
+                                groq_api_key=os.getenv("GROQ_API_KEY"),
+                                model_name="llama-3.3-70b-versatile",
+                                max_tokens=4096,
+                                timeout=60
+                            )
+                            
+                            # Add explicit tool forcing to the message
+                            force_tool_msg = SystemMessage(
+                                content="You MUST call a tool. Respond with a tool call, not reasoning text."
+                            )
+                            ai_message = simple_llm.invoke(messages_to_send + [force_tool_msg])
+                            
+                            # Try to parse tool calls from content
+                            if ai_message.content and not ai_message.tool_calls:
+                                parsed = parse_tool_call_from_string(ai_message.content, self.tools)
+                                if parsed:
+                                    ai_message.tool_calls = parsed
+                                    ai_message.content = ""
+                                    print("✓ Fallback parsing succeeded")
+                                    break
+                        except Exception as e2:
+                            print(f"⚠️ Fallback also failed: {e2}")
+                    
+                    if attempt == max_retries - 1:
+                        # Last resort: inject a default tool call
+                        print("🚨 All attempts failed - forcing think_through_logic")
+                        ai_message = AIMessage(
+                            content="",
+                            tool_calls=[ToolCall(
+                                name="think_through_logic",
+                                args={"reasoning": "Processing question"},
+                                id=str(uuid.uuid4())
+                            )]
+                        )
+                    else:
+                        time.sleep(2 ** attempt)
+            
+            # If still no tool calls after all attempts, force one
+            if not ai_message.tool_calls:
+                if isinstance(ai_message.content, str) and ai_message.content.strip():
+                    # Try one more parse
+                    parsed = parse_tool_call_from_string(ai_message.content, self.tools)
+                    if parsed:
+                        ai_message.tool_calls = parsed
+                        ai_message.content = ""
+                        print("✓ Final parse succeeded")
+                    else:
+                        # Absolute last resort
+                        print("🚨 EMERGENCY: Forcing think_through_logic")
+                        ai_message.tool_calls = [ToolCall(
+                            name="think_through_logic",
+                            args={"reasoning": "analyzing question"},
+                            id=str(uuid.uuid4())
+                        )]
+                        ai_message.content = ""
+            
+            # Track tool usage
+            tool_history = state.get('tool_history', [])
+            has_plan = state.get('has_plan', False)
+            
+            if ai_message.tool_calls:
+                tool_name = ai_message.tool_calls[0]['name']
+                print(f"🔧 Tool Call: {tool_name}")
+                tool_history.append(tool_name)
+                
+                if tool_name == "create_plan":
+                    has_plan = True
+            else:
+                print(f"⚠️ No tool call (this shouldn't happen!)")
+                print(f"💭 Content: {ai_message.content[:200]}...")
+            
+            return {
+                "messages": [ai_message],
+                "turn": current_turn,
+                "has_plan": has_plan,
+                "tool_history": tool_history,
+                "last_tool_was_thinking": ai_message.tool_calls and ai_message.tool_calls[0]['name'] == 'think_through_logic'
+            }
+
+        # Tool Node with Error Tracking (FIXED)
+        def tool_node_wrapper(state: AgentState):
+            """Executes tools and tracks errors."""
+            print(f"🔧 Executing tools...")
+            
+            # Create fresh ToolNode instance
+            tool_executor = ToolNode(self.tools)
+            
+            # Invoke properly
+            result = tool_executor.invoke(state)
+            
+            # Track errors
+            consecutive_errors = state.get('consecutive_errors', 0)
+            
+            if result.get('messages'):
+                last_msg = result['messages'][-1]
+                if isinstance(last_msg, ToolMessage):
+                    if "Error" in last_msg.content or "error" in last_msg.content.lower():
+                        consecutive_errors += 1
+                        print(f"⚠️ Tool error detected (consecutive: {consecutive_errors})")
+                    else:
+                        consecutive_errors = 0
+            
+            result['consecutive_errors'] = consecutive_errors
+            return result
+        
+        # Build Graph
+        print("Building graph...")
+        graph_builder = StateGraph(AgentState)
+        
+        graph_builder.add_node("agent", agent_node)
+        graph_builder.add_node("tools", tool_node_wrapper)
+        
+        graph_builder.add_edge(START, "agent")
+        
+        graph_builder.add_conditional_edges(
+            "agent",
+            should_continue,
+            {
+                "tools": "tools",
+                "agent": "agent",
+                END: END
+            }
+        )
+        
+        graph_builder.add_edge("tools", "agent")
+        
+        self.graph = graph_builder.compile()
+        print("✅ Graph compiled successfully.")
+
+    def __call__(self, question: str) -> str:
+        """Execute agent on a question."""
+        print(f"\n{'='*70}")
+        print(f"🎯 NEW QUESTION")
+        print(f"{'='*70}")
+        print(f"Q: {question[:200]}{'...' if len(question) > 200 else ''}")
+        print(f"{'='*70}\n")
+        
+        graph_input = {
+            "messages": [
+                SystemMessage(content=self.system_prompt),
+                HumanMessage(content=question)
+            ],
+            "turn": 0,
+            "has_plan": False,
+            "consecutive_errors": 0,
+            "tool_history": [],
+            "last_tool_was_thinking": False
+        }
+        
+        final_answer = "AGENT FAILED TO PRODUCE ANSWER"
+        all_messages = []
+        
+        try:
+            config = {"recursion_limit": MAX_TURNS + 10}
+            
+            for event in self.graph.stream(graph_input, stream_mode="values", config=config):
+                if not event.get('messages'):
+                    continue
+                
+                all_messages = event["messages"]
+                last_message = all_messages[-1]
+                
+                # Check for final answer
+                if isinstance(last_message, AIMessage) and last_message.tool_calls:
+                    for tool_call in last_message.tool_calls:
+                        if tool_call.get("name") == "final_answer_tool":
+                            args = tool_call.get('args', {})
+                            if 'answer' in args:
+                                final_answer = args['answer']
+                                print(f"\n{'='*70}")
+                                print(f"✅ FINAL ANSWER: '{final_answer}'")
+                                print(f"{'='*70}\n")
+                                break
+
+                elif isinstance(last_message, ToolMessage):
+                    preview = last_message.content[:200].replace('\n', ' ')
+                    print(f"📊 Tool '{last_message.name}' result: {preview}...")
+                    
+                elif isinstance(last_message, AIMessage) and not last_message.tool_calls:
+                    print(f"💭 AI: {last_message.content[:200]}...")
+            
+            # If no final answer, try to extract from tool messages
+            if final_answer == "AGENT FAILED TO PRODUCE ANSWER":
+                print("⚠️ No final_answer_tool called. Checking tool results...")
+                
+                for msg in reversed(all_messages):
+                    if isinstance(msg, ToolMessage):
+                        if msg.name in ["calculator", "think_through_logic", "code_interpreter"]:
+                            content = msg.content.strip()
+                            # Look for short, answer-like content
+                            if content and len(content) < 200 and not content.startswith("Error"):
+                                # Extract just the result part
+                                lines = content.split('\n')
+                                for line in reversed(lines):
+                                    if line.strip() and not line.startswith(('✅', '⚠️', 'Next', 'Remember')):
+                                        final_answer = line.strip()
+                                        print(f"📝 Extracted from {msg.name}: '{final_answer}'")
+                                        break
+                                break
+
+            # Clean the answer
+            cleaned = str(final_answer).strip()
+            
+            # Remove prefixes
+            prefixes = [
+                "the answer is:", "here is the answer:", "based on",
+                "final answer:", "answer:", "the final answer is:",
+                "my answer is:", "according to", "i found that",
+                "the result is:", "result:"
+            ]
+            for prefix in prefixes:
+                if cleaned.lower().startswith(prefix.lower()):
+                    potential = cleaned[len(prefix):].strip()
+                    if potential:
+                        cleaned = potential
+                        break
+            
+            # Remove code fences and quotes
+            cleaned = remove_fences_simple(cleaned)
+            
+            while cleaned.startswith("`") and cleaned.endswith("`"):
+                cleaned = cleaned[1:-1].strip()
+            
+            if (cleaned.startswith('"') and cleaned.endswith('"')) or \
+               (cleaned.startswith("'") and cleaned.endswith("'")):
+                cleaned = cleaned[1:-1].strip()
+            
+            # Remove trailing period for short answers
+            if cleaned.endswith('.') and len(cleaned.split()) < 10:
+                cleaned = cleaned[:-1]
+            
+            print(f"\n{'='*70}")
+            print(f"🎉 RETURNING ANSWER")
+            print(f"{'='*70}")
+            print(f"{cleaned}")
+            print(f"{'='*70}\n")
+            
+            return cleaned
+            
+        except Exception as e:
+            print(f"❌ Graph error: {e}")
+            print(traceback.format_exc())
+            return f"AGENT ERROR: {e}"
+
+
+# =============================================================================
+# GLOBAL AGENT INSTANTIATION
+# =============================================================================
+agent = None
+
+try:
+    initialize_rag_components()
+    
+    agent = PlanningReflectionAgent()
+    print("✅ Global PlanningReflectionAgent instantiated.")
+    
+    # Verify it's callable
+    if not callable(agent):
+        print("❌ ERROR: Agent not callable!")
+        agent = None
     else:
-        print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
+        print("✅ Agent is callable.")
+    
+    if asr_pipeline is None:
+        print("⚠️ ASR Pipeline not loaded.")
+        
+except Exception as e:
+    print(f"❌ FATAL: Agent initialization failed: {e}")
+    traceback.print_exc()
+    agent = None
 
-    print("-"*(60 + len(" App Starting ")) + "\n")
+# ====================================================
+# --- (Original Template Code - Mock Questions Version) ---
+def run_and_submit_all( profile: gr.OAuthProfile | None): # Corrected type hint
+    """
+    Fetches MOCK questions, runs the BasicAgent on them, simulates submission prep,
+    and displays the results. DOES NOT SUBMIT.
+    """
+    space_id = os.getenv("SPACE_ID")
+    username = profile.username if profile else "local_test_user"
+    print(f"User: {username}{'' if profile else ' (dummy)'}")
+    
+    # Check if global agent initialized
+    if not agent:
+        return "FATAL ERROR: Global agent failed to initialize. Check logs.", None
+
+    print("Using globally instantiated agent.")
+    agent_code = f"httpsS://huggingface.co/spaces/{space_id}/tree/main" if space_id else "local_run" # Corrected URL
+    print(f"Agent code URL: {agent_code}")
+    print("--- USING MOCK QUESTIONS ---")
+    
+    # --- MOCK QUESTIONS ---
+    # 
+    # vvv  PASTE YOUR FULL LIST OF 20 MOCK QUESTIONS HERE  vvv
+    #
+    mock_questions_data = [
+        {
+            "task_id": "mock_level1_001",
+            "question": r"""Here's a fun riddle that I'd like you to try.\n\nAn adventurer exploring an ancient tomb came across a horde of gold coins, all neatly stacked in columns. As he reached to scoop them into his backpack, a mysterious voice filled the room. \"You have fallen for my trap adventurer,\" the voice began, and suddenly the doorway to the chamber was sealed by a heavy rolling disk of stone. The adventurer tried to move the stone disk but was unable to budge the heavy stone. Trapped, he was startled when the voice again spoke. \n\n\"If you solve my riddle, I will reward you with a portion of my riches, but if you are not clever, you will never leave this treasure chamber. Before you are 200 gold coins. I pose a challenge to you, adventurer. Within these stacks of coins, all but 30 are face-up. You must divide the coins into two piles, one is yours, and one is mine. You may place as many coins as you like in either pile. You may flip any coins over, but you may not balance any coins on their edges. For every face-down coin in your pile, you will be rewarded with two gold coins. But be warned, if both piles do not contain the same number of face-down coins, the door will remain sealed for all eternity!\"\n\nThe adventurer smiled, as this would be an easy task. All he had to do was flip over every coin so it was face down, and he would win the entire treasure! As he moved to the columns of coins, however, the light suddenly faded, and he was left in total darkness. The adventurer reached forward and picked up one of the coins, and was shocked when he realized that both sides felt almost the same. Without the light, he was unable to determine which side of the coin was heads and which side was tails. He carefully replaced the coin in its original orientation and tried to think of a way to solve the puzzle. Finally, out of desperation, the adventurer removed 30 coins to create his pile. He then carefully flipped over each coin in his pile, so its orientation was inverted from its original state.\n\n\"I've finished,\" he said, and the lights returned. Looking at the two piles, he noticed that the larger pile contained 14 face-down coins.\n\nWhat was the outcome for the adventurer? If he failed the challenge, please respond with \"The adventurer died.\" Otherwise, please provide the number of coins the adventurer won at the conclusion of the riddle. If the adventurer won any coins, provide your response as the number of coins, with no other text."""
+        },
+        {
+            "task_id": "mock_level1_002",
+            "question": r"""If you use some of the letters in the given Letter Bank to spell out the sentence "I am a penguin halfway to the moon", which of the remaining unused letters would have to be changed to spell out, "The moon is made of cheese"? Return a comma-separated alphabetized list.\nLetter Bank: {OAMFETIMPECRFSHTDNIWANEPNOFAAIYOOMGUTNAHHLNEHCME}"""
+        },
+        {
+            "task_id": "mock_level1_003",
+            "question": r"""A data annotator stayed up too late creating test questions to check that a system was working properly and submitted several questions with mathematical errors. On nights when they created 15 test questions, they made 1 error. On nights when they created fewer than 15 questions, they also corrected 3 errors. On nights they created 20 questions, they made 0 errors. On nights when they created 25 or more, they made 4 errors. Over the course of five nights, the worker produced a total of 6 errors. When asked how many nights they created 15 questions, they gave three possible numbers as responses. What are the three numbers, presented in the format x, y, z in ascending order?"""
+        },
+        {
+            "task_id": "mock_level1_004",
+            "question": r"""Please solve the following crossword:\n\n|1|2|3|4|5|\n|6| | | | |\n|7| | | | |\n|8| | | | |\n|X|9| | | |\n\nI have indicated by numbers where the hints start, so you should replace numbers and spaces by the answers.\nAnd X denotes a black square that isn\u2019t to fill.\n\nACROSS\n- 1 Wooden strips on a bed frame\n- 6 _ Minhaj, Peabody-winning comedian for "Patriot Act"\n- 7 Japanese city of 2.6+ million\n- 8 Stopwatch, e.g.\n- 9 Pain in the neck\n\nDOWN\n- 1 Quick drink of whiskey\n- 2 Eye procedure\n- 3 "Same here," in a three-word phrase\n- 4 Already occupied, as a seat\n- 5 Sarcastically critical commentary. Answer by concatenating the characters you choose to fill the crossword, in row-major order."""
+        },
+        {
+            "task_id": "mock_level1_005",
+            "question": r"""I wanted to make another batch of cherry melomel. I remember liking the last recipe I tried, but I can't remember it off the top of my head. It was from the Reddit, r/mead. I remember that the user who made it had a really distinct name, I think it was StormBeforeDawn. Could you please look up the recipe for me? I'm not sure if it has been changed, so please make sure that the recipe you review wasn't updated after July 14, 2022. That's the last time I tried the recipe.\n\nWhat I want to know is how many cherries I'm supposed to use. I'm making a 10-gallon batch in two 5-gallon carboys. Please just respond with the integer number of pounds of whole cherries with pits that are supposed to be used for a 10-gallon batch."""
+        },
+        {
+            "task_id": "mock_level1_006",
+            "question": r"""Verify each of the following ISBN 13 numbers:\n\n1. 9783518188156\n2. 9788476540746\n3. 9788415091004\n4. 9788256014590\n5. 9782046407331\n\nIf any are invalid, correct them by changing the final digit. Then, return the list, comma separated, in the same order as in the question."""
+        },
+        {
+            "task_id": "mock_level1_007",
+            "question": r"""A porterhouse by any other name is centered around a letter. What does Three Dog Night think about the first natural number that starts with that letter? Give the first line from the lyrics that references it."""
+        },
+        {
+            "task_id": "mock_level1_008",
+            "question": r"""Bob has genome type Aa, and Linda has genome type Aa. Assuming that a child of theirs also has a child with someone who also has genome type Aa, what is the probability that Bob and Linda's grandchild will have Genome type Aa? Write the answer as a percentage, rounding to the nearest integer if necessary."""
+        },
+        {
+            "task_id": "mock_level1_009",
+            "question": r"""An array of candy is set out to choose from including gumballs, candy corn, gumdrops, banana taffy, chocolate chips, and gummy bears. There is one bag of each type of candy. The gumballs come in red, orange, yellow, green, blue, and brown. The candy corn is yellow, white, and orange. The gumdrops are red, green, purple, yellow, and orange. The banana taffy is yellow. The chocolate chips are brown and white. The gummy bears are red, green, yellow, and orange. Five people pass through and each selects one bag. The first selects one with only primary colors. The second selects one with no primary colors. The third selects one with all the primary colors. The fourth selects one that has neither the most nor the least colors of the remaining bags. The fifth selects the one with their favorite color, green. A second bag of the candy the first person chose is added to the remaining bag of candy. Which two candies are in the remaining bag after the addition? Give me them in a comma separated list, in alphabetical order"""
+        },
+        {
+            "task_id": "mock_level1_010",
+            "question": r"""In the year 2020, where were koi fish found in the watershed with the id 02040203? Give only the name of the pond, lake, or stream where the fish were found, and not the name of the city or county."""
+        },
+        {
+            "task_id": "mock_level1_011",
+            "question": r"""In Sonia Sanchez\u2019s poem \u201cfather\u2019s voice\u201d, what primary colour is evoked by the imagery in the beginning of the tenth stanza? Answer with a capitalized word."""
+        },
+        {
+            "task_id": "mock_level1_012",
+            "question": r"""According to Papers with Code, what was the name of the first model to go beyond 70% of accuracy on ImageNet ?"""
+        },
+        {
+            "task_id": "mock_level1_013",
+            "question": r"""What is the dimension of the boundary of the tame twindragon rounded to two decimal places?"""
+        },
+        {
+            "task_id": "mock_level1_014",
+            "question": r"""In what year was the home village of the subject of British Museum item #Bb,11.118 founded?"""
+        },
+        {
+            "task_id": "mock_level1_015",
+            "question": r"""What is the ISSN of the journal that included G. Scott's potato article that mentioned both a fast food restaurant and a Chinese politician in the title in a 2012 issue?"""
+        },
+        {
+            "task_id": "mock_level1_016",
+            "question": r"""VNV Nation has a song that shares its title with the nickname of Louis XV. What album was it released with?"""
+        },
+        {
+            "task_id": "mock_level1_017",
+            "question": r"""If I combine a Beatle's first name and a type of beer, in what category and year of Nobel Prize do I have a winner? Answer using the format CATEGORY, YEAR."""
+        },
+        {
+            "task_id": "mock_level1_018",
+            "question": r"""In the version of NumPy where the numpy.msort function was deprecated, which attribute was added to the numpy.polynomial package's polynomial classes?"""
+        },
+        {
+            "task_id": "mock_level1_019",
+            "question": r"""A word meaning dramatic or theatrical forms a species of duck when appended with two letters and then duplicated. What is that word?"""
+        },
+        {
+            "task_id": "mock_level1_020",
+            "question": r"""As of August 2023, how many in-text citations on the West African Vodun Wikipedia page reference a source that was cited using Scopus?"""
+        }
+    ]
+    
+    questions_data = mock_questions_data
+    print(f"Using {len(questions_data)} mock questions.")
+
+    results_log, answers_payload = [], []
+    print(f"Running agent on {len(questions_data)} mock questions...")
+
+    for i, item in enumerate(questions_data):
+        task_id, question_text = item.get("task_id"), item.get("question")
+        if not task_id or question_text is None: print(f"Skipping mock item {i+1}"); continue
+
+        print(f"\n--- Running Mock Task {i+1} (ID: {task_id}) ---")
+        try:
+            file_path = item.get("file_path")
+            question_text_with_context = question_text
+            if file_path:
+                 question_text_with_context = f"{question_text}\n\n[Attached File: {file_path}]"
+                 print(f"Q includes file: {file_path}")
+
+            submitted_answer = agent(question_text_with_context)
+            submitted_answer_str = str(submitted_answer) if submitted_answer is not None else ""
+            answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer_str})
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer_str})
+            print(f"--- Mock Task {task_id} Complete ---")
+        except Exception as e:
+             print(f"FATAL ERROR on mock task {task_id}: {e}")
+             import traceback; traceback.print_exc()
+             submitted_answer = f"AGENT CRASH: {e}"
+             answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
+             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
 
-    print("Launching Gradio Interface for Basic Agent Evaluation...")
-    demo.launch(debug=True, share=False)
+    if not answers_payload: return "Agent produced no answers.", pd.DataFrame(results_log)
+
+    status_update = f"Finished mock run. Processed {len(answers_payload)} answers for '{username}'."
+    print(status_update); print("--- MOCK RUN - SUBMISSION SKIPPED ---")
+    final_status = "--- Mock RUN COMPLETE ---\n" + status_update + "\nSubmission SKIPPED." # Corrected typo
+    results_df = pd.DataFrame(results_log); results_df['Correct'] = 'N/A (Mock)'
+    return final_status, results_df
+
+
+# --- Build Gradio Interface ---
+with gr.Blocks() as demo:
+    gr.Markdown("# GAIA Agent - MOCK TEST (Groq Llama3.1)")
+    gr.Markdown("""
+        **Instructions:** Click 'Run Mock Evaluation'.
+        **Notes:** Uses Groq (Llama-3.3-70b Executor). Ensure `GROQ_API_KEY` secret/env var exists. **DOES NOT** fetch official Qs or submit. Check logs for details.
+        """)
+    gr.LoginButton()
+    run_button = gr.Button("Run Mock Evaluation")
+    status_output = gr.Textbox(label="Run Status / Mock Result", lines=5, interactive=False)
+    results_table = gr.DataFrame(label="Mock Qs, Agent Answers, Results", wrap=True)
+    run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
+
+if __name__ == "__main__":
+    print("\n" + "-"*30 + " App Starting " + "-"*30)
+    space_host_startup = os.getenv("SPACE_ID"); space_id_startup = os.getenv("SPACE_ID") # Corrected variable name
+    if space_host_startup: print(f"✅ SPACE_HOST: {space_host_startup}\n   Runtime URL: https://{space_host_startup}.hf.space")
+    else: print("ℹ️ No SPACE_HOST (local?).")
+    if space_id_startup: print(f"✅ SPACE_ID: {space_id_startup}\n   Repo URL: https://huggingface.co/spaces/{space_id_startup}\n   Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
+    else: print("ℹ️ No SPACE_ID (local?).")
+    try: script_dir = os.path.dirname(os.path.realpath(__file__))
+    except NameError: script_dir = os.getcwd()
+    print(f"Script directory: {script_dir}")
+    print(f"CWD: {os.getcwd()}")
+    try: print("Files in CWD:", os.listdir("."))
+    except FileNotFoundError: print("Warning: CWD listing failed.")
+    print("-"*(60 + len(" App Starting ")) + "\n")
+    print("Launching Gradio Interface...")
+    demo.queue().launch(debug=True, share=False)