Update app.py

app.py

@@ -3,29 +3,462 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
+import json
+import mimetypes
+import glob
+import time # Added for timing
+
+# LangChain/LangGraph imports
+from langchain_core.messages import HumanMessage, AIMessage, ToolMessage
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.runnables import RunnablePassthrough
+from langchain_core.tools import tool
+from langchain_openai import ChatOpenAI
+from langgraph.graph import END, StateGraph
+from langgraph.prebuilt import ToolExecutor
+from langchain_core.utils.function_calling import format_tool_to_openai_function # Helper for tool formatting if needed
+
+# Tool Imports
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain_community.document_loaders import TextLoader, PyPDFLoader # Import specific loaders
+from pathlib import Path # For file path handling
 
-# (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+FILE_DOWNLOAD_BASE_URL = f"{DEFAULT_API_URL}/files"
+# Define a directory where files might be downloaded or located
+DATA_DIR = "./data" # Use this as a base for downloaded files too
+
+# --- Ensure Data Directory Exists ---
+os.makedirs(DATA_DIR, exist_ok=True)
+print(f"Data directory '{DATA_DIR}' ensured.")
+
+# --- Environment Variable Check ---
+required_env_vars = ["OPENAI_API_KEY", "TAVILY_API_KEY"]
+missing_vars = [var for var in required_env_vars if not os.getenv(var)]
+
+if missing_vars:
+    print("\n" + "="*50)
+    print("ERROR: Missing required environment variables!")
+    print("Please set the following environment variables:")
+    for var in missing_vars:
+        print(f"- {var}")
+    print(f"\nThey should be set in the Hugging Face Space settings under 'Variables'.")
+    print("You will not be able to run the agent without these.")
+    print("="*50 + "\n")
+    # In a real app, you might raise an error or disable functionality
+
+# --- Define Tools ---
+
+@tool
+def list_local_files(directory: str = DATA_DIR) -> str:
+    """List files available locally in a directory. Defaults to the DATA_DIR."""
+    try:
+        # List all files and directories, but focus on files
+        # Use ** to search recursively within task_id subdirectories as well
+        entries = glob.glob(os.path.join(directory, '**/*'), recursive=True)
+        files = [entry for entry in entries if os.path.isfile(entry)]
+        if not files:
+            return f"No files found in local directory: {directory} (and subdirectories)"
+        # Return paths relative to DATA_DIR for clarity
+        file_list = "\n".join([os.path.relpath(f, DATA_DIR) for f in files])
+        return f"Files available locally in {directory} (and subdirectories):\n{file_list}"
+    except Exception as e:
+        return f"Error listing local files in {directory}: {e}"
+
+@tool
+def read_local_file(filepath: str, directory: str = DATA_DIR) -> str:
+    """Read the content of a specified local file within a directory. Supports .txt and .pdf. Filepath should be relative to the directory (e.g., task_id/filename.txt). Defaults to the DATA_DIR."""
+    # Sanitize filepath to prevent directory traversal
+    base_path = Path(directory).resolve()
+    full_path = (base_path / filepath).resolve()
+
+    # Check if the resolved path is actually within the intended base directory
+    try:
+        full_path.relative_to(base_path)
+    except ValueError:
+        return f"Error: Access denied. Filepath '{filepath}' is outside the allowed directory '{directory}'."
+
+
+    if not full_path.exists():
+        return f"Error: Local file not found at {full_path}"
+    if not full_path.is_file():
+        return f"Error: {filepath} is not a local file."
+
+    try:
+        mime_type, _ = mimetypes.guess_type(full_path)
+        print(f"Attempting to read file {full_path} with mime type {mime_type}")
+
+        if mime_type == 'application/pdf':
+            loader = PyPDFLoader(str(full_path))
+            docs = loader.load()
+            content = "\n".join([doc.page_content for doc in docs])
+            return f"Content of {filepath} (PDF):\n{content[:4000]}..." # Increased limit slightly
+        elif mime_type and mime_type.startswith('text/'):
+             loader = TextLoader(str(full_path))
+             docs = loader.load()
+             content = "\n".join([doc.page_content for doc in docs])
+             return f"Content of {filepath} (Text):\n{content[:4000]}..." # Increased limit slightly
+        else:
+            # Fallback for other types - try reading as text
+            try:
+                 loader = TextLoader(str(full_path))
+                 docs = loader.load()
+                 content = "\n".join([doc.page_content for doc in docs])
+                 return f"Content of {filepath} (Attempted Text Read):\n{content[:4000]}..." # Increased limit slightly
+            except Exception:
+                 return f"Error: Unsupported local file type for {filepath}. Mime type: {mime_type}. Cannot read content as text."
+
+    except Exception as e:
+        return f"Error reading local file {filepath}: {e}"
+
+
+@tool
+def download_and_read_file(task_id: str, filename: str) -> str:
+    """Downloads a file provided for a specific task ID from the evaluation API and then reads its content. Saves files to ./data/{task_id}/"""
+    download_url = f"{FILE_DOWNLOAD_BASE_URL}/{task_id}"
+    save_dir = os.path.join(DATA_DIR, str(task_id))
+    os.makedirs(save_dir, exist_ok=True) # Ensure task-specific directory exists
+    save_path = os.path.join(save_dir, filename)
+
+    print(f"Attempting to download file '{filename}' for task '{task_id}' from {download_url}")
+
+    try:
+        # The API endpoint /files/{task_id} seems to return a zip or archive
+        # Let's assume for now it returns the *specific* file if requested via query param or it handles internally?
+        # The prompt mentions GET /files/{task_id} which implies the task_id is the key,
+        # but the example question didn't specify how files are listed or referenced beyond their name.
+        # A common GAIA pattern is the API returning a list of file *metadata* or an archive.
+        # Let's adjust: Assume the API at /files/{task_id} returns a ZIP containing *all* files for that task.
+        # We need to download the zip, extract it, and *then* read the specific file.
+
+        # Revised tool logic: Download the task_id archive, extract it, then read the requested filename.
+        archive_url = f"{FILE_DOWNLOAD_BASE_URL}/{task_id}"
+        print(f"Downloading archive for task {task_id} from {archive_url}")
+        response = requests.get(archive_url, stream=True, timeout=30) # Increased timeout
+        response.raise_for_status() # Raise an HTTPError for bad responses (4xx or 5xx)
+
+        archive_path = os.path.join(save_dir, f"task_{task_id}_files.zip")
+        with open(archive_path, 'wb') as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                f.write(chunk)
+        print(f"Downloaded archive to {archive_path}")
+
+        # Extract the archive
+        import zipfile
+        extract_dir = os.path.join(save_dir, "extracted")
+        os.makedirs(extract_dir, exist_ok=True)
+        with zipfile.ZipFile(archive_path, 'r') as zip_ref:
+            zip_ref.extractall(extract_dir)
+        print(f"Extracted archive to {extract_dir}")
+
+        # Now, find the requested filename within the extracted directory
+        # Use glob to find the file, case-insensitively and allowing for potential path variations inside the zip
+        search_pattern = os.path.join(extract_dir, '**', filename)
+        found_files = glob.glob(search_pattern, recursive=True, include_hidden=True)
+
+        if not found_files:
+            return f"Error: File '{filename}' not found within the archive for task {task_id} after extraction to {extract_dir}. Files found: {list_local_files(extract_dir)}" # List files found in extracted dir
+
+        if len(found_files) > 1:
+             print(f"Warning: Found multiple files matching '{filename}' in archive for task {task_id}. Using the first one: {found_files[0]}")
+
+        file_to_read_path = found_files[0] # Use the first match
+
+        # Now read the extracted file using the existing read logic
+        # We can reuse parts of read_local_file or just inline it
+        print(f"Attempting to read extracted file: {file_to_read_path}")
+        mime_type, _ = mimetypes.guess_type(file_to_read_path)
+        print(f"Detected mime type: {mime_type}")
+
+        content = ""
+        if mime_type == 'application/pdf':
+            loader = PyPDFLoader(str(file_to_read_path))
+            docs = loader.load()
+            content = "\n".join([doc.page_content for doc in docs])
+        elif mime_type and mime_type.startswith('text/'):
+             loader = TextLoader(str(file_to_read_path))
+             docs = loader.load()
+             content = "\n".join([doc.page_content for doc in docs])
+        else:
+             # Fallback for other types - try reading as text
+            try:
+                 loader = TextLoader(str(file_to_read_path))
+                 docs = loader.load()
+                 content = "\n".join([doc.page_content for doc in docs])
+            except Exception:
+                 return f"Error: Unsupported file type for '{filename}' ({file_to_read_path}). Mime type: {mime_type}. Cannot read content after download and extraction."
+
+
+        return f"Successfully downloaded and read '{filename}' for task {task_id}. Content:\n{content[:4000]}..." # Limit output size
+
+    except requests.exceptions.RequestException as e:
+        return f"Error downloading archive for task {task_id}: {e}"
+    except zipfile.BadZipFile:
+        return f"Error: Downloaded file for task {task_id} is not a valid zip archive."
+    except FileNotFoundError:
+        return f"Error: The file '{filename}' was expected but not found in the extracted archive for task {task_id}."
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return f"An unexpected error occurred during download or reading of '{filename}' for task {task_id}: {e}"
+
+
+# Initialize Tavily Search Tool
+tavily_tool = TavilySearchResults(max_results=5)
+
+# List of tools available to the agent
+# Added the new download_and_read_file tool
+tools = [tavily_tool, list_local_files, read_local_file, download_and_read_file]
+
+# --- Define the LangGraph Agent ---
+
+# Define the state for the graph
+# Added 'task_id' to the state
+class AgentState:
+    messages: list
+    task_id: str | None = None # Store the current task ID
+
+# Define nodes
+def call_llm(state: AgentState):
+    """Invokes the LLM to make a decision or generate a response."""
+    messages = state['messages']
+    task_id = state.get('task_id') # Get task_id from state if available
+    print(f"\n---Calling LLM (Task ID: {task_id})---")
+    # Provide task_id in the prompt if helpful? Or rely on tool signature?
+    # Relying on tool signature is better. The LLM should understand it needs task_id for the download tool.
+
+    # Add a system message to guide the agent? Optional but often helpful.
+    # We can bind this to the LLM later or add it here dynamically.
+    # Let's add a basic system message when invoking the graph.
+    # For now, just invoke with the current messages.
 
