Proposal: Extend interrupt() to Support State Updates

[mme]

Problem

Right now, interrupt() creates ephemeral HITL (human-in-the-loop) interactions that bypass the usual messages log (which includes both text messages, and tool call messages).

Often, though, it’s useful for users to treat these HITL interactions as standard agent-user interactions - so they can be saved in the conversation history, become available as context for an LLM, etc.

Example

Consider the following chat conversation

"..."

"What is your favorite color?" // interrupt(question)

"Blue" // answer = interrupt(...)

"..."

"Do you remember my favorite color?"

"Yes, it's blue" // impossible without the conversation history

If the interrupt question/answer does not make it into the messages array:

1. It will not be serialized alongside the rest of the user-agent interaction
2. It will not be available in the conversation context in future interactions. E.g. when the user asks "Do you remember my favorite color?" the answer will be “No.

Motivation

• The interrupt() developer experience is the best one for HITL - since it’s localized and self-evident. answer = interrupt(question_for_human)
• In many cases (including for Copilots), the ‘default behavior’ users wish for in HITL interactions is not just to get a question/answer, but for the interaction to become a standard part of the history
  • text question/answer can be encoded as standard human/AI messages
  • JSON question/answer can be encoded as tool call / tool result
• Currently it’s impossible for users to locally modify the messages state alongside the interrupt flow while still benefiting from the interrupt developer experience

Proposal

We propose extending interrupt() to accept state updates via a configuration object that determines how to map between a value passed to interrupt and the state:

class InterruptConfig(TypedDict):
    # Function that takes a question of any type and returns a Command.
    on_interrupt_update: Callable[[Any], Command]
    
    # Function that takes an answer of any type and returns a Command.
    on_resume_update: Callable[[Any], Command]

The interrupt() function accepts a second argument, interrupt_config, which specifies how the provided value is incorporated into the state update.

• The on_interrupt_update parameter is a function that defines how the value provided to interrupt() is transformed into a state update immediately after the interrupt occurs.
• The on_resume_update parameter is a function that defines how the value provided to Command(resume=value) is transformed into a state update before the graph resumes execution.

To enable a nice developer experience, a standard interrupt config is provided that maps a dict structure representing a tool call to AIMessage(tool_calls=[...]) and a string to AIMessage(content="...")

from langgraph.types import update_messages_interrupt_config

def a_node(state: MessagesState):
    answer = interrupt(
        {
            "name": "approve",
            "args": {
               "title": "Really delete xyz?"
            }
        },
        update_messages_interrupt_config
    )
	  
    if answer["delete"]:
        perform_delete("some_file")
		  
    answer = interrupt(
        "What's your name?",
        update_messages_interrupt_config
    )
		
    print(f"Hi {answer}")

[eyurtsev]

cc @eyurtsev tagging myself