QA Agent for Certification

.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.py[cod]
+*.so
+.env
+.Python
+.venv
+build/
+dist/
+cache/
+GAIA/
+google.json

README.md

@@ -1,8 +1,8 @@
 ---
-title: Template Final Assignment
-emoji: 🕵🏻‍♂️
+title: Q&A Agent with tool use to answer questions
+emoji: 🤖
 colorFrom: indigo
-colorTo: indigo
+colorTo: yellow
 sdk: gradio
 sdk_version: 5.25.2
 app_file: app.py

app.py

@@ -1,34 +1,210 @@
 import os
 import gradio as gr
 import requests
-import inspect
 import pandas as pd
+import yaml
+from smolagents import CodeAgent, LiteLLMModel, DuckDuckGoSearchTool, WikipediaSearchTool
+from datasets import load_dataset
+from cache_manager import CacheManager
+from tools.final_answer import final_answer
+from tools.get_file import get_file
+from tools.web_scraping import (
+    scrape_webpage_content,
+    extract_links_from_webpage,
+    get_webpage_metadata
+)
+
+# Load the GAIA dataset
+dataset = load_dataset("gaia-benchmark/GAIA", "2023_level1", trust_remote_code=True, cache_dir="GAIA")
+print("GAIA dataset loaded successfully.")
+
+# Initialize cache manager
+cache_manager = CacheManager()
 
-# (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-class BasicAgent:
-    def __init__(self):
-        print("BasicAgent initialized.")
+# --- QA Agent Definition ---
+class QAAgent:
+    def __init__(self, temperature=None, max_tokens=None, max_steps=None):
+        """
+        Initialize the QA Agent with configuration from config.yaml.
+        
+        Args:
+            temperature: Temperature for text generation (overrides config)
+            max_tokens: Maximum number of tokens for the model (overrides config)
+            max_steps: Maximum number of steps the agent can take (overrides config)
+        """
+        print("Initializing QA Agent with configuration...")
+        
+        try:
+            # Load configuration
+            config = self._load_config()
+            
+            # Load prompts
+            prompts = self._load_prompts()
+            
+            # Get model configuration with overrides
+            model_config = config.get('model', {})
+            model_id = model_config.get('model_id', 'anthropic/claude-sonnet-4-20250514')
+            temp = temperature if temperature is not None else model_config.get('temperature', 0.2)
+            max_tok = max_tokens if max_tokens is not None else model_config.get('max_tokens', 2096)
+            
+            # Get agent configuration with overrides
+            agent_config = config.get('agent', {})
+            self.max_steps = max_steps if max_steps is not None else agent_config.get('max_steps', 5)
+            
+            print(f"Model: {model_id}")
+            print(f"Temperature: {temp}")
+            print(f"Max tokens: {max_tok}")
+            print(f"Max steps: {self.max_steps}")
+            
+            # Prepare model initialization parameters
+            model_params = {
+                'model_id': model_id,
+                'temperature': temp,
+                'max_tokens': max_tok
+            }
+            
+            # Add Vertex AI specific parameters if using a vertex_ai model
+            if model_id.startswith('vertex_ai/'):
+                print("Configuring Vertex AI parameters...")
+                vertex_config = config.get('vertex_ai', {})
+                
+                # Add vertex project if specified
+                if 'vertex_project' in vertex_config and vertex_config['vertex_project'] != 'your-gcp-project-id':
+                    model_params['vertex_project'] = vertex_config['vertex_project']
+                    print(f"  Vertex Project: {vertex_config['vertex_project']}")
+                
+                # Add vertex location if specified
+                if 'vertex_location' in vertex_config:
+                    model_params['vertex_location'] = vertex_config['vertex_location']
+                    print(f"  Vertex Location: {vertex_config['vertex_location']}")
+                
+                # Add vertex credentials if specified and valid
+                creds_path = vertex_config.get('vertex_credentials')
+                if creds_path and creds_path not in ['/path/to/service-account.json', './google.json']:
+                    if os.path.exists(creds_path):
+                        try:
+                            # Validate it's a proper JSON file
+                            import json
+                            with open(creds_path, 'r') as f:
+                                json.load(f)
+                            model_params['vertex_credentials'] = creds_path
+                            print(f"  Vertex Credentials: {creds_path}")
+                        except (json.JSONDecodeError, Exception) as e:
+                            print(f"  Warning: Invalid credentials file {creds_path}: {e}")
+                    else:
+                        print(f"  Warning: Credentials file not found: {creds_path}")
+                
+                # Add safety settings if specified
+                if 'safety_settings' in vertex_config:
+                    model_params['safety_settings'] = vertex_config['safety_settings']
+                    print(f"  Safety Settings: {len(vertex_config['safety_settings'])} categories configured")
+            
+            # Initialize the LiteLLM model
+            model = LiteLLMModel(**model_params)
+            
+            # Available tools for the agent
+            tools = [
+                DuckDuckGoSearchTool(),
+                WikipediaSearchTool(),
+                get_file,
+                scrape_webpage_content,
+                extract_links_from_webpage,
+                get_webpage_metadata,
+                final_answer
+            ]
+            
+            # Create the agent without prompt_templates (they'll be used in question processing)
+            self.agent = CodeAgent(
+                tools=tools,
+                model=model,
+                max_steps=self.max_steps
+            )
+            
+            # Store prompts for use in question processing
+            self.prompts = prompts
+            
+            print("Agent initialized successfully!")
+            
+        except Exception as e:
+            # Provide helpful error messages based on the model type
+            error_msg = f"Error initializing QA Agent: {e}"
+            
+            if "authentication" in str(e).lower() or "api" in str(e).lower() or "credentials" in str(e).lower():
+                if hasattr(self, '_load_config'):
+                    config = self._load_config()
+                    model_id = config.get('model', {}).get('model_id', '')
+                    
+                    if "vertex_ai" in model_id.lower() or "gemini" in model_id.lower():
+                        error_msg += "\n\nFor Vertex AI models, please:"
+                        error_msg += "\n1. Set up authentication:"
+                        error_msg += "\n   Option A: gcloud auth application-default login"
+                        error_msg += "\n   Option B: export GOOGLE_APPLICATION_CREDENTIALS='/path/to/service-account.json'"
+                        error_msg += "\n   Option C: Set vertex_credentials in config.yaml"
+                        error_msg += "\n2. Update config.yaml with your:"
+                        error_msg += "\n   - vertex_project: 'your-gcp-project-id'"
+                        error_msg += "\n   - vertex_location: 'us-central1' (or your preferred region)"
+                    elif "anthropic" in model_id.lower():
+                        error_msg += "\n\nFor Anthropic models, please set: export ANTHROPIC_API_KEY='your-key-here'"
+                    elif "openai" in model_id.lower() or "gpt" in model_id.lower():
+                        error_msg += "\n\nFor OpenAI models, please set: export OPENAI_API_KEY='your-key-here'"
+            
+            print(error_msg)
+            raise Exception(error_msg)
+    
+    def _load_config(self):
+        """Load configuration from config.yaml"""
+        try:
+            with open('config.yaml', 'r') as f:
+                return yaml.safe_load(f)
+        except FileNotFoundError:
+            print("Warning: config.yaml not found, using default configuration")
+            return {}
+        except Exception as e:
+            print(f"Error loading config.yaml: {e}")
+            return {}
+    
+    def _load_prompts(self):
+        """Load prompts from prompts.yaml"""
+        try:
+            with open('prompts.yaml', 'r') as f:
+                return yaml.safe_load(f)
+        except FileNotFoundError:
+            print("Warning: prompts.yaml not found, using default prompts")
+            return {}
+        except Exception as e:
+            print(f"Error loading prompts.yaml: {e}")
+            return {}
+    
     def __call__(self, question: str) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer = "This is a default answer."
-        print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_answer
+        try:
+            # Get system prompt from loaded prompts and combine with question
+            system_prompt = self.prompts.get('system_prompt', '')
+            if system_prompt:
+                enhanced_question = f"{system_prompt}\n\n{question}"
+            else:
+                enhanced_question = question
+            
+            # Use the agent to run and answer the enhanced question
+            answer = self.agent.run(enhanced_question)
+            print(f"Agent returning answer (first 100 chars): {str(answer)[:100]}...")
+            return str(answer)
+        except Exception as e:
+            print(f"Error running agent: {e}")
+            return f"Error processing question: {e}"
 
-def run_and_submit_all( profile: gr.OAuthProfile | None):
+def run_questions(profile: gr.OAuthProfile | None):
     """
-    Fetches all questions, runs the BasicAgent on them, submits all answers,
-    and displays the results.
+    Fetches all questions, runs the QAAgent on them, and caches the answers.
     """
     # --- Determine HF Space Runtime URL and Repo URL ---
     space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
 
     if profile:
-        username= f"{profile.username}"
+        username = f"{profile.username}"
         print(f"User logged in: {username}")
     else:
         print("User not logged in.")
@@ -36,17 +212,13 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
     api_url = DEFAULT_API_URL
     questions_url = f"{api_url}/questions"
-    submit_url = f"{api_url}/submit"
 
-    # 1. Instantiate Agent ( modify this part to create your agent)
+    # 1. Instantiate Agent
     try:
-        agent = BasicAgent()
+        agent = QAAgent()
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
-    # In the case of an app running as a hugging Face space, this link points toward your codebase ( usefull for others so please keep it public)
-    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
-    print(agent_code)
 
     # 2. Fetch Questions
     print(f"Fetching questions from: {questions_url}")
@@ -58,45 +230,193 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
              print("Fetched questions list is empty.")
              return "Fetched questions list is empty or invalid format.", None
         print(f"Fetched {len(questions_data)} questions.")
-    except requests.exceptions.RequestException as e:
-        print(f"Error fetching questions: {e}")
-        return f"Error fetching questions: {e}", None
     except requests.exceptions.JSONDecodeError as e:
          print(f"Error decoding JSON response from questions endpoint: {e}")
          print(f"Response text: {response.text[:500]}")
          return f"Error decoding server response for questions: {e}", None
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching questions: {e}")
+        return f"Error fetching questions: {e}", None
     except Exception as e:
         print(f"An unexpected error occurred fetching questions: {e}")
         return f"An unexpected error occurred fetching questions: {e}", None
 
-    # 3. Run your Agent
+    # 3. Run Agent and Cache Results
     results_log = []
-    answers_payload = []
+    cached_count = 0
+    processed_count = 0
     print(f"Running agent on {len(questions_data)} questions...")
+    
     for item in questions_data:
         task_id = item.get("task_id")
         question_text = item.get("question")
+        file_name = item.get("file_name")
+        
         if not task_id or question_text is None:
             print(f"Skipping item with missing task_id or question: {item}")
             continue
-        try:
-            submitted_answer = agent(question_text)
+            
+        # Check if answer is already cached
+        cached_result = cache_manager.get_cached_answer(question_text)
+        if cached_result and cached_result.get('cache_valid', False):
+            print(f"Using cached answer for task {task_id}")
+            submitted_answer = cached_result['answer']
+            cached_count += 1
+            results_log.append({
+                "Task ID": task_id, 
+                "Question": question_text, 
+                "Submitted Answer": submitted_answer,
+                "Status": "Cached"
+            })
+        else:
+            # Run agent and cache the result
+            try:
+                print(f"Processing task {task_id} with agent...")
+                
+                # Enhance question with file information if file is present
+                enhanced_question = question_text
+                if file_name:
+                    enhanced_question = f"{question_text}\n\nNote: This question references a file named '{file_name}'. Use the get_file tool to retrieve its content."
+                
+                submitted_answer = agent(enhanced_question)
+                
+                # Cache the answer
+                cache_success = cache_manager.cache_answer(
+                    question=question_text,
+                    answer=submitted_answer,
+                    iterations=1,
+                    file_name=file_name
+                )
+                
+                processed_count += 1
+                status = "Processed & Cached" if cache_success else "Processed (Cache Failed)"
+                results_log.append({
+                    "Task ID": task_id, 
+                    "Question": question_text, 
+                    "Submitted Answer": submitted_answer,
+                    "Status": status
+                })
+                
+            except Exception as e:
+                print(f"Error running agent on task {task_id}: {e}")
+                error_answer = f"AGENT ERROR: {e}"
+                
+                # Cache the error (will be marked as invalid)
+                cache_manager.cache_answer(
+                    question=question_text,
+                    answer=error_answer,
+                    iterations=1,
+                    file_name=file_name
+                )
+                
+                results_log.append({
+                    "Task ID": task_id, 
+                    "Question": question_text, 
+                    "Submitted Answer": error_answer,
+                    "Status": "Error"
+                })
+
+    status_message = (
+        f"Questions processing completed!\n"
+        f"Total questions: {len(questions_data)}\n"
+        f"Used cached answers: {cached_count}\n"
+        f"Newly processed: {processed_count}\n"
+        f"Answers are cached and ready for submission."
+    )
+    
+    print(status_message)
+    results_df = pd.DataFrame(results_log)
+    return status_message, results_df
+
+def submit_answers(profile: gr.OAuthProfile | None):
+    """
+    Loads cached answers and submits them to the evaluation server.
+    """
+    # --- Determine HF Space Runtime URL and Repo URL ---
+    space_id = os.getenv("SPACE_ID")
+
+    if profile:
+        username = f"{profile.username}"
+        print(f"User logged in: {username}")
+    else:
+        print("User not logged in.")
+        return "Please Login to Hugging Face with the button.", None
+
+    api_url = DEFAULT_API_URL
+    questions_url = f"{api_url}/questions"
+    submit_url = f"{api_url}/submit"
+    
+    # In the case of an app running as a Hugging Face space, this link points toward your codebase
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    print(agent_code)
+
+    # 1. Fetch Questions to get task_ids
+    print(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:
+             print("Fetched questions list is empty.")
+             return "Fetched questions list is empty or invalid format.", None
+        print(f"Fetched {len(questions_data)} questions.")
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching questions: {e}")
+        return f"Error fetching questions: {e}", None
+
+    # 2. Load Cached Answers
+    answers_payload = []
+    results_log = []
+    missing_answers = []
+    
+    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}")
+            continue
+            
+        # Try to get cached answer
+        cached_result = cache_manager.get_cached_answer(question_text)
+        if cached_result and cached_result.get('cache_valid', False):
+            submitted_answer = cached_result['answer']
             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})
