openclaw/dist/openclaw-agent-execution-operations-DpsVwNpq.mjs

Multi-channel AI gateway with extensible messaging integrations

import { c as isRecord } from "./record-coerce-TIsquoVR.mjs";
import { t as formatErrorMessage } from "./errors-BvOkmQM5.mjs";
import { u as readSqliteCacheDataVersion } from "./sqlite-schema-facts-BVf0E_0z.mjs";
import { o as SQLITE_WORKER_PREPARE_COMMAND } from "./sqlite-worker-contract-C51cJHzg.mjs";
import { i as deferSqliteWorkerCommitReceipt, s as requestSqliteWorkerOperationAdmission, u as takeSqliteWorkerOperationAdmissionAttachment } from "./sqlite-worker-operation-admission-C5lBzzTk.mjs";
import { isPromise } from "node:util/types";
//#region src/state/openclaw-agent-execution-domain.ts
/** A domain restriction must obtain exactly one grant for the original native stage. */
function requestRestrictedAgentDatabaseAdmission(request, restriction) {
	const { stage } = request;
	let admitted = false;
	const dispatch = (restricted) => {
		if (admitted || restricted.stage !== stage) throw new Error("Agent admission restriction changed its native stage");
		requestSqliteWorkerOperationAdmission(restricted);
		admitted = true;
	};
	if (restriction) restriction(request, dispatch);
	else dispatch(request);
	if (!admitted) throw new Error("Agent admission restriction omitted its native grant");
}
/** One admitted publication scope borrows the canonical connection; it never owns its close. */
function createAgentDatabaseDomainOwner(context) {
	let binding;
	let prepared;
	let failedBinding = false;
	const requireBinding = (id) => {
		if (!binding || binding.id !== id || !binding.authority.active) throw new Error("Agent database operation lost its bound publication scope");
		return binding;
	};
	const bind = (input) => {
		const database = context.assertCurrent();
		if (!prepared || prepared.id !== input.id || binding) throw new Error("Agent publication module was not prepared for this scope");
		readSqliteCacheDataVersion(database, "fresh");
		const factory = prepared.factory;
		prepared = void 0;
		failedBinding = true;
		const authority = { active: true };
		try {
			const backend = factory(input.input, {
				databasePath: context.databasePath,
				database,
				admit: (stage, requestAdmission) => {
					if (!authority.active) throw new Error("Agent publication cleanup cannot admit a transaction");
					context.admit(stage, requestAdmission);
				}
			});
			if (isPromise(backend)) {
				backend.catch(() => {});
				throw new Error("Connection-bound publication factories must remain synchronous");
			}
			if (!isRecord(backend) || typeof backend.execute !== "function" || typeof backend.close !== "function" || typeof backend.assertSettled !== "function" || SQLITE_WORKER_PREPARE_COMMAND in backend && backend[SQLITE_WORKER_PREPARE_COMMAND] !== void 0 && typeof backend[SQLITE_WORKER_PREPARE_COMMAND] !== "function" || backend.prepare !== void 0 && typeof backend.prepare !== "function") throw new Error("Agent publication module returned an invalid connection-bound backend");
			binding = {
				id: input.id,
				backend,
				authority
			};
			failedBinding = false;
		} catch (error) {
			authority.active = false;
			throw error;
		}
	};
	const prepareCommand = async (input) => {
		const current = requireBinding(input.id);
		const loading = current.backend[SQLITE_WORKER_PREPARE_COMMAND]?.(input.command.type);
		if (loading) await loading;
		await current.backend.prepare?.(input.command);
		if (requireBinding(input.id) !== current) throw new Error("Agent publication changed during command preparation");
	};
	const closeBinding = () => {
		if (!binding) return;
		binding.authority.active = false;
		const closed = binding.backend.close();
		if (closed !== void 0) {
			closed.catch(() => {});
			throw new Error("Connection-bound publication cleanup must remain synchronous");
		}
		binding = void 0;
	};
	return {
		async prepare(command) {
			if (command.type === "database.domain.bind" || command.type === "database.domain.publish") {
				if (binding || prepared) throw new Error("Agent database already has an admitted publication scope");
				const url = new URL(command.input.moduleUrl);
				if (url.protocol !== "file:" || url.search || url.hash) throw new Error("Agent publication requires a static local module URL");
				const module = await import(url.href);
				if (!isRecord(module) || typeof module.bindSqliteWorkerBackend !== "function") throw new Error("Agent publication module must export bindSqliteWorkerBackend");
				const factory = module.bindSqliteWorkerBackend;
				prepared = {
					id: command.input.id,
					factory: (input, bindingContext) => factory(input, bindingContext)
				};
			} else if (command.type === "database.domain.execute") await prepareCommand(command.input);
		},
		async preparePublication(input) {
			bind(input);
			requireBinding(input.id).backend.assertSettled?.();
			await Promise.resolve();
			await prepareCommand(input);
		},
		cleanupPublication(id) {
			if (binding?.id === id) {
				context.assertCleanupCurrent();
				closeBinding();
			}
		},
		execute(command) {
			if (command.type === "database.domain.bind") {
				bind(command.input);
				return;
			}
			context.assertCurrent();
			const current = requireBinding(command.input.id);
			if (command.type === "database.domain.close") {
				closeBinding();
				return;
			}
			return current.backend.execute(command.input.command);
		},
		assertSettled() {
			prepared = void 0;
			if (failedBinding) throw new Error("Agent publication binding did not settle");
			if (binding && !binding.authority.active) throw new Error("Agent publication cleanup did not settle");
			binding?.backend.assertSettled?.();
		},
		close() {
			closeBinding();
			prepared = void 0;
		}
	};
}
//#endregion
//#region src/trajectory/runtime-retention.contract.ts
function readTrajectoryRuntimeRetentionLease(attachment) {
	if (typeof attachment !== "object" || attachment === null || !("trajectoryRetentionLease" in attachment) || !(attachment.trajectoryRetentionLease instanceof SharedArrayBuffer) || attachment.trajectoryRetentionLease.byteLength !== 4) throw new Error("Trajectory retention lease is unavailable");
	return new Int32Array(attachment.trajectoryRetentionLease);
}
//#endregion
//#region src/state/openclaw-agent-execution-operations.ts
let transcript;
function prepareAgentTranscript() {
	return Promise.all([
		import("./session-accessor.sqlite-transcript-header-QhyF0eFL.mjs"),
		import("./session-accessor.sqlite-scope-BH08l9Kb.mjs"),
		import("./session-transcript-authority-BmvW_r53.mjs")
	]).then(([header, scope, authority]) => {
		transcript = {
			initialize: header.ensureTranscriptHeader,
			assertIdentity: scope.assertSqliteTranscriptWriteIdentity,
			readPublication: authority.readStagedSessionTranscriptAuthority
		};
	});
}
async function loadAgentTranscriptOperations() {
	await prepareAgentTranscript();
	return { "session.transcript.initialize": (input, context) => {
		if (!transcript) throw new Error("Session transcript initialization was not prepared");
		const { initialize, readPublication } = transcript;
		const assertIdentity = transcript.assertIdentity;
		assertIdentity(input);
		return context.writeTransaction("session.entry.create-with-transcript", "Session transcript", (current) => {
			const publication = {
				kind: "session-transcript-initialized",
				sessionKey: input.sessionKey
			};
			initialize(current, {
				agentId: context.options.agentId,
				path: context.options.path,
				...input
			}, input.cwd, { onPlaceholderInserted: ({ sessionId }) => {
				publication.placeholder = { sessionId };
			} });
			publication.transcriptPublication = readPublication(current);
			deferSqliteWorkerCommitReceipt(current.db, publication);
			context.admit("commit", publication);
			return publication;
		});
	} };
}
async function loadAgentTranscriptReadOperations() {
	const [raw, visible, memory, anchors, cold, fence, identity, reader, scopes, agents, errors, watermark] = await Promise.all([
		import("./session-accessor.sqlite-delta-BEgN6KJd.mjs"),
		import("./session-accessor.sqlite-active-events-QAGSp-Q7.mjs"),
		import("./capture.worker-iLLkPr8l.mjs"),
		import("./session-transcript-anchor-read.kernel-C9TADcjC.mjs"),
		import("./session-cold-storage-state-C1_VqcYt.mjs"),
		import("./session-transcript-read-fence-WqsJEDeM.mjs"),
		import("./sqlite-worker-identity-BAqG0S-d.mjs"),
		import("./openclaw-agent-db-readonly-open-CVPYfkJD.mjs"),
		import("./session-accessor.sqlite-scope-helpers-HJr7Z-dj.mjs"),
		import("./normalization-core/agent-id.js"),
		import("./session-history-worker-errors-DjiFdP0e.mjs"),
		import("./session-accessor.sqlite-transcript-watermark-8RsEIigo.mjs")
	]);
	const readResult = (read) => {
		try {
			return {
				ok: true,
				value: read()
			};
		} catch (error) {
			const encoded = errors.encodeSessionTranscriptWorkerError(error);
			if (!encoded) throw error;
			return {
				ok: false,
				error: encoded
			};
		}
	};
	const open = (input, context) => {
		const database = context.open();
		identity.assertExistingDatabaseIdentity(database.path, input.expectedIdentity.key, input.expectedIdentity.birthtime);
		if (input.scope) identity.assertExistingDatabaseIdentity(input.scope.storePath ?? database.path, input.expectedIdentity.key, input.expectedIdentity.birthtime);
		if (input.resolved) {
			if ((input.resolved.databaseAgentId ?? input.resolved.agentId) !== database.agentId) throw new Error("Prepared transcript read belongs to another agent database");
			identity.assertExistingDatabaseIdentity(input.resolved.path ?? database.path, input.expectedIdentity.key, input.expectedIdentity.birthtime);
			if (input.scope) {
				const scope = input.scope;
				if (scope.sessionId !== input.resolved.sessionId || scope.agentId !== void 0 && agents.normalizeAgentId(scope.agentId) !== input.resolved.agentId || scope.sessionKey !== void 0 && scopes.resolveSqliteSessionKey(scope.sessionKey, input.resolved.agentId) !== input.resolved.sessionKey) throw new Error("Prepared transcript read changed its captured session scope");
			}
		}
		return database;
	};
	const snapshot = (input, context, read) => {
		const database = open(input, context);
		return reader.readOpenClawAgentDatabaseSnapshot(database, () => read(database));
	};
	return {
		"session.transcript.watermark.read": (input, context) => readResult(() => {
			open(input, context);
			return watermark.readSessionTranscriptWatermark(input.scope);
		}),
		"session.transcript.rawDelta.read": (input, context) => readResult(() => {
			const result = snapshot(input, context, (database) => fence.runWithSessionTranscriptReadFence(input.admission, () => raw.readTranscriptRawDeltaInDatabase(database, input.resolved, input.limits)));
			return result.found ? result.value : { kind: "missing" };
		}),
		"session.transcript.visibleDelta.read": (input, context) => readResult(() => {
			open(input, context);
			return fence.runWithSessionTranscriptReadFence(input.admission, () => visible.readSessionTranscriptVisibleMessageDeltaCore(input.scope, input.limits, {
				readOnly: true,
				resolvedScope: input.resolved
			}));
		}),
		"session.transcript.memoryCapture.read": (input, context) => readResult(() => {
			open(input, context);
			return fence.runWithSessionTranscriptReadFence(input.admission, () => memory.readSessionMemoryCapture({
				scope: input.scope,
				resolvedScope: input.resolved,
				messageCount: input.messageCount
			}));
		}),
		"session.transcript.anchors.read": (input, context) => readResult(() => {
			const result = snapshot(input, context, (database) => anchors.readSessionTranscriptAnchorFactsInDatabase(database, input.resolved, input.selection));
			return result.found ? result.value : { anchors: [] };
		}),
		"session.transcript.coldMetadata.read": (input, context) => readResult(() => {
			const result = snapshot(input, context, (database) => cold.readSessionColdTranscript(database.db, input.sessionId));
			return result.found ? result.value : void 0;
		})
	};
}
async function loadAgentReplacementOperations() {
	const [kernel, { assertSessionSubagentRunsCurrent }] = await Promise.all([import("./session-accessor.sqlite-replacement-state-h7Yz1bCz.mjs"), import("./session-accessor.sqlite-descendant-basis-BTaqumUQ.mjs")]);
	return { "session.entries.replace": (input, context) => context.writeTransaction("session.entry-replacements", "Session replacement", (current) => {
		assertSessionSubagentRunsCurrent(input, context.options.env ?? process.env);
		const result = kernel.commitSessionEntryReplacementsInDatabase(current, input, () => {
			const initialization = input.initializeTranscript;
			if (!initialization) return;
			try {
				if (!transcript) throw new Error("Session transcript initialization was not prepared");
				const { initialize } = transcript;
				const assertIdentity = transcript.assertIdentity;
				assertIdentity(initialization);
				initialize(current, {
					agentId: context.options.agentId,
					path: context.options.path,
					...initialization
				}, initialization.cwd);
			} catch (error) {
				throw Object.assign(new Error(formatErrorMessage(error), { cause: error }), { name: "SessionTranscriptInitializationError" });
			}
		});
		const publication = kernel.prepareSessionEntryReplacementPublication(result, current);
		deferSqliteWorkerCommitReceipt(current.db, publication);
		context.admit("commit", publication);
		assertSessionSubagentRunsCurrent(input, context.options.env ?? process.env);
		return {
			...result,
			publication
		};
	}) };
}
async function loadAgentRestartRecoveryOperations() {
	const kernel = await import("./session-accessor.sqlite-recovery.worker-CAcJeEuK.mjs");
	return { "session.restart.recover": (input, { writeTransaction, admit }) => writeTransaction("session.lifecycle.recover-tombstone", "Session recovery", (current) => {
		const result = kernel.recoverRestartTombstoneInDatabase(current, input);
		deferSqliteWorkerCommitReceipt(current.db, result.publication ?? { kind: "session-restart-recovery-unchanged" });
		admit("commit", result.publication);
		return result;
	}) };
}
async function loadAgentEntryReadOperations() {
	const kernel = await import("./session-entry-read.worker-Bk0PyRMc.mjs");
	const { readSessionEntryCohort, readSessionEntryDataInDatabase } = await import("./session-entry-cohort.worker-BI4Zz3Ud.mjs");
	return { "session.entry.read": (input, { open }) => {
		const database = open();
		return "sessionKeys" in input ? readSessionEntryCohort(database, input, (request) => kernel.readExactSessionEntriesWithLifecycle(request, database)) : readSessionEntryDataInDatabase(database, input.sessionKey);
	} };
}
async function loadAgentEntryPatchOperations() {
	const kernel = await import("./session-entry-patch.worker-B0spyaNx.mjs");
	return {
		"session.entry.patch.prepare": (input, { open }) => kernel.readSessionEntryPatchSnapshot(open(), input),
		"session.entry.patch.commit": kernel.commitSessionEntryPatch
	};
}
async function loadAgentCompoundOperations() {
	const turn = await import("./session-turn.worker--GjV6of9.mjs");
	const reset = await import("./session-reset.worker-CsGmjZGm.mjs");
	const lifecycle = await import("./config/sessions/session-lifecycle-projection.worker.js");
	await (await import("./session-turn-predicate-loSpP9Qs.mjs")).prepareSessionTurnPredicates();
	return {
		"session.turn.prepare": turn.prepareSessionTurn,
		"session.turn.commit": turn.commitSessionTurn,
		"session.lifecycle.reset": reset.commitSessionReset,
		"session.lifecycle.project": lifecycle.commitSessionLifecycleProjection
	};
}
async function loadAgentPurgeOperations() {
	const purge = await import("./session-agent-purge.worker--EO3E0vE.mjs");
	return {
		"session.agentPurge.prepare": purge.prepareSessionAgentPurge,
		"session.agentPurge.commit": purge.commitSessionAgentPurge
	};
}
async function loadAgentMaintenanceFinalizationOperations() {
	const finalization = await import("./session-maintenance-finalization.worker-DfyjzUSD.mjs");
	const maintenanceStore = await import("./session-accessor.sqlite-maintenance-store-k7FAIh_Q.mjs");
	return {
		"session.maintenance.finalize": finalization.finalizeSessionMaintenance,
		"session.maintenance.size": (input, { open }) => maintenanceStore.readSessionTranscriptJsonlBytesInDatabase(open(), input.sessionIds)
	};
}
async function loadAgentMessageCutOperations() {
	return { "session.messageCut.commit": (await import("./session-message-cut.worker-D5pKzOwu.mjs")).commitSessionMessageCut };
}
async function loadAgentNativeBindingOperations() {
	return { "session.nativeBindings.delete": (await import("./session-native-binding.worker-B1YHAXbo.mjs")).deleteSessionWithNativeBindings };
}
async function prepareAgentNativeBindingOperation(input, env) {
	await (await import("./session-native-binding.worker-B1YHAXbo.mjs")).prepareSessionNativeBindingDeletion(input, env);
}
async function loadAgentTrajectoryOperations() {
	const kernel = await import("./runtime-store.sqlite-DDvB5qeL.mjs");
	const retention = await import("./runtime-retention.sqlite-5eXsP_GC.mjs");
	return {
		"trajectory.events.append": (input, { writeTransaction, admit }) => {
			kernel.appendSqliteTrajectoryRuntimeEventsWithWriter(input, (label, write) => writeTransaction(label, "Trajectory append", (current) => {
				const result = write(current);
				deferSqliteWorkerCommitReceipt(current.db, { kind: "trajectory-runtime-append" });
				admit("commit");
				return result;
			}));
		},
		"trajectory.retention.begin": (_input, { open }) => {
			return retention.beginTrajectoryRuntimeRetention(open().db, readTrajectoryRuntimeRetentionLease(takeSqliteWorkerOperationAdmissionAttachment()));
		},
		"trajectory.retention.delete": (input, { open, writeTransaction, admit }) => {
			const database = open();
			const batch = retention.selectTrajectoryRuntimeRetentionBatch(database.db, input);
			if (batch.refresh) return retention.deleteTrajectoryRuntimeRetention(database, batch);
			return writeTransaction("trajectory.runtime.retention.delete", "Trajectory retention", (current) => {
				const result = retention.deleteTrajectoryRuntimeRetention(current, batch);
				admit("commit");
				return result;
			});
		}
	};
}
async function loadAgentArchiveOperations() {
	const kernel = await import("./session-accessor.sqlite-archive-store-kernel-BLACa31R.mjs");
	return {
		"session.archives.preparePublication": (input, { writeTransaction, admit }) => writeTransaction("session.archive.publish", "Session archive publication", (current) => {
			const result = kernel.prepareSessionTranscriptArchivePublishPlans(current, input);
			admit("commit");
			return result;
		}),
		"session.archives.recordPublication": (input, { writeTransaction, admit }) => writeTransaction("session.archive.publish", "Session archive publication", (current) => {
			const result = kernel.recordSessionTranscriptArchivePublishResults(current, input.results, input.nowMs);
			admit("commit");
			return result;
		})
	};
}
async function loadAgentAcpOperations() {
	const kernel = await import("./session-meta-entry.worker-BMlYZ8Nq.mjs");
	return { "session.entry.acp": (input, { open, options, admit }) => kernel.mutateAcpSessionEntryInWorker(open(), options, input, admit) };
}
async function loadAgentProviderReviewOperations() {
	const kernel = await import("./provider-review-store.worker-BT99G8dK.mjs");
	return { "session.providerReview.compare": (input, { open, options, admit }) => kernel.compareSessionProviderReviewInWorker(open(), options, input, admit) };
}
async function loadAgentReactionOperations() {
	const kernel = await import("./session-reaction-store.kernel-DU3eqS-j.mjs");
	return { "session.reaction.set": (input, { writeTransaction, admit }) => writeTransaction("session.reaction.set", "Reaction write", (current) => {
		const result = kernel.setSessionReactionInDatabase(current, input.sessionKey, input.params);
		admit("commit");
		return result;
	}) };
}
async function loadAgentPendingInputOperations() {
	const pending = await import("./session-pending-input-operations.kernel-CNdkgTMV.mjs");
	const kernel = await import("./session-pending-input-withdrawal.worker-jqlox7NK.mjs");
	const history = await import("./session-pending-input-history-reconcile-DIprj4Pv.mjs");
	return {
		"session.pendingInputs.read": (input, { open }) => pending.readPendingInput(open(), input),
		"session.pendingInputs.mutate": (input, context) => pending.mutatePendingInput(input, context, deferSqliteWorkerCommitReceipt),
		"session.pendingInputs.interruptHistory": (input, { open, options, admit }) => {
			const database = open();
			return history.interruptPendingInputHistoryInDatabase(database, options, input, admit, (receipt) => deferSqliteWorkerCommitReceipt(database.db, receipt));
		},
		"session.pendingInputs.withdraw": (input, { open, options, admit }) => kernel.discardSessionPendingInputInWorker(open(), options, input, admit)
	};
}
async function loadAgentArchivePruningOperations() {
	const kernel = await import("./session-history-archive-pruning.worker-_B7KFb7c.mjs");
	return {
		"session.archivePruning.pruneRetention": (input, { open, options, admit }) => kernel.pruneSessionArchivesByRetentionInDatabase(open(), options, input, admit),
		"session.archivePruning.deletePublished": (input, { open, options, admit }) => kernel.deletePublishedSessionArchiveInDatabase(open(), options, input, admit),
		"session.archivePruning.removeLegacy": (input, { open, options, admit }) => kernel.removeLegacySessionArchiveInDatabase(open(), options, input.filePath, admit),
		"session.archivePruning.reclaimPages": (input, { open, admit }) => open().walMaintenance.reclaimFreePages({
			maxPages: input.maxPages,
			beforeMutation: () => admit("transaction"),
			onCommit: () => admit("commit")
		})
	};
}
async function loadConversationDeliveryOperations() {
	const kernel = await import("./conversation-delivery-store.kernel-CuDWhKBD.mjs");
	return {
		"conversation.delivery.begin": (input, { writeTransaction, admit }) => writeTransaction("conversation-delivery.begin", "Conversation delivery", (database) => {
			const result = kernel.beginConversationDeliveryInDatabase(database, input);
			admit("commit");
			return result;
		}),
		"conversation.delivery.transition": (input, { writeTransaction, admit }) => writeTransaction(`conversation-delivery.${input.status}`, "Conversation delivery", (database) => {
			const result = kernel.transitionConversationDeliveryInDatabase(database, input);
			admit("commit");
			return result;
		})
	};
}
async function loadConversationRegistryOperations() {
	const { deferConversationWorkerReceipt } = await import("./session-accessor.sqlite-conversation-publication-BvQLXAFm.mjs");
	const { prepareConversationIdentities, upsertConversationIdentities } = await import("./session-accessor.sqlite-conversation-NR1cKHAQ.mjs");
	const { selectConversationRowsFromDatabase, resolveConversationInDatabase } = await import("./session-accessor.sqlite-conversation-read-D1f01LJj.mjs");
	const { readConversationDeliveryInDatabase } = await import("./conversation-delivery-store.kernel-CuDWhKBD.mjs");
	return {
		"conversation.register": (input, { writeTransaction, admit }) => {
			const prepared = prepareConversationIdentities(input.identities);
			return writeTransaction("conversation.register", "Conversation registration", (database) => {
				const publication = upsertConversationIdentities(database, prepared, input.discoveredAt);
				if (publication && typeof publication.source.identity === "string") deferConversationWorkerReceipt(database.db, publication);
				const rows = input.query ? selectConversationRowsFromDatabase(database, input.query) : void 0;
				admit("commit");
				return rows;
			});
		},
		"conversation.authority": (input, { writeTransaction, admit }) => writeTransaction("conversation.authority", "Conversation authority", (database) => {
			const operation = "operationId" in input ? readConversationDeliveryInDatabase(database, input) : void 0;
			const conversationRef = "conversationRef" in input ? input.conversationRef : operation?.conversationRef;
			const facts = {
				operation: operation ? { conversationRef: operation.conversationRef } : void 0,
				conversation: conversationRef ? resolveConversationInDatabase(database, conversationRef) : void 0
			};
			admit("commit", {
				kind: "conversation-authority",
				facts
			});
			return facts;
		})
	};
}
async function loadUsageCacheOperations() {
	const kernel = await import("./session-cost-usage-cache.kernel-BvjuKtBp.mjs");
	return {
		"usageCache.writeRollup": (input, { writeTransaction, admit }) => writeTransaction("session-cost-usage.rollup.write", "Usage cache", ({ db }) => {
			const result = kernel.writeSessionCostUsageRollupInDatabase(db, input);
			admit("commit");
			return result;
		}),
		"usageCache.prune": (input, { writeTransaction, admit }) => writeTransaction("session-cost-usage.rollup.prune", "Usage cache", ({ db }) => {
			kernel.pruneSessionCostUsageRollupsInDatabase(db, input);
			admit("commit");
		}),
		"usageCache.acquireLock": (input, { writeTransaction, admit }) => writeTransaction("session-cost-usage.refresh-lock.acquire", "Usage cache", ({ db }) => {
			const result = kernel.acquireSessionCostUsageRefreshLockInDatabase(db, input);
			admit("commit");
			return result;
		}),
		"usageCache.releaseLock": (input, { writeTransaction, admit }) => writeTransaction("session-cost-usage.refresh-lock.delete", "Usage cache", ({ db }) => {
			kernel.deleteSessionCostUsageRefreshLockInDatabase(db, input);
			admit("commit");
		})
	};
}
//#endregion
export { prepareAgentTranscript as C, requestRestrictedAgentDatabaseAdmission as E, prepareAgentNativeBindingOperation as S, createAgentDatabaseDomainOwner as T, loadAgentTranscriptOperations as _, loadAgentEntryPatchOperations as a, loadConversationRegistryOperations as b, loadAgentMessageCutOperations as c, loadAgentProviderReviewOperations as d, loadAgentPurgeOperations as f, loadAgentTrajectoryOperations as g, loadAgentRestartRecoveryOperations as h, loadAgentCompoundOperations as i, loadAgentNativeBindingOperations as l, loadAgentReplacementOperations as m, loadAgentArchiveOperations as n, loadAgentEntryReadOperations as o, loadAgentReactionOperations as p, loadAgentArchivePruningOperations as r, loadAgentMaintenanceFinalizationOperations as s, loadAgentAcpOperations as t, loadAgentPendingInputOperations as u, loadAgentTranscriptReadOperations as v, readTrajectoryRuntimeRetentionLease as w, loadUsageCacheOperations as x, loadConversationDeliveryOperations as y };