openclaw/dist/plugin-sdk/codex-session-transcript-runtime.js

Multi-channel AI gateway with extensible messaging integrations

import { c as isRecord } from "../record-coerce-TIsquoVR.mjs";
import { d as readDatabasePathIdentitySync, r as assertExistingDatabaseIdentity } from "../sqlite-worker-identity-BRNRpRyc.mjs";
import { t as SessionTranscriptReadFenceError } from "../session-transcript-read-fence-error-DoYPfzaJ.mjs";
import { l as resolveOpenClawAgentSqlitePath } from "../openclaw-agent-db.paths-BbmZlEP5.mjs";
import { i as toDatabaseOptions } from "../session-accessor.sqlite-scope-helpers-CfDTAEsL.mjs";
import { n as captureSessionTranscriptTargetBinding } from "../transcript-target-binding-DpcuSIFy.mjs";
import { r as IncognitoSessionSyncAccessError } from "../incognito-session-error-BUzgcwoZ.mjs";
import { r as captureOwnedTranscriptWriteAssertion } from "../transcript-write-context-DwwjCPCE.mjs";
import { u as resolveSqliteTranscriptReadScope } from "../session-accessor.sqlite-scope-BkgwxatT.mjs";
import { t as captureIncognitoSessionBinding } from "../session-incognito-binding-Dp6RTei2.mjs";
import { a as withSessionContextAdmission, i as runWithSessionTranscriptReadFence, n as resolveSessionTranscriptReadFence } from "../session-transcript-read-fence-DqVaDIch.mjs";
import { o as validateSessionTranscriptContextVersion, r as validateSessionTranscriptContextAdmission, t as readSessionTranscriptContextMessages } from "../session-accessor.sqlite-model-context-C4SiIif1.mjs";
import { t as readSessionTranscriptContextProjectionAsync } from "../session-transcript-context-read-pDFXvJTK.mjs";
import { t as createSessionTranscriptContextReader } from "../session-transcript-context-reader-DoDQRzjm.mjs";
//#region src/plugin-sdk/codex-session-transcript-runtime.ts
/** Capture the admitted actor before yielding; ordinary host-owned routing stays unchanged. */
function captureCodexSessionContextReader(source, signal) {
	const binding = captureIncognitoSessionBinding(source);
	if (!binding) return;
	const target = captureSessionTranscriptTargetBinding(source);
	const { actor } = binding;
	const assertOwned = captureOwnedTranscriptWriteAssertion(target);
	const claim = actor.sessions.captureCurrent(target.sessionKey);
	const assertCurrent = () => {
		signal?.throwIfAborted();
		binding.admissionSignal?.throwIfAborted();
		assertOwned();
		actor.assertCurrent();
		claim.assertCurrent();
	};
	assertCurrent();
	const input = {
		sessionKey: target.sessionKey,
		sessionId: target.sessionId,
		lifecycleRevision: actor.sessions.readSharing(target.sessionKey)?.entry?.lifecycleRevision,
		admission: resolveSessionTranscriptReadFence(target)
	};
	return async (readTarget, read) => {
		const value = await actor.sessions.withSharedState(async () => {
			assertCurrent();
			const { bindIncognitoSessionComputeReader } = await import("../session-incognito-compute-read-CDF0eWtT.mjs");
			assertCurrent();
			return bindIncognitoSessionComputeReader({
				actor,
				authority: { assertCurrent },
				target: input,
				signal
			}).nativeContext(readTarget, read);
		});
		assertCurrent();
		actor.assertReadable();
		return value;
	};
}
function assertCodexSessionSyncAccess(target, method) {
	if (captureIncognitoSessionBinding(target)) throw new IncognitoSessionSyncAccessError(method, "captureCodexSessionContextReader");
}
/** @deprecated Synchronous SDK compatibility until the next major; bundled readers retain worker validation. */
function validateCodexSessionTranscriptReadAdmission(...args) {
	assertCodexSessionSyncAccess(args[0], "validateCodexSessionTranscriptReadAdmission");
	validateSessionTranscriptContextAdmission(...args);
}
/** @deprecated Synchronous SDK compatibility until the next major; bundled readers retain worker validation. */
function validateCodexSessionTranscriptContextVersion(...args) {
	assertCodexSessionSyncAccess(args[0], "validateCodexSessionTranscriptContextVersion");
	validateSessionTranscriptContextVersion(...args);
}
/** The native evidence consumer remains lazy inside one readonly transcript snapshot. */
function readCodexSessionContext(target, read, admission, physicalSource) {
	assertCodexSessionSyncAccess(target, "readCodexSessionContext");
	if (physicalSource) {
		const databasePath = resolveOpenClawAgentSqlitePath(toDatabaseOptions(resolveSqliteTranscriptReadScope(target)));
		const identity = physicalSource.expectedIdentity;
		if (identity) assertExistingDatabaseIdentity(databasePath, identity.key, identity.birthtime);
		else if (readDatabasePathIdentitySync(databasePath).key.startsWith("file:")) throw new Error("Session context changed its captured database owner");
	}
	return withSessionContextAdmission(target, admission, () => readSessionTranscriptContextMessages(target, read));
}
/** Reads the bundled Codex mirror strictly before one admitted user row. */
async function readCodexSessionTranscriptEventsBeforeAdmission(params, admission) {
	const { readSessionTranscriptEvents, resolveSessionTranscriptIdentity } = await import("./session-transcript-runtime.js");
	const target = await resolveSessionTranscriptIdentity(params);
	if (target.agentId !== admission.agentId || target.sessionId !== admission.sessionId || target.sessionKey !== admission.sessionKey) throw new SessionTranscriptReadFenceError("Current-turn transcript admission belongs to a different transcript target");
	return await runWithSessionTranscriptReadFence(admission, async () => await readSessionTranscriptEvents(params));
}
/** @deprecated Use withCodexSessionTranscriptMirrorWrite. Removed at the next Plugin SDK major. */
async function withCodexSessionTranscriptMirrorWriteLock(params, run) {
	return withMirrorWrite(params, run, "lock");
}
/** Runs ordered optimistic mirror writes and returns each committed message's sequence. */
async function withCodexSessionTranscriptMirrorWrite(params, run) {
	return withMirrorWrite(params, run, "sequence");
}
async function withMirrorWrite(params, run, mode) {
	const { withProjectedSessionTranscriptWriteLock } = await import("../session-transcript-lock-runtime-Cdxbs9wJ.mjs");
	return await withProjectedSessionTranscriptWriteLock(params, run, (context, locked) => ({
		...context,
		appendMessageWithMessageSequence: (options) => locked.appendMessageWithMessageSequence({
			...options,
			...params.config !== void 0 ? { config: params.config } : {}
		}),
		readMessageFacts: async (factParams) => {
			const facts = await locked.readMessageFacts(factParams);
			const messagesByIdempotencyKey = /* @__PURE__ */ new Map();
			for (const [idempotencyKey, message] of facts.messagesByIdempotencyKey) if (isAgentMessageRecord(message)) messagesByIdempotencyKey.set(idempotencyKey, message);
			return {
				...facts,
				messagesByIdempotencyKey
			};
		}
	}), mode);
}
function isAgentMessageRecord(value) {
	return isRecord(value) && typeof value.role === "string" && value.role.trim().length > 0;
}
//#endregion
export { SessionTranscriptReadFenceError, captureCodexSessionContextReader, resolveSessionTranscriptReadFence as captureCodexSessionTranscriptReadAdmission, createSessionTranscriptContextReader as createCodexSessionContextReader, readCodexSessionContext, readSessionTranscriptContextProjectionAsync as readCodexSessionContextProjection, readCodexSessionTranscriptEventsBeforeAdmission, validateCodexSessionTranscriptContextVersion, validateCodexSessionTranscriptReadAdmission, withCodexSessionTranscriptMirrorWrite, withCodexSessionTranscriptMirrorWriteLock };