Update app.py

app.py

@@ -199,7 +199,6 @@
 #     demo.launch(debug=True, share=False)
 
 
-
 import os
 import gradio as gr
 import requests
@@ -210,44 +209,41 @@ from typing import TypedDict, Annotated, List
 
 # ==============================================================================
 # PART 1: YOUR AGENT'S LOGIC AND DEFINITION
-# All of this is new. It replaces the old placeholder.
 # ==============================================================================
 
 # LangChain and LangGraph imports
 from langchain_huggingface import HuggingFaceEndpoint
-from langchain_community.tools.tavily_search import TavilySearchResults
+# NEW: Import TavilySearch from the new package
+from langchain_tavily import TavilySearch
 from langchain_experimental.tools import PythonREPLTool
 from langchain_core.messages import BaseMessage, HumanMessage
 from langgraph.graph import StateGraph, END
 from langgraph.prebuilt import ToolNode
+# NEW: Import the compatible agent constructor and prompt hub
+from langchain.agents import create_tool_calling_agent
+from langchain import hub
+
 
 # Load API keys from .env file or Space secrets
 load_dotenv()
 hf_token = os.getenv("HF_TOKEN")
 tavily_api_key = os.getenv("TAVILY_API_KEY")
 
-# Set the Tavily API key for the tool to use
 if tavily_api_key:
     os.environ["TAVILY_API_KEY"] = tavily_api_key
 else:
     print("Warning: TAVILY_API_KEY not found. Web search tool will not work.")
 
 # --- Define Agent Tools ---
+# NEW: Using TavilySearch from the correct package
 tools = [
-    TavilySearchResults(max_results=3, description="A search engine for finding up-to-date information on the web."),
+    TavilySearch(max_results=3, description="A search engine for finding up-to-date information on the web."),
     PythonREPLTool()
 ]
 tool_node = ToolNode(tools)
 
 # --- Configure the LLM "Brain" ---
 repo_id = "meta-llama/Meta-Llama-3-8B-Instruct"
-SYSTEM_PROMPT = """You are a highly capable AI agent. Your mission is to accurately answer complex questions.
-**Instructions:**
-1.  **Analyze:** Read the question to understand what is being asked.
-2.  **Plan:** Think step-by-step. Break the problem into smaller tasks. Decide which tool is best for each task.
-3.  **Execute:** Call ONE tool at a time.
-4.  **Observe & Reason:** After getting a tool's result, observe it. Decide if you have the final answer or if you need to use another tool.
-5.  **Final Answer:** Once confident, provide a clear, direct, and concise final answer."""
 
 llm = HuggingFaceEndpoint(
     repo_id=repo_id,
@@ -255,179 +251,130 @@ llm = HuggingFaceEndpoint(
     temperature=0,
     max_new_tokens=2048,
 )
-llm_with_tools = llm.bind_tools(tools)
+
+# --- THE FIX: Create Agent with a Compatible Method ---
+# REMOVED: llm_with_tools = llm.bind_tools(tools)
+# This was causing the error.
+
+# NEW: We pull a pre-made prompt that knows how to handle tool calls.
+prompt = hub.pull("hwchase17/react-json")
+
+# NEW: We use `create_tool_calling_agent`. This function correctly combines the LLM,
+# the tools, and the prompt, without needing the .bind_tools() method.
+agent_runnable = create_tool_calling_agent(llm, tools, prompt)
+
 
 # --- Build the LangGraph Agent ---
 class AgentState(TypedDict):
-    messages: Annotated[List[BaseMessage], lambda x, y: x + y]
+    # The 'messages' key is no longer used, 'input' and 'agent_outcome' are standard for this agent type
+    input: str
+    chat_history: list[BaseMessage]
+    agent_outcome: dict
 
+# NEW: The agent_node is much simpler now. It just calls the runnable we created.
 def agent_node(state):
-    last_message = state['messages'][-1]
-    prompt_with_system = [HumanMessage(content=SYSTEM_PROMPT, name="system_prompt"), last_message]
-    response = llm_with_tools.invoke(prompt_with_system)
-    return {"messages": [response]}
-
-def should_continue(state):
-    if state["messages"][-1].tool_calls:
-        return "tools"
-    return END
-
-workflow = StateGraph(AgentState)
-workflow.add_node("agent", agent_node)
-workflow.add_node("tools", tool_node)
-workflow.set_entry_point("agent")
-workflow.add_conditional_edges("agent", should_continue, {"tools": "tools", "end": END})
-workflow.add_edge("tools", "agent")
-
-# Compile the graph into a runnable app
-compiled_agent_app = workflow.compile()
-
-# --- THIS IS THE NEW BasicAgent CLASS THAT REPLACES THE PLACEHOLDER ---
+    outcome = agent_runnable.invoke(state)
+    return {"agent_outcome": outcome}
+
+def tool_node_executor(state):
+    # The agent_runnable provides tool calls in a specific format. We execute them.
+    tool_calls = state["agent_outcome"].tool_calls
+    tool_outputs = []
+    for tool_call in tool_calls:
+        tool_name = tool_call["name"]
+        tool_to_call = {tool.name: tool for tool in tools}[tool_name]
+        tool_output = tool_to_call.invoke(tool_call["args"])
+        tool_outputs.append({"output": tool_output, "tool_call_id": tool_call["id"]})
+    return {"intermediate_steps": tool_outputs}
+
+
+# This setup is more complex but correctly models the ReAct loop in LangGraph
 class BasicAgent:
     def __init__(self):
-        # Check for API keys during initialization
         if not hf_token or not tavily_api_key:
             raise ValueError("HF_TOKEN or TAVILY_API_KEY not set. Please add them to your Space secrets.")
         print("LangGraph Agent initialized successfully.")
+        # We need an agent executor to run the loop
+        from langchain.agents import AgentExecutor
+        self.agent_executor = AgentExecutor(agent=agent_runnable, tools=tools, verbose=True)
 
     def __call__(self, question: str) -> str:
         print(f"Agent received question (first 80 chars): {question[:80]}...")
         try:
-            inputs = {"messages": [HumanMessage(content=question)]}
-            final_response = ""
-            for s in compiled_agent_app.stream(inputs, {"recursion_limit": 15}):
-                if "agent" in s and s["agent"]["messages"][-1].content:
-                    final_response = s["agent"]["messages"][-1].content
-            
-            if not final_response:
-                final_response = "Agent finished but did not produce a clear final answer."
-
-            print(f"Agent returning final answer (first 80 chars): {final_response[:80]}...")
-            return final_response
+            # The AgentExecutor expects a dictionary with an "input" key.
+            response = self.agent_executor.invoke({"input": question})
+            final_answer = response.get("output", "Agent did not produce an output.")
+            print(f"Agent returning final answer (first 80 chars): {final_answer[:80]}...")
+            return final_answer
         except Exception as e:
             print(f"An error occurred in agent execution: {e}")
             return f"Error: {e}"
 
+
 # ==============================================================================
-# PART 2: THE GRADIO TEST HARNESS UI
-# The rest of this file remains exactly as it was provided in the template.
+# PART 2: THE GRADIO TEST HARNESS UI (UNCHANGED)
 # ==============================================================================
-
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
-    """
-    Fetches all questions, runs the BasicAgent on them, submits all answers,
-    and displays the results.
-    """
-    # (The rest of this function remains unchanged)
-    # --- Determine HF Space Runtime URL and Repo URL ---
-    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
-
+    # This entire function remains the same as the template
+    space_id = os.getenv("SPACE_ID")
     if profile:
         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
-
     api_url = DEFAULT_API_URL
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
-
-    # 1. Instantiate Agent (this now calls YOUR agent class from above)
     try:
         agent = BasicAgent()
     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"An unexpected error occurred fetching questions: {e}")
         return f"An unexpected error occurred fetching questions: {e}", None
-
-    # 3. Run your Agent
-    results_log = []
-    answers_payload = []
+    results_log, answers_payload = [], []
     print(f"Running agent on {len(questions_data)} questions...")
     for item in questions_data:
-        task_id = item.get("task_id")
-        question_text = item.get("question")
-        if not task_id or question_text is None:
-            print(f"Skipping item with missing task_id or question: {item}")
-            continue
+        task_id, question_text = item.get("task_id"), item.get("question")
+        if not task_id or question_text is None: continue
         try:
-            # This line now calls your __call__ method in your new BasicAgent
             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:
-             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}"})
-
-    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 
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
+    if not answers_payload: return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
     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()
         result_data = response.json()
-        final_status = (
-            f"Submission Successful!\n"
-            f"User: {result_data.get('username')}\n"
-            f"Overall Score: {result_data.get('score', 'N/A')}% "
-            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
+        final_status = (f"Submission Successful!\nUser: {result_data.get('username')}\nOverall Score: {result_data.get('score', 'N/A')}% ({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\nMessage: {result_data.get('message', '')}")
+        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"An unexpected error occurred during submission: {e}", pd.DataFrame(results_log)
 
-# --- Build Gradio Interface using Blocks ---
+# --- Gradio Interface (Unchanged) ---
 with gr.Blocks() as demo:
     gr.Markdown("# GAIA Agent Evaluation Runner")
-    gr.Markdown(
-        """
-        1.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
-        2.  Click 'Run Evaluation & Submit All Answers' to run your custom agent and see the score.
-        """
-    )
+    gr.Markdown("1. Log in. 2. Click 'Run Evaluation'.")
     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)
-    run_button.click(
-        fn=run_and_submit_all,
-        outputs=[status_output, results_table]
-    )
+    run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
 
 if __name__ == "__main__":
     demo.launch(debug=True, share=False)