Modified files

agent.py

@@ -5,23 +5,34 @@ import urllib.parse as urlparse
 import io
 import contextlib
 import re
+import json
 from functools import lru_cache, wraps
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, List
+from datetime import datetime, timedelta
 
 from dotenv import load_dotenv
 from requests.exceptions import RequestException
+import requests
 import serpapi
 from llama_index.core import VectorStoreIndex, download_loader
 from llama_index.core.schema import Document
 from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, NoTranscriptFound
+import pandas as pd
+import numpy as np
 
-from smolagents import (CodeAgent, InferenceClientModel, ToolCallingAgent,
-                        WebSearchTool, WikipediaTool, tool)
+# --- Correctly import the specific tools from smolagents ---
+from smolagents import (
+    CodeAgent,
+    InferenceClientModel,
+    ToolCallingAgent,
+    GoogleSearchTool,
+    tool,
+)
 
 # --- Configuration and Setup ---
 
 def configure_logging():
-    """Sets up basic logging configuration."""
+    """Sets up detailed logging configuration for debugging."""
     logging.basicConfig(
         level=logging.INFO,
         format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
@@ -29,14 +40,24 @@ def configure_logging():
     )
 
 def load_api_keys():
-    """Loads API keys from a .env file."""
+    """Loads API keys from environment variables with fallback."""
     load_dotenv()
     keys = {
         'together': os.getenv('TOGETHER_API_KEY'),
         'serpapi': os.getenv('SERPAPI_API_KEY'),
+        'hf_token': os.getenv('HF_TOKEN') or os.getenv('HUGGINGFACE_HUB_TOKEN'),
     }
-    if not all(keys.values()):
-        raise ValueError("One or more API keys are missing. Please check your .env file.")
+    
+    # Log which keys are available (without revealing the actual keys)
+    for key_name, key_value in keys.items():
+        if key_value:
+            logging.info(f"✅ {key_name.upper()} API key loaded")
+        else:
+            logging.warning(f"⚠️ {key_name.upper()} API key not found")
+    
+    if not keys['together']:
+        raise ValueError("TOGETHER_API_KEY is required but not found in environment variables.")
+    
     return keys
 
 # --- Custom Exceptions ---
@@ -46,46 +67,67 @@ class SerpApiClientException(Exception):
 class YouTubeTranscriptApiError(Exception):
     pass
 
-# --- Decorators ---
+class DataProcessingError(Exception):
+    pass
+
+# --- Enhanced Decorators ---
 
 def retry(max_retries=3, initial_delay=1, backoff=2):
-    """A robust retry decorator with exponential backoff."""
+    """A robust retry decorator with exponential backoff and better error handling."""
     def decorator(func):
         @wraps(func)
         def wrapper(*args, **kwargs):
             delay = initial_delay
-            retryable_exceptions = (RequestException, SerpApiClientException, YouTubeTranscriptApiError, TranscriptsDisabled, NoTranscriptFound)
+            retryable_exceptions = (
+                RequestException, 
+                SerpApiClientException, 
+                YouTubeTranscriptApiError, 
+                TranscriptsDisabled, 
+                NoTranscriptFound,
+                ConnectionError,
+                TimeoutError
+            )
+            last_exception = None
+            
             for attempt in range(1, max_retries + 1):
                 try:
                     return func(*args, **kwargs)
                 except retryable_exceptions as e:
+                    last_exception = e
                     if attempt == max_retries:
                         logging.error(f"{func.__name__} failed after {attempt} attempts: {e}")
-                        raise
+                        break
                     logging.warning(f"Attempt {attempt} for {func.__name__} failed: {e}. Retrying in {delay} seconds...")
                     time.sleep(delay)
                     delay *= backoff
                 except Exception as e:
                     logging.error(f"{func.__name__} failed with a non-retryable error: {e}")
                     raise
+            
+            # If we get here, all retries failed
+            return f"Error after {max_retries} attempts: {last_exception}"
         return wrapper
     return decorator
 
-# --- Helper Functions ---
+# --- Enhanced Helper Functions ---
 
 def extract_video_id(url_or_id: str) -> Optional[str]:
-    """Extract YouTube video ID from various URL formats."""
+    """Extract YouTube video ID from various URL formats with better validation."""
     if not url_or_id:
         return None
     
-    # If it's already just an ID (11 characters, alphanumeric + underscore/dash)
+    # Clean the input
+    url_or_id = url_or_id.strip()
+    
+    # Check if it's already a video ID
     if re.match(r'^[a-zA-Z0-9_-]{11}$', url_or_id):
         return url_or_id
     
-    # Extract from various YouTube URL formats
+    # Various YouTube URL patterns
     patterns = [
         r'(?:youtube\.com/watch\?v=|youtu\.be/|youtube\.com/embed/)([a-zA-Z0-9_-]{11})',
         r'youtube\.com/.*[?&]v=([a-zA-Z0-9_-]{11})',
+        r'youtube-nocookie\.com/embed/([a-zA-Z0-9_-]{11})',
     ]
     
     for pattern in patterns:
@@ -95,386 +137,1809 @@ def extract_video_id(url_or_id: str) -> Optional[str]:
     
     return None
 
-def clean_search_results(results: Dict[str, Any]) -> str:
-    """Clean and format search results from SerpAPI."""
-    if not results:
-        return "No results found."
-    
-    formatted_results = []
-    
-    # Handle organic results
-    if organic_results := results.get('organic_results', []):
-        formatted_results.append("### Web Results")
-        for i, res in enumerate(organic_results[:5], 1):
-            title = res.get('title', 'N/A')
-            snippet = res.get('snippet', 'No description available.')
-            link = res.get('link', '#')
-            formatted_results.append(f"{i}. **{title}**\n   {snippet}\n   Source: {link}")
-    
-    # Handle knowledge graph
-    if knowledge_graph := results.get('knowledge_graph'):
-        formatted_results.append("\n### Knowledge Graph")
-        if title := knowledge_graph.get('title'):
-            formatted_results.append(f"**{title}**")
-        if description := knowledge_graph.get('description'):
-            formatted_results.append(f"{description}")
-    
-    # Handle answer box
-    if answer_box := results.get('answer_box'):
-        formatted_results.append("\n### Direct Answer")
-        if answer := answer_box.get('answer'):
-            formatted_results.append(f"{answer}")
-        elif snippet := answer_box.get('snippet'):
-            formatted_results.append(f"{snippet}")
-    
-    return "\n\n".join(formatted_results) if formatted_results else "No relevant results found."
-
-# --- Main Agent Initialization ---
+def clean_text_output(text: str) -> str:
+    """Clean and normalize text output for better processing."""
+    if not text:
+        return ""
+    
+    # Remove excessive whitespace
+    text = re.sub(r'\s+', ' ', text.strip())
+    
+    # Remove common prefixes that might interfere with answer extraction
+    prefixes_to_remove = [
+        "Based on the search results,",
+        "According to the information,",
+        "The answer is:",
+        "Result:",
+    ]
+    
+    for prefix in prefixes_to_remove:
+        if text.lower().startswith(prefix.lower()):
+            text = text[len(prefix):].strip()
+    
+    return text
+
+def extract_numerical_answer(text: str) -> Optional[str]:
+    """Extract numerical answers from text with better precision."""
+    # Look for standalone numbers
+    number_patterns = [
+        r'\b(\d+\.?\d*)\b',  # Decimal numbers
+        r'\b(\d+/\d+)\b',    # Fractions
+        r'\b(\d+,\d+(?:,\d+)*)\b',  # Numbers with commas
+    ]
+    
+    for pattern in number_patterns:
+        matches = re.findall(pattern, text)
+        if matches:
+            return matches[-1]  # Return the last match (often the final answer)
+    
+    return None
+
+# --- Answer Extraction Functions ---
+
+def extract_final_answer(response: str) -> str:
+    """
+    Extract the final answer from agent response following GAIA format requirements.
+    Looks for 'FINAL ANSWER:' pattern and extracts the answer after it.
+    """
+    if not response:
+        return ""
+    
+    # Look for FINAL ANSWER pattern (case insensitive)
+    final_answer_pattern = re.compile(r'FINAL\s+ANSWER\s*:\s*(.+?)(?:\n|$)', re.IGNORECASE | re.DOTALL)
+    match = final_answer_pattern.search(response)
+    
+    if match:
+        answer = match.group(1).strip()
+        # Clean up common formatting issues
+        answer = re.sub(r'\s+', ' ', answer)  # Normalize whitespace
+        answer = answer.rstrip('.')  # Remove trailing periods
+        return answer
+    
+    # Fallback: if no FINAL ANSWER found, try to extract from end of response
+    lines = response.strip().split('\n')
+    if lines:
+        last_line = lines[-1].strip()
+        # Remove common prefixes
+        for prefix in ['Answer:', 'Result:', 'The answer is:', 'Final result:']:
+            if last_line.lower().startswith(prefix.lower()):
+                return last_line[len(prefix):].strip()
+        return last_line
+    
+    return response.strip()
+
+def normalize_answer_format(answer: str, expected_type: str = "auto") -> str:
+    """
+    Normalize answer format according to GAIA requirements.
+    Args:
+        answer: The extracted answer
+        expected_type: "number", "string", "list", or "auto" to detect
+    """
+    if not answer:
+        return answer
+    
+    answer = answer.strip()
+    
+    # Auto-detect type if not specified
+    if expected_type == "auto":
+        # Try to detect a list (comma-separated, at least two elements)
+        if ',' in answer and len([x for x in answer.split(',') if x.strip()]) > 1:
+            expected_type = "list"
+        # Try to detect a number (integer or float, possibly negative)
+        elif re.fullmatch(r'[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?', answer.replace(',', '').strip()):
+            expected_type = "number"
+        # Otherwise, treat as string
+        else:
+            expected_type = "string"
+        
 
 def initialize_agent():
     """
-    Initializes a multi-disciplinary agent optimized for GAIA benchmark questions.
+    Initializes an enhanced multi-disciplinary agent optimized for GAIA benchmark questions.
     """
     configure_logging()
-    api_keys = load_api_keys()
+    logging.info("🚀 Starting GAIA agent initialization...")
     
-    # --- Caching Layer for LlamaIndex ---
-    @lru_cache(maxsize=32)
-    @retry()
+    try:
+        api_keys = load_api_keys()
+    except Exception as e:
+        logging.error(f"Failed to load API keys: {e}")
+        return None
+    
+    # --- Enhanced Caching Layer for LlamaIndex ---
+    @lru_cache(maxsize=64)  # Increased cache size
+    @retry(max_retries=3)
     def get_webpage_index(url: str) -> VectorStoreIndex:
-        """Create a searchable index from a webpage."""
-        logging.info(f"Indexing webpage: {url}")
+        logging.info(f"📄 Indexing webpage: {url}")
         try:
             loader_cls = download_loader("BeautifulSoupWebReader")
             loader = loader_cls()
             docs = loader.load_data(urls=[url])
             if not docs:
                 raise ValueError(f"No content could be extracted from {url}")
-            return VectorStoreIndex.from_documents(docs)
+            
+            # Filter out very short documents
+            valid_docs = [doc for doc in docs if len(doc.text.strip()) > 50]
+            if not valid_docs:
+                raise ValueError(f"No substantial content found in {url}")
+                
+            return VectorStoreIndex.from_documents(valid_docs)
         except Exception as e:
-            logging.error(f"Failed to index webpage {url}: {e}")
+            logging.error(f"Error indexing webpage {url}: {e}")
             raise
 
     @lru_cache(maxsize=32)
-    @retry()
+    @retry(max_retries=3)
     def get_youtube_index(video_id: str) -> VectorStoreIndex:
-        """Create a searchable index from a YouTube video transcript."""
-        logging.info(f"Indexing YouTube video: {video_id}")
+        logging.info(f"🎥 Indexing YouTube video: {video_id}")
         try:
-            # Try to get transcript in English first, then any available language
+            # Try to get English transcript first
             try:
                 transcript = YouTubeTranscriptApi.get_transcript(video_id, languages=['en'])
             except (TranscriptsDisabled, NoTranscriptFound):
-                # Try to get any available transcript
+                # Try auto-generated or any available transcript
                 transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
-                transcript = transcript_list.find_transcript(['en']).fetch()
+                try:
+                    transcript = transcript_list.find_transcript(['en']).fetch()
+                except:
+                    # Get any available transcript
+                    available_transcripts = list(transcript_list)
+                    if not available_transcripts:
+                        raise YouTubeTranscriptApiError(f"No transcripts available for video {video_id}")
+                    transcript = available_transcripts[0].fetch()
             
             if not transcript:
                 raise YouTubeTranscriptApiError(f"No transcript available for video {video_id}")
             
-            text = ' '.join([entry['text'] for entry in transcript])
-            if not text.strip():
+            # Combine transcript with timestamps for better context
+            text_segments = []
+            for entry in transcript:
+                timestamp = int(entry.get('start', 0))
+                text = entry.get('text', '').strip()
+                if text:
+                    text_segments.append(f"[{timestamp}s] {text}")
+            
+            full_text = ' '.join(text_segments)
+            if not full_text.strip():
                 raise YouTubeTranscriptApiError(f"Empty transcript for video {video_id}")
             
-            doc = Document(text=text, doc_id=f"youtube_{video_id}")
+            doc = Document(
+                text=full_text, 
+                doc_id=f"youtube_{video_id}",
+                metadata={"source": f"https://youtube.com/watch?v={video_id}"}
+            )
             return VectorStoreIndex.from_documents([doc])
+            
         except Exception as e:
-            logging.error(f"Failed to index YouTube video {video_id}: {e}")
-            raise YouTubeTranscriptApiError(f"Could not process YouTube video {video_id}: {e}")
+            logging.error(f"Error indexing YouTube video {video_id}: {e}")
+            raise
 
     # --- Enhanced Tool Definitions ---
 
     @tool
-    @retry()
-    def google_search(query: str) -> str:
-        """
-        Perform a comprehensive Google search with enhanced result formatting.
-        Use for general knowledge questions, current events, or when you need factual information.
-
-        Args:
-            query (str): The search query
-        """
-        try:
-            client = serpapi.Client(api_key=api_keys['serpapi'])
-            results = client.search(q=query, engine="google", num=10)
-            return clean_search_results(results)
-        except Exception as e:
-            logging.error(f"Google search failed for query '{query}': {e}")
-            return f"Search failed: {e}"
-
-    @tool
-    def query_webpage(url: str, query: str) -> str:
+    def advanced_web_query(url: str, query: str) -> str:
         """
-        Extract specific information from a webpage by asking a targeted question.
-        Best for when you have a specific URL and need detailed information from it.
-
+        Extract specific information from a webpage using advanced querying.
+        Handles various content types and provides detailed responses.
         Args:
-            url (str): The complete URL of the webpage
-            query (str): Specific question about the webpage content
+            url: The webpage URL to analyze
+            query: Specific question to ask about the content
         """
         try:
             if not url.startswith(('http://', 'https://')):
                 url = 'https://' + url
             
+            logging.info(f"🔍 Querying webpage: {url} with query: {query}")
             index = get_webpage_index(url)
             query_engine = index.as_query_engine(
-                similarity_top_k=5,
-                response_mode="tree_summarize"
+                similarity_top_k=8,  # Increased for better coverage
+                response_mode="tree_summarize",
+                verbose=True
             )
+            
             response = query_engine.query(query)
-            return str(response)
+            result = clean_text_output(str(response))
+            
+            # If the response seems incomplete, try a broader query
+            if len(result) < 50 and "not found" not in result.lower():
+                broader_query = f"Information about {query.split()[-1] if query.split() else query}"
+                broader_response = query_engine.query(broader_query)
+                broader_result = clean_text_output(str(broader_response))
+                if len(broader_result) > len(result):
+                    result = broader_result
+            
+            return result
+            
         except Exception as e:
             error_msg = f"Error querying webpage {url}: {e}"
             logging.error(error_msg)
             return error_msg
 
     @tool
-    def query_youtube_video(video_url_or_id: str, query: str) -> str:
+    def enhanced_youtube_query(video_url_or_id: str, query: str) -> str:
         """
-        Extract information from YouTube video transcripts by asking specific questions.
-        Handles various YouTube URL formats and video IDs.
-
+        Extract information from YouTube video transcripts with enhanced processing.
+        Handles timestamps and provides contextual responses.
         Args:
-            video_url_or_id (str): YouTube URL or video ID
-            query (str): Specific question about the video content
+            video_url_or_id: YouTube URL or video ID
+            query: Specific question about the video content
         """
         try:
             video_id = extract_video_id(video_url_or_id)
             if not video_id:
                 return f"Error: Could not extract valid YouTube video ID from '{video_url_or_id}'"
             
+            logging.info(f"🎬 Querying YouTube video: {video_id} with query: {query}")
             index = get_youtube_index(video_id)
             query_engine = index.as_query_engine(
-                similarity_top_k=5,
-                response_mode="tree_summarize"
+                similarity_top_k=6,
+                response_mode="tree_summarize",
+                verbose=True
             )
+            
             response = query_engine.query(query)
-            return str(response)
+            result = clean_text_output(str(response))
+            
+            return result
+            
         except YouTubeTranscriptApiError as e:
-            return f"YouTube transcript error for {video_url_or_id}: {e}"
+            error_msg = f"YouTube transcript error for {video_url_or_id}: {e}"
+            logging.error(error_msg)
+            return error_msg
         except Exception as e:
             error_msg = f"Error querying YouTube video {video_url_or_id}: {e}"
             logging.error(error_msg)
             return error_msg
 
     @tool
-    def run_python_code(code: str) -> str:
+    def enhanced_python_execution(code: str) -> str:
         """
-        Execute Python code in a safe environment and return the output.
-        Perfect for calculations, data processing, and algorithmic problems.
-        Available modules: math, datetime, json, re, collections, itertools, numpy, pandas
-
+        Execute Python code with enhanced capabilities and error handling.
+        Includes mathematical, data processing, and web scraping capabilities.
         Args:
-            code (str): Python code to execute
-        """
-        # Create a safe execution environment with useful modules
-        safe_globals = {
-            '__builtins__': {
-                'print': print, 'len': len, 'range': range, 'enumerate': enumerate,
-                'zip': zip, 'map': map, 'filter': filter, 'sum': sum, 'max': max, 'min': min,
-                'abs': abs, 'round': round, 'sorted': sorted, 'reversed': reversed,
-                'int': int, 'float': float, 'str': str, 'bool': bool, 'list': list,
-                'dict': dict, 'set': set, 'tuple': tuple, 'type': type, 'isinstance': isinstance,
-            }
-        }
-        
-        # Add safe imports
+            code: Python code to execute
+        """
+        # Expanded safe globals with more libraries
+        safe_globals = {}
         try:
-            import math
-            import datetime
-            import json
-            import re
-            import collections
-            import itertools
+            # Basic Python modules
+            import math, datetime, json, re, collections, itertools, random
+            from fractions import Fraction
+            from decimal import Decimal
+            import statistics
+            
             safe_globals.update({
                 'math': math, 'datetime': datetime, 'json': json, 're': re,
-                'collections': collections, 'itertools': itertools
+                'collections': collections, 'itertools': itertools, 'random': random,
+                'Fraction': Fraction, 'Decimal': Decimal, 'statistics': statistics
             })
             
-            # Try to import numpy and pandas if available
+            # Scientific computing
             try:
                 import numpy as np
                 safe_globals['np'] = np
                 safe_globals['numpy'] = np
             except ImportError:
-                pass
+                logging.warning("NumPy not available")
             
             try:
                 import pandas as pd
                 safe_globals['pd'] = pd
                 safe_globals['pandas'] = pd
             except ImportError:
-                pass
+                logging.warning("Pandas not available")
+            
+            # Web requests for data fetching
+            try:
+                import requests
+                safe_globals['requests'] = requests
+            except ImportError:
+                logging.warning("Requests not available")
                 
         except ImportError as e:
-            logging.warning(f"Some modules not available for code execution: {e}")
+            logging.warning(f"Some modules not available: {e}")
+        
+        # Capture both stdout and stderr
+        stdout_capture = io.StringIO()
+        stderr_capture = io.StringIO()
         
-        output = io.StringIO()
         try:
-            with contextlib.redirect_stdout(output):
-                exec(code, safe_globals)
-            result = output.getvalue()
-            return result if result else "Code executed successfully (no output)"
+            logging.info(f"🐍 Executing Python code: {code[:100]}...")
+            
+            with contextlib.redirect_stdout(stdout_capture), contextlib.redirect_stderr(stderr_capture):
+                # Use exec with restricted builtins for safety
+                restricted_builtins = {
+                    'abs': abs, 'all': all, 'any': any, 'bin': bin, 'bool': bool,
+                    'chr': chr, 'dict': dict, 'dir': dir, 'divmod': divmod,
+                    'enumerate': enumerate, 'filter': filter, 'float': float,
+                    'format': format, 'hex': hex, 'int': int, 'len': len,
+                    'list': list, 'map': map, 'max': max, 'min': min, 'oct': oct,
+                    'ord': ord, 'pow': pow, 'print': print, 'range': range,
+                    'repr': repr, 'reversed': reversed, 'round': round,
+                    'set': set, 'sorted': sorted, 'str': str, 'sum': sum,
+                    'tuple': tuple, 'type': type, 'zip': zip,
+                }
+                
+                exec(code, {"__builtins__": restricted_builtins}, safe_globals)
+            
+            stdout_result = stdout_capture.getvalue()
+            stderr_result = stderr_capture.getvalue()
+            
+            # Combine outputs
+            result_parts = []
+            if stdout_result.strip():
+                result_parts.append(stdout_result.strip())
+            if stderr_result.strip():
+                result_parts.append(f"Warnings/Errors: {stderr_result.strip()}")
+            
+            if result_parts:
+                return '\n'.join(result_parts)
+            else:
+                return "Code executed successfully (no output)"
+                
         except Exception as e:
-            return f"Code execution error: {e}"
+            error_msg = f"Code execution error: {e}"
+            stderr_result = stderr_capture.getvalue()
+            if stderr_result.strip():
+                error_msg += f"\nAdditional details: {stderr_result.strip()}"
+            logging.error(error_msg)
+            return error_msg
 
     @tool
-    def advanced_search(query: str, search_type: str = "general") -> str:
+    def enhanced_wikipedia_search(query: str, detailed: bool = True) -> str:
         """
-        Perform specialized searches for different types of information.
-        
+        Search Wikipedia with enhanced content extraction and error handling.
+        Args:
+            query: Search term
+            detailed: Whether to return detailed information or just summary
+        """
+        try:
+            import wikipedia
+            wikipedia.set_lang("en")
+            wikipedia.set_rate_limiting(True)
+            
+            logging.info(f"📚 Searching Wikipedia for: {query}")
+            
+            # Handle disambiguation and search suggestions
+            try:
+                page = wikipedia.page(query, auto_suggest=True)
+            except wikipedia.DisambiguationError as e:
+                # Take the first option from disambiguation
+                if e.options:
+                    page = wikipedia.page(e.options[0])
+                else:
+                    return f"Wikipedia disambiguation error for '{query}': {e}"
+            except wikipedia.PageError:
+                # Try searching if direct page lookup fails
+                search_results = wikipedia.search(query, results=3)
+                if search_results:
+                    page = wikipedia.page(search_results[0])
+                else:
+                    return f"No Wikipedia results found for '{query}'"
+            
+            if detailed:
+                # Get more comprehensive content
+                content_sections = []
+                content_sections.append(f"**{page.title}**")
+                content_sections.append(f"Summary: {page.summary}")
+                
+                # Add first few sections if available
+                if hasattr(page, 'content') and page.content:
+                    sections = page.content.split('\n\n')[:3]  # First 3 paragraphs
+                    for section in sections:
+                        if section.strip() and len(section) > 50:
+                            content_sections.append(section.strip())
+                
+                content_sections.append(f"Source: {page.url}")
+                return '\n\n'.join(content_sections)
+            else:
+                return f"**{page.title}**\n\n{page.summary}\n\nSource: {page.url}"
+                
+        except ImportError:
+            return "Wikipedia library not installed. Cannot perform search."
+        except Exception as e:
+            error_msg = f"Wikipedia search error for '{query}': {e}"
+            logging.error(error_msg)
+            return error_msg
+
+    @tool
+    def data_processing_tool(data_description: str, operation: str) -> str:
+        """
+        Process and analyze data based on descriptions and operations.
+        Useful for mathematical calculations, data analysis, and structured data processing.
         Args:
-            query (str): Search query
-            search_type (str): Type of search - "academic", "news", "images", "general"
+            data_description: Description of the data or data source
+            operation: The operation to perform (calculate, analyze, extract, etc.)
         """
         try:
-            client = serpapi.Client(api_key=api_keys['serpapi'])
+            logging.info(f"📊 Processing data: {data_description} | Operation: {operation}")
             
-            search_params = {"q": query, "num": 8}
+            # This tool is designed to work with the Python execution tool
+            # for complex data processing tasks
+            code_template = f"""
+# Data processing task: {operation}
+# Data description: {data_description}
+
+# Add your specific data processing logic here
+# This is a template - specific implementation depends on the data and operation
+
+print("Data processing task initiated")
+print(f"Description: {data_description}")
+print(f"Operation: {operation}")
+
+# Example operations:
+if "calculate" in "{operation}".lower():
+    print("Performing calculation...")
+elif "analyze" in "{operation}".lower():
+    print("Performing analysis...")
+elif "extract" in "{operation}".lower():
+    print("Extracting information...")
+
+print("Task completed - use enhanced_python_execution for specific calculations")
+"""
             
-            if search_type == "academic":
-                results = client.search(engine="google_scholar", **search_params)
-            elif search_type == "news":
-                search_params["tbm"] = "nws"
-                results = client.search(engine="google", **search_params)
-            else:  # general
-                results = client.search(engine="google", **search_params)
+            return enhanced_python_execution(code_template)
             
-            return clean_search_results(results)
         except Exception as e:
-            return f"Advanced search failed: {e}"
+            error_msg = f"Data processing error: {e}"
+            logging.error(error_msg)
+            return error_msg
 
     # --- Model and Agent Setup ---
     
     try:
+        # Use a more capable model for better performance
         model = InferenceClientModel(
-            model_id="Qwen/Qwen2.5-7B-Instruct",
+            model_id="meta-llama/Llama-3.1-70B-Instruct-Turbo",  # Upgraded model
             token=api_keys['together'],
             provider="together"
         )
-        logging.info("Model loaded successfully.")
+        logging.info("✅ Model loaded successfully")
     except Exception as e:
-        logging.error(f"Failed to load model: {e}")
-        raise
+        logging.error(f"Failed to load primary model, falling back: {e}")
+        try:
+            # Fallback model
+            model = InferenceClientModel(
+                model_id="Qwen/Qwen2.5-7B-Instruct",
+                token=api_keys['together'],
+                provider="together"
+            )
+            logging.info("✅ Fallback model loaded successfully")
+        except Exception as e2:
+            logging.error(f"Failed to load fallback model: {e2}")
+            raise
+
+    # Configure Google Search tool
+    google_search_tool = None
+    if api_keys['serpapi']:
+        try:
+            google_search_tool = GoogleSearchTool(
+                provider='serpapi', 
+                serpapi_api_key=api_keys['serpapi']
+            )
+            logging.info("✅ Google Search tool configured")
+        except Exception as e:
+            logging.warning(f"Failed to configure Google Search tool: {e}")
+
+    # Prepare tools list
+    tools_list = [
+        enhanced_wikipedia_search,
+        advanced_web_query,
+        enhanced_youtube_query,
+        enhanced_python_execution,
+        data_processing_tool,
+    ]
+    
+    if google_search_tool:
+        tools_list.insert(0, google_search_tool)
 
     # Specialized worker agent with comprehensive toolset
     worker_agent = ToolCallingAgent(
-        tools=[
-            google_search,
-            advanced_search,
-            query_webpage,
-            query_youtube_video,
-            run_python_code,
-            WikipediaTool(),
-        ],
+        tools=tools_list,
         model=model,
-        max_steps=6,  # Allow more steps for complex tasks
+        max_steps=8,  # Increased for complex tasks
         name="gaia_specialist",
-        description="Expert agent for GAIA benchmark tasks: web research, document analysis, video processing, and code execution."
+        description="Advanced specialist agent for GAIA benchmark: web research, document analysis, video processing, mathematical computation, and data analysis."
     )
 
-    # Strategic manager agent
+    # Enhanced strategic manager agent
+    manager_tools = []
+    if google_search_tool:
+        manager_tools.append(google_search_tool)
+
     manager = CodeAgent(
         model=model,
         managed_agents=[worker_agent],
-        tools=[WebSearchTool()],
-        additional_authorized_imports=[
-            "time", "numpy", "pandas", "requests", "serpapi", "llama_index", 
-            "beautifulsoup4", "markdownify", "lxml", "json", "urllib.parse", 
-            "youtube_transcript_api", "together", "math", "datetime", "re", 
-            "collections", "itertools"
-        ],
-        instructions="""You are an expert AI system designed to excel at the GAIA benchmark. Your mission is to provide precise, accurate answers to complex questions spanning multiple domains.
+        tools=manager_tools,
+        instructions="""You are a general AI assistant designed for the GAIA benchmark. Your mission is to provide precise, accurate answers to complex questions that require deep reasoning and analysis.
+
+**CRITICAL: ANSWER FORMAT REQUIREMENT**
+You MUST finish your response with: FINAL ANSWER: [YOUR FINAL ANSWER]
+
+YOUR FINAL ANSWER formatting rules:
+- For NUMBERS: No commas, no units (like $ or %), no additional text
+  Example: "FINAL ANSWER: 42" NOT "FINAL ANSWER: 42 dollars" or "FINAL ANSWER: $42"
+- For STRINGS: No articles (a, an, the), no abbreviations, write digits in plain text
+  Example: "FINAL ANSWER: New York City" NOT "FINAL ANSWER: NYC" or "FINAL ANSWER: The Big Apple"
+- For LISTS: Comma-separated, apply above rules to each element
+  Example: "FINAL ANSWER: Paris, London, Berlin" or "FINAL ANSWER: 1.5, 2.3, 4.7"
 
 **STRATEGIC APPROACH:**
 
-1. **QUESTION ANALYSIS:**
-   - Parse the question carefully to identify: required output format, key constraints, domain (science, history, current events, etc.)
-   - Determine the information sources needed: web search, specific websites, videos, calculations, or combinations
-
-2. **EXECUTION STRATEGY:**
-   
-   **Direct Web Search (for simple lookups):**
-   ```python
-   results = WebSearchTool(query="your search query")
-   print(results)
-   ```
-   
-   **Delegate to Specialist Agent (for complex tasks):**
-   ```python
-   answer = gaia_specialist.run("Detailed task description with specific requirements")
-   print(answer)
-   ```
-   
-   The specialist can:
-   - `google_search`: Comprehensive web searches with rich formatting
-   - `advanced_search`: Academic papers, news, specialized searches  
-   - `query_webpage`: Deep analysis of specific URLs
-   - `query_youtube_video`: Extract information from video transcripts
-   - `run_python_code`: Mathematical calculations, data processing, algorithms
-   - `wikipedia_search`: Encyclopedic information
-
-3. **ANSWER FORMATTING:**
-   - Provide ONLY the final answer in the exact format requested
-   - No explanations, prefixes, or extra text unless specifically asked
-   - For numerical answers: provide just the number
-   - For yes/no questions: provide just "Yes" or "No"
-   - For lists: follow the specified format exactly
-
-**EXAMPLES:**
-
-Question: "What is 15! (15 factorial)?"
-Strategy: Mathematical calculation → delegate to specialist
+1. **ANALYZE THE QUESTION**: Determine what type of answer is expected (number, string, or list)
+
+2. **DECOMPOSE THE PROBLEM**: Break complex questions into sub-problems:
+   - Identify required information sources
+   - Plan tool usage sequence
+   - Consider verification steps
+
+3. **TOOL SELECTION**:
+   - Use GoogleSearchTool for current information and general web queries
+   - Delegate to gaia_specialist for complex multi-tool analysis:
+     * advanced_web_query: Deep webpage content analysis
+     * enhanced_youtube_query: Video transcript analysis
+     * enhanced_python_execution: Mathematical calculations and data processing
+     * enhanced_wikipedia_search: Encyclopedic knowledge
+     * data_processing_tool: Structured data analysis
+
+4. **VERIFICATION**: Cross-check critical information and validate calculations
+
+**DELEGATION EXAMPLES**:
+
+Simple queries:
 ```python
-result = gaia_specialist.run("Calculate 15 factorial using Python")
-print(result)
+# Direct search for current information
+result = search_tool.run("population Tokyo 2024")
+# Extract and format the answer properly
 ```
 
-Question: "What is the capital of the country where Mount Everest is located?"
-Strategy: Multi-step reasoning → delegate to specialist  
+Complex analysis:
 ```python
-answer = gaia_specialist.run("Find the country where Mount Everest is located, then identify its capital city")
-print(answer)
+# Delegate comprehensive tasks to specialist
+answer = gaia_specialist.run('''
+Find the founding year of the company mentioned in this video: [URL],
+calculate years from founding to 2024,
+then identify a major historical event from that founding year.
+Format the final answer according to GAIA requirements.
+''')
 ```
 
-Remember: Your final output must be ONLY the answer itself, formatted exactly as requested."""
+**RESPONSE STRUCTURE**:
+1. Show your reasoning and steps
+2. Use tools to gather information
+3. Verify your findings
+4. Format the final answer correctly
+5. End with "FINAL ANSWER: [answer]"
+
+**EXAMPLES OF PROPER FORMATTING**:
+- Question asks for a year: "FINAL ANSWER: 1991"
+- Question asks for a city: "FINAL ANSWER: San Francisco"  
+- Question asks for a percentage: "FINAL ANSWER: 25" (not "25%" unless specified)
+- Question asks for a list of countries: "FINAL ANSWER: France, Germany, Italy"
+- Question asks for a calculation result: "FINAL ANSWER: 456"
+
+Remember: Be methodical, verify your information, and always end with the properly formatted FINAL ANSWER."""
     )
     
-    logging.info("Enhanced GAIA agent initialized successfully.")
-    return manager
+    logging.info("🎯 Enhanced GAIA agent initialized successfully!")
+    
+    # Return wrapped agent that ensures GAIA format compliance
+    return create_gaia_agent_wrapper(manager)
 
-# --- Testing and Main Execution ---
+# --- Main Execution Block for Local Testing ---
 
 def main():
     """Test the agent with sample GAIA-style questions."""
     configure_logging()
+    logging.info("🧪 Starting local testing...")
+    
     try:
         agent = initialize_agent()
-        if agent:
-            # Sample questions covering different GAIA categories
-            test_questions = [
-                "What is the square root of 144?",
-                "In what year was the Python programming language first released?",
-                "What is the chemical formula for caffeine?",
-                "How many days are there between January 1, 2024 and March 15, 2024?",
-            ]
-            
-            for i, question in enumerate(test_questions, 1):
-                logging.info(f"\n{'='*50}")
-                logging.info(f"Test Question {i}: {question}")
-                logging.info(f"{'='*50}")
+        if not agent:
+            logging.error("Agent initialization failed")
+            return
+        
+        # More challenging test questions similar to GAIA
+        test_questions = [
+            "What is 15! / (12! * 3!) ?",
+            "In what year was the Python programming language first released?",
+            "What is the square root of 2,025?",
+        ]
+        
+        for i, question in enumerate(test_questions, 1):
+            logging.info(f"\n{'='*60}")
+            logging.info(f"🔍 Test Question {i}: {question}")
+            logging.info('='*60)
+            
+            start_time = time.time()
+            try:
+                # The agent wrapper now handles GAIA format compliance
+                response = agent(question)
+                elapsed_time = time.time() - start_time
                 
-                try:
-                    response = agent.run(question)
-                    logging.info(f"Agent Answer: {response}")
-                except Exception as e:
-                    logging.error(f"Error processing question {i}: {e}")
+                logging.info(f"✅ Final Answer: {response}")
+                logging.info(f"⏱️ Execution time: {elapsed_time:.2f} seconds")
+                
+            except Exception as e:
+                logging.error(f"❌ Error processing question {i}: {e}")
+            
+            time.sleep(2)  # Prevent rate limiting
+            
+        logging.info(f"\n{'='*60}")
+        logging.info("🏁 Testing completed!")
+        logging.info('='*60)
+        
+    except Exception as e:
+        logging.critical(f"💥 Critical error during testing: {e}", exc_info=True)
+
+if __name__ == "__main__":
+    main(), answer:
+            expected_type = "number" if ',' not in answer or answer.count(',') < 2 else "list"
+        elif ',' in answer and len(answer.split(',')) > 1:
+            expected_type = "list"
+        else:
+            expected_type = "string"
+    
+    if expected_type == "number":
+        # Remove commas and units for numbers
+        answer = re.sub(r'[,$%]', '', answer)
+        answer = re.sub(r'\s+', '', answer)
+        # Keep only number and decimal point
+        number_match = re.search(r'[\d.-]+', answer)
+        if number_match:
+            return number_match.group(0)
+    
+    elif expected_type == "string":
+        # Remove articles and normalize
+        answer = re.sub(r'\b(a|an|the)\s+', '', answer, flags=re.IGNORECASE)
+        answer = re.sub(r'\s+', ' ', answer).strip()
+        # Expand common abbreviations
+        abbreviations = {
+            'NYC': 'New York City',
+            'LA': 'Los Angeles', 
+            'SF': 'San Francisco',
+            'US': 'United States',
+            'UK': 'United Kingdom',
+            'EU': 'European Union'
+        }
+        for abbr, full in abbreviations.items():
+            if answer.upper() == abbr:
+                answer = full
+                break
+    
+    elif expected_type == "list":
+        # Process each element in the list
+        elements = [elem.strip() for elem in answer.split(',')]
+        normalized_elements = []
+        for elem in elements:
+            if re.match(r'^[\d.-]+', elem):
+
+def initialize_agent():
+    """
+    Initializes an enhanced multi-disciplinary agent optimized for GAIA benchmark questions.
+    """
+    configure_logging()
+    logging.info("🚀 Starting GAIA agent initialization...")
+    
+    try:
+        api_keys = load_api_keys()
+    except Exception as e:
+        logging.error(f"Failed to load API keys: {e}")
+        return None
+    
+    # --- Enhanced Caching Layer for LlamaIndex ---
+    @lru_cache(maxsize=64)  # Increased cache size
+    @retry(max_retries=3)
+    def get_webpage_index(url: str) -> VectorStoreIndex:
+        logging.info(f"📄 Indexing webpage: {url}")
+        try:
+            loader_cls = download_loader("BeautifulSoupWebReader")
+            loader = loader_cls()
+            docs = loader.load_data(urls=[url])
+            if not docs:
+                raise ValueError(f"No content could be extracted from {url}")
+            
+            # Filter out very short documents
+            valid_docs = [doc for doc in docs if len(doc.text.strip()) > 50]
+            if not valid_docs:
+                raise ValueError(f"No substantial content found in {url}")
                 
-                # Small delay between questions
-                time.sleep(1)
+            return VectorStoreIndex.from_documents(valid_docs)
+        except Exception as e:
+            logging.error(f"Error indexing webpage {url}: {e}")
+            raise
+
+    @lru_cache(maxsize=32)
+    @retry(max_retries=3)
+    def get_youtube_index(video_id: str) -> VectorStoreIndex:
+        logging.info(f"🎥 Indexing YouTube video: {video_id}")
+        try:
+            # Try to get English transcript first
+            try:
+                transcript = YouTubeTranscriptApi.get_transcript(video_id, languages=['en'])
+            except (TranscriptsDisabled, NoTranscriptFound):
+                # Try auto-generated or any available transcript
+                transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
+                try:
+                    transcript = transcript_list.find_transcript(['en']).fetch()
+                except:
+                    # Get any available transcript
+                    available_transcripts = list(transcript_list)
+                    if not available_transcripts:
+                        raise YouTubeTranscriptApiError(f"No transcripts available for video {video_id}")
+                    transcript = available_transcripts[0].fetch()
+            
+            if not transcript:
+                raise YouTubeTranscriptApiError(f"No transcript available for video {video_id}")
+            
+            # Combine transcript with timestamps for better context
+            text_segments = []
+            for entry in transcript:
+                timestamp = int(entry.get('start', 0))
+                text = entry.get('text', '').strip()
+                if text:
+                    text_segments.append(f"[{timestamp}s] {text}")
+            
+            full_text = ' '.join(text_segments)
+            if not full_text.strip():
+                raise YouTubeTranscriptApiError(f"Empty transcript for video {video_id}")
+            
+            doc = Document(
+                text=full_text, 
+                doc_id=f"youtube_{video_id}",
+                metadata={"source": f"https://youtube.com/watch?v={video_id}"}
+            )
+            return VectorStoreIndex.from_documents([doc])
+            
+        except Exception as e:
+            logging.error(f"Error indexing YouTube video {video_id}: {e}")
+            raise
+
+    # --- Enhanced Tool Definitions ---
+
+    @tool
+    def advanced_web_query(url: str, query: str) -> str:
+        """
+        Extract specific information from a webpage using advanced querying.
+        Handles various content types and provides detailed responses.
+        Args:
+            url: The webpage URL to analyze
+            query: Specific question to ask about the content
+        """
+        try:
+            if not url.startswith(('http://', 'https://')):
+                url = 'https://' + url
+            
+            logging.info(f"🔍 Querying webpage: {url} with query: {query}")
+            index = get_webpage_index(url)
+            query_engine = index.as_query_engine(
+                similarity_top_k=8,  # Increased for better coverage
+                response_mode="tree_summarize",
+                verbose=True
+            )
+            
+            response = query_engine.query(query)
+            result = clean_text_output(str(response))
+            
+            # If the response seems incomplete, try a broader query
+            if len(result) < 50 and "not found" not in result.lower():
+                broader_query = f"Information about {query.split()[-1] if query.split() else query}"
+                broader_response = query_engine.query(broader_query)
+                broader_result = clean_text_output(str(broader_response))
+                if len(broader_result) > len(result):
+                    result = broader_result
+            
+            return result
+            
+        except Exception as e:
+            error_msg = f"Error querying webpage {url}: {e}"
+            logging.error(error_msg)
+            return error_msg
+
+    @tool
+    def enhanced_youtube_query(video_url_or_id: str, query: str) -> str:
+        """
+        Extract information from YouTube video transcripts with enhanced processing.
+        Handles timestamps and provides contextual responses.
+        Args:
+            video_url_or_id: YouTube URL or video ID
+            query: Specific question about the video content
+        """
+        try:
+            video_id = extract_video_id(video_url_or_id)
+            if not video_id:
+                return f"Error: Could not extract valid YouTube video ID from '{video_url_or_id}'"
+            
+            logging.info(f"🎬 Querying YouTube video: {video_id} with query: {query}")
+            index = get_youtube_index(video_id)
+            query_engine = index.as_query_engine(
+                similarity_top_k=6,
+                response_mode="tree_summarize",
+                verbose=True
+            )
+            
+            response = query_engine.query(query)
+            result = clean_text_output(str(response))
+            
+            return result
+            
+        except YouTubeTranscriptApiError as e:
+            error_msg = f"YouTube transcript error for {video_url_or_id}: {e}"
+            logging.error(error_msg)
+            return error_msg
+        except Exception as e:
+            error_msg = f"Error querying YouTube video {video_url_or_id}: {e}"
+            logging.error(error_msg)
+            return error_msg
 
+    @tool
+    def enhanced_python_execution(code: str) -> str:
+        """
+        Execute Python code with enhanced capabilities and error handling.
+        Includes mathematical, data processing, and web scraping capabilities.
+        Args:
+            code: Python code to execute
+        """
+        # Expanded safe globals with more libraries
+        safe_globals = {}
+        try:
+            # Basic Python modules
+            import math, datetime, json, re, collections, itertools, random
+            from fractions import Fraction
+            from decimal import Decimal
+            import statistics
+            
+            safe_globals.update({
+                'math': math, 'datetime': datetime, 'json': json, 're': re,
+                'collections': collections, 'itertools': itertools, 'random': random,
+                'Fraction': Fraction, 'Decimal': Decimal, 'statistics': statistics
+            })
+            
+            # Scientific computing
+            try:
+                import numpy as np
+                safe_globals['np'] = np
+                safe_globals['numpy'] = np
+            except ImportError:
+                logging.warning("NumPy not available")
+            
+            try:
+                import pandas as pd
+                safe_globals['pd'] = pd
+                safe_globals['pandas'] = pd
+            except ImportError:
+                logging.warning("Pandas not available")
+            
+            # Web requests for data fetching
+            try:
+                import requests
+                safe_globals['requests'] = requests
+            except ImportError:
+                logging.warning("Requests not available")
+                
+        except ImportError as e:
+            logging.warning(f"Some modules not available: {e}")
+        
+        # Capture both stdout and stderr
+        stdout_capture = io.StringIO()
+        stderr_capture = io.StringIO()
+        
+        try:
+            logging.info(f"🐍 Executing Python code: {code[:100]}...")
+            
+            with contextlib.redirect_stdout(stdout_capture), contextlib.redirect_stderr(stderr_capture):
+                # Use exec with restricted builtins for safety
+                restricted_builtins = {
+                    'abs': abs, 'all': all, 'any': any, 'bin': bin, 'bool': bool,
+                    'chr': chr, 'dict': dict, 'dir': dir, 'divmod': divmod,
+                    'enumerate': enumerate, 'filter': filter, 'float': float,
+                    'format': format, 'hex': hex, 'int': int, 'len': len,
+                    'list': list, 'map': map, 'max': max, 'min': min, 'oct': oct,
+                    'ord': ord, 'pow': pow, 'print': print, 'range': range,
+                    'repr': repr, 'reversed': reversed, 'round': round,
+                    'set': set, 'sorted': sorted, 'str': str, 'sum': sum,
+                    'tuple': tuple, 'type': type, 'zip': zip,
+                }
+                
+                exec(code, {"__builtins__": restricted_builtins}, safe_globals)
+            
+            stdout_result = stdout_capture.getvalue()
+            stderr_result = stderr_capture.getvalue()
+            
+            # Combine outputs
+            result_parts = []
+            if stdout_result.strip():
+                result_parts.append(stdout_result.strip())
+            if stderr_result.strip():
+                result_parts.append(f"Warnings/Errors: {stderr_result.strip()}")
+            
+            if result_parts:
+                return '\n'.join(result_parts)
+            else:
+                return "Code executed successfully (no output)"
+                
+        except Exception as e:
+            error_msg = f"Code execution error: {e}"
+            stderr_result = stderr_capture.getvalue()
+            if stderr_result.strip():
+                error_msg += f"\nAdditional details: {stderr_result.strip()}"
+            logging.error(error_msg)
+            return error_msg
+
+    @tool
+    def enhanced_wikipedia_search(query: str, detailed: bool = True) -> str:
+        """
+        Search Wikipedia with enhanced content extraction and error handling.
+        Args:
+            query: Search term
+            detailed: Whether to return detailed information or just summary
+        """
+        try:
+            import wikipedia
+            wikipedia.set_lang("en")
+            wikipedia.set_rate_limiting(True)
+            
+            logging.info(f"📚 Searching Wikipedia for: {query}")
+            
+            # Handle disambiguation and search suggestions
+            try:
+                page = wikipedia.page(query, auto_suggest=True)
+            except wikipedia.DisambiguationError as e:
+                # Take the first option from disambiguation
+                if e.options:
+                    page = wikipedia.page(e.options[0])
+                else:
+                    return f"Wikipedia disambiguation error for '{query}': {e}"
+            except wikipedia.PageError:
+                # Try searching if direct page lookup fails
+                search_results = wikipedia.search(query, results=3)
+                if search_results:
+                    page = wikipedia.page(search_results[0])
+                else:
+                    return f"No Wikipedia results found for '{query}'"
+            
+            if detailed:
+                # Get more comprehensive content
+                content_sections = []
+                content_sections.append(f"**{page.title}**")
+                content_sections.append(f"Summary: {page.summary}")
+                
+                # Add first few sections if available
+                if hasattr(page, 'content') and page.content:
+                    sections = page.content.split('\n\n')[:3]  # First 3 paragraphs
+                    for section in sections:
+                        if section.strip() and len(section) > 50:
+                            content_sections.append(section.strip())
+                
+                content_sections.append(f"Source: {page.url}")
+                return '\n\n'.join(content_sections)
+            else:
+                return f"**{page.title}**\n\n{page.summary}\n\nSource: {page.url}"
+                
+        except ImportError:
+            return "Wikipedia library not installed. Cannot perform search."
+        except Exception as e:
+            error_msg = f"Wikipedia search error for '{query}': {e}"
+            logging.error(error_msg)
+            return error_msg
+
+    @tool
+    def data_processing_tool(data_description: str, operation: str) -> str:
+        """
+        Process and analyze data based on descriptions and operations.
+        Useful for mathematical calculations, data analysis, and structured data processing.
+        Args:
+            data_description: Description of the data or data source
+            operation: The operation to perform (calculate, analyze, extract, etc.)
+        """
+        try:
+            logging.info(f"📊 Processing data: {data_description} | Operation: {operation}")
+            
+            # This tool is designed to work with the Python execution tool
+            # for complex data processing tasks
+            code_template = f"""
+# Data processing task: {operation}
+# Data description: {data_description}
+
+# Add your specific data processing logic here
+# This is a template - specific implementation depends on the data and operation
+
+print("Data processing task initiated")
+print(f"Description: {data_description}")
+print(f"Operation: {operation}")
+
+# Example operations:
+if "calculate" in "{operation}".lower():
+    print("Performing calculation...")
+elif "analyze" in "{operation}".lower():
+    print("Performing analysis...")
+elif "extract" in "{operation}".lower():
+    print("Extracting information...")
+
+print("Task completed - use enhanced_python_execution for specific calculations")
+"""
+            
+            return enhanced_python_execution(code_template)
+            
+        except Exception as e:
+            error_msg = f"Data processing error: {e}"
+            logging.error(error_msg)
+            return error_msg
+
+    # --- Model and Agent Setup ---
+    
+    try:
+        # Use a more capable model for better performance
+        model = InferenceClientModel(
+            model_id="meta-llama/Llama-3.1-70B-Instruct-Turbo",  # Upgraded model
+            token=api_keys['together'],
+            provider="together"
+        )
+        logging.info("✅ Model loaded successfully")
+    except Exception as e:
+        logging.error(f"Failed to load primary model, falling back: {e}")
+        try:
+            # Fallback model
+            model = InferenceClientModel(
+                model_id="Qwen/Qwen2.5-7B-Instruct",
+                token=api_keys['together'],
+                provider="together"
+            )
+            logging.info("✅ Fallback model loaded successfully")
+        except Exception as e2:
+            logging.error(f"Failed to load fallback model: {e2}")
+            raise
+
+    # Configure Google Search tool
+    google_search_tool = None
+    if api_keys['serpapi']:
+        try:
+            google_search_tool = GoogleSearchTool(
+                provider='serpapi', 
+                serpapi_api_key=api_keys['serpapi']
+            )
+            logging.info("✅ Google Search tool configured")
+        except Exception as e:
+            logging.warning(f"Failed to configure Google Search tool: {e}")
+
+    # Prepare tools list
+    tools_list = [
+        enhanced_wikipedia_search,
+        advanced_web_query,
+        enhanced_youtube_query,
+        enhanced_python_execution,
+        data_processing_tool,
+    ]
+    
+    if google_search_tool:
+        tools_list.insert(0, google_search_tool)
+
+    # Specialized worker agent with comprehensive toolset
+    worker_agent = ToolCallingAgent(
+        tools=tools_list,
+        model=model,
+        max_steps=8,  # Increased for complex tasks
+        name="gaia_specialist",
+        description="Advanced specialist agent for GAIA benchmark: web research, document analysis, video processing, mathematical computation, and data analysis."
+    )
+
+    # Enhanced strategic manager agent
+    manager_tools = []
+    if google_search_tool:
+        manager_tools.append(google_search_tool)
+
+    manager = CodeAgent(
+        model=model,
+        managed_agents=[worker_agent],
+        tools=manager_tools,
+        instructions="""You are a general AI assistant designed for the GAIA benchmark. Your mission is to provide precise, accurate answers to complex questions that require deep reasoning and analysis.
+
+**CRITICAL: ANSWER FORMAT REQUIREMENT**
+You MUST finish your response with: FINAL ANSWER: [YOUR FINAL ANSWER]
+
+YOUR FINAL ANSWER formatting rules:
+- For NUMBERS: No commas, no units (like $ or %), no additional text
+  Example: "FINAL ANSWER: 42" NOT "FINAL ANSWER: 42 dollars" or "FINAL ANSWER: $42"
+- For STRINGS: No articles (a, an, the), no abbreviations, write digits in plain text
+  Example: "FINAL ANSWER: New York City" NOT "FINAL ANSWER: NYC" or "FINAL ANSWER: The Big Apple"
+- For LISTS: Comma-separated, apply above rules to each element
+  Example: "FINAL ANSWER: Paris, London, Berlin" or "FINAL ANSWER: 1.5, 2.3, 4.7"
+
+**STRATEGIC APPROACH:**
+
+1. **ANALYZE THE QUESTION**: Determine what type of answer is expected (number, string, or list)
+
+2. **DECOMPOSE THE PROBLEM**: Break complex questions into sub-problems:
+   - Identify required information sources
+   - Plan tool usage sequence
+   - Consider verification steps
+
+3. **TOOL SELECTION**:
+   - Use GoogleSearchTool for current information and general web queries
+   - Delegate to gaia_specialist for complex multi-tool analysis:
+     * advanced_web_query: Deep webpage content analysis
+     * enhanced_youtube_query: Video transcript analysis
+     * enhanced_python_execution: Mathematical calculations and data processing
+     * enhanced_wikipedia_search: Encyclopedic knowledge
+     * data_processing_tool: Structured data analysis
+
+4. **VERIFICATION**: Cross-check critical information and validate calculations
+
+**DELEGATION EXAMPLES**:
+
+Simple queries:
+```python
+# Direct search for current information
+result = search_tool.run("population Tokyo 2024")
+# Extract and format the answer properly
+```
+
+Complex analysis:
+```python
+# Delegate comprehensive tasks to specialist
+answer = gaia_specialist.run('''
+Find the founding year of the company mentioned in this video: [URL],
+calculate years from founding to 2024,
+then identify a major historical event from that founding year.
+Format the final answer according to GAIA requirements.
+''')
+```
+
+**RESPONSE STRUCTURE**:
+1. Show your reasoning and steps
+2. Use tools to gather information
+3. Verify your findings
+4. Format the final answer correctly
+5. End with "FINAL ANSWER: [answer]"
+
+**EXAMPLES OF PROPER FORMATTING**:
+- Question asks for a year: "FINAL ANSWER: 1991"
+- Question asks for a city: "FINAL ANSWER: San Francisco"  
+- Question asks for a percentage: "FINAL ANSWER: 25" (not "25%" unless specified)
+- Question asks for a list of countries: "FINAL ANSWER: France, Germany, Italy"
+- Question asks for a calculation result: "FINAL ANSWER: 456"
+
+Remember: Be methodical, verify your information, and always end with the properly formatted FINAL ANSWER."""
+    )
+    
+    logging.info("🎯 Enhanced GAIA agent initialized successfully!")
+    return manager
+
+# --- Main Execution Block for Local Testing ---
+
+def main():
+    """Test the agent with sample GAIA-style questions."""
+    configure_logging()
+    logging.info("🧪 Starting local testing...")
+    
+    try:
+        agent = initialize_agent()
+        if not agent:
+            logging.error("Agent initialization failed")
+            return
+        
+        # More challenging test questions similar to GAIA
+        test_questions = [
+            "What is 15! / (12! * 3!) ?",
+            "In what year was the Python programming language first released?",
+            "What is the square root of 2,025?",
+        ]
+        
+        for i, question in enumerate(test_questions, 1):
+            logging.info(f"\n{'='*60}")
+            logging.info(f"🔍 Test Question {i}: {question}")
+            logging.info('='*60)
+            
+            start_time = time.time()
+            try:
+                response = agent.run(question)
+                elapsed_time = time.time() - start_time
+                
+                logging.info(f"✅ Agent Answer: {response}")
+                logging.info(f"⏱️ Execution time: {elapsed_time:.2f} seconds")
+                
+            except Exception as e:
+                logging.error(f"❌ Error processing question {i}: {e}")
+            
+            time.sleep(2)  # Prevent rate limiting
+            
+        logging.info(f"\n{'='*60}")
+        logging.info("🏁 Testing completed!")
+        logging.info('='*60)
+        
+    except Exception as e:
+        logging.critical(f"💥 Critical error during testing: {e}", exc_info=True)
+
+if __name__ == "__main__":
+    main(), elem:
+                # It's a number
+                normalized_elements.append(normalize_answer_format(elem, "number"))
+            else:
+                # It's a string
+                normalized_elements.append(normalize_answer_format(elem, "string"))
+        return ', '.join(normalized_elements)
+    
+    return answer
+
+# --- Enhanced Agent Wrapper ---
+
+def create_gaia_agent_wrapper(agent):
+    """
+    Create a wrapper around the agent that ensures GAIA format compliance.
+    """
+    def gaia_agent_run(question: str) -> str:
+        """
+        Run the agent with GAIA format compliance.
+        Returns only the final answer in the correct format.
+        """
+        try:
+            # Add explicit formatting instruction to the question
+            formatted_question = f"""
+{question}
+
+Remember to end your response with: FINAL ANSWER: [YOUR FINAL ANSWER]
+
+Follow GAIA formatting rules:
+- Numbers: No commas, no units (unless specified)
+- Strings: No articles, no abbreviations, digits in plain text
+- Lists: Comma-separated following above rules for each element
+"""
+            
+            # Get the full response from the agent
+            full_response = agent.run(formatted_question)
+            
+            # Extract and normalize the final answer
+            final_answer = extract_final_answer(full_response)
+            normalized_answer = normalize_answer_format(final_answer)
+            
+            logging.info(f"🎯 Question: {question}")
+            logging.info(f"🤖 Full response: {full_response}")
+            logging.info(f"✅ Final answer: {normalized_answer}")
+            
+            return normalized_answer
+            
+        except Exception as e:
+            error_msg = f"Agent execution error: {e}"
+            logging.error(error_msg)
+            return f"ERROR: {e}"
+    
+    return gaia_agent_run
+
+def initialize_agent():
+    """
+    Initializes an enhanced multi-disciplinary agent optimized for GAIA benchmark questions.
+    """
+    configure_logging()
+    logging.info("🚀 Starting GAIA agent initialization...")
+    
+    try:
+        api_keys = load_api_keys()
+    except Exception as e:
+        logging.error(f"Failed to load API keys: {e}")
+        return None
+    
+    # --- Enhanced Caching Layer for LlamaIndex ---
+    @lru_cache(maxsize=64)  # Increased cache size
+    @retry(max_retries=3)
+    def get_webpage_index(url: str) -> VectorStoreIndex:
+        logging.info(f"📄 Indexing webpage: {url}")
+        try:
+            loader_cls = download_loader("BeautifulSoupWebReader")
+            loader = loader_cls()
+            docs = loader.load_data(urls=[url])
+            if not docs:
+                raise ValueError(f"No content could be extracted from {url}")
+            
+            # Filter out very short documents
+            valid_docs = [doc for doc in docs if len(doc.text.strip()) > 50]
+            if not valid_docs:
+                raise ValueError(f"No substantial content found in {url}")
+                
+            return VectorStoreIndex.from_documents(valid_docs)
+        except Exception as e:
+            logging.error(f"Error indexing webpage {url}: {e}")
+            raise
+
+    @lru_cache(maxsize=32)
+    @retry(max_retries=3)
+    def get_youtube_index(video_id: str) -> VectorStoreIndex:
+        logging.info(f"🎥 Indexing YouTube video: {video_id}")
+        try:
+            # Try to get English transcript first
+            try:
+                transcript = YouTubeTranscriptApi.get_transcript(video_id, languages=['en'])
+            except (TranscriptsDisabled, NoTranscriptFound):
+                # Try auto-generated or any available transcript
+                transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
+                try:
+                    transcript = transcript_list.find_transcript(['en']).fetch()
+                except:
+                    # Get any available transcript
+                    available_transcripts = list(transcript_list)
+                    if not available_transcripts:
+                        raise YouTubeTranscriptApiError(f"No transcripts available for video {video_id}")
+                    transcript = available_transcripts[0].fetch()
+            
+            if not transcript:
+                raise YouTubeTranscriptApiError(f"No transcript available for video {video_id}")
+            
+            # Combine transcript with timestamps for better context
+            text_segments = []
+            for entry in transcript:
+                timestamp = int(entry.get('start', 0))
+                text = entry.get('text', '').strip()
+                if text:
+                    text_segments.append(f"[{timestamp}s] {text}")
+            
+            full_text = ' '.join(text_segments)
+            if not full_text.strip():
+                raise YouTubeTranscriptApiError(f"Empty transcript for video {video_id}")
+            
+            doc = Document(
+                text=full_text, 
+                doc_id=f"youtube_{video_id}",
+                metadata={"source": f"https://youtube.com/watch?v={video_id}"}
+            )
+            return VectorStoreIndex.from_documents([doc])
+            
+        except Exception as e:
+            logging.error(f"Error indexing YouTube video {video_id}: {e}")
+            raise
+
+    # --- Enhanced Tool Definitions ---
+
+    @tool
+    def advanced_web_query(url: str, query: str) -> str:
+        """
+        Extract specific information from a webpage using advanced querying.
+        Handles various content types and provides detailed responses.
+        Args:
+            url: The webpage URL to analyze
+            query: Specific question to ask about the content
+        """
+        try:
+            if not url.startswith(('http://', 'https://')):
+                url = 'https://' + url
+            
+            logging.info(f"🔍 Querying webpage: {url} with query: {query}")
+            index = get_webpage_index(url)
+            query_engine = index.as_query_engine(
+                similarity_top_k=8,  # Increased for better coverage
+                response_mode="tree_summarize",
+                verbose=True
+            )
+            
+            response = query_engine.query(query)
+            result = clean_text_output(str(response))
+            
+            # If the response seems incomplete, try a broader query
+            if len(result) < 50 and "not found" not in result.lower():
+                broader_query = f"Information about {query.split()[-1] if query.split() else query}"
+                broader_response = query_engine.query(broader_query)
+                broader_result = clean_text_output(str(broader_response))
+                if len(broader_result) > len(result):
+                    result = broader_result
+            
+            return result
+            
+        except Exception as e:
+            error_msg = f"Error querying webpage {url}: {e}"
+            logging.error(error_msg)
+            return error_msg
+
+    @tool
+    def enhanced_youtube_query(video_url_or_id: str, query: str) -> str:
+        """
+        Extract information from YouTube video transcripts with enhanced processing.
+        Handles timestamps and provides contextual responses.
+        Args:
+            video_url_or_id: YouTube URL or video ID
+            query: Specific question about the video content
+        """
+        try:
+            video_id = extract_video_id(video_url_or_id)
+            if not video_id:
+                return f"Error: Could not extract valid YouTube video ID from '{video_url_or_id}'"
+            
+            logging.info(f"🎬 Querying YouTube video: {video_id} with query: {query}")
+            index = get_youtube_index(video_id)
+            query_engine = index.as_query_engine(
+                similarity_top_k=6,
+                response_mode="tree_summarize",
+                verbose=True
+            )
+            
+            response = query_engine.query(query)
+            result = clean_text_output(str(response))
+            
+            return result
+            
+        except YouTubeTranscriptApiError as e:
+            error_msg = f"YouTube transcript error for {video_url_or_id}: {e}"
+            logging.error(error_msg)
+            return error_msg
+        except Exception as e:
+            error_msg = f"Error querying YouTube video {video_url_or_id}: {e}"
+            logging.error(error_msg)
+            return error_msg
+
+    @tool
+    def enhanced_python_execution(code: str) -> str:
+        """
+        Execute Python code with enhanced capabilities and error handling.
+        Includes mathematical, data processing, and web scraping capabilities.
+        Args:
+            code: Python code to execute
+        """
+        # Expanded safe globals with more libraries
+        safe_globals = {}
+        try:
+            # Basic Python modules
+            import math, datetime, json, re, collections, itertools, random
+            from fractions import Fraction
+            from decimal import Decimal
+            import statistics
+            
+            safe_globals.update({
+                'math': math, 'datetime': datetime, 'json': json, 're': re,
+                'collections': collections, 'itertools': itertools, 'random': random,
+                'Fraction': Fraction, 'Decimal': Decimal, 'statistics': statistics
+            })
+            
+            # Scientific computing
+            try:
+                import numpy as np
+                safe_globals['np'] = np
+                safe_globals['numpy'] = np
+            except ImportError:
+                logging.warning("NumPy not available")
+            
+            try:
+                import pandas as pd
+                safe_globals['pd'] = pd
+                safe_globals['pandas'] = pd
+            except ImportError:
+                logging.warning("Pandas not available")
+            
+            # Web requests for data fetching
+            try:
+                import requests
+                safe_globals['requests'] = requests
+            except ImportError:
+                logging.warning("Requests not available")
+                
+        except ImportError as e:
+            logging.warning(f"Some modules not available: {e}")
+        
+        # Capture both stdout and stderr
+        stdout_capture = io.StringIO()
+        stderr_capture = io.StringIO()
+        
+        try:
+            logging.info(f"🐍 Executing Python code: {code[:100]}...")
+            
+            with contextlib.redirect_stdout(stdout_capture), contextlib.redirect_stderr(stderr_capture):
+                # Use exec with restricted builtins for safety
+                restricted_builtins = {
+                    'abs': abs, 'all': all, 'any': any, 'bin': bin, 'bool': bool,
+                    'chr': chr, 'dict': dict, 'dir': dir, 'divmod': divmod,
+                    'enumerate': enumerate, 'filter': filter, 'float': float,
+                    'format': format, 'hex': hex, 'int': int, 'len': len,
+                    'list': list, 'map': map, 'max': max, 'min': min, 'oct': oct,
+                    'ord': ord, 'pow': pow, 'print': print, 'range': range,
+                    'repr': repr, 'reversed': reversed, 'round': round,
+                    'set': set, 'sorted': sorted, 'str': str, 'sum': sum,
+                    'tuple': tuple, 'type': type, 'zip': zip,
+                }
+                
+                exec(code, {"__builtins__": restricted_builtins}, safe_globals)
+            
+            stdout_result = stdout_capture.getvalue()
+            stderr_result = stderr_capture.getvalue()
+            
+            # Combine outputs
+            result_parts = []
+            if stdout_result.strip():
+                result_parts.append(stdout_result.strip())
+            if stderr_result.strip():
+                result_parts.append(f"Warnings/Errors: {stderr_result.strip()}")
+            
+            if result_parts:
+                return '\n'.join(result_parts)
+            else:
+                return "Code executed successfully (no output)"
+                
+        except Exception as e:
+            error_msg = f"Code execution error: {e}"
+            stderr_result = stderr_capture.getvalue()
+            if stderr_result.strip():
+                error_msg += f"\nAdditional details: {stderr_result.strip()}"
+            logging.error(error_msg)
+            return error_msg
+
+    @tool
+    def enhanced_wikipedia_search(query: str, detailed: bool = True) -> str:
+        """
+        Search Wikipedia with enhanced content extraction and error handling.
+        Args:
+            query: Search term
+            detailed: Whether to return detailed information or just summary
+        """
+        try:
+            import wikipedia
+            wikipedia.set_lang("en")
+            wikipedia.set_rate_limiting(True)
+            
+            logging.info(f"📚 Searching Wikipedia for: {query}")
+            
+            # Handle disambiguation and search suggestions
+            try:
+                page = wikipedia.page(query, auto_suggest=True)
+            except wikipedia.DisambiguationError as e:
+                # Take the first option from disambiguation
+                if e.options:
+                    page = wikipedia.page(e.options[0])
+                else:
+                    return f"Wikipedia disambiguation error for '{query}': {e}"
+            except wikipedia.PageError:
+                # Try searching if direct page lookup fails
+                search_results = wikipedia.search(query, results=3)
+                if search_results:
+                    page = wikipedia.page(search_results[0])
+                else:
+                    return f"No Wikipedia results found for '{query}'"
+            
+            if detailed:
+                # Get more comprehensive content
+                content_sections = []
+                content_sections.append(f"**{page.title}**")
+                content_sections.append(f"Summary: {page.summary}")
+                
+                # Add first few sections if available
+                if hasattr(page, 'content') and page.content:
+                    sections = page.content.split('\n\n')[:3]  # First 3 paragraphs
+                    for section in sections:
+                        if section.strip() and len(section) > 50:
+                            content_sections.append(section.strip())
+                
+                content_sections.append(f"Source: {page.url}")
+                return '\n\n'.join(content_sections)
+            else:
+                return f"**{page.title}**\n\n{page.summary}\n\nSource: {page.url}"
+                
+        except ImportError:
+            return "Wikipedia library not installed. Cannot perform search."
+        except Exception as e:
+            error_msg = f"Wikipedia search error for '{query}': {e}"
+            logging.error(error_msg)
+            return error_msg
+
+    @tool
+    def data_processing_tool(data_description: str, operation: str) -> str:
+        """
+        Process and analyze data based on descriptions and operations.
+        Useful for mathematical calculations, data analysis, and structured data processing.
+        Args:
+            data_description: Description of the data or data source
+            operation: The operation to perform (calculate, analyze, extract, etc.)
+        """
+        try:
+            logging.info(f"📊 Processing data: {data_description} | Operation: {operation}")
+            
+            # This tool is designed to work with the Python execution tool
+            # for complex data processing tasks
+            code_template = f"""
+# Data processing task: {operation}
+# Data description: {data_description}
+
+# Add your specific data processing logic here
+# This is a template - specific implementation depends on the data and operation
+
+print("Data processing task initiated")
+print(f"Description: {data_description}")
+print(f"Operation: {operation}")
+
+# Example operations:
+if "calculate" in "{operation}".lower():
+    print("Performing calculation...")
+elif "analyze" in "{operation}".lower():
+    print("Performing analysis...")
+elif "extract" in "{operation}".lower():
+    print("Extracting information...")
+
+print("Task completed - use enhanced_python_execution for specific calculations")
+"""
+            
+            return enhanced_python_execution(code_template)
+            
+        except Exception as e:
+            error_msg = f"Data processing error: {e}"
+            logging.error(error_msg)
+            return error_msg
+
+    # --- Model and Agent Setup ---
+    
+    try:
+        # Use a more capable model for better performance
+        model = InferenceClientModel(
+            model_id="meta-llama/Llama-3.1-70B-Instruct-Turbo",  # Upgraded model
+            token=api_keys['together'],
+            provider="together"
+        )
+        logging.info("✅ Model loaded successfully")
+    except Exception as e:
+        logging.error(f"Failed to load primary model, falling back: {e}")
+        try:
+            # Fallback model
+            model = InferenceClientModel(
+                model_id="Qwen/Qwen2.5-7B-Instruct",
+                token=api_keys['together'],
+                provider="together"
+            )
+            logging.info("✅ Fallback model loaded successfully")
+        except Exception as e2:
+            logging.error(f"Failed to load fallback model: {e2}")
+            raise
+
+    # Configure Google Search tool
+    google_search_tool = None
+    if api_keys['serpapi']:
+        try:
+            google_search_tool = GoogleSearchTool(
+                provider='serpapi', 
+                serpapi_api_key=api_keys['serpapi']
+            )
+            logging.info("✅ Google Search tool configured")
+        except Exception as e:
+            logging.warning(f"Failed to configure Google Search tool: {e}")
+
+    # Prepare tools list
+    tools_list = [
+        enhanced_wikipedia_search,
+        advanced_web_query,
+        enhanced_youtube_query,
+        enhanced_python_execution,
+        data_processing_tool,
+    ]
+    
+    if google_search_tool:
+        tools_list.insert(0, google_search_tool)
+
+    # Specialized worker agent with comprehensive toolset
+    worker_agent = ToolCallingAgent(
+        tools=tools_list,
+        model=model,
+        max_steps=8,  # Increased for complex tasks
+        name="gaia_specialist",
+        description="Advanced specialist agent for GAIA benchmark: web research, document analysis, video processing, mathematical computation, and data analysis."
+    )
+
+    # Enhanced strategic manager agent
+    manager_tools = []
+    if google_search_tool:
+        manager_tools.append(google_search_tool)
+
+    manager = CodeAgent(
+        model=model,
+        managed_agents=[worker_agent],
+        tools=manager_tools,
+        instructions="""You are a general AI assistant designed for the GAIA benchmark. Your mission is to provide precise, accurate answers to complex questions that require deep reasoning and analysis.
+
+**CRITICAL: ANSWER FORMAT REQUIREMENT**
+You MUST finish your response with: FINAL ANSWER: [YOUR FINAL ANSWER]
+
+YOUR FINAL ANSWER formatting rules:
+- For NUMBERS: No commas, no units (like $ or %), no additional text
+  Example: "FINAL ANSWER: 42" NOT "FINAL ANSWER: 42 dollars" or "FINAL ANSWER: $42"
+- For STRINGS: No articles (a, an, the), no abbreviations, write digits in plain text
+  Example: "FINAL ANSWER: New York City" NOT "FINAL ANSWER: NYC" or "FINAL ANSWER: The Big Apple"
+- For LISTS: Comma-separated, apply above rules to each element
+  Example: "FINAL ANSWER: Paris, London, Berlin" or "FINAL ANSWER: 1.5, 2.3, 4.7"
+
+**STRATEGIC APPROACH:**
+
+1. **ANALYZE THE QUESTION**: Determine what type of answer is expected (number, string, or list)
+
+2. **DECOMPOSE THE PROBLEM**: Break complex questions into sub-problems:
+   - Identify required information sources
+   - Plan tool usage sequence
+   - Consider verification steps
+
+3. **TOOL SELECTION**:
+   - Use GoogleSearchTool for current information and general web queries
+   - Delegate to gaia_specialist for complex multi-tool analysis:
+     * advanced_web_query: Deep webpage content analysis
+     * enhanced_youtube_query: Video transcript analysis
+     * enhanced_python_execution: Mathematical calculations and data processing
+     * enhanced_wikipedia_search: Encyclopedic knowledge
+     * data_processing_tool: Structured data analysis
+
+4. **VERIFICATION**: Cross-check critical information and validate calculations
+
+**DELEGATION EXAMPLES**:
+
+Simple queries:
+```python
+# Direct search for current information
+result = search_tool.run("population Tokyo 2024")
+# Extract and format the answer properly
+```
+
+Complex analysis:
+```python
+# Delegate comprehensive tasks to specialist
+answer = gaia_specialist.run('''
+Find the founding year of the company mentioned in this video: [URL],
+calculate years from founding to 2024,
+then identify a major historical event from that founding year.
+Format the final answer according to GAIA requirements.
+''')
+```
+
+**RESPONSE STRUCTURE**:
+1. Show your reasoning and steps
+2. Use tools to gather information
+3. Verify your findings
+4. Format the final answer correctly
+5. End with "FINAL ANSWER: [answer]"
+
+**EXAMPLES OF PROPER FORMATTING**:
+- Question asks for a year: "FINAL ANSWER: 1991"
+- Question asks for a city: "FINAL ANSWER: San Francisco"  
+- Question asks for a percentage: "FINAL ANSWER: 25" (not "25%" unless specified)
+- Question asks for a list of countries: "FINAL ANSWER: France, Germany, Italy"
+- Question asks for a calculation result: "FINAL ANSWER: 456"
+
+Remember: Be methodical, verify your information, and always end with the properly formatted FINAL ANSWER."""
+    )
+    
+    logging.info("🎯 Enhanced GAIA agent initialized successfully!")
+    return manager
+
+# --- Main Execution Block for Local Testing ---
+
+def main():
+    """Test the agent with sample GAIA-style questions."""
+    configure_logging()
+    logging.info("🧪 Starting local testing...")
+    
+    try:
+        agent = initialize_agent()
+        if not agent:
+            logging.error("Agent initialization failed")
+            return
+        
+        # More challenging test questions similar to GAIA
+        test_questions = [
+            "What is 15! / (12! * 3!) ?",
+            "In what year was the Python programming language first released?",
+            "What is the square root of 2,025?",
+        ]
+        
+        for i, question in enumerate(test_questions, 1):
+            logging.info(f"\n{'='*60}")
+            logging.info(f"🔍 Test Question {i}: {question}")
+            logging.info('='*60)
+            
+            start_time = time.time()
+            try:
+                response = agent.run(question)
+                elapsed_time = time.time() - start_time
+                
+                logging.info(f"✅ Agent Answer: {response}")
+                logging.info(f"⏱️ Execution time: {elapsed_time:.2f} seconds")
+                
+            except Exception as e:
+                logging.error(f"❌ Error processing question {i}: {e}")
+            
+            time.sleep(2)  # Prevent rate limiting
+            
+        logging.info(f"\n{'='*60}")
+        logging.info("🏁 Testing completed!")
+        logging.info('='*60)
+        
     except Exception as e:
-        logging.critical(f"Critical error during testing: {e}", exc_info=True)
+        logging.critical(f"💥 Critical error during testing: {e}", exc_info=True)
 
 if __name__ == "__main__":
     main()

app.py

@@ -2,23 +2,56 @@ import os
 import gradio as gr
 import requests
 import pandas as pd
+import re
+import logging
 from agent import initialize_agent # Import the agent initialization function
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
 # --- Helper Functions ---
+
+def extract_final_answer_from_response(response: str) -> str:
+    """
+    Extract the final answer from agent response following GAIA format.
+    The agent should return responses ending with 'FINAL ANSWER: [answer]'
+    """
+    if not response:
+        return ""
+    
+    # The agent wrapper should already return just the final answer
+    # but this is a safety check in case the format isn't perfect
+    if isinstance(response, str):
+        # Look for FINAL ANSWER pattern
+        final_answer_pattern = re.compile(r'FINAL\s+ANSWER\s*:\s*(.+?)(?:\n|$)', re.IGNORECASE | re.DOTALL)
+        match = final_answer_pattern.search(response)
+        
+        if match:
+            answer = match.group(1).strip()
+            # Clean up the answer
+            answer = re.sub(r'\s+', ' ', answer)
+            answer = answer.rstrip('.')
+            return answer
+    
+    # If no FINAL ANSWER pattern found, return the response as is
+    # (the agent wrapper should have already cleaned it)
+    return str(response).strip()
+
 def _fetch_questions(api_url: str) -> list:
     """Fetches evaluation questions from the API."""
     questions_url = f"{api_url}/questions"
-    print(f"Fetching questions from: {questions_url}")
+    logger.info(f"Fetching questions from: {questions_url}")
     try:
         response = requests.get(questions_url, timeout=15)
         response.raise_for_status()
         questions_data = response.json()
         if not questions_data:
             raise ValueError("Fetched questions list is empty or invalid format.")
-        print(f"Fetched {len(questions_data)} questions.")
+        logger.info(f"Fetched {len(questions_data)} questions.")
         return questions_data
     except requests.exceptions.RequestException as e:
         raise RuntimeError(f"Error fetching questions: {e}") from e
@@ -31,27 +64,69 @@ def _run_agent_on_questions(agent, questions_data: list) -> tuple[list, list]:
     """Runs the agent on each question and collects answers and logs."""
     results_log = []
     answers_payload = []
-    print(f"Running agent on {len(questions_data)} questions...")
+    logger.info(f"Running agent on {len(questions_data)} questions...")
+    
     for item in questions_data:
         task_id = item.get("task_id")
         question_text = item.get("question")
         if not task_id or question_text is None:
-            print(f"Skipping item with missing task_id or question: {item}")
+            logger.warning(f"Skipping item with missing task_id or question: {item}")
             continue
+        
         try:
-            submitted_answer = agent(question_text)
-            answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
-            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
+            logger.info(f"Processing task {task_id}: {question_text[:100]}...")
+            
+            # The agent is now wrapped to return GAIA-compliant format
+            raw_response = agent(question_text)
+            
+            # Extract the final answer (should already be clean from wrapper)
+            submitted_answer = extract_final_answer_from_response(raw_response)
+            
+            # Log the full interaction for debugging
+            logger.info(f"Task {task_id} - Raw response: {raw_response}")
+            logger.info(f"Task {task_id} - Final answer: {submitted_answer}")
+            
+            answers_payload.append({
+                "task_id": task_id, 
+                "submitted_answer": submitted_answer
+            })
+            
+            results_log.append({
+                "Task ID": task_id, 
+                "Question": question_text, 
+                "Raw Response": raw_response,
+                "Final Answer": submitted_answer
+            })
+            
         except Exception as e:
-            print(f"Error running agent on task {task_id}: {e}")
-            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
+            error_msg = f"AGENT ERROR: {e}"
+            logger.error(f"Error running agent on task {task_id}: {e}")
+            
+            answers_payload.append({
+                "task_id": task_id, 
+                "submitted_answer": error_msg
+            })
+            
+            results_log.append({
+                "Task ID": task_id, 
+                "Question": question_text, 
+                "Raw Response": error_msg,
+                "Final Answer": error_msg
+            })
+    
     return answers_payload, results_log
 
 def _submit_answers(api_url: str, username: str, agent_code_url: str, answers_payload: list) -> dict:
     """Submits the agent's answers to the evaluation API."""
     submit_url = f"{api_url}/submit"
-    submission_data = {"username": username.strip(), "agent_code": agent_code_url, "answers": answers_payload}
-    print(f"Submitting {len(answers_payload)} answers for user '{username}' to: {submit_url}")
+    submission_data = {
+        "username": username.strip(), 
+        "agent_code": agent_code_url, 
+        "answers": answers_payload
+    }
+    
+    logger.info(f"Submitting {len(answers_payload)} answers for user '{username}' to: {submit_url}")
+    
     try:
         response = requests.post(submit_url, json=submission_data, timeout=60)
         response.raise_for_status()
@@ -79,9 +154,9 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     username = None
     if profile:
         username = profile.username
-        print(f"User logged in: {username}")
+        logger.info(f"User logged in: {username}")
     else:
-        print("User not logged in.")
+        logger.info("User not logged in.")
         return "Please Login to Hugging Face with the button.", None
 
     if not username:
@@ -89,7 +164,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
 
     space_id = os.getenv("SPACE_ID")
     if not space_id:
-        print("SPACE_ID environment variable not found. Cannot determine agent_code URL.")
+        logger.error("SPACE_ID environment variable not found. Cannot determine agent_code URL.")
         return "Error: SPACE_ID not set. Cannot determine agent_code URL.", None
     agent_code_url = f"https://huggingface.co/spaces/{space_id}/tree/main"
 
@@ -98,11 +173,11 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
 
     try:
         # 1. Instantiate Agent
-        print("Initializing agent...")
+        logger.info("Initializing agent...")
         agent = initialize_agent()
         if agent is None:
             raise RuntimeError("Agent initialization failed. Check agent.py for details.")
-        print("Agent initialized successfully.")
+        logger.info("Agent initialized successfully.")
 
         # 2. Fetch Questions
         questions_data = _fetch_questions(DEFAULT_API_URL)
@@ -117,79 +192,129 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         submission_result = _submit_answers(DEFAULT_API_URL, username, agent_code_url, answers_payload)
 
         final_status = (
-            f"Submission Successful!\n"
-            f"User: {submission_result.get('username')}\n"
-            f"Overall Score: {submission_result.get('score', 'N/A')}% "
+            f"🎉 Submission Successful!\n"
+            f"👤 User: {submission_result.get('username')}\n"
+            f"📊 Overall Score: {submission_result.get('score', 'N/A')}% "
             f"({submission_result.get('correct_count', '?')}/{submission_result.get('total_attempted', '?')} correct)\n"
-            f"Message: {submission_result.get('message', 'No message received.')}"
+            f"💬 Message: {submission_result.get('message', 'No message received.')}\n"
+            f"🔗 Agent Code: {agent_code_url}"
         )
         status_message = final_status
         results_df = pd.DataFrame(results_log)
 
     except RuntimeError as e:
