@langchain/langgraph-sdk 1.9.28 → 1.9.30

package/dist/stream/controller.d.cts

@@ -120,14 +120,15 @@ declare class StreamController<StateType extends object = Record<string, unknown
    * 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
@@ -135,9 +136,8 @@ declare class StreamController<StateType extends object = Record<string, unknown
    * 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
@@ -158,27 +158,16 @@ declare class StreamController<StateType extends object = Record<string, unknown
    * );
    * ```
    *
-   * @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`.
    */
   respond(response: unknown, options?: StreamRespondOptions<ConfigurableType>): Promise<void>;
   /**

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;EAsH0B;;;;;EAA7C,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EA0vBF;;;;;;;EAAA,IA/oBvC,gBAAA,CAAA,GAAoB,OAAA;EA+zBS;;;;;;;;EAtwB3B,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EAm/BpB;;;;;;;;;;;;;;EAlqBf,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EAhnB5B;;;;;;;;EAm3BlB,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EAn3B4B;;;;;;EA63BzB,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EA33BtB;;;;EA+4Bb,UAAA,CAAA,GAAc,OAAA;EA9qBhB;;;;;;;;;;;EA8uBE,YAAA,CAAa,EAAA,WAAa,OAAA;EA/FW;;;EAsGrC,UAAA,CAAA,GAAc,OAAA;EA3FC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmKf,OAAA,CACJ,QAAA,WACA,OAAA,GAAU,oBAAA,CAAqB,gBAAA,IAC9B,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4GG,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;;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;EAwI0B;;;;;EAA7C,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EA0yBF;;;;;;;EAAA,IA3rBvC,gBAAA,CAAA,GAAoB,OAAA;EAg2BS;;;;;;;;EAvyB3B,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EAqhCpB;;;;;;;;;;;;;;EAzpBf,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EAjrB5B;;;;;;;;EAq7BlB,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EAr7B4B;;;;;;EA+7BzB,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EA77BtB;;;;EAi9Bb,UAAA,CAAA,GAAc,OAAA;EA1tBhB;;;;;;;;;;;EA0xBE,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+GG,UAAA,CACJ,aAAA,EAAe,MAAA,mBACf,OAAA,GAAU,uBAAA,CAAwB,gBAAA,IACjC,OAAA;;;;EA0DG,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

@@ -120,14 +120,15 @@ declare class StreamController<StateType extends object = Record<string, unknown
    * 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
@@ -135,9 +136,8 @@ declare class StreamController<StateType extends object = Record<string, unknown
    * 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
@@ -158,27 +158,16 @@ declare class StreamController<StateType extends object = Record<string, unknown
    * );
    * ```
    *
-   * @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`.
    */
   respond(response: unknown, options?: StreamRespondOptions<ConfigurableType>): Promise<void>;
   /**

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;;;;;EAsHnB,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EA0vBb;;;;;;;EAAA,IA/oB5B,gBAAA,CAAA,GAAoB,OAAA;EAqvBJ;;;;;;;;EA5rBd,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EAu+B5B;;;;;;;;;;;;;;EAtpBP,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EAhnB3C;;;;;;;;EAm3BH,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EAn3BM;;;;;;EA63BH,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EA33BhC;;;;EA+4BH,UAAA,CAAA,GAAc,OAAA;EAzxBR;;;;;;;;;;;EAy1BN,YAAA,CAAa,EAAA,WAAa,OAAA;EA/FA;;;EAsG1B,UAAA,CAAA,GAAc,OAAA;EA3Fd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmKA,OAAA,CACJ,QAAA,WACA,OAAA,GAAU,oBAAA,CAAqB,gBAAA,IAC9B,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4GG,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;;;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;;;;;EAwInB,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EA0yBb;;;;;;;EAAA,IA3rB5B,gBAAA,CAAA,GAAoB,OAAA;EAiyBJ;;;;;;;;EAxuBd,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EAygC5B;;;;;;;;;;;;;;EA7oBP,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EAjrB3C;;;;;;;;EAq7BH,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EAr7BM;;;;;;EA+7BH,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EA77BhC;;;;EAi9BH,UAAA,CAAA,GAAc,OAAA;EAz0BR;;;;;;;;;;;EAy4BN,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+GG,UAAA,CACJ,aAAA,EAAe,MAAA,mBACf,OAAA,GAAU,uBAAA,CAAwB,gBAAA,IACjC,OAAA;;;;EA0DG,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

@@ -169,13 +169,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
@@ -270,12 +288,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),
@@ -379,13 +399,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
@@ -396,6 +419,7 @@ var StreamController = class {
 			* surprising. Mirrors the legacy `StreamOrchestrator` behaviour.
 			*/
 			this.queueStore.setState(() => EMPTY_QUEUE);
+			await teardown;
 		}
 		if (this.#currentThreadId == null) {
 			this.rootStore.setState((s) => ({
@@ -426,12 +450,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
@@ -516,6 +542,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;
@@ -523,7 +551,8 @@ var StreamController = class {
 						activeIds.add(id);
 						activeInterrupts.push(normalizeInterruptForClient({
 							id,
-							value: typed?.value
+							value: typed?.value,
+							namespace: Array.isArray(typed?.namespace) ? [...typed.namespace] : namespace
 						}));
 					}
 				}
@@ -541,7 +570,7 @@ var StreamController = class {
 					...s,
 					error
 				}));
-			}
+			} else threadMissing = true;
 		} finally {
 			this.rootStore.setState((s) => ({
 				...s,
@@ -551,6 +580,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
@@ -687,7 +730,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);
@@ -895,14 +938,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
@@ -910,9 +954,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
@@ -933,33 +976,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;
@@ -1029,11 +1061,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: 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);
@@ -1200,16 +1231,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() {
@@ -1221,6 +1247,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);
@@ -1233,16 +1267,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 ToolCallAssembler();
 		this.#lifecycleLoading.reset();
@@ -1254,6 +1288,13 @@ var StreamController = class {
 		this.#messageMetadata.reset();
 		this.#hydratedActiveInterruptIds = null;
 		this.queueStore.setState(() => EMPTY_QUEUE);
+		try {
+			await subscription?.unsubscribe();
+		} catch {}
+		try {
+			await this.#rootPump;
+		} catch {}
+		this.#rootPump = void 0;
 		if (thread != null) {
 			try {
 				await thread.close();
@@ -1277,6 +1318,7 @@ var StreamController = class {
 	*/
 	#startRootPump(thread) {
 		if (this.#rootPump != null) return;
+		const pumpGeneration = this.#rootPumpGeneration;
 		let resolveReady;
 		this.#rootPumpReady = new Promise((resolve) => {
 			resolveReady = resolve;
@@ -1335,6 +1377,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;
@@ -1348,9 +1398,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.
 						*
@@ -1382,7 +1432,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();
 				}
@@ -1412,16 +1462,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.
@@ -1514,7 +1562,7 @@ var StreamController = class {
 			return;
 		}
 		if (event.method === "input.requested") {
-			this.#recordRootInterrupt(event);
+			this.#recordInterrupt(event);
 			return;
 		}
 		if (event.method === "lifecycle") event.params.data;
@@ -1642,21 +1690,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 (!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 = normalizeInterruptForClient({
 			id: interruptId,
-			value: data.payload
+			value: data.payload,
+			namespace
 		});
 		this.rootStore.setState((s) => {
 			if (s.interrupts.some((entry) => entry.id === interruptId)) return s;
@@ -1669,6 +1718,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.
 	*/