Update app.py

app.py

@@ -1,6 +1,5 @@
 import gradio as gr
 from langgraph.graph import StateGraph, END
-# We are using MemorySaver now
 from langgraph.checkpoint.memory import MemorySaver
 import operator
 from typing import TypedDict, Annotated, Optional
@@ -21,8 +20,6 @@ def greeting_node(state: GraphState) -> GraphState:
     print(greeting)
     return {"greeting_message": greeting, "current_node": "greeting"}
 
-# IMPORTANT: This node will now run *after* human input is in the state.
-# It does NOT ask for input.
 def human_input_node(state: GraphState) -> GraphState:
     """
     Node 2: This node processes the human input that was added to the state
@@ -68,30 +65,23 @@ def start_graph(thread_id_state):
     new_thread_id = str(uuid.uuid4())
     print(f"\n--- Starting New Graph Execution with thread_id: {new_thread_id} ---")
     
-    # In-memory saver does not need explicit drop for new UUIDs, but good for resetting if reusing IDs
-    # try:
-    #     global_memory_saver.drop(config={"configurable": {"thread_id": new_thread_id}})
-    # except Exception as e:
-    #     print(f"Could not drop previous state for {new_thread_id}: {e}")
-
     try:
-        # Initial run: Graph executes greeting_node, then interrupts BEFORE human_input_node.
-        # We pass None as input, as the state is managed by the graph's execution up to the breakpoint.
-        for s in global_graph.stream(None, {"configurable": {"thread_id": new_thread_id}}):
+        # CRITICAL FIX: Pass an empty dictionary {} as input for the first stream call.
+        # This tells LangGraph to start from the entry point with an initial empty state.
+        for s in global_graph.stream({}, {"configurable": {"thread_id": new_thread_id}}):
             if "__end__" in s:
                 break
             elif "__interrupt__" in s:
                 print(f"Graph interrupted BEFORE {s.get('__interrupt__', 'Unknown')} node.")
                 break
             else:
-                pass # You can print s here to see node outputs during initial run
+                pass 
         
         current_state_snapshot = global_graph.get_state({"configurable": {"thread_id": new_thread_id}})
         
         output_message = current_state_snapshot.values.get("greeting_message", "No greeting yet.")
         output_message += "\n\n" + "Please type your response in the 'Your Input' box and click 'Resume Graph'."
 
-        # Enable human input textbox and resume button, disable start button
         return (output_message, gr.update(interactive=True), gr.update(interactive=True), gr.update(interactive=False), new_thread_id)
 
     except Exception as e:
@@ -103,38 +93,24 @@ def resume_graph(human_input_from_ui: str, thread_id_state):
     print(f"Human input received from UI: {human_input_from_ui}")
 
     try:
-        # --- CRITICAL CHANGES FOR RESUMPTION WITH INTERRUPT_BEFORE ---
-        # 1. Get the current state from the checkpointer.
         current_state_snapshot = global_graph.get_state({"configurable": {"thread_id": thread_id_state}})
-        
-        # 2. Extract the current values dictionary from the snapshot.
         current_state_values = current_state_snapshot.values
         
-        # 3. Manually update the 'human_input' field in this dictionary.
-        # The operator.add on Annotated[Optional[str], operator.add] will implicitly
-        # handle combining if it was a list or similar, but for a simple string
-        # it typically means setting the value.
         current_state_values["human_input"] = human_input_from_ui
 
-        # 4. Save this modified state back to the checkpointer.
-        # This is how the human's input is "injected" into the graph's memory.
         global_memory_saver.put_state(current_state_values, {"configurable": {"thread_id": thread_id_state}})
 
-        # 5. Resume the graph with None as input.
-        # The graph will now load the state (which includes the injected human_input)
-        # and proceed to execute the 'human_input_interrupt' node (which it was paused before)
-        # and subsequent nodes.
+        # Resume the graph with None as input after manually updating the state.
         for s in global_graph.stream(None, {"configurable": {"thread_id": thread_id_state}}):
             if "__end__" in s:
                 break
             else:
-                pass # You can print s here to see node outputs during resumption
+                pass 
 
         final_state_snapshot = global_graph.get_state({"configurable": {"thread_id": thread_id_state}})
         final_state_values = final_state_snapshot.values
 
         final_message = final_state_values.get("final_response", "Graph finished without final response.")
-        # Disable input, resume button, enable start button for new conversation
         return (final_message, gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=True), thread_id_state)
 
     except Exception as e: