Update app.py

app.py

@@ -1,267 +1,305 @@
 import os
-import gradio as gr
-import requests
-import inspect
-import pandas as pd
 import io
-import contextlib
-import traceback
-from typing import TypedDict, Annotated, List, Optional
-import torch
 import json
 import re
-import uuid
-import time
-import ast
+import traceback
+import contextlib
+from typing import List, Optional
+from pathlib import Path
 
-# --- Pydantic Import ---
+import gradio as gr
+import pandas as pd
+import torch
 from pydantic import BaseModel, Field
 
-# --- Multimodal & Web Tool Imports ---
+# Multimodal & Web Tools
 from transformers import pipeline
 from youtube_transcript_api import YouTubeTranscriptApi
 from bs4 import BeautifulSoup
+import requests
 
-# --- LangChain & LangGraph Imports ---
+# LangChain & LangGraph
 from langgraph.graph.message import add_messages
-from langchain_core.messages import AnyMessage, HumanMessage, AIMessage, ToolMessage, SystemMessage, ToolCall
+from langchain_core.messages import HumanMessage, AIMessage, ToolMessage
 from langgraph.prebuilt import ToolNode
 from langgraph.graph import START, END, StateGraph
-from langchain_community.tools import DuckDuckGoSearchRun
 from langchain_core.tools import tool
-from langchain_google_genai import ChatGoogleGenerativeAI # <-- For Gemini
+from langchain_groq import ChatGroq  # <-- Groq integration
 
-# --- RAG Imports ---
+# 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
 
-# --- Constants ---
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-MAX_TURNS = 20
-MAX_MESSAGE_LENGTH = 8000
-
-# --- Initialize ASR Pipeline ---
-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
-
-# Global agent declaration for RAG tool access
-agent = None
-
-# ====================================================
-# --- Tool Definitions (Unchanged) ---
-
+# =============================================================================
+# 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
+
+# =============================================================================
+# 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()
+
+# =============================================================================
+# 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
+
+# =============================================================================
+# TOOL DEFINITIONS
+# =============================================================================
+
+# --- Search Tool ---
 class SearchInput(BaseModel):
     query: str = Field(description="The search query.")
 
 @tool(args_schema=SearchInput)
 def search_tool(query: str) -> str:
-    """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."
+    """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"
     
-    print(f"--- Calling Search Tool with query: {query} ---")
+    print(f"🔍 Searching: {query}")
     try:
         search = DuckDuckGoSearchRun()
         result = search.run(query)
-        if len(result) > MAX_MESSAGE_LENGTH:
-            result = result[:MAX_MESSAGE_LENGTH] + f"\n...[truncated, {len(result)} total chars]"
-        return result
+        return FileUtils.truncate_if_needed(result)
     except Exception as e:
-        return f"Error running search for '{query}': {str(e)}"
-
+        return f"Search error for '{query}': {str(e)}"
 
+# --- Code Interpreter Tool ---
 class CodeInput(BaseModel):
-    code: str = Field(description="The Python code to execute, which must include a print() statement for output.")
+    code: str = Field(description="Python code to execute (must include print() for output).")
 
 @tool(args_schema=CodeInput)
 def code_interpreter(code: str) -> str:
     """
-    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 (e.g., 'from collections import Counter') *inside* any function you define.
-    Available: pandas as pd, basic Python libraries.
+    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
     """
     if not isinstance(code, str):
-        return "Error: Invalid input. 'code' must be a string."
+        return "Error: 'code' must be a string"
     
-    # 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."
+    # Security validation
+    error = SecurityValidator.validate_code(code)
+    if error:
+        return f"Error: {error}"
     
-    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"💻 Executing code:\n{code}\n---")
     
-    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 in execution:\n{stderr}\n\nStdout (if any):\n{stdout}"
+            return f"Error:\n{stderr}\n\nOutput:\n{stdout}"
         
         if 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 f"Success:\n{FileUtils.truncate_if_needed(stdout)}"
         
-        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}"
-
+        return "Success: Code executed but produced no output.\n⚠️ Use print() to see results!"
+    
+    except Exception:
+        return f"Execution failed:\n{traceback.format_exc()}"
 
+# --- File Operations ---
 class ReadFileInput(BaseModel):
-    path: str = Field(description="The path to the file to read.")
+    path: str = Field(description="Path to the file to read.")
 
 @tool(args_schema=ReadFileInput)
 def read_file(path: str) -> str:
-    """Reads the content of a file at the specified path. Use this to examine uploaded files or files you've created."""
-    if not isinstance(path, str) or not path.strip():
-        return "Error: Invalid input. 'path' must be a non-empty string."
+    """Read the content of a file."""
+    if not path or not isinstance(path, str):
+        return "Error: 'path' must be a non-empty string"
+    
+    print(f"📖 Reading: {path}")
     
-    print(f"--- Calling Read File Tool: {path} ---")
+    file_path = FileUtils.find_file(path)
+    if not file_path:
+        cwd_files = list(Path.cwd().iterdir())
+        return (f"Error: File not found: '{path}'\n"
+                f"Files in current directory: {[f.name for f in cwd_files]}")
     
     try:
-        script_dir = os.getcwd()
-        safe_path = os.path.normpath(path)
-        
-        paths_to_try = [
-            os.path.join(script_dir, safe_path),
-            safe_path,
-            os.path.join(os.getcwd(), os.path.basename(safe_path))
-        ]
-        
-        full_path = None
-        for attempt_path in paths_to_try:
-            if os.path.exists(attempt_path):
-                full_path = attempt_path
-                break
-        
-        if not full_path:
-            cwd_files = os.listdir(".")
-            return (f"Error: File not found: '{path}'\n"
-                    f"Tried paths:\n" + "\n".join(f"  - {p}" for p in paths_to_try) + 
-                    f"\n\nFiles in current directory: {cwd_files}")
-        
-        print(f"Reading file: {full_path}")
-        _, ext = os.path.splitext(full_path)
-        
-        try:
-            with open(full_path, 'r', encoding='utf-8') as f:
-                content = f.read()
-            if len(content) > MAX_MESSAGE_LENGTH:
-                content = content[:MAX_MESSAGE_LENGTH] + f"\n...[truncated, {len(content)} total chars]"
-            return content
-            
-        except UnicodeDecodeError:
-            try:
-                with open(full_path, 'rb') as f:
-                    binary_content = f.read()
-                return f"File appears to be binary ({len(binary_content)} bytes). Cannot display as text.\nFile type: {ext}\nConsider using audio_transcription_tool for audio files."
-            except Exception as bin_e:
-                return f"Error: Could not read file as text or binary: {str(bin_e)}"
-        except Exception as read_e:
-            return f"Error reading file: {str(read_e)}"
-            
+        # Try reading as text
+        content = file_path.read_text(encoding='utf-8')
+        return FileUtils.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"Unexpected error accessing file '{path}': {str(e)}"
-
+        return f"Error reading file: {str(e)}"
 
 class WriteFileInput(BaseModel):
-    path: str = Field(description="The path of the file to write to.")
-    content: str = Field(description="The content to write into the file.")
+    path: str = Field(description="Path to write the file.")
+    content: str = Field(description="Content to write.")
 
 @tool(args_schema=WriteFileInput)
 def write_file(path: str, content: str) -> str:
-    """Writes content to a file at the specified path. Creates directories if needed."""
-    if not isinstance(path, str) or not path.strip():
-        return "Error: Invalid input. 'path' must be a non-empty string."
+    """Write content to a file."""
+    if not path or not isinstance(path, str):
+        return "Error: 'path' must be a non-empty string"
     if not isinstance(content, str):
-        return "Error: Invalid input. 'content' must be a string."
+        return "Error: 'content' must be a string"
     
-    print(f"--- Calling Write File Tool: {path} ---")
+    print(f"✍️ Writing to: {path}")
     
     try:
-        base_dir = os.getcwd()
-        full_path = os.path.join(base_dir, path)
-        
-        dir_path = os.path.dirname(full_path)
-        if dir_path:
-            os.makedirs(dir_path, exist_ok=True)
-        
-        with open(full_path, 'w', encoding='utf-8') as f:
-            f.write(content)
-        
-        return f"Successfully wrote {len(content)} characters to '{path}'."
-        
+        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}'"
     except Exception as e:
-        return f"Error writing file '{path}': {str(e)}"
-
+        return f"Error writing file: {str(e)}"
 
 class ListDirInput(BaseModel):
-    path: str = Field(description="The directory path to list.", default=".")
+    path: str = Field(description="Directory path to list.", default=".")
 
 @tool(args_schema=ListDirInput)
 def list_directory(path: str = ".") -> str:
-    """Lists the contents of a directory. Useful for finding available files."""
-    if not isinstance(path, str):
-        return "Error: Invalid input. 'path' must be a string."
-    
-    print(f"--- Calling List Directory Tool: {path} ---")
+    """List the contents of a directory."""
+    print(f"📁 Listing: {path}")
     
     try:
-        base_dir = os.getcwd()
-        full_path = os.path.join(base_dir, path) if path != "." else base_dir
+        dir_path = Path.cwd() / path if path != "." else Path.cwd()
         
-        if not os.path.isdir(full_path):
-            return f"Error: '{path}' is not a valid directory."
+        if not dir_path.is_dir():
+            return f"Error: '{path}' is not a valid directory"
         
-        items = os.listdir(full_path)
+        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 sorted(items):
-            item_path = os.path.join(full_path, item)
-            if os.path.isdir(item_path):
-                directories.append(f"📁 {item}/")
+        for item in items:
+            if item.is_dir():
+                directories.append(f"📁 {item.name}/")
             else:
-                size = os.path.getsize(item_path)
-                files.append(f"📄 {item} ({size} bytes)")
+                size = item.stat().st_size
+                files.append(f"📄 {item.name} ({size} bytes)")
         
         result = f"Contents of '{path}':\n\n"
         if directories:
@@ -270,72 +308,48 @@ def list_directory(path: str = ".") -> str:
             result += "Files:\n" + "\n".join(files)
         
         return result
-        
+    
     except Exception as e:
-        return f"Error listing directory '{path}': {str(e)}"
-
+        return f"Error listing directory: {str(e)}"
 
+# --- Audio Transcription ---
 class AudioInput(BaseModel):
-    file_path: str = Field(description="The file path of the audio to transcribe.")
+    file_path: str = Field(description="Path to the audio file.")
 
 @tool(args_schema=AudioInput)
 def audio_transcription_tool(file_path: str) -> str:
-    """Transcribes an audio file (mp3, wav, etc.) 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."
+    """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"
     
-    print(f"--- Calling Audio Transcription: {file_path} ---")
+    print(f"🎤 Transcribing: {file_path}")
     
-    if asr_pipeline is None:
-        return "Error: ASR pipeline is not available. Audio transcription cannot be performed."
+    audio_path = FileUtils.find_file(file_path)
+    if not audio_path:
+        return f"Error: Audio file not found: '{file_path}'"
     
     try:
-        script_dir = os.getcwd()
-        safe_path = os.path.normpath(file_path)
-        
-        paths_to_try = [
-            os.path.join(script_dir, safe_path),
-            safe_path,
-            os.path.join(os.getcwd(), os.path.basename(safe_path))
-        ]
-        
-        full_path = None
-        for attempt_path in paths_to_try:
-            if os.path.exists(attempt_path):
-                full_path = attempt_path
-                break
-        
-        if not full_path:
-            return f"Error: Audio file not found: '{file_path}'"
-        
-        print(f"Transcribing file: {full_path}")
-        transcription = asr_pipeline(full_path)
-        result_text = transcription.get("text", "")
-        
-        if not result_text:
-            return "Error: Transcription produced no text."
-        
-        if len(result_text) > MAX_MESSAGE_LENGTH:
-            result_text = result_text[:MAX_MESSAGE_LENGTH] + f"\n...[truncated]"
-        
-        return f"Transcription:\n{result_text}"
-        
+        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)}"
     except Exception as e:
-        return f"Error transcribing '{file_path}': {str(e)}"
-
+        return f"Error transcribing: {str(e)}"
 
+# --- YouTube Transcript ---
 class YoutubeInput(BaseModel):
-    video_url: str = Field(description="The URL of the YouTube video.")
+    video_url: str = Field(description="YouTube video URL.")
 
 @tool(args_schema=YoutubeInput)
 def get_youtube_transcript(video_url: str) -> str:
-    """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."
+    """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"
     
-    print(f"--- Calling YouTube Transcript: {video_url} ---")
+    print(f"📺 Fetching 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]
@@ -343,775 +357,203 @@ 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 YouTube video ID from '{video_url}'."
-            
+            return f"Error: Could not extract video ID from '{video_url}'"
+        
         transcript_list = YouTubeTranscriptApi.get_transcript(video_id)
         
         if not transcript_list:
-            return "Error: No transcript found for this video."
-            
-        full_transcript = " ".join([item["text"] for item in transcript_list])
-        
-        if len(full_transcript) > MAX_MESSAGE_LENGTH:
-            full_transcript = full_transcript[:MAX_MESSAGE_LENGTH] + f"\n...[truncated]"
-        
-        return f"YouTube Transcript:\n{full_transcript}"
+            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)}"
+    
     except Exception as e:
-        return f"Error getting transcript for '{video_url}': {str(e)}"
+        return f"Error getting transcript: {str(e)}"
 
-
-# --- NEW RAG-BASED SCRAPER TOOL ---
+# --- RAG-Based Web Scraper ---
 class ScrapeInput(BaseModel):
-    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.")
+    url: str = Field(description="URL to scrape (http:// or https://).")
+    query: str = Field(description="Question to answer from the page.")
 
 @tool(args_schema=ScrapeInput)
 def scrape_and_retrieve(url: str, query: str) -> str:
     """
-    Scrapes a webpage, chunks its content, and performs a RAG (Retrieval-Augmented Generation)
-    search to find the most relevant information related to a query.
-    Use this to "ask a question" of a webpage.
+    Scrape a webpage and use RAG to find relevant information.
     
     Args:
-        url (str): The URL to scrape (must start with http:// or https://).
-        query (str): The specific question to answer or information to find on the page.
+        url: The URL to scrape
+        query: The specific question to answer
     """
-    if not (url.lower().startswith(('http://', 'https://'))):
-        return "Error: Invalid URL. Must start with http:// or https://. Got: '{url}'"
+    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 to search the page content."
-    if not agent or not agent.embeddings or not agent.text_splitter:
-        return "Error: RAG components are not initialized. Cannot perform retrieval."
-
-    print(f"--- Calling RAG Scraper: {url} for query: {query} ---")
+        return "Error: A query is required"
+    
+    # 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}")
     
     try:
-        # 1. Scrape
+        # Scrape webpage
         headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+            '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()
         
         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 on the page."
+            return "Error: Could not find main content"
         
         text = main_content.get_text(separator='\n', strip=True)
-        text = '\n'.join(chunk for chunk in (line.strip() for line in text.splitlines()) if chunk)
+        text = '\n'.join(line.strip() for line in text.splitlines() if line.strip())
         
         if not text:
-            return "Error: Scraped content was empty."
+            return "Error: No content extracted"
         
-        # 2. Split
-        docs = agent.text_splitter.create_documents([text])
+        # Split text into chunks
+        docs = scrape_and_retrieve.text_splitter.create_documents([text])
         if not docs:
-            return "Error: Text could not be split into documents."
-            
-        # 3. Embed & Create Vector Store
-        db = FAISS.from_documents(docs, agent.embeddings)
+            return "Error: Could not split text into documents"
         
-        # 4. Retrieve
-        retriever = db.as_retriever(search_kwargs={"k": 5}) # Get top 5 chunks
+        # Create vector store and retrieve
+        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 on the page for that query."
-            
-        # 5. Format and Return
-        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}"
-
+            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}"
+    
     except Exception as e:
-        tb_str = traceback.format_exc()
-        return f"Error scraping or retrieving from {url}: {str(e)}\n{tb_str}"
-
+        return f"Error scraping {url}: {str(e)}\n{traceback.format_exc()}"
 
+# --- Final Answer Tool ---
 class FinalAnswerInput(BaseModel):
-    answer: str = Field(description="The final, definitive answer to the question.")
+    answer: str = Field(description="The final, definitive answer.")
 
 @tool(args_schema=FinalAnswerInput)
 def final_answer_tool(answer: str) -> str:
     """
-    Call this tool ONLY when you have the final, definitive answer.
-    The 'answer' must be EXACTLY what was asked for, with no extra text.
+    Call this ONLY when you have the final answer.
+    The answer must be EXACTLY what was asked for, with no extra text.
     """
     if not isinstance(answer, str):
-        try:
-            answer = str(answer)
-        except:
-            return "Error: Invalid input. 'answer' must be a string."
+        answer = str(answer)
     
-    print(f"--- FINAL ANSWER TOOL CALLED ---")
-    print(f"Answer: {answer}")
+    print(f"✅ FINAL ANSWER: {answer}")
     return answer
 
-
-# --- Helper Function ---
-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
-
-
-# --- *** ROBUST FALLBACK PARSER *** ---
-def parse_tool_call_from_string(content: str, tools: List) -> List[ToolCall]:
-    """
-    Parses malformed tool call strings (dribbled) 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 # For storing cleaned string before parsing
-
-    # STRATEGY 1: Try to parse <function(tool_name)>...{json_string}...
-    # This also handles <function=tool_name>...{json_string}...
-    func_match = re.search(
-        r"<function[(=]\s*([^)]+)\s*[)>](.*)", # <-- More robust regex
-        content,
-        re.DOTALL | re.IGNORECASE
-    )
+# =============================================================================
+# AGENT CLASS
+# =============================================================================
+class GroqAgent:
+    """Agent powered by Groq's Llama 70B model."""
     
-    if func_match:
-        try:
-            tool_name = func_match.group(1).strip().replace("'", "").replace('"', '') # Clean tool name
-            remaining_content = func_match.group(2)
-            
-            json_start_index = remaining_content.find('{')
-            if json_start_index != -1:
-                json_str = remaining_content[json_start_index:]
-                # --- Aggressive Cleaning ---
-                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 after cleaning: {e}. Trying ast.literal_eval.")
-            try:
-                # Secondary attempt with ast.literal_eval
-                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 (SyntaxError, ValueError) as ast_e: 
-                 print(f"⚠️ Fallback (Format 1): ast.literal_eval also failed: {ast_e}")
-                 tool_name = None 
-            except Exception as e_inner: 
-                print(f"⚠️ Fallback (Format 1): Unexpected error during ast.literal_eval: {e_inner}")
-                tool_name = None
-    
-    # ========================================================================
-    # STRATEGY 2: Try to parse bare JSON (if Strategy 1 failed)
-    # ========================================================================
-    if not tool_name:
-        # First, try to find markdown code fences
-        fence_match = re.search(r"```(?:json)?\s*(\{.+?\})\s*```", content, re.DOTALL)
-        
-        if fence_match:
-            json_str = fence_match.group(1)
-        else:
-            # Use balanced brace extraction for bare JSON
-            json_str = extract_json_with_balanced_braces(content)
+    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
+        )
         