-        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}"})
+            results_log.append({
+                "Task ID": task_id, 
+                "Question": question_text, 
+                "Submitted Answer": submitted_answer,
+                "Status": "Ready for Submission"
+            })
+        else:
+            missing_answers.append(task_id)
+            results_log.append({
+                "Task ID": task_id, 
+                "Question": question_text, 
+                "Submitted Answer": "NO CACHED ANSWER",
+                "Status": "Missing Answer"
+            })
+
+    if missing_answers:
+        status_message = (
+            f"Cannot submit: Missing cached answers for {len(missing_answers)} questions.\n"
+            f"Missing task IDs: {missing_answers[:5]}{'...' if len(missing_answers) > 5 else ''}\n"
+            f"Please run the questions first to generate and cache answers."
+        )
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
 
     if not answers_payload:
-        print("Agent did not produce any answers to submit.")
-        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+        print("No valid cached answers found for submission.")
+        return "No valid cached answers found for submission.", pd.DataFrame(results_log)
 
-    # 4. Prepare Submission 
+    # 3. Prepare Submission 
     submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
-    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
+    status_update = f"Submitting {len(answers_payload)} cached answers for user '{username}'..."
     print(status_update)
 
-    # 5. Submit
+    # 4. Submit
     print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
     try:
         response = requests.post(submit_url, json=submission_data, timeout=60)
@@ -139,35 +459,55 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         results_df = pd.DataFrame(results_log)
         return status_message, results_df
 
+def clear_cache():
+    """Clear all cached answers."""
+    cache_manager.clear_cache()
+    return "Cache cleared successfully!", pd.DataFrame()
 
 # --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
-    gr.Markdown("# Basic Agent Evaluation Runner")
+    gr.Markdown("# QA Agent Evaluation Runner")
     gr.Markdown(
         """
         **Instructions:**
 
         1.  Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ...
         2.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
-        3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
+        3.  Click 'Run Questions' to fetch questions and run your agent (answers will be cached).
+        4.  Click 'Submit Answers' to submit the cached answers and see your score.
+        5.  Use 'Clear Cache' to remove all cached answers if needed.
 
         ---
-        **Disclaimers:**
-        Once clicking on the "submit button, it can take quite some time ( this is the time for the agent to go through all the questions).
-        This space provides a basic setup and is intentionally sub-optimal to encourage you to develop your own, more robust solution. For instance for the delay process of the submit button, a solution could be to cache the answers and submit in a seperate action or even to answer the questions in async.
+        **Benefits of Separate Run/Submit:**
+        - Answers are cached, so you can run questions once and submit multiple times
+        - Faster submission since answers are pre-computed
+        - Better error handling and recovery
+        - Ability to review answers before submission
         """
     )
 
     gr.LoginButton()
 
-    run_button = gr.Button("Run Evaluation & Submit All Answers")
+    with gr.Row():
+        run_button = gr.Button("Run Questions", variant="primary")
+        submit_button = gr.Button("Submit Answers", variant="secondary")
+        clear_button = gr.Button("Clear Cache", variant="stop")
 
-    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
-    # Removed max_rows=10 from DataFrame constructor
+    status_output = gr.Textbox(label="Status / Result", lines=5, interactive=False)
     results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
 
     run_button.click(
-        fn=run_and_submit_all,
+        fn=run_questions,
+        outputs=[status_output, results_table]
+    )
+    
+    submit_button.click(
+        fn=submit_answers,
+        outputs=[status_output, results_table]
+    )
+    
+    clear_button.click(
+        fn=clear_cache,
         outputs=[status_output, results_table]
     )
 
@@ -192,5 +532,5 @@ if __name__ == "__main__":
 
     print("-"*(60 + len(" App Starting ")) + "\n")
 
-    print("Launching Gradio Interface for Basic Agent Evaluation...")
+    print("Launching Gradio Interface for QA Agent Evaluation...")
     demo.launch(debug=True, share=False)

cache_manager.py

@@ -0,0 +1,250 @@
+"""
+Cache manager for storing and retrieving agent answers.
+"""
+
+import os
+import json
+import hashlib
+from typing import Optional, Dict, Any, List
+from datetime import datetime
+
+class CacheManager:
+    """Manages caching of agent answers to avoid redundant processing."""
+
+    def __init__(self, cache_dir: str = "cache"):
+        self.cache_dir = cache_dir
+        self.ensure_cache_dir()
+
+    def ensure_cache_dir(self):
+        """Create cache directory if it doesn't exist."""
+        if not os.path.exists(self.cache_dir):
+            os.makedirs(self.cache_dir)
+
+    def _get_question_hash(self, question: str) -> str:
+        """Generate a hash for the question to use as filename."""
+        return hashlib.md5(question.encode('utf-8')).hexdigest()[:12]
+
+    def _get_cache_path(self, question: str) -> str:
+        """Get the cache file path for a question."""
+        question_hash = self._get_question_hash(question)
+        return os.path.join(self.cache_dir, f"question_{question_hash}.json")
+
+    def get_cached_answer(self, question: str) -> Optional[Dict[str, Any]]:
+        """
+        Retrieve cached answer for a question.
+
+        Args:
+            question: The question to look up
+
+        Returns:
+            Dictionary with answer, iterations, and metadata if cached, None otherwise
+        """
+        cache_path = self._get_cache_path(question)
+        if not os.path.exists(cache_path):
+            return None
+        try:
+            with open(cache_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            answers = data.get('answers', [])
+            if not answers:
+                return None
+            last_answer = answers[-1]
+            return {
+                'answer': last_answer.get('answer', ''),
+                'iterations': last_answer.get('iterations', 0),
+                'timestamp': last_answer.get('timestamp', ''),
+                'cache_valid': data.get('cache_valid', False),
+                'file_name': data.get('file_name', None)
+            }
+        except Exception as e:
+            print(f"Error reading cache: {e}")
+            return None
+
+    def cache_answer(self, question: str, answer: Optional[str], iterations: int = 1, file_name: Optional[str] = None) -> bool:
+        """
+        Cache an answer for a question with iteration count.
+
+        Args:
+            question: The question that was asked
+            answer: The answer to cache
+            iterations: Number of iterations/steps used (should be 1-10 typically)
+
+        Returns:
+            True if cached successfully, False otherwise
+        """
+        cache_path = self._get_cache_path(question)
+        cache_valid = bool(answer and self.validate_answer_content(answer))
+        now = datetime.now().isoformat()
+        try:
+            if os.path.exists(cache_path):
+                with open(cache_path, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+            else:
+                data = {
+                    'question': question,
+                    'answers': [],
+                    'cache_valid': False,
+                    'file_name': file_name
+                }
+            # Always update file_name for logging
+            if file_name:
+                data['file_name'] = file_name
+                print(f"[CacheManager] file_name submitted: {file_name}")
+            # Add answer if available, else just update cache_valid
+            if cache_valid:
+                data['answers'].append({
+                    'answer': answer,
+                    'iterations': iterations,
+                    'timestamp': now
+                })
+                data['cache_valid'] = True
+            else:
+                # Even if no answer, mark cache_valid false and add a stub answer
+                data['answers'].append({
+                    'answer': answer if answer else "",
+                    'iterations': iterations,
+                    'timestamp': now
+                })
+                data['cache_valid'] = False
+            with open(cache_path, 'w', encoding='utf-8') as f:
+                json.dump(data, f, indent=2)
+            return True
+        except Exception as e:
+            print(f"Error caching answer: {e}")
+            return False
+
+    def validate_answer_content(self, answer: str) -> bool:
+        """
+        Validate that answer content is reasonable to cache.
+        Error messages and corrupted responses should NOT be cached as valid.
+
+        Args:
+            answer: The answer content to validate
+
+        Returns:
+            True if answer is valid to cache, False otherwise
+        """
+        if not answer or not isinstance(answer, str):
+            return False
+        
+        clean_answer = answer.strip()
+        if len(clean_answer) < 3:
+            return False
+        
+        # Check for error patterns - these should NEVER be cached as valid answers
+        error_patterns = [
+            'error calling llm',
+            'error running agent',
+            'error in',
+            'error processing',
+            'litellm.badrequest',
+            'litellm.exception',
+            'vertexaiexception',
+            'badrequest',
+            'invalid_argument',
+            'authentication',
+            'credentials',
+            'api key',
+            'traceback',
+            'exception occurred',
+            'failed to',
+            'unable to submit',
+            'mimetype parameter',
+            'not supported'
+        ]
+        
+        # Check if answer contains any error patterns (case insensitive)
+        lower_answer = clean_answer.lower()
+        for pattern in error_patterns:
+            if pattern in lower_answer:
+                print(f"[CacheManager] Rejecting answer containing error pattern: '{pattern}'")
+                return False
+        
+        # Check for corrupt/empty patterns
+        corrupt_patterns = [']', '[', '{}', '()', '""', "''", 'null', 'undefined']
+        if clean_answer in corrupt_patterns:
+            return False
+        
+        # Check if answer is only brackets/punctuation
+        if all(c in '[]{}()' for c in clean_answer):
+            return False
+        
+        return True
+
+    def clear_cache(self):
+        """Clear all cached answers."""
+        try:
+            for filename in os.listdir(self.cache_dir):
+                file_path = os.path.join(self.cache_dir, filename)
+                if os.path.isfile(file_path):
+                    os.remove(file_path)
+            print("Cache cleared successfully")
+        except Exception as e:
+            print(f"Error clearing cache: {e}")
+
+    def list_cached_questions(self) -> List[Dict[str, Any]]:
+        """List all cached questions with metadata."""
+        cached_questions = []
+        try:
+            for filename in os.listdir(self.cache_dir):
+                if filename.startswith('question_') and filename.endswith('.json'):
+                    cache_path = os.path.join(self.cache_dir, filename)
+                    with open(cache_path, 'r', encoding='utf-8') as f:
+                        data = json.load(f)
+                        cached_questions.append({
+                            'question': data.get('question', ''),
+                            'cache_valid': data.get('cache_valid', False),
+                            'file_name': data.get('file_name', None),
+                            'last_timestamp': data['answers'][-1]['timestamp'] if data.get('answers') else None
+                        })
+        except Exception as e:
+            print(f"Error listing cached questions: {e}")
+        return sorted(cached_questions, key=lambda x: x.get('last_timestamp', ''), reverse=True)
+    
+    def cleanup_invalid_cache_entries(self) -> int:
+        """
+        Clean up cache entries that contain error messages or invalid content.
+        
+        Returns:
+            Number of entries cleaned up
+        """
+        cleaned_count = 0
+        try:
+            for filename in os.listdir(self.cache_dir):
+                if filename.startswith('question_') and filename.endswith('.json'):
+                    cache_path = os.path.join(self.cache_dir, filename)
+                    
+                    try:
+                        with open(cache_path, 'r', encoding='utf-8') as f:
+                            data = json.load(f)
+                        
+                        # Check if this entry should be cleaned up
+                        should_cleanup = False
+                        
+                        # Check if cache_valid is True but contains invalid content
+                        if data.get('cache_valid', False):
+                            answers = data.get('answers', [])
+                            for answer_entry in answers:
+                                answer_text = answer_entry.get('answer', '')
+                                if not self.validate_answer_content(answer_text):
+                                    print(f"Found invalid cached answer in {filename}: {answer_text[:100]}...")
+                                    should_cleanup = True
+                                    break
+                        
+                        if should_cleanup:
+                            # Mark as invalid instead of deleting to preserve history
+                            data['cache_valid'] = False
+                            with open(cache_path, 'w', encoding='utf-8') as f:
+                                json.dump(data, f, indent=2)
+                            cleaned_count += 1
+                            print(f"Cleaned up invalid cache entry: {filename}")
+                    
+                    except Exception as e:
+                        print(f"Error processing cache file {filename}: {e}")
+                        continue
+        
+        except Exception as e:
+            print(f"Error during cache cleanup: {e}")
+        
+        print(f"Cache cleanup completed. {cleaned_count} entries cleaned up.")
+        return cleaned_count

config.example.yaml

@@ -0,0 +1,75 @@
+# Example Enhanced GAIA Agent Configuration with Vertex AI Parameters
+# Copy this file to config.yaml and update with your specific values
+
+model:
+  # Choose your preferred model
+  model_id: vertex_ai/gemini-2.5-pro        # Vertex AI Gemini model
+  #model_id: vertex_ai/gemini-1.5-pro       # Alternative Gemini version
+  #model_id: anthropic/claude-sonnet-4      # Alternative: Anthropic Claude
+  #model_id: openai/gpt-4                   # Alternative: OpenAI GPT-4
+  temperature: 0.2
+  max_tokens: 8096
+
+# Vertex AI specific configuration (REQUIRED for vertex_ai models)
+vertex_ai:
+  # REQUIRED: Replace with your actual GCP project ID
+  vertex_project: "your-gcp-project-id"
+  
+  # REQUIRED: Choose your preferred region
+  vertex_location: "us-central1"
+  # Other popular regions: "us-east1", "europe-west1", "asia-southeast1"
+  
+  # Authentication: Choose ONE of the following options:
+  
+  # Option 1: Service account file (recommended for local development)
+  vertex_credentials: "/path/to/your-service-account.json"
+  
+  # Option 2: Environment variables (comment out vertex_credentials above)
+  # Set these in your shell:
+  # export GOOGLE_APPLICATION_CREDENTIALS="/path/to/service-account.json"
+  # export VERTEXAI_PROJECT="your-gcp-project-id"
+  # export VERTEXAI_LOCATION="us-central1"
+  
+  # Option 3: GCP SDK authentication (comment out vertex_credentials above)
+  # Run: gcloud auth application-default login
+  
+  # Safety settings for content filtering
+  # Adjust thresholds based on your use case:
+  # BLOCK_NONE, BLOCK_LOW_AND_ABOVE, BLOCK_MEDIUM_AND_ABOVE, BLOCK_ONLY_HIGH
+  safety_settings:
+    - category: "HARM_CATEGORY_HARASSMENT"
+      threshold: "BLOCK_MEDIUM_AND_ABOVE"
+    - category: "HARM_CATEGORY_HATE_SPEECH"
+      threshold: "BLOCK_MEDIUM_AND_ABOVE"
+    - category: "HARM_CATEGORY_SEXUALLY_EXPLICIT"
+      threshold: "BLOCK_MEDIUM_AND_ABOVE"
+    - category: "HARM_CATEGORY_DANGEROUS_CONTENT"
+      threshold: "BLOCK_MEDIUM_AND_ABOVE"
+  
+  # Optional: Enable grounding with Google Search (experimental)
+  # This adds real-time web search capabilities to responses
+  enable_grounding: false
+
+# Agent configuration
+agent:
+  name: GAIA-Agent
+  description: Agent using LiteLLM with enhanced Vertex AI features
+  max_steps: 5
+  verbosity_level: 1
+
+# GAIA dataset settings
+gaia:
+  local_path: "./GAIA"
+
+# Cache settings  
+cache:
+  enabled: true
+  directory: cache
+
+# Setup Instructions:
+# 1. Copy this file to config.yaml
+# 2. Replace "your-gcp-project-id" with your actual GCP project ID
+# 3. Choose and configure one authentication method
+# 4. Adjust safety settings as needed
+# 5. Set vertex_location to your preferred region
+# 6. Test with: python agent.py or python app.py

config.yaml

@@ -0,0 +1,55 @@
+# Enhanced GAIA Agent Configuration with Vertex AI Parameters
+
+model:
+  #model_id: anthropic/claude-sonnet-4-20250514
+  model_id: vertex_ai/gemini-2.5-pro
+  temperature: 0.2
+  max_tokens: 8096
+
+# Vertex AI specific configuration
+vertex_ai:
+  # Project and location settings (REQUIRED - update with your values)
+  vertex_project: "gen-lang-client-0348172727"  # Replace with your actual GCP project ID
+  vertex_location: "europe-west1"         # Or your preferred region (us-east1, europe-west1, etc.)
+  
+  # Authentication options (choose one):
+  # Option 1: Service account file path (recommended for local development)
+  vertex_credentials: "google.json"  # Replace with actual path
+  
+  # Option 2: Use environment variables (RECOMMENDED - currently active):
+  # Set these environment variables:
+  # export GOOGLE_APPLICATION_CREDENTIALS="/path/to/service-account.json"
+  # export VERTEXAI_PROJECT="gen-lang-client-0348172727"
+  # export VERTEXAI_LOCATION="europe-west1"
+  
+  # Option 3: Use gcloud auth (simplest for development):
+  # Run: gcloud auth application-default login
+  
+  # Safety settings for content filtering
+  safety_settings:
+    - category: "HARM_CATEGORY_HARASSMENT"
+      threshold: "BLOCK_MEDIUM_AND_ABOVE"
+    - category: "HARM_CATEGORY_HATE_SPEECH"
+      threshold: "BLOCK_MEDIUM_AND_ABOVE"
+    - category: "HARM_CATEGORY_SEXUALLY_EXPLICIT"
+      threshold: "BLOCK_MEDIUM_AND_ABOVE"
+    - category: "HARM_CATEGORY_DANGEROUS_CONTENT"
+      threshold: "BLOCK_MEDIUM_AND_ABOVE"
+  
+  # Optional: Enable grounding with Google Search (experimental)
+  enable_grounding: false
+
+agent:
+  name: QA-Agent
+  description: Agent using LiteLLM with enhanced Vertex AI features
+  max_steps: 5
+  verbosity_level: 1
+
+# GAIA dataset settings
+gaia:
+  local_path: "./GAIA"
+
+# Cache settings
+cache:
+  enabled: true
+  directory: cache

prompts.yaml

@@ -0,0 +1,45 @@
+system_prompt: |
+  You are a precise test question answering agent designed to provide accurate, concise answers.
+
+  CRITICAL: When a question references a file (e.g. "file.xlsx"), you MUST use the get_file tool as first option/step to load the file content before doing any code, analysis, or calculations. Do NOT attempt to open or read files directly in code. Only use the content returned by get_file.
+
+  Look for file references like "analyze file.xlsx", "check image.png", "review document.pdf", etc.
+
+  Remember: You are being evaluated on answer accuracy and precision, not explanation quality.
+
+user_prompt: |
+  Answer this question with maximum precision and minimum words: {task}
+  
+  If the question references any files, use the get_file tool to load them first.
+  Use other tools efficiently to gather additional information if needed.
+  Provide only the essential answer.
+
+final_answer: |
+  {answer}
+
+planning: |
+  Question: {task}
+  
+  Plan:
+  1. Check if question references any files by name
+  2. If yes: use get_file tool to load the file
+  3. If no: identify what specific information is needed from web
+  4. Use minimum tools to get accurate data
+  5. Extract the essential answer only
+  6. Provide direct response without explanation
+  
+  Target: Use get_file when files are referenced, web tools when needed.
+
+managed_agent: |
+  You are a test question answering agent optimized for ultra-fast precision.
+  
+  Your mission:
+  1. Check if question references files by name (e.g., "analyze data.xlsx", "check image.png")
+  2. If files referenced: use get_file tool to load them
+  3. If no files: use web search and other tools efficiently (1-2 maximum)
+  4. Extract the precise answer without explanations
+  5. Return only the essential information requested
+  
+  Current question: {task}
+  
+  Remember: File references = use get_file tool. Web content = efficient tool usage.

requirements.txt

@@ -1,2 +1,13 @@
+datasets
+beautifulsoup4
 gradio
-requests
+gradio[oauth]
+requests
+smolagents
+smolagents[litellm]
+wikipedia-api
+duckduckgo-search
+pandasPyPDF2 
+openpyxl 
+huggingface_hub 
+pandas

tools/final_answer.py

@@ -0,0 +1,54 @@
+from smolagents import tool
+
+@tool  
+def final_answer(answer: str) -> str:
+    """
+    Tool to provide the final, precise answer to a test question.
+    
+    IMPORTANT: This tool should receive only the direct answer without any explanations,
+    prefixes like "The answer is", or additional formatting.
+    
+    Args:
+        answer: The precise, direct answer (e.g., "42", "Paris", "Yes", "2023-10-15")
+        
+    Returns:
+        The clean final answer string
+    """
+    # Clean the answer to ensure precision
+    clean_answer = str(answer).strip()
+    
+    # Remove common prefixes that add unnecessary verbosity
+    prefixes_to_remove = [
+        "the answer is ",
+        "based on my research, ",
+        "according to my findings, ",
+        "the result is ",
+        "my answer is ",
+        "i found that ",
+        "the correct answer is ",
+        "after searching, ",
+    ]
+    
+    lower_answer = clean_answer.lower()
+    for prefix in prefixes_to_remove:
+        if lower_answer.startswith(prefix):
+            clean_answer = clean_answer[len(prefix):]
+            break
+    
+    # Remove trailing periods for single-word answers (but keep for sentences)
+    if len(clean_answer.split()) == 1 and clean_answer.endswith('.'):
+        clean_answer = clean_answer[:-1]
+    
+    return clean_answer.strip()
+
+class FinalAnswerTool:
+    """Compatibility class for the final answer tool"""
+    
+    def __call__(self, answer: str) -> str:
+        result = final_answer(answer)
+        if isinstance(result, str):
+            return result
+        elif isinstance(result, NotImplementedError):
+            raise result
+        else:
+            return str(result)

tools/get_file.py

@@ -0,0 +1,368 @@
+"""
+File retrieval tool for accessing files from the GAIA dataset.
+Handles multiple file formats including audio, text, PDFs, images, spreadsheets, and structured data.
+Enhanced with content transformation capabilities for better LLM readability.
+
+Required Dependencies:
+pip install PyPDF2 openpyxl huggingface_hub pandas
+
+For audio transcription, set HF_TOKEN environment variable.
+"""
+
+from smolagents import tool
+from datasets import load_dataset
+import os
+import json
+import csv
+import io
+import base64
+from typing import Optional, Dict, Any
+import mimetypes
+
+# Direct imports - install these packages for full functionality
+import PyPDF2
+import openpyxl
+import pandas as pd
+from huggingface_hub import InferenceClient
+import requests
+
+# Global dataset variable to avoid reloading
+_dataset = None
+
+def get_dataset():
+    """Get or load the GAIA dataset."""
+    global _dataset
+    if _dataset is None:
+        _dataset = load_dataset("gaia-benchmark/GAIA", "2023_level1", trust_remote_code=True, cache_dir="GAIA")
+    return _dataset
+
+@tool
+def get_file(filename: str) -> str:
+    """
+    Retrieve file content by filename.
+          
+    Args:
+        filename: The name of the file to retrieve from
+        
+    Returns:
+        A string containing the file content information and metadata.
+        For binary files, returns metadata and base64-encoded content when appropriate.
+    """
+    try:
+        # Load the dataset
+        dataset = get_dataset()
+        
+        # Search for the file in the validation split
+        file_item = None
+        
+        # Handle both iterable and indexable datasets
+        try:
+            # Access validation split using proper datasets API
+            validation_data = dataset["validation"]  # type: ignore
+            
+            # Try to iterate through the dataset
+            for item in validation_data:
+                if isinstance(item, dict) and item.get("file_name") == filename:
+                    file_item = item
+                    break
+        except Exception as e:
+            # If direct access fails, try alternative approaches
+            try:
+                # Try accessing as attribute
+                validation_data = dataset.validation  # type: ignore
+                for item in validation_data:
+                    if isinstance(item, dict) and item.get("file_name") == filename:
+                        file_item = item
+                        break
+            except Exception as e2:
+                return f"Error accessing dataset: {str(e)} / {str(e2)}"
+        
+        if not file_item:
+            return f"File '{filename}' not found in the GAIA dataset. Available files can be found by examining the dataset validation split."
+        
+        # Get file path from dataset item
+        file_path = file_item.get("file_path") if isinstance(file_item, dict) else None
+        if not file_path:
+            return f"File '{filename}' found in dataset but no file_path available."
+        
+        # Check if file exists at the specified path
+        if not os.path.exists(file_path):
+            return f"File '{filename}' not found at expected path: {file_path}"
+        
+        # Determine file type and MIME type
+        mime_type, _ = mimetypes.guess_type(filename)
+        file_extension = os.path.splitext(filename)[1].lower()
+        
+        # Prepare result with metadata
+        result = f"File: {filename}\n"
+        result += f"MIME Type: {mime_type or 'unknown'}\n"
+        result += f"Extension: {file_extension}\n"
+        
+        # Add any additional metadata from the dataset item
+        if isinstance(file_item, dict) and "task_id" in file_item:
+            result += f"Associated Task ID: {file_item['task_id']}\n"
+        
+        result += "\n" + "="*50 + "\n"
+        result += "FILE CONTENT:\n"
+        result += "="*50 + "\n\n"
+        
+        # Handle different file types
+        try:
+            if _is_text_file(filename, mime_type):
+                with open(file_path, 'r', encoding='utf-8', errors='replace') as f:
+                    content = f.read()
+                if len(content) > 10000:
+                    content = content[:10000] + "\n\n... [Content truncated - showing first 10,000 characters]"
+                result += content
+                
+            elif _is_pdf_file(filename, mime_type):
+                result += _handle_pdf_file(file_path, filename)
+                
+            elif _is_excel_file(filename, mime_type):
+                result += _handle_excel_file(file_path, filename)
+                
+            elif _is_csv_file(filename, mime_type):
+                result += _handle_csv_file(file_path, filename)
+                
+            elif _is_audio_file(filename, mime_type):
+                result += _handle_audio_file(file_path, filename)
+                
+            elif _is_image_file(filename, mime_type):
+                with open(file_path, 'rb') as f:
+                    file_content = f.read()
+                result += _handle_image_file(file_content, filename)
+                
+            elif _is_structured_data_file(filename, mime_type):
+                with open(file_path, 'r', encoding='utf-8', errors='replace') as f:
+                    content = f.read()
+                result += _handle_structured_data(content, filename)
+                
+            else:
+                with open(file_path, 'rb') as f:
+                    file_content = f.read()
+                result += _handle_binary_file(file_content, filename)
+                
+        except Exception as e:
+            return f"Error reading file '{filename}': {str(e)}"
+        
+        return result
+        
+    except Exception as e:
+        return f"Error retrieving file '{filename}': {str(e)}"
+
+def _is_text_file(filename: str, mime_type: Optional[str]) -> bool:
+    """Check if file is a text file."""
+    text_extensions = {'.txt', '.md', '.rtf', '.log', '.cfg', '.ini', '.conf', '.py', '.js', '.html', '.css', '.sql', '.sh', '.bat', '.r', '.cpp', '.c', '.java', '.php', '.rb', '.go', '.rs', '.ts', '.jsx', '.tsx', '.vue', '.svelte'}
+    return (
+        filename.lower().endswith(tuple(text_extensions)) or
+        (mime_type is not None and mime_type.startswith('text/'))
+    )
+
+def _is_pdf_file(filename: str, mime_type: Optional[str]) -> bool:
+    """Check if file is a PDF file."""
+    return filename.lower().endswith('.pdf') or (mime_type == 'application/pdf')
+
+def _is_excel_file(filename: str, mime_type: Optional[str]) -> bool:
+    """Check if file is an Excel file."""
+    return filename.lower().endswith(('.xlsx', '.xls'))
+
+def _is_csv_file(filename: str, mime_type: Optional[str]) -> bool:
+    """Check if file is a CSV file."""
+    return filename.lower().endswith('.csv') or (mime_type == 'text/csv')
+
+def _is_audio_file(filename: str, mime_type: Optional[str]) -> bool:
+    """Check if file is an audio file."""
+    audio_extensions = {'.mp3', '.wav', '.m4a', '.aac', '.ogg', '.flac', '.wma'}
+    return filename.lower().endswith(tuple(audio_extensions)) or (mime_type is not None and mime_type.startswith('audio/'))
+
+def _is_image_file(filename: str, mime_type: Optional[str]) -> bool:
+    """Check if file is an image file."""
+    image_extensions = {'.jpg', '.jpeg', '.png', '.gif', '.bmp', '.svg', '.webp', '.tiff', '.ico'}
+    return filename.lower().endswith(tuple(image_extensions)) or (mime_type is not None and mime_type.startswith('image/'))
+
+def _is_structured_data_file(filename: str, mime_type: Optional[str]) -> bool:
+    """Check if file is a structured data file."""
+    return filename.lower().endswith(('.json', '.xml', '.yaml', '.yml'))
+
+def _handle_pdf_file(file_path: str, filename: str) -> str:
+    """Extract text from PDF file."""
+    try:
+        result = f"PDF TEXT CONTENT:\n"
+        result += "="*50 + "\n"
+        
+        with open(file_path, 'rb') as pdf_file:
+            pdf_reader = PyPDF2.PdfReader(pdf_file)
+            page_count = len(pdf_reader.pages)
+            result += f"Total pages: {page_count}\n\n"
+            
+            text_content = ""
+            for page_num in range(min(10, page_count)):  # First 10 pages
+                page = pdf_reader.pages[page_num]
+                page_text = page.extract_text()
+                if page_text:
+                    text_content += f"--- PAGE {page_num + 1} ---\n"
+                    text_content += page_text + "\n\n"
+            
+            if page_count > 10:
+                text_content += f"... [Showing first 10 pages out of {page_count} total]\n"
+            
+            if len(text_content) > 15000:
+                text_content = text_content[:15000] + "\n\n... [Content truncated]"
+            
+            result += text_content
+        
+        return result
+    except Exception as e:
+        return f"Error extracting PDF text: {str(e)}"
+
+def _handle_excel_file(file_path: str, filename: str) -> str:
+    """Extract data from Excel file."""
+    try:
+        result = f"EXCEL CONTENT:\n"
+        result += "="*50 + "\n"
+        
+        # Use pandas for Excel reading
+        excel_file = pd.ExcelFile(file_path)
+        sheet_names = excel_file.sheet_names
+        
+        result += f"Number of sheets: {len(sheet_names)}\n"
+        result += f"Sheet names: {', '.join(str(name) for name in sheet_names)}\n\n"
+        
+        for sheet_name in sheet_names[:3]:  # First 3 sheets
+            df = pd.read_excel(file_path, sheet_name=sheet_name)
+            result += f"SHEET: {sheet_name}\n"
+            result += "="*30 + "\n"
+            result += f"Dimensions: {df.shape[0]} rows × {df.shape[1]} columns\n"
+            result += f"Columns: {list(df.columns)}\n\n"
+            
+            result += "First 5 rows:\n"
+            result += df.head().to_string(index=True) + "\n\n"
+        
+        if len(sheet_names) > 3:
+            result += f"... and {len(sheet_names) - 3} more sheets\n"
+        
+        return result
+    except Exception as e:
+        return f"Error reading Excel file: {str(e)}"
+
+def _handle_csv_file(file_path: str, filename: str) -> str:
+    """Extract data from CSV file."""
+    try:
+        result = f"CSV CONTENT:\n"
+        result += "="*50 + "\n"
+        
+        df = pd.read_csv(file_path)
+        result += f"Dimensions: {df.shape[0]} rows × {df.shape[1]} columns\n"
+        result += f"Columns: {list(df.columns)}\n\n"
+        
+        result += "First 10 rows:\n"
+        result += df.head(10).to_string(index=True) + "\n"
+        
+        return result
+    except Exception as e:
+        return f"Error reading CSV file: {str(e)}"
+
+def _handle_audio_file(file_path: str, filename: str) -> str:
+    """Transcribe audio file."""
+    try:
+        result = f"AUDIO TRANSCRIPTION:\n"
+        result += "="*50 + "\n"
+        
+        if not os.environ.get("HF_TOKEN"):
+            return "Audio transcription requires HF_TOKEN environment variable to be set."
+        
+        # Determine content type based on file extension
+        file_ext = os.path.splitext(filename)[1].lower()
+        content_type_map = {
+            '.mp3': 'audio/mpeg',
+            '.wav': 'audio/wav',
+            '.flac': 'audio/flac',
+            '.m4a': 'audio/m4a',
+            '.ogg': 'audio/ogg',
+            '.webm': 'audio/webm'
+        }
+        content_type = content_type_map.get(file_ext, 'audio/mpeg')
+        
+        headers = {
+            "Authorization": f"Bearer {os.environ['HF_TOKEN']}",
+            "Content-Type": content_type
+        }
+        
+        # Read the audio file
+        with open(file_path, 'rb') as audio_file:
+            audio_data = audio_file.read()
+        
+        # Make direct API call to HuggingFace
+        api_url = "https://api-inference.huggingface.co/models/openai/whisper-large-v3"
+        response = requests.post(api_url, headers=headers, data=audio_data)
+        
+        if response.status_code == 200:
+            transcription_output = response.json()
+        else:
+            return f"Error from HuggingFace API: {response.status_code} - {response.text}"
+        
+        
+        if isinstance(transcription_output, dict) and 'text' in transcription_output:
+            transcription_text = transcription_output['text']
+        else:
+            transcription_text = str(transcription_output)
+        
+        result += transcription_text + "\n"
+        result += "\n" + "="*50 + "\n"
+        result += "Transcription completed using Whisper Large v3"
+        
+        return result
+    except Exception as e:
+        return f"Error transcribing audio: {str(e)}"
+
+def _handle_image_file(file_content: bytes, filename: str) -> str:
+    """Handle image file with base64 encoding."""
+    try:
+        result = f"IMAGE CONTENT:\n"
+        result += "="*50 + "\n"
+        result += f"Image file: {filename}\n"
+        result += f"File size: {len(file_content)} bytes\n"
+        result += f"Format: {os.path.splitext(filename)[1].upper().lstrip('.')}\n\n"
+        
+        # Encode image as base64
+        base64_content = base64.b64encode(file_content).decode('utf-8')
+        result += "Base64 encoded content:\n"
+        result += base64_content + "\n\n"
+        
+        result += "Note: This is the base64 encoded image data that can be decoded and analyzed."
+        return result
+    except Exception as e:
+        return f"Error handling image: {str(e)}"
+
+def _handle_binary_file(file_content: bytes, filename: str) -> str:
+    """Handle binary files with base64 encoding."""
+    try:
+        result = f"BINARY FILE CONTENT:\n"
+        result += "="*50 + "\n"
+        result += f"Binary file: {filename}\n"
+        result += f"File size: {len(file_content)} bytes\n"
+        result += f"File extension: {os.path.splitext(filename)[1]}\n\n"
+        
+        # Encode binary content as base64
+        base64_content = base64.b64encode(file_content).decode('utf-8')
+        result += "Base64 encoded content:\n"
+        result += base64_content + "\n\n"
+        
+        result += "Note: This is the base64 encoded binary data."
+        return result
+    except Exception as e:
+        return f"Error handling binary file: {str(e)}"
+
+def _handle_structured_data(content: str, filename: str) -> str:
+    """Handle structured data files."""
+    try:
+        if filename.lower().endswith('.json'):
+            try:
+                data = json.loads(content)
+                return json.dumps(data, indent=2, ensure_ascii=False)
+            except json.JSONDecodeError:
+                return content
+        else:
+            return content
+    except Exception as e:
+        return f"Error handling structured data: {str(e)}"

tools/web_scraping.py

@@ -0,0 +1,221 @@
+"""
+Web scraping tools for extracting content from web pages.
+"""
+
+from smolagents import tool
+import requests
+from bs4 import BeautifulSoup
+import urllib.parse
+
+
+@tool
+def scrape_webpage_content(url: str, content_selector: str = None) -> str:
+    """
+    Scrape content from a webpage and extract the main text content.
+    
+    Args:
+        url: The URL of the webpage to scrape
+        content_selector: Optional CSS selector to target specific content (e.g., '.article__content', '#main-content')
+        
+    Returns:
+        The extracted text content from the webpage
+    """
+    try:
+        # Validate URL
+        parsed_url = urllib.parse.urlparse(url)
+        if not parsed_url.scheme or not parsed_url.netloc:
+            return f"Invalid URL: {url}"
+        
+        # Set headers to mimic a real browser
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'Accept-Encoding': 'gzip, deflate',
+            'Connection': 'keep-alive',
+        }
+        
+        # Make the request
+        response = requests.get(url, headers=headers, timeout=15)
+        response.raise_for_status()
+        
+        # Parse the HTML
+        soup = BeautifulSoup(response.content, 'html.parser')
+        
+        # Remove script and style elements
+        for script in soup(["script", "style", "nav", "header", "footer", "aside"]):
+            script.decompose()
+        
+        # Extract content based on selector or find main content
+        if content_selector:
+            # Use the provided CSS selector
+            content_element = soup.select_one(content_selector)
+            if content_element:
+                text_content = content_element.get_text(strip=True, separator=' ')
+            else:
+                return f"No content found with selector '{content_selector}' on {url}"
+        else:
+            # Try common content selectors
+            content_selectors = [
+                'article',
+                '.article__content',
+                '.content',
+                '.post-content',
+                '.entry-content',
+                '#content',
+                'main',
+                '.main-content',
+                '[role="main"]'
+            ]
+            
+            text_content = None
+            for selector in content_selectors:
+                element = soup.select_one(selector)
+                if element:
+                    text_content = element.get_text(strip=True, separator=' ')
+                    break
+            
+            # If no specific content area found, get body text
+            if not text_content:
+                body = soup.find('body')
+                if body:
+                    text_content = body.get_text(strip=True, separator=' ')
+                else:
+                    text_content = soup.get_text(strip=True, separator=' ')
+        
+        # Clean up the text
+        if text_content:
+            # Remove excessive whitespace
+            lines = [line.strip() for line in text_content.split('\n') if line.strip()]
+            cleaned_text = '\n'.join(lines)
+            
+            # Limit length to prevent overwhelming responses
+            if len(cleaned_text) > 5000:
+                cleaned_text = cleaned_text[:5000] + "... [Content truncated]"
+            
+            return f"Content from {url}:\n\n{cleaned_text}"
+        else:
+            return f"No readable content found on {url}"
+            
+    except requests.exceptions.RequestException as e:
+        return f"Error fetching webpage {url}: {str(e)}"
+    except Exception as e:
+        return f"Error scraping webpage {url}: {str(e)}"
+
+
+@tool
+def extract_links_from_webpage(url: str, link_text_filter: str = None) -> str:
+    """
+    Extract links from a webpage, optionally filtering by link text.
+    
+    Args:
+        url: The URL of the webpage to scrape
+        link_text_filter: Optional text to filter links by (case-insensitive)
+        
+    Returns:
+        A formatted string containing the extracted links
+    """
+    try:
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+        }
+        
+        response = requests.get(url, headers=headers, timeout=15)
+        response.raise_for_status()
+        
+        soup = BeautifulSoup(response.content, 'html.parser')
+        
+        # Find all links
+        links = soup.find_all('a', href=True)
+        
+        extracted_links = []
+        for link in links:
+            href = link['href']
+            text = link.get_text(strip=True)
+            
+            # Convert relative URLs to absolute
+            if href.startswith('/'):
+                parsed_base = urllib.parse.urlparse(url)
+                href = f"{parsed_base.scheme}://{parsed_base.netloc}{href}"
+            elif href.startswith('#'):
+                continue  # Skip anchor links
+            
+            # Filter by text if specified
+            if link_text_filter:
+                if link_text_filter.lower() not in text.lower():
+                    continue
+            
+            if text and href.startswith('http'):
+                extracted_links.append(f"• {text}: {href}")
+        
+        if extracted_links:
+            result = f"Links extracted from {url}:\n\n" + '\n'.join(extracted_links[:20])  # Limit to 20 links
+            if len(extracted_links) > 20:
+                result += f"\n... and {len(extracted_links) - 20} more links"
+            return result
+        else:
+            return f"No links found on {url}"
+            
+    except Exception as e:
+        return f"Error extracting links from {url}: {str(e)}"
+
+
+@tool
+def get_webpage_metadata(url: str) -> str:
+    """
+    Extract metadata from a webpage (title, description, etc.).
+    
+    Args:
+        url: The URL of the webpage to analyze
+        
+    Returns:
+        A formatted string containing the webpage metadata
+    """
+    try:
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+        }
+        
+        response = requests.get(url, headers=headers, timeout=15)
+        response.raise_for_status()
+        
+        soup = BeautifulSoup(response.content, 'html.parser')
+        
+        metadata = []
+        
+        # Title
+        title = soup.find('title')
+        if title:
+            metadata.append(f"Title: {title.get_text(strip=True)}")
+        
+        # Meta description
+        meta_desc = soup.find('meta', attrs={'name': 'description'})
+        if meta_desc and meta_desc.get('content'):
+            metadata.append(f"Description: {meta_desc['content']}")
+        
+        # Meta keywords
+        meta_keywords = soup.find('meta', attrs={'name': 'keywords'})
+        if meta_keywords and meta_keywords.get('content'):
+            metadata.append(f"Keywords: {meta_keywords['content']}")
+        
+        # Author
+        meta_author = soup.find('meta', attrs={'name': 'author'})
+        if meta_author and meta_author.get('content'):
+            metadata.append(f"Author: {meta_author['content']}")
+        
+        # Open Graph metadata
+        og_title = soup.find('meta', attrs={'property': 'og:title'})
+        if og_title and og_title.get('content'):
+            metadata.append(f"OG Title: {og_title['content']}")
+        
+        og_desc = soup.find('meta', attrs={'property': 'og:description'})
+        if og_desc and og_desc.get('content'):
+            metadata.append(f"OG Description: {og_desc['content']}")
+        
+        if metadata:
+            return f"Metadata from {url}:\n\n" + '\n'.join(metadata)
+        else:
+            return f"No metadata found on {url}"
+            
+    except Exception as e:
+        return f"Error extracting metadata from {url}: {str(e)}"