Update app.py

app.py

@@ -3,50 +3,230 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
+import google.generativeai as genai
+import re
+import time
 
-# (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+MAX_ITERATIONS = 7 # Set a limit to prevent infinite loops
 
-# --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-class BasicAgent:
-    def __init__(self):
-        print("BasicAgent initialized.")
-    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
-
-def run_and_submit_all( profile: gr.OAuthProfile | None):
+# --- Tool Definitions ---
+
+class WebSearchTool:
+    """
+    A tool to search the web using the Perplexity API.
+    It returns a concise answer to a given query.
     """
-    Fetches all questions, runs the BasicAgent on them, submits all answers,
+    def __init__(self, api_key):
+        self.api_key = api_key
+        self.url = "https://api.perplexity.ai/chat/completions"
+        print("WebSearchTool initialized.")
+
+    def execute(self, query: str) -> str:
+        print(f"Executing WebSearchTool with query: {query}")
+        payload = {
+            "model": "llama-3-sonar-small-32k-online",
+            "messages": [
+                {"role": "system", "content": "You are an assistant that provides a concise and factual answer to the user's query."},
+                {"role": "user", "content": query}
+            ]
+        }
+        headers = {
+            "accept": "application/json",
+            "content-type": "application/json",
+            "Authorization": f"Bearer {self.api_key}"
+        }
+        try:
+            response = requests.post(self.url, json=payload, headers=headers, timeout=30)
+            response.raise_for_status()
+            result = response.json()
+            answer = result['choices'][0]['message']['content']
+            print(f"WebSearchTool result: {answer[:150]}...")
+            return answer
+        except requests.exceptions.RequestException as e:
+            print(f"Error calling Perplexity API: {e}")
+            return f"Error: Could not get a response from the web search tool. {e}"
+
+class FileDownloaderTool:
+    """
+    A tool to download and read the content of a file associated with a task.
+    The input should be the task_id.
+    """
+    def __init__(self, api_url: str):
+        self.api_url = api_url
+        print("FileDownloaderTool initialized.")
+
+    def execute(self, task_id: str) -> str:
+        print(f"Executing FileDownloaderTool for task_id: {task_id}")
+        file_url = f"{self.api_url}/files/{task_id}"
+        try:
+            response = requests.get(file_url, timeout=20)
+            response.raise_for_status()
+            # Assuming the file content is text
+            content = response.text
+            print(f"FileDownloaderTool successfully read file for task {task_id}. Content length: {len(content)}")
+            # Return a summary or a portion if the content is too long
+            if len(content) > 5000:
+                return f"File content (first 5000 chars):\n{content[:5000]}"
+            return f"File content:\n{content}"
+        except requests.exceptions.HTTPError as e:
+            if e.response.status_code == 404:
+                print(f"No file found for task_id: {task_id}")
+                return "No file is associated with this task."
+            else:
+                 print(f"HTTP error downloading file for task_id {task_id}: {e}")
+                 return f"Error: Failed to download file due to an HTTP error: {e}"
+        except requests.exceptions.RequestException as e:
+            print(f"Network error downloading file for task_id {task_id}: {e}")
+            return f"Error: Failed to download file due to a network error: {e}"
+
+
+# --- GAIA Agent Definition ---
+class GAIAAgent:
+    def __init__(self, gemini_api_key: str, pplx_api_key: str, api_url: str):
+        print("Initializing GAIAAgent...")
+        # Configure Gemini
+        genai.configure(api_key=gemini_api_key)
+        self.model = genai.GenerativeModel('gemini-1.5-flash-latest')
+
+        # Initialize Tools
+        self.tools = {
+            "WebSearch": WebSearchTool(api_key=pplx_api_key),
+            "FileDownloader": FileDownloaderTool(api_url=api_url),
+        }
+        
+        # Define the ReAct prompt template
+        self.prompt_template = """
+You are a helpful assistant designed to answer questions accurately.
+
+To solve the user's question, you must use a sequence of thoughts and actions.
+You have access to the following tools:
+
+- **WebSearch[query]**: Use this to search the internet for up-to-date information, facts, or general knowledge.
+- **FileDownloader[task_id]**: Use this to download and read a file associated with the current task. The task_id is '{task_id}'.
+
+Your reasoning process should follow this format:
+
+Thought: I need to figure out what information is missing. I will use a tool to find it.
+Action: ToolName[input for the tool]
+Observation: [The result from the tool will be inserted here]
+
+... (this Thought/Action/Observation cycle can repeat multiple times)
+
+Thought: I have now gathered enough information to answer the user's question.
+Final Answer: The final answer to the original question.
+
+**Important Rules:**
+1. The `Action` line must be *exactly* in the format `ToolName[input]`. For example: `WebSearch[When was the Eiffel Tower built?]`.
+2. The `task_id` for the current question is '{task_id}'. Use it ONLY with the FileDownloader tool.
+3. If no file is associated with the task, the FileDownloader tool will return 'No file is associated with this task.'.
+4. Once you have the final answer, do not use any more tools. State the final answer clearly after "Final Answer:".
+
+Here is the question:
+{question}
+"""
+        print("GAIAAgent initialized successfully.")
+
+    def __call__(self, question: str, task_id: str) -> str:
+        print(f"Agent received question for task {task_id}: {question[:100]}...")
+
+        # Format the initial prompt with the question and task_id
+        prompt = self.prompt_template.format(question=question, task_id=task_id)
+        
+        # Start the ReAct loop
+        for i in range(MAX_ITERATIONS):
+            print(f"\n--- Iteration {i+1} ---")
+            
+            try:
+                print("Generating response from Gemini...")
+                # Add a small delay to avoid hitting rate limits too quickly
+                time.sleep(1)
+                response = self.model.generate_content(prompt)
+                response_text = response.text
+                print(f"LLM Response:\n{response_text}")
+
+            except Exception as e:
+                print(f"Error calling Gemini API: {e}")
+                return f"Error: Could not get a response from the reasoning model. {e}"
+
+            # Check for Final Answer
+            final_answer_match = re.search(r"Final Answer:\s*(.*)", response_text, re.DOTALL)
+            if final_answer_match:
+                final_answer = final_answer_match.group(1).strip()
+                print(f"Found Final Answer: {final_answer}")
+                # Per instructions, return only the answer itself
+                return final_answer
+
+            # Check for Action
+            action_match = re.search(r"Action:\s*(\w+)\[(.*?)\]", response_text)
+            if action_match:
+                tool_name = action_match.group(1).strip()
+                tool_input = action_match.group(2).strip()
+
+                if tool_name in self.tools:
+                    print(f"Executing tool '{tool_name}' with input '{tool_input}'")
+                    tool = self.tools[tool_name]
+                    try:
+                        # Special handling for FileDownloader which needs task_id
+                        if tool_name == "FileDownloader":
+                            observation = tool.execute(task_id)
+                        else:
+                            observation = tool.execute(tool_input)
+                    except Exception as e:
+                        observation = f"Error executing tool: {e}"
+                    
+                    # Append the observation to the prompt for the next turn
+                    prompt += f"{response_text}\nObservation: {observation}\n"
+                else:
+                    print(f"Error: Agent tried to use an unknown tool: {tool_name}")
+                    prompt += f"{response_text}\nObservation: Error - The tool '{tool_name}' does not exist. Available tools are: {list(self.tools.keys())}.\n"
+            else:
+                print("Error: Agent did not provide a valid Action or Final Answer. Ending loop.")
+                # If the model just gives a response without the proper format, return it as a last resort.
+                return response_text.strip()
+
+        print("Agent reached max iterations without finding a final answer.")
+        return "Agent could not determine the answer within the allowed number of steps."
+
+
+def run_and_submit_all(profile: gr.OAuthProfile | None):
+    """
+    Fetches all questions, runs the GAIAAgent on them, submits all answers,
     and displays the results.
     """
     # --- Determine HF Space Runtime URL and Repo URL ---
-    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
+    space_id = os.getenv("SPACE_ID")
 
     if profile:
-        username= f"{profile.username}"
+        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
 
+    # --- Get API Keys from Secrets ---
+    pplx_key = os.getenv("PPLX_API_KEY")
+    gemini_key = os.getenv("GEMINI_API_KEY")
+
+    if not pplx_key or not gemini_key:
+        error_msg = "API keys not found in Space secrets. Please set PPLX_API_KEY and GEMINI_API_KEY in your Space settings."
+        print(error_msg)
+        return error_msg, 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 = GAIAAgent(gemini_api_key=gemini_key, pplx_api_key=pplx_key, api_url=api_url)
     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)
+    print(f"Agent code link: {agent_code}")
 
     # 2. Fetch Questions
     print(f"Fetching questions from: {questions_url}")
@@ -80,7 +260,8 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
             print(f"Skipping item with missing task_id or question: {item}")
             continue
         try:
-            submitted_answer = agent(question_text)
+            # Pass both question and task_id to the agent
+            submitted_answer = agent(question_text, task_id)
             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:
@@ -99,7 +280,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     # 5. Submit
     print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
     try:
-        response = requests.post(submit_url, json=submission_data, timeout=60)
+        response = requests.post(submit_url, json=submission_data, timeout=120) # Increased timeout for submission
         response.raise_for_status()
         result_data = response.json()
         final_status = (
@@ -142,19 +323,16 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
 # --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
-    gr.Markdown("# Basic Agent Evaluation Runner")
+    gr.Markdown("# GAIA 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 ...
+        1.  Ensure you have added your `PPLX_API_KEY` and `GEMINI_API_KEY` to this Space's **Settings > Secrets**.
         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.
-
         ---
         **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.
+        This process can take a significant amount of time (10-20 minutes) as the agent processes each of the 20 questions. The UI will be blocked during this time. Please be patient.
         """
     )
 
@@ -163,34 +341,33 @@ with gr.Blocks() as demo:
     run_button = gr.Button("Run Evaluation & Submit All Answers")
 
     status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
-    # Removed max_rows=10 from DataFrame constructor
     results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
 
+    # Add the profile object from the LoginButton to the click function's inputs
     run_button.click(
         fn=run_and_submit_all,
+        # The login button automatically provides the profile object to functions that need it.
+        # We just need to ensure the function signature matches.
         outputs=[status_output, results_table]
     )
 
 if __name__ == "__main__":
     print("\n" + "-"*30 + " App Starting " + "-"*30)
-    # Check for SPACE_HOST and SPACE_ID at startup for information
     space_host_startup = os.getenv("SPACE_HOST")
-    space_id_startup = os.getenv("SPACE_ID") # Get SPACE_ID at startup
+    space_id_startup = os.getenv("SPACE_ID")
 
     if space_host_startup:
         print(f"✅ SPACE_HOST found: {space_host_startup}")
-        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
     else:
         print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
 
-    if space_id_startup: # Print repo URLs if SPACE_ID is found
+    if space_id_startup:
         print(f"✅ SPACE_ID found: {space_id_startup}")
         print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
-        print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
     else:
-        print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
+        print("ℹ️  SPACE_ID environment variable not found (running locally?).")
 
     print("-"*(60 + len(" App Starting ")) + "\n")
 
-    print("Launching Gradio Interface for Basic Agent Evaluation...")
+    print("Launching Gradio Interface for GAIA Agent Evaluation...")
     demo.launch(debug=True, share=False)