-        status_message = f"Operation Failed: {e}"
-        print(status_message)
+        status_message = f"❌ Operation Failed: {e}"
+        logger.error(status_message)
         # If an error occurs during agent run, results_log might be partially filled
-        # Ensure results_df is created even if answers_payload is empty due to early error
         if 'results_log' in locals():
             results_df = pd.DataFrame(results_log)
         else:
             results_df = pd.DataFrame([{"Status": "Error", "Details": str(e)}])
     except Exception as e:
-        status_message = f"An unexpected critical error occurred: {e}"
-        print(status_message)
+        status_message = f"💥 Critical Error: {e}"
+        logger.error(status_message)
         results_df = pd.DataFrame([{"Status": "Critical Error", "Details": str(e)}])
 
     return status_message, results_df
 
 # --- Gradio Interface Definition ---
-with gr.Blocks() as demo:
-    gr.Markdown("# GAIA Benchmark Evaluation with smolagent")
-    gr.Markdown(
-        """
-        **Instructions:**
-        1.  Clone this Space and modify `agent.py` to define your agent's logic, tools, and necessary packages.
-        2.  Log in to your Hugging Face account using the button below. Your HF username will be used for submission.
-        3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see your score.
-        ---
-        **Important Notes:**
-        *   The evaluation process can take some time as the agent processes all questions.
-        *   This Space provides a basic setup. You are encouraged to develop a more robust solution (e.g., caching answers, asynchronous processing) for production use.
-        """
-    )
-
-    gr.LoginButton()
+with gr.Blocks(title="GAIA Benchmark Agent", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🧠 GAIA Benchmark Evaluation Agent
+    
+    **Enhanced AI Agent for General AI Assistant (GAIA) Benchmark**
+    """)
+    
+    gr.Markdown("""
+    ## 📋 Instructions:
+    
+    1. **Setup**: Clone this Space and ensure your `.env` file contains:
+       ```
+       TOGETHER_API_KEY=your_together_api_key
+       SERPAPI_API_KEY=your_serpapi_key
+       ```
+    
+    2. **Login**: Use the button below to log in with your Hugging Face account
+    
+    3. **Run**: Click 'Run Evaluation & Submit' to process all GAIA questions
+    
+    4. **Wait**: The process may take several minutes depending on question complexity
+    
+    ---
+    
+    ### 🎯 GAIA Format Requirements:
+    - **Numbers**: No commas, no units (unless specified)
+    - **Strings**: No articles (a, an, the), no abbreviations  
+    - **Lists**: Comma-separated values following above rules
+    
+    ### 🔧 Agent Capabilities:
+    - **Web Research**: Google Search, Wikipedia, webpage analysis
+    - **Video Analysis**: YouTube transcript processing
+    - **Mathematical Computing**: Python execution with scientific libraries
+    - **Multi-step Reasoning**: Complex problem decomposition
+    """)
 
-    run_button = gr.Button("Run Evaluation & Submit All Answers")
+    with gr.Row():
+        gr.LoginButton(scale=1)
+        run_button = gr.Button("🚀 Run Evaluation & Submit All Answers", variant="primary", scale=2)
 
-    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
-    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
+    status_output = gr.Textbox(
+        label="📊 Evaluation Status & Results", 
+        lines=8, 
+        interactive=False,
+        placeholder="Click 'Run Evaluation' to start the process..."
+    )
+    
+    results_table = gr.DataFrame(
+        label="📝 Detailed Question Results", 
+        wrap=True,
+        interactive=False,
+        column_widths=["10%", "40%", "25%", "25%"]
+    )
 
     run_button.click(
         fn=run_and_submit_all,
         outputs=[status_output, results_table]
     )
 
+    gr.Markdown("""
+    ---
+    ### 💡 Tips for Better Performance:
+    - Ensure stable internet connection for web searches
+    - Monitor the status output for real-time progress
+    - Check the detailed results table for individual question analysis
+    - The agent automatically formats answers according to GAIA requirements
+    """)
+
 if __name__ == "__main__":
-    print("\n" + "-"*30 + " App Starting " + "-"*30)
-    # Check for SPACE_HOST and SPACE_ID at startup for information
-    space_host_startup = os.getenv("SPACE_HOST")
-    space_id_startup = os.getenv("SPACE_ID")
-
-    if space_host_startup:
-        print(f"✅ SPACE_HOST found: {space_host_startup}")
-        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
+    print("\n" + "="*70)
+    print("🚀 GAIA BENCHMARK AGENT STARTING")
+    print("="*70)
+    
+    # Check environment variables
+    space_host = os.getenv("SPACE_HOST")
+    space_id = os.getenv("SPACE_ID")
+    together_key = os.getenv("TOGETHER_API_KEY")
+    serpapi_key = os.getenv("SERPAPI_API_KEY")
+
+    if space_host:
+        print(f"✅ SPACE_HOST: {space_host}")
+        print(f"   🌐 Runtime URL: https://{space_host}.hf.space")
     else:
-        print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
+        print("ℹ️  SPACE_HOST not found (local development)")
 
-    if space_id_startup:
-        print(f"✅ SPACE_ID found: {space_id_startup}")
-        print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
-        print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
+    if space_id:
+        print(f"✅ SPACE_ID: {space_id}")
+        print(f"   📂 Repo URL: https://huggingface.co/spaces/{space_id}")
     else:
-        print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
+        print("⚠️  SPACE_ID not found - submissions may fail")
+
+    print(f"🔑 API Keys Status:")
+    print(f"   Together AI: {'✅ Set' if together_key else '❌ Missing'}")
+    print(f"   SerpAPI: {'✅ Set' if serpapi_key else '⚠️ Missing (optional)'}")
 
-    print("-"*(60 + len(" App Starting ")) + "\n")
+    print("="*70)
+    print("🎯 Launching GAIA Benchmark Interface...")
+    print("="*70 + "\n")
 
-    print("Launching Gradio Interface for Basic Agent Evaluation...")
     demo.launch(debug=True, share=False)

requirements.txt

@@ -10,4 +10,11 @@ serpapi
 llama-index
 youtube-transcript-api
 together
-python-chess
+python-chess
+transformers
+torch
+requests
+serpapi-python-client
+llama-index
+beautifulsoup4
+lxml