Update app.py

app.py

@@ -2,20 +2,18 @@ import os
 import gradio as gr
 import requests
 import pandas as pd
+import traceback
 
 # Import smol-agent and tool components
 from smolagents import CodeAgent, LiteLLMModel, tool
-from smolagents import DuckDuckGoSearchTool
+# Corrected import for the search tool
+from smolagents.tools import DuckDuckGoSearch
 from unstructured.partition.auto import partition
 
-
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Agent Definition ---
-
-# 1. Define Your Tools
-
+# --- Tool Definition ---
 @tool
 def file_reader(file_path: str) -> str:
     """Reads the content of a file and returns its text content.
@@ -30,179 +28,155 @@ def file_reader(file_path: str) -> str:
         if file_path.startswith("http://") or file_path.startswith("https://"):
             response = requests.get(file_path, timeout=20)
             response.raise_for_status()
-            # Use a temporary file to process with unstructured
             with open("temp_file", "wb") as f:
                 f.write(response.content)
             elements = partition("temp_file")
             os.remove("temp_file") # Clean up
         else:
-            # Assumes it's a local path within the Space
             elements = partition(file_path)
-
         return "\n\n".join([str(el) for el in elements])
     except Exception as e:
         return f"Error reading or processing file '{file_path}': {e}"
 
-# 2. Define Your Agent Class
+# --- Agent Class (Completely Rewritten) ---
 class GaiaSmolAgent:
     def __init__(self):
         print("Initializing GaiaSmolAgent with OpenAI...")
-        # Ensure you have set your OPENAI_API_KEY as a secret in your HF Space
         api_key = os.getenv("OPENAI_API_KEY")
         if not api_key:
             raise ValueError("API key 'OPENAI_API_KEY' not found in environment secrets.")
 
-        # The "Planner" model - for high-level reasoning
         self.planner_model = LiteLLMModel(
-            model_id="gpt-4o", # Using OpenAI's gpt-4o model
+            model_id="gpt-4o",
             api_key=api_key,
             temperature=0.0,
         )
 
-        from smolagents import DuckDuckGoSearchTool
-
-        # The "Executor" agent - for executing tasks with tools
+        # Initialize the agent with the tools it can use.
+        # The agent will make these available to the script it runs.
         self.executor_agent = CodeAgent(
-            model=self.planner_model, # Can use the same model
-            # --- MODIFICATION 2: Use the DEFINITIVELY correct tool name in the list ---
-            tools=[file_reader, DuckDuckGoSearchTool()], # Corrected class name
-            add_base_tools=True,
+            model=self.planner_model,
+            tools=[file_reader, DuckDuckGoSearch()],
+            add_base_tools=True, # Provides a python interpreter
         )
-        print("GaiaSmolAgent initialized successfully with OpenAI.")
+        print("GaiaSmolAgent initialized successfully.")
 
-    def _generate_plan(self, question: str) -> list[str]:
-        """Generates a step-by-step plan to answer the question."""
-        print(f"Generating plan for question: {question[:100]}...")
+    def _generate_script(self, question: str) -> str:
+        """Generates a self-contained Python script to answer the question."""
+        print(f"Generating script for question: {question[:100]}...")
         
+        # This new prompt asks for a single, complete script.
         prompt = f"""
-        You are a master planner that creates Python code plans for an agent.
-        You have access to the following tools:
-        - `DuckDuckGoSearch(query: str) -> str`: Searches the web and returns a string with the results.
-        - `file_reader(file_path: str) -> str`: Reads a file from a URL or local path and returns its contents as a string.
-        - A full Python interpreter to process strings, perform calculations, etc.
+        You are an expert Python programmer. Your task is to write a single, self-contained Python script to answer the user's question.
 
-        Your task is to create a plan to answer the user's question. The plan must be a Python list of strings, where each string is a single line of Python code.
+        You have access to the following functions which are pre-imported and ready to use:
+        - `duck_duck_go_search(query: str) -> str`: Searches the web and returns a string with the results.
+        - `file_reader(file_path: str) -> str`: Reads a file and returns its contents as a string.
 
-        **Crucial Instructions:**
-        1.  The output of `DuckDuckGoSearch` and `file_reader` is always a STRING. You MUST use Python code (e.g., string manipulation, regex) in a subsequent step to extract information from this string. **DO NOT treat the tool output like a dictionary or JSON.**
-        2.  Store the output of tools in variables (e.g., `search_results = DuckDuckGoSearch(...)`).
-        3.  The final step of the plan MUST be a call to `final_answer("your final answer here")`. The answer must be a single, concise string.
+        CRITICAL INSTRUCTIONS:
+        1.  Your output must be ONLY the Python code for the script. Do not add any explanation or markdown formatting like ```python.
+        2.  The script MUST end with a call to a function `final_answer(answer: str)`.
+        3.  The `answer` passed to `final_answer` must be a single, concise string.
+        4.  All logic, including processing the string outputs from the tools, must be included in this single script. State is preserved within the script.
 
         Question: "{question}"
 
-        Example of a good plan for the question "What is the main topic of the document at http://example.com/paper.pdf?":
-        Plan:
-        [
-            "file_content = file_reader('http://example.com/paper.pdf')",
-            "summary = 'The main topic seems to be about: ' + file_content[:200]",
-            "final_answer(summary)"
-        ]
+        Example for "What is the capital of France?":
+        search_result = duck_duck_go_search("capital of France")
+        # In a real scenario, you would parse this string to find the answer.
+        # For this example, we'll just summarize the string.
+        answer = "Based on the search, the capital is likely Paris." # Replace with actual logic
+        final_answer(answer)
+        
+        Now, write the Python script to answer the user's question.
         """
         response = self.planner_model.generate(prompt)
-        print(f"Generated plan: {response}")
-        try:
-            # Safely evaluate the string to a Python list
-            plan = eval(response)
-            if isinstance(plan, list):
-                return plan
-            else:
-                # If the LLM doesn't return a list, create a fallback plan
-                return [f"final_answer('Error: Plan generation failed. The model did not return a valid list.')"]
-        except Exception as e:
-            print(f"Error parsing plan with eval(): {e}")
-            # If eval fails, create a fallback plan
-            return [f"final_answer('Error: Plan generation failed. The model returned malformed code: {response}')"]
-
+        
+        # Clean up the response from the LLM, which sometimes wraps it in markdown
+        if "```python" in response:
+            response = response.split("```python")[1].split("```")[0].strip()
+        
+        print(f"--- Generated Script ---\n{response}\n------------------------")
+        return response
 
     def __call__(self, question: str) -> str:
-        """Runs the planner and executor to answer the question."""
-        # ... (This method remains unchanged)
+        """Generates and executes a single script to answer the question."""
         print(f"Agent received question: {question[:100]}...")
-        plan = self._generate_plan(question)
-        final_answer = self.executor_agent.run(plan)
+        
+        try:
+            # Step 1: Generate a single, complete script
+            script_to_execute = self._generate_script(question)
+            
+            # Step 2: Execute the entire script in one go.
+            # The agent will match the function calls in the script (e.g., duck_duck_go_search)
+            # to the tools it was initialized with.
+            final_answer = self.executor_agent.run(script_to_execute)
+
+        except Exception as e:
+            print(f"FATAL AGENT ERROR: An exception occurred during agent execution: {e}")
+            print(traceback.format_exc()) # Print the full traceback for debugging
+            return f"FATAL AGENT ERROR: {e}"
+
         print(f"Agent returning final answer: {final_answer}")
         return str(final_answer)
 
-
+# --- Main Application Logic (Unchanged) ---
 def run_and_submit_all(profile: gr.OAuthProfile | None):
-    """
-    Fetches all questions, runs the GaiaSmolAgent on them, submits all answers,
-    and displays the results.
-    """
-    # --- 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.")
+    if not profile:
         return "Please Login to Hugging Face with the button.", None
+    
+    username = profile.username
+    print(f"User logged in: {username}")
 
     api_url = DEFAULT_API_URL
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # 1. Instantiate Agent
     try:
-        # **MODIFIED PART: Instantiate your new agent**
         agent = GaiaSmolAgent()
     except Exception as e:
-        print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
 
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
-    print(agent_code)
 
-    # 2. Fetch Questions
-    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 Exception as e:
-        print(f"Error fetching questions: {e}")
         return f"Error fetching questions: {e}", None
 
-
-    # 3. Run your Agent
     results_log = []
     answers_payload = []
-    print(f"Running agent on {len(questions_data)} questions...")
     for item in questions_data:
         task_id = item.get("task_id")
-        # GAIA questions can include file paths
         question_text = item.get("question")
-        file_path = item.get("file") # Get the file URL if it exists
+        file_path = item.get("file")
         if file_path:
              question_text += f"\n\nRelevant file is available at: {file_path}"
-
+        
         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)
             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:
+            # This catches errors in the __call__ method itself
+            error_message = f"AGENT ERROR: {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(traceback.format_exc())
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": error_message})
 
     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
     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}'..."
-    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.raise_for_status()
@@ -214,56 +188,38 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
             f"Message: {result_data.get('message', 'No message received.')}"
         )
-        print("Submission successful.")
-        results_df = pd.DataFrame(results_log)
-        return final_status, results_df
-    except requests.exceptions.HTTPError as e:
-        error_detail = f"Server responded with status {e.response.status_code}."
-        try:
-            error_json = e.response.json()
-            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
-        except requests.exceptions.JSONDecodeError:
-            error_detail += f" Response: {e.response.text[:500]}"
-        status_message = f"Submission Failed: {error_detail}"
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
+        return final_status, pd.DataFrame(results_log)
     except Exception as e:
-        status_message = f"An unexpected error occurred during submission: {e}"
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
+        return f"Submission Failed: {e}", pd.DataFrame(results_log)
 
-# --- Gradio Interface ---
-# (This part remains unchanged)
+# --- Gradio Interface (Unchanged) ---
 with gr.Blocks() as demo:
     gr.Markdown("# GAIA Agent Evaluation Runner (smol-agent)")
     gr.Markdown(
         """
         **Instructions:**
-
         1.  Ensure you have added your **OpenAI API key** (as `OPENAI_API_KEY`) in the Space's 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.
+        2.  Log in to your Hugging Face account using the button below.
+        3.  Click 'Run Evaluation & Submit All Answers' to run your agent and see the score.
         """
     )
-    
     gr.LoginButton()
-
     run_button = gr.Button("Run Evaluation & Submit All Answers")
-
     status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
     results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
-
-    # This is the new way to bind the OAuth profile to the function
-    run_button.click(
+    
+    demo.load(
         fn=run_and_submit_all,
-        inputs=None, # No direct input components
+        inputs=None,
         outputs=[status_output, results_table],
-        api_name="run_evaluation" # Add an API name for programmatic access
+        every=None, # Remove automatic running on load
+    )
+    
+    run_button.click(
+        fn=run_and_submit_all,
+        outputs=[status_output, results_table]
     )
 
-# The __main__ block remains the same
 if __name__ == "__main__":
     print("Launching Gradio Interface for GAIA Agent Evaluation...")
     demo.launch(debug=True, share=False)