fc

agent.py

@@ -0,0 +1,829 @@
+import os
+import json
+import logging
+from typing import Dict, List, Any, Optional, Union
+from datetime import datetime
+import asyncio
+import base64
+from io import BytesIO
+
+import google.generativeai as genai
+from google.generativeai.types import HarmCategory, HarmBlockThreshold
+from PIL import Image
+import pandas as pd
+import numpy as np
+import requests
+from duckduckgo_search import DDGS
+import tempfile
+from pathlib import Path
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class GAIAQuestion:
+    """GAIA benchmark question structure"""
+    
+    def __init__(self, question_id: str, question: str, level: int, 
+                 final_answer: Optional[str] = None, file_name: Optional[str] = None, 
+                 file_path: Optional[str] = None, annotator_metadata: Optional[Dict] = None):
+        self.question_id = question_id
+        self.question = question
+        self.level = level
+        self.final_answer = final_answer
+        self.file_name = file_name
+        self.file_path = file_path
+        self.annotator_metadata = annotator_metadata
+
+class GeminiTool:
+    """Base class for Gemini agent tools"""
+    
+    def __init__(self, name: str, description: str):
+        self.name = name
+        self.description = description
+    
+    def execute(self, input_data: str) -> str:
+        raise NotImplementedError
+
+class CalculatorTool(GeminiTool):
+    """Advanced calculator tool for mathematical operations"""
+    
+    def __init__(self):
+        super().__init__(
+            name="calculator",
+            description="""
+            Performs mathematical calculations including:
+            - Basic arithmetic (+, -, *, /, %)
+            - Advanced math (sqrt, log, sin, cos, tan, exp, etc.)
+            - Financial calculations (compound interest, annuities, etc.)
+            - Statistical operations (mean, median, std, etc.)
+            
+            Examples:
+            - "sqrt(144)" → 12
+            - "log(100)" → 2.0 (base 10)
+            - "sin(pi/2)" → 1.0
+            - "compound_interest(1000, 0.05, 3)" → compound interest calculation
+            """
+        )
+    
+    def execute(self, expression: str) -> str:
+        try:
+            import math
+            import statistics
+            
+            # Enhanced safe evaluation environment
+            safe_dict = {
+                "__builtins__": {},
+                # Basic operations
+                "abs": abs, "round": round, "min": min, "max": max,
+                "sum": sum, "pow": pow, "divmod": divmod,
+                
+                # Math functions
+                "sqrt": math.sqrt, "log": math.log, "log10": math.log10,
+                "ln": math.log, "exp": math.exp,
+                "sin": math.sin, "cos": math.cos, "tan": math.tan,
+                "asin": math.asin, "acos": math.acos, "atan": math.atan,
+                "sinh": math.sinh, "cosh": math.cosh, "tanh": math.tanh,
+                "pi": math.pi, "e": math.e,
+                "floor": math.floor, "ceil": math.ceil,
+                "factorial": math.factorial, "gcd": math.gcd,
+                
+                # Statistical functions
+                "mean": statistics.mean, "median": statistics.median,
+                "mode": statistics.mode, "stdev": statistics.stdev,
+                
+                # Financial functions
+                "compound_interest": self._compound_interest,
+                "simple_interest": self._simple_interest,
+                "present_value": self._present_value,
+                "future_value": self._future_value,
+            }
+            
+            # Handle special financial calculations
+            if "compound_interest" in expression.lower():
+                return self._handle_financial_calculation(expression)
+            
+            # Evaluate the expression safely
+            result = eval(expression, safe_dict)
+            
+            return f"Calculation result: {result}"
+            
+        except Exception as e:
+            return f"Calculation error: {str(e)}. Please check your mathematical expression."
+    
+    def _compound_interest(self, principal: float, rate: float, time: float, n: int = 1) -> float:
+        """Calculate compound interest: A = P(1 + r/n)^(nt)"""
+        return principal * (1 + rate/n) ** (n * time)
+    
+    def _simple_interest(self, principal: float, rate: float, time: float) -> float:
+        """Calculate simple interest: A = P(1 + rt)"""
+        return principal * (1 + rate * time)
+    
+    def _present_value(self, future_value: float, rate: float, time: float) -> float:
+        """Calculate present value: PV = FV / (1 + r)^t"""
+        return future_value / (1 + rate) ** time
+    
+    def _future_value(self, present_value: float, rate: float, time: float) -> float:
+        """Calculate future value: FV = PV * (1 + r)^t"""
+        return present_value * (1 + rate) ** time
+    
+    def _handle_financial_calculation(self, expression: str) -> str:
+        """Handle complex financial calculations"""
+        try:
+            # Parse common financial calculation patterns
+            if "compound" in expression.lower():
+                # Extract parameters from natural language
+                # This is a simplified parser - in production, you'd use more sophisticated NLP
+                import re
+                
+                # Look for patterns like "1000 at 5% for 3 years"
+                money_pattern = r'\$?(\d+(?:\.\d+)?)'
+                rate_pattern = r'(\d+(?:\.\d+)?)%'
+                time_pattern = r'(\d+(?:\.\d+)?)\s*years?'
+                
+                money_match = re.search(money_pattern, expression)
+                rate_match = re.search(rate_pattern, expression)
+                time_match = re.search(time_pattern, expression)
+                
+                if money_match and rate_match and time_match:
+                    principal = float(money_match.group(1))
+                    rate = float(rate_match.group(1)) / 100  # Convert percentage
+                    time = float(time_match.group(1))
+                    
+                    # Default to annual compounding
+                    n = 12 if "monthly" in expression.lower() else 1
+                    
+                    result = self._compound_interest(principal, rate, time, n)
+                    
+                    return f"""
+Financial Calculation - Compound Interest:
+- Principal: ${principal:,.2f}
+- Interest Rate: {rate*100}% per year
+- Time Period: {time} years
+- Compounding: {'Monthly' if n == 12 else 'Annually'}
+- Final Amount: ${result:,.2f}
+- Interest Earned: ${result - principal:,.2f}
+"""
+                
+            return "Unable to parse financial calculation. Please use format like: compound_interest(1000, 0.05, 3)"
+            
+        except Exception as e:
+            return f"Financial calculation error: {str(e)}"
+
+class WebSearchTool(GeminiTool):
+    """Web search tool using DuckDuckGo"""
+    
+    def __init__(self):
+        super().__init__(
+            name="web_search",
+            description="""
+            Searches the web for current information using DuckDuckGo.
+            Returns relevant, up-to-date search results with summaries.
+            
+            Best for:
+            - Current events and news
+            - Recent statistics and data
+            - Current prices, populations, etc.
+            - Latest information on any topic
+            
+            Example: "current population of Tokyo 2024"
+            """
+        )
+        self.ddgs = DDGS()
+    
+    def execute(self, query: str) -> str:
+        try:
+            # Perform web search
+            results = list(self.ddgs.text(query, max_results=5))
+            
+            if not results:
+                return f"No search results found for: {query}"
+            
+            formatted_results = f"Web search results for '{query}':\n\n"
+            
+            for i, result in enumerate(results, 1):
+                title = result.get('title', 'No title')
+                snippet = result.get('body', 'No description')
+                url = result.get('href', 'No URL')
+                
+                formatted_results += f"{i}. **{title}**\n"
+                formatted_results += f"   {snippet[:200]}...\n"
+                formatted_results += f"   Source: {url}\n\n"
+            
+            return formatted_results
+            
+        except Exception as e:
+            return f"Web search error: {str(e)}. Unable to perform search at this time."
+
+class FileAnalyzerTool(GeminiTool):
+    """Tool for analyzing various file types"""
+    
+    def __init__(self):
+        super().__init__(
+            name="file_analyzer",
+            description="""
+            Analyzes various file types including:
+            - Text files (.txt, .md, .json, .csv)
+            - Data files (CSV, Excel, JSON)
+            - Image files (PNG, JPG, GIF, etc.)
+            - Documents and structured data
+            
+            Provides summaries, statistics, and insights from file contents.
+            """
+        )
+    
+    def execute(self, file_path: str) -> str:
+        try:
+            if not os.path.exists(file_path):
+                return f"File not found: {file_path}"
+            
+            file_extension = Path(file_path).suffix.lower()
+            
+            if file_extension in ['.txt', '.md', '.py', '.js', '.html', '.css']:
+                return self._analyze_text_file(file_path)
+            elif file_extension == '.json':
+                return self._analyze_json_file(file_path)
+            elif file_extension == '.csv':
+                return self._analyze_csv_file(file_path)
+            elif file_extension in ['.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp']:
+                return self._analyze_image_file(file_path)
+            else:
+                return f"Unsupported file type: {file_extension}"
+                
+        except Exception as e:
+            return f"Error analyzing file: {str(e)}"
+    
+    def _analyze_text_file(self, file_path: str) -> str:
+        with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+            content = f.read()
+        
+        lines = content.split('\n')
+        words = content.split()
+        chars = len(content)
+        
+        # Basic text statistics
+        avg_line_length = sum(len(line) for line in lines) / len(lines) if lines else 0
+        avg_word_length = sum(len(word) for word in words) / len(words) if words else 0
+        
+        preview = content[:500] + ('...' if len(content) > 500 else '')
+        
+        return f"""
+📄 Text File Analysis:
+- File: {Path(file_path).name}
+- Lines: {len(lines):,}
+- Words: {len(words):,}
+- Characters: {chars:,}
+- Average line length: {avg_line_length:.1f} characters
+- Average word length: {avg_word_length:.1f} characters
+
+📝 Content Preview:
+{preview}
+"""
+    
+    def _analyze_json_file(self, file_path: str) -> str:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        data_type = type(data).__name__
+        
+        if isinstance(data, dict):
+            keys_info = f"Keys ({len(data)}): {list(data.keys())[:10]}"
+            if len(data) > 10:
+                keys_info += "..."
+        elif isinstance(data, list):
+            keys_info = f"List with {len(data)} items"
+        else:
+            keys_info = f"Single {data_type} value"
+        
+        preview = json.dumps(data, indent=2)[:500]
+        if len(str(data)) > 500:
+            preview += "..."
+        
+        return f"""
+🔧 JSON File Analysis:
+- File: {Path(file_path).name}
+- Data type: {data_type}
+- {keys_info}
+- File size: {os.path.getsize(file_path):,} bytes
+
+📊 Content Preview:
+{preview}
+"""
+    
+    def _analyze_csv_file(self, file_path: str) -> str:
+        try:
+            df = pd.read_csv(file_path)
+            
+            # Basic statistics
+            rows, cols = df.shape
+            numeric_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+            text_cols = df.select_dtypes(include=['object']).columns.tolist()
+            missing_data = df.isnull().sum()
+            
+            # Summary statistics for numeric columns
+            numeric_summary = ""
+            if numeric_cols:
+                numeric_summary = "\n📊 Numeric Columns Summary:\n"
+                for col in numeric_cols[:5]:  # Show first 5 numeric columns
+                    col_data = df[col]
+                    numeric_summary += f"  {col}: mean={col_data.mean():.2f}, std={col_data.std():.2f}, min={col_data.min()}, max={col_data.max()}\n"
+            
+            preview = df.head(3).to_string(max_cols=6)
+            
+            return f"""
+📊 CSV File Analysis:
+- File: {Path(file_path).name}
+- Dimensions: {rows:,} rows × {cols} columns
+- Numeric columns: {len(numeric_cols)} ({numeric_cols[:5]})
+- Text columns: {len(text_cols)} ({text_cols[:5]})
+- Missing values: {missing_data.sum()} total
+- File size: {os.path.getsize(file_path):,} bytes
+
+{numeric_summary}
+
+📋 Data Preview (first 3 rows):
+{preview}
+"""
+        except Exception as e:
+            return f"Error analyzing CSV file: {str(e)}"
+    
+    def _analyze_image_file(self, file_path: str) -> str:
+        try:
+            with Image.open(file_path) as img:
+                width, height = img.size
+                mode = img.mode
+                format_name = img.format
+                file_size = os.path.getsize(file_path)
+                
+                # Calculate aspect ratio
+                aspect_ratio = width / height
+                
+                # Determine image orientation
+                orientation = "Square" if abs(aspect_ratio - 1) < 0.1 else ("Landscape" if aspect_ratio > 1 else "Portrait")
+                
+                return f"""
+🖼️ Image File Analysis:
+- File: {Path(file_path).name}
+- Format: {format_name}
+- Dimensions: {width} × {height} pixels
+- Color mode: {mode}
+- Aspect ratio: {aspect_ratio:.2f} ({orientation})
+- File size: {file_size:,} bytes ({file_size/1024:.1f} KB)
+
+Note: For detailed image content analysis, the image will be processed by Gemini's vision capabilities.
+"""
+        except Exception as e:
+            return f"Error analyzing image: {str(e)}"
+
+class GeminiGAIAAgent:
+    """
+    Advanced GAIA benchmark agent using Google Gemini
+    Optimized for multimodal understanding and complex reasoning
+    """
+    
+    def __init__(self, 
+                 model_name: str = "gemini-2.5-flash",
+                 api_key: Optional[str] = None,
+                 temperature: float = 0.1,
+                 max_tokens: int = 2048,
+                 verbose: bool = True):
+        
+        self.model_name = model_name
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.verbose = verbose
+        
+        # Configure Gemini API
+        self._configure_gemini(api_key)
+        
+        # Initialize model
+        self.model = self._initialize_model()
+        
+        # Initialize tools
+        self.tools = self._initialize_tools()
+        
+        # Conversation history
+        self.conversation_history = []
+        
+        logger.info(f"Gemini GAIA Agent initialized with model: {model_name}")
+    
+    def _configure_gemini(self, api_key: Optional[str]):
+        """Configure Gemini API"""
+        if api_key:
+            genai.configure(api_key=api_key)
+        elif os.getenv("GOOGLE_API_KEY"):
+            genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
+        else:
+            logger.warning("No Google API key provided. Please set GOOGLE_API_KEY environment variable or pass api_key parameter.")
+    
+    def _initialize_model(self):
+        """Initialize the Gemini model"""
+        try:
+            # Configure safety settings for more permissive responses
+            safety_settings = {
+                HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE,
+                HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE,
+                HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE,
+                HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE,
+            }
+            
+            # Generation configuration
+            generation_config = genai.types.GenerationConfig(
+                temperature=self.temperature,
+                max_output_tokens=self.max_tokens,
+                top_p=0.8,
+                top_k=40
+            )
+            
+            model = genai.GenerativeModel(
+                model_name=self.model_name,
+                generation_config=generation_config,
+                safety_settings=safety_settings
+            )
+            
+            return model
+            
+        except Exception as e:
+            logger.error(f"Failed to initialize Gemini model: {str(e)}")
+            return None
+    
+    def _initialize_tools(self) -> Dict[str, GeminiTool]:
+        """Initialize all available tools"""
+        tools = {
+            "calculator": CalculatorTool(),
+            "web_search": WebSearchTool(),
+            "file_analyzer": FileAnalyzerTool(),
+        }
+        
+        return tools
+    
+    def _create_system_prompt(self) -> str:
+        """Create the system prompt for the agent"""
+        current_time = datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')
+        
+        return f"""You are an advanced AI assistant designed to solve GAIA benchmark questions with exceptional accuracy and reasoning.
+
+GAIA (General AI Assistants) benchmark tests your ability to:
+1. 🧠 **Complex Reasoning**: Multi-step problem solving and logical inference
+2. 🔧 **Tool Usage**: Effective use of calculators, web search, and file analysis
+3. 🖼️ **Multimodal Understanding**: Processing text, images, data files, and documents
+4. 🎯 **Accuracy**: Providing precise, well-researched answers
+
+AVAILABLE TOOLS:
+- **calculator**: Advanced mathematical operations, financial calculations, statistics
+- **web_search**: Current information from the web using DuckDuckGo
+- **file_analyzer**: Analysis of text files, CSV data, JSON, and images
+
+INSTRUCTIONS:
+1. **Think Step-by-Step**: Break down complex problems into logical steps
+2. **Use Tools Strategically**: Choose the right tools for each task
+3. **Verify Information**: Double-check calculations and search for current data when needed
+4. **Be Precise**: Provide exact, accurate answers with proper reasoning
+5. **Show Your Work**: Explain your thought process clearly
+6. **Handle Files**: Analyze uploaded files as part of your solution process
+
+RESPONSE FORMAT:
+When using tools, clearly indicate:
+- Which tool you're using and why
+- The input you're providing to the tool
+- How the tool's output contributes to your final answer
+
+Current Date/Time (UTC): {current_time}
+User: AdilzhanB
+
+Remember: Your goal is to provide the most accurate and well-reasoned answer possible for each GAIA question."""
+    
+    def _identify_required_tools(self, question: str, file_path: Optional[str] = None) -> List[str]:
+        """Identify which tools might be needed for a question"""
+        required_tools = []
+        question_lower = question.lower()
+        
+        # Mathematical operations
+        math_keywords = ['calculate', 'compute', 'math', 'formula', 'equation', 
+                        'interest', 'percentage', 'average', 'sum', 'multiply',
+                        'divide', 'square root', 'logarithm', 'statistics']
+        if any(keyword in question_lower for keyword in math_keywords):
+            required_tools.append('calculator')
+        
+        # Current/recent information
+        current_keywords = ['current', 'latest', 'recent', 'today', '2024', '2025',
+                          'now', 'present', 'up-to-date', 'newest']
+        search_keywords = ['population', 'price', 'news', 'event', 'happening']
+        if any(keyword in question_lower for keyword in current_keywords + search_keywords):
+            required_tools.append('web_search')
+        
+        # File analysis
+        if file_path or any(keyword in question_lower for keyword in 
+                          ['file', 'document', 'image', 'data', 'csv', 'analyze', 'uploaded']):
+            required_tools.append('file_analyzer')
+        
+        return required_tools
+    
+    def _use_tool(self, tool_name: str, input_data: str) -> str:
+        """Execute a specific tool with given input"""
+        if tool_name not in self.tools:
+            return f"Tool '{tool_name}' not available."
+        
+        try:
+            result = self.tools[tool_name].execute(input_data)
+            return result
+        except Exception as e:
+            return f"Error using {tool_name}: {str(e)}"
+    
+    def _process_image_for_gemini(self, file_path: str) -> Optional[dict]:
+        """Process image file for Gemini's multimodal capabilities"""
+        try:
+            with open(file_path, 'rb') as f:
+                image_data = f.read()
+            
+            # Convert to format Gemini expects
+            import mimetypes
+            mime_type, _ = mimetypes.guess_type(file_path)
+            
+            return {
+                'mime_type': mime_type or 'image/jpeg',
+                'data': image_data
+            }
+        except Exception as e:
+            logger.error(f"Error processing image: {str(e)}")
+            return None
+    
+    def solve_gaia_question(self, gaia_question: GAIAQuestion) -> Dict[str, Any]:
+        """
+        Main method to solve a GAIA benchmark question
+        """
+        start_time = datetime.utcnow()
+        logger.info(f"Solving GAIA Question {gaia_question.question_id} (Level {gaia_question.level})")
+        
+        if not self.model:
+            return {
+                "question_id": gaia_question.question_id,
+                "error": "Model not initialized. Please check your Google API key.",
+                "timestamp": start_time.isoformat()
+            }
+        
+        try:
+            # Step 1: Analyze question and identify required tools
+            required_tools = self._identify_required_tools(gaia_question.question, gaia_question.file_path)
+            
+            # Step 2: Gather context from tools
+            tool_results = {}
+            reasoning_steps = []
+            
+            # File analysis first (if applicable)
+            if gaia_question.file_path and os.path.exists(gaia_question.file_path):
+                reasoning_steps.append(f"📎 Analyzing uploaded file: {gaia_question.file_name}")
+                file_analysis = self._use_tool("file_analyzer", gaia_question.file_path)
+                tool_results["file_analyzer"] = file_analysis
+                reasoning_steps.append(f"✅ File analysis completed")
+            
+            # Use other tools as needed
+            for tool_name in required_tools:
+                if tool_name != "file_analyzer":  # Already handled above
+                    reasoning_steps.append(f"🔧 Using {tool_name} tool")
+                    
+                    if tool_name == "web_search":
+                        # Extract search query from question
+                        search_query = gaia_question.question
+                        tool_result = self._use_tool(tool_name, search_query)
+                    elif tool_name == "calculator":
+                        # For now, we'll let Gemini decide what to calculate
+                        tool_result = "Calculator tool available for mathematical operations"
+                    else:
+                        tool_result = self._use_tool(tool_name, gaia_question.question)
+                    
+                    tool_results[tool_name] = tool_result
+                    reasoning_steps.append(f"✅ {tool_name} completed")
+            
+            # Step 3: Prepare content for Gemini
+            content_parts = []
+            
+            # System prompt and question
+            prompt = f"""{self._create_system_prompt()}
+
+GAIA BENCHMARK QUESTION (Level {gaia_question.level}):
+Question ID: {gaia_question.question_id}
+Question: {gaia_question.question}
+
+AVAILABLE TOOL RESULTS:
+{json.dumps(tool_results, indent=2) if tool_results else "No tools used yet."}
+
+TASK:
+Solve this GAIA question step by step. You may request specific tool usage if needed by clearly stating:
+"USE_TOOL: [tool_name] with input: [input_data]"
+
+Provide your complete reasoning and final answer."""
+
+            content_parts.append(prompt)
+            
+            # Add image if it's an image file
+            if (gaia_question.file_path and 
+                Path(gaia_question.file_path).suffix.lower() in ['.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp']):
+                
+                image_data = self._process_image_for_gemini(gaia_question.file_path)
+                if image_data:
+                    content_parts.append(image_data)
+                    reasoning_steps.append("🖼️ Image included for visual analysis")
+            
+            # Step 4: Generate response with Gemini
+            reasoning_steps.append("🤖 Generating response with Gemini...")
+            
+            response = self.model.generate_content(content_parts)
+            
+            if not response or not response.text:
+                raise Exception("Empty response from Gemini model")
+            
+            agent_response = response.text
+            reasoning_steps.append("✅ Response generated successfully")
+            
+            # Step 5: Process any additional tool requests
+            if "USE_TOOL:" in agent_response:
+                reasoning_steps.append("🔧 Processing additional tool requests...")
+                agent_response = self._process_tool_requests(agent_response, reasoning_steps)
+            
+            # Step 6: Calculate confidence and metrics
+            confidence_score = self._calculate_confidence(agent_response, tool_results)
+            end_time = datetime.utcnow()
+            processing_time = (end_time - start_time).total_seconds()
+            
+            # Step 7: Prepare final result
+            result = {
+                "question_id": gaia_question.question_id,
+                "question": gaia_question.question,
+                "level": gaia_question.level,
+                "agent_response": agent_response,
+                "reasoning_steps": reasoning_steps,
+                "tools_used": list(tool_results.keys()),
+                "tool_results": tool_results,
+                "confidence_score": confidence_score,
+                "processing_time_seconds": processing_time,
+                "timestamp": end_time.isoformat(),
+                "model_used": self.model_name,
+                "agent_version": "1.0-gemini"
+            }
+            
+            # Add to conversation history
+            self.conversation_history.append(result)
+            
+            logger.info(f"Question {gaia_question.question_id} solved successfully in {processing_time:.2f}s")
+            return result
+            
+        except Exception as e:
+            error_msg = f"Error solving question: {str(e)}"
+            logger.error(error_msg)
+            
+            return {
+                "question_id": gaia_question.question_id,
+                "question": gaia_question.question,
+                "level": gaia_question.level,
+                "agent_response": f"Error: {error_msg}",
+                "error": True,
+                "timestamp": datetime.utcnow().isoformat(),
+                "model_used": self.model_name
+            }
+    
+    def _process_tool_requests(self, response: str, reasoning_steps: List[str]) -> str:
+        """Process tool usage requests from Gemini's response"""
+        lines = response.split('\n')
+        processed_response = []
+        
+        for line in lines:
+            if line.strip().startswith("USE_TOOL:"):
+                try:
+                    # Parse tool request: "USE_TOOL: calculator with input: 2+2"
+                    parts = line.split("USE_TOOL:")[1].strip()
+                    tool_name = parts.split("with input:")[0].strip()
+                    tool_input = parts.split("with input:")[1].strip()
+                    
+                    reasoning_steps.append(f"🔧 Executing {tool_name} with input: {tool_input}")
+                    
+                    # Execute the tool
+                    tool_result = self._use_tool(tool_name, tool_input)
+                    
+                    # Replace the tool request with the result
+                    processed_response.append(f"Tool Result ({tool_name}): {tool_result}")
+                    reasoning_steps.append(f"✅ {tool_name} executed successfully")
+                    
+                except Exception as e:
+                    processed_response.append(f"Tool Error: {str(e)}")
+                    reasoning_steps.append(f"❌ Tool execution failed: {str(e)}")
+            else:
+                processed_response.append(line)
+        
+        return '\n'.join(processed_response)
+    
+    def _calculate_confidence(self, response: str, tool_results: Dict) -> float:
+        """Calculate confidence score based on various factors"""
+        confidence = 0.5  # Base confidence
+        
+        # Increase confidence for detailed responses
+        if len(response) > 200:
+            confidence += 0.1
+        
+        # Increase confidence for tool usage
+        if tool_results:
+            confidence += 0.2
+        
+        # Increase confidence for structured responses
+        if any(marker in response for marker in ['Step', 'Analysis:', 'Result:', 'Conclusion:']):
+            confidence += 0.1
+        
+        # Decrease confidence for uncertainty indicators
+        uncertainty_words = ['uncertain', 'unclear', 'might', 'possibly', 'approximately', 'estimate']
+        if any(word in response.lower() for word in uncertainty_words):
+            confidence -= 0.1
+        
+        # Increase confidence for numerical precision
+        if any(char.isdigit() for char in response):
+            confidence += 0.1
+        
+        return max(0.0, min(1.0, confidence))
+    
+    def get_available_tools(self) -> List[str]:
+        """Get list of available tool names"""
+        return list(self.tools.keys())
+    
+    def test_tools(self) -> Dict[str, str]:
+        """Test all tools to ensure they're working"""
+        test_results = {}
+        
+        for tool_name, tool in self.tools.items():
+            try:
+                if tool_name == "calculator":
+                    result = tool.execute("sqrt(16)")
+                elif tool_name == "web_search":
+                    result = tool.execute("test search query")
+                elif tool_name == "file_analyzer":
+                    # Create a temporary test file
+                    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
+                        f.write("Test file content")
+                        temp_path = f.name
+                    
+                    result = tool.execute(temp_path)
+                    os.unlink(temp_path)  # Clean up
+                else:
+                    result = "Tool available"
+                
+                test_results[tool_name] = f"✅ Working: {result[:100]}..."
+                
+            except Exception as e:
+                test_results[tool_name] = f"❌ Error: {str(e)}"
+        
+        return test_results
+    
+    def get_conversation_history(self, limit: int = 5) -> List[Dict]:
+        """Get recent conversation history"""
+        return self.conversation_history[-limit:] if self.conversation_history else []
+
+# Example usage and testing
+if __name__ == "__main__":
+    import sys
+    
+    # Check for API key
+    if not os.getenv("GOOGLE_API_KEY"):
+        print("⚠️  Please set your GOOGLE_API_KEY environment variable")
+        print("You can get one from: https://makersuite.google.com/app/apikey")
+        sys.exit(1)
+    
+    # Initialize agent
+    print("🚀 Initializing Gemini GAIA Agent...")
+    agent = GeminiGAIAAgent(verbose=True)
+    
+    # Test tools
+    print("\n🔧 Testing tools...")
+    tool_results = agent.test_tools()
+    for tool, result in tool_results.items():
+        print(f"  {tool}: {result}")
+    
+    # Test with sample questions
+    sample_questions = [
+        GAIAQuestion(
+            question_id="test_001",
+            question="What is the square root of 144?",
+            level=1
+        ),
+        GAIAQuestion(
+            question_id="test_002", 
+            question="If I invest $1000 at 5% annual compound interest, how much will I have after 3 years?",
+            level=2
+        ),
+        GAIAQuestion(
+            question_id="test_003",
+            question="What is the current population of Tokyo according to the latest data?",
+            level=2
+        )
+    ]
+    
+    print("\n📝 Testing sample questions...")
+    for question in sample_questions:
+        print(f"\n{'='*60}")
+        result = agent.solve_gaia_question(question)
+        
+        print(f"Question: {result['question']}")
+        print(f"Level: {result['level']}")
+        print(f"Tools Used: {result.get('tools_used', [])}")
+        print(f"Confidence: {result.get('confidence_score', 0):.2f}")
+        print(f"Answer: {result['agent_response'][:300]}...")
+        
+        if result.get('error'):
+            print(f"❌ Error occurred: {result.get('agent_response')}")

app.py

@@ -0,0 +1,603 @@
+import os
+import json
+import tempfile
+import logging
+from typing import Dict, List, Any, Optional, Tuple
+from datetime import datetime
+import asyncio
+
+import gradio as gr
+import pandas as pd
+from agent import GeminiGAIAAgent, GAIAQuestion
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class GeminiGAIAApp:
+    """
+    Gradio application for Gemini-powered GAIA Benchmark Agent
+    Hugging Face Agents Course - Unit 4 Final Assignment
+    """
+    
+    def __init__(self):
+        self.agent = None
+        self.conversation_history = []
+        self.current_question_id = 0
+        
+        # Agent metadata
+        self.agent_info = {
+            "name": "Gemini GAIA Benchmark Agent",
+            "author": "AdilzhanB",
+            "course": "Hugging Face Agents Course - Unit 4",
+            "model": "Google Gemini 2.5 Flash",
+            "version": "1.0",
+            "created": "2025-06-17 15:32:22",
+            "capabilities": [
+                "Complex multi-step reasoning",
+                "Advanced mathematical calculations", 
+                "Real-time web search",
+                "Multimodal file analysis",
+                "Natural language understanding"
+            ]
+        }
+        
+        # Huggingface repository link
+        self.agent_code_link = "https://huggingface.co/spaces/AdilzhanB/Gemini-GAIA-Agent"
+        
+    def _initialize_agent(self, api_key: Optional[str] = None):
+        """Initialize the Gemini GAIA agent"""
+        try:
+            self.agent = GeminiGAIAAgent(
+                model_name="gemini-1.5-pro",
+                api_key=api_key,
+                temperature=0.1,
+                verbose=False
+            )
+            logger.info("Gemini agent initialized successfully")
+            return "✅ Agent initialized successfully!"
+        except Exception as e:
+            error_msg = f"Failed to initialize agent: {str(e)}"
+            logger.error(error_msg)
+            self.agent = None
+            return f"❌ {error_msg}"
+    
+    def solve_question(self, 
+                      question_text: str, 
+                      difficulty_level: int, 
+                      uploaded_file, 
+                      api_key: Optional[str] = None) -> Tuple[str, str, str, str, str, str]:
+        """
+        Main function to solve GAIA questions
+        
+        Returns: (reasoning, tools_used, confidence, processing_time, final_answer, status)
+        """
+        try:
+            # Initialize agent if needed or API key changed
+            if not self.agent or (api_key and api_key.strip()):
+                init_status = self._initialize_agent(api_key.strip() if api_key else None)
+                if "❌" in init_status:
+                    return "", "", "", "", "", init_status
+            
+            if not self.agent:
+                return "", "", "", "", "", "❌ Agent not initialized. Please provide a valid Google API key."
+            
+            if not question_text.strip():
+                return "", "", "", "", "", "❌ Please enter a question."
+            
+            # Handle file upload
+            file_path = None
+            file_name = None
+            if uploaded_file is not None:
+                file_path = uploaded_file.name
+                file_name = os.path.basename(file_path)
+            
+            # Create GAIA question
+            self.current_question_id += 1
+            gaia_question = GAIAQuestion(
+                question_id=f"user_question_{self.current_question_id}",
+                question=question_text,
+                level=difficulty_level,
+                file_path=file_path,
+                file_name=file_name
+            )
+            
+            # Solve the question
+            logger.info(f"Solving question: {question_text[:50]}...")
+            result = self.agent.solve_gaia_question(gaia_question)
+            
+            # Store in conversation history
+            self.conversation_history.append({
+                "timestamp": datetime.now().isoformat(),
+                "question": question_text,
+                "result": result
+            })
+            
+            # Extract results
+            if result.get("error"):
+                return "", "", "", "", "", f"❌ Error: {result.get('agent_response', 'Unknown error')}"
+            
+            # Format reasoning steps
+            reasoning_steps = "\n".join([
+                f"{i+1}. {step}" for i, step in enumerate(result.get("reasoning_steps", []))
+            ])
+            if not reasoning_steps:
+                reasoning_steps = "Gemini processed the question using its internal reasoning."
+            
+            # Format tools used
+            tools_used = ", ".join(result.get("tools_used", ["None"]))
+            if not tools_used or tools_used == "None":
+                tools_used = "Gemini's built-in capabilities"
+            
+            # Get other metrics
+            confidence = f"{result.get('confidence_score', 0.0):.2f}"
+            processing_time = f"{result.get('processing_time_seconds', 0):.2f}s"
+            final_answer = result.get("agent_response", "No answer generated")
+            
+            # Success status
+            status = f"✅ Question solved successfully! (Model: {result.get('model_used', 'Gemini')})"
+            
+            logger.info(f"Question solved successfully. Tools: {tools_used}, Confidence: {confidence}")
+            
+            return (
+                reasoning_steps,
+                tools_used,
+                confidence,
+                processing_time,
+                final_answer,
+                status
+            )
+            
+        except Exception as e:
+            error_msg = f"❌ Error solving question: {str(e)}"
+            logger.error(error_msg)
+            return "", "", "", "", "", error_msg
+    
+    def get_conversation_history(self) -> str:
+        """Get formatted conversation history"""
+        if not self.conversation_history:
+            return "No questions solved yet. Try asking a GAIA-style question!"
+        
+        history_text = "## 📚 Recent Conversation History\n\n"
+        
+        for i, entry in enumerate(self.conversation_history[-5:], 1):  # Show last 5
+            result = entry['result']
+            
+            history_text += f"### Question {i}\n"
+            history_text += f"**Asked:** {entry['question'][:150]}...\n"
+            history_text += f"**Level:** {result.get('level', 'N/A')}\n"
+            history_text += f"**Tools Used:** {', '.join(result.get('tools_used', ['None']))}\n"
+            history_text += f"**Confidence:** {result.get('confidence_score', 0):.2f}\n"
+            history_text += f"**Answer Preview:** {result.get('agent_response', 'No answer')[:200]}...\n"
+            history_text += f"**Time:** {entry['timestamp'][:19]}\n\n"
+            history_text += "---\n\n"
+        
+        return history_text
+    
+    def clear_history(self) -> str:
+        """Clear conversation history"""
+        self.conversation_history = []
+        self.current_question_id = 0
+        return "🗑️ History cleared successfully!"
+    
+    def test_agent_capabilities(self, api_key: Optional[str] = None) -> str:
+        """Test agent and tool capabilities"""
+        try:
+            # Initialize agent if needed
+            if not self.agent or (api_key and api_key.strip()):
+                init_status = self._initialize_agent(api_key.strip() if api_key else None)
+                if "❌" in init_status:
+                    return init_status
+            
+            if not self.agent:
+                return "❌ Agent not initialized. Please provide a valid Google API key."
+            
+            # Test tools
+            tool_results = self.agent.test_tools()
+            
+            result_text = "## 🔧 Agent Capability Test Results\n\n"
+            result_text += f"**Model:** {self.agent.model_name}\n"
+            result_text += f"**Status:** {'✅ Initialized' if self.agent.model else '❌ Not initialized'}\n\n"
+            
+            result_text += "### Tool Test Results\n"
+            
+            for tool_name, result in tool_results.items():
+                status_icon = "✅" if "✅" in result else "❌"
+                result_text += f"{status_icon} **{tool_name.title()}**: {result}\n"
+            
+            result_text += "\n### Available Capabilities\n"
+            for capability in self.agent_info["capabilities"]:
+                result_text += f"- ✅ {capability}\n"
+            
+            return result_text
+            
+        except Exception as e:
+            return f"❌ Error testing agent: {str(e)}"
+    
+    def get_example_question(self, level: int, example_type: str) -> Tuple[str, int]:
+        """Get example questions based on level and type"""
+        examples = {
+            1: {
+                "math": "What is the square root of 144?",
+                "factual": "What is the capital of Japan?",
+                "conversion": "Convert 100 degrees Fahrenheit to Celsius"
+            },
+            2: {
+                "financial": "If I invest $1000 at 5% annual compound interest, how much will I have after 3 years?",
+                "current": "What is the current population of Tokyo according to the latest data?",
+                "analysis": "Calculate the average temperature if the daily temperatures were 72°F, 75°F, 68°F, and 71°F"
+            },
+            3: {
+                "complex": "Based on current economic indicators, what are the main recession risks for 2024?",
+                "research": "Compare the GDP growth rates of the top 5 economies in 2023 and identify key trends",
+                "multimodal": "Analyze any uploaded data file and provide insights about patterns and trends"
+            }
+        }
+        
+        question = examples.get(level, {}).get(example_type, "What is 2 + 2?")
+        return question, level
+    
+    def create_interface(self):
+        """Create the comprehensive Gradio interface"""
+        
+        # Custom CSS for professional styling
+        custom_css = """
+        .gradio-container {
+            max-width: 1400px !important;
+            margin: 0 auto;
+        }
+        .main-header {
+            text-align: center;
+            background: linear-gradient(90deg, #4285f4, #34a853, #fbbc05, #ea4335);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            background-clip: text;
+            margin-bottom: 20px;
+        }
+        .info-box {
+            background-color: #f8f9fa;
+            border-left: 4px solid #4285f4;
+            padding: 15px;
+            margin: 10px 0;
+            border-radius: 5px;
+        }
+        """
+        
+        with gr.Blocks(css=custom_css, title="Gemini GAIA Agent", theme=gr.themes.Soft()) as interface:
+            
+            # Main Header
+            gr.HTML("""
+                <div class="main-header">
+                    <h1>🚀 Gemini GAIA Benchmark Agent</h1>
+                </div>
+            """)
+            
+            # Agent Information
+            with gr.Row():
+                gr.Markdown(f"""
+                <div class="info-box">
+                    <h3>🤖 Agent Information</h3>
+                    <ul>
+                        <li><strong>Created by:</strong> {self.agent_info['author']}</li>
+                        <li><strong>Course:</strong> {self.agent_info['course']}</li>
+                        <li><strong>Model:</strong> {self.agent_info['model']}</li>
+                        <li><strong>Version:</strong> {self.agent_info['version']}</li>
+                        <li><strong>Date:</strong> {self.agent_info['created']}</li>
+                    </ul>
+                </div>
+                """)
+            
+            # API Key Configuration
+            with gr.Row():
+                with gr.Column():
+                    api_key_input = gr.Textbox(
+                        label="🔑 Google API Key (Required)",
+                        placeholder="Enter your Google AI API key here...",
+                        type="password",
+                        info="Get your free API key from: https://makersuite.google.com/app/apikey"
+                    )
+                    test_agent_btn = gr.Button("🧪 Test Agent & Tools", variant="secondary")
+            
+            # Main Question Interface
+            gr.Markdown("## 💭 Ask Your GAIA Question")
+            
+            with gr.Row():
+                # Left Panel - Input
+                with gr.Column(scale=2):
+                    question_input = gr.Textbox(
+                        label="📝 Your Question",
+                        placeholder="Enter your GAIA-style question here...\n\nExamples:\n- What is the compound interest on $1000 at 5% for 3 years?\n- What is the current population of Tokyo?\n- Analyze the uploaded CSV data and find patterns",
+                        lines=4,
+                        max_lines=8
+                    )
+                    
+                    with gr.Row():
+                        difficulty_slider = gr.Slider(
+                            label="🎯 Difficulty Level",
+                            minimum=1,
+                            maximum=3,
+                            value=2,
+                            step=1,
+                            info="1=Basic | 2=Intermediate | 3=Advanced"
+                        )
+                        
+                        file_upload = gr.File(
+                            label="📎 Upload File (Optional)",
+                            file_types=[".txt", ".csv", ".json", ".xlsx", ".png", ".jpg", ".jpeg", ".gif", ".pdf"],
+                            info="Support: Text, Data, Images"
+                        )
+                    
+                    solve_button = gr.Button(
+                        "🚀 Solve with Gemini",
+                        variant="primary",
+                        size="lg",
+                        scale=2
+                    )
+                
+                # Right Panel - Quick Examples
+                with gr.Column(scale=1):
+                    gr.Markdown("### 📚 Quick Examples")
+                    
+                    # Level 1 Examples
+                    gr.Markdown("**Level 1 (Basic)**")
+                    with gr.Row():
+                        math_btn = gr.Button("🧮 Math", size="sm")
+                        factual_btn = gr.Button("🌍 Factual", size="sm")
+                        convert_btn = gr.Button("🔄 Convert", size="sm")
+                    
+                    # Level 2 Examples  
+                    gr.Markdown("**Level 2 (Intermediate)**")
+                    with gr.Row():
+                        finance_btn = gr.Button("💰 Finance", size="sm")
+                        current_btn = gr.Button("📊 Current", size="sm")
+                        analysis_btn = gr.Button("📈 Analysis", size="sm")
+                    
+                    # Level 3 Examples
+                    gr.Markdown("**Level 3 (Advanced)**")
+                    with gr.Row():
+                        complex_btn = gr.Button("🧠 Complex", size="sm")
+                        research_btn = gr.Button("🔬 Research", size="sm")
+                        multimodal_btn = gr.Button("🖼️ Multimodal", size="sm")
+            
+            # Output Section
+            gr.Markdown("## 🎯 Agent Response")
+            
+            with gr.Row():
+                # Main Answer
+                with gr.Column(scale=2):
+                    final_answer_output = gr.Textbox(
+                        label="🤖 Gemini's Answer",
+                        lines=8,
+                        max_lines=15,
+                        show_copy_button=True,
+                        info="Complete response with reasoning and solution"
+                    )
+                
+                # Metrics
+                with gr.Column(scale=1):
+                    confidence_output = gr.Textbox(
+                        label="📊 Confidence Score",
+                        max_lines=1,
+                        info="Agent's confidence in the answer"
+                    )
+                    
+                    processing_time_output = gr.Textbox(
+                        label="⏱️ Processing Time",
+                        max_lines=1,
+                        info="Time taken to solve"
+                    )
+                    
+                    tools_used_output = gr.Textbox(
+                        label="🔧 Tools Used",
+                        max_lines=3,
+                        info="Which capabilities were utilized"
+                    )
+                    
+                    status_output = gr.Textbox(
+                        label="✅ Status",
+                        max_lines=2,
+                        info="Execution status and model info"
+                    )
+            
+            # Detailed Reasoning (Expandable)
+            with gr.Accordion("🔍 Detailed Reasoning Steps", open=False):
+                reasoning_output = gr.Textbox(
+                    label="Step-by-Step Reasoning",
+                    lines=10,
+                    show_copy_button=True,
+                    info="Detailed breakdown of the solution process"
+                )
+            
+            # Additional Features Tabs
+            with gr.Tabs():
+                # Tool Testing Tab
+                with gr.TabItem("🛠️ Agent Capabilities"):
+                    tool_test_output = gr.Markdown(
+                        "Click 'Test Agent & Tools' above to check all capabilities.",
+                        elem_classes=["info-box"]
+                    )
+                    
+                    gr.Markdown("""
+                    ### 🎯 GAIA Benchmark Capabilities
+                    
+                    This agent is designed to excel at:
+                    
+                    - **🧠 Complex Reasoning**: Multi-step logical problem solving
+                    - **🧮 Mathematical Operations**: Advanced calculations and financial modeling  
+                    - **🔍 Web Search**: Real-time information retrieval using DuckDuckGo
+                    - **📄 File Analysis**: Processing text, CSV, JSON, and image files
+                    - **🖼️ Multimodal Understanding**: Analyzing images with Gemini's vision capabilities
+                    - **📊 Data Processing**: Statistical analysis and pattern recognition
+                    """)
+                
+                # History Tab
+                with gr.TabItem("📚 Conversation History"):
+                    with gr.Row():
+                        refresh_history_btn = gr.Button("🔄 Refresh History", variant="secondary")
+                        clear_history_btn = gr.Button("🗑️ Clear History", variant="stop")
+                    
+                    history_output = gr.Markdown(
+                        "No questions solved yet. Start by asking a GAIA question!",
+                        elem_classes=["info-box"]
+                    )
+                
+                # Documentation Tab
+                with gr.TabItem("📖 About GAIA"):
+                    gr.Markdown(f"""
+                    ### 🎯 What is GAIA?
+                    
+                    **GAIA (General AI Assistants)** is a comprehensive benchmark designed to evaluate AI assistants on real-world tasks that require:
+                    
+                    #### 🧠 Core Capabilities Tested
+                    - **Reasoning**: Complex multi-step problem solving and logical inference
+                    - **Multimodal Understanding**: Processing text, images, documents, and data files
+                    - **Web Browsing**: Searching for and utilizing current information
+                    - **Tool Use**: Effective integration and use of various computational tools
+                    
+                    #### 📊 Difficulty Levels
+                    - **Level 1**: Basic factual questions and simple reasoning tasks
+                    - **Level 2**: Multi-step problems requiring tool integration
+                    - **Level 3**: Complex tasks requiring advanced reasoning and multiple tools
+                    
+                    #### 🚀 This Agent's Approach
+                    This implementation uses **Google Gemini 1.5 Pro** for its:
+                    - Superior multimodal capabilities (text + images)
+                    - Advanced reasoning and problem-solving
+                    - Large context window for complex tasks
+                    - Built-in safety and reliability features
+                    
+                    #### 🔗 Technical Details
+                    - **Model**: Google Gemini 1.5 Pro
+                    - **Framework**: Custom Python implementation
+                    - **Tools**: Calculator, Web Search, File Analyzer
+                    - **Interface**: Gradio 4.0+
+                    - **Author**: {self.agent_info['author']}
+                    
+                    #### 📚 Resources
+                    - [GAIA Benchmark Paper](https://arxiv.org/abs/2311.12983)
+                    - [GAIA Dataset](https://huggingface.co/datasets/gaia-benchmark/GAIA)
+                    - [Google AI Studio](https://makersuite.google.com/)
+                    - [Course Repository]({self.agent_code_link})
+                    """)
+            
+            # Wire up all the interactions
+            
+            # Main solve function
+            solve_button.click(
+                self.solve_question,
+                inputs=[question_input, difficulty_slider, file_upload, api_key_input],
+                outputs=[reasoning_output, tools_used_output, confidence_output, 
+                        processing_time_output, final_answer_output, status_output]
+            )
+            
+            # Tool testing
+            test_agent_btn.click(
+                self.test_agent_capabilities,
+                inputs=[api_key_input],
+                outputs=[tool_test_output]
+            )
+            
+            # History management
+            refresh_history_btn.click(
+                self.get_conversation_history,
+                outputs=[history_output]
+            )
+            
+            clear_history_btn.click(
+                self.clear_history,
+                outputs=[history_output]
+            )
+            
+            # Example buttons - Level 1
+            math_btn.click(
+                lambda: self.get_example_question(1, "math"),
+                outputs=[question_input, difficulty_slider]
+            )
+            factual_btn.click(
+                lambda: self.get_example_question(1, "factual"),
+                outputs=[question_input, difficulty_slider]
+            )
+            convert_btn.click(
+                lambda: self.get_example_question(1, "conversion"),
+                outputs=[question_input, difficulty_slider]
+            )
+            
+            # Example buttons - Level 2
+            finance_btn.click(
+                lambda: self.get_example_question(2, "financial"),
+                outputs=[question_input, difficulty_slider]
+            )
+            current_btn.click(
+                lambda: self.get_example_question(2, "current"),
+                outputs=[question_input, difficulty_slider]
+            )
+            analysis_btn.click(
+                lambda: self.get_example_question(2, "analysis"),
+                outputs=[question_input, difficulty_slider]
+            )
+            
+            # Example buttons - Level 3
+            complex_btn.click(
+                lambda: self.get_example_question(3, "complex"),
+                outputs=[question_input, difficulty_slider]
+            )
+            research_btn.click(
+                lambda: self.get_example_question(3, "research"),
+                outputs=[question_input, difficulty_slider]
+            )
+            multimodal_btn.click(
+                lambda: self.get_example_question(3, "multimodal"),
+                outputs=[question_input, difficulty_slider]
+            )
+            
+            # Footer
+            gr.HTML(f"""
+                <div style="text-align: center; margin-top: 40px; padding: 20px; background-color: #f8f9fa; border-radius: 10px;">
+                    <h3>🎓 Hugging Face Agents Course - Unit 4 Final Assignment</h3>
+                    <p><strong>Gemini GAIA Benchmark Agent</strong> | Created with ❤️ by {self.agent_info['author']}</p>
+                    <p>🔗 <a href="{self.agent_code_link}" target="_blank">View Source Code</a> | 
+                       📚 <a href="https://huggingface.co/learn/agents-course" target="_blank">Course Materials</a> |
+                       🤖 <a href="https://makersuite.google.com/" target="_blank">Google AI Studio</a></p>
+                    <p><em>Powered by Google Gemini 1.5 Pro • Built with Gradio • Current Time (UTC): 2025-06-17 15:32:22</em></p>
+                </div>
+            """)
+        
+        return interface
+
+def main():
+    """Main function to launch the Gemini GAIA application"""
+    
+    # Configure logging
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    
+    logger.info("🚀 Starting Gemini GAIA Benchmark Agent Application...")
+    
+    # Create the application
+    app = GeminiGAIAApp()
+    interface = app.create_interface()
+    
+    # Launch configuration for Hugging Face Spaces
+    launch_kwargs = {
+        "share": True,  # Create public shareable link
+        "server_name": "0.0.0.0",  # Allow external connections  
+        "server_port": 7860,  # Default Gradio port
+        "show_error": True,  # Show errors in UI
+        "quiet": False,  # Show startup logs
+        "favicon_path": None,  # Custom favicon
+        "auth": None,  # No authentication required
+    }
+    
+    logger.info("🌐 Launching Gradio interface...")
+    logger.info("🔗 The app will be available at http://localhost:7860")
+    
+    try:
+        interface.launch(**launch_kwargs)
+    except Exception as e:
+        logger.error(f"❌ Failed to launch application: {str(e)}")
+        print("Please check your environment setup and try again.")
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,28 @@
+# Core dependencies for Gemini GAIA Agent
+gradio>=4.36.0
+google-generativeai>=0.7.0
+
+# Data processing and analysis
+pandas>=2.0.0
+numpy>=1.24.0
+Pillow>=10.0.0
+
+# Web search capabilities
+duckduckgo-search>=5.0.0
+requests>=2.31.0
+
+# Utilities and environment
+python-dotenv>=1.0.0
+asyncio>=3.4.3
+pathlib>=1.0.0
+
+# Optional: Enhanced functionality
+beautifulsoup4>=4.12.0
+lxml>=4.9.0
+openpyxl>=3.1.0
+markdown>=3.5.0
+
+# Development and testing (optional)
+pytest>=7.4.0
+black>=23.0.0
+flake8>=6.0.0