Human-in-the-Loop Functionality: How to Pause Threads Mid-Run for Input?

[MePriyanshuHoo]

Issue with current functionality:
I couldn’t find a clear way in the API to pause a thread’s run midway, wait for user input, and then resume. This is problematic for workflows that require human intervention during execution, as there doesn’t seem to be a mechanism to handle this scenario.

For example:

• Endpoints like /threads/{thread_id}/runs/wait are designed to wait for final output but don’t seem to support pausing mid-run for input.
• /threads/{thread_id}/runs/stream streams output in real-time, but I’m not sure if it allows for dynamic input injection while the run is active.

Idea or request:
It would be helpful to have:

1. A way to pause a run at a specific stage, hold its state, and await input.
2. Documentation or examples showing how to provide input dynamically during a run.

[markokraemer]

Human in the Loop is achieved through tool call involving the human with the Thread Run. Or after the Thread Run has completed, user could add a message to the Thread. Which then can be run again.

[lakshyaag12]

Does this indicate that for HITL in one thread, we can make more than 1 run? Or should we continue with the same run in the same thread?

[hinthornw]

It's multiple runs for the same thread. When you interrupt, the state is checkpointed, so when you resume the thread, the logic can continue

[lakshyaag12]

Thanks William FH (@hinthornw)!

[brisacoder]

Hello,

I'm highly interested in this topic. After discussing with Nuno Campos (@nfcampos) and following his guidance, I've implemented Human-in-the-Loop (HITL) functionality across agentic frameworks as described below. I'd appreciate your feedback.

Scenario

User (Chat Interface) <===> Agent/App A (Langgraph) <===== Network =====> Agent/App B (Autogen)

Implementation

To effectively manage Human-in-the-Loop interactions, my approach incorporates these key components:

1. Event Propagation:

   • When Agent B (Autogen) encounters a scenario requiring human intervention (HITL event), the event must propagate back to Agent A via the network.

2. Event Translation:

   • The Autogen-generated interrupt is converted into a Server-Sent Event (SSE), ensuring standardized communication back to Agent A.

3. Network Transmission:

   • Agent A receives and processes the SSE, pausing the active thread and displaying the required human intervention directly in the user's chat interface.

4. Human Interaction and Resumption:

   • The user's response is captured via the chat interface, after which the paused thread resumes execution.

Summary:

The implementation involves 2 agents (Langgraph and Autogen), 2 interrupts, and 2 suspended threads. Human intervention events from Autogen trigger interrupts converted into SSE events, propagated via the network to Langgraph. Both agent threads pause awaiting user input and resume execution upon receiving it.