example_agent.py

"""
Example GAIA Agent Implementation

This file shows how to implement a basic agent with external API integration.
You can use this as a starting point and customize it for your needs.
"""

import requests
import json
import re
from typing import Dict, List, Any
from agent_implementation import BaseGAIAAgent

class ExampleGAIAAgent(BaseGAIAAgent):
    """
    Example agent implementation with basic reasoning and external API support.
    
    This agent demonstrates:
    1. Basic question analysis
    2. Mathematical calculations
    3. Simple reasoning patterns
    4. Error handling
    """
    
    def __init__(self):
        super().__init__()
        self.calculation_patterns = [
            r'(\d+)\s*\+\s*(\d+)',
            r'(\d+)\s*-\s*(\d+)',
            r'(\d+)\s*\*\s*(\d+)',
            r'(\d+)\s*/\s*(\d+)',
            r'(\d+)\s*%\s*(\d+)'
        ]
    
    def generate_answer(self, question: Dict) -> str:
        """
        Generate an answer for a given question.
        
        This implementation includes:
        - Question type detection
        - Mathematical calculations
        - Basic reasoning
        - File content processing
        """
        task_id = question.get("task_id", "")
        question_text = question.get("question", "")
        
        # Download any associated files
        file_content = self.download_file(task_id)
        
        # Analyze the question type
        question_type = self.analyze_question_type(question_text)
        
        # Generate answer based on question type
        if question_type == "calculation":
            answer = self.handle_calculation(question_text)
        elif question_type == "temporal":
            answer = self.handle_temporal(question_text)
        elif question_type == "factual":
            answer = self.handle_factual(question_text, file_content)
        else:
            answer = self.handle_general(question_text, file_content)
        
        return answer
    
    def analyze_question_type(self, question: str) -> str:
        """Determine the type of question based on keywords and patterns."""
        question_lower = question.lower()
        
        # Check for mathematical operations
        if any(op in question_lower for op in ["calculate", "compute", "sum", "total", "percentage", "percent"]):
            return "calculation"
        
        # Check for temporal questions
        if any(word in question_lower for word in ["when", "date", "time", "year", "month", "day"]):
            return "temporal"
        
        # Check for factual questions
        if any(word in question_lower for word in ["what", "which", "who", "where"]):
            return "factual"
        
        return "general"
    
    def handle_calculation(self, question: str) -> str:
        """Handle mathematical calculation questions."""
        # Extract numbers and operations
        for pattern in self.calculation_patterns:
            match = re.search(pattern, question)
            if match:
                num1 = float(match.group(1))
                num2 = float(match.group(2))
                
                if '+' in pattern:
                    result = num1 + num2
                    operation = "addition"
                elif '-' in pattern:
                    result = num1 - num2
                    operation = "subtraction"
                elif '*' in pattern:
                    result = num1 * num2
                    operation = "multiplication"
                elif '/' in pattern:
                    if num2 == 0:
                        return "Error: Division by zero"
                    result = num1 / num2
                    operation = "division"
                elif '%' in pattern:
                    result = num1 % num2
                    operation = "modulo"
                
                return f"The result of {operation} {num1} and {num2} is {result}"
        
        # Handle percentage calculations
        percentage_match = re.search(r'(\d+)%\s*of\s*(\d+)', question)
        if percentage_match:
            percentage = float(percentage_match.group(1))
            value = float(percentage_match.group(2))
            result = (percentage / 100) * value
            return f"{percentage}% of {value} is {result}"
        
        return "I cannot perform the requested calculation with the given information."
    
    def handle_temporal(self, question: str) -> str:
        """Handle temporal questions."""
        # Extract dates
        date_patterns = [
            r'(\d{4})-(\d{2})-(\d{2})',
            r'(\d{1,2})/(\d{1,2})/(\d{4})',
            r'(\w+)\s+(\d{1,2}),?\s+(\d{4})'
        ]
        
        for pattern in date_patterns:
            match = re.search(pattern, question)
            if match:
                if pattern == r'(\d{4})-(\d{2})-(\d{2})':
                    year, month, day = match.groups()
                    return f"The date is {year}-{month}-{day}"
                elif pattern == r'(\d{1,2})/(\d{1,2})/(\d{4})':
                    month, day, year = match.groups()
                    return f"The date is {month}/{day}/{year}"
                elif pattern == r'(\w+)\s+(\d{1,2}),?\s+(\d{4})':
                    month, day, year = match.groups()
                    return f"The date is {month} {day}, {year}"
        
        return "I cannot determine the specific date or time from the question."
    
    def handle_factual(self, question: str, file_content: str) -> str:
        """Handle factual questions."""
        # If there's file content, try to extract relevant information
        if file_content:
            # Simple keyword matching
            question_keywords = self.extract_keywords(question)
            file_lines = file_content.split('\n')
            
            for line in file_lines:
                if any(keyword.lower() in line.lower() for keyword in question_keywords):
                    return f"Based on the file content: {line.strip()}"
        
        # For general factual questions, provide a structured response
        return self.generate_structured_answer(question)
    
    def handle_general(self, question: str, file_content: str) -> str:
        """Handle general questions."""
        # Combine file content analysis with general reasoning
        if file_content:
            return f"Based on the provided information: {file_content[:200]}..."
        
        return self.generate_structured_answer(question)
    
    def extract_keywords(self, text: str) -> List[str]:
        """Extract important keywords from text."""
        # Remove common words
        stop_words = {"the", "a", "an", "and", "or", "but", "in", "on", "at", "to", "for", "of", "with", "by", "is", "are", "was", "were"}
        words = re.findall(r'\b\w+\b', text.lower())
        keywords = [word for word in words if word not in stop_words and len(word) > 2]
        return keywords
    
    def generate_structured_answer(self, question: str) -> str:
        """Generate a structured answer for general questions."""
        # This is a placeholder - you would implement your own reasoning here
        # You could integrate with external APIs like OpenAI, Anthropic, etc.
        
        # Example structure:
        answer_parts = [
            "Based on my analysis of the question:",
            f"- Question type: {self.analyze_question_type(question)}",
            "- Key information needed: [identify what's needed]",
            "- Reasoning approach: [describe your method]",
            "- Answer: [provide your answer]"
        ]
        
        return "\n".join(answer_parts)
    
    def enhance_with_external_api(self, question: str) -> str:
        """
        Example of how to integrate with external APIs.
        Uncomment and customize this method if you want to use external services.
        """
        # Example with OpenAI (you would need to add your API key)
        """
        import openai
        
        try:
            response = openai.ChatCompletion.create(
                model="gpt-4",
                messages=[
                    {"role": "system", "content": "You are a helpful assistant that answers questions accurately and concisely."},
                    {"role": "user", "content": question}
                ],
                temperature=0.1
            )
            return response.choices[0].message.content
        except Exception as e:
            return f"Error calling external API: {e}"
        """
        
        # Placeholder return
        return "External API integration not configured. Please implement your own API calls."

# Example usage and testing
if __name__ == "__main__":
    # Create an instance of the example agent
    agent = ExampleGAIAAgent()
    
    # Test questions
    test_questions = [
        {
            "task_id": "test_001",
            "question": "What is 15 + 27?"
        },
        {
            "task_id": "test_002", 
            "question": "What is 25% of 80?"
        },
        {
            "task_id": "test_003",
            "question": "What is the date 2024-03-15?"
        },
        {
            "task_id": "test_004",
            "question": "What is the capital of France?"
        }
    ]
    
    # Test the agent
    print("Testing Example GAIA Agent:")
    print("=" * 50)
    
    for i, question in enumerate(test_questions, 1):
        print(f"\nTest {i}:")
        print(f"Question: {question['question']}")
        answer = agent.generate_answer(question)
        print(f"Answer: {answer}")
        print("-" * 30)