Update app.py

app.py

@@ -3,7 +3,7 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
-from langgraph.prebuilt import ToolNode
+from langgraph.prebuilt import ToolNode, create_react_agent
 from tools import web_search, parse_excel, ocr_image
 # import langgraph
 from typing import TypedDict, Annotated
@@ -26,116 +26,57 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-
 class AgentState(TypedDict):
-    # We store the full chat history as a list of strings.
-    messages: Annotated[list[str], add_messages]
-    # If the agent requests a tool, it will fill in:
-    tool_request: dict | None
-    # Whenever a tool runs, its result goes here:
-    tool_result: str | None
-
-# 2) Wrap ChatOpenAI in a function whose signature is (state, user_input) → new_state
-llm = ChatOpenAI(model_name="gpt-4.1-mini")
-
-def agent_node(state: AgentState, user_input: str) -> AgentState:
-    """
-    This function replaces raw ChatOpenAI. It must accept (state, user_input) 
-    and return a new AgentState dict.
-    """
-    # 2.a) Grab prior chat history (empty list on first turn)
-    prior_msgs = state.get("messages", [])
-    # 2.b) Append the new user_input
-    chat_history = prior_msgs + [f"USER: {user_input}"]
-    # 2.c) Ask the LLM for a response
-    llm_output = llm(chat_history).content
-
-    # 2.d) Check if the LLM output is valid Python dict literal indicating a tool call.
-    #      If it is, parse it and stash in state["tool_request"]. Otherwise, no tool.
-    tool_req = None
-    try:
-        parsed = eval(llm_output)
-        if isinstance(parsed, dict) and parsed.get("tool"):
-            tool_req = parsed
-    except Exception:
-        tool_req = None
-
-    # 2.e) Construct the new state:
-    return {
-        "messages": chat_history + [f"ASSISTANT: {llm_output}"],
-        "tool_request": tool_req,
-        "tool_result": None  # will be filled by the tool_node if invoked
-    }
-
-# 3) Create a ToolNode for all three tools, then wrap it in a function
-#    whose signature is also (state, tool_request) → new_state.
-underlying_tool_node = ToolNode([ocr_image, parse_excel, web_search])
-
-def tool_node(state: AgentState, tool_request: dict) -> AgentState:
-    """
-    The graph will only call this when tool_request is a dict like
-      {"tool": "...", "path": "...", ...}
-    Use the underlying ToolNode to run it and store the result.
-    """
-    # 3.a) Run the actual ToolNode on that dict:
-    result_text = underlying_tool_node.run(tool_request)
-
-    # 3.b) Update state.messages to note the tool's output,
-    #      and clear tool_request so we don't loop.
-    return {
-        "messages": [f"TOOL ({tool_request['tool']}): {result_text}"],
-        "tool_request": None,
-        "tool_result": result_text
-    }
-
-# 4) Build and register nodes exactly as in the tutorial
+    # Keep track of the full “chat history” so the LLM sees it each time
+    messages: list[str]
+    # These two fields are _optional_—we won’t even use them directly in our code,
+    # but the ReAct agent will populate them when it calls a tool.
+    tool_name: str       # e.g. "ocr_image" or "web_search"
+    tool_input: str      # whatever arguments you passed into the tool
+
+# ─── 2) Instantiate your LLM (ChatOpenAI) ───
+llm = ChatOpenAI(model_name="gpt-4.1-mini", temperature=0.0)
+
+# ─── 3) Wrap your three tools into a single ToolNode ───
+# ToolNode lets LangGraph know “these are the only tool functions the agent may call”
+tool_node = ToolNode([ocr_image, parse_excel, web_search])
+
+# ─── 4) Use create_react_agent to build a ReAct‐style agent for you ───
+# This single “agent” node will:
+#   • Take the entire AgentState (including messages),
+#   • Look at state["messages"], decide if it needs to call a tool,
+#   • If so, emit {"tool": "<tool_name>", "input": "<tool_input>"},
+#     and then feed results back into the LLM automatically,
+#   • If not, emit a final answer as plain text.
+agent = create_react_agent(llm, tool_node)
+
+# ─── 5) Build a graph with exactly two edges, just like the tutorial ───
 graph = StateGraph(AgentState)
-graph.add_node("agent", agent_node)
-graph.add_node("tools", tool_node)
+graph.add_node("agent", agent)
 
-# 5) Simple START → "agent" edge (no third argument needed)
+# 5.a) Whenever user input arrives, send it into the “agent” node:
 graph.add_edge(START, "agent")
 
-# 6) Simple "tools" → "agent" edge (again, no third argument)
-graph.add_edge("tools", "agent")
+# 5.b) Once “agent” produces its final text (not a tool call), go to END:
+graph.add_edge("agent", END)
 
-# 7) Conditional branching out of "agent," exactly like the tutorial
-def route_agent(state: AgentState, agent_out):
-    """
-    When the LLM (agent_node) runs, it returns an AgentState where
-    - state["tool_request"] is either a dict (if a tool was asked) or None.
-    - state["tool_result"] is always None on entry to agent_node.
-
-    route_agent must look at that returned state (called agent_out)
-    and decide:
-      • If agent_out["tool_request"] is not None, go to "tools".
-      • Otherwise, terminate (go to END).
-    """
-    if agent_out.get("tool_request") is not None:
-        return "tools"
-    return "final"
-
-graph.add_conditional_edges(
-    "agent",       # source
-    route_agent,   # routing function (signature: (state, agent_out) → str key)
-    {
-        "tools": "tools",  # if route_agent(...) == "tools", transition to node "tools"
-        "final": END       # if route_agent(...) == "final", stop execution
-    }
-)
-
-# 8) Compile the graph (now graph.run(...) will work)
+# 5.c) Compile so we can call .invoke(...) at runtime
 compiled_graph = graph.compile()
 
-# 9) Define respond_to_input so that Gradio (and the Hugging Face submission) can call it
+# ─── 6) Define a simple function Gradio (and the “submit all” loop) can call ───
 def respond_to_input(user_input: str) -> str:
-    initial_state: AgentState = {"messages": [], "tool_request": None, "tool_result": None}
-    # ✔️ use .invoke() in v0.4.7
+    initial_state: AgentState = {
+        "messages": [],  # No history on the first turn
+        "tool_name": "",
+        "tool_input": ""
+    }
+    # In v0.4.7, use .invoke(...) on the compiled graph
     final_state = compiled_graph.invoke(initial_state, user_input)
-    # Return the last assistant message
-    last = final_state["messages"][-1]
-    return last.replace("ASSISTANT: ", "")
-
+    # `create_react_agent` always appends its LLM text into state["messages"].
+    # The last entry of “ASSISTANT: <answer>” is the final answer.
+    last_line = final_state["messages"][-1]
+    # If the agent prefixes with “ASSISTANT: ”, strip it off.
+    return last_line.replace("ASSISTANT: ", "", 1)
 
 
 class BasicAgent: