Interrupts not working as expected (graph resets instead of resuming)

[alex-feel]

I'm experiencing two issues when using Agent Chat UI with LangGraph:

1. Only the second interrupt (from the get_user_feedback node) appears in the UI.
2. After responding to that interrupt, the graph restarts from the beginning rather than resuming from the current node.

I have verified that everything works correctly in LangGraph Studio (as shown in the attached video).
I’m not proficient in TypeScript and have only recently started working with LangGraph, so I might be missing an obvious issue on my end.

Steps to Reproduce:

1. Use the code below.
2. Run Agent Chat UI.
3. Notice that only the second interrupt is displayed and after providing input, the graph resets.

Minimal reproducible code

from enum import Enum
from typing import Annotated
from typing import Literal
from typing import TypedDict

from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
from langchain_core.messages import AIMessage
from langchain_core.messages import AnyMessage
from langchain_core.messages import HumanMessage
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnableConfig
from langgraph.checkpoint.memory import MemorySaver
from langgraph.graph import add_messages
from langgraph.graph import START
from langgraph.graph import StateGraph
from langgraph.types import Command
from langgraph.types import interrupt


load_dotenv()


class State(TypedDict):
  messages: Annotated[list[AnyMessage], add_messages]


class YesNoEnum(str, Enum):
  YES = 'yes'
  NO = 'no'


model = init_chat_model()

checkpointer = MemorySaver()

config = RunnableConfig(
  configurable={
      'model': 'gpt-4o-mini',
      'temperature': 0.5,
      'max_tokens': None,
      'timeout': None,
  }
)


async def validate_request_scope(state: State) -> Command[Literal['provide_cat_info', 'handle_off_topic']]:
  prompt = ChatPromptTemplate.from_messages([
      ('system', '''
You are the input controller for a "cats-only" system.
Determine if a user request EXCLUSIVELY relates to cats.

Answer ONLY "yes" or "no" (all lower case):
- "yes" if the request is about cats
- "no" otherwise
          '''),
      ('human', '''
Please validate the following user query:
{user_query}
          ''')
  ])

  chain = prompt | model | StrOutputParser()

  result = (chain.invoke(
      {
          'user_query': state['messages'][-1].content,
      },
      config=config,
  )).strip().lower()

  try:
      validation_result = YesNoEnum(result)
  except ValueError:
      validation_result = YesNoEnum.YES

  # Decision logic
  if validation_result is YesNoEnum.YES:
      goto = 'provide_cat_info'
      messages = []

  else:
      goto = 'handle_off_topic'
      messages = []

  return Command(
      update={
          'messages': messages,
      },
      goto=goto,
  )


async def handle_off_topic(state: State) -> Command[Literal['validate_request_scope']]:  # noqa
  interrupt_message = {
      'message': 'I can only help with cats. Sorry, but your request is off-topic.'
  }

  new_query = interrupt(interrupt_message)

  return Command(
      update={
          'messages': HumanMessage(content=new_query),
      },
      goto='validate_request_scope',
  )


async def provide_cat_info(state: State):  # noqa
  messages = [AIMessage(content='Here is some info about cats.')]

  return {
      'messages': messages,
  }


async def get_user_feedback(state: State) -> Command[Literal['provide_cat_info']]:  # noqa
  interrupt_message = {
      'message': 'The cat info is ready. If you have any comments or additional details, '
                 'send them to me and I will continue working.'
  }

  feedback = interrupt(interrupt_message)

  return Command(
      update={
          'messages': [HumanMessage(content=feedback)],
      },
      goto='provide_cat_info',
  )

workflow = StateGraph(State)

workflow.add_node('validate_request_scope', validate_request_scope)
workflow.add_node('handle_off_topic', handle_off_topic)
workflow.add_node('provide_cat_info', provide_cat_info)
workflow.add_node('get_user_feedback', get_user_feedback)

workflow.add_edge(START, 'validate_request_scope')
workflow.add_edge('provide_cat_info', 'get_user_feedback')

graph = workflow.compile()

Video Demonstration: [Video demonstration link]

Please let me know if additional information is needed. Thanks!

[Romamo]

Check code from this comment #69 (comment)

[alex-feel]

@Romamo, thank you for your help so far.

I tried to adapt this approach in my code as follows:

My adapted code for handle_off_topic

async def handle_off_topic(state: State) -> Command[Literal['validate_request_scope']]:
    request = HumanInterrupt(
        action_request=ActionRequest(
            action='Update your request',  # The action being requested
            args={}  # Arguments for the action
        ),
        config=HumanInterruptConfig(
            allow_ignore=False,  # Disallow skipping this step
            allow_respond=True,  # Allow text feedback
            allow_edit=False,    # Don't allow editing
            allow_accept=True    # Allow direct acceptance
        ),
        description='I can only help with cats. Sorry, but your request is off-topic.'
    )
    # Send the interrupt request and get the response
    response = interrupt([request])[0]

    return Command(
        update={
            'messages': HumanMessage(content=response),
        },
        goto='validate_request_scope',
    )

However, while this works in LangGraph Studio, still nothing is displayed in Agent Chat UI for the interrupt. If a response is received, only the first character of the user's input is stored in the HumanMessage.

[Romamo]

@alex-feel
It's not exactly the same

[alex-feel]

@Romamo, it didn't work when I tried the same code. Here I used an approach from this example.

[bracesproul]

@alex-feel are you seeing any errors in the console when you try to call the graph & the interrupt is triggered? Also, could you send me a LangSmith trace where this interrupt is triggered? I can see if I notice anything.

Thanks

[alex-feel]

Hi @bracesproul, thanks for the quick reply.

There are no errors in the console — everything runs smoothly. Here are the logs:
https://gist.github.com/alex-feel/385a1b9a10bdf7547bfe861ec4caa915

I'm using the latest package versions:

langchain-community==0.3.20
langchain-core==0.3.50
langchain-openai==0.3.12
langgraph-cli[inmem]==0.1.83
langgraph==0.3.23
langsmith==0.3.23

Here are three LangSmith traces (all from the same thread_id in Agent Chat UI):

1. Initial message: "Biggest dog?"
   Expected: validate_request_scope routes to handle_off_topic, which triggers an interrupt with a message.
   Actual: nothing shown in the UI.
   https://smith.langchain.com/public/ec489c98-203b-4a58-aba4-3ca1e12300d2/r

2. Next message: "Biggest cat?"
   Expected: message is classified by validate_request_scope as valid, handled by provide_cat_info, then followed by an interrupt from get_user_feedback.
   Actual: works as expected, interrupt is displayed.
   https://smith.langchain.com/public/a9b27fb1-a9a1-44fe-9c10-7b1333158319/r

3. Follow-up message: "Give me more info"
   Expected: graph resumes at provide_cat_info, then transitions to get_user_feedback, which should again trigger the interrupt.
   Actual: graph restarts entirely and nothing is shown — no output, no interrupt (the message is treated as off-topic since the graph was started from the beginning).
   https://smith.langchain.com/public/7b5dc431-afc6-42be-9295-14e8c4d4e5ed/r

Let me know if I can provide anything else. Thanks again for taking a look.

[bracesproul]

in order for the Agent Chat UI to render the interrupt component, your interrupt needs to pass this schema which none of your interrupts do

[alex-feel]

@bracesproul, despite implementing the suggested changes, the issue persists: the interrupt message from the handle_off_topic function does not appear in the UI, while the interrupt from get_user_feedback functions as expected (as before).

Traces:

https://smith.langchain.com/public/d6e18e96-c9c7-4f1c-a974-289cab5cd543/r
https://smith.langchain.com/public/c5214e51-c422-4899-900a-649a30689e65/r
https://smith.langchain.com/public/34013716-0e7b-468c-975b-e363ea271c71/r

Current Implementation:

from enum import Enum
from typing import Annotated
from typing import Literal
from typing import TypedDict

from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
from langchain_core.messages import AIMessage
from langchain_core.messages import AnyMessage
from langchain_core.messages import HumanMessage
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnableConfig
from langgraph.checkpoint.memory import MemorySaver
from langgraph.graph import add_messages
from langgraph.graph import START
from langgraph.graph import StateGraph
from langgraph.prebuilt.interrupt import HumanInterrupt
from langgraph.types import Command
from langgraph.types import interrupt


load_dotenv()


class State(TypedDict):
  messages: Annotated[list[AnyMessage], add_messages]


class YesNoEnum(str, Enum):
  YES = 'yes'
  NO = 'no'


model = init_chat_model()

checkpointer = MemorySaver()

config = RunnableConfig(
  configurable={
      'model': 'gpt-4o-mini',
      'temperature': 0.5,
      'max_tokens': None,
      'timeout': None,
  }
)


async def validate_request_scope(state: State) -> Command[Literal['provide_cat_info', 'handle_off_topic']]:
  prompt = ChatPromptTemplate.from_messages([
      ('system', '''
You are the input controller for a "cats-only" system.
Determine if a user request EXCLUSIVELY relates to cats.

Answer ONLY "yes" or "no" (all lower case):
- "yes" if the request is about cats
- "no" otherwise
          '''),
      ('human', '''
Please validate the following user query:
{user_query}
          ''')
  ])

  chain = prompt | model | StrOutputParser()

  result = (chain.invoke(
      {
          'user_query': state['messages'][-1].content,
      },
      config=config,
  )).strip().lower()

  try:
      validation_result = YesNoEnum(result)
  except ValueError:
      validation_result = YesNoEnum.YES

  # Decision logic
  if validation_result is YesNoEnum.YES:
      goto = 'provide_cat_info'
      messages = []

  else:
      goto = 'handle_off_topic'
      messages = []

  return Command(
      update={
          'messages': messages,
      },
      goto=goto,
  )


async def handle_off_topic(state: State) -> Command[Literal['validate_request_scope']]:  # noqa
  # Create an interrupt request
  request: HumanInterrupt = {
      'action_request': {
          'action': 'Update your request',
          'args': {},
      },
      'config': {
          'allow_ignore': False,
          'allow_respond': True,
          'allow_edit': False,
          'allow_accept': False,
      },
      'description': 'I can only help with cats. Sorry, but your request is off-topic.',
  }

  # Send interrupt and await user response
  response = interrupt(request)[0]

  # Process the user's response
  return Command(
      update={
          'messages': [HumanMessage(content=response['args'])]
      },
      goto='validate_request_scope',
  )


async def provide_cat_info(state: State):  # noqa
  messages = [AIMessage(content='Here is some info about cats.')]

  return {
      'messages': messages,
  }


async def get_user_feedback(state: State) -> Command[Literal['provide_cat_info']]:  # noqa
  # Create an interrupt request
  request: HumanInterrupt = {
      'action_request': {
          'action': 'Do you need additional info?',
          'args': {},
      },
      'config': {
          'allow_ignore': False,
          'allow_respond': True,
          'allow_edit': False,
          'allow_accept': False,
      },
      'description': 'The cat info is ready. If you have any comments or additional details, '
                     'send them to me and I will continue working.',
  }

  # Send interrupt and await user response
  response = interrupt(request)[0]

  # Process the user's response
  return Command(
      update={
          'messages': [HumanMessage(content=response['args'])]
      },
      goto='provide_cat_info',
  )


workflow = StateGraph(State)

workflow.add_node('validate_request_scope', validate_request_scope)
workflow.add_node('handle_off_topic', handle_off_topic)
workflow.add_node('provide_cat_info', provide_cat_info)
workflow.add_node('get_user_feedback', get_user_feedback)

workflow.add_edge(START, 'validate_request_scope')
workflow.add_edge('provide_cat_info', 'get_user_feedback')

graph = workflow.compile()

I would appreciate any further guidance on resolving this issue.

[Romamo]

@alex-feel replace this

  return Command(
      update={
          'messages': [HumanMessage(content=response['args'])]
      },
      goto='provide_cat_info',
  )

to

return {"input": response}

[alex-feel]

@Romamo,

Thank you for taking the time to review my implementation and for your suggestion. I have carefully considered your proposed change, but there are a few reasons why it does not fit my use case:

1. State Structure: My state does not include an input field. The suggestion to return {"input": response} would have no designated place to store the response in my current state definition.

2. Functionality of get_user_feedback: The change you proposed targets the get_user_feedback function, yet this function is working correctly as designed. It uses goto='provide_cat_info', ensuring that after the user responds, the flow returns to provide_cat_info. There is no issue with the interrupt handling in the UI for this function. The issue is in the handle_off_topic function.

3. Cycle Continuity: Even if my state did include an input field, replacing the current return statement with {"input": response} would break the intended cycle. The current design ensures that, after processing the user’s response, the cycle resumes at provide_cat_info. Changing this would disrupt that flow, and the execution would not continue as expected.

I appreciate your input, but based on these points, I believe that my current implementation correctly reflects the intended behavior.

[alex-feel]

@bracesproul,

I have a few clarifications regarding the interrupt schema you mentioned:

1. Reference to Agent Inbox: You referred to the schema from the Agent Inbox repository. Could you explain why you’re suggesting that? I’m using Agent Chat UI, which is designed to work with the standard LangGraph interrupt function. I don’t see how the Agent Inbox schema relates to my current setup.

2. Standard Schema vs. Agent Inbox: Is the schema you mentioned a standard requirement for LangGraph interrupts, or is it specific only to Agent Inbox? According to the documentation I’ve reviewed (e.g., human_in_the_loop and interrupt type reference), my initial implementation already conforms to the expected usage.

3. Behavioral Inconsistency: My code works exactly the same before and after applying the suggested schema. The interrupt from the get_user_feedback function displays correctly, but the one from handle_off_topic never shows up in Agent Chat UI. This inconsistency is puzzling.

4. Unexpected UI Elements: When experimenting with the proposed schema, I encountered a strange form that includes a "Mark as Resolved" button and a separate input field for user responses. I’m aiming to use the existing chat input field exclusively; having two different input mechanisms degrades the UX.

5. Clarification on Requirements: It seems there might be some confusion here. I don’t need the Agent Inbox or its specialized schema — I need the standard interrupt functionality as described in the LangGraph documentation. Agent Chat UI is advertised as a Vite + React application that enables chatting with any LangGraph server using the messages key, so I would expect the standard interrupt to work out of the box.

6. Everything Works in LangGraph Studio: All functionality works correctly in LangGraph Studio with my initial code — absolutely everything works as expected. This further indicates that the issue is not with my interrupt implementation but likely lies within the Agent Chat UI itself.

Based on these points, it appears that the cause of the problem is within the Agent Chat UI code, which seems to be a bug.

Could you please help clarify these points? I appreciate your insights and any further guidance you can provide.

[VMinB12]

@alex-feel Could you try replacing

  response = interrupt(request)[0]

with

  response = interrupt([request])[0]

In fact, the documentation always provides a list[HumanInterrupt] to the interrupt method.

[alex-feel]

@VMinB12, thanks for trying to help, but my initial version of the code does not contain the following line:

response = interrupt(request)[0]

My version follows the documentation (please see the first post).

[bracesproul]

@alex-feel

Reference to Agent Inbox: You referred to the schema from the Agent Inbox repository. Could you explain why you’re suggesting that? I’m using Agent Chat UI, which is designed to work with the standard LangGraph interrupt function. I don’t see how the Agent Inbox schema relates to my current setup.

As of right now, we only render interrupts when the value of the interrupt matches a specific schema. This is the schema from the Agent Inbox project, because it reuses the same UI to render the interrupt from the Agent Inbox project. I am working on rendering raw JSON with the contents of the interrupt when the schema does not match the HumanInterrupt (py, js) object, but that will not be out for a day or two.

Standard Schema vs. Agent Inbox: Is the schema you mentioned a standard requirement for LangGraph interrupts, or is it specific only to Agent Inbox? According to the documentation I’ve reviewed (e.g., [human_in_the_loop](https://langchain-ai.github.io/langgraph/concepts/human_in_the_loop/#interrupt) and [interrupt type reference](https://langchain-ai.github.io/langgraph/reference/types/#langgraph.types.interrupt)), my https://github.com/langchain-ai/agent-chat-ui/issues/85#issue-2959060384 already conforms to the expected usage.

This schema is specific to the UI we render for interrupts. When using interrupts in LangGraph, you can pass any object to the interrupt function, but in order for us to render a UI which allows you to interact with the interrupt (e.g resume the graph), we must have a standardized schema.

Behavioral Inconsistency: My code works exactly the same before and after applying the suggested schema. The interrupt from the get_user_feedback function displays correctly, but the one from handle_off_topic never shows up in Agent Chat UI. This inconsistency is puzzling.

After inspecting your traces, I believe this PR should resolve your issue, since the trace where handle_off_topic was called did not have any AI/tool messages in the state beforehand, and thus the interrupt had no way of being rendered.

Unexpected UI Elements: When experimenting with the proposed schema, I encountered a strange form that includes a "Mark as Resolved" button and a separate input field for user responses. I’m aiming to use the existing chat input field exclusively; having two different input mechanisms degrades the UX.

This is a UI/UX decision we made when implementing the Agent Inbox, where we found it useful to have the allowed actions defined in the HumanInterrupt config schema, but also to include a Mark as Resolved which did not resume the interrupt, but instead updated the graph to the __end__ node, which cleanly ended it without erroring, or resuming with an ignore action. This can be easily removed if you have the code cloned though!

Clarification on Requirements: It seems there might be some confusion here. I don’t need the Agent Inbox or its specialized schema — I need the standard interrupt functionality as described in the LangGraph documentation. Agent Chat UI is advertised as a Vite + React application that enables chatting with any LangGraph server using the messages key, so I would expect the standard interrupt to work out of the box.

Interrupts will be rendered as raw json after I finish making that change, but without using the Agent Inbox HumanInterrupt schema, the raw rendering of interrupts will not be very useful as you will either:

1. not have a way to resume the interrupt, because I won't know what values/schema to resume with.
2. I'll have to make a decision on how resuming works, e.g any text sent in the message box after an interrupt will be passed to the resume field, but this could have some downsides since it's an opinionated way of resuming interrupts.

Everything Works in LangGraph Studio: All functionality works correctly in LangGraph Studio with my initial code — absolutely everything works as expected. This further indicates that the issue is not with my interrupt implementation but likely lies within the Agent Chat UI itself.

Correct, there was a bug with rendering interrupts when there were no AI/tool messages present in the state.

---

I hope these answers help, and please tag me if you run into more issues!