@langchain/langgraph 1.3.6 → 1.4.0

package/dist/pregel/loop.cjs

@@ -7,12 +7,72 @@ const require_io = require("./io.cjs");
 const require_index = require("./utils/index.cjs");
 const require_algo = require("./algo.cjs");
 const require_debug = require("./debug.cjs");
+const require_replay = require("./replay.cjs");
 const require_stream = require("./stream.cjs");
 let _langchain_langgraph_checkpoint = require("@langchain/langgraph-checkpoint");
+let uuid = require("uuid");
+let _langchain_core_messages = require("@langchain/core/messages");
 //#region src/pregel/loop.ts
 const INPUT_DONE = Symbol.for("INPUT_DONE");
 const INPUT_RESUMING = Symbol.for("INPUT_RESUMING");
 const DEFAULT_LOOP_LIMIT = 25;
+/**
+* Recursively assign a stable UUID to any {@link BaseMessage} (in a value, an
+* array, or an object's values) that is missing an `id`. Used so DeltaChannel
+* writes — replayed on every read — reconstruct identical message identities.
+*/
+function ensureMessageIds(value) {
+	if (value == null || typeof value !== "object") return;
+	if (_langchain_core_messages.BaseMessage.isInstance(value)) {
+		const msg = value;
+		if (msg.id == null) {
+			msg.id = (0, uuid.v4)();
+			if (msg.lc_kwargs != null) msg.lc_kwargs.id = msg.id;
+		}
+		return;
+	}
+	if (Array.isArray(value)) {
+		for (const item of value) ensureMessageIds(item);
+		return;
+	}
+}
+/**
+* Split a serialized checkpoint namespace into its path segments.
+*
+* Checkpoint namespaces are stored as a single string whose nested levels are
+* joined by {@link CHECKPOINT_NAMESPACE_SEPARATOR} (e.g. `"parent|child"`).
+* The root namespace — represented as `undefined` or the empty string — maps
+* to an empty array.
+*
+* @param ns - The serialized checkpoint namespace, or `undefined`.
+* @returns The namespace as an array of path segments (`[]` for the root).
+*/
+function checkpointNamespaceFromNs(ns) {
+	if (ns === void 0 || ns === "") return [];
+	return ns.split("|");
+}
+/**
+* Find the most deeply nested namespace recorded in a checkpoint map.
+*
+* The checkpoint map ({@link CONFIG_KEY_CHECKPOINT_MAP}) associates every
+* namespace seen on a thread with its checkpoint id. Because nested namespaces
+* are built by appending segments to their parent, a deeper namespace always
+* yields a longer key — so the longest non-empty key is the deepest one.
+*
+* Used by the loop's `#interruptStreamNamespace()` during subgraph
+* time-travel: interrupt events must be emitted against the active (deepest)
+* subgraph namespace rather than the root graph.
+*
+* @param map - The checkpoint map (namespace -> checkpoint id), or `undefined`.
+* @returns The deepest namespace as path segments, or `[]` when the map is
+*   absent, empty, or only contains the root namespace.
+*/
+function deepestCheckpointMapNamespace(map) {
+	if (!map) return [];
+	let deepest = "";
+	for (const key of Object.keys(map)) if (key !== "" && key.length > deepest.length) deepest = key;
+	return checkpointNamespaceFromNs(deepest);
+}
 var AsyncBatchedCache = class extends _langchain_langgraph_checkpoint.BaseCache {
 	cache;
 	queue = Promise.resolve();
@@ -49,6 +109,15 @@ var PregelLoop = class PregelLoop {
 	channels;
 	checkpoint;
 	checkpointIdSaved;
+	/**
+	* Exit-mode accumulator of DeltaChannel writes across the whole run, as
+	* `[step, taskId, channel, value]`. `undefined` outside "exit" durability.
+	*/
+	_exitDeltaWrites;
+	/** Whether a real checkpoint was loaded from the saver at initialization. */
+	_hasPersistedParent = false;
+	/** The checkpointConfig as captured at initialization (anchor for exit writes). */
+	_initialCheckpointConfig;
 	checkpointConfig;
 	checkpointMetadata;
 	checkpointNamespace;
@@ -64,10 +133,18 @@ var PregelLoop = class PregelLoop {
 	prevCheckpointConfig;
 	updatedChannels;
 	status = "pending";
+	/**
+	* Run-scoped control surface for cooperative draining. Populated from the
+	* run config. When `control.drainRequested` is true, the loop stops at the
+	* next superstep boundary instead of dispatching more tasks.
+	*/
+	control;
 	tasks = {};
 	stream;
 	checkpointerPromises = /* @__PURE__ */ new Set();
 	isNested;
+	/** True when an explicit checkpoint_id targets the latest saved checkpoint. */
+	resumeAtHead;
 	_checkpointerChainedPromise = Promise.resolve();
 	/**
 	* Track a checkpointer promise, removing it from the set on success.
@@ -107,6 +184,9 @@ var PregelLoop = class PregelLoop {
 		const runIdMatchesPrevious = !this.isNested && this.config.metadata?.run_id !== void 0 && this.checkpointMetadata?.run_id !== void 0 && this.config.metadata.run_id === this.checkpointMetadata?.run_id;
 		return hasChannelVersions && (configIsResuming || inputIsNullOrUndefined || inputIsCommandResuming || inputIsResuming || runIdMatchesPrevious);
 	}
+	get isReplaying() {
+		return !this.skipDoneTasks;
+	}
 	constructor(params) {
 		this.input = params.input;
 		this.checkpointer = params.checkpointer;
@@ -122,6 +202,7 @@ var PregelLoop = class PregelLoop {
 		this.config = params.config;
 		this.checkpointConfig = params.checkpointConfig;
 		this.isNested = params.isNested;
+		this.resumeAtHead = params.resumeAtHead;
 		this.manager = params.manager;
 		this.outputKeys = params.outputKeys;
 		this.streamKeys = params.streamKeys;
@@ -137,6 +218,11 @@ var PregelLoop = class PregelLoop {
 		this.durability = params.durability;
 		this.debug = params.debug;
 		this.triggerToNodes = params.triggerToNodes;
+		this.control = this.config.control;
+		this._exitDeltaWrites = this.durability === "exit" && this.checkpointer != null ? [] : void 0;
+		this._hasPersistedParent = params.hasPersistedParent ?? false;
+		this._initialCheckpointConfig = params.checkpointConfig;
+		this.checkpointIdSaved = params.checkpoint.id;
 	}
 	static async initialize(params) {
 		let { config, stream } = params;
@@ -147,15 +233,24 @@ var PregelLoop = class PregelLoop {
 			if (scratchpad.subgraphCounter > 0) config = require_index.patchConfigurable(config, { [require_constants.CONFIG_KEY_CHECKPOINT_NS]: [config.configurable[require_constants.CONFIG_KEY_CHECKPOINT_NS], scratchpad.subgraphCounter.toString()].join("|") });
 			scratchpad.subgraphCounter += 1;
 		}
+		const requestedCheckpointId = config.configurable?.checkpoint_id;
 		const isNested = require_constants.CONFIG_KEY_READ in (config.configurable ?? {});
 		if (!isNested && config.configurable?.checkpoint_ns !== void 0 && config.configurable?.checkpoint_ns !== "") config = require_index.patchConfigurable(config, {
 			checkpoint_ns: "",
 			checkpoint_id: void 0
 		});
 		let checkpointConfig = config;
-		if (config.configurable?.["checkpoint_map"] !== void 0 && config.configurable?.["checkpoint_map"]?.[config.configurable?.checkpoint_ns]) checkpointConfig = require_index.patchConfigurable(config, { checkpoint_id: config.configurable[require_constants.CONFIG_KEY_CHECKPOINT_MAP][config.configurable?.checkpoint_ns] });
-		const checkpointNamespace = config.configurable?.checkpoint_ns?.split("|") ?? [];
-		const saved = await params.checkpointer?.getTuple(checkpointConfig) ?? {
+		if (config.configurable?.checkpoint_id === void 0 && config.configurable?.["checkpoint_map"] !== void 0 && config.configurable?.["checkpoint_map"]?.[config.configurable?.checkpoint_ns]) checkpointConfig = require_index.patchConfigurable(config, { checkpoint_id: config.configurable[require_constants.CONFIG_KEY_CHECKPOINT_MAP][config.configurable?.checkpoint_ns] });
+		const checkpointNamespace = checkpointNamespaceFromNs(config.configurable?.checkpoint_ns);
+		let saved;
+		if (!params.checkpointer) saved = void 0;
+		else if (checkpointConfig.configurable?.["checkpoint_id"]) saved = await params.checkpointer.getTuple(checkpointConfig);
+		else if (config.configurable?.["__pregel_replay_state"]) {
+			saved = await config.configurable[require_constants.CONFIG_KEY_REPLAY_STATE].getCheckpoint(config.configurable?.["checkpoint_ns"] ?? "", params.checkpointer, checkpointConfig);
+			if (config.configurable) delete config.configurable[require_constants.CONFIG_KEY_RESUMING];
+		} else saved = await params.checkpointer.getTuple(checkpointConfig);
+		const hasPersistedParent = saved !== void 0;
+		if (!saved) saved = {
 			config,
 			checkpoint: (0, _langchain_langgraph_checkpoint.emptyCheckpoint)(),
 			metadata: {
@@ -177,8 +272,21 @@ var PregelLoop = class PregelLoop {
 		const prevCheckpointConfig = saved.parentConfig;
 		const checkpoint = (0, _langchain_langgraph_checkpoint.copyCheckpoint)(saved.checkpoint);
 		const checkpointMetadata = { ...saved.metadata };
-		const checkpointPendingWrites = saved.pendingWrites ?? [];
-		const channels = require_base.emptyChannels(params.channelSpecs, checkpoint);
+		let checkpointPendingWrites = saved.pendingWrites ?? [];
+		const currentCheckpointNamespace = config.configurable?.checkpoint_ns;
+		const checkpointMap = config.configurable?.[require_constants.CONFIG_KEY_CHECKPOINT_MAP];
+		if (typeof currentCheckpointNamespace === "string" && currentCheckpointNamespace !== "" && typeof checkpointMap === "object" && checkpointMap !== null && currentCheckpointNamespace in checkpointMap && checkpointPendingWrites.length > 0) checkpointPendingWrites = checkpointPendingWrites.filter(([, channel]) => channel !== require_constants.RESUME);
+		let resumeAtHead = false;
+		const threadId = checkpointConfig.configurable?.thread_id;
+		const checkpointNs = checkpointConfig.configurable?.checkpoint_ns ?? "";
+		if (params.checkpointer && requestedCheckpointId && typeof threadId === "string") resumeAtHead = (await params.checkpointer.getTuple({ configurable: {
+			thread_id: threadId,
+			checkpoint_ns: checkpointNs
+		} }))?.config.configurable?.checkpoint_id === requestedCheckpointId && checkpointMetadata.source !== "update" && checkpointMetadata.source !== "fork";
+		const channels = await require_base.channelsFromCheckpoint(params.channelSpecs, checkpoint, {
+			saver: params.checkpointer,
+			config: checkpointConfig
+		});
 		const step = (checkpointMetadata.step ?? 0) + 1;
 		const stop = step + (config.recursionLimit ?? DEFAULT_LOOP_LIMIT) + 1;
 		const checkpointPreviousVersions = { ...checkpoint.channel_versions };
@@ -195,6 +303,7 @@ var PregelLoop = class PregelLoop {
 			checkpointNamespace,
 			channels,
 			isNested,
+			resumeAtHead,
 			manager: params.manager,
 			skipDoneTasks,
 			step,
@@ -211,7 +320,8 @@ var PregelLoop = class PregelLoop {
 			interruptBefore: params.interruptBefore,
 			durability: params.durability,
 			debug: params.debug,
-			triggerToNodes: params.triggerToNodes
+			triggerToNodes: params.triggerToNodes,
+			hasPersistedParent
 		});
 	}
 	_checkpointerPutAfterPrevious(input) {
@@ -250,6 +360,10 @@ var PregelLoop = class PregelLoop {
 			c,
 			v
 		]);
+		for (const [c, v] of writesToSave) {
+			const channel = this.channels[c];
+			if (channel != null && require_base.isDeltaChannel(channel)) ensureMessageIds(v);
+		}
 		const config = require_index.patchConfigurable(this.checkpointConfig, {
 			[require_constants.CONFIG_KEY_CHECKPOINT_NS]: this.config.configurable?.checkpoint_ns ?? "",
 			[require_constants.CONFIG_KEY_CHECKPOINT_ID]: this.checkpoint.id
@@ -309,7 +423,8 @@ var PregelLoop = class PregelLoop {
 	/**
 	* Execute a single iteration of the Pregel loop.
 	* Returns true if more iterations are needed.
-	* @param params
+	* @param params - The input keys to use for the tick.
+	* @returns True if more iterations are needed, false otherwise.
 	*/
 	async tick(params) {
 		if (this.store && !this.store.isRunning) await this.store?.start();
@@ -320,13 +435,23 @@ var PregelLoop = class PregelLoop {
 			this.status = "interrupt_before";
 			throw new require_errors.GraphInterrupt();
 		} else if (Object.values(this.tasks).every((task) => task.writes.length > 0)) {
-			const writes = Object.values(this.tasks).flatMap((t) => t.writes);
-			this.updatedChannels = require_algo._applyWrites(this.checkpoint, this.channels, Object.values(this.tasks), this.checkpointerGetNextVersion, this.triggerToNodes);
+			const finishTaskList = Object.values(this.tasks);
+			const writes = finishTaskList.flatMap((t) => t.writes);
+			this.updatedChannels = require_algo._applyWrites(this.checkpoint, this.channels, finishTaskList, this.checkpointerGetNextVersion, this.triggerToNodes);
 			const valuesOutput = await require_utils.gatherIterator(require_utils.prefixGenerator(require_io.mapOutputValues(this.outputKeys, writes, this.channels), "values"));
+			if (this._exitDeltaWrites !== void 0) for (const [tid, ch, v] of this.checkpointPendingWrites) {
+				const channel = this.channels[ch];
+				if (channel != null && require_base.isDeltaChannel(channel)) this._exitDeltaWrites.push([
+					this.step,
+					tid,
+					ch,
+					v
+				]);
+			}
 			this.checkpointPendingWrites = [];
 			await this._putCheckpoint({ source: "loop" });
 			this._emitValuesWithCheckpointMeta(valuesOutput);
-			if (require_algo.shouldInterrupt(this.checkpoint, this.interruptAfter, Object.values(this.tasks))) {
+			if (require_algo.shouldInterrupt(this.checkpoint, this.interruptAfter, finishTaskList)) {
 				this.status = "interrupt_after";
 				throw new require_errors.GraphInterrupt();
 			}
@@ -346,30 +471,40 @@ var PregelLoop = class PregelLoop {
 			triggerToNodes: this.triggerToNodes,
 			updatedChannels: this.updatedChannels
 		});
-		if (this.checkpointer) this._emit(await require_utils.gatherIterator(require_utils.prefixGenerator(require_debug.mapDebugCheckpoint(this.checkpointConfig, this.channels, this.streamKeys, this.checkpointMetadata, Object.values(this.tasks), this.checkpointPendingWrites, this.prevCheckpointConfig, this.outputKeys), "checkpoints")));
-		if (Object.values(this.tasks).length === 0) {
+		let taskList = Object.values(this.tasks);
+		if (this.checkpointer && (this.stream.modes.has("checkpoints") || this.stream.modes.has("debug"))) this._emit(await require_utils.gatherIterator(require_utils.prefixGenerator(require_debug.mapDebugCheckpoint(this.checkpointConfig, this.channels, this.streamKeys, this.checkpointMetadata, taskList, this.checkpointPendingWrites, this.prevCheckpointConfig, this.outputKeys), "checkpoints")));
+		if (taskList.length === 0) {
 			this.status = "done";
 			return false;
 		}
+		if (this.control != null && this.control.drainRequested) {
+			this.status = "draining";
+			return false;
+		}
 		if (this.skipDoneTasks && this.checkpointPendingWrites.length > 0) {
 			for (const [tid, k, v] of this.checkpointPendingWrites) {
-				if (k === "__error__" || k === "__interrupt__" || k === "__resume__") continue;
-				const task = Object.values(this.tasks).find((t) => t.id === tid);
+				if (k === "__error__" || k === "__error_source_node__" || k === "__interrupt__" || k === "__resume__") continue;
+				const task = taskList.find((t) => t.id === tid);
 				if (task) task.writes.push([k, v]);
 			}
-			for (const task of Object.values(this.tasks)) if (task.writes.length > 0) this._outputWrites(task.id, task.writes, true);
+			this._resumeErrorHandlersIfApplicable();
+			taskList = Object.values(this.tasks);
+			for (const task of taskList) if (task.writes.length > 0) this._outputWrites(task.id, task.writes, true);
 		}
-		if (Object.values(this.tasks).every((task) => task.writes.length > 0)) return this.tick({ inputKeys });
-		if (require_algo.shouldInterrupt(this.checkpoint, this.interruptBefore, Object.values(this.tasks))) {
+		if (taskList.every((task) => task.writes.length > 0)) return this.tick({ inputKeys });
+		if (require_algo.shouldInterrupt(this.checkpoint, this.interruptBefore, taskList)) {
 			this.status = "interrupt_before";
 			throw new require_errors.GraphInterrupt();
 		}
-		const debugOutput = await require_utils.gatherIterator(require_utils.prefixGenerator(require_debug.mapDebugTasks(Object.values(this.tasks)), "tasks"));
-		this._emit(debugOutput);
+		if (this.stream.modes.has("tasks") || this.stream.modes.has("debug")) {
+			const debugOutput = await require_utils.gatherIterator(require_utils.prefixGenerator(require_debug.mapDebugTasks(taskList), "tasks"));
+			this._emit(debugOutput);
+		}
 		return true;
 	}
 	async finishAndHandleError(error) {
 		if (this.durability === "exit" && (!this.isNested || typeof error !== "undefined" || this.checkpointNamespace.every((part) => !part.includes(":")))) {
+			await this._putExitDeltaWrites();
 			this._putCheckpoint(this.checkpointMetadata);
 			this._flushPendingWrites();
 		}
@@ -380,7 +515,7 @@ var PregelLoop = class PregelLoop {
 				this.updatedChannels = require_algo._applyWrites(this.checkpoint, this.channels, Object.values(this.tasks), this.checkpointerGetNextVersion, this.triggerToNodes);
 				this._emitValuesWithCheckpointMeta(require_utils.gatherIteratorSync(require_utils.prefixGenerator(require_io.mapOutputValues(this.outputKeys, Object.values(this.tasks).flatMap((t) => t.writes), this.channels), "values")));
 			}
-			if (require_errors.isGraphInterrupt(error) && !error.interrupts.length) this._emit([["updates", { [require_constants.INTERRUPT]: [] }], ["values", { [require_constants.INTERRUPT]: [] }]]);
+			if (require_errors.isGraphInterrupt(error) && !error.interrupts.length) this._emit([["updates", { [require_constants.INTERRUPT]: [] }], ["values", { [require_constants.INTERRUPT]: [] }]], this.#interruptStreamNamespace());
 		}
 		return suppress;
 	}
@@ -407,7 +542,7 @@ var PregelLoop = class PregelLoop {
 			this.toInterrupt.push(pushed);
 			return;
 		}
-		this._emit(require_utils.gatherIteratorSync(require_utils.prefixGenerator(require_debug.mapDebugTasks([pushed]), "tasks")));
+		if (this.stream.modes.has("tasks") || this.stream.modes.has("debug")) this._emit(require_utils.gatherIteratorSync(require_utils.prefixGenerator(require_debug.mapDebugTasks([pushed]), "tasks")));
 		if (this.debug) require_debug.printStepTasks(this.step, [pushed]);
 		this.tasks[pushed.id] = pushed;
 		if (this.skipDoneTasks) this._matchWrites({ [pushed.id]: pushed });
@@ -415,6 +550,74 @@ var PregelLoop = class PregelLoop {
 		for (const { task } of tasks) this._outputWrites(task.id, task.writes, true);
 		return pushed;
 	}
+	/**
+	* Returns the name of the error handler node registered for `nodeName`, or
+	* `undefined` if none is configured.
+	*/
+	getErrorHandlerNode(nodeName) {
+		return this.nodes[nodeName]?.errorHandlerNode;
+	}
+	/**
+	* Whether `nodeName` is itself an auto-generated error handler node.
+	*/
+	isErrorHandlerNode(nodeName) {
+		return this.nodes[nodeName]?.isErrorHandler === true;
+	}
+	/**
+	* Schedule a node-level error handler task for a task that failed after its
+	* retry policy was exhausted. Prepares the handler task (injecting a
+	* {@link NodeError}), registers it so the runner executes it within the
+	* current step, and returns it (or `undefined` if no handler applies).
+	*
+	* The failure provenance (`ERROR` + `ERROR_SOURCE_NODE`) is checkpointed by
+	* the runner via {@link PregelLoop#putWrites} so handlers observe the same
+	* context after a resume.
+	*/
+	scheduleErrorHandler(failedTask, error) {
+		const handlerNode = this.getErrorHandlerNode(String(failedTask.name));
+		if (!handlerNode) return void 0;
+		const handlerTask = require_algo._prepareNodeErrorHandlerTask(failedTask, handlerNode, error, this.checkpoint, this.checkpointPendingWrites, this.nodes, this.channels, failedTask.config ?? this.config, {
+			step: this.step,
+			checkpointer: this.checkpointer,
+			manager: this.manager,
+			store: this.store,
+			stream: this.stream
+		});
+		if (handlerTask === void 0) return void 0;
+		this.tasks[handlerTask.id] = handlerTask;
+		this._emit(require_utils.gatherIteratorSync(require_utils.prefixGenerator(require_debug.mapDebugTasks([handlerTask]), "tasks")));
+		if (this.debug) require_debug.printStepTasks(this.step, [handlerTask]);
+		return handlerTask;
+	}
+	/**
+	* On resume, re-schedule error handlers for tasks that failed in a prior run
+	* but had not finished being handled. Scans pending writes for
+	* `ERROR_SOURCE_NODE` markers (paired with `ERROR`), marks the originating
+	* task as done (so the runner won't re-run it), and prepares a fresh handler
+	* task so the runner picks it up.
+	*/
+	_resumeErrorHandlersIfApplicable() {
+		const failed = /* @__PURE__ */ new Map();
+		for (const [tid, chan] of this.checkpointPendingWrites) {
+			if (chan !== "__error_source_node__") continue;
+			const errorWrite = this.checkpointPendingWrites.find(([t, c]) => t === tid && c === "__error__");
+			if (errorWrite === void 0) continue;
+			const value = errorWrite[2];
+			const error = new Error(value?.message ?? String(value));
+			if (value?.name) error.name = value.name;
+			failed.set(tid, error);
+		}
+		for (const [tid, error] of failed) {
+			const task = this.tasks[tid];
+			if (task === void 0) continue;
+			if (!this.getErrorHandlerNode(String(task.name))) continue;
+			if (task.writes.length === 0) task.writes.push([require_constants.ERROR, {
+				message: error.message,
+				name: error.name
+			}]);
+			this.scheduleErrorHandler(task, error);
+		}
+	}
 	_suppressInterrupt(e) {
 		return require_errors.isGraphInterrupt(e) && !this.isNested;
 	}
@@ -443,20 +646,24 @@ var PregelLoop = class PregelLoop {
 			writes: nullWrites,
 			triggers: []
 		}], this.checkpointerGetNextVersion, this.triggerToNodes);
-		const isCommandUpdateOrGoto = require_constants.isCommand(this.input) && nullWrites.length > 0;
-		if (this.isResuming || isCommandUpdateOrGoto) {
+		const inputIsCommand = require_constants.isCommand(this.input);
+		const isCommandUpdateOrGoto = inputIsCommand && nullWrites.length > 0;
+		const isTimeTraveling = this.isReplaying && (this.isNested && configurable?.["checkpoint_ns"] !== void 0 && configurable?.["checkpoint_ns"] !== "" && configurable?.["checkpoint_map"] !== void 0 && configurable["checkpoint_ns"] in configurable["checkpoint_map"] || !(inputIsCommand && this.input.resume != null || configurable?.["__pregel_resuming"] === true || this.resumeAtHead));
+		if (isTimeTraveling) this.checkpointPendingWrites = this.checkpointPendingWrites.filter((w) => w[1] !== require_constants.RESUME);
+		const cachedIsResuming = this.isResuming;
+		if (cachedIsResuming || isCommandUpdateOrGoto) {
+			const interruptSeen = { ...this.checkpoint.versions_seen[require_constants.INTERRUPT] };
 			for (const channelName in this.channels) {
 				if (!Object.prototype.hasOwnProperty.call(this.channels, channelName)) continue;
-				if (this.checkpoint.channel_versions[channelName] !== void 0) {
-					const version = this.checkpoint.channel_versions[channelName];
-					this.checkpoint.versions_seen[require_constants.INTERRUPT] = {
-						...this.checkpoint.versions_seen[require_constants.INTERRUPT],
-						[channelName]: version
-					};
-				}
+				if (this.checkpoint.channel_versions[channelName] !== void 0) interruptSeen[channelName] = this.checkpoint.channel_versions[channelName];
+			}
+			this.checkpoint.versions_seen[require_constants.INTERRUPT] = interruptSeen;
+			if (isTimeTraveling && this.checkpointMetadata.source !== "update" && this.checkpointMetadata.source !== "fork") {
+				this.checkpointPendingWrites = this.checkpointPendingWrites.filter((w) => w[1] !== require_constants.INTERRUPT);
+				await this._putCheckpoint({ source: "fork" });
 			}
 			const valuesOutput = await require_utils.gatherIterator(require_utils.prefixGenerator(require_io.mapOutputValues(this.outputKeys, true, this.channels), "values"));
-			if (this.isResuming) this.input = INPUT_RESUMING;
+			if (cachedIsResuming) this.input = INPUT_RESUMING;
 			else if (isCommandUpdateOrGoto) {
 				await this._putCheckpoint({ source: "input" });
 				this.input = INPUT_DONE;
@@ -471,17 +678,47 @@ var PregelLoop = class PregelLoop {
 					writes: inputWrites,
 					triggers: []
 				}]), this.checkpointerGetNextVersion, this.triggerToNodes);
+				const deltaInput = inputWrites.filter(([c]) => {
+					const channel = this.channels[c];
+					return channel != null && require_base.isDeltaChannel(channel);
+				});
+				if (deltaInput.length > 0) {
+					if (this._exitDeltaWrites !== void 0) for (const [c, v] of deltaInput) this._exitDeltaWrites.push([
+						this.step,
+						require_constants.NULL_TASK_ID,
+						c,
+						v
+					]);
+					else if (this.checkpointer != null) this.putWrites(require_constants.NULL_TASK_ID, deltaInput);
+				}
 				await this._putCheckpoint({ source: "input" });
 				this.input = INPUT_DONE;
 			} else if (!("__pregel_resuming" in (this.config.configurable ?? {}))) throw new require_errors.EmptyInputError(`Received no input writes for ${JSON.stringify(inputKeys, null, 2)}`);
 			else this.input = INPUT_DONE;
 		}
-		if (!this.isNested) this.config = require_index.patchConfigurable(this.config, { [require_constants.CONFIG_KEY_RESUMING]: this.isResuming });
+		if (!this.isNested) {
+			let replayState;
+			if (isTimeTraveling) {
+				let replayCheckpointId = this.checkpoint.id;
+				if ((this.checkpointMetadata.source === "update" || this.checkpointMetadata.source === "fork") && this.prevCheckpointConfig) replayCheckpointId = this.prevCheckpointConfig.configurable?.["checkpoint_id"] ?? replayCheckpointId;
+				replayState = new require_replay.ReplayState(replayCheckpointId);
+			}
+			this.config = require_index.patchConfigurable(this.config, {
+				[require_constants.CONFIG_KEY_RESUMING]: this.isResuming,
+				[require_constants.CONFIG_KEY_REPLAY_STATE]: replayState
+			});
+		}
+	}
+	#interruptStreamNamespace() {
+		const ns = this.checkpointNamespace;
+		if (!(ns.length === 0 || ns.length === 1 && ns[0] === "") || this.config.configurable?.["__pregel_stream"] === void 0) return ns;
+		const deepest = deepestCheckpointMapNamespace(this.config.configurable?.[require_constants.CONFIG_KEY_CHECKPOINT_MAP]);
+		return deepest.length > 0 ? deepest : ns;
 	}