-        if json_str:
-            try:
-                # Try strict JSON first
-                parsed_json = json.loads(json_str)
-                print(f"🔧 Fallback (Format 2 - json.loads): Parsed bare JSON.")
-            except json.JSONDecodeError as e:
-                print(f"⚠️ Fallback (Format 2): json.loads failed: {e}")
-                print(f"   Attempting ast.literal_eval...")
-                try:
-                    parsed_json = ast.literal_eval(json_str)
-                    if isinstance(parsed_json, dict):
-                        print(f"🔧 Fallback (Format 2 - ast.literal_eval): Parsed bare JSON.")
-                    else:
-                        print(f"⚠️ Fallback (Format 2): ast.literal_eval did not produce a dict.")
-                        parsed_json = None
-                except Exception as ast_e:
-                     print(f"⚠️ Fallback (Format 2): ast.literal_eval also failed: {ast_e}")
-                     parsed_json = None
-
-            # --- If either parser succeeded, try to infer tool name ---
-            if parsed_json and isinstance(parsed_json, dict):
-                tool_input = parsed_json
-                
-                # ------------------------------------------------
-                # Infer tool name based on JSON structure
-                # ORDER MATTERS: Most specific checks first!
-                # ------------------------------------------------
-                
-                # 1. OpenAI/LangChain standard format (name + arguments)
-                if "name" in parsed_json and "arguments" in parsed_json:
-                    tool_name = parsed_json.get("name")
-                    tool_input = parsed_json.get("arguments", {})
-                    print(f"🔧 Fallback (Format 2): Detected OpenAI-style format for '{tool_name}'")
-                
-                # 2. Custom format (tool + tool_input)
-                elif "tool" in parsed_json and "tool_input" in parsed_json:
-                    tool_name = parsed_json.get("tool")
-                    tool_input = parsed_json.get("tool_input", {})
-                    print(f"🔧 Fallback (Format 2): Detected custom format for '{tool_name}'")
-                
-                # 3. Specific tool signatures (most specific first)
-                elif "url" in parsed_json and "query" in parsed_json:
-                    tool_name = "scrape_and_retrieve"
-                    print(f"🔧 Fallback (Format 2): Inferred 'scrape_and_retrieve'")
-                
-                elif "path" in parsed_json and "content" in parsed_json:
-                    tool_name = "write_file"
-                    print(f"🔧 Fallback (Format 2): Inferred 'write_file'")
-                
-                elif "video_url" in parsed_json:
-                    tool_name = "get_youtube_transcript"
-                    print(f"🔧 Fallback (Format 2): Inferred 'get_youtube_transcript'")
-                
-                elif "file_path" in parsed_json:
-                    tool_name = "audio_transcription_tool"
-                    print(f"🔧 Fallback (Format 2): Inferred 'audio_transcription_tool'")
-                
-                elif "code" in parsed_json:
-                    tool_name = "code_interpreter"
-                    print(f"🔧 Fallback (Format 2): Inferred 'code_interpreter'")
-                
-                elif "answer" in parsed_json:
-                    tool_name = "final_answer_tool"
-                    print(f"🔧 Fallback (Format 2): Inferred 'final_answer_tool'")
-                
-                elif "query" in parsed_json:
-                    tool_name = "search_tool"
-                    print(f"🔧 Fallback (Format 2): Inferred 'search_tool'")
-                
-                elif "path" in parsed_json:
-                    tool_name = "read_file"
-                    print(f"🔧 Fallback (Format 2): Inferred 'read_file'")
-                
-                else:
-                    print(f"⚠️ Fallback (Format 2): Found JSON but couldn't infer tool name")
-                    print(f"   JSON keys: {list(parsed_json.keys())}")
-
-    # ========================================================================
-    # FINAL VALIDATION: Build and return ToolCall if parsing succeeded
-    # ========================================================================
-    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 []   
-
-# List of all tools
-defined_tools = [
-    search_tool,
-    code_interpreter,
-    read_file,
-    write_file,
-    list_directory,
-    audio_transcription_tool,
-    get_youtube_transcript,
-    scrape_and_retrieve,  # Replaced scrape_web_page
-    final_answer_tool
-]
-
-
-# --- *** NEW: Reverted AgentState *** ---
-class AgentState(TypedDict):
-    messages: Annotated[List[AnyMessage], add_messages]
-    turn: int
-
-
-# --- *** NEW: Reverted 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 (reasoning/planning step)
-    print(f"--- Condition: No tool call (Turn {current_turn}). Continuing to agent. ---")
-    return "agent"
-
-
-# ====================================================
-# --- *** NEW: Reverted Basic Agent Class *** ---
-class BasicAgent:
-    def __init__(self):
-        print("BasicAgent (Single LLM) initializing...")
+        # 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
+        )
         
-        # --- *** UPDATED: Check for Google API Key *** ---
-        GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
-        if not GEMINI_API_KEY:
-            raise ValueError("GEMINI_API_KEY environment variable is not set!")
-        # --- *** END UPDATE *** ---
-
-        self.tools = defined_tools
+        # 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
+        ]
         
-        # --- Initialize RAG Components ---
-        print("Initializing RAG components...")
-        try:
-            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
-            )
-            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
+        # Bind tools to LLM
+        self.llm_with_tools = self.llm.bind_tools(self.tools)
         
-        # 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 V7 (Simplified) ====================
-        # This prompt is for a single, powerful agent
-        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.
-"""
-
-    # --- *** UPDATED: Initialize Google Gemini LLM *** ---
-    print("Initializing Google Gemini LLM...")
-    try:
-        # --- Initialize ONE Powerful LLM for all tasks ---
-        self.planner_llm = ChatGoogleGenerativeAI(
-            model="gemini-2.0-flash-exp",  # ← Same model, different config
-            google_api_key=GEMINI_API_KEY,
-            temperature=0,
-            convert_system_message_to_human=True,
-            max_output_tokens=1024  # Planner needs less tokens
-        )
-        print("✅ Planner LLM (Gemini 2.0 Flash) initialized.")
-
-    except Exception as e:
-        print(f"❌ Error initializing Gemini: {e}")
-        raise
-    # --- *** END UPDATE *** ---
+        # Build graph
+        self.graph = self._build_graph()
     
-        # --- Node 1: The Agent ---
-        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)
-            
-            # Note: Max turns is also checked in should_continue, but good to have here
-            if current_turn > MAX_TURNS:
-                return {"messages": [SystemMessage(content="Max turns reached.")]}
+    def _build_graph(self) -> StateGraph:
+        """Build the LangGraph state graph."""
+        # TODO: Implement graph building logic
+        pass
     
-            max_retries = 3
-            ai_message = None
-            for attempt in range(max_retries):
-                try:
-                    # Call the single, powerful LLM
-                    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 = "" # Clear the text 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}
+    def run(self, user_input: str) -> str:
+        """Run the agent on user input."""
+        # TODO: Implement agent execution logic
+        pass
+
+# =============================================================================
+# GRADIO INTERFACE
+# =============================================================================
+def create_interface():
+    """Create the Gradio interface."""
     
-        # --- 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)
-        
-        graph_builder.add_edge(START, "agent")
-        
-        graph_builder.add_conditional_edges(
-            "agent",
-            should_continue, # Use the reverted conditional function
-            {
-                "tools": "tools",
-                "agent": "agent", # For loop prevention
-                END: END
-            }
-        )
-        
-        graph_builder.add_edge("tools", "agent") # Loop back to 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]}...")
-        
-        # --- Initialize Reverted AgentState (no plan) ---
-        graph_input = {
-            "messages": [
-                SystemMessage(content=self.system_prompt),
-                HumanMessage(content=question)
-            ],
-            "turn": 0 
-        }
+    def chat(message, history, groq_api_key):
+        if not groq_api_key:
+            return "Please provide a Groq API key"
         
-        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
-            
+            agent = GroqAgent(api_key=groq_api_key)
+            response = agent.run(message)
+            return response
         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 f"Error: {str(e)}"
     
-    # 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?"""
-        }
-    ]
+    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..."
+            )
+        
+        chatbot = gr.Chatbot(label="Chat", height=500)
+        msg = gr.Textbox(
+            label="Message",
+            placeholder="Ask me anything...",
+            lines=2
+        )
+        
+        msg.submit(chat, [msg, chatbot, api_key_input], chatbot)
     
-    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])
+    return demo
 
 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)
-
-
+    demo = create_interface()
+    demo.launch()