@langchain/langgraph-sdk 1.12.3 → 1.12.5

package/dist/stream/controller.cjs

@@ -172,6 +172,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
@@ -243,6 +251,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
@@ -302,7 +320,8 @@ var StreamController = class {
 		this.#lifecycleLoading = new require_lifecycle_loading_tracker.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 require_store.StreamStore(require_queue_adapter.EMPTY_QUEUE);
@@ -337,6 +356,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);
@@ -496,6 +520,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) {
 				/**
@@ -534,6 +560,11 @@ var StreamController = class {
 				const seedMessages = state.values[this.#messagesKey];
 				if (Array.isArray(seedMessages)) {
 					this.#subagents.seedFromCheckpointMessages(seedMessages);
+					const finishedToolCalls = require_tool_calls.seedToolCallsFromMessages(ROOT_NAMESPACE, require_message_coercion.ensureMessageInstances(seedMessages)).filter((toolCall) => toolCall.status === "finished");
+					if (finishedToolCalls.length > 0) this.rootStore.setState((s) => ({
+						...s,
+						toolCalls: finishedToolCalls.reduce((toolCalls, toolCall) => require_tool_calls.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
@@ -561,7 +592,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);
 			}
 			/**
@@ -913,6 +944,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 {}
@@ -928,9 +966,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;
@@ -1348,6 +1389,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();
@@ -1587,6 +1629,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
@@ -1662,7 +1706,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.
@@ -2008,9 +2077,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?.();
@@ -2022,6 +2094,12 @@ var StreamController = class {
 				if (settled) return;
 				if (event.method !== "lifecycle") return;
 				if (!require_namespace.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;
@@ -2037,6 +2115,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({
@@ -2131,6 +2213,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
 exports.ROOT_PUMP_CHANNELS = ROOT_PUMP_CHANNELS;
 exports.StreamController = StreamController;