@langchain/langgraph-sdk 1.9.28 → 1.9.30

package/dist/client/stream/types.d.cts

@@ -180,10 +180,10 @@ interface ThreadModules {
  * Matches the in-process `InterruptPayload` type.
  *
  * {@link ThreadStream.interrupts} collects these entries in arrival order.
- * Use them (via {@link StreamController.getThread `getThread()`}) when
- * you need the protocol `namespace` tuple for
- * {@link StreamController.respond `respond()`} — for example subgraph
- * interrupts that are not mirrored on {@link RootSnapshot.interrupts}.
+ * The same pending interrupts (including nested namespaces) are also
+ * mirrored onto {@link RootSnapshot.interrupts} / framework
+ * `stream.interrupts` for UI rendering; `respond()` resolves `namespace`
+ * from either list when only `interruptId` is supplied.
  */
 interface InterruptPayload<TPayload = unknown> {
   interruptId: string;

package/dist/client/stream/types.d.ts

@@ -180,10 +180,10 @@ interface ThreadModules {
  * Matches the in-process `InterruptPayload` type.
  *
  * {@link ThreadStream.interrupts} collects these entries in arrival order.
- * Use them (via {@link StreamController.getThread `getThread()`}) when
- * you need the protocol `namespace` tuple for
- * {@link StreamController.respond `respond()`} — for example subgraph
- * interrupts that are not mirrored on {@link RootSnapshot.interrupts}.
+ * The same pending interrupts (including nested namespaces) are also
+ * mirrored onto {@link RootSnapshot.interrupts} / framework
+ * `stream.interrupts` for UI rendering; `respond()` resolves `namespace`
+ * from either list when only `interruptId` is supplied.
  */
 interface InterruptPayload<TPayload = unknown> {
   interruptId: string;

package/dist/schema.d.cts

@@ -128,6 +128,13 @@ interface Interrupt<TValue = unknown> {
    * The value of the interrupt.
    */
   value?: TValue;
+  /**
+   * Protocol namespace tuple for resume targeting (`[]` at root).
+   * Populated for nested subgraph / subagent interrupts so
+   * `respond({ interruptId })` can resume without a separate
+   * `getThread()?.interrupts` lookup.
+   */
+  namespace?: string[];
   /**
    * Will be deprecated in the future.
    * @deprecated Will be removed in the future.

package/dist/schema.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.cts","names":[],"sources":["../src/schema.ts"],"mappings":"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"}
+{"version":3,"file":"schema.d.cts","names":[],"sources":["../src/schema.ts"],"mappings":"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"}

package/dist/schema.d.ts

@@ -128,6 +128,13 @@ interface Interrupt<TValue = unknown> {
    * The value of the interrupt.
    */
   value?: TValue;
+  /**
+   * Protocol namespace tuple for resume targeting (`[]` at root).
+   * Populated for nested subgraph / subagent interrupts so
+   * `respond({ interruptId })` can resume without a separate
+   * `getThread()?.interrupts` lookup.
+   */
+  namespace?: string[];
   /**
    * Will be deprecated in the future.
    * @deprecated Will be removed in the future.

package/dist/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","names":[],"sources":["../src/schema.ts"],"mappings":"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"}
+{"version":3,"file":"schema.d.ts","names":[],"sources":["../src/schema.ts"],"mappings":"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"}

package/dist/stream/controller.cjs

@@ -170,13 +170,31 @@ var StreamController = class {
 	*/
 	#submitGeneration = 0;
 	/**
-	* Thread ids we minted client-side on first `submit()`. Keeping them
-	* here lets `hydrate()` skip the `threads.getState()` round-trip —
-	* we know there is nothing checkpointed server-side yet (and the
-	* request would 404 and surface a spurious error to the UI).
+	* 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
+	* thread server-side.
 	*/
 	#selfCreatedThreadIds = /* @__PURE__ */ new Set();
 	/**
+	* Caller-supplied thread ids that 404'd on hydrate. Unlike
+	* {@link #selfCreatedThreadIds}, these are revalidated on every
+	* hydrate: another client may create the same id between visits.
+	* While marked missing, `submit()` still defers the root SSE pump
+	* until `run.start` / `commands` commits the row — joining
+	* `/stream/events` beforehand leaves a dead subscription on
+	* langgraph_api's in-mem runtime.
+	*/
+	#missingThreadIds = /* @__PURE__ */ new Set();
+	/**
 	* In-flight per-subagent namespace resolutions, keyed by tool-call
 	* id. De-dupes concurrent {@link resolveSubagentNamespace} calls so
 	* re-renders / multiple consumers of the same subagent don't issue
@@ -271,12 +289,14 @@ var StreamController = class {
 			rememberSelfCreatedThreadId: (threadId) => {
 				this.#selfCreatedThreadIds.add(threadId);
 			},
+			isSelfCreatedThreadId: (threadId) => this.#selfCreatedThreadIds.has(threadId) || this.#missingThreadIds.has(threadId),
 			hydrate: (threadId) => this.hydrate(threadId),
 			ensureThread: (threadId, deferRootPump) => this.#ensureThread(threadId, deferRootPump),
 			startDeferredRootPump: () => this.#startDeferredRootPump(),
 			abandonDeferredRootPump: () => this.#abandonDeferredRootPump(),
 			forgetSelfCreatedThreadId: (threadId) => {
 				this.#selfCreatedThreadIds.delete(threadId);
+				this.#missingThreadIds.delete(threadId);
 			},
 			waitForRootPumpReady: () => this.#rootPumpReady,
 			awaitNextTerminal: (signal) => this.#awaitNextTerminal(signal),
@@ -380,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
@@ -397,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) => ({
@@ -427,12 +451,14 @@ var StreamController = class {
 		const hydratedThreadId = this.#currentThreadId;
 		let hydrationError;
 		let threadExists = false;
+		let threadMissing = false;
 		let threadActive = true;
 		try {
 			const state = await this.#fetchHydrationState();
 			if (this.#disposed || this.#currentThreadId !== hydratedThreadId) return;
 			threadExists = state != null;
 			threadActive = isThreadStateActive(state);
+			this.#missingThreadIds.delete(hydratedThreadId);
 			if (state?.values != null) {
 				/**
 				* `threads.getState()` returns the legacy `ThreadState` shape
@@ -517,6 +543,8 @@ var StreamController = class {
 				const activeIds = /* @__PURE__ */ new Set();
 				for (const task of state.tasks) {
 					if (!Array.isArray(task?.interrupts)) continue;
+					const checkpointNs = task?.checkpoint?.checkpoint_ns;
+					const namespace = typeof checkpointNs === "string" && checkpointNs.length > 0 ? checkpointNs.split("|").filter((segment) => segment.length > 0) : [...ROOT_NAMESPACE];
 					for (const interrupt of task.interrupts) {
 						const typed = interrupt;
 						const id = typed?.id;
@@ -524,7 +552,8 @@ var StreamController = class {
 						activeIds.add(id);
 						activeInterrupts.push(require_interrupts.normalizeInterruptForClient({
 							id,
-							value: typed?.value
+							value: typed?.value,
+							namespace: Array.isArray(typed?.namespace) ? [...typed.namespace] : namespace
 						}));
 					}
 				}
@@ -542,7 +571,7 @@ var StreamController = class {
 					...s,
 					error
 				}));
-			}
+			} else threadMissing = true;
 		} finally {
 			this.rootStore.setState((s) => ({
 				...s,
@@ -552,6 +581,20 @@ var StreamController = class {
 			else this.#resolveHydration();
 		}
 		/**
+		* Missing threads must not open `/stream/events`. The in-mem
+		* runtime accepts the join against a not-yet-created id but the
+		* subscription never attaches to the live channel — the first run
+		* then delivers 0 bytes until idle reconnect. Park the pump until
+		* `submit()`'s `run.start` creates the row (see
+		* {@link #startDeferredRootPump}). Tracked in `#missingThreadIds`
+		* (not `#selfCreatedThreadIds`) so a later hydrate revalidates —
+		* another client may create the same id between visits.
+		*/
+		if (threadMissing) {
+			this.#missingThreadIds.add(hydratedThreadId);
+			return;
+		}
+		/**
 		* Open the shared subscription on mount so in-flight server-side
 		* runs are observed even when no local `submit()` is active — BUT
 		* only when the thread is actually active (see
@@ -688,7 +731,7 @@ var StreamController = class {
 	*/
 	async #trySeedProjectionFromHistory(params) {
 		const threadId = this.#currentThreadId;
-		if (this.#disposed || threadId == null || params.namespace.length === 0 || !this.#rootPumpDeferred || this.#selfCreatedThreadIds.has(threadId)) return false;
+		if (this.#disposed || threadId == null || params.namespace.length === 0 || !this.#rootPumpDeferred || this.#selfCreatedThreadIds.has(threadId) || this.#missingThreadIds.has(threadId)) return false;
 		if (await this.#skipDefaultSubagentProjection(params.namespace, threadId)) return true;
 		if (this.#disposed || this.#currentThreadId !== threadId || !this.#rootPumpDeferred) return false;
 		const seed = await this.#getScopedHistorySeed(threadId, params.namespace);
@@ -896,14 +939,15 @@ var StreamController = class {
 	* oldest and picks the first entry whose `interruptId` has not already
 	* been resolved by a prior `respond()` call. That entry may be at the
 	* root (`namespace: []`) or inside a subgraph (non-empty `namespace`).
-	* This is **not** the same as {@link RootSnapshot.interrupts
-	* `rootStore.interrupts[0]`} / framework `stream.interrupt`, which only
-	* mirrors root-namespace interrupts for UI convenience.
+	* {@link RootSnapshot.interrupts `rootStore.interrupts`} /
+	* framework `stream.interrupts` mirrors the same pending interrupts
+	* (including nested namespaces) for UI rendering.
 	*
 	* Omitting `interruptId` is fine when exactly one interrupt is pending.
 	* When several can be active (parallel subagents, fan-out, nested
-	* graphs), pass an explicit `interruptId` (and `namespace` for subgraph
-	* interrupts) so you resume the interrupt the user acted on.
+	* graphs), pass an explicit `interruptId` so you resume the interrupt
+	* the user acted on. `namespace` is resolved automatically from
+	* `thread.interrupts` / `stream.interrupts` when omitted.
 	*
 	* To resume several interrupts pending at the same checkpoint in one
 	* command, use {@link respondAll} — sequential single `respond()` calls
@@ -911,9 +955,8 @@ var StreamController = class {
 	* others with no interrupted run to respond to.
 	*
 	* The server validates `namespace` against the pending interrupt. Root
-	* interrupts use `namespace: []` (the default when `namespace` is
-	* omitted). Subgraph interrupts require the exact tuple from
-	* `getThread()?.interrupts` — see the example below.
+	* interrupts use `namespace: []`. Subgraph interrupts carry the exact
+	* tuple on each {@link Interrupt} / {@link InterruptPayload} entry.
 	*
 	* @param response - Payload sent back to the interrupted namespace.
 	* @param options - Optional target (`interruptId` / `namespace`) and
@@ -934,33 +977,22 @@ var StreamController = class {
 	* );
 	* ```
 	*
-	* @example Multiple root interrupts — target by id
+	* @example Multiple / nested interrupts — target by id
 	* ```tsx
 	* for (const intr of stream.interrupts) {
 	*   await stream.respond(decide(intr.value), { interruptId: intr.id! });
 	* }
 	* ```
 	*
-	* @example Subgraph interrupt — read `namespace` from the thread stream
-	* ```tsx
-	* const thread = stream.getThread();
-	* for (const entry of thread?.interrupts ?? []) {
-	*   await stream.respond(buildResponse(entry.payload), {
-	*     interruptId: entry.interruptId,
-	*     namespace: entry.namespace,
-	*   });
-	* }
-	* ```
-	*
-	* Each {@link InterruptPayload} on `thread.interrupts` mirrors an
-	* `input.requested` event: `{ interruptId, payload, namespace }`.
-	* Nested interrupts may appear here but not on `stream.interrupts`.
+	* Each {@link InterruptPayload} on `thread.interrupts` and each
+	* {@link Interrupt} on `stream.interrupts` mirrors an
+	* `input.requested` event with its protocol `namespace`.
 	*/
 	async respond(response, options) {
 		if (this.#disposed || this.#thread == null) throw new Error("No active thread to respond to.");
 		const resolved = options?.interruptId != null ? {
 			interruptId: options.interruptId,
-			namespace: options.namespace ?? [...ROOT_NAMESPACE]
+			namespace: this.#resolveNamespaceForInterruptId(options.interruptId, options.namespace)
 		} : this.#resolveInterruptForResume();
 		if (resolved == null) throw new Error("No pending interrupt to respond to.");
 		const thread = this.#thread;
@@ -1030,11 +1062,10 @@ var StreamController = class {
 		const entries = Object.entries(responsesById);
 		if (entries.length === 0) throw new Error("respondAll() requires at least one response.");
 		const thread = this.#thread;
-		const pending = thread.interrupts;
 		const responses = entries.map(([interruptId, response]) => ({
 			interrupt_id: interruptId,
 			response: require_hitl_interrupt_payload.normalizeHitlResponseForServer(response),
-			namespace: pending.find((entry) => entry.interruptId === interruptId)?.namespace ?? [...ROOT_NAMESPACE]
+			namespace: this.#resolveNamespaceForInterruptId(interruptId)
 		}));
 		const prepared = options?.update != null ? this.#beginOptimistic(options.update) : void 0;
 		const dispatchUpdate = this.#resolveDispatchUpdate(options?.update, prepared);
@@ -1201,16 +1232,11 @@ var StreamController = class {
 	* Without this, the controller would be wedged in a state where:
 	*   - `#thread` is wired but no content pump is open
 	*   - `#rootPumpDeferred` stays `true`
-	*   - `selfCreatedThreadIds` still holds the id
 	*
-	* A retry submit on the same controller would see
-	* `wasSelfCreated=false` (because `currentThreadId` is no longer
-	* null), `#ensureThread(id, false)` would early-return because
-	* `#thread != null`, and the pump would never start. The thread
-	* would have an id committed to the URL but no live subscription.
-	*
-	* Tearing down `#thread` so the next submit re-runs `#ensureThread`
-	* from scratch is the simplest recovery — the failed dispatch
+	* A retry submit must re-run `#ensureThread` from scratch (with
+	* `deferRootPump` still true — the id stays in
+	* `#selfCreatedThreadIds` until a successful dispatch). Tearing
+	* down `#thread` is the simplest recovery; the failed dispatch
 	* means there was nothing to subscribe to anyway.
 	*/
 	#abandonDeferredRootPump() {
@@ -1222,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);
@@ -1234,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();
@@ -1255,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();
@@ -1278,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;
@@ -1336,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;
@@ -1349,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.
 						*
@@ -1383,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();
 				}
@@ -1413,16 +1463,14 @@ var StreamController = class {
 		this.#subgraphs.push(event);
 		this.#lifecycleLoading.handle(event);
 		/**
-		* Nested `input.requested` events (HITL inside a subagent /
-		* subgraph) are not observable via the narrow content pump. The
-		* `ThreadStream` itself already records them into
-		* `thread.interrupts`, which `#latestUnresolvedInterrupt()`
-		* consults — so HITL respond() works for any depth. Root-level
-		* interrupts are also mirrored into `rootStore.interrupts` here so
-		* UI state does not depend on the narrower content pump being the
-		* first consumer to see the event.
+		* `input.requested` events (including HITL inside a subagent /
+		* subgraph) are not always observable via the narrow content pump.
+		* Mirror every namespace into `rootStore.interrupts` here so UI
+		* state does not depend on the content pump being the first
+		* consumer. `ThreadStream.interrupts` is updated in parallel for
+		* resume targeting.
 		*/
-		this.#recordRootInterrupt(event);
+		this.#recordInterrupt(event);
 	}
 	/**
 	* Process one root-pump event and update all root projections.
@@ -1515,7 +1563,7 @@ var StreamController = class {
 			return;
 		}
 		if (event.method === "input.requested") {
-			this.#recordRootInterrupt(event);
+			this.#recordInterrupt(event);
 			return;
 		}
 		if (event.method === "lifecycle") event.params.data;
@@ -1643,21 +1691,22 @@ var StreamController = class {
 		}
 	}
 	/**
-	* Mirror root protocol interrupts into the root snapshot.
+	* Mirror protocol interrupts (any namespace) into the root snapshot.
 	*
 	* This can be called from both the wildcard lifecycle/input watcher and the
 	* root content pump. Store-level dedup keeps the user-facing list stable.
 	*/
-	#recordRootInterrupt(event) {
+	#recordInterrupt(event) {
 		if (event.method !== "input.requested") return;
-		if (!require_namespace.isRootNamespace(event.params.namespace)) return;
 		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 namespace = Array.isArray(event.params.namespace) ? [...event.params.namespace] : [...ROOT_NAMESPACE];
 		const interrupt = require_interrupts.normalizeInterruptForClient({
 			id: interruptId,
-			value: data.payload
+			value: data.payload,
+			namespace
 		});
 		this.rootStore.setState((s) => {
 			if (s.interrupts.some((entry) => entry.id === interruptId)) return s;
@@ -1670,6 +1719,21 @@ var StreamController = class {
 		});
 	}
 	/**
+	* Resolve the protocol namespace for a targeted resume.
+	*
+	* Prefer an explicit caller-supplied namespace, then the matching
+	* {@link ThreadStream.interrupts} entry, then the UI mirror on
+	* `rootStore.interrupts`, finally root (`[]`).
+	*/
+	#resolveNamespaceForInterruptId(interruptId, explicitNamespace) {
+		if (explicitNamespace != null) return [...explicitNamespace];
+		const fromThread = this.#thread?.interrupts.find((entry) => entry.interruptId === interruptId)?.namespace;
+		if (fromThread != null) return [...fromThread];
+		const fromRoot = this.rootStore.getSnapshot().interrupts.find((entry) => entry.id === interruptId)?.namespace;
+		if (fromRoot != null) return [...fromRoot];
+		return [...ROOT_NAMESPACE];
+	}
+	/**
 	* Mark an interrupt resolved for replay filtering and mirror the
 	* removal into the root snapshot the framework hooks read.
 	*/