@langchain/langgraph-sdk 1.9.29 → 1.9.30

package/dist/stream/controller.cjs

@@ -170,6 +170,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
@@ -392,13 +400,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 +420,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) => ({
@@ -1236,6 +1248,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 +1268,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();
@@ -1269,6 +1289,13 @@ var StreamController = class {
 		this.#messageMetadata.reset();
 		this.#hydratedActiveInterruptIds = null;
 		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 +1319,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 +1378,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 +1399,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 +1433,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();
 				}