@langchain/langgraph-sdk 1.12.5 → 1.12.7

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;;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;EAmL0B;;;;;EAA7C,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EAi2BF;;;;;;;EAAA,IA3tBvC,gBAAA,CAAA,GAAoB,OAAA;EA44BS;;;;;;;;EAn1B3B,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EAqkCpB;;;;;;;;;;;;;;EAzqBf,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EAnxB5B;;;;;;;;EAuhClB,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EAvhC4B;;;;;;EAiiCzB,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EA/hCtB;;;;EA2jCb,UAAA,CAAA,GAAc,OAAA;EAlwBhB;;;;;;;;;;;EAq0BE,YAAA,CAAa,EAAA,WAAa,OAAA;EA1GW;;;;EAkHrC,UAAA,CAAA,GAAc,OAAA;EAvGT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoKL,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;;AAgD1C;;;;;;;;;;;;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;EAkM0B;;;;;EAA7C,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EAo2BF;;;;;;;EAAA,IA3tBvC,gBAAA,CAAA,GAAoB,OAAA;EA44BS;;;;;;;;EAn1B3B,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EAykCpB;;;;;;;;;;;;;;EA7qBf,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EAryB5B;;;;;;;;EAyiClB,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EAziC4B;;;;;;EAmjCzB,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EAjjCtB;;;;EA6kCb,UAAA,CAAA,GAAc,OAAA;EAlwBhB;;;;;;;;;;;EAq0BE,YAAA,CAAa,EAAA,WAAa,OAAA;EA1GW;;;;EAkHrC,UAAA,CAAA,GAAc,OAAA;EAvGT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoKL,OAAA,CACJ,QAAA,WACA,OAAA,GAAU,oBAAA,CAAqB,gBAAA,IAC9B,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmHG,UAAA,CACJ,aAAA,EAAe,MAAA,mBACf,OAAA,GAAU,uBAAA,CAAwB,gBAAA,IACjC,OAAA;;;;EA8DG,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":";;;;;;;;;;;;;;;;cA6Ka,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;EADE;;;;;EAoLrB,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EA2lBO;;;;;;;EAAA,IArdhD,gBAAA,CAAA,GAAoB,OAAA;EAq0BQ;;;;;;;;EA5wB1B,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EAogCxB;;;;;;;;;;;;;;EAxmBX,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EApxBI;;;;;;;;EAwhClD,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EAxhCuC;;;;;;EAkiCpC,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EAhiCgB;;;;EA4jCnD,UAAA,CAAA,GAAc,OAAA;EAx4ByB;;;;;;;;;;;EA28BvC,YAAA,CAAa,EAAA,WAAa,OAAA;EA1GpB;;;;EAkHN,UAAA,CAAA,GAAc,OAAA;EAvGd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoKA,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":";;;;;;;;;;;;;;;;cA6Ka,kBAAA,WAA6B,OAAA;;;;AAgD1C;;;;;;;;;;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;EADE;;;;;EAmMrB,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EA8lBO;;;;;;;EAAA,IArdhD,gBAAA,CAAA,GAAoB,OAAA;EAq0BQ;;;;;;;;EA5wB1B,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EAwgCxB;;;;;;;;;;;;;;EA5mBX,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EAtyBI;;;;;;;;EA0iClD,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EA1iCuC;;;;;;EAojCpC,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EAljCgB;;;;EA8kCnD,UAAA,CAAA,GAAc,OAAA;EA34ByB;;;;;;;;;;;EA88BvC,YAAA,CAAa,EAAA,WAAa,OAAA;EA1GpB;;;;EAkHN,UAAA,CAAA,GAAc,OAAA;EAvGd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoKA,OAAA,CACJ,QAAA,WACA,OAAA,GAAU,oBAAA,CAAqB,gBAAA,IAC9B,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmHG,UAAA,CACJ,aAAA,EAAe,MAAA,mBACf,OAAA,GAAU,uBAAA,CAAwB,gBAAA,IACjC,OAAA;;;;EA8DG,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

@@ -185,6 +185,21 @@ var StreamController = class {
 	* from the newly-started run and must be accepted.
 	*/
 	#interruptReplayThroughSeq;
+	/**
+	* Command whose barrier is still to be found on the thread stream. The
+	* agent server answers HTTP commands from a fresh per-request manager,
+	* so `applied_through_seq` is 0 while the stream replays the whole
+	* history with positive seqs. The barrier is then the event before the
+	* `running` event of the run the command started: `run.start` names that
+	* run, and a resume starts the first root run after the answered
+	* interrupts were last requested. Unknown interrupts stay buffered until
+	* it is found.
+	*/
+	#awaitingRunBoundary;
+	/** Seq of each root run's `running` event, keyed by run id. */
+	#rootRunStartSeqs = /* @__PURE__ */ new Map();
+	/** Highest seq at which each interrupt was requested. */
+	#interruptRequestSeqs = /* @__PURE__ */ new Map();
 	/** Unknown inputs waiting to be classified as live or replayed history. */
 	#pendingHydrationInterruptEvents = [];
 	#settleParkedInterruptsPromise;
@@ -350,6 +365,7 @@ var StreamController = class {
 			awaitResumedRunTerminal: (signal) => this.#awaitResumedRunTerminal(signal),
 			onSubmitStart: () => {
 				this.#submitGeneration += 1;
+				this.#awaitingRunBoundary = void 0;
 				this.#interruptCommandPending = this.#hydratedActiveInterruptIds != null;
 				this.#pendingInterruptEvents = this.#pendingHydrationInterruptEvents;
 				this.#pendingHydrationInterruptEvents = [];
@@ -361,11 +377,12 @@ var StreamController = class {
 				for (const release of [...this.#heldLifecycleReleases]) release();
 			},
 			onRunCreated: (runId) => {
-				this.#advanceInterruptReplayBarrier();
+				this.#advanceInterruptReplayBarrier({ runId });
 				this.#notifyCreated(runId);
 			},
 			onRunCompleted: (reason, runId) => this.#notifyCompleted(reason, runId),
 			onRunEnd: () => {
+				this.#abandonRunBoundary();
 				this.#interruptCommandPending = false;
 				this.#markLocalRunEnd();
 			},
@@ -1099,7 +1116,7 @@ var StreamController = class {
 					config: options?.config,
 					metadata: options?.metadata
 				});
-				this.#advanceInterruptReplayBarrier();
+				this.#advanceInterruptReplayBarrier({ answeredInterruptIds: [resolved.interruptId] });
 				this.#markInterruptResolvedInRootStore(resolved.interruptId);
 			}, prepared?.handle);
 		} catch (error) {
@@ -1170,7 +1187,7 @@ var StreamController = class {
 					config: options?.config,
 					metadata: options?.metadata
 				});
-				this.#advanceInterruptReplayBarrier();
+				this.#advanceInterruptReplayBarrier({ answeredInterruptIds: responses.map((r) => r.interrupt_id) });
 				for (const { interrupt_id: interruptId } of responses) this.#markInterruptResolvedInRootStore(interruptId);
 			}, prepared?.handle);
 		} catch (error) {
@@ -1390,6 +1407,9 @@ var StreamController = class {
 		this.#hydratedActiveInterruptIds = null;
 		this.#hydratedCheckpointTime = void 0;
 		this.#interruptReplayThroughSeq = void 0;
+		this.#awaitingRunBoundary = void 0;
+		this.#rootRunStartSeqs.clear();
+		this.#interruptRequestSeqs.clear();
 		this.#pendingHydrationInterruptEvents = [];
 		this.#discardPendingInterruptEvents();
 		this.queueStore.setState(() => EMPTY_QUEUE);
@@ -1606,10 +1626,70 @@ var StreamController = class {
 		* consumer. `ThreadStream.interrupts` is updated in parallel for
 		* resume targeting.
 		*/
+		this.#observeRunBoundary(event);
 		this.#recordInterrupt(event);
 		this.#settleParkedInterruptsOnTerminal(event);
 	}
 	/**
+	* Remember where each root run starts and where each interrupt was last
+	* requested, then try to place a pending command barrier. Both the
+	* content pump and the lifecycle watcher replay the same tape with the
+	* same seqs, so recording either copy is enough.
+	*/
+	#observeRunBoundary(event) {
+		const { seq } = event;
+		if (typeof seq !== "number") return;
+		if (event.method === "input.requested") {
+			const id = event.params.data?.interrupt_id;
+			if (typeof id !== "string") return;
+			if (seq <= (this.#interruptRequestSeqs.get(id) ?? -1)) return;
+			this.#interruptRequestSeqs.set(id, seq);
+		} else if (event.method === "lifecycle" && isRootNamespace(event.params.namespace) && event.params.data?.event === "running") {
+			const runId = synthesizedEventRunId(event.event_id);
+			if (runId == null || this.#rootRunStartSeqs.has(runId)) return;
+			this.#rootRunStartSeqs.set(runId, seq);
+		} else return;
+		this.#resolveRunBoundary();
+	}
+	/**
+	* Place the barrier of a command that reported `applied_through_seq: 0`
+	* once its run's `running` event has been seen, then classify the
+	* interrupts buffered while it was unknown.
+	*/
+	#resolveRunBoundary() {
+		const command = this.#awaitingRunBoundary;
+		if (command == null) return;
+		let runStartSeq;
+		if ("runId" in command) runStartSeq = this.#rootRunStartSeqs.get(command.runId);
+		else {
+			let lastRequested = -1;
+			for (const id of command.answeredInterruptIds) {
+				const seq = this.#interruptRequestSeqs.get(id);
+				if (seq == null) return;
+				lastRequested = Math.max(lastRequested, seq);
+			}
+			for (const seq of this.#rootRunStartSeqs.values()) if (seq > lastRequested && (runStartSeq == null || seq < runStartSeq)) runStartSeq = seq;
+		}
+		if (runStartSeq == null) return;
+		this.#awaitingRunBoundary = void 0;
+		this.#interruptReplayThroughSeq = runStartSeq - 1;
+		this.#interruptCommandPending = false;
+		this.#flushPendingInterruptEvents();
+	}
+	/**
+	* Give up on a barrier whose run never showed up on the stream: a run
+	* cancelled before it started, or a resume whose answered interrupts
+	* were trimmed from the tape. Stop buffering and let the parked
+	* interrupt state check decide what was held.
+	*/
+	#abandonRunBoundary() {
+		if (this.#awaitingRunBoundary == null) return;
+		this.#awaitingRunBoundary = void 0;
+		this.#interruptCommandPending = false;
+		this.#flushPendingInterruptEvents();
+		this.#settleParkedInterrupts();
+	}
+	/**
 	* Process one root-pump event and update all root projections.
 	*
 	* @param event - Event yielded by the root subscription.
@@ -1901,24 +1981,38 @@ var StreamController = class {
 	* Convert the hydrate-time allowlist into a replay barrier after a command
 	* is accepted. Built-in transports update `lastAppliedThroughSeq` from the
 	* command response before resolving `submitRun` / `respondInput`.
+	*
+	* @param command - The run the command started, used to find the barrier
+	*   on the thread stream when the response reports
+	*   `applied_through_seq: 0`.
 	*/
-	#advanceInterruptReplayBarrier() {
+	#advanceInterruptReplayBarrier(command) {
 		if (this.#hydratedActiveInterruptIds == null) {
 			this.#discardPendingInterruptEvents();
 			return;
 		}
 		const throughSeq = this.#thread?.ordering?.lastAppliedThroughSeq;
+		if (throughSeq === 0 && command != null) {
+			this.#awaitingRunBoundary = command;
+			this.#resolveRunBoundary();
+			return;
+		}
 		if (typeof throughSeq === "number") this.#interruptReplayThroughSeq = throughSeq;
 		else {
 			this.#hydratedActiveInterruptIds = null;
 			this.#interruptReplayThroughSeq = void 0;
 		}
 		this.#interruptCommandPending = false;
+		this.#flushPendingInterruptEvents();
+	}
+	/** Classify the interrupts buffered while a command was in flight. */
+	#flushPendingInterruptEvents() {
 		const pendingEvents = this.#pendingInterruptEvents;
 		this.#pendingInterruptEvents = [];
 		for (const event of pendingEvents) this.#recordInterrupt(event);
 	}
 	#discardPendingInterruptEvents() {
+		this.#awaitingRunBoundary = void 0;
 		this.#interruptCommandPending = false;
 		this.#pendingInterruptEvents = [];
 	}
@@ -2068,7 +2162,9 @@ var StreamController = class {
 	* `stream.interrupts` empty while the checkpoint still has siblings.
 	*/
 	async #awaitResumedRunTerminal(signal) {
+		const generation = this.#submitGeneration;
 		const terminal = await this.#awaitRootTerminal(signal, { skipInterruptedUntilRunning: true });
+		if (this.#submitGeneration === generation) this.#abandonRunBoundary();
 		if (!signal.aborted && !this.#disposed && (terminal.event === "interrupted" || terminal.event === "completed")) await this.#reconcilePendingInterruptsFromServer();
 		return terminal;
 	}