@librechat/agents 3.7.1 → 3.7.3

package/dist/cjs/eventActor/EventActorExecutor.cjs

@@ -0,0 +1,797 @@
+let _langchain_langgraph = require("@langchain/langgraph");
+let node_crypto = require("node:crypto");
+let _langchain_core_singletons = require("@langchain/core/singletons");
+//#region src/eventActor/EventActorExecutor.ts
+const DEFAULT_MAX_DEPTH = 1;
+const DEFAULT_DORMANT_CHECKPOINT_TTL_MS = 1440 * 60 * 1e3;
+function createInvocationCheckpointNs(request, attemptId = (0, node_crypto.randomUUID)()) {
+	return `event-actor/${(0, node_crypto.createHash)("sha256").update(request.actorThreadId).update("\0").update(request.invocationId).update("\0").update(attemptId).digest("hex").slice(0, 32)}`;
+}
+function snapshotEvent(event) {
+	const ancestors = /* @__PURE__ */ new WeakSet();
+	const clone = (value) => {
+		if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+		if (typeof value === "number") {
+			if (!Number.isFinite(value)) throw new Error("Event actor event numbers must be finite");
+			return Object.is(value, -0) ? 0 : value;
+		}
+		if (typeof value !== "object") throw new Error("Event actor events must contain only JSON values");
+		if (ancestors.has(value)) throw new Error("Event actor events must not contain cycles");
+		ancestors.add(value);
+		try {
+			if (Array.isArray(value)) {
+				if (Object.getOwnPropertySymbols(value).length > 0) throw new Error("Event actor event arrays must not contain symbols");
+				const snapshot = [];
+				for (let index = 0; index < value.length; index += 1) {
+					if (!Object.hasOwn(value, index)) throw new Error("Event actor event arrays must not contain holes");
+					snapshot.push(clone(value[index]));
+				}
+				if (Object.keys(value).length !== value.length) throw new Error("Event actor event arrays must not contain named properties");
+				return Object.freeze(snapshot);
+			}
+			const prototype = Object.getPrototypeOf(value);
+			if (prototype !== Object.prototype && prototype !== null) throw new Error("Event actor events must contain only JSON objects");
+			if (Object.getOwnPropertySymbols(value).length > 0) throw new Error("Event actor events must not contain symbol keys");
+			const snapshot = {};
+			for (const key of Object.keys(value).sort()) {
+				const item = value[key];
+				Object.defineProperty(snapshot, key, {
+					configurable: false,
+					enumerable: true,
+					writable: false,
+					value: clone(item)
+				});
+			}
+			return Object.freeze(snapshot);
+		} finally {
+			ancestors.delete(value);
+		}
+	};
+	return clone(event);
+}
+function snapshotCheckpointReference(checkpoint) {
+	return {
+		threadId: checkpoint.threadId,
+		...checkpoint.checkpointId == null ? {} : { checkpointId: checkpoint.checkpointId },
+		checkpointNs: checkpoint.checkpointNs
+	};
+}
+function snapshotCheckpointFork(checkpoint) {
+	return {
+		...snapshotCheckpointReference(checkpoint),
+		invocationId: checkpoint.invocationId
+	};
+}
+function snapshotHead(head) {
+	return {
+		actorThreadId: head.actorThreadId,
+		generation: Object.is(head.generation, -0) ? 0 : head.generation,
+		...head.checkpoint == null ? {} : { checkpoint: snapshotCheckpointReference(head.checkpoint) }
+	};
+}
+function snapshotInvocationReference(invocation) {
+	return {
+		actorThreadId: invocation.actorThreadId,
+		invocationId: invocation.invocationId,
+		depth: invocation.depth,
+		continuation: invocation.continuation,
+		base: snapshotHead(invocation.base),
+		fork: snapshotCheckpointFork(invocation.fork)
+	};
+}
+function snapshotInvocation(invocation) {
+	return {
+		...snapshotInvocationReference(invocation),
+		event: snapshotEvent(invocation.event)
+	};
+}
+function snapshotPrepareRequest(request) {
+	return {
+		actorThreadId: request.actorThreadId,
+		invocationId: request.invocationId,
+		depth: request.depth,
+		event: snapshotEvent(request.event)
+	};
+}
+function freezeInvocationReference(invocation) {
+	const snapshot = snapshotInvocationReference(invocation);
+	if (snapshot.base.checkpoint != null) Object.freeze(snapshot.base.checkpoint);
+	Object.freeze(snapshot.base);
+	Object.freeze(snapshot.fork);
+	return Object.freeze(snapshot);
+}
+function freezeInvocation(invocation) {
+	return Object.freeze({
+		...freezeInvocationReference(invocation),
+		event: snapshotEvent(invocation.event)
+	});
+}
+function snapshotPreparedInvocation(invocation) {
+	return Object.freeze({
+		...freezeInvocation(invocation),
+		preparationDigest: invocation.preparationDigest
+	});
+}
+function canonicalHead(head) {
+	if (head.checkpoint == null) return {
+		actorThreadId: head.actorThreadId,
+		generation: head.generation,
+		checkpoint: null
+	};
+	return {
+		actorThreadId: head.actorThreadId,
+		generation: head.generation,
+		checkpoint: {
+			threadId: head.checkpoint.threadId,
+			checkpointId: head.checkpoint.checkpointId ?? null,
+			checkpointNs: head.checkpoint.checkpointNs
+		}
+	};
+}
+function serializeInvocationPreparation(invocation) {
+	return JSON.stringify({
+		kind: "invocation",
+		actorThreadId: invocation.actorThreadId,
+		invocationId: invocation.invocationId,
+		depth: invocation.depth,
+		continuation: invocation.continuation,
+		base: canonicalHead(invocation.base),
+		fork: {
+			invocationId: invocation.fork.invocationId,
+			threadId: invocation.fork.threadId,
+			checkpointId: invocation.fork.checkpointId ?? null,
+			checkpointNs: invocation.fork.checkpointNs
+		},
+		event: snapshotEvent(invocation.event)
+	});
+}
+function serializeUnavailablePreparation(request, head) {
+	return JSON.stringify({
+		kind: "checkpoint_unavailable",
+		request: {
+			actorThreadId: request.actorThreadId,
+			invocationId: request.invocationId,
+			depth: request.depth,
+			event: snapshotEvent(request.event)
+		},
+		head: canonicalHead(head)
+	});
+}
+function freezePrepareRequest(request) {
+	return Object.freeze(snapshotPrepareRequest(request));
+}
+function freezeHead(head) {
+	const snapshot = snapshotHead(head);
+	if (snapshot.checkpoint != null) Object.freeze(snapshot.checkpoint);
+	return Object.freeze(snapshot);
+}
+function snapshotAmbientConfig(config) {
+	if (config == null) return;
+	return {
+		...config,
+		...config.tags == null ? {} : { tags: [...config.tags] },
+		...config.metadata == null ? {} : { metadata: { ...config.metadata } },
+		...config.configurable == null ? {} : { configurable: { ...config.configurable } }
+	};
+}
+function requireNonEmpty(value, name) {
+	if (value.trim() === "") throw new Error(`${name} must not be empty`);
+}
+function validateHead(head, actorThreadId, checkpointRequired = false) {
+	if (head.actorThreadId !== actorThreadId || !Number.isSafeInteger(head.generation) || head.generation < 0) throw new Error("Event actor head is invalid");
+	if (head.checkpoint == null) {
+		if (checkpointRequired) throw new Error("Committed event actor head has no checkpoint");
+		if (head.generation > 0) throw new Error("Advanced event actor head has no checkpoint");
+		return;
+	}
+	requireNonEmpty(head.checkpoint.threadId, "head.checkpoint.threadId");
+	if (typeof head.checkpoint.checkpointNs !== "string") throw new Error("head.checkpoint.checkpointNs must be a string");
+	requireNonEmpty(head.checkpoint.checkpointId ?? "", "head.checkpoint.checkpointId");
+}
+function validateInvocation(request, invocation, continuation, checkpointNs, maxDepth, expectedHead) {
+	validateInvocationReference(invocation, maxDepth);
+	if (invocation.actorThreadId !== request.actorThreadId || invocation.invocationId !== request.invocationId || invocation.depth !== request.depth || invocation.continuation !== continuation) throw new Error("Event actor preparation returned a mismatched invocation");
+	if (invocation.base.actorThreadId !== request.actorThreadId || invocation.fork.invocationId !== request.invocationId || invocation.fork.checkpointNs !== checkpointNs) throw new Error("Event actor preparation returned mismatched checkpoint ownership");
+	if (expectedHead != null && (expectedHead.actorThreadId !== request.actorThreadId || invocation.base.generation !== expectedHead.generation || invocation.base.checkpoint?.threadId !== expectedHead.checkpoint?.threadId || invocation.base.checkpoint?.checkpointId !== expectedHead.checkpoint?.checkpointId || invocation.base.checkpoint?.checkpointNs !== expectedHead.checkpoint?.checkpointNs)) throw new Error("Cold continuation did not use the prepared actor head");
+}
+function validateInvocationReference(invocation, maxDepth) {
+	requireNonEmpty(invocation.actorThreadId, "actorThreadId");
+	requireNonEmpty(invocation.invocationId, "invocationId");
+	if (!Number.isSafeInteger(invocation.depth) || invocation.depth < 1) throw new Error("Event actor invocation depth is invalid");
+	if (maxDepth != null && invocation.depth > maxDepth) throw new Error(`Event actor depth ${invocation.depth} exceeds maximum ${maxDepth}`);
+	const continuation = invocation.continuation;
+	if (continuation !== "warm" && continuation !== "cold") throw new Error("Event actor invocation continuation is invalid");
+	validateHead(invocation.base, invocation.actorThreadId);
+	if (invocation.fork.invocationId !== invocation.invocationId) throw new Error("Event actor invocation has mismatched checkpoint ownership");
+	requireNonEmpty(invocation.fork.threadId, "fork.threadId");
+	requireNonEmpty(invocation.fork.checkpointNs, "fork.checkpointNs");
+	if (invocation.base.checkpoint != null) {
+		if (invocation.fork.threadId !== invocation.base.checkpoint.threadId) throw new Error("Event actor fork changed its logical checkpoint thread");
+		requireNonEmpty(invocation.fork.checkpointId ?? "", "fork.checkpointId for resumed actor");
+		if (invocation.continuation === "warm" && invocation.fork.checkpointId !== invocation.base.checkpoint.checkpointId) throw new Error("Warm event actor fork did not start from the committed checkpoint");
+	}
+}
+function checkpointIdsMatch(left, right) {
+	return left != null && right != null && left.checkpointId === right.checkpointId;
+}
+function checkpointsMatch(left, right) {
+	return checkpointIdsMatch(left, right) && left?.threadId === right?.threadId && left?.checkpointNs === right?.checkpointNs;
+}
+function validateTerminalCheckpoint(invocation, checkpoint) {
+	if (checkpoint.invocationId !== invocation.invocationId || checkpoint.threadId !== invocation.fork.threadId || checkpoint.checkpointNs !== invocation.fork.checkpointNs || checkpoint.checkpointId == null || checkpoint.checkpointId.trim() === "" || checkpoint.checkpointId === invocation.fork.checkpointId || checkpointIdsMatch(checkpoint, invocation.base.checkpoint)) throw new Error("Event actor result escaped its invocation checkpoint fork");
+}
+function createRunnableConfig(invocation, signal, ambient) {
+	const { signal: _ambientSignal, runId: _ambientRunId, runName: _ambientRunName, callbacks: ambientCallbacks, tags: ambientTags, metadata: ambientMetadata, configurable: ambientConfigurable, ...ambientRuntime } = ambient ?? {};
+	const configurable = Object.fromEntries(Object.entries(ambientConfigurable ?? {}).filter(([key]) => !key.startsWith("__pregel_") && !key.startsWith("__librechat_") && key !== "lc_run_breaker_scope"));
+	delete configurable.run_id;
+	delete configurable.thread_id;
+	delete configurable.checkpoint_ns;
+	delete configurable.checkpoint_id;
+	delete configurable.checkpoint_map;
+	delete configurable.event_actor_thread_id;
+	delete configurable.event_actor_invocation_id;
+	delete configurable.event_actor_generation;
+	delete configurable.event_actor_depth;
+	delete configurable.event_actor_continuation;
+	const metadata = Object.fromEntries(Object.entries(ambientMetadata ?? {}).filter(([key]) => !key.startsWith("langgraph_") && !key.startsWith("__pregel_") && key !== "run_id" && key !== "thread_id" && key !== "checkpoint_ns" && key !== "checkpoint_id" && key !== "checkpoint_map"));
+	return {
+		...ambientRuntime,
+		signal,
+		...ambientCallbacks == null ? {} : { callbacks: ambientCallbacks },
+		...ambientTags == null ? {} : { tags: ambientTags },
+		metadata: {
+			...metadata,
+			thread_id: invocation.fork.threadId,
+			checkpoint_ns: invocation.fork.checkpointNs,
+			eventActorThreadId: invocation.actorThreadId,
+			eventActorInvocationId: invocation.invocationId,
+			eventActorGeneration: invocation.base.generation,
+			eventActorDepth: invocation.depth,
+			eventActorContinuation: invocation.continuation
+		},
+		configurable: {
+			...configurable,
+			thread_id: invocation.fork.threadId,
+			checkpoint_ns: invocation.fork.checkpointNs,
+			...invocation.fork.checkpointId == null ? {} : { checkpoint_id: invocation.fork.checkpointId },
+			event_actor_thread_id: invocation.actorThreadId,
+			event_actor_invocation_id: invocation.invocationId,
+			event_actor_generation: invocation.base.generation,
+			event_actor_depth: invocation.depth,
+			event_actor_continuation: invocation.continuation
+		}
+	};
+}
+function asError(error) {
+	try {
+		return error instanceof Error ? error : new Error(String(error));
+	} catch {
+		return /* @__PURE__ */ new Error("Unknown event actor error");
+	}
+}
+function createIndeterminateResult(invocation, error, result) {
+	return Object.freeze({
+		status: "commit_indeterminate",
+		...result === void 0 ? {} : { result },
+		checkpoint: Object.freeze({
+			invocationId: invocation.fork.invocationId,
+			threadId: invocation.fork.threadId,
+			checkpointNs: invocation.fork.checkpointNs
+		}),
+		error: asError(error)
+	});
+}
+function createSettlementIndeterminateResult(settlement, error) {
+	return Object.freeze({
+		status: "commit_indeterminate",
+		result: settlement.result,
+		checkpoint: Object.freeze(snapshotCheckpointFork(settlement.checkpoint)),
+		error: asError(error)
+	});
+}
+function snapshotAppliedTerminal(invocation, terminal) {
+	let result;
+	try {
+		result = snapshotEvent(terminal.result);
+		const snapshot = {
+			status: "snapshot_ready",
+			result,
+			checkpoint: snapshotCheckpointFork(terminal.checkpoint),
+			invocation: freezeInvocationReference(invocation)
+		};
+		validateTerminalCheckpoint(snapshot.invocation, snapshot.checkpoint);
+		return snapshot;
+	} catch (error) {
+		return createIndeterminateResult(invocation, error, result);
+	}
+}
+function isAborted(signal) {
+	return signal?.aborted === true;
+}
+var EventActorPreparationCancelledError = class extends Error {
+	continuation;
+	constructor(continuation, reason) {
+		super(`Event actor ${continuation} preparation was cancelled`, { cause: reason });
+		this.continuation = continuation;
+		this.name = "EventActorPreparationCancelledError";
+	}
+};
+function resolveExecutionDepth(requestedDepth, ambientConfig) {
+	const ambientDepth = ambientConfig?.configurable?.event_actor_depth;
+	if (ambientDepth == null) return requestedDepth ?? 1;
+	if (!Number.isSafeInteger(ambientDepth) || Number(ambientDepth) < 1) throw new Error("Ambient event actor depth is invalid");
+	const nestedDepth = Number(ambientDepth) + 1;
+	if (requestedDepth != null && requestedDepth !== nestedDepth) throw new Error(`Nested event actor depth ${requestedDepth} must advance parent depth ${ambientDepth}`);
+	return nestedDepth;
+}
+function validateCommittedHead(invocation, checkpoint, head) {
+	validateHead(head, invocation.actorThreadId, true);
+	if (head.generation !== invocation.base.generation + 1 || head.checkpoint?.threadId !== checkpoint.threadId || head.checkpoint.checkpointNs !== checkpoint.checkpointNs || head.checkpoint.checkpointId !== checkpoint.checkpointId) throw new Error("Event actor commit returned an invalid logical head");
+}
+var EventActorExecutor = class {
+	#adapter;
+	#maxDepth;
+	#dormantCheckpointTtlMs;
+	#preparationSigningKey;
+	#issuedSettlements = /* @__PURE__ */ new WeakSet();
+	#preparationPhases = /* @__PURE__ */ new Map();
+	#nextPhaseExpiry = Number.POSITIVE_INFINITY;
+	constructor(adapter, options = {}) {
+		this.#adapter = adapter;
+		this.#maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+		this.#dormantCheckpointTtlMs = options.dormantCheckpointTtlMs ?? DEFAULT_DORMANT_CHECKPOINT_TTL_MS;
+		const signingKey = Buffer.from(options.preparationSigningKey ?? (0, node_crypto.randomBytes)(32));
+		if (signingKey.byteLength < 32) throw new Error("preparationSigningKey must contain at least 32 bytes");
+		this.#preparationSigningKey = signingKey;
+		if (!Number.isSafeInteger(this.#maxDepth) || this.#maxDepth < 1) throw new Error("maxDepth must be a positive safe integer");
+		if (!Number.isSafeInteger(this.#dormantCheckpointTtlMs) || this.#dormantCheckpointTtlMs < 1) throw new Error("dormantCheckpointTtlMs must be a positive safe integer");
+	}
+	#signPreparation(payload) {
+		return (0, node_crypto.createHmac)("sha256", this.#preparationSigningKey).update(payload).digest("hex");
+	}
+	#preparationSignatureMatches(signature, payload) {
+		if (!/^[a-f0-9]{64}$/.test(signature)) return false;
+		return (0, node_crypto.timingSafeEqual)(Buffer.from(signature, "hex"), Buffer.from(this.#signPreparation(payload), "hex"));
+	}
+	#createPreparedInvocation(invocation) {
+		const trustedInvocation = freezeInvocation(invocation);
+		const payload = serializeInvocationPreparation(trustedInvocation);
+		return Object.freeze({
+			...trustedInvocation,
+			preparationDigest: this.#createTimedPreparationDigest(payload)
+		});
+	}
+	#createTimedPreparationDigest(payload) {
+		const expiresAt = Math.min(Number.MAX_SAFE_INTEGER, Date.now() + this.#dormantCheckpointTtlMs);
+		return `${expiresAt}.${this.#signPreparation(`${expiresAt}\0${payload}`)}`;
+	}
+	#validateTimedPreparationDigest(preparationDigest, payload, subject, allowExpired = false) {
+		requireNonEmpty(preparationDigest, "preparationDigest");
+		const match = /^(\d+)\.([a-f0-9]{64})$/.exec(preparationDigest);
+		const expiresAt = Number(match?.[1]);
+		if (match == null || !Number.isSafeInteger(expiresAt) || expiresAt < 1 || !this.#preparationSignatureMatches(match[2], `${expiresAt}\0${payload}`)) throw new Error(`Event actor ${subject} binding is invalid`);
+		if (!allowExpired && expiresAt <= Date.now()) throw new Error(`Event actor ${subject} binding has expired`);
+		return expiresAt;
+	}
+	#validatePreparedInvocation(invocation, allowExpired = false) {
+		return this.#validateTimedPreparationDigest(invocation.preparationDigest, serializeInvocationPreparation(invocation), "prepared invocation", allowExpired);
+	}
+	#prunePreparationPhases(now = Date.now()) {
+		this.#nextPhaseExpiry = Number.POSITIVE_INFINITY;
+		for (const [digest, phase] of this.#preparationPhases) if ("expiresAt" in phase && phase.expiresAt <= now) this.#preparationPhases.delete(digest);
+		else if ("expiresAt" in phase) this.#nextPhaseExpiry = Math.min(this.#nextPhaseExpiry, phase.expiresAt);
+	}
+	#getPreparationPhase(preparationDigest) {
+		if (Date.now() >= this.#nextPhaseExpiry) this.#prunePreparationPhases();
+		return this.#preparationPhases.get(preparationDigest);
+	}
+	#setTerminalPreparationPhase(preparationDigest, status, authorityExpiresAt) {
+		const now = Date.now();
+		if (now >= this.#nextPhaseExpiry) this.#prunePreparationPhases(now);
+		const phase = {
+			status,
+			expiresAt: Math.max(authorityExpiresAt, Math.min(Number.MAX_SAFE_INTEGER, now + this.#dormantCheckpointTtlMs))
+		};
+		this.#preparationPhases.set(preparationDigest, phase);
+		this.#nextPhaseExpiry = Math.min(this.#nextPhaseExpiry, phase.expiresAt);
+	}
+	async prepare(request, signal) {
+		const trustedRequest = snapshotPrepareRequest(request);
+		resolveExecutionDepth(trustedRequest.depth, _langchain_core_singletons.AsyncLocalStorageProviderSingleton.getRunnableConfig());
+		this.#validatePrepareRequest(trustedRequest);
+		const checkpointNs = createInvocationCheckpointNs(trustedRequest);
+		const adapterRequest = {
+			...snapshotPrepareRequest(trustedRequest),
+			checkpointNs
+		};
+		const controller = new AbortController();
+		const abort = () => controller.abort(signal?.reason);
+		if (isAborted(signal)) abort();
+		else signal?.addEventListener("abort", abort, { once: true });
+		if (isAborted(controller.signal)) {
+			signal?.removeEventListener("abort", abort);
+			throw new EventActorPreparationCancelledError("warm", controller.signal.reason);
+		}
+		let preparation;
+		try {
+			preparation = await this.#adapter.prepare({ ...adapterRequest }, { signal: controller.signal });
+		} catch (error) {
+			if (isAborted(controller.signal) && error === controller.signal.reason) throw new EventActorPreparationCancelledError("warm", error);
+			throw error;
+		} finally {
+			signal?.removeEventListener("abort", abort);
+		}
+		const preparationStatus = preparation.status;
+		if (preparationStatus === "ready") {
+			const adapterInvocation = snapshotInvocation(preparation.invocation);
+			validateInvocation(trustedRequest, adapterInvocation, "warm", checkpointNs, this.#maxDepth);
+			const preparedInvocation = this.#createPreparedInvocation({
+				...adapterInvocation,
+				event: snapshotEvent(trustedRequest.event)
+			});
+			if (isAborted(controller.signal)) {
+				await this.#discardInvocationReference(snapshotInvocationReference(preparedInvocation), "cancelled");
+				throw new EventActorPreparationCancelledError("warm", controller.signal.reason);
+			}
+			return Object.freeze({
+				status: "ready",
+				invocation: preparedInvocation
+			});
+		} else {
+			if (preparationStatus !== "checkpoint_unavailable") throw new Error("Event actor preparation returned an invalid status");
+			const preparedHead = freezeHead(preparation.head);
+			validateHead(preparedHead, trustedRequest.actorThreadId);
+			if (isAborted(controller.signal)) throw new EventActorPreparationCancelledError("warm", controller.signal.reason);
+			const preparedRequest = freezePrepareRequest(trustedRequest);
+			return Object.freeze({
+				status: "checkpoint_unavailable",
+				request: preparedRequest,
+				head: preparedHead,
+				preparationDigest: this.#createTimedPreparationDigest(serializeUnavailablePreparation(preparedRequest, preparedHead))
+			});
+		}
+	}
+	async coldContinue(preparation, signal) {
+		const request = snapshotPrepareRequest(preparation.request);
+		const trustedHead = snapshotHead(preparation.head);
+		const preparationDigest = preparation.preparationDigest;
+		const authorityExpiresAt = this.#validateTimedPreparationDigest(preparationDigest, serializeUnavailablePreparation(request, trustedHead), "unavailable preparation");
+		resolveExecutionDepth(request.depth, _langchain_core_singletons.AsyncLocalStorageProviderSingleton.getRunnableConfig());
+		this.#validatePrepareRequest(request);
+		validateHead(trustedHead, request.actorThreadId);
+		const checkpointNs = createInvocationCheckpointNs(request);
+		const adapterRequest = {
+			...snapshotPrepareRequest(request),
+			checkpointNs
+		};
+		const controller = new AbortController();
+		const abort = () => controller.abort(signal?.reason);
+		if (isAborted(signal)) abort();
+		else signal?.addEventListener("abort", abort, { once: true });
+		if (isAborted(controller.signal)) {
+			signal?.removeEventListener("abort", abort);
+			throw new EventActorPreparationCancelledError("cold", controller.signal.reason);
+		}
+		if (this.#getPreparationPhase(preparationDigest) != null) {
+			signal?.removeEventListener("abort", abort);
+			throw new Error("Event actor unavailable preparation was already consumed");
+		}
+		this.#preparationPhases.set(preparationDigest, { status: "invoking" });
+		let invocation;
+		try {
+			invocation = await this.#adapter.coldContinue({ ...adapterRequest }, snapshotHead(trustedHead), { signal: controller.signal });
+		} catch (error) {
+			this.#setTerminalPreparationPhase(preparationDigest, "discarded", authorityExpiresAt);
+			if (isAborted(controller.signal) && error === controller.signal.reason) throw new EventActorPreparationCancelledError("cold", error);
+			throw error;
+		} finally {
+			signal?.removeEventListener("abort", abort);
+		}
+		this.#setTerminalPreparationPhase(preparationDigest, "retained", authorityExpiresAt);
+		const adapterInvocation = snapshotInvocation(invocation);
+		validateInvocation(request, adapterInvocation, "cold", checkpointNs, this.#maxDepth, trustedHead);
+		const trustedInvocation = {
+			...adapterInvocation,
+			event: snapshotEvent(request.event)
+		};
+		if (isAborted(controller.signal)) {
+			await this.#discardInvocationReference(snapshotInvocationReference(trustedInvocation), "cancelled");
+			this.#setTerminalPreparationPhase(preparationDigest, "discarded", authorityExpiresAt);
+			throw new EventActorPreparationCancelledError("cold", controller.signal.reason);
+		}
+		const preparedInvocation = this.#createPreparedInvocation(trustedInvocation);
+		this.#setTerminalPreparationPhase(preparationDigest, "discarded", authorityExpiresAt);
+		return preparedInvocation;
+	}
+	async invoke(invocation, signal) {
+		const trustedInvocation = snapshotPreparedInvocation(invocation);
+		const authorityExpiresAt = this.#validatePreparedInvocation(trustedInvocation);
+		const preparationDigest = trustedInvocation.preparationDigest;
+		if (this.#getPreparationPhase(preparationDigest) != null) throw new Error("Event actor prepared invocation was already consumed");
+		this.#preparationPhases.set(preparationDigest, { status: "invoking" });
+		const settlementInvocation = snapshotInvocationReference(trustedInvocation);
+		let terminal;
+		try {
+			terminal = await this.#invokeWithConfig(snapshotInvocation(trustedInvocation), signal, _langchain_core_singletons.AsyncLocalStorageProviderSingleton.getRunnableConfig());
+		} catch (error) {
+			if ((0, _langchain_langgraph.isGraphInterrupt)(error) || (0, _langchain_langgraph.isParentCommand)(error)) {
+				this.#setTerminalPreparationPhase(preparationDigest, "retained", authorityExpiresAt);
+				throw error;
+			}
+			this.#setTerminalPreparationPhase(preparationDigest, "discardable", authorityExpiresAt);
+			await this.discard(trustedInvocation, isAborted(signal) ? "cancelled" : "failed");
+			throw error;
+		}
+		this.#setTerminalPreparationPhase(preparationDigest, "retained", authorityExpiresAt);
+		let status;
+		try {
+			status = terminal.status;
+		} catch (error) {
+			return createIndeterminateResult(settlementInvocation, error);
+		}
+		if (status === "applied") {
+			const snapshot = snapshotAppliedTerminal(settlementInvocation, terminal);
+			return snapshot.status === "snapshot_ready" ? this.#issueSettlement(snapshot) : snapshot;
+		}
+		if (status !== "completed_no_action") return createIndeterminateResult(settlementInvocation, /* @__PURE__ */ new Error("Event actor invocation returned an invalid status"));
+		let completed;
+		try {
+			completed = Object.freeze({
+				status: "completed_no_action",
+				...terminal.result === void 0 ? {} : { result: snapshotEvent(terminal.result) }
+			});
+		} catch (error) {
+			this.#setTerminalPreparationPhase(preparationDigest, "discardable", authorityExpiresAt);
+			await this.discard(trustedInvocation, "completed_no_action");
+			throw error;
+		}
+		this.#setTerminalPreparationPhase(preparationDigest, "discardable", authorityExpiresAt);
+		await this.discard(trustedInvocation, "completed_no_action");
+		return completed;
+	}
+	#issueSettlement(snapshot) {
+		const settlement = Object.freeze({
+			status: "applied",
+			result: snapshot.result,
+			checkpoint: Object.freeze(snapshotCheckpointFork(snapshot.checkpoint)),
+			invocation: freezeInvocationReference(snapshot.invocation)
+		});
+		this.#issuedSettlements.add(settlement);
+		return settlement;
+	}
+	async #invokeWithConfig(invocation, signal, ambientConfig) {
+		resolveExecutionDepth(invocation.depth, ambientConfig);
+		validateInvocation({
+			actorThreadId: invocation.actorThreadId,
+			invocationId: invocation.invocationId,
+			depth: invocation.depth,
+			event: invocation.event
+		}, invocation, invocation.continuation, invocation.fork.checkpointNs, this.#maxDepth);
+		const controller = new AbortController();
+		const abort = () => controller.abort(signal?.reason);
+		if (isAborted(signal)) abort();
+		else signal?.addEventListener("abort", abort, { once: true });
+		const config = createRunnableConfig(invocation, controller.signal, ambientConfig);
+		try {
+			if (controller.signal.aborted) throw asError(controller.signal.reason ?? "Event actor cancelled");
+			return await _langchain_core_singletons.AsyncLocalStorageProviderSingleton.runWithConfig(config, () => this.#adapter.invoke(invocation, {
+				signal: controller.signal,
+				config
+			}));
+		} finally {
+			signal?.removeEventListener("abort", abort);
+		}
+	}
+	async commit(settlement) {
+		if (!this.#issuedSettlements.has(settlement)) throw new Error("Event actor settlement was not issued by this executor");
+		const trustedInvocation = snapshotInvocationReference(settlement.invocation);
+		validateInvocationReference(trustedInvocation, this.#maxDepth);
+		const trustedCheckpoint = snapshotCheckpointFork(settlement.checkpoint);
+		validateTerminalCheckpoint(trustedInvocation, trustedCheckpoint);
+		this.#issuedSettlements.delete(settlement);
+		try {
+			const committed = await this.#adapter.commit({
+				invocation: snapshotInvocationReference(trustedInvocation),
+				expectedHead: snapshotHead(trustedInvocation.base),
+				checkpoint: { ...trustedCheckpoint },
+				result: settlement.result,
+				retention: {
+					committedCheckpoints: 2,
+					dormantCheckpointTtlMs: this.#dormantCheckpointTtlMs
+				}
+			});
+			const status = committed.status;
+			if (status === "committed") {
+				const committedHead = snapshotHead(committed.head);
+				validateCommittedHead(trustedInvocation, trustedCheckpoint, committedHead);
+				return {
+					status: "committed",
+					head: committedHead
+				};
+			}
+			if (status !== "stale") throw new Error("Event actor commit returned an invalid status");
+			const staleHead = committed.head;
+			if (staleHead != null) {
+				const committedHead = snapshotHead(staleHead);
+				validateHead(committedHead, trustedInvocation.actorThreadId);
+				if (committedHead.generation <= trustedInvocation.base.generation) throw new Error("Stale event actor head did not advance past its base");
+				if (trustedInvocation.base.checkpoint != null && committedHead.checkpoint?.threadId !== trustedInvocation.base.checkpoint.threadId) throw new Error("Stale event actor head changed its checkpoint thread");
+				if (checkpointIdsMatch(committedHead.checkpoint, trustedInvocation.base.checkpoint) || checkpointIdsMatch(committedHead.checkpoint, trustedInvocation.fork) || checkpointsMatch(committedHead.checkpoint, trustedCheckpoint)) throw new Error("Stale event actor head does not identify a competing checkpoint");
+				return {
+					status: "stale",
+					head: committedHead
+				};
+			}
+			return { status: "stale" };
+		} catch (error) {
+			return createSettlementIndeterminateResult(settlement, error);
+		}
+	}
+	async discard(invocation, reason) {
+		const discardReason = reason;
+		if (discardReason !== "cancelled" && discardReason !== "completed_no_action" && discardReason !== "failed") throw new Error("Event actor discard reason is invalid");
+		const trustedInvocation = snapshotPreparedInvocation(invocation);
+		const expiresAt = this.#validatePreparedInvocation(trustedInvocation, true);
+		const preparationDigest = trustedInvocation.preparationDigest;
+		const previousPhase = this.#getPreparationPhase(preparationDigest);
+		if (expiresAt <= Date.now() && previousPhase == null) throw new Error("Event actor prepared invocation binding has expired");
+		if (previousPhase != null && previousPhase.status !== "discardable") throw new Error("Event actor prepared invocation is no longer discardable");
+		this.#preparationPhases.set(preparationDigest, { status: "discarding" });
+		try {
+			await this.#discardInvocationReference(trustedInvocation, reason);
+			this.#setTerminalPreparationPhase(preparationDigest, "discarded", expiresAt);
+		} catch (error) {
+			if (previousPhase == null) this.#preparationPhases.delete(preparationDigest);
+			else {
+				this.#preparationPhases.set(preparationDigest, previousPhase);
+				if ("expiresAt" in previousPhase) this.#nextPhaseExpiry = Math.min(this.#nextPhaseExpiry, previousPhase.expiresAt);
+			}
+			throw error;
+		}
+	}
+	#discardInvocationReference(invocation, reason) {
+		const trustedInvocation = snapshotInvocationReference(invocation);
+		validateInvocationReference(trustedInvocation, this.#maxDepth);
+		return this.#adapter.discard({
+			invocation: trustedInvocation,
+			reason
+		});
+	}
+	#validatePrepareRequest(request) {
+		requireNonEmpty(request.actorThreadId, "actorThreadId");
+		requireNonEmpty(request.invocationId, "invocationId");
+		if (!Number.isSafeInteger(request.depth) || request.depth < 1 || request.depth > this.#maxDepth) throw new Error(`Event actor depth ${request.depth} exceeds maximum ${this.#maxDepth}`);
+	}
+	async execute(request) {
+		const trustedRequest = {
+			actorThreadId: request.actorThreadId,
+			invocationId: request.invocationId,
+			event: snapshotEvent(request.event),
+			...request.depth == null ? {} : { depth: request.depth },
+			...request.signal == null ? {} : { signal: request.signal }
+		};
+		const ambientConfig = snapshotAmbientConfig(_langchain_core_singletons.AsyncLocalStorageProviderSingleton.getRunnableConfig());
+		const depth = resolveExecutionDepth(trustedRequest.depth, ambientConfig);
+		const prepareRequest = {
+			actorThreadId: trustedRequest.actorThreadId,
+			invocationId: trustedRequest.invocationId,
+			depth,
+			event: trustedRequest.event
+		};
+		let preparation;
+		try {
+			preparation = await this.prepare(prepareRequest, trustedRequest.signal);
+		} catch (error) {
+			if (error instanceof EventActorPreparationCancelledError) return {
+				status: "cancelled",
+				continuation: error.continuation
+			};
+			throw error;
+		}
+		if (preparation.status === "checkpoint_unavailable" && isAborted(trustedRequest.signal)) return {
+			status: "cancelled",
+			continuation: "cold"
+		};
+		let invocation;
+		try {
+			invocation = preparation.status === "ready" ? preparation.invocation : await this.coldContinue(preparation, trustedRequest.signal);
+		} catch (error) {
+			if (error instanceof EventActorPreparationCancelledError) return {
+				status: "cancelled",
+				continuation: "cold"
+			};
+			throw error;
+		}
+		const continuation = preparation.status === "ready" ? "warm" : "cold";
+		const invocationReference = snapshotInvocationReference(invocation);
+		const invocationForAdapter = snapshotInvocation(invocation);
+		if (isAborted(trustedRequest.signal)) {
+			await this.#discardInvocationReference(invocationReference, "cancelled");
+			return {
+				status: "cancelled",
+				continuation
+			};
+		}
+		let terminal;
+		try {
+			terminal = await this.#invokeWithConfig(invocationForAdapter, trustedRequest.signal, ambientConfig);
+		} catch (error) {
+			if ((0, _langchain_langgraph.isGraphInterrupt)(error) || (0, _langchain_langgraph.isParentCommand)(error)) throw error;
+			const reason = isAborted(trustedRequest.signal) ? "cancelled" : "failed";
+			await this.#discardInvocationReference(invocationReference, reason);
+			if (reason === "cancelled") return {
+				status: "cancelled",
+				continuation
+			};
+			return {
+				status: "failed",
+				error: asError(error),
+				continuation
+			};
+		}
+		let terminalStatus;
+		try {
+			terminalStatus = terminal.status;
+		} catch (error) {
+			return {
+				...createIndeterminateResult(invocationReference, error),
+				continuation
+			};
+		}
+		if (terminalStatus === "completed_no_action") {
+			let result;
+			try {
+				result = terminal.result === void 0 ? void 0 : snapshotEvent(terminal.result);
+			} catch (error) {
+				await this.#discardInvocationReference(invocationReference, "completed_no_action");
+				return {
+					status: "failed",
+					error: asError(error),
+					continuation
+				};
+			}
+			await this.#discardInvocationReference(invocationReference, "completed_no_action");
+			return {
+				status: "completed_no_action",
+				...result === void 0 ? {} : { result },
+				continuation
+			};
+		}
+		if (terminalStatus !== "applied") return {
+			...createIndeterminateResult(invocationReference, /* @__PURE__ */ new Error("Event actor invocation returned an invalid status")),
+			continuation
+		};
+		const appliedSnapshot = snapshotAppliedTerminal(invocationReference, terminal);
+		if (appliedSnapshot.status === "commit_indeterminate") return {
+			...appliedSnapshot,
+			continuation
+		};
+		const trustedTerminal = this.#issueSettlement(appliedSnapshot);
+		const committed = await this.commit(trustedTerminal);
+		if (committed.status === "commit_indeterminate") return {
+			...committed,
+			continuation
+		};
+		if (committed.status === "stale") return {
+			status: "commit_conflict",
+			result: trustedTerminal.result,
+			checkpoint: { ...trustedTerminal.checkpoint },
+			...committed.head == null ? {} : { head: snapshotHead(committed.head) },
+			continuation
+		};
+		return {
+			status: "applied",
+			result: trustedTerminal.result,
+			head: committed.head,
+			continuation
+		};
+	}
+};
+function createEventActorExecutor(adapter, options = {}) {
+	return new EventActorExecutor(adapter, options);
+}
+//#endregion
+exports.EventActorExecutor = EventActorExecutor;
+exports.createEventActorExecutor = createEventActorExecutor;
+
+//# sourceMappingURL=EventActorExecutor.cjs.map