Update app.py

app.py

@@ -4,7 +4,10 @@ import json
 import re
 import traceback
 import contextlib
-from typing import List, Optional
+import uuid
+import time
+import ast
+from typing import List, Optional, TypedDict, Annotated
 from pathlib import Path
 
 import gradio as gr
@@ -20,11 +23,11 @@ import requests
 
 # LangChain & LangGraph
 from langgraph.graph.message import add_messages
-from langchain_core.messages import HumanMessage, AIMessage, ToolMessage
+from langchain_core.messages import HumanMessage, AIMessage, ToolMessage, SystemMessage, AnyMessage
+from langchain_core.tools import tool, ToolCall
 from langgraph.prebuilt import ToolNode
 from langgraph.graph import START, END, StateGraph
-from langchain_core.tools import tool
-from langchain_groq import ChatGroq  # <-- Groq integration
+from langchain_groq import ChatGroq
 
 # RAG
 from langchain_text_splitters import RecursiveCharacterTextSplitter
@@ -35,264 +38,223 @@ from langchain_community.tools import DuckDuckGoSearchRun
 # =============================================================================
 # CONFIGURATION
 # =============================================================================
-class Config:
-    DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-    MAX_TURNS = 20
-    MAX_MESSAGE_LENGTH = 8000
-    GROQ_MODEL = "llama-3.3-70b-versatile"  # Groq's Llama 70B model
-    ASR_MODEL = "openai/whisper-base"
-    EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
-    CHUNK_SIZE = 1000
-    CHUNK_OVERLAP = 200
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+MAX_TURNS = 20
+MAX_MESSAGE_LENGTH = 8000
 
 # =============================================================================
 # ASR INITIALIZATION
 # =============================================================================
-class ASRManager:
-    """Manages the Automatic Speech Recognition pipeline."""
-    
-    def __init__(self):
-        self.pipeline = None
-        self._initialize()
-    
-    def _initialize(self):
-        """Initialize the ASR pipeline with proper device handling."""
-        try:
-            print("Initializing ASR (Whisper) pipeline...")
-            device = 0 if torch.cuda.is_available() else -1
-            device_name = "cuda:0" if device == 0 else "cpu"
-            print(f"Using device: {device_name}")
-            
-            self.pipeline = pipeline(
-                "automatic-speech-recognition",
-                model=Config.ASR_MODEL,
-                torch_dtype=torch.float16 if device == 0 else torch.float32,
-                device=device
-            )
-            print("✅ ASR pipeline loaded successfully")
-        except Exception as e:
-            print(f"⚠️ Failed to load ASR pipeline: {e}")
-            self.pipeline = None
-    
-    def transcribe(self, file_path: str) -> str:
-        """Transcribe an audio file."""
-        if self.pipeline is None:
-            raise RuntimeError("ASR pipeline not available")
-        
-        result = self.pipeline(file_path)
-        return result.get("text", "")
-
-# Global ASR manager
-asr_manager = ASRManager()
+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
 # =============================================================================
-class FileUtils:
-    """Utilities for file operations."""
-    
-    @staticmethod
-    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
-    
-    @staticmethod
-    def truncate_if_needed(content: str, max_length: int = Config.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
-
-class SecurityValidator:
-    """Validates code for security concerns."""
-    
-    DANGEROUS_PATTERNS = ['__import__', 'eval(', 'compile(', 'subprocess', 'os.system']
-    WRITE_MODES = ["'w'", '"w"', "'a'", '"a"', "'wb'", '"wb"']
-    
-    @classmethod
-    def validate_code(cls, code: str) -> Optional[str]:
-        """
-        Validate code for security issues.
-        Returns error message if dangerous, None if safe.
-        """
-        code_lower = code.lower()
-        
-        # Check for dangerous operations
-        for pattern in cls.DANGEROUS_PATTERNS:
-            if pattern in code_lower:
-                return f"Potentially dangerous operation '{pattern}' is not allowed"
-        
-        # Check for file writing
-        if 'open(' in code_lower and any(mode in code for mode in cls.WRITE_MODES):
-            return "Writing files not allowed in code_interpreter. Use write_file tool"
-        
-        return None
+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
 
 # =============================================================================
 # TOOL DEFINITIONS
 # =============================================================================
 
-# --- Search Tool ---
 class SearchInput(BaseModel):
     query: str = Field(description="The search query.")
 
 @tool(args_schema=SearchInput)
 def search_tool(query: str) -> str:
-    """Search the web using DuckDuckGo for recent information."""
-    if not query or not isinstance(query, str):
-        return "Error: 'query' must be a non-empty string"
+    """Calls DuckDuckGo search and returns the results. Use this for recent information or general web searches."""
+    if not isinstance(query, str) or not query.strip():
+        return "Error: Invalid input. 'query' must be a non-empty string."
     
-    print(f"🔍 Searching: {query}")
+    print(f"--- Calling Search Tool with query: {query} ---")
     try:
         search = DuckDuckGoSearchRun()
         result = search.run(query)
-        return FileUtils.truncate_if_needed(result)
+        if len(result) > MAX_MESSAGE_LENGTH:
+            result = result[:MAX_MESSAGE_LENGTH] + f"\n...[truncated, {len(result)} total chars]"
+        return result
     except Exception as e:
-        return f"Search error for '{query}': {str(e)}"
+        return f"Error running search for '{query}': {str(e)}"
+
 
-# --- Code Interpreter Tool ---
 class CodeInput(BaseModel):
-    code: str = Field(description="Python code to execute (must include print() for output).")
+    code: str = Field(description="The Python code to execute, which must include a print() statement for output.")
 
 @tool(args_schema=CodeInput)
 def code_interpreter(code: str) -> str:
     """
-    Execute Python code and return output.
-    
-    RULES:
-    1. ALWAYS use print() for output
-    2. Keep code simple and focused
-    3. Add comments to explain logic
-    4. Import libraries inside functions
-    5. Available: pandas as pd, basic Python libraries
+    Executes a string of Python code and returns its stdout, stderr, and any error.
+    CRITICAL RULES:
+    1. ALWAYS use print() to output your final answer.
+    2. Write simple, focused code. One task per execution.
+    3. Add comments (#) to explain your logic.
+    4. SCOPE RULE: Import all necessary libraries inside any function you define.
+    Available: pandas as pd, basic Python libraries.
     """
     if not isinstance(code, str):
-        return "Error: 'code' must be a string"
+        return "Error: Invalid input. 'code' must be a string."
     
-    # Security validation
-    error = SecurityValidator.validate_code(code)
-    if error:
-        return f"Error: {error}"
+    # Basic safety checks
+    dangerous_patterns = ['__import__', 'eval(', 'compile(', 'subprocess', 'os.system']
+    code_lower = code.lower()
+    for pattern in dangerous_patterns:
+        if pattern in code_lower:
+            return f"Error: Potentially dangerous operation '{pattern}' is not allowed."
     
-    print(f"💻 Executing code:\n{code}\n---")
+    if 'open(' in code_lower and any(mode in code for mode in ["'w'", '"w"', "'a'", '"a"', "'wb'", '"wb"']):
+        return "Error: Writing files is not allowed in code_interpreter. Use write_file tool instead."
     
+    print(f"--- Calling Code Interpreter ---\nCode:\n{code}\n---")
     output_stream = io.StringIO()
     error_stream = io.StringIO()
     
     try:
-        with contextlib.redirect_stdout(output_stream), \
-             contextlib.redirect_stderr(error_stream):
-            
+        with contextlib.redirect_stdout(output_stream), contextlib.redirect_stderr(error_stream):
             safe_globals = {
                 "pd": pd,
                 "__builtins__": __builtins__
             }
             exec(code, safe_globals, {})
-        
+            
         stdout = output_stream.getvalue()
         stderr = error_stream.getvalue()
         
         if stderr:
-            return f"Error:\n{stderr}\n\nOutput:\n{stdout}"
+            return f"Error in execution:\n{stderr}\n\nStdout (if any):\n{stdout}"
         
         if stdout:
-            return f"Success:\n{FileUtils.truncate_if_needed(stdout)}"
+            if len(stdout) > MAX_MESSAGE_LENGTH:
+                stdout = stdout[:MAX_MESSAGE_LENGTH] + f"\n...[truncated, {len(stdout)} total chars]"
+            return f"Success:\n{stdout}"
         
-        return "Success: Code executed but produced no output.\n⚠️ Use print() to see results!"
-    
-    except Exception:
-        return f"Execution failed:\n{traceback.format_exc()}"
+        return "Success: Code executed without error but produced no output.\n⚠️ Remember to use print() to output your results!"
+        
+    except Exception as e:
+        tb_str = traceback.format_exc()
+        return f"Execution failed:\n{tb_str}"
+
 
-# --- File Operations ---
 class ReadFileInput(BaseModel):
-    path: str = Field(description="Path to the file to read.")
+    path: str = Field(description="The path to the file to read.")
 
 @tool(args_schema=ReadFileInput)
 def read_file(path: str) -> str:
-    """Read the content of a file."""
-    if not path or not isinstance(path, str):
-        return "Error: 'path' must be a non-empty string"
+    """Reads the content of a file at the specified path."""
+    if not isinstance(path, str) or not path.strip():
+        return "Error: Invalid input. 'path' must be a non-empty string."
     
-    print(f"📖 Reading: {path}")
+    print(f"--- Calling Read File Tool: {path} ---")
     
-    file_path = FileUtils.find_file(path)
+    file_path = find_file(path)
     if not file_path:
-        cwd_files = list(Path.cwd().iterdir())
+        cwd_files = os.listdir(".")
         return (f"Error: File not found: '{path}'\n"
-                f"Files in current directory: {[f.name for f in cwd_files]}")
+                f"Files in current directory: {cwd_files}")
     
     try:
-        # Try reading as text
         content = file_path.read_text(encoding='utf-8')
-        return FileUtils.truncate_if_needed(content)
-    
+        return truncate_if_needed(content)
     except UnicodeDecodeError:
-        # Binary file
         size = file_path.stat().st_size
         ext = file_path.suffix
         return (f"File appears to be binary ({size} bytes). Cannot display as text.\n"
                 f"File type: {ext}\n"
                 f"Consider using audio_transcription_tool for audio files.")
-    
     except Exception as e:
         return f"Error reading file: {str(e)}"
 
+
 class WriteFileInput(BaseModel):
-    path: str = Field(description="Path to write the file.")
-    content: str = Field(description="Content to write.")
+    path: str = Field(description="The path of the file to write to.")
+    content: str = Field(description="The content to write into the file.")
 
 @tool(args_schema=WriteFileInput)
 def write_file(path: str, content: str) -> str:
-    """Write content to a file."""
-    if not path or not isinstance(path, str):
-        return "Error: 'path' must be a non-empty string"
+    """Writes content to a file at the specified path."""
+    if not isinstance(path, str) or not path.strip():
+        return "Error: Invalid input. 'path' must be a non-empty string."
     if not isinstance(content, str):
-        return "Error: 'content' must be a string"
+        return "Error: Invalid input. 'content' must be a string."
     
-    print(f"✍️ Writing to: {path}")
+    print(f"--- Calling Write File Tool: {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"Successfully wrote {len(content)} characters to '{path}'"
+        return f"Successfully wrote {len(content)} characters to '{path}'."
     except Exception as e:
-        return f"Error writing file: {str(e)}"
+        return f"Error writing file '{path}': {str(e)}"
+
 
 class ListDirInput(BaseModel):
-    path: str = Field(description="Directory path to list.", default=".")
+    path: str = Field(description="The directory path to list.", default=".")
 
 @tool(args_schema=ListDirInput)
 def list_directory(path: str = ".") -> str:
-    """List the contents of a directory."""
-    print(f"📁 Listing: {path}")
+    """Lists the contents of a directory."""
+    print(f"--- Calling List Directory Tool: {path} ---")
     
     try:
         dir_path = Path.cwd() / path if path != "." else Path.cwd()
         
         if not dir_path.is_dir():
-            return f"Error: '{path}' is not a valid directory"
+            return f"Error: '{path}' is not a valid directory."
         
         items = sorted(dir_path.iterdir())
         
         if not items:
-            return f"Directory '{path}' is empty"
+            return f"Directory '{path}' is empty."
         
-        files = []
-        directories = []
+        files, directories = [], []
         
         for item in items:
             if item.is_dir():
@@ -308,48 +270,52 @@ def list_directory(path: str = ".") -> str:
             result += "Files:\n" + "\n".join(files)
         
         return result
-    
     except Exception as e:
-        return f"Error listing directory: {str(e)}"
+        return f"Error listing directory '{path}': {str(e)}"
+
 
-# --- Audio Transcription ---
 class AudioInput(BaseModel):
-    file_path: str = Field(description="Path to the audio file.")
+    file_path: str = Field(description="The file path of the audio to transcribe.")
 
 @tool(args_schema=AudioInput)
 def audio_transcription_tool(file_path: str) -> str:
-    """Transcribe an audio file to text using Whisper."""
-    if not file_path or not isinstance(file_path, str):
-        return "Error: 'file_path' must be a non-empty string"
+    """Transcribes an audio file to text using Whisper."""
+    if not isinstance(file_path, str) or not file_path.strip():
+        return "Error: Invalid input. 'file_path' must be a non-empty string."
     
-    print(f"🎤 Transcribing: {file_path}")
+    print(f"--- Calling Audio Transcription: {file_path} ---")
     
-    audio_path = FileUtils.find_file(file_path)
+    if asr_pipeline is None:
+        return "Error: ASR pipeline is not available."
+    
+    audio_path = find_file(file_path)
     if not audio_path:
         return f"Error: Audio file not found: '{file_path}'"
     
     try:
-        text = asr_manager.transcribe(str(audio_path))
-        if not text:
-            return "Error: Transcription produced no text"
-        return f"Transcription:\n{FileUtils.truncate_if_needed(text)}"
+        transcription = asr_pipeline(str(audio_path))
+        result_text = transcription.get("text", "")
+        
+        if not result_text:
+            return "Error: Transcription produced no text."
+        
+        return f"Transcription:\n{truncate_if_needed(result_text)}"
     except Exception as e:
-        return f"Error transcribing: {str(e)}"
+        return f"Error transcribing '{file_path}': {str(e)}"
+
 
-# --- YouTube Transcript ---
 class YoutubeInput(BaseModel):
-    video_url: str = Field(description="YouTube video URL.")
+    video_url: str = Field(description="The URL of the YouTube video.")
 
 @tool(args_schema=YoutubeInput)
 def get_youtube_transcript(video_url: str) -> str:
-    """Fetch transcript/captions for a YouTube video."""
-    if not video_url or not isinstance(video_url, str):
-        return "Error: 'video_url' must be a non-empty string"
+    """Fetches the transcript/captions for a YouTube video."""
+    if not isinstance(video_url, str) or not video_url.strip():
+        return "Error: Invalid input. 'video_url' must be a non-empty string."
     
-    print(f"📺 Fetching transcript: {video_url}")
+    print(f"--- Calling YouTube Transcript: {video_url} ---")
     
     try:
-        # Extract video ID
         video_id = None
         if "watch?v=" in video_url:
             video_id = video_url.split("v=")[1].split("&")[0]
@@ -357,46 +323,40 @@ def get_youtube_transcript(video_url: str) -> str:
             video_id = video_url.split("youtu.be/")[1].split("?")[0]
         
         if not video_id:
-            return f"Error: Could not extract video ID from '{video_url}'"
-        
+            return f"Error: Could not extract YouTube video ID from '{video_url}'."
+            
         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"YouTube Transcript:\n{FileUtils.truncate_if_needed(full_transcript)}"
-    
+            return "Error: No transcript found for this video."
+            
+        full_transcript = " ".join([item["text"] for item in transcript_list])
+        return f"YouTube Transcript:\n{truncate_if_needed(full_transcript)}"
     except Exception as e:
-        return f"Error getting transcript: {str(e)}"
+        return f"Error getting transcript for '{video_url}': {str(e)}"
+
 
-# --- RAG-Based Web Scraper ---
 class ScrapeInput(BaseModel):
-    url: str = Field(description="URL to scrape (http:// or https://).")
-    query: str = Field(description="Question to answer from the page.")
+    url: str = Field(description="The URL to scrape (must start with http:// or https://).")
+    query: str = Field(description="The specific question to answer or information to find on the page.")
 
 @tool(args_schema=ScrapeInput)
 def scrape_and_retrieve(url: str, query: str) -> str:
     """
-    Scrape a webpage and use RAG to find relevant information.
-    
-    Args:
-        url: The URL to scrape
-        query: The specific question to answer
+    Scrapes a webpage, chunks its content, and performs RAG search.
     """
-    if not url.lower().startswith(('http://', 'https://')):
+    if not (url.lower().startswith(('http://', 'https://'))):
         return f"Error: Invalid URL. Must start with http:// or https://. Got: '{url}'"
     if not query:
-        return "Error: A query is required"
+        return "Error: A query is required to search the page content."
     
     # Access global agent for RAG components
-    if not hasattr(scrape_and_retrieve, 'embeddings'):
-        return "Error: RAG components not initialized"
-    
-    print(f"🌐 Scraping: {url} for query: {query}")
+    if not hasattr(scrape_and_retrieve, 'embeddings') or not hasattr(scrape_and_retrieve, 'text_splitter'):
+        return "Error: RAG components are not initialized."
+
+    print(f"--- Calling RAG Scraper: {url} for query: {query} ---")
     
     try:
-        # Scrape webpage
         headers = {
             'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
         }
@@ -404,156 +364,606 @@ def scrape_and_retrieve(url: str, query: str) -> str:
         response.raise_for_status()
         
         soup = BeautifulSoup(response.text, 'html.parser')
-        
-        # Remove non-content elements
         for tag in soup(["script", "style", "nav", "footer", "aside", "header"]):
             tag.extract()
         
-        # Extract main content
         main_content = soup.find('main') or soup.find('article') or soup.body
         if not main_content:
-            return "Error: Could not find main content"
+            return "Error: Could not find main content on the page."
         
         text = main_content.get_text(separator='\n', strip=True)
-        text = '\n'.join(line.strip() for line in text.splitlines() if line.strip())
+        text = '\n'.join(chunk for chunk in (line.strip() for line in text.splitlines()) if chunk)
         
         if not text:
-            return "Error: No content extracted"
+            return "Error: Scraped content was empty."
         
-        # Split text into chunks
         docs = scrape_and_retrieve.text_splitter.create_documents([text])
         if not docs:
-            return "Error: Could not split text into documents"
-        
-        # Create vector store and retrieve
+            return "Error: Text could not be split into documents."
+            
         db = FAISS.from_documents(docs, scrape_and_retrieve.embeddings)
         retriever = db.as_retriever(search_kwargs={"k": 5})
         retrieved_docs = retriever.invoke(query)
         
         if not retrieved_docs:
-            return "Error: No relevant information found"
-        
-        # Format results
-        context = "\n\n---\n\n".join(doc.page_content for doc in retrieved_docs)
-        return f"Relevant Context from {url} for '{query}':\n\n{context}"
-    
+            return "Error: No relevant information found on the page for that query."
+            
+        context = "\n\n---\n\n".join([doc.page_content for doc in retrieved_docs])
+        return f"Relevant Context from {url} for query '{query}':\n\n{context}"
+
     except Exception as e:
-        return f"Error scraping {url}: {str(e)}\n{traceback.format_exc()}"
+        tb_str = traceback.format_exc()
+        return f"Error scraping or retrieving from {url}: {str(e)}\n{tb_str}"
+
 
-# --- Final Answer Tool ---
 class FinalAnswerInput(BaseModel):
-    answer: str = Field(description="The final, definitive answer.")
+    answer: str = Field(description="The final, definitive answer to the question.")
 
 @tool(args_schema=FinalAnswerInput)
 def final_answer_tool(answer: str) -> str:
     """
-    Call this ONLY when you have the final answer.
-    The answer must be EXACTLY what was asked for, with no extra text.
+    Call this tool ONLY when you have the final, definitive answer.
+    The 'answer' must be EXACTLY what was asked for, with no extra text.
     """
     if not isinstance(answer, str):
-        answer = str(answer)
+        try:
+            answer = str(answer)
+        except:
+            return "Error: Invalid input. 'answer' must be a string."
     
-    print(f"✅ FINAL ANSWER: {answer}")
+    print(f"--- FINAL ANSWER TOOL CALLED ---")
+    print(f"Answer: {answer}")
     return answer
 
+
 # =============================================================================
-# AGENT CLASS
+# FALLBACK PARSER
 # =============================================================================
-class GroqAgent:
-    """Agent powered by Groq's Llama 70B model."""
-    
-    def __init__(self, api_key: str):
-        self.api_key = api_key
-        
-        # Initialize LLM
-        self.llm = ChatGroq(
-            api_key=api_key,
-            model=Config.GROQ_MODEL,
-            temperature=0.1,
-            max_tokens=4096
-        )
-        
-        # Initialize RAG components
-        self.embeddings = HuggingFaceEmbeddings(
-            model_name=Config.EMBEDDING_MODEL
-        )
-        self.text_splitter = RecursiveCharacterTextSplitter(
-            chunk_size=Config.CHUNK_SIZE,
-            chunk_overlap=Config.CHUNK_OVERLAP
-        )
-        
-        # Attach RAG components to scraper tool
-        scrape_and_retrieve.embeddings = self.embeddings
-        scrape_and_retrieve.text_splitter = self.text_splitter
-        
-        # Define tools
-        self.tools = [
-            search_tool,
-            code_interpreter,
-            read_file,
-            write_file,
-            list_directory,
-            audio_transcription_tool,
-            get_youtube_transcript,
-            scrape_and_retrieve,
-            final_answer_tool
-        ]
-        
-        # Bind tools to LLM
-        self.llm_with_tools = self.llm.bind_tools(self.tools)
-        
-        # Build graph
-        self.graph = self._build_graph()
-    
-    def _build_graph(self) -> StateGraph:
-        """Build the LangGraph state graph."""
-        # TODO: Implement graph building logic
-        pass
-    
-    def run(self, user_input: str) -> str:
-        """Run the agent on user input."""
-        # TODO: Implement agent execution logic
-        pass
+def parse_tool_call_from_string(content: str, tools: List) -> List[ToolCall]:
+    """
+    Parses malformed tool call strings from an LLM response.
+    """
+    print(f"Original LLM content for fallback parsing:\n---\n{content}\n---")
+    tool_name = None
+    tool_input = None
+    cleaned_str = None
+
+    # STRATEGY 1: Try to parse <function(tool_name)>...{json_string}...
+    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_content = func_match.group(2)
+            
+            json_start_index = remaining_content.find('{')
+            if json_start_index != -1:
+                json_str = remaining_content[json_start_index:]
+                cleaned_str = json_str.strip()
+                cleaned_str = ''.join(c for c in cleaned_str if c.isprintable() or c in '\n\r\t')
+                cleaned_str = cleaned_str.strip().rstrip(',')
+                
+                tool_input = json.loads(cleaned_str)
+                print(f"🔧 Fallback (Format 1 - json.loads): Parsed tool call for '{tool_name}'")
+            else:
+                print(f"⚠️ Fallback (Format 1): Found <function> but no JSON blob.")
+                tool_name = None
+                
+        except json.JSONDecodeError as e:
+            print(f"⚠️ Fallback (Format 1): json.loads failed: {e}. Trying ast.literal_eval.")
+            try:
+                if cleaned_str:
+                    potential_input = ast.literal_eval(cleaned_str)
+                    if isinstance(potential_input, dict):
+                        tool_input = potential_input
+                        print(f"🔧 Fallback (Format 1 - ast.literal_eval): Parsed tool call for '{tool_name}'")
+                    else:
+                        print(f"⚠️ Fallback (Format 1): ast.literal_eval did not produce a dict.")
+                        tool_name = None
+                else:
+                    tool_name = None
+            except:
+                tool_name = None
+    
+    # FINAL VALIDATION
+    if tool_name and tool_input is not None:
+        if any(t.name == tool_name for t in tools):
+            tool_call = ToolCall(
+                name=tool_name,
+                args=tool_input,
+                id=str(uuid.uuid4())
+            )
+            print(f"✅ Successfully created tool call: {tool_name}")
+            return [tool_call]
+        else:
+            print(f"❌ Tool '{tool_name}' not found in available tools")
+            print(f"   Available: {[t.name for t in tools]}")
+    
+    print("❌ Failed to parse any valid tool call from content")
+    return []
+
 
 # =============================================================================
-# GRADIO INTERFACE
+# DEFINED TOOLS LIST
 # =============================================================================
-def create_interface():
-    """Create the Gradio interface."""
-    
-    def chat(message, history, groq_api_key):
-        if not groq_api_key:
-            return "Please provide a Groq API key"
+defined_tools = [
+    search_tool,
+    code_interpreter,
+    read_file,
+    write_file,
+    list_directory,
+    audio_transcription_tool,
+    get_youtube_transcript,
+    scrape_and_retrieve,
+    final_answer_tool
+]
+
+
+# =============================================================================
+# AGENT STATE
+# =============================================================================
+class AgentState(TypedDict):
+    messages: Annotated[List[AnyMessage], add_messages]
+    turn: int
+
+
+# =============================================================================
+# CONDITIONAL EDGE FUNCTION
+=============================================================================
+def should_continue(state: AgentState):
+    """
+    Decide whether to continue, call tools, or end.
+    """
+    last_message = state['messages'][-1]
+    current_turn = state.get('turn', 0)
+
+    # 1. Check for final_answer_tool
+    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":
+                print("--- Condition: final_answer_tool called, ending. ---")
+                return END
+
+    # 2. Check turn limit
+    if current_turn >= MAX_TURNS:
+        print(f"--- Condition: Max turns ({MAX_TURNS}) reached. Ending. ---")
+        return END
+
+    # 3. Route to tools if tool calls exist
+    if isinstance(last_message, AIMessage) and last_message.tool_calls:
+        print("--- Condition: Tools called, routing to tools node. ---")
+        return "tools"
+    
+    # 4. Loop prevention
+    if len(state['messages']) > 2 and isinstance(last_message, AIMessage) and isinstance(state['messages'][-2], AIMessage):
+        print(f"--- Condition: Detected 2+ consecutive AI messages (Turn {current_turn}). Ending to prevent loop. ---")
+        return END
+
+    # 5. Loop back to agent
+    print(f"--- Condition: No tool call (Turn {current_turn}). Continuing to agent. ---")
+    return "agent"
+
+
+# =============================================================================
+# BASIC AGENT CLASS
+# =============================================================================
+class BasicAgent:
+    def __init__(self):
+        print("BasicAgent (Single LLM) initializing...")
         
+        GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+        if not GROQ_API_KEY:
+            raise ValueError("GROQ_API_KEY environment variable is not set!")
+
+        self.tools = defined_tools
+        
+        # Initialize RAG Components
+        print("Initializing RAG components...")
         try:
-            agent = GroqAgent(api_key=groq_api_key)
-            response = agent.run(message)
-            return response
-        except Exception as e:
-            return f"Error: {str(e)}"
-    
-    with gr.Blocks(title="Groq Llama 70B Agent") as demo:
-        gr.Markdown("# 🚀 Groq Llama 70B Agentic Assistant")
-        gr.Markdown("Powered by Groq's ultra-fast Llama 70B model")
-        
-        with gr.Row():
-            api_key_input = gr.Textbox(
-                label="Groq API Key",
-                type="password",
-                placeholder="Enter your Groq API key..."
+            self.embeddings = HuggingFaceEmbeddings(
+                model_name="sentence-transformers/all-MiniLM-L6-v2",
+                model_kwargs={'device': 'cpu'}
+            )
+            self.text_splitter = RecursiveCharacterTextSplitter(
+                chunk_size=1000,
+                chunk_overlap=200
             )
+            
+            # Attach to scraper tool
+            scrape_and_retrieve.embeddings = self.embeddings
+            scrape_and_retrieve.text_splitter = self.text_splitter
+            
+            print("✅ RAG components initialized.")
+        except Exception as e:
+            print(f"⚠️ Warning: Could not initialize RAG components. Error: {e}")
+            self.embeddings = None
+            self.text_splitter = None
+        
+        # Build tool descriptions
+        tool_desc_list = []
+        for tool in self.tools:
+            if tool.args_schema:
+                schema = tool.args_schema.model_json_schema()
+                args_desc = []
+                for prop, details in schema.get('properties', {}).items():
+                    desc = details.get('description', '')
+                    args_desc.append(f"  - {prop}: {desc}")
+                args_str = "\n".join(args_desc)
+                desc = f"- {tool.name}:\n  {tool.description}\n  Args:\n{args_str}"
+            else:
+                desc = f"- {tool.name}: {tool.description}"
+            tool_desc_list.append(desc)
+        tool_descriptions = "\n".join(tool_desc_list)
+
+        # System Prompt
+        self.system_prompt = f"""You are a highly intelligent AI assistant for the GAIA benchmark.
+Your goal: Provide the EXACT answer in the EXACT format requested.
+
+**PROTOCOL:**
+1. **ANALYZE:** Read the question and history. What is the next logical step?
+2. **ACT:** Call ONE tool to get information or perform a calculation.
+3. **EVALUATE:** Look at the tool's output. Do you have the final answer?
+   - **If NO:** Go back to Step 1 and decide the *next* step.
+   - **If YES:** Call final_answer_tool immediately with the answer.
+
+**CRITICAL RULES:**
+- **TOOL USE:** You MUST use tools to find the answer. Do NOT use your own knowledge.
+- **FINAL ANSWER:** When you have the answer, use final_answer_tool. The 'answer' argument must be the answer ONLY (e.g., "42", "red, blue, green").
+- **JSON FORMAT:** All tool calls MUST be in this exact JSON format:
+  {{"name": "tool_name", "arguments": {{"key": "value"}}}}
+
+**EXAMPLE: CODE INTERPRETER**
+{{"name": "code_interpreter", "arguments": {{"code": "print(1 + 1)"}}}}
+
+**EXAMPLE: FINAL ANSWER**
+{{"name": "final_answer_tool", "arguments": {{"answer": "28"}}}}
+
+**TOOLS:**
+{tool_descriptions}
+
+**REMEMBER:** One step at a time. Use tools. Format JSON correctly.
+"""
+
+        print("Initializing Groq LLM...")
+        try:
+            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)
+            print("✅ Main LLM (llama-3.3-70b-versatile with tools) initialized.")
+
+        except Exception as e:
+            print(f"❌ Error initializing Groq: {e}")
+            raise
+        
+        # Agent Node
+        def agent_node(state: AgentState):
+            current_turn = state.get('turn', 0) + 1
+            print(f"\n{'='*60}")
+            print(f"AGENT TURN {current_turn}/{MAX_TURNS}")
+            print('='*60)
+            
+            if current_turn > MAX_TURNS:
+                return {"messages": [SystemMessage(content="Max turns reached.")]}
+
+            max_retries = 3
+            ai_message = None
+            for attempt in range(max_retries):
+                try:
+                    ai_message = self.llm_with_tools.invoke(state["messages"])
+                    break
+                except Exception as e:
+                    print(f"⚠️ LLM attempt {attempt+1}/{max_retries} failed: {e}")
+                    if attempt == max_retries - 1:
+                        ai_message = AIMessage(
+                            content=f"Error: LLM failed after {max_retries} attempts: {e}"
+                        )
+                    time.sleep(2 ** attempt)
+            
+            # Fallback Parsing Logic
+            if not ai_message.tool_calls and isinstance(ai_message.content, str) and ai_message.content.strip():
+                parsed_tool_calls = parse_tool_call_from_string(ai_message.content, self.tools)
+                if parsed_tool_calls:
+                    print("🔧 Fallback SUCCESS: Rebuilding tool call(s).")
+                    ai_message.tool_calls = parsed_tool_calls
+                    ai_message.content = ""
+                else:
+                    print(f"⚠️ Fallback FAILED: Could not parse any tool call from content:\n{ai_message.content[:200]}...")
+            
+            if ai_message.tool_calls:
+                print(f"🔧 Agent Tool Call: {ai_message.tool_calls[0]['name']}")
+            else:
+                print(f"💭 Agent Reasoning: {ai_message.content[:200]}...")
+            
+            return {"messages": [ai_message], "turn": current_turn}
+
+        # Tool Node
+        tool_node = ToolNode(self.tools)
+        
+        # Build Graph
+        print("Building Single-Agent graph...")
+        graph_builder = StateGraph(AgentState)
+        
+        graph_builder.add_node("agent", agent_node)
+        graph_builder.add_node("tools", tool_node)
         
-        chatbot = gr.Chatbot(label="Chat", height=500)
-        msg = gr.Textbox(
-            label="Message",
-            placeholder="Ask me anything...",
-            lines=2
+        graph_builder.add_edge(START, "agent")
+        
+        graph_builder.add_conditional_edges(
+            "agent",
+            should_continue,
+            {
+                "tools": "tools",
+                "agent": "agent",
+                END: END
+            }
         )
         
-        msg.submit(chat, [msg, chatbot, api_key_input], chatbot)
+        graph_builder.add_edge("tools", "agent")
+        
+        self.graph = graph_builder.compile()
+        print("✅ Single-Agent graph compiled successfully.")
+
+    def __call__(self, question: str) -> str:
+        print(f"\n--- Starting Agent Run for Question ---")
+        print(f"Agent received question (first 100 chars): {question[:100]}...")
+        
+        graph_input = {
+            "messages": [
+                SystemMessage(content=self.system_prompt),
+                HumanMessage(content=question)
+            ],
+            "turn": 0
+        }
+        
+               final_answer = "AGENT FAILED TO PRODUCE ANSWER"
+        try:
+            config = {"recursion_limit": MAX_TURNS + 5}
+            for event in self.graph.stream(graph_input, stream_mode="values", config=config):
+
+                if event.get('messages'): # Ensure messages exist
+                    last_message = event["messages"][-1]
+                else:
+                    continue # Skip if no messages yet
+                
+                # Check for final answer extraction
+                if isinstance(last_message, AIMessage) and last_message.tool_calls:
+                    if last_message.tool_calls[0].get("name") == "final_answer_tool":
+                        final_answer_args = last_message.tool_calls[0].get('args', {})
+                        if 'answer' in final_answer_args:
+                             final_answer = final_answer_args['answer']
+                             print(f"--- Final Answer Captured from tool call: '{final_answer}' ---")
+                             break 
+                        else:
+                             print(f"⚠️ Final Answer tool called without 'answer' argument: {final_answer_args}")
+                             final_answer = "ERROR: FINAL_ANSWER_TOOL CALLED WITHOUT ANSWER"
+                             break 
+
+                elif isinstance(last_message, ToolMessage):
+                    print(f"Tool Result ({last_message.tool_call_id}): {last_message.content[:500]}...")
+                elif isinstance(last_message, AIMessage) and not last_message.tool_calls:
+                    print(f"AI Message (Reasoning): {last_message.content[:500]}...")
+                elif isinstance(last_message, SystemMessage):
+                     print(f"System Message: {last_message.content[:500]}...")
+
+
+            # --- Final Answer Cleaning ---
+            cleaned_answer = str(final_answer).strip()
+            prefixes_to_remove = ["The answer is:", "Here is the answer:", "Based on the information:", "Final Answer:", "Answer:"]
+            original_cleaned = cleaned_answer
+            for prefix in prefixes_to_remove:
+                if cleaned_answer.lower().startswith(prefix.lower()):
+                    potential_answer = cleaned_answer[len(prefix):].strip()
+                    if potential_answer: 
+                        cleaned_answer = potential_answer
+                        break 
+            
+            cleaned_answer = remove_fences_simple(cleaned_answer)
+            if cleaned_answer.startswith("`") and cleaned_answer.endswith("`"):
+                    cleaned_answer = cleaned_answer[1:-1].strip()
+                    
+            print(f"Agent returning final answer (cleaned): '{cleaned_answer}'")
+            return cleaned_answer
+            
+        except Exception as e:
+            print(f"Error running agent graph: {e}")
+            tb_str = traceback.format_exc()
+            print(tb_str)
+            return f"AGENT GRAPH ERROR: {e}"
+
+
+# ====================================================
+# --- Global Agent Instantiation ---
+
+try:
+    agent = BasicAgent()
+    print("✅ Global BasicAgent instantiated successfully.")
+    if asr_pipeline is None: print("⚠️ Global ASR Pipeline failed load.")
+except Exception as e:
+    print(f"❌ FATAL: Could not instantiate global agent: {e}")
+    traceback.print_exc()
+    agent = None
+
+# ====================================================
+# --- (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)'}")
     
-    return demo
+    # 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})
+
+    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__":
-    demo = create_interface()
-    demo.launch()
+    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)
+