@langchain/langgraph-sdk 1.12.3 → 1.12.5

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;EAiK0B;;;;;EAA7C,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EAm0BF;;;;;;;EAAA,IArsBvC,gBAAA,CAAA,GAAoB,OAAA;EA22BS;;;;;;;;EAlzB3B,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EAoiCpB;;;;;;;;;;;;;;EA9pBf,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EAnuB5B;;;;;;;;EAu+BlB,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EAv+B4B;;;;;;EAi/BzB,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EA/+BtB;;;;EAmgCb,UAAA,CAAA,GAAc,OAAA;EApuBhB;;;;;;;;;;;EAoyBE,YAAA,CAAa,EAAA,WAAa,OAAA;EA/FW;;;;EAuGrC,UAAA,CAAA,GAAc,OAAA;EA5FT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyJL,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;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"}

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;;;;;EAkKrB,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EA6jBO;;;;;;;EAAA,IA/bhD,gBAAA,CAAA,GAAoB,OAAA;EAoyBQ;;;;;;;;EA3uB1B,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EAm+BxB;;;;;;;;;;;;;;EA7lBX,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EApuBI;;;;;;;;EAw+BlD,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EAx+BuC;;;;;;EAk/BpC,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EAh/BgB;;;;EAogCnD,UAAA,CAAA,GAAc,OAAA;EAl2ByB;;;;;;;;;;;EAk6BvC,YAAA,CAAa,EAAA,WAAa,OAAA;EA/FpB;;;;EAuGN,UAAA,CAAA,GAAc,OAAA;EA5Fd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyJA,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;;;;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"}

package/dist/stream/controller.js

@@ -171,6 +171,14 @@ var StreamController = class {
 	*/
 	#hydratedActiveInterruptIds = null;
 	/**
+	* Creation time of the checkpoint the latest {@link hydrate} seeded
+	* from. A new stream subscription replays the thread's retained
+	* history, and events produced before this moment are already part of
+	* the seed: applying them again rewinds `messages`, `values` and
+	* `toolCalls` to older turns and then rebuilds them.
+	*/
+	#hydratedCheckpointTime;
+	/**
 	* 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
@@ -242,6 +250,16 @@ var StreamController = class {
 	#rootEventListeners = /* @__PURE__ */ new Set();
 	#rootBus;
 	#activeRunId;
+	/**
+	* Run id `run.start` returned for the in-flight local `submit()`. Kept
+	* apart from {@link #activeRunId}, which a rolled-back submit's late
+	* response can still overwrite.
+	*/
+	#submittedRunId;
+	/** `true` from a local run's dispatch until its `run.start` answers. */
+	#submittedRunIdPending = false;
+	/** One per armed terminal wait: re-runs the lifecycle events it held until `run.start` answered. */
+	#heldLifecycleReleases = /* @__PURE__ */ new Set();
 	#localRunDepth = 0;
 	/**
 	* `true` once a root `values` event has been applied for the current
@@ -301,7 +319,8 @@ var StreamController = class {
 		this.#lifecycleLoading = new LifecycleLoadingTracker({
 			store: this.rootStore,
 			isDisposed: () => this.#disposed,
-			onSettled: () => this.#submitter.scheduleQueueDrainOnObservedIdle()
+			onSettled: () => this.#submitter.scheduleQueueDrainOnObservedIdle(),
+			ignore: (event) => this.#submittedRunMatch(event) != null
 		});
 		this.messageMetadataStore = this.#messageMetadata.store;
 		this.queueStore = new StreamStore(EMPTY_QUEUE);
@@ -336,6 +355,11 @@ var StreamController = class {
 				this.#pendingHydrationInterruptEvents = [];
 			},
 			onRunStart: () => this.#markLocalRunStart(),
+			onRunStartReturned: (runId) => {
+				this.#submittedRunId = runId;
+				this.#submittedRunIdPending = false;
+				for (const release of [...this.#heldLifecycleReleases]) release();
+			},
 			onRunCreated: (runId) => {
 				this.#advanceInterruptReplayBarrier();
 				this.#notifyCreated(runId);
@@ -495,6 +519,8 @@ var StreamController = class {
 			if (this.#disposed || this.#currentThreadId !== hydratedThreadId) return;
 			threadExists = state != null;
 			threadActive = isThreadStateActive(state);
+			const checkpointTime = Date.parse(state?.created_at ?? "");
+			this.#hydratedCheckpointTime = Number.isNaN(checkpointTime) ? void 0 : checkpointTime;
 			this.#missingThreadIds.delete(hydratedThreadId);
 			if (state?.values != null) {
 				/**
@@ -533,6 +559,11 @@ var StreamController = class {
 				const seedMessages = state.values[this.#messagesKey];
 				if (Array.isArray(seedMessages)) {
 					this.#subagents.seedFromCheckpointMessages(seedMessages);
+					const finishedToolCalls = seedToolCallsFromMessages(ROOT_NAMESPACE, ensureMessageInstances(seedMessages)).filter((toolCall) => toolCall.status === "finished");
+					if (finishedToolCalls.length > 0) this.rootStore.setState((s) => ({
+						...s,
+						toolCalls: finishedToolCalls.reduce((toolCalls, toolCall) => upsertToolCall(toolCalls, toolCall), s.toolCalls)
+					}));
 					/**
 					* An idle (finished) thread defers its root SSE pump; the first
 					* `submit()` brings it up and the transport replays the finished
@@ -560,7 +591,7 @@ var StreamController = class {
 			*/
 			const unpersisted = this.#messageMetadata.unpersistedOptimisticIds();
 			if (unpersisted.size > 0) {
-				this.#rootMessages.dropOptimisticMessages(unpersisted);
+				this.#rootMessages.dropMessages(unpersisted);
 				this.#messageMetadata.forget(unpersisted);
 			}
 			/**
@@ -912,6 +943,13 @@ var StreamController = class {
 		if (options?.cancel ?? true) {
 			const threadId = this.#currentThreadId;
 			const runId = this.#activeRunId;
+			if (runId != null && this.rootStore.getSnapshot().isLoading) {
+				const dropped = this.#rootMessages.closeRun({
+					sync: true,
+					unfinishedOnly: true
+				});
+				if (dropped.size > 0) this.#messageMetadata.forget(dropped);
+			}
 			if (threadId != null && runId != null) try {
 				await this.#options.client.runs.cancel(threadId, runId);
 			} catch {}
@@ -927,9 +965,12 @@ var StreamController = class {
 	}
 	#markLocalRunStart() {
 		this.#localRunDepth += 1;
+		this.#submittedRunId = void 0;
+		this.#submittedRunIdPending = true;
 	}
 	#markLocalRunEnd() {
 		this.#localRunDepth = Math.max(0, this.#localRunDepth - 1);
+		if (this.#localRunDepth === 0) this.#submittedRunIdPending = false;
 	}
 	#notifyCreated(runId) {
 		this.#activeRunId = runId;
@@ -1347,6 +1388,7 @@ var StreamController = class {
 		this.#localRunDepth = 0;
 		this.#messageMetadata.reset();
 		this.#hydratedActiveInterruptIds = null;
+		this.#hydratedCheckpointTime = void 0;
 		this.#interruptReplayThroughSeq = void 0;
 		this.#pendingHydrationInterruptEvents = [];
 		this.#discardPendingInterruptEvents();
@@ -1586,6 +1628,8 @@ var StreamController = class {
 		if (this.#rootEventListeners.size > 0) for (const listener of this.#rootEventListeners) try {
 			listener(event);
 		} catch {}
+		const floor = this.#hydratedCheckpointTime;
+		if (floor != null && event.params.timestamp < floor) return;
 		/**
 		* `messages` and `tools` events are emitted under a node's
 		* namespace — for a typical StateGraph the LLM's token deltas
@@ -1661,7 +1705,32 @@ var StreamController = class {
 			this.#recordInterrupt(event);
 			return;
 		}
-		if (event.method === "lifecycle") event.params.data;
+		if (event.method === "lifecycle") {
+			/**
+			* Root lifecycle transitions are observed elsewhere
+			* (#awaitTerminal) to unblock `submit`. Here they drop a closed
+			* run's never-checkpointed messages.
+			*/
+			const lifecycle = event.params.data;
+			const dropped = this.#rootMessages.applyLifecycle(lifecycle?.event);
+			if (dropped.size > 0) this.#messageMetadata.forget(dropped);
+		}
+	}
+	/**
+	* How a lifecycle event relates to the run a local `submit()` started.
+	* New subscriptions replay earlier runs' terminals, and accepting one
+	* would end the submitted run early: `"other"` marks those, `"pending"`
+	* an event that names a run before `run.start` has answered. `undefined`
+	* when it can't be told apart (no submit in flight, no run named, or no
+	* run id returned).
+	*/
+	#submittedRunMatch(event) {
+		if (event.method !== "lifecycle" || this.#localRunDepth === 0) return;
+		const runId = synthesizedEventRunId(event.event_id);
+		if (runId == null) return void 0;
+		if (this.#submittedRunIdPending) return "pending";
+		if (this.#submittedRunId == null) return void 0;
+		return runId === this.#submittedRunId ? void 0 : "other";
 	}
 	/**
 	* Merge a `values` payload into root values and root messages.
@@ -2007,9 +2076,12 @@ var StreamController = class {
 		return new Promise((resolve) => {
 			let settled = false;
 			let sawRunning = false;
+			const held = [];
+			const heldReleases = this.#heldLifecycleReleases;
 			function finish(result) {
 				if (settled) return;
 				settled = true;
+				heldReleases.delete(releaseHeld);
 				unsubscribeRoot?.();
 				unsubscribeThread?.();
 				unsubscribeError?.();
@@ -2021,6 +2093,12 @@ var StreamController = class {
 				if (settled) return;
 				if (event.method !== "lifecycle") return;
 				if (!isRootNamespace(event.params.namespace)) return;
+				const match = this.#submittedRunMatch(event);
+				if (match === "other") return;
+				if (match === "pending") {
+					held.push(event);
+					return;
+				}
 				const lifecycle = event.params.data;
 				if (lifecycle?.event === "running") {
 					sawRunning = true;
@@ -2036,6 +2114,10 @@ var StreamController = class {
 					setTimeout(() => finish({ event: "interrupted" }), 0);
 				}
 			};
+			const releaseHeld = () => {
+				for (const event of held.splice(0)) onEvent(event);
+			};
+			heldReleases.add(releaseHeld);
 			const unsubscribeRoot = this.#rootBus.subscribe(onEvent);
 			const unsubscribeThread = this.#thread?.onEvent(onEvent);
 			const unsubscribeError = this.#thread?.onError((error) => finish({
@@ -2130,6 +2212,15 @@ function collectActiveInterruptsFromTasks(tasks) {
 		activeIds
 	};
 }
+/**
+* Run id from a `synth:<run_id>:...` event id, the form the agent server
+* uses for events it synthesizes such as root `lifecycle`. Events carry no
+* run id field.
+*/
+function synthesizedEventRunId(eventId) {
+	if (eventId == null || !eventId.startsWith("synth:")) return void 0;
+	return eventId.split(":")[1] || void 0;
+}
 //#endregion
 export { ROOT_PUMP_CHANNELS, StreamController };