@langchain/langgraph-sdk 1.10.3-rc.0 → 1.10.3-rc.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;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"}
+{"version":3,"file":"controller.d.cts","names":[],"sources":["../../src/stream/controller.ts"],"mappings":";;;;;;;;;;;;;;AA6KA;;cAAa,kBAAA,WAA6B,OAAA;;AAwC1C;;;;;;;;;;;;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;EAiK0B;;;;;EAA7C,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EAiyBF;;;;;;;EAAA,IAtqBvC,gBAAA,CAAA,GAAoB,OAAA;EA20BS;;;;;;;;EAlxB3B,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EAogCpB;;;;;;;;;;;;;;EA7pBf,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EAjsB5B;;;;;;;;EAq8BlB,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EAr8B4B;;;;;;EA+8BzB,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EA78BtB;;;;EAi+Bb,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;;;;;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"}
+{"version":3,"file":"controller.d.ts","names":[],"sources":["../../src/stream/controller.ts"],"mappings":";;;;;;;;;;;;;;;AA6KA;cAAa,kBAAA,WAA6B,OAAA;;;AAwC1C;;;;;;;;;;;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;;;;;EAiKnB,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EAiyBb;;;;;;;EAAA,IAtqB5B,gBAAA,CAAA,GAAoB,OAAA;EA4wBJ;;;;;;;;EAntBd,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EAw/B5B;;;;;;;;;;;;;;EAjpBP,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EAjsB3C;;;;;;;;EAq8BH,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EAr8BM;;;;;;EA+8BH,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EA78BhC;;;;EAi+BH,UAAA,CAAA,GAAc,OAAA;EAh0BR;;;;;;;;;;;EAg4BN,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

@@ -104,6 +104,8 @@ const ROOT_PUMP_CHANNELS = [
 	"messages",
 	"tools"
 ];
+const PARKED_INTERRUPT_SETTLE_MS = 5e3;
+const PARKED_INTERRUPT_SETTLE_POLL_MS = 500;
 /**
 * Coordinates one thread's protocol-v2 stream and exposes stable
 * observable projections for framework bindings.
@@ -142,17 +144,16 @@ var StreamController = class {
 	*/
 	#rootPumpDeferred = false;
 	#threadEventUnsubscribe;
+	#threadErrorUnsubscribe;
 	#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`.
+	* is no `input.responded` protocol event). A live event after the
+	* resume barrier clears an id from this set so an interrupt raised
+	* again by a later run can reappear on `rootStore.interrupts`.
 	*/
 	#resolvedInterrupts = /* @__PURE__ */ new Set();
 	/**
@@ -175,6 +176,9 @@ var StreamController = class {
 	* from the newly-started run and must be accepted.
 	*/
 	#interruptReplayThroughSeq;
+	/** Unknown inputs waiting to be classified as live or replayed history. */
+	#pendingHydrationInterruptEvents = [];
+	#settleParkedInterruptsPromise;
 	/**
 	* Unknown interrupt events received between local command dispatch and its
 	* response. The response supplies the sequence barrier needed to classify
@@ -326,7 +330,8 @@ var StreamController = class {
 			onSubmitStart: () => {
 				this.#submitGeneration += 1;
 				this.#interruptCommandPending = this.#hydratedActiveInterruptIds != null;
-				this.#pendingInterruptEvents = [];
+				this.#pendingInterruptEvents = this.#pendingHydrationInterruptEvents;
+				this.#pendingHydrationInterruptEvents = [];
 			},
 			onRunStart: () => this.#markLocalRunStart(),
 			onRunCreated: (runId) => {
@@ -1281,6 +1286,8 @@ var StreamController = class {
 		this.registry.bind(void 0);
 		this.#threadEventUnsubscribe?.();
 		this.#threadEventUnsubscribe = void 0;
+		this.#threadErrorUnsubscribe?.();
+		this.#threadErrorUnsubscribe = void 0;
 		/**
 		* Persistent lifecycle driver is scoped to the current thread
 		* stream. Remove it so a swap to a new thread starts with a clean
@@ -1309,6 +1316,7 @@ var StreamController = class {
 		this.#messageMetadata.reset();
 		this.#hydratedActiveInterruptIds = null;
 		this.#interruptReplayThroughSeq = void 0;
+		this.#pendingHydrationInterruptEvents = [];
 		this.#discardPendingInterruptEvents();
 		this.queueStore.setState(() => EMPTY_QUEUE);
 		try {
@@ -1355,6 +1363,13 @@ var StreamController = class {
 		* pump's narrow filter.
 		*/
 		this.#threadEventUnsubscribe = thread.onEvent((event) => this.#onWildcardEvent(event));
+		this.#threadErrorUnsubscribe = thread.onError((error) => {
+			this.rootStore.setState((s) => ({
+				...s,
+				error,
+				isLoading: false
+			}));
+		});
 		/**
 		* Persistent isLoading driver. Drives `isLoading` from
 		* root-namespace lifecycle events so that in-flight runs observed
@@ -1493,6 +1508,7 @@ var StreamController = class {
 		* resume targeting.
 		*/
 		this.#recordInterrupt(event);
+		this.#settleParkedInterruptsOnTerminal(event);
 	}
 	/**
 	* Process one root-pump event and update all root projections.
@@ -1733,7 +1749,12 @@ var StreamController = class {
 			this.#pendingInterruptEvents.push(event);
 			return;
 		}
-		if (isUnknownInterrupt && (this.#interruptReplayThroughSeq == null || eventSeq != null && eventSeq <= this.#interruptReplayThroughSeq)) return;
+		const barrier = this.#interruptReplayThroughSeq;
+		if (isUnknownInterrupt && barrier == null) {
+			this.#pendingHydrationInterruptEvents.push(event);
+			return;
+		}
+		if (isUnknownInterrupt && barrier != null && eventSeq != null && eventSeq <= barrier) return;
 		const namespace = Array.isArray(event.params.namespace) ? [...event.params.namespace] : [...ROOT_NAMESPACE];
 		const interrupt = normalizeInterruptForClient({
 			id: interruptId,
@@ -1795,8 +1816,7 @@ var StreamController = class {
 	* 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.
+	* resume barrier clears the id when the same interrupt is raised again.
 	*/
 	#markInterruptResolvedInRootStore(interruptId) {
 		this.#resolvedInterrupts.add(interruptId);
@@ -1815,10 +1835,11 @@ var StreamController = class {
 	* `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.
+	* each targeted id client-side. The server checkpoint can continue to
+	* list the original interrupt batch after accepting a partial response,
+	* so locally-resolved ids remain filtered while untouched siblings are
+	* restored. This keeps `stream.interrupts` truthful without re-exposing
+	* an already-consumed interrupt.
 	*
 	* Uses the same transport-aware state fetch as {@link hydrate}, and
 	* drops the result if the thread swapped or a new submit/respond
@@ -1826,21 +1847,69 @@ var StreamController = class {
 	*/
 	async #reconcilePendingInterruptsFromServer() {
 		const threadId = this.#currentThreadId;
-		if (threadId == null || this.#disposed) return;
+		if (threadId == null || this.#disposed) return null;
 		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;
+			if (this.#disposed || this.#currentThreadId !== threadId || this.#submitGeneration !== generationAtFetch) return null;
+			if (!Array.isArray(state?.tasks)) return null;
 			const { activeInterrupts, activeIds } = collectActiveInterruptsFromTasks(state.tasks);
-			for (const id of activeIds) this.#resolvedInterrupts.delete(id);
+			const pendingInterrupts = activeInterrupts.filter((interrupt) => interrupt.id == null || !this.#resolvedInterrupts.has(interrupt.id));
 			this.rootStore.setState((s) => ({
 				...s,
-				interrupts: activeInterrupts,
-				interrupt: activeInterrupts[0]
+				interrupts: pendingInterrupts,
+				interrupt: pendingInterrupts[0]
 			}));
 			this.#hydratedActiveInterruptIds = activeIds;
-		} catch {}
+			return state;
+		} catch {
+			return null;
+		}
+	}
+	#settleParkedInterruptsOnTerminal(event) {
+		if (this.#pendingHydrationInterruptEvents.length === 0) return;
+		if (event.method !== "lifecycle") return;
+		if (!isRootNamespace(event.params.namespace)) return;
+		const status = event.params.data?.event;
+		if (status !== "interrupted" && status !== "completed" && status !== "failed") return;
+		this.#settleParkedInterrupts();
+	}
+	/**
+	* Decide parked interrupts with server state instead of a stream marker.
+	*
+	* After a passive rejoin the stream cannot tell a replayed, already
+	* resolved `input.requested` from one the current run just raised: the
+	* SSE replays the thread buffer on connect with no marker for where the
+	* replay ends. `state.tasks[].interrupts` is authoritative: parked ids it
+	* lists are live, the rest are history.
+	*/
+	async #settleParkedInterrupts() {
+		const makePromise = async () => {
+			try {
+				const threadId = this.#currentThreadId;
+				const generation = this.#submitGeneration;
+				const deadline = Date.now() + PARKED_INTERRUPT_SETTLE_MS;
+				for (;;) {
+					if (this.#disposed || this.#currentThreadId !== threadId || this.#submitGeneration !== generation || this.#pendingHydrationInterruptEvents.length === 0) return;
+					const parkedIds = new Set(this.#pendingHydrationInterruptEvents.map((event) => event.params.data.interrupt_id));
+					const state = await this.#reconcilePendingInterruptsFromServer();
+					if (state != null) {
+						if ([...this.#hydratedActiveInterruptIds ?? []].some((id) => parkedIds.has(id)) || !isThreadStateActive(state)) {
+							this.#pendingHydrationInterruptEvents = [];
+							return;
+						}
+					}
+					if (Date.now() >= deadline) return;
+					await new Promise((resolve) => {
+						setTimeout(resolve, PARKED_INTERRUPT_SETTLE_POLL_MS);
+					});
+				}
+			} finally {
+				this.#settleParkedInterruptsPromise = void 0;
+			}
+		};
+		this.#settleParkedInterruptsPromise ??= makePromise();
+		return this.#settleParkedInterruptsPromise;
 	}
 	/**
 	* Resolve on the next root-namespace terminal lifecycle event
@@ -1886,6 +1955,7 @@ var StreamController = class {
 				settled = true;
 				unsubscribeRoot?.();
 				unsubscribeThread?.();
+				unsubscribeError?.();
 				signal.removeEventListener("abort", finishAborted);
 				resolve(result);
 			}
@@ -1911,6 +1981,10 @@ var StreamController = class {
 			};
 			const unsubscribeRoot = this.#rootBus.subscribe(onEvent);
 			const unsubscribeThread = this.#thread?.onEvent(onEvent);
+			const unsubscribeError = this.#thread?.onError((error) => finish({
+				event: "failed",
+				error: error.message
+			}));
 			if (signal.aborted) finishAborted();
 			else signal.addEventListener("abort", finishAborted, { once: true });
 		});