@langchain/langgraph-sdk 1.10.0 → 1.10.2

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;EAqJ0B;;;;;EAA7C,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EAszBF;;;;;;;EAAA,IA5rBvC,gBAAA,CAAA,GAAoB,OAAA;EAi2BS;;;;;;;;EAxyB3B,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EA0hCpB;;;;;;;;;;;;;;EA7pBf,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EA1sB5B;;;;;;;;EA88BlB,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EA98B4B;;;;;;EAw9BzB,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EAt9BtB;;;;EA0+Bb,UAAA,CAAA,GAAc,OAAA;EA3tBhB;;;;;;;;;;;EA2xBE,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiHG,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;EA+J0B;;;;;EAA7C,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EAgyBF;;;;;;;EAAA,IAtqBvC,gBAAA,CAAA,GAAoB,OAAA;EA20BS;;;;;;;;EAlxB3B,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EAogCpB;;;;;;;;;;;;;;EA7pBf,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EA9rB5B;;;;;;;;EAk8BlB,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EAl8B4B;;;;;;EA48BzB,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EA18BtB;;;;EA89Bb,UAAA,CAAA,GAAc,OAAA;EArsBhB;;;;;;;;;;;EAqwBE,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiHG,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"}

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;;;;;EAqJnB,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EAszBb;;;;;;;EAAA,IA5rB5B,gBAAA,CAAA,GAAoB,OAAA;EAkyBJ;;;;;;;;EAzuBd,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EA8gC5B;;;;;;;;;;;;;;EAjpBP,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EA1sB3C;;;;;;;;EA88BH,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EA98BM;;;;;;EAw9BH,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EAt9BhC;;;;EA0+BH,UAAA,CAAA,GAAc,OAAA;EAr1BR;;;;;;;;;;;EAq5BN,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiHG,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;;;;;EA+JnB,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EAgyBb;;;;;;;EAAA,IAtqB5B,gBAAA,CAAA,GAAoB,OAAA;EA4wBJ;;;;;;;;EAntBd,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EAw/B5B;;;;;;;;;;;;;;EAjpBP,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EA9rB3C;;;;;;;;EAk8BH,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EAl8BM;;;;;;EA48BH,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EA18BhC;;;;EA89BH,UAAA,CAAA,GAAc,OAAA;EA/zBR;;;;;;;;;;;EA+3BN,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiHG,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"}

package/dist/stream/controller.js

@@ -144,6 +144,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
@@ -558,24 +568,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(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,
@@ -1728,8 +1722,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);
@@ -1793,8 +1791,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);
@@ -1809,6 +1811,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.
 	*
@@ -1833,9 +1867,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) => {
@@ -1927,6 +1967,38 @@ function extractAndCoerceMessagesWithFallback(values, messagesKey) {
 	if (!Array.isArray(raw)) return null;
 	return 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(normalizeInterruptForClient({
+				id,
+				value: typed?.value,
+				namespace: Array.isArray(typed?.namespace) ? [...typed.namespace] : namespace
+			}));
+		}
+	}
+	return {
+		activeInterrupts,
+		activeIds
+	};
+}
 //#endregion
 export { ROOT_PUMP_CHANNELS, StreamController };