@langchain/langgraph-sdk 1.10.3-rc.1 → 1.11.0

package/dist/stream/controller.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"controller.d.cts","names":[],"sources":["../../src/stream/controller.ts"],"mappings":";;;;;;;;;;;;;;AA6KA;;cAAa,kBAAA,WAA6B,OAAA;;AAkC1C;;;;;;;;;;;;cAAa,gBAAA,4BACgB,MAAA,8EAEO,MAAA;EAAA;WAEzB,SAAA,EAAW,WAAA,CAAY,YAAA,CAAa,SAAA,EAAW,aAAA;EAAA,SAC/C,aAAA,EAAe,WAAA,CAAY,WAAA;EAAA,SAC3B,aAAA,EAAe,WAAA,CAAY,WAAA;EAAA,SAC3B,mBAAA,EAAqB,WAAA,CAAY,iBAAA;EAAA,SACjC,oBAAA,EAAsB,WAAA,CAAY,kBAAA;EAAA,SAClC,UAAA,EAAY,WAAA,CAAY,uBAAA,CAAwB,SAAA;EAAA,SAChD,QAAA,EAAU,eAAA;EAiK0B;;;;;EAA7C,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EAoyBF;;;;;;;EAAA,IAxqBvC,gBAAA,CAAA,GAAoB,OAAA;EA60BS;;;;;;;;EApxB3B,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EAsgCpB;;;;;;;;;;;;;;EA7pBf,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EApsB5B;;;;;;;;EAw8BlB,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EAx8B4B;;;;;;EAk9BzB,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EAh9BtB;;;;EAo+Bb,UAAA,CAAA,GAAc,OAAA;EAvsBhB;;;;;;;;;;;EAuwBE,YAAA,CAAa,EAAA,WAAa,OAAA;EA/FW;;;EAsGrC,UAAA,CAAA,GAAc,OAAA;EA3FC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwJf,OAAA,CACJ,QAAA,WACA,OAAA,GAAU,oBAAA,CAAqB,gBAAA,IAC9B,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiHG,UAAA,CACJ,aAAA,EAAe,MAAA,mBACf,OAAA,GAAU,uBAAA,CAAwB,gBAAA,IACjC,OAAA;;;;EA4DG,OAAA,CAAA,GAAW,OAAA;;;;;;;;;;;;;;;;EAyBjB,QAAA,CAAA;;;;;;EA4BA,SAAA,CAAA,GAAa,YAAA;;;;;;;;EAWb,eAAA,CACE,QAAA,GAAW,MAAA,EAAQ,YAAA;AAAA"}
+{"version":3,"file":"controller.d.cts","names":[],"sources":["../../src/stream/controller.ts"],"mappings":";;;;;;;;;;;;;;AA6KA;;cAAa,kBAAA,WAA6B,OAAA;;AAwC1C;;;;;;;;;;;;cAAa,gBAAA,4BACgB,MAAA,8EAEO,MAAA;EAAA;WAEzB,SAAA,EAAW,WAAA,CAAY,YAAA,CAAa,SAAA,EAAW,aAAA;EAAA,SAC/C,aAAA,EAAe,WAAA,CAAY,WAAA;EAAA,SAC3B,aAAA,EAAe,WAAA,CAAY,WAAA;EAAA,SAC3B,mBAAA,EAAqB,WAAA,CAAY,iBAAA;EAAA,SACjC,oBAAA,EAAsB,WAAA,CAAY,kBAAA;EAAA,SAClC,UAAA,EAAY,WAAA,CAAY,uBAAA,CAAwB,SAAA;EAAA,SAChD,QAAA,EAAU,eAAA;EAiK0B;;;;;EAA7C,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EAiyBF;;;;;;;EAAA,IAtqBvC,gBAAA,CAAA,GAAoB,OAAA;EA20BS;;;;;;;;EAlxB3B,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EAogCpB;;;;;;;;;;;;;;EA7pBf,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EAjsB5B;;;;;;;;EAq8BlB,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EAr8B4B;;;;;;EA+8BzB,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EA78BtB;;;;EAi+Bb,UAAA,CAAA,GAAc,OAAA;EArsBhB;;;;;;;;;;;EAqwBE,YAAA,CAAa,EAAA,WAAa,OAAA;EA/FW;;;EAsGrC,UAAA,CAAA,GAAc,OAAA;EA3FC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwJf,OAAA,CACJ,QAAA,WACA,OAAA,GAAU,oBAAA,CAAqB,gBAAA,IAC9B,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiHG,UAAA,CACJ,aAAA,EAAe,MAAA,mBACf,OAAA,GAAU,uBAAA,CAAwB,gBAAA,IACjC,OAAA;;;;EA4DG,OAAA,CAAA,GAAW,OAAA;;;;;;;;;;;;;;;;EAyBjB,QAAA,CAAA;;;;;;EA4BA,SAAA,CAAA,GAAa,YAAA;;;;;;;;EAWb,eAAA,CACE,QAAA,GAAW,MAAA,EAAQ,YAAA;AAAA"}

package/dist/stream/controller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"controller.d.ts","names":[],"sources":["../../src/stream/controller.ts"],"mappings":";;;;;;;;;;;;;;;AA6KA;cAAa,kBAAA,WAA6B,OAAA;;;AAkC1C;;;;;;;;;;;cAAa,gBAAA,4BACgB,MAAA,8EAEO,MAAA;EAAA;WAEzB,SAAA,EAAW,WAAA,CAAY,YAAA,CAAa,SAAA,EAAW,aAAA;EAAA,SAC/C,aAAA,EAAe,WAAA,CAAY,WAAA;EAAA,SAC3B,aAAA,EAAe,WAAA,CAAY,WAAA;EAAA,SAC3B,mBAAA,EAAqB,WAAA,CAAY,iBAAA;EAAA,SACjC,oBAAA,EAAsB,WAAA,CAAY,kBAAA;EAAA,SAClC,UAAA,EAAY,WAAA,CAAY,uBAAA,CAAwB,SAAA;EAAA,SAChD,QAAA,EAAU,eAAA;EAAA;;;;;EAiKnB,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EAoyBb;;;;;;;EAAA,IAxqB5B,gBAAA,CAAA,GAAoB,OAAA;EA8wBJ;;;;;;;;EArtBd,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EA0/B5B;;;;;;;;;;;;;;EAjpBP,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EApsB3C;;;;;;;;EAw8BH,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EAx8BM;;;;;;EAk9BH,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EAh9BhC;;;;EAo+BH,UAAA,CAAA,GAAc,OAAA;EAn0BR;;;;;;;;;;;EAm4BN,YAAA,CAAa,EAAA,WAAa,OAAA;EA/FA;;;EAsG1B,UAAA,CAAA,GAAc,OAAA;EA3Fd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwJA,OAAA,CACJ,QAAA,WACA,OAAA,GAAU,oBAAA,CAAqB,gBAAA,IAC9B,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiHG,UAAA,CACJ,aAAA,EAAe,MAAA,mBACf,OAAA,GAAU,uBAAA,CAAwB,gBAAA,IACjC,OAAA;;;;EA4DG,OAAA,CAAA,GAAW,OAAA;;;;;;;;;;;;;;;;EAyBjB,QAAA,CAAA;;;;;;EA4BA,SAAA,CAAA,GAAa,YAAA;;;;;;;;EAWb,eAAA,CACE,QAAA,GAAW,MAAA,EAAQ,YAAA;AAAA"}
+{"version":3,"file":"controller.d.ts","names":[],"sources":["../../src/stream/controller.ts"],"mappings":";;;;;;;;;;;;;;;AA6KA;cAAa,kBAAA,WAA6B,OAAA;;;AAwC1C;;;;;;;;;;;cAAa,gBAAA,4BACgB,MAAA,8EAEO,MAAA;EAAA;WAEzB,SAAA,EAAW,WAAA,CAAY,YAAA,CAAa,SAAA,EAAW,aAAA;EAAA,SAC/C,aAAA,EAAe,WAAA,CAAY,WAAA;EAAA,SAC3B,aAAA,EAAe,WAAA,CAAY,WAAA;EAAA,SAC3B,mBAAA,EAAqB,WAAA,CAAY,iBAAA;EAAA,SACjC,oBAAA,EAAsB,WAAA,CAAY,kBAAA;EAAA,SAClC,UAAA,EAAY,WAAA,CAAY,uBAAA,CAAwB,SAAA;EAAA,SAChD,QAAA,EAAU,eAAA;EAAA;;;;;EAiKnB,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EAiyBb;;;;;;;EAAA,IAtqB5B,gBAAA,CAAA,GAAoB,OAAA;EA4wBJ;;;;;;;;EAntBd,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EAw/B5B;;;;;;;;;;;;;;EAjpBP,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EAjsB3C;;;;;;;;EAq8BH,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EAr8BM;;;;;;EA+8BH,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EA78BhC;;;;EAi+BH,UAAA,CAAA,GAAc,OAAA;EAh0BR;;;;;;;;;;;EAg4BN,YAAA,CAAa,EAAA,WAAa,OAAA;EA/FA;;;EAsG1B,UAAA,CAAA,GAAc,OAAA;EA3Fd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwJA,OAAA,CACJ,QAAA,WACA,OAAA,GAAU,oBAAA,CAAqB,gBAAA,IAC9B,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiHG,UAAA,CACJ,aAAA,EAAe,MAAA,mBACf,OAAA,GAAU,uBAAA,CAAwB,gBAAA,IACjC,OAAA;;;;EA4DG,OAAA,CAAA,GAAW,OAAA;;;;;;;;;;;;;;;;EAyBjB,QAAA,CAAA;;;;;;EA4BA,SAAA,CAAA,GAAa,YAAA;;;;;;;;EAWb,eAAA,CACE,QAAA,GAAW,MAAA,EAAQ,YAAA;AAAA"}

package/dist/stream/controller.js

@@ -104,6 +104,8 @@ const ROOT_PUMP_CHANNELS = [
 	"messages",
 	"tools"
 ];
+const PARKED_INTERRUPT_SETTLE_MS = 5e3;
+const PARKED_INTERRUPT_SETTLE_POLL_MS = 500;
 /**
 * Coordinates one thread's protocol-v2 stream and exposes stable
 * observable projections for framework bindings.
@@ -142,6 +144,7 @@ var StreamController = class {
 	*/
 	#rootPumpDeferred = false;
 	#threadEventUnsubscribe;
+	#threadErrorUnsubscribe;
 	#disposed = false;
 	#pendingDisposeTimer = null;
 	/**
@@ -166,17 +169,16 @@ var StreamController = class {
 	* than {@link #interruptReplayThroughSeq} bypass the allowlist.
 	*/
 	#hydratedActiveInterruptIds = null;
-	/** Checkpoint whose replay establishes the hydrate-time interrupt cutoff. */
-	#hydratedInterruptCheckpointId;
 	/**
-	* Highest event sequence represented by hydration or already applied when
-	* the latest run command was accepted. Interrupts outside the hydrate-time
-	* allowlist remain filtered through this sequence, while newer events are
-	* live output and must be accepted.
+	* Highest event sequence already applied when the latest run command
+	* was accepted. Interrupts outside the hydrate-time allowlist remain
+	* filtered through this sequence, while newer events are live output
+	* from the newly-started run and must be accepted.
 	*/
 	#interruptReplayThroughSeq;
-	/** Unknown inputs waiting for replay to reach the hydrated checkpoint. */
+	/** Unknown inputs waiting to be classified as live or replayed history. */
 	#pendingHydrationInterruptEvents = [];
+	#settleParkedInterruptsPromise;
 	/**
 	* Unknown interrupt events received between local command dispatch and its
 	* response. The response supplies the sequence barrier needed to classify
@@ -330,7 +332,6 @@ var StreamController = class {
 				this.#interruptCommandPending = this.#hydratedActiveInterruptIds != null;
 				this.#pendingInterruptEvents = this.#pendingHydrationInterruptEvents;
 				this.#pendingHydrationInterruptEvents = [];
-				this.#hydratedInterruptCheckpointId = void 0;
 			},
 			onRunStart: () => this.#markLocalRunStart(),
 			onRunCreated: (runId) => {
@@ -581,7 +582,6 @@ var StreamController = class {
 				}));
 				if (this.#submitGeneration === generationAtFetch) {
 					this.#hydratedActiveInterruptIds = activeIds;
-					this.#hydratedInterruptCheckpointId = state.checkpoint?.checkpoint_id ?? void 0;
 					this.#interruptReplayThroughSeq = void 0;
 				}
 			}
@@ -1217,7 +1217,10 @@ var StreamController = class {
 	*   still required.
 	*/
 	#ensureThread(threadId, deferRootPump = false) {
-		if (this.#thread != null) return this.#thread;
+		if (this.#thread != null) {
+			if (!deferRootPump && !this.#rootPumpDeferred && this.#rootPump == null) this.#startRootPump(this.#thread);
+			return this.#thread;
+		}
 		this.#thread = this.#options.client.threads.stream(threadId, {
 			assistantId: this.#options.assistantId,
 			transport: this.#options.transport,
@@ -1226,7 +1229,8 @@ var StreamController = class {
 			maxReconnectAttempts: this.#options.maxReconnectAttempts,
 			streamIdleReconnect: this.#options.streamIdleReconnect,
 			reconnectDelayMs: this.#options.reconnectDelayMs,
-			onReconnect: this.#options.onReconnect
+			onReconnect: this.#options.onReconnect,
+			onConnected: this.#options.onConnected
 		});
 		this.registry.bind(this.#thread);
 		if (deferRootPump) {
@@ -1286,6 +1290,8 @@ var StreamController = class {
 		this.registry.bind(void 0);
 		this.#threadEventUnsubscribe?.();
 		this.#threadEventUnsubscribe = void 0;
+		this.#threadErrorUnsubscribe?.();
+		this.#threadErrorUnsubscribe = void 0;
 		/**
 		* Persistent lifecycle driver is scoped to the current thread
 		* stream. Remove it so a swap to a new thread starts with a clean
@@ -1313,7 +1319,6 @@ var StreamController = class {
 		this.#localRunDepth = 0;
 		this.#messageMetadata.reset();
 		this.#hydratedActiveInterruptIds = null;
-		this.#hydratedInterruptCheckpointId = void 0;
 		this.#interruptReplayThroughSeq = void 0;
 		this.#pendingHydrationInterruptEvents = [];
 		this.#discardPendingInterruptEvents();
@@ -1362,6 +1367,14 @@ var StreamController = class {
 		* pump's narrow filter.
 		*/
 		this.#threadEventUnsubscribe = thread.onEvent((event) => this.#onWildcardEvent(event));
+		this.#threadErrorUnsubscribe = thread.onError((error) => {
+			this.rootStore.setState((s) => ({
+				...s,
+				error,
+				isLoading: false
+			}));
+			this.#rootSubscription?.close();
+		});
 		/**
 		* Persistent isLoading driver. Drives `isLoading` from
 		* root-namespace lifecycle events so that in-flight runs observed
@@ -1372,7 +1385,7 @@ var StreamController = class {
 		*/
 		this.#rootEventListeners.add(this.#lifecycleLoading.listener);
 		this.#rootEventListeners.add(this.#runLifecycleListener);
-		this.#rootPump = (async () => {
+		const pump = (async () => {
 			try {
 				/**
 				* Root content pump: depth 1 is required because the controller
@@ -1463,7 +1476,15 @@ var StreamController = class {
 						} catch {}
 					}
 					if (this.#disposed || pumpGeneration !== this.#rootPumpGeneration) break;
-					if (!subscription.isPaused) break;
+					if (!subscription.isPaused) {
+						const snapshot = this.rootStore.getSnapshot();
+						if (snapshot.isLoading && snapshot.error == null) this.rootStore.setState((s) => ({
+							...s,
+							error: /* @__PURE__ */ new Error("Thread event stream closed before the active run completed."),
+							isLoading: false
+						}));
+						break;
+					}
 					await subscription.waitForResume();
 				}
 			} catch {
@@ -1471,6 +1492,21 @@ var StreamController = class {
 				resolveReady = void 0;
 			}
 		})();
+		this.#rootPump = pump;
+		pump.finally(() => {
+			if (pumpGeneration !== this.#rootPumpGeneration) return;
+			if (this.#rootPump !== pump) return;
+			this.#rootPumpGeneration += 1;
+			this.#rootSubscription = void 0;
+			this.#rootPump = void 0;
+			this.#rootPumpReady = void 0;
+			this.#threadEventUnsubscribe?.();
+			this.#threadEventUnsubscribe = void 0;
+			this.#threadErrorUnsubscribe?.();
+			this.#threadErrorUnsubscribe = void 0;
+			this.#rootEventListeners.delete(this.#lifecycleLoading.listener);
+			this.#rootEventListeners.delete(this.#runLifecycleListener);
+		});
 	}
 	/**
 	* Handle an event delivered via {@link ThreadStream.onEvent}.
@@ -1491,7 +1527,6 @@ var StreamController = class {
 		} catch {}
 		this.#subgraphs.push(event);
 		this.#lifecycleLoading.handle(event);
-		this.#advanceInterruptReplayBarrierFromCheckpoint(event);
 		/**
 		* `input.requested` events (including HITL inside a subagent /
 		* subgraph) are not always observable via the narrow content pump.
@@ -1501,6 +1536,7 @@ var StreamController = class {
 		* resume targeting.
 		*/
 		this.#recordInterrupt(event);
+		this.#settleParkedInterruptsOnTerminal(event);
 	}
 	/**
 	* Process one root-pump event and update all root projections.
@@ -1741,11 +1777,12 @@ var StreamController = class {
 			this.#pendingInterruptEvents.push(event);
 			return;
 		}
-		if (isUnknownInterrupt && this.#interruptReplayThroughSeq == null && this.#hydratedInterruptCheckpointId != null) {
+		const barrier = this.#interruptReplayThroughSeq;
+		if (isUnknownInterrupt && barrier == null) {
 			this.#pendingHydrationInterruptEvents.push(event);
 			return;
 		}
-		if (isUnknownInterrupt && (this.#interruptReplayThroughSeq == null || eventSeq != null && eventSeq <= this.#interruptReplayThroughSeq)) return;
+		if (isUnknownInterrupt && barrier != null && eventSeq != null && eventSeq <= barrier) return;
 		const namespace = Array.isArray(event.params.namespace) ? [...event.params.namespace] : [...ROOT_NAMESPACE];
 		const interrupt = normalizeInterruptForClient({
 			id: interruptId,
@@ -1762,16 +1799,6 @@ var StreamController = class {
 			};
 		});
 	}
-	/** Establish the hydration cutoff when ordered replay reaches its checkpoint. */
-	#advanceInterruptReplayBarrierFromCheckpoint(event) {
-		if (event.method !== "checkpoints" || this.#hydratedInterruptCheckpointId == null || !isRootNamespace(event.params.namespace)) return;
-		if (event.params.data?.id !== this.#hydratedInterruptCheckpointId || typeof event.seq !== "number") return;
-		this.#interruptReplayThroughSeq = event.seq;
-		this.#hydratedInterruptCheckpointId = void 0;
-		const pendingEvents = this.#pendingHydrationInterruptEvents.sort((a, b) => (a.seq ?? 0) - (b.seq ?? 0));
-		this.#pendingHydrationInterruptEvents = [];
-		for (const pendingEvent of pendingEvents) this.#recordInterrupt(pendingEvent);
-	}
 	/**
 	* Convert the hydrate-time allowlist into a replay barrier after a command
 	* is accepted. Built-in transports update `lastAppliedThroughSeq` from the
@@ -1848,12 +1875,12 @@ var StreamController = class {
 	*/
 	async #reconcilePendingInterruptsFromServer() {
 		const threadId = this.#currentThreadId;
-		if (threadId == null || this.#disposed) return;
+		if (threadId == null || this.#disposed) return null;
 		const generationAtFetch = this.#submitGeneration;
 		try {
 			const state = await this.#fetchHydrationState();
-			if (this.#disposed || this.#currentThreadId !== threadId || this.#submitGeneration !== generationAtFetch) return;
-			if (!Array.isArray(state?.tasks)) return;
+			if (this.#disposed || this.#currentThreadId !== threadId || this.#submitGeneration !== generationAtFetch) return null;
+			if (!Array.isArray(state?.tasks)) return null;
 			const { activeInterrupts, activeIds } = collectActiveInterruptsFromTasks(state.tasks);
 			const pendingInterrupts = activeInterrupts.filter((interrupt) => interrupt.id == null || !this.#resolvedInterrupts.has(interrupt.id));
 			this.rootStore.setState((s) => ({
@@ -1862,7 +1889,55 @@ var StreamController = class {
 				interrupt: pendingInterrupts[0]
 			}));
 			this.#hydratedActiveInterruptIds = activeIds;
-		} catch {}
+			return state;
+		} catch {
+			return null;
+		}
+	}
+	#settleParkedInterruptsOnTerminal(event) {
+		if (this.#pendingHydrationInterruptEvents.length === 0) return;
+		if (event.method !== "lifecycle") return;
+		if (!isRootNamespace(event.params.namespace)) return;
+		const status = event.params.data?.event;
+		if (status !== "interrupted" && status !== "completed" && status !== "failed") return;
+		this.#settleParkedInterrupts();
+	}
+	/**
+	* Decide parked interrupts with server state instead of a stream marker.
+	*
+	* After a passive rejoin the stream cannot tell a replayed, already
+	* resolved `input.requested` from one the current run just raised: the
+	* SSE replays the thread buffer on connect with no marker for where the
+	* replay ends. `state.tasks[].interrupts` is authoritative: parked ids it
+	* lists are live, the rest are history.
+	*/
+	async #settleParkedInterrupts() {
+		const makePromise = async () => {
+			try {
+				const threadId = this.#currentThreadId;
+				const generation = this.#submitGeneration;
+				const deadline = Date.now() + PARKED_INTERRUPT_SETTLE_MS;
+				for (;;) {
+					if (this.#disposed || this.#currentThreadId !== threadId || this.#submitGeneration !== generation || this.#pendingHydrationInterruptEvents.length === 0) return;
+					const parkedIds = new Set(this.#pendingHydrationInterruptEvents.map((event) => event.params.data.interrupt_id));
+					const state = await this.#reconcilePendingInterruptsFromServer();
+					if (state != null) {
+						if ([...this.#hydratedActiveInterruptIds ?? []].some((id) => parkedIds.has(id)) || !isThreadStateActive(state)) {
+							this.#pendingHydrationInterruptEvents = [];
+							return;
+						}
+					}
+					if (Date.now() >= deadline) return;
+					await new Promise((resolve) => {
+						setTimeout(resolve, PARKED_INTERRUPT_SETTLE_POLL_MS);
+					});
+				}
+			} finally {
+				this.#settleParkedInterruptsPromise = void 0;
+			}
+		};
+		this.#settleParkedInterruptsPromise ??= makePromise();
+		return this.#settleParkedInterruptsPromise;
 	}
 	/**
 	* Resolve on the next root-namespace terminal lifecycle event
@@ -1908,6 +1983,7 @@ var StreamController = class {
 				settled = true;
 				unsubscribeRoot?.();
 				unsubscribeThread?.();
+				unsubscribeError?.();
 				signal.removeEventListener("abort", finishAborted);
 				resolve(result);
 			}
@@ -1933,6 +2009,10 @@ var StreamController = class {
 			};
 			const unsubscribeRoot = this.#rootBus.subscribe(onEvent);
 			const unsubscribeThread = this.#thread?.onEvent(onEvent);
+			const unsubscribeError = this.#thread?.onError((error) => finish({
+				event: "failed",
+				error: error.message
+			}));
 			if (signal.aborted) finishAborted();
 			else signal.addEventListener("abort", finishAborted, { once: true });
 		});