@langchain/langgraph-sdk 1.10.2 → 1.10.3-rc.1

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;;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;EAiK0B;;;;;EAA7C,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EAoyBF;;;;;;;EAAA,IAxqBvC,gBAAA,CAAA,GAAoB,OAAA;EA60BS;;;;;;;;EApxB3B,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EAsgCpB;;;;;;;;;;;;;;EA7pBf,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EApsB5B;;;;;;;;EAw8BlB,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EAx8B4B;;;;;;EAk9BzB,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EAh9BtB;;;;EAo+Bb,UAAA,CAAA,GAAc,OAAA;EAvsBhB;;;;;;;;;;;EAuwBE,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;;;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;;;;;EAiKnB,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EAoyBb;;;;;;;EAAA,IAxqB5B,gBAAA,CAAA,GAAoB,OAAA;EA8wBJ;;;;;;;;EArtBd,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EA0/B5B;;;;;;;;;;;;;;EAjpBP,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EApsB3C;;;;;;;;EAw8BH,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EAx8BM;;;;;;EAk9BH,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EAh9BhC;;;;EAo+BH,UAAA,CAAA,GAAc,OAAA;EAn0BR;;;;;;;;;;;EAm4BN,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

@@ -148,11 +148,9 @@ var StreamController = class {
 	* 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();
 	/**
@@ -168,13 +166,17 @@ var StreamController = class {
 	* than {@link #interruptReplayThroughSeq} bypass the allowlist.
 	*/
 	#hydratedActiveInterruptIds = null;
+	/** Checkpoint whose replay establishes the hydrate-time interrupt cutoff. */
+	#hydratedInterruptCheckpointId;
 	/**
-	* Highest event sequence already applied when the latest run command
-	* was accepted. Interrupts outside the hydrate-time allowlist remain
-	* filtered through this sequence, while newer events are live output
-	* from the newly-started run and must be accepted.
+	* Highest event sequence represented by hydration or already applied when
+	* the latest run command was accepted. Interrupts outside the hydrate-time
+	* allowlist remain filtered through this sequence, while newer events are
+	* live output and must be accepted.
 	*/
 	#interruptReplayThroughSeq;
+	/** Unknown inputs waiting for replay to reach the hydrated checkpoint. */
+	#pendingHydrationInterruptEvents = [];
 	/**
 	* Unknown interrupt events received between local command dispatch and its
 	* response. The response supplies the sequence barrier needed to classify
@@ -326,7 +328,9 @@ var StreamController = class {
 			onSubmitStart: () => {
 				this.#submitGeneration += 1;
 				this.#interruptCommandPending = this.#hydratedActiveInterruptIds != null;
-				this.#pendingInterruptEvents = [];
+				this.#pendingInterruptEvents = this.#pendingHydrationInterruptEvents;
+				this.#pendingHydrationInterruptEvents = [];
+				this.#hydratedInterruptCheckpointId = void 0;
 			},
 			onRunStart: () => this.#markLocalRunStart(),
 			onRunCreated: (runId) => {
@@ -577,6 +581,7 @@ var StreamController = class {
 				}));
 				if (this.#submitGeneration === generationAtFetch) {
 					this.#hydratedActiveInterruptIds = activeIds;
+					this.#hydratedInterruptCheckpointId = state.checkpoint?.checkpoint_id ?? void 0;
 					this.#interruptReplayThroughSeq = void 0;
 				}
 			}
@@ -1308,7 +1313,9 @@ var StreamController = class {
 		this.#localRunDepth = 0;
 		this.#messageMetadata.reset();
 		this.#hydratedActiveInterruptIds = null;
+		this.#hydratedInterruptCheckpointId = void 0;
 		this.#interruptReplayThroughSeq = void 0;
+		this.#pendingHydrationInterruptEvents = [];
 		this.#discardPendingInterruptEvents();
 		this.queueStore.setState(() => EMPTY_QUEUE);
 		try {
@@ -1484,6 +1491,7 @@ var StreamController = class {
 		} catch {}
 		this.#subgraphs.push(event);
 		this.#lifecycleLoading.handle(event);
+		this.#advanceInterruptReplayBarrierFromCheckpoint(event);
 		/**
 		* `input.requested` events (including HITL inside a subagent /
 		* subgraph) are not always observable via the narrow content pump.
@@ -1733,6 +1741,10 @@ var StreamController = class {
 			this.#pendingInterruptEvents.push(event);
 			return;
 		}
+		if (isUnknownInterrupt && this.#interruptReplayThroughSeq == null && this.#hydratedInterruptCheckpointId != null) {
+			this.#pendingHydrationInterruptEvents.push(event);
+			return;
+		}
 		if (isUnknownInterrupt && (this.#interruptReplayThroughSeq == null || eventSeq != null && eventSeq <= this.#interruptReplayThroughSeq)) return;
 		const namespace = Array.isArray(event.params.namespace) ? [...event.params.namespace] : [...ROOT_NAMESPACE];
 		const interrupt = normalizeInterruptForClient({
@@ -1750,6 +1762,16 @@ var StreamController = class {
 			};
 		});
 	}
+	/** Establish the hydration cutoff when ordered replay reaches its checkpoint. */
+	#advanceInterruptReplayBarrierFromCheckpoint(event) {
+		if (event.method !== "checkpoints" || this.#hydratedInterruptCheckpointId == null || !isRootNamespace(event.params.namespace)) return;
+		if (event.params.data?.id !== this.#hydratedInterruptCheckpointId || typeof event.seq !== "number") return;
+		this.#interruptReplayThroughSeq = event.seq;
+		this.#hydratedInterruptCheckpointId = void 0;
+		const pendingEvents = this.#pendingHydrationInterruptEvents.sort((a, b) => (a.seq ?? 0) - (b.seq ?? 0));
+		this.#pendingHydrationInterruptEvents = [];
+		for (const pendingEvent of pendingEvents) this.#recordInterrupt(pendingEvent);
+	}
 	/**
 	* Convert the hydrate-time allowlist into a replay barrier after a command
 	* is accepted. Built-in transports update `lastAppliedThroughSeq` from the
@@ -1795,8 +1817,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 +1836,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
@@ -1833,11 +1855,11 @@ var StreamController = class {
 			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);
+			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 {}