Update tools.py

tools.py

@@ -1,73 +1,115 @@
 import os
-import requests
-from duckduckgo_search import DDGS
+import re
+import google.generativeai as genai
+from tools import web_search, read_file_from_api, python_interpreter
 
-# This is the base URL for the competition API, used to fetch files.
-GAIA_API_URL = "https://agents-course-unit4-scoring.hf.space"
+# --- 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.
 
-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}"
+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 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.
+---
+Here is the problem:
+Question: {question}
+"""
+
+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)
+        
+        # --- 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 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.)
-        return response.text
-    except requests.exceptions.RequestException as e:
-        return f"Error reading file from API: {e}"
+        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 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, or any complex logic.
-    The code runs in a restricted environment. Only print the final result.
-    
-    Args:
-        code (str): A string containing valid Python code.
+    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"
+        
+        prompt = REACT_PROMPT.format(question=question)
         
-    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.
-    import io
-    import sys
-    from contextlib import redirect_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"
 
-    try:
-        f = io.StringIO()
-        with redirect_stdout(f):
-            exec(code, {})
-        return f.getvalue()
-    except Exception as e:
-        return f"Error executing Python code: {type(e).__name__}: {e}"
+        # 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."