-# --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-class BasicAgent:
+    response = llm_with_tools.invoke(messages)
+    print(f"LLM Response type: {type(response)}")
+    print(f"LLM Response: {response}")
+    return {'messages': messages + [response], 'task_id': task_id}
+
+def call_tool(state: AgentState):
+    """Executes the tools specified by the LLM."""
+    messages = state['messages']
+    task_id = state.get('task_id') # Get task_id from state
+    last_message = messages[-1]
+    print(f"\n---Executing Tools (Task ID: {task_id})---")
+
+    tool_outputs = []
+    # Ensure the last message is a tool call message
+    if not hasattr(last_message, 'tool_calls') or not last_message.tool_calls:
+         print("Last message was not a tool call message. This shouldn't happen if routing is correct.")
+         # Return state unchanged or with an error message? Returning unchanged might lead to loop.
+         # Let's add a message indicating the issue.
+         tool_outputs.append(ToolMessage(content="Agent attempted to call tools but the last message didn't contain tool calls.", tool_call_id="error"))
+         return {'messages': messages + tool_outputs, 'task_id': task_id}
+
+
+    for tool_call in last_message.tool_calls:
+        print(f"Executing tool: {tool_call.tool} with args: {tool_call.args} (Call ID: {tool_call.id})")
+        try:
+             # The tool_executor.invoke expects the message *containing* the tool calls
+             # It handles calling the correct tool function based on the message content
+             output = tool_executor.invoke(last_message)
+             # The output structure from ToolExecutor.invoke(message_with_tool_calls)
+             # can be complex (e.g., list of dicts or messages).
+             # A simpler approach is to manually call the tool functions using tool_call.args
+             # and construct ToolMessage with the corresponding tool_call.id.
+
+             # Find the tool function by name
+             tool_function = next((t for t in tools if t.name == tool_call.tool), None)
+             if tool_function:
+                 # Execute the tool function with parsed arguments
+                 # Be careful: tool_call.args is a dict, need to unpack it
+                 # Ensure args match tool signature, this relies on LLM's correctness
+                 print(f"Attempting to call {tool_call.tool}(**{tool_call.args})")
+                 # Need to handle potential errors in unpacking args or tool execution
+                 try:
+                     # Pass task_id to the tool args if the tool expects it
+                     # The download_and_read_file tool expects task_id and filename
+                     # The LLM *must* include task_id in the args when calling this tool
+                     if 'task_id' in tool_call.args and tool_call.tool == 'download_and_read_file':
+                          tool_result = tool_function.invoke(tool_call.args) # Use invoke for LangChain tools
+                     else:
+                         # For other tools, just pass the args provided by the LLM
+                         tool_result = tool_function.invoke(tool_call.args) # Use invoke
+
+                     tool_outputs.append(ToolMessage(content=str(tool_result), tool_call_id=tool_call.id))
+                     print(f"Tool '{tool_call.tool}' output: {tool_result[:200]}...")
+                 except Exception as e:
+                     print(f"Error executing tool {tool_call.tool} with args {tool_call.args}: {e}")
+                     import traceback
+                     traceback.print_exc()
+                     tool_outputs.append(ToolMessage(content=f"Error executing {tool_call.tool}: {e}", tool_call_id=tool_call.id))
+             else:
+                 print(f"Error: Tool '{tool_call.tool}' not found.")
+                 tool_outputs.append(ToolMessage(content=f"Error: Tool '{tool_call.tool}' not found.", tool_call_id=tool_call.id))
+
+        except Exception as e:
+             print(f"An unexpected error occurred during tool execution for {tool_call.tool} (ID: {tool_call.id}): {e}")
+             import traceback
+             traceback.print_exc()
+             tool_outputs.append(ToolMessage(content=f"An unexpected error occurred during tool execution for {tool_call.tool}: {e}", tool_call_id=tool_call.id))
+
+
+    # Append tool outputs to the messages
+    # Each output needs to be linked back to the tool call ID
+    return {'messages': messages + tool_outputs, 'task_id': task_id}
+
+# Define conditional edge logic
+def route_tools(state: AgentState):
+    """Routes the agent based on whether the LLM decided to use a tool."""
+    last_message = state['messages'][-1]
+    print(f"\n---Routing (Task ID: {state.get('task_id')})---")
+    print(f"Last message type: {type(last_message)}")
+    print(f"Last message content: {last_message.content}")
+    print(f"Last message tool_calls: {hasattr(last_message, 'tool_calls') and last_message.tool_calls}")
+
+    # If the last message has tool calls, route to the tool execution node
+    if hasattr(last_message, 'tool_calls') and last_message.tool_calls:
+        print("Routing to tool_execution")
+        return 'tool_execution'
+    # Otherwise, route to the end node (assuming it's a final answer)
+    print("Routing to end")
+    return END
+
+# Initialize the LLM and bind tools
+try:
+    # Add a system prompt to guide the LLM
+    system_prompt = (
+        "You are a helpful AI assistant designed to answer complex real-world questions based on provided tools."
+        "You have access to web search and the ability to list and read local files, including downloading files provided with a task."
+        "Follow these steps:"
+        "1. Carefully analyze the user's question."
+        "2. Break down the question into smaller steps required to find the answer."
+        "3. Use the available tools (`tavily_search`, `list_local_files`, `read_local_file`, `download_and_read_file`) to gather necessary information."
+        "   - If the question mentions files and you have the task_id available in your state, use the `download_and_read_file` tool with the correct `task_id` and `filename` to get file contents."
+        "   - If files are already downloaded or you need to see what's available locally, use `list_local_files`."
+        "   - Use `read_local_file` to read files already on disk (e.g., after downloading or if pre-loaded)."
+        "   - Use `tavily_search` for general knowledge or looking up information online."
+        "4. Synthesize the information gathered from the tools."
+        "5. Formulate the final answer based *only* on the information you have retrieved or reasoned about."
+        "6. Ensure the answer is in the exact format requested by the user (e.g., comma-separated list, specific ordering)."
+        "7. If you have sufficient information and the answer is ready, provide the final answer. Otherwise, use tools or ask for clarification if necessary (though for this benchmark, you must attempt to answer)."
+        "Do NOT make up information."
+    )
+
+    llm = ChatOpenAI(model="gpt-4o-mini", temperature=0) # gpt-4o-mini is cheaper and often sufficient
+    llm_with_tools = llm.bind_tools(tools)
+    print("LLM and tools initialized.")
+except Exception as e:
+    print(f"Error initializing LLM or binding tools: {e}")
+    llm = None
+    llm_with_tools = None
+
+
+# Initialize the ToolExecutor (though we are manually invoking tools in call_tool node)
+# We keep this mainly for reference or potential future use if we switch back
+tool_executor = ToolExecutor(tools)
+print("Tool executor initialized.")
+
+# Build the graph
+workflow = StateGraph(AgentState)
+
+# Add nodes
+workflow.add_node("llm", call_llm)
+workflow.add_node("tool_execution", call_tool)
+
+# Set the entry point
+workflow.set_entry_point("llm")
+
+# Add edges
+workflow.add_edge("tool_execution", "llm") # After executing tools, always go back to the LLM to decide next step
+
+# Add conditional edge from LLM
+workflow.add_conditional_edge(
+    "llm",
+    route_tools,
+    {"tool_execution": "tool_execution", END: END}
+)
+
+# Compile the graph
+try:
+    app = workflow.compile()
+    print("LangGraph compiled successfully.")
+except Exception as e:
+     print(f"Error compiling LangGraph workflow: {e}")
+     import traceback
+     traceback.print_exc()
+     app = None
+
+# --- Agent Definition using LangGraph ---
+class GaiaAgent:
     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
+        print("GaiaAgent initialized.")
+        if app is None or llm_with_tools is None:
+             raise RuntimeError("Agent failed to initialize due to missing API keys or graph compilation error.")
+        self.agent_app = app # Store the compiled graph
+        self.system_prompt = system_prompt # Store the system prompt
+
+    # Modified __call__ to accept task_id
+    def __call__(self, task_id: str, question: str) -> str:
+        print(f"\nAgent received question for Task ID {task_id}: {question}")
+
+        if self.agent_app is None:
+             print("Agent app is not compiled. Cannot process question.")
+             return "Agent failed to initialize."
+
+        try:
+            # Run the LangGraph workflow
+            # The initial state includes the system prompt, the human message, and the task_id
+            initial_messages = [
+                 AIMessage(content=self.system_prompt), # Start with System prompt guidance (as an AI message often works well with tool calling)
+                 HumanMessage(content=question)
+            ]
+            print("Invoking LangGraph agent...")
+            # Pass task_id in the initial state
+            final_state = self.agent_app.invoke(
+                {"messages": initial_messages, "task_id": task_id},
+                # config={"recursion_limit": 50} # Optional: increase recursion depth
+            )
+            print("LangGraph agent finished.")
+            # print(f"Final state messages: {final_state['messages']}") # Can be verbose
+
+            # Extract the final answer from the last AIMessage
+            final_message = final_state['messages'][-1]
+            if isinstance(final_message, AIMessage):
+                 final_answer = final_message.content
+                 print(f"Agent returning answer: {final_answer}")
+                 return final_answer
+            else:
+                 # If the last message isn't an AIMessage, it means the agent didn't converge
+                 # or the routing is incorrect. Return the last message content or an error.
+                 # This might happen if the agent ends after a tool call and doesn't produce a final AIMessage.
+                 error_message = f"Agent finished in an unexpected state. Last message type: {type(final_message)}. Content: {final_message}"
+                 print(error_message)
+                 # Attempt to extract *any* useful content from the last message if not AIMessage
+                 content_attempt = ""
+                 if hasattr(final_message, 'content'):
+                      content_attempt = str(final_message.content)
+                 elif hasattr(final_message, 'tool_outputs'):
+                      content_attempt = "Tool Outputs: " + json.dumps(final_message.tool_outputs)
+                 else:
+                      content_attempt = str(final_message)
+
+                 return f"Agent finished without a final answer message. Last output: {content_attempt[:500]}"
+
+        except Exception as e:
+            print(f"Error during agent execution: {e}")
+            import traceback
+            traceback.print_exc()
+            return f"An error occurred during agent execution: {e}"
+
+
+# --- Rest of the original code (kept mostly as is) ---
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
-    Fetches all questions, runs the BasicAgent on them, submits all answers,
+    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}"
@@ -34,24 +467,30 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         print("User not logged in.")
         return "Please Login to Hugging Face with the button.", None
 
+    if missing_vars:
+         return f"Missing required environment variables: {', '.join(missing_vars)}. Please set them in your Space settings.", 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()
+        print("GaiaAgent instantiated successfully.")
     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)
+        import traceback
+        traceback.print_exc()
+        return f"Error initializing agent: {e}\nCheck your environment variables.", None
+
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "Local development environment - No Space ID"
+    print(f"Agent code link: {agent_code}")
 
     # 2. Fetch Questions
     print(f"Fetching questions from: {questions_url}")
     try:
-        response = requests.get(questions_url, timeout=15)
+        response = requests.get(questions_url, timeout=30)
         response.raise_for_status()
         questions_data = response.json()
         if not questions_data:
@@ -73,33 +512,52 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     results_log = []
     answers_payload = []
     print(f"Running agent on {len(questions_data)} questions...")
+    start_time = time.time()
+    question_counter = 0
+
     for item in questions_data:
+        question_counter += 1
         task_id = item.get("task_id")
         question_text = item.get("question")
+        print(f"\n--- Processing Task ID: {task_id} ({question_counter}/{len(questions_data)}) ---")
+        print(f"Question: {question_text[:150]}...")
+
         if not task_id or question_text is None:
             print(f"Skipping item with missing task_id or question: {item}")
+            results_log.append({"Task ID": "N/A", "Question": str(item), "Submitted Answer": "Skipped (missing data)"})
             continue
+
+        submitted_answer = "Agent failed to run." # Default in case of crash
         try:
-            submitted_answer = agent(question_text)
+            # Pass task_id to the agent's call method
+            submitted_answer = agent(task_id, question_text)
             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}"})
+             print(f"FATAL ERROR running agent on task {task_id}: {e}")
+             import traceback
+             traceback.print_exc()
+             error_answer = f"AGENT CRASHED on task {task_id}: {e}"
+             answers_payload.append({"task_id": task_id, "submitted_answer": error_answer}) # Submit error answer
+             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": error_answer})
+
+    end_time = time.time()
+    total_duration = end_time - start_time
+    print(f"\nFinished running agent on {len(questions_data)} questions in {total_duration:.2f} seconds.")
 
     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)
 
-    # 4. Prepare Submission 
+    # 4. 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"Agent finished running. Submitting {len(answers_payload)} answers for user '{username}'..."
     print(status_update)
 
     # 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=180) # Increased timeout further
         response.raise_for_status()
         result_data = response.json()
         final_status = (
@@ -142,19 +600,28 @@ 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 Level 1 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.
+        1.  **Clone this space.**
+        2.  **Set Environment Variables:** Go to the Space settings and add your `OPENAI_API_KEY` and `TAVILY_API_KEY` as secret variables. These are required for the agent to use the LLM and search tools.
+        3.  Modify the `GaiaAgent` code (above) to improve its reasoning, tool use, and prompt engineering.
+        4.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
+        5.  Click 'Run Evaluation & Submit All Answers' to fetch questions (with task IDs), run your agent (which can now download files via the API using the task ID), submit answers, and see the score.
 
         ---
+        **Agent Details:**
+        This agent uses `langgraph` and `langchain`. It has access to:
+        *   Web search via Tavily (`tavily_search`).
+        *   Listing local files (`list_local_files`).
+        *   Reading local files (`read_local_file`).
+        *   **Downloading and reading files provided with a task via the evaluation API (`download_and_read_file`), using the task ID.**
+        *   A capable LLM (OpenAI's `gpt-4o-mini` by default, requires `OPENAI_API_KEY`).
+
         **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.
+        Running the evaluation can take several minutes as the agent processes each question. The provided agent is a starting point; significant prompt engineering, tool refinement, and potentially more sophisticated graph logic will be needed to reliably score above 30%.
         """
     )
 
@@ -163,8 +630,7 @@ 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)
+    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True, row_selectable=False)
 
     run_button.click(
         fn=run_and_submit_all,
@@ -173,9 +639,8 @@ with gr.Blocks() as demo:
 
 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}")
@@ -183,14 +648,22 @@ if __name__ == "__main__":
     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.")
 
+    if missing_vars:
+        print("\n" + "="*50)
+        print("WARNING: Launching interface but required API keys are missing.")
+        print("Set OPENAI_API_KEY and TAVILY_API_KEY in environment variables.")
+        print("The agent WILL FAIL without these.")
+        print("="*50 + "\n")
+
+
     print("-"*(60 + len(" App Starting ")) + "\n")
 
-    print("Launching Gradio Interface for Basic Agent Evaluation...")
+    print("Launching Gradio Interface for GAIA Level 1 Agent Evaluation...")
     demo.launch(debug=True, share=False)