@langchain/langgraph-sdk 1.10.0 → 1.10.3-rc.0

package/dist/stream/controller.cjs

@@ -145,6 +145,16 @@ var StreamController = class {
 	#threadEventUnsubscribe;
 	#disposed = false;
 	#pendingDisposeTimer = null;
+	/**
+	* Interrupt ids this controller has locally marked resolved via
+	* {@link respond} / {@link respondAll}. Used only to suppress
+	* *historical* SSE replay of those `input.requested` events (there
+	* is no `input.responded` protocol event). Live events after the
+	* resume barrier — or a post-resume reconcile against
+	* `state.tasks[].interrupts` — clear an id from this set so a
+	* still-pending server interrupt can reappear on
+	* `rootStore.interrupts`.
+	*/
 	#resolvedInterrupts = /* @__PURE__ */ new Set();
 	/**
 	* Set of interrupt IDs the server reports as currently *active* on
@@ -559,24 +569,8 @@ var StreamController = class {
 			*/
 			if (Array.isArray(state?.tasks)) {
 				const generationAtFetch = this.#submitGeneration;
-				const activeInterrupts = [];
-				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;
-						if (typeof id !== "string" || activeIds.has(id)) continue;
-						activeIds.add(id);
-						activeInterrupts.push(require_interrupts.normalizeInterruptForClient({
-							id,
-							value: typed?.value,
-							namespace: Array.isArray(typed?.namespace) ? [...typed.namespace] : namespace
-						}));
-					}
-				}
+				const { activeInterrupts, activeIds } = collectActiveInterruptsFromTasks(state.tasks);
+				for (const id of activeIds) this.#resolvedInterrupts.delete(id);
 				this.rootStore.setState((s) => ({
 					...s,
 					interrupts: activeInterrupts,
@@ -1729,8 +1723,12 @@ var StreamController = class {
 		if (event.method !== "input.requested") return;
 		const data = event.params.data;
 		const interruptId = data?.interrupt_id;
-		if (typeof interruptId !== "string" || this.#resolvedInterrupts.has(interruptId)) return;
+		if (typeof interruptId !== "string") return;
 		const eventSeq = typeof event.seq === "number" ? event.seq : void 0;
+		if (this.#resolvedInterrupts.has(interruptId)) {
+			if (!(this.#hydratedActiveInterruptIds == null || typeof this.#interruptReplayThroughSeq === "number" && eventSeq != null && eventSeq > this.#interruptReplayThroughSeq)) return;
+			this.#resolvedInterrupts.delete(interruptId);
+		}
 		const isUnknownInterrupt = this.#hydratedActiveInterruptIds != null && !this.#hydratedActiveInterruptIds.has(interruptId);
 		if (isUnknownInterrupt && this.#interruptCommandPending) {
 			this.#pendingInterruptEvents.push(event);
@@ -1794,8 +1792,12 @@ var StreamController = class {
 		return [...ROOT_NAMESPACE];
 	}
 	/**
-	* Mark an interrupt resolved for replay filtering and mirror the
-	* removal into the root snapshot the framework hooks read.
+	* Mark an interrupt resolved for historical-replay filtering and
+	* mirror the removal into the root snapshot the framework hooks read.
+	*
+	* Tombstones are not permanent: a live `input.requested` after the
+	* resume barrier, or {@link #reconcilePendingInterruptsFromServer},
+	* clears the id when the server still reports it as pending.
 	*/
 	#markInterruptResolvedInRootStore(interruptId) {
 		this.#resolvedInterrupts.add(interruptId);
@@ -1810,6 +1812,38 @@ var StreamController = class {
 		});
 	}
 	/**
+	* Re-sync `rootStore.interrupts` from the server's authoritative
+	* `state.tasks[].interrupts` after a resumed run settles.
+	*
+	* Sequential `respond()` of parallel interrupts optimistically clears
+	* each id client-side. When the server still has siblings pending and
+	* does not re-emit `input.requested` for them (session map already
+	* holds the id), this restore keeps `stream.interrupts` truthful so
+	* callers do not free-text `submit()` into an ambiguous resume.
+	*
+	* Uses the same transport-aware state fetch as {@link hydrate}, and
+	* drops the result if the thread swapped or a new submit/respond
+	* started while the fetch was in flight.
+	*/
+	async #reconcilePendingInterruptsFromServer() {
+		const threadId = this.#currentThreadId;
+		if (threadId == null || this.#disposed) return;
+		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;
+			const { activeInterrupts, activeIds } = collectActiveInterruptsFromTasks(state.tasks);
+			for (const id of activeIds) this.#resolvedInterrupts.delete(id);
+			this.rootStore.setState((s) => ({
+				...s,
+				interrupts: activeInterrupts,
+				interrupt: activeInterrupts[0]
+			}));
+			this.#hydratedActiveInterruptIds = activeIds;
+		} catch {}
+	}
+	/**
 	* Resolve on the next root-namespace terminal lifecycle event
 	* (`completed` / `failed` / `interrupted`) or on abort.
 	*
@@ -1834,9 +1868,15 @@ var StreamController = class {
 	* but before `respondInput` calls `#prepareForNextRun`; accepting that
 	* terminal would unsubscribe the watcher before the resumed run's `failed`
 	* terminal arrives.
+	*
+	* On `interrupted` / `completed`, reconciles pending interrupts from
+	* server state so optimistic clears from {@link respond} cannot leave
+	* `stream.interrupts` empty while the checkpoint still has siblings.
 	*/
-	#awaitResumedRunTerminal(signal) {
-		return this.#awaitRootTerminal(signal, { skipInterruptedUntilRunning: true });
+	async #awaitResumedRunTerminal(signal) {
+		const terminal = await this.#awaitRootTerminal(signal, { skipInterruptedUntilRunning: true });
+		if (!signal.aborted && !this.#disposed && (terminal.event === "interrupted" || terminal.event === "completed")) await this.#reconcilePendingInterruptsFromServer();
+		return terminal;
 	}
 	#awaitRootTerminal(signal, options) {
 		return new Promise((resolve) => {
@@ -1928,6 +1968,38 @@ function extractAndCoerceMessagesWithFallback(values, messagesKey) {
 	if (!Array.isArray(raw)) return null;
 	return require_message_coercion.ensureMessageInstances(raw);
 }
+/**
+* Collect pending interrupts from a `threads.getState()` `tasks` array.
+*
+* Shared by {@link StreamController.hydrate} and the post-resume
+* reconcile path so both stay aligned on namespace derivation and
+* id dedupe.
+*/
+function collectActiveInterruptsFromTasks(tasks) {
+	const activeInterrupts = [];
+	const activeIds = /* @__PURE__ */ new Set();
+	for (const task of tasks) {
+		if (!Array.isArray(task?.interrupts)) continue;
+		const typedTask = task;
+		const checkpointNs = typedTask.checkpoint?.checkpoint_ns;
+		const namespace = typeof checkpointNs === "string" && checkpointNs.length > 0 ? checkpointNs.split("|").filter((segment) => segment.length > 0) : [...ROOT_NAMESPACE];
+		for (const interrupt of typedTask.interrupts) {
+			const typed = interrupt;
+			const id = typed?.id;
+			if (typeof id !== "string" || activeIds.has(id)) continue;
+			activeIds.add(id);
+			activeInterrupts.push(require_interrupts.normalizeInterruptForClient({
+				id,
+				value: typed?.value,
+				namespace: Array.isArray(typed?.namespace) ? [...typed.namespace] : namespace
+			}));
+		}
+	}
+	return {
+		activeInterrupts,
+		activeIds
+	};
+}
 //#endregion
 exports.ROOT_PUMP_CHANNELS = ROOT_PUMP_CHANNELS;
 exports.StreamController = StreamController;