@langchain/langgraph-sdk 1.9.29 → 1.9.31

package/dist/stream/controller.cjs

@@ -155,12 +155,25 @@ var StreamController = class {
 	* SSE replay re-adds historically-requested interrupts that have
 	* since been resolved (no `input.responded` event exists in the
 	* protocol, so the SDK has no other way to tell replay from live
-	* for an idle thread). `null` outside the hydrate-window so
-	* genuinely new live interrupts on an active run aren't filtered;
-	* cleared at the start of `submit()` for the same reason.
+	* for an idle thread). After a command is accepted, events newer
+	* than {@link #interruptReplayThroughSeq} bypass the allowlist.
 	*/
 	#hydratedActiveInterruptIds = null;
 	/**
+	* 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 interrupt events received between local command dispatch and its
+	* response. The response supplies the sequence barrier needed to classify
+	* each event as historical replay or live output from the new run.
+	*/
+	#pendingInterruptEvents = [];
+	#interruptCommandPending = false;
+	/**
 	* Monotonic counter bumped at the start of each `submit()` and used
 	* by {@link hydrate} to skip its post-fetch allowlist write when a
 	* submit started while the state fetch was in flight. Without this
@@ -170,6 +183,14 @@ var StreamController = class {
 	*/
 	#submitGeneration = 0;
 	/**
+	* Monotonic counter bumped at the start of each `#teardownThread`.
+	* The root pump captures the generation when it starts and drops
+	* any event whose generation no longer matches — including queued
+	* events that `SubscriptionHandle.close()` still drains after the
+	* snapshot has already been cleared by `hydrate()`.
+	*/
+	#rootPumpGeneration = 0;
+	/**
 	* Thread ids this controller minted client-side on first `submit()`.
 	* `hydrate()` skips `threads.getState()` for these — we know there
 	* is nothing checkpointed yet. Cleared once dispatch commits the
@@ -294,13 +315,20 @@ var StreamController = class {
 			awaitNextTerminal: (signal) => this.#awaitNextTerminal(signal),
 			awaitResumedRunTerminal: (signal) => this.#awaitResumedRunTerminal(signal),
 			onSubmitStart: () => {
-				this.#hydratedActiveInterruptIds = null;
 				this.#submitGeneration += 1;
+				this.#interruptCommandPending = this.#hydratedActiveInterruptIds != null;
+				this.#pendingInterruptEvents = [];
 			},
 			onRunStart: () => this.#markLocalRunStart(),
-			onRunCreated: (runId) => this.#notifyCreated(runId),
+			onRunCreated: (runId) => {
+				this.#advanceInterruptReplayBarrier();
+				this.#notifyCreated(runId);
+			},
 			onRunCompleted: (reason, runId) => this.#notifyCompleted(reason, runId),
-			onRunEnd: () => this.#markLocalRunEnd(),
+			onRunEnd: () => {
+				this.#interruptCommandPending = false;
+				this.#markLocalRunEnd();
+			},
 			beginOptimistic: (input) => this.#beginOptimistic(input),
 			settleOptimistic: (handle, event) => this.#settleOptimistic(handle, event)
 		});
@@ -392,13 +420,16 @@ var StreamController = class {
 			* Suspense boundary remounted against the new id suspends again.
 			*/
 			this.#resetHydrationPromise();
-			await this.#teardownThread();
 			/**
-			* Reset UI-facing snapshot so stale messages/values/tool-calls
-			* from the previous thread don't bleed into the new one. The
-			* new thread's state (if any) is then populated below via
-			* `#applyValues`.
+			* Kick teardown so the synchronous abort (unbind, drop onEvent,
+			* close the root subscription, reset assemblers) runs before we
+			* touch the snapshot. Then reset immediately so the UI does not
+			* wait on pump/close. An interrupted thread parks the root pump
+			* on `waitForResume()`; awaiting teardown *before* this reset
+			* left `threadId` null while `messages` still showed the previous
+			* conversation (`useStream` fire-and-forgets `hydrate()`).
 			*/
+			const teardown = this.#teardownThread();
 			this.rootStore.setState(() => ({
 				...this.#createInitialSnapshot(),
 				threadId: this.#currentThreadId
@@ -409,6 +440,7 @@ var StreamController = class {
 			* surprising. Mirrors the legacy `StreamOrchestrator` behaviour.
 			*/
 			this.queueStore.setState(() => require_submit_coordinator.EMPTY_QUEUE);
+			await teardown;
 		}
 		if (this.#currentThreadId == null) {
 			this.rootStore.setState((s) => ({
@@ -550,7 +582,10 @@ var StreamController = class {
 					interrupts: activeInterrupts,
 					interrupt: activeInterrupts[0]
 				}));
-				if (this.#submitGeneration === generationAtFetch) this.#hydratedActiveInterruptIds = activeIds;
+				if (this.#submitGeneration === generationAtFetch) {
+					this.#hydratedActiveInterruptIds = activeIds;
+					this.#interruptReplayThroughSeq = void 0;
+				}
 			}
 		} catch (error) {
 			if (error?.status !== 404) {
@@ -997,9 +1032,11 @@ var StreamController = class {
 					config: options?.config,
 					metadata: options?.metadata
 				});
+				this.#advanceInterruptReplayBarrier();
 				this.#markInterruptResolvedInRootStore(resolved.interruptId);
 			}, prepared?.handle);
 		} catch (error) {
+			this.#discardPendingInterruptEvents();
 			if (this.#disposed && isAbortLikeError(error)) return;
 			throw error;
 		}
@@ -1066,9 +1103,11 @@ var StreamController = class {
 					config: options?.config,
 					metadata: options?.metadata
 				});
+				this.#advanceInterruptReplayBarrier();
 				for (const { interrupt_id: interruptId } of responses) this.#markInterruptResolvedInRootStore(interruptId);
 			}, prepared?.handle);
 		} catch (error) {
+			this.#discardPendingInterruptEvents();
 			if (this.#disposed && isAbortLikeError(error)) return;
 			throw error;
 		}
@@ -1236,6 +1275,14 @@ var StreamController = class {
 	* Close the current thread stream and reset per-thread assembly state.
 	*/
 	async #teardownThread() {
+		/**
+		* Invalidate the in-flight root pump before `close()` unparks it.
+		* `SubscriptionHandle.close()` leaves queued events intact and the
+		* iterator drains them before observing `closed`, so without this
+		* bump a parked interrupted pump would still dispatch stale
+		* `values` / `messages` into a snapshot `hydrate()` already cleared.
+		*/
+		this.#rootPumpGeneration += 1;
 		const thread = this.#thread;
 		this.#thread = void 0;
 		this.registry.bind(void 0);
@@ -1248,16 +1295,16 @@ var StreamController = class {
 		*/
 		this.#rootEventListeners.delete(this.#lifecycleLoading.listener);
 		this.#rootEventListeners.delete(this.#runLifecycleListener);
-		try {
-			await this.#rootSubscription?.unsubscribe();
-		} catch {}
+		/**
+		* Close first so a pump parked on `waitForResume()` (interrupted
+		* run) unparks even if the unsubscribe RPC is slow. `close()` is
+		* idempotent; `unsubscribe()` is then a no-op once closed.
+		*/
+		const subscription = this.#rootSubscription;
 		this.#rootSubscription = void 0;
+		subscription?.close();
 		this.#rootPumpReady = void 0;
 		this.#rootPumpDeferred = false;
-		try {
-			await this.#rootPump;
-		} catch {}
-		this.#rootPump = void 0;
 		this.#rootMessages.reset();
 		this.#rootToolAssembler = new require_tools.ToolCallAssembler();
 		this.#lifecycleLoading.reset();
@@ -1268,7 +1315,16 @@ var StreamController = class {
 		this.#localRunDepth = 0;
 		this.#messageMetadata.reset();
 		this.#hydratedActiveInterruptIds = null;
+		this.#interruptReplayThroughSeq = void 0;
+		this.#discardPendingInterruptEvents();
 		this.queueStore.setState(() => require_submit_coordinator.EMPTY_QUEUE);
+		try {
+			await subscription?.unsubscribe();
+		} catch {}
+		try {
+			await this.#rootPump;
+		} catch {}
+		this.#rootPump = void 0;
 		if (thread != null) {
 			try {
 				await thread.close();
@@ -1292,6 +1348,7 @@ var StreamController = class {
 	*/
 	#startRootPump(thread) {
 		if (this.#rootPump != null) return;
+		const pumpGeneration = this.#rootPumpGeneration;
 		let resolveReady;
 		this.#rootPumpReady = new Promise((resolve) => {
 			resolveReady = resolve;
@@ -1350,6 +1407,14 @@ var StreamController = class {
 					resolveReady = void 0;
 				});
 				const subscription = await subscriptionPromise;
+				if (pumpGeneration !== this.#rootPumpGeneration) {
+					resolveReady?.();
+					resolveReady = void 0;
+					try {
+						subscription.close();
+					} catch {}
+					return;
+				}
 				resolveReady?.();
 				resolveReady = void 0;
 				this.#rootSubscription = subscription;
@@ -1363,9 +1428,9 @@ var StreamController = class {
 				* for every resumed iteration until the subscription is
 				* permanently closed or the controller is disposed.
 				*/
-				while (!this.#disposed) {
+				while (!this.#disposed && pumpGeneration === this.#rootPumpGeneration) {
 					for await (const event of subscription) {
-						if (this.#disposed) break;
+						if (this.#disposed || pumpGeneration !== this.#rootPumpGeneration) break;
 						/**
 						* Resilience: isolate per-event dispatch from the pump loop.
 						*
@@ -1397,7 +1462,7 @@ var StreamController = class {
 							this.#onRootEvent(event);
 						} catch {}
 					}
-					if (this.#disposed) break;
+					if (this.#disposed || pumpGeneration !== this.#rootPumpGeneration) break;
 					if (!subscription.isPaused) break;
 					await subscription.waitForResume();
 				}
@@ -1665,7 +1730,13 @@ var StreamController = class {
 		const data = event.params.data;
 		const interruptId = data?.interrupt_id;
 		if (typeof interruptId !== "string" || this.#resolvedInterrupts.has(interruptId)) return;
-		if (this.#hydratedActiveInterruptIds != null && !this.#hydratedActiveInterruptIds.has(interruptId)) return;
+		const eventSeq = typeof event.seq === "number" ? event.seq : void 0;
+		const isUnknownInterrupt = this.#hydratedActiveInterruptIds != null && !this.#hydratedActiveInterruptIds.has(interruptId);
+		if (isUnknownInterrupt && this.#interruptCommandPending) {
+			this.#pendingInterruptEvents.push(event);
+			return;
+		}
+		if (isUnknownInterrupt && (this.#interruptReplayThroughSeq == null || eventSeq != null && eventSeq <= this.#interruptReplayThroughSeq)) return;
 		const namespace = Array.isArray(event.params.namespace) ? [...event.params.namespace] : [...ROOT_NAMESPACE];
 		const interrupt = require_interrupts.normalizeInterruptForClient({
 			id: interruptId,
@@ -1683,6 +1754,31 @@ var StreamController = class {
 		});
 	}
 	/**
+	* Convert the hydrate-time allowlist into a replay barrier after a command
+	* is accepted. Built-in transports update `lastAppliedThroughSeq` from the
+	* command response before resolving `submitRun` / `respondInput`.
+	*/
+	#advanceInterruptReplayBarrier() {
+		if (this.#hydratedActiveInterruptIds == null) {
+			this.#discardPendingInterruptEvents();
+			return;
+		}
+		const throughSeq = this.#thread?.ordering?.lastAppliedThroughSeq;
+		if (typeof throughSeq === "number") this.#interruptReplayThroughSeq = throughSeq;
+		else {
+			this.#hydratedActiveInterruptIds = null;
+			this.#interruptReplayThroughSeq = void 0;
+		}
+		this.#interruptCommandPending = false;
+		const pendingEvents = this.#pendingInterruptEvents;
+		this.#pendingInterruptEvents = [];
+		for (const event of pendingEvents) this.#recordInterrupt(event);
+	}
+	#discardPendingInterruptEvents() {
+		this.#interruptCommandPending = false;
+		this.#pendingInterruptEvents = [];
+	}
+	/**
 	* Resolve the protocol namespace for a targeted resume.
 	*
 	* Prefer an explicit caller-supplied namespace, then the matching