Update tools.py

tools.py

@@ -1,115 +1,89 @@
 import os
-import re
-import google.generativeai as genai
-from tools import web_search, read_file_from_api, python_interpreter
+import requests
+from duckduckgo_search import DDGS
+import pandas as pd
+import io
 
-# --- The ReAct Prompt Template ---
-# This master prompt is the "brain" of the agent. It tells the LLM how to behave.
-# It's explicitly told that the "Final Answer:" prefix is for its internal use only.
-REACT_PROMPT = """
-You are a helpful and intelligent agent designed to solve complex problems. You have access to a set of tools to help you.
+# This is the base URL for the competition API, used to construct file URLs.
+GAIA_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-Your task is to answer the user's question accurately. To do this, you must operate in a loop of Thought, Action, and Observation.
-
-1.  **Thought:** First, reason about the problem and your strategy.
-2.  **Action:** Based on your thought, choose ONE of the following tools to use. The format must be `Action: tool_name[input]`.
-3.  **Observation:** After you perform an action, you will receive an observation.
-4.  **Repeat:** You will repeat this process until you are certain of the final answer.
-
-Your available tools are:
-- `web_search[query]`: Searches the web to find up-to-date information or facts.
-- `read_file_from_api[task_id]`: Reads a file required by the question. The `task_id` is implicitly available from the context.
-- `python_interpreter[code]`: Executes Python code for calculations or complex logic.
-
-**CRITICAL INSTRUCTION:** When you have the final answer, you MUST use the following format for your last step:
-`Final Answer: [The single, exact answer]`
-
-This `Final Answer:` prefix is a signal for the system to stop. The system will automatically extract *only the text after the prefix* for the submission. Do not add any other text, explanation, or formatting around the final answer.
+def web_search(query: str) -> str:
+    """
+    Performs a web search using the DuckDuckGo search engine and returns the top results.
+    Use this to find current information, facts, or to answer general knowledge questions.
+    
+    Args:
+        query (str): The search query.
+        
+    Returns:
+        str: A formatted string of the search results.
+    """
+    print(f"Tool: Performing web search for '{query}'...")
+    try:
+        with DDGS() as ddgs:
+            results = [r for r in ddgs.text(query, max_results=5)]
+            return "\n".join([f"[{i+1}] {r['title']}: {r['body']}" for i, r in enumerate(results)]) if results else "No results found."
+    except Exception as e:
+        return f"Error during web search: {e}"
 
----
-Here is the problem:
-Question: {question}
-"""
+def read_file_from_api(task_id: str) -> str:
+    """
+    Downloads and reads the content of a file associated with a specific task_id from the GAIA competition API.
+    Only use this tool when the user's question explicitly mentions a file or attachment.
+    
+    Args:
+        task_id (str): The task ID associated with the file to download.
+        
+    Returns:
+        str: The content of the file as a string, or an error message.
+    """
+    print(f"Tool: Reading file for task_id '{task_id}'...")
+    file_url = f"{GAIA_API_URL}/files/{task_id}"
+    try:
+        response = requests.get(file_url, timeout=10)
+        response.raise_for_status()
+        # We assume the content is text-based (txt, csv, json, etc.) for direct reading
+        return response.text
+    except requests.exceptions.RequestException as e:
+        return f"Error reading file from API: {e}"
 
-class GeminiAgent:
-    def __init__(self):
-        print("Initializing GeminiAgent (ReAct)...")
-        api_key = os.getenv("GEMINI_API_KEY")
-        if not api_key:
-            raise ValueError("GEMINI_API_KEY secret not found! Please set it in your Space's settings.")
-            
-        genai.configure(api_key=api_key)
+def python_interpreter(code: str) -> str:
+    """
+    Executes a given string of Python code and returns its standard output.
+    This tool is highly useful for calculations, data manipulation (using pandas), or any complex logic.
+    The code runs in a restricted environment. Only print the final result.
+    It has access to the 'pandas' library (as pd).
+    
+    Args:
+        code (str): A string containing valid Python code.
         
-        # --- CORRECTED MODEL NAME ---
-        # Using the state-of-the-art gemini-2.5-pro model.
-        self.model = genai.GenerativeModel('gemini-2.5-pro')
+    Returns:
+        str: The captured stdout from the executed code, or the error.
+    """
+    print(f"Tool: Executing Python code:\n---\n{code}\n---")
+    # WARNING: Executing arbitrary code is a security risk.
+    # In a real-world application, this should be done in a sandboxed environment.
+    local_scope = {"pd": pd, "io": io}
+    
+    # Use a string stream to capture the output of 'print' statements
+    string_stream = io.StringIO()
+    
+    try:
+        # Redirect stdout to our string stream
+        import sys
+        original_stdout = sys.stdout
+        sys.stdout = string_stream
         
-        self.tools = {
-            "web_search": web_search,
-            "read_file_from_api": read_file_from_api,
-            "python_interpreter": python_interpreter
-        }
-        print("GeminiAgent initialized successfully with model 'gemini-2.5-pro'.")
-
-    def __call__(self, question: str) -> str:
-        # The task_id is often encoded in the question for GAIA.
-        task_id_match = re.search(r'gaia-id:(\S+)', question)
-        task_id = task_id_match.group(1) if task_id_match else "unknown"
+        # Execute the code
+        exec(code, {"__builtins__": __builtins__}, local_scope)
         
-        prompt = REACT_PROMPT.format(question=question)
+    except Exception as e:
+        # Restore stdout and return the error
+        sys.stdout = original_stdout
+        print(f"Error executing python code: {e}")
+        return f"Error: {type(e).__name__}: {e}"
+    finally:
+        # Always restore stdout
+        sys.stdout = original_stdout
         
-        # ReAct loop - Max 10 turns to prevent runaways
-        for turn in range(10):
-            print(f"\n--- Turn {turn + 1} ---\n")
-            
-            # 1. THOUGHT + ACTION
-            response = self.model.generate_content(prompt)
-            
-            # Handle cases where the model response might be empty or blocked
-            if not response.parts:
-                print("Warning: Model returned an empty response.")
-                prompt += "\nObservation: The model returned an empty response. Please try again."
-                continue
-            
-            response_text = response.text
-            print(f"LLM Response:\n{response_text}\n")
-            
-            # --- PARSING LOGIC THAT COMPLIES WITH SUBMISSION RULES ---
-            # 2. Check for the "Final Answer:" prefix.
-            final_answer_match = re.search(r"Final Answer: (.*)", response_text, re.DOTALL)
-            if final_answer_match:
-                # If the prefix is found, extract ONLY the answer part.
-                answer = final_answer_match.group(1).strip()
-                print(f"Final Answer signal detected. Extracting and returning: '{answer}'")
-                # This return value is what gets submitted to the API. It does NOT contain the prefix.
-                return answer
-
-            # 3. ACT - If no final answer, look for a tool to use.
-            action_match = re.search(r"Action: (\w+)\[(.*)\]", response_text, re.DOTALL)
-            if not action_match:
-                # This can happen if the model is confused. We'll let it try again.
-                observation = "No valid 'Action:' or 'Final Answer:' found in your response. Please think step-by-step and select a tool or provide the final answer."
-            else:
-                tool_name = action_match.group(1).strip()
-                tool_input = action_match.group(2).strip()
-                
-                if tool_name not in self.tools:
-                    observation = f"Error: Unknown tool '{tool_name}'. Please choose from the available tools."
-                else:
-                    try:
-                        # Special handling for the file reader tool to pass the task_id
-                        if tool_name == "read_file_from_api":
-                            observation = self.tools[tool_name](task_id)
-                        else:
-                            observation = self.tools[tool_name](tool_input)
-                    except Exception as e:
-                        observation = f"Error executing tool {tool_name}: {e}"
-            
-            print(f"Observation:\n{observation}\n")
-
-            # 4. OBSERVE - Append the full turn to the prompt for the next loop.
-            prompt += f"{response_text}\nObservation: {observation}\n"
-
-        # Fallback if the agent gets stuck in a loop
-        print("Agent failed to find an answer within the turn limit.")
-        return "Agent failed to find an answer within 10 turns."
+    return string_stream.getvalue()