-	_emit(values) {
+	_emit(values, namespace = this.checkpointNamespace) {
 		for (const [mode, payload] of values) {
 			if (this.stream.modes.has(mode)) this.stream.push([
-				this.checkpointNamespace,
+				namespace,
 				mode,
 				payload
 			]);
@@ -494,7 +731,7 @@ var PregelLoop = class PregelLoop {
 					else return "task";
 				})();
 				this.stream.push([
-					this.checkpointNamespace,
+					namespace,
 					"debug",
 					{
 						step,
@@ -564,15 +801,99 @@ var PregelLoop = class PregelLoop {
 				}
 			};
 		};
-		if (!exiting) this.checkpointMetadata = {
-			...inputMetadata,
-			step: this.step,
-			parents: this.config.configurable?.["checkpoint_map"] ?? {}
-		};
-		this.checkpoint = require_base.createCheckpoint(this.checkpoint, doCheckpoint ? this.channels : void 0, this.step, exiting ? { id: this.checkpoint.id } : void 0);
+		let newCounters;
+		if (!exiting) {
+			const prevCounters = this.checkpointMetadata.counters_since_delta_snapshot ?? {};
+			newCounters = {};
+			const updated = this.updatedChannels ?? /* @__PURE__ */ new Set();
+			for (const chName in this.channels) {
+				if (!Object.prototype.hasOwnProperty.call(this.channels, chName)) continue;
+				if (!require_base.isDeltaChannel(this.channels[chName])) continue;
+				const [u, s] = prevCounters[chName] ?? [0, 0];
+				newCounters[chName] = [updated.has(chName) ? u + 1 : u, s + 1];
+			}
+			this.checkpointMetadata = {
+				...inputMetadata,
+				step: this.step,
+				parents: this.config.configurable?.["checkpoint_map"] ?? {}
+			};
+		} else newCounters = { ...this.checkpointMetadata.counters_since_delta_snapshot ?? {} };
+		const channelsToSnapshot = doCheckpoint ? require_base.deltaChannelsToSnapshot(this.channels, newCounters) : /* @__PURE__ */ new Set();
+		this.checkpoint = require_base.createCheckpoint(this.checkpoint, doCheckpoint ? this.channels : void 0, this.step, {
+			id: exiting ? this.checkpoint.id : void 0,
+			channelsToSnapshot,
+			updatedChannels: this.updatedChannels,
+			getNextVersion: doCheckpoint ? (current) => this.checkpointerGetNextVersion(current) : void 0
+		});
+		for (const k of channelsToSnapshot) newCounters[k] = [0, 0];
+		const nonZero = {};
+		for (const k in newCounters) {
+			if (!Object.prototype.hasOwnProperty.call(newCounters, k)) continue;
+			const [u, s] = newCounters[k];
+			if (u !== 0 || s !== 0) nonZero[k] = [u, s];
+		}
+		if (Object.keys(nonZero).length > 0) this.checkpointMetadata.counters_since_delta_snapshot = nonZero;
+		else delete this.checkpointMetadata.counters_since_delta_snapshot;
 		if (doCheckpoint) storeCheckpoint(this.checkpoint);
 		if (!exiting) this.step += 1;
 	}
+	/**
+	* Stage the exit-mode accumulator of DeltaChannel writes so the final
+	* checkpoint can be reconstructed. In "exit" durability per-step writes are
+	* not persisted, so delta writes are accumulated across the run and anchored
+	* here — under the saved parent, or a freshly-created stub when this is a
+	* first run with no persisted parent. Channels that will snapshot in the
+	* final checkpoint are excluded (their full value lives in `channel_values`).
+	*
+	* Must run BEFORE the final `_putCheckpoint` so the stub branch can adjust
+	* `checkpointConfig` to anchor the final checkpoint on the stub.
+	*/
+	async _putExitDeltaWrites() {
+		if (this._exitDeltaWrites === void 0 || this._exitDeltaWrites.length === 0 || this.checkpointer == null || this._initialCheckpointConfig === void 0) return;
+		const counters = this.checkpointMetadata.counters_since_delta_snapshot ?? {};
+		const channelsToSnapshot = require_base.deltaChannelsToSnapshot(this.channels, counters);
+		const pending = this._exitDeltaWrites.filter(([, , ch]) => !channelsToSnapshot.has(ch));
+		if (pending.length === 0) return;
+		let anchorConfig;
+		if (this._hasPersistedParent) anchorConfig = this._initialCheckpointConfig;
+		else {
+			const stubCp = (0, _langchain_langgraph_checkpoint.emptyCheckpoint)();
+			stubCp.id = this.checkpointIdSaved ?? stubCp.id;
+			stubCp.ts = (/* @__PURE__ */ new Date()).toISOString();
+			const stubPutConfig = require_index.patchConfigurable(this._initialCheckpointConfig, { [require_constants.CONFIG_KEY_CHECKPOINT_ID]: void 0 });
+			anchorConfig = require_index.patchConfigurable(this._initialCheckpointConfig, { [require_constants.CONFIG_KEY_CHECKPOINT_ID]: stubCp.id });
+			this._trackCheckpointerPromise(this.checkpointer.put(stubPutConfig, stubCp, {
+				source: "loop",
+				step: -2,
+				parents: {}
+			}, {}));
+			this.checkpointConfig = anchorConfig;
+		}
+		const anchorWriteConfig = require_index.patchConfigurable(anchorConfig, {
+			[require_constants.CONFIG_KEY_CHECKPOINT_NS]: this.config.configurable?.checkpoint_ns ?? "",
+			[require_constants.CONFIG_KEY_CHECKPOINT_ID]: anchorConfig.configurable?.[require_constants.CONFIG_KEY_CHECKPOINT_ID]
+		});
+		const grouped = /* @__PURE__ */ new Map();
+		const order = [];
+		for (const [step, tid, ch, v] of pending) {
+			const key = `${step}\u0000${tid}`;
+			let group = grouped.get(key);
+			if (group === void 0) {
+				group = [];
+				grouped.set(key, group);
+				order.push({
+					key,
+					step,
+					tid
+				});
+			}
+			group.push([ch, v]);
+		}
+		for (const { key, step, tid } of order) {
+			const synthTid = `${String(step).padStart(8, "0")}-${tid}`;
+			this._trackCheckpointerPromise(this.checkpointer.putWrites(anchorWriteConfig, grouped.get(key), synthTid));
+		}
+	}
 	_flushPendingWrites() {
 		if (this.checkpointer == null) return;
 		if (this.checkpointPendingWrites.length === 0) return;