Weird interrupt related issue

[CymDanus]

I have a functional and working graph which works perfectly fine like it should.
However when I use the interrupt function within a node I created called "human_feedback_node" the interrupt just does nothing and forcefully quits the execution. If I add a try and except clause, it doesn't exit from the program but it doesn't ask me for anything. I understand its entering the except clause because its an interrupt but why doesn't it ask me for input?

Here is the related code -

from typing import Literal
from langgraph.types import Command
from graph.state import State
from graph.consts import *
from langchain_core.messages import HumanMessage
from langgraph.types import interrupt

def human_feedback_node(state: State) -> Command[Literal[SUPERVISOR_NODE]]:
    """Human feedback node that processes user input and updates the state."""
    
    # Get the user feedback from the state
    user_feedback = interrupt("Do you approve of the output?\n")
    print(f"User feedback: {user_feedback}")
    # Add the user feedback as a message to the state
    return Command(
        resume=user_feedback,
        update={
            "messages": [
                HumanMessage(content=user_feedback, name="human_feedback_node")
            ]
        },
        goto=SUPERVISOR_NODE
    ) 

Here is the video of it happening

Screen.Recording.2025-01-16.at.10.14.21.mov

[hinthornw]

Thanks for writing in. That sounds like interrupt is behaving as designed.

It raises a node interrupt exception, which LangGraph interprets as an instruction to pause the graph execution. The interrupt message is emitted in the stream output and stored in the persistence layer (for when you get the state of the graph). You then resume the graph with the response value.

See e.g., the doc:
https://langchain-ai.github.io/langgraph/concepts/human_in_the_loop/#how-does-resuming-from-an-interrupt-work

[CymDanus]

But the interrupt it self is supposed to let me write an answer? It just quits from the graph and if I add a try except clause it does interrupt but it doesn't ask for input. I don't understand do you mean by "behaving as designed" if its not asking for input. By the way - It is behaving as intended when running from Langgraph studio.

[vbarda]

it doesn't ask for input

is your expectation more like input() in python? if so, LangGraph interrupt() doesn't do this. It just stops the graph execution and you need to resume it using Command(resume) to provide the value

i think there is actually an issue in your code example: Command(resume) should be used after the graph is halted by interrupt(), to provide the interrupt value, not in the value returned by the node function

e.g.

...
def human_feedback_node(state: State) -> Command[Literal[SUPERVISOR_NODE]]:
    """Human feedback node that processes user input and updates the state."""
    
    # Get the user feedback from the state
    user_feedback = interrupt("Do you approve of the output?\n")
    print(f"User feedback: {user_feedback}")
    # Add the user feedback as a message to the state
    return Command(
        # remove resume here
        update={
            "messages": [
                HumanMessage(content=user_feedback, name="human_feedback_node")
            ]
        },
        goto=SUPERVISOR_NODE
    )
... 

graph = (
  StateGraph()
  .add_node(human_feedback_node)
 ....
)

graph.invoke({"messages": [...]})
# now graph is interrupted
graph.invoke(Command(resume="My value"))

hope this clarifies a bit!

[CymDanus]

Thank you it clarifies everything but should I keep looping the graph to continue its flow if its interrupted? What if its interrupted more than once? Also I am using graph.stream - does it change anything?

for event in graph.stream( {"messages": [("user", "...message here..")]}, config=thread_config, stream_mode="debug" ): print(event) print("----")

[vbarda]

Not sure what you mean by "looping to continue". if you interrupt multiple times (including in a loop), you will need to provide a value using Command(resume) for each of the interrupt invocations. The only thing to keep in mind: when you resume the graph with Command(resume), you re-execute the full node that contains interrupt() and use the resume value. And if you have a loop in your node (or multiple interrupts), e.g.

while True:
    value = interrupt()

it will re-execute the full loop, and look up all of the previously provided resume values (cached by LangGraph), and then interrupt again.

Using graph.stream doesn't change anything, you can provide Command(resume) to it the same way

[CymDanus]

I will provide my main code and you will see what I mean, either way your answer made it clear and I used your answer to enhance my understanding by some debugging and reverse engineering. Thank you!

Human feed back node

def human_feedback_node(state: State) -> Command[Literal[DEPENDENCY_NODE, EXECUTOR_NODE, METADATA_NODE, SUMMARY_NODE, EXECUTOR_NODE, SUPERVISOR_NODE]]:
    """Human feedback node that processes user input and updates the state."""
    previous_node = state["messages"][-1].name
    human_interrupt = interrupt(f"Do you approve of the output from {previous_node}?\n")

    #prompt omitted because that would just make this reply really long
    revision_prompt = prompt_template.format_messages(
        human_message=human_interrupt,
        previous_node=previous_node
    )

    response = llm.with_structured_output(Route).invoke(revision_prompt)

    next_worker = response["next_worker"]
    return Command(
        update={
            "messages": [
                HumanMessage(content=human_interrupt, name=HUMAN_FEEDBACK_NODE)
            ]
        },
        goto=next_worker
    )

Main code

while True:
    for event in graph.stream(
        human_message, config=thread_config, stream_mode="debug"
    ):
        print(event)
        print("----")

    human_feedback = input("Do you approve of the output?\n")
    human_message = Command(resume=human_feedback)