@modelprofile.com/flexharness-agent 6.0.0

package/dist_ts_agent/smartagent.persistence.js

@@ -0,0 +1,677 @@
+import * as plugins from './plugins.js';
+const SNAPSHOT_SCHEMA_VERSION = 2;
+const ARCHIVE_SCHEMA_VERSION = 2;
+export const isAgentEventStoreV2 = (store) => !!store
+    && 'eventSchemaVersion' in store
+    && store.eventSchemaVersion === 2;
+const AGENT_EVENT_TYPES = new Set([
+    'system-message',
+    'user-message',
+    'assistant-message',
+    'tool-call',
+    'tool-result',
+    'runtime-event',
+    'model-message',
+    'generation-begun',
+    'generation-execution-started',
+    'generation-execution-completed',
+    'generation-outcome',
+    'tool-execution-intent',
+    'tool-execution-reconciliation',
+    'context-compaction',
+]);
+const AGENT_CONVERSATION_EVENT_TYPES = new Set([
+    'system-message',
+    'user-message',
+    'assistant-message',
+    'tool-call',
+    'tool-result',
+    'model-message',
+]);
+const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+const validationError = (path, message) => {
+    throw new Error(`${path} ${message}`);
+};
+const assertRecord = (value, path) => {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        validationError(path, 'must be an object.');
+    }
+};
+const assertNonEmptyString = (value, path) => {
+    if (typeof value !== 'string' || !value.trim()) {
+        validationError(path, 'must be a non-empty string.');
+    }
+};
+const assertOptionalString = (value, path) => {
+    if (value !== undefined && typeof value !== 'string') {
+        validationError(path, 'must be a string when provided.');
+    }
+};
+const assertTimestamp = (value, path) => {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+        validationError(path, 'must be a non-negative finite number.');
+    }
+};
+const assertPositiveInteger = (value, path) => {
+    if (!Number.isSafeInteger(value) || Number(value) <= 0) {
+        validationError(path, 'must be a positive safe integer.');
+    }
+};
+const assertStringArray = (value, path) => {
+    if (!Array.isArray(value))
+        return validationError(path, 'must be an array.');
+    const values = new Set();
+    for (const [index, entry] of value.entries()) {
+        assertNonEmptyString(entry, `${path}[${index}]`);
+        if (values.has(entry))
+            validationError(path, 'must not contain duplicate values.');
+        values.add(entry);
+    }
+};
+const assertProviderOptions = (value, path) => {
+    if (value !== undefined)
+        assertRecord(value, path);
+};
+const assertToolResultOutput = (value, path) => {
+    assertRecord(value, path);
+    assertNonEmptyString(value.type, `${path}.type`);
+    assertProviderOptions(value.providerOptions, `${path}.providerOptions`);
+    if (value.type === 'text' || value.type === 'error-text') {
+        if (typeof value.value !== 'string')
+            validationError(`${path}.value`, 'must be a string.');
+        return;
+    }
+    if (value.type === 'json' || value.type === 'error-json') {
+        if (!hasOwn(value, 'value'))
+            validationError(`${path}.value`, 'is required.');
+        return;
+    }
+    if (value.type === 'execution-denied') {
+        assertOptionalString(value.reason, `${path}.reason`);
+        return;
+    }
+    if (value.type !== 'content')
+        return validationError(`${path}.type`, 'is invalid.');
+    if (!Array.isArray(value.value)) {
+        return validationError(`${path}.value`, 'must be an array.');
+    }
+    for (const [index, entryValue] of value.value.entries()) {
+        const entryPath = `${path}.value[${index}]`;
+        assertRecord(entryValue, entryPath);
+        assertNonEmptyString(entryValue.type, `${entryPath}.type`);
+        assertProviderOptions(entryValue.providerOptions, `${entryPath}.providerOptions`);
+        if (entryValue.type === 'text') {
+            if (typeof entryValue.text !== 'string')
+                validationError(`${entryPath}.text`, 'must be a string.');
+        }
+        else if (entryValue.type === 'media'
+            || entryValue.type === 'file-data'
+            || entryValue.type === 'image-data') {
+            if (typeof entryValue.data !== 'string')
+                validationError(`${entryPath}.data`, 'must be a string.');
+            if (typeof entryValue.mediaType !== 'string') {
+                validationError(`${entryPath}.mediaType`, 'must be a string.');
+            }
+            assertOptionalString(entryValue.filename, `${entryPath}.filename`);
+        }
+        else if (entryValue.type === 'file-url' || entryValue.type === 'image-url') {
+            if (typeof entryValue.url !== 'string')
+                validationError(`${entryPath}.url`, 'must be a string.');
+        }
+        else if (entryValue.type === 'file-id' || entryValue.type === 'image-file-id') {
+            if (typeof entryValue.fileId !== 'string') {
+                assertRecord(entryValue.fileId, `${entryPath}.fileId`);
+                for (const [provider, fileId] of Object.entries(entryValue.fileId)) {
+                    if (typeof fileId !== 'string') {
+                        validationError(`${entryPath}.fileId.${provider}`, 'must be a string.');
+                    }
+                }
+            }
+        }
+        else if (entryValue.type !== 'custom') {
+            validationError(`${entryPath}.type`, 'is invalid.');
+        }
+    }
+};
+const assertMessageContentPart = (value, path, role) => {
+    assertRecord(value, path);
+    assertNonEmptyString(value.type, `${path}.type`);
+    assertProviderOptions(value.providerOptions, `${path}.providerOptions`);
+    if (value.type === 'text' || value.type === 'reasoning') {
+        if (value.type === 'reasoning' && role !== 'assistant') {
+            validationError(`${path}.type`, `is invalid for a ${role} message.`);
+        }
+        if (typeof value.text !== 'string')
+            validationError(`${path}.text`, 'must be a string.');
+        return;
+    }
+    if (value.type === 'image') {
+        if (role !== 'user')
+            validationError(`${path}.type`, `is invalid for a ${role} message.`);
+        if (!hasOwn(value, 'image'))
+            validationError(`${path}.image`, 'is required.');
+        assertOptionalString(value.mediaType, `${path}.mediaType`);
+        return;
+    }
+    if (value.type === 'file') {
+        if (role === 'tool')
+            validationError(`${path}.type`, 'is invalid for a tool message.');
+        if (!hasOwn(value, 'data'))
+            validationError(`${path}.data`, 'is required.');
+        if (typeof value.mediaType !== 'string')
+            validationError(`${path}.mediaType`, 'must be a string.');
+        assertOptionalString(value.filename, `${path}.filename`);
+        return;
+    }
+    if (value.type === 'tool-call') {
+        if (role !== 'assistant')
+            validationError(`${path}.type`, `is invalid for a ${role} message.`);
+        assertNonEmptyString(value.toolCallId, `${path}.toolCallId`);
+        assertNonEmptyString(value.toolName, `${path}.toolName`);
+        if (!hasOwn(value, 'input'))
+            validationError(`${path}.input`, 'is required.');
+        if (value.providerExecuted !== undefined && typeof value.providerExecuted !== 'boolean') {
+            validationError(`${path}.providerExecuted`, 'must be a boolean when provided.');
+        }
+        return;
+    }
+    if (value.type === 'tool-result') {
+        if (role === 'user')
+            validationError(`${path}.type`, 'is invalid for a user message.');
+        assertNonEmptyString(value.toolCallId, `${path}.toolCallId`);
+        assertNonEmptyString(value.toolName, `${path}.toolName`);
+        if (!hasOwn(value, 'output'))
+            validationError(`${path}.output`, 'is required.');
+        assertToolResultOutput(value.output, `${path}.output`);
+        return;
+    }
+    if (value.type === 'tool-approval-request') {
+        if (role !== 'assistant')
+            validationError(`${path}.type`, `is invalid for a ${role} message.`);
+        assertNonEmptyString(value.approvalId, `${path}.approvalId`);
+        assertNonEmptyString(value.toolCallId, `${path}.toolCallId`);
+        return;
+    }
+    if (value.type === 'tool-approval-response') {
+        if (role !== 'tool')
+            validationError(`${path}.type`, `is invalid for a ${role} message.`);
+        assertNonEmptyString(value.approvalId, `${path}.approvalId`);
+        if (typeof value.approved !== 'boolean')
+            validationError(`${path}.approved`, 'must be a boolean.');
+        assertOptionalString(value.reason, `${path}.reason`);
+        if (value.providerExecuted !== undefined && typeof value.providerExecuted !== 'boolean') {
+            validationError(`${path}.providerExecuted`, 'must be a boolean when provided.');
+        }
+        return;
+    }
+    validationError(`${path}.type`, `is invalid for a ${role} message.`);
+};
+const assertMessageContent = (value, path, role) => {
+    if (role === 'system') {
+        if (typeof value !== 'string')
+            validationError(path, 'must be a string.');
+        return;
+    }
+    if (typeof value === 'string' && role !== 'tool')
+        return;
+    if (!Array.isArray(value)) {
+        return validationError(path, 'must be a string or content-part array.');
+    }
+    for (const [index, part] of value.entries()) {
+        assertMessageContentPart(part, `${path}[${index}]`, role);
+    }
+};
+const assertModelMessage = (value, path) => {
+    assertRecord(value, path);
+    const role = value.role;
+    if (role !== 'system'
+        && role !== 'user'
+        && role !== 'assistant'
+        && role !== 'tool')
+        return validationError(`${path}.role`, 'is invalid.');
+    if (!hasOwn(value, 'content'))
+        validationError(`${path}.content`, 'is required.');
+    assertMessageContent(value.content, `${path}.content`, role);
+    assertProviderOptions(value.providerOptions, `${path}.providerOptions`);
+};
+const assertRequiredGenerationId = (event, path) => {
+    assertNonEmptyString(event.generationId, `${path}.generationId`);
+};
+const assertArchivedTransactions = (value, path) => {
+    if (!Array.isArray(value))
+        return validationError(path, 'must be an array.');
+    const generationIds = new Set();
+    for (const [index, entryValue] of value.entries()) {
+        const entryPath = `${path}[${index}]`;
+        assertRecord(entryValue, entryPath);
+        assertNonEmptyString(entryValue.generationId, `${entryPath}.generationId`);
+        assertNonEmptyString(entryValue.claimTokenDigest, `${entryPath}.claimTokenDigest`);
+        if (generationIds.has(entryValue.generationId)) {
+            validationError(path, 'must not contain duplicate generationId values.');
+        }
+        generationIds.add(entryValue.generationId);
+        if (entryValue.outcome !== 'accepted'
+            && entryValue.outcome !== 'rejected'
+            && entryValue.outcome !== 'interrupted')
+            validationError(`${entryPath}.outcome`, 'is invalid.');
+    }
+};
+const validateAgentEvents = (value, path, conversationOnly = false) => {
+    if (!Array.isArray(value))
+        return validationError(path, 'must be an array.');
+    const eventIds = new Set();
+    let priorSequence = 0;
+    for (const [index, eventValue] of value.entries()) {
+        const eventPath = `${path}[${index}]`;
+        assertRecord(eventValue, eventPath);
+        assertNonEmptyString(eventValue.id, `${eventPath}.id`);
+        if (eventIds.has(eventValue.id))
+            validationError(path, 'must not contain duplicate event IDs.');
+        eventIds.add(eventValue.id);
+        assertTimestamp(eventValue.timestamp, `${eventPath}.timestamp`);
+        if (eventValue.sequence !== undefined) {
+            assertPositiveInteger(eventValue.sequence, `${eventPath}.sequence`);
+            if (eventValue.sequence <= priorSequence) {
+                validationError(`${eventPath}.sequence`, 'must be strictly monotonic.');
+            }
+            priorSequence = eventValue.sequence;
+        }
+        if (eventValue.parentIds !== undefined) {
+            assertStringArray(eventValue.parentIds, `${eventPath}.parentIds`);
+        }
+        for (const field of ['causationId', 'generationId', 'inferenceId']) {
+            if (eventValue[field] !== undefined) {
+                assertNonEmptyString(eventValue[field], `${eventPath}.${field}`);
+            }
+        }
+        assertNonEmptyString(eventValue.type, `${eventPath}.type`);
+        if (!AGENT_EVENT_TYPES.has(eventValue.type))
+            validationError(`${eventPath}.type`, 'is invalid.');
+        if (conversationOnly && !AGENT_CONVERSATION_EVENT_TYPES.has(eventValue.type)) {
+            validationError(`${eventPath}.type`, 'must be a conversation event.');
+        }
+        switch (eventValue.type) {
+            case 'system-message':
+                if (!hasOwn(eventValue, 'content'))
+                    validationError(`${eventPath}.content`, 'is required.');
+                assertMessageContent(eventValue.content, `${eventPath}.content`, 'system');
+                assertProviderOptions(eventValue.providerOptions, `${eventPath}.providerOptions`);
+                break;
+            case 'user-message':
+            case 'assistant-message':
+                if (!hasOwn(eventValue, 'content'))
+                    validationError(`${eventPath}.content`, 'is required.');
+                assertMessageContent(eventValue.content, `${eventPath}.content`, eventValue.type === 'user-message'
+                    ? 'user'
+                    : 'assistant');
+                assertProviderOptions(eventValue.providerOptions, `${eventPath}.providerOptions`);
+                break;
+            case 'tool-call':
+                assertNonEmptyString(eventValue.toolCallId, `${eventPath}.toolCallId`);
+                assertNonEmptyString(eventValue.toolName, `${eventPath}.toolName`);
+                if (!hasOwn(eventValue, 'input'))
+                    validationError(`${eventPath}.input`, 'is required.');
+                if (eventValue.providerExecuted !== undefined && typeof eventValue.providerExecuted !== 'boolean') {
+                    validationError(`${eventPath}.providerExecuted`, 'must be a boolean when provided.');
+                }
+                assertProviderOptions(eventValue.providerOptions, `${eventPath}.providerOptions`);
+                break;
+            case 'tool-result':
+                assertNonEmptyString(eventValue.toolCallId, `${eventPath}.toolCallId`);
+                assertNonEmptyString(eventValue.toolName, `${eventPath}.toolName`);
+                if (eventValue.executionIntentId !== undefined) {
+                    assertNonEmptyString(eventValue.executionIntentId, `${eventPath}.executionIntentId`);
+                }
+                assertOptionalString(eventValue.error, `${eventPath}.error`);
+                if (eventValue.responseMessageCommitted !== undefined
+                    && typeof eventValue.responseMessageCommitted !== 'boolean') {
+                    validationError(`${eventPath}.responseMessageCommitted`, 'must be a boolean when provided.');
+                }
+                if (eventValue.modelOutput !== undefined) {
+                    assertToolResultOutput(eventValue.modelOutput, `${eventPath}.modelOutput`);
+                }
+                assertProviderOptions(eventValue.providerOptions, `${eventPath}.providerOptions`);
+                assertProviderOptions(eventValue.messageProviderOptions, `${eventPath}.messageProviderOptions`);
+                break;
+            case 'runtime-event':
+                assertRecord(eventValue.event, `${eventPath}.event`);
+                assertNonEmptyString(eventValue.event.type, `${eventPath}.event.type`);
+                if (eventValue.modelVisible !== undefined && typeof eventValue.modelVisible !== 'boolean') {
+                    validationError(`${eventPath}.modelVisible`, 'must be a boolean when provided.');
+                }
+                break;
+            case 'model-message':
+                assertModelMessage(eventValue.message, `${eventPath}.message`);
+                break;
+            case 'generation-begun':
+                assertRequiredGenerationId(eventValue, eventPath);
+                assertNonEmptyString(eventValue.claimTokenDigest, `${eventPath}.claimTokenDigest`);
+                break;
+            case 'generation-execution-started':
+            case 'generation-execution-completed':
+                assertRequiredGenerationId(eventValue, eventPath);
+                break;
+            case 'generation-outcome':
+                assertRequiredGenerationId(eventValue, eventPath);
+                if (eventValue.outcome !== 'accepted'
+                    && eventValue.outcome !== 'rejected'
+                    && eventValue.outcome !== 'interrupted')
+                    validationError(`${eventPath}.outcome`, 'is invalid.');
+                assertOptionalString(eventValue.reason, `${eventPath}.reason`);
+                break;
+            case 'tool-execution-intent':
+                assertRequiredGenerationId(eventValue, eventPath);
+                assertNonEmptyString(eventValue.toolCallId, `${eventPath}.toolCallId`);
+                assertNonEmptyString(eventValue.toolName, `${eventPath}.toolName`);
+                if (!hasOwn(eventValue, 'input'))
+                    validationError(`${eventPath}.input`, 'is required.');
+                break;
+            case 'tool-execution-reconciliation':
+                assertRequiredGenerationId(eventValue, eventPath);
+                assertNonEmptyString(eventValue.intentId, `${eventPath}.intentId`);
+                assertNonEmptyString(eventValue.toolCallId, `${eventPath}.toolCallId`);
+                assertNonEmptyString(eventValue.toolName, `${eventPath}.toolName`);
+                if (eventValue.resolution !== 'executed'
+                    && eventValue.resolution !== 'not-executed'
+                    && eventValue.resolution !== 'abandoned-unknown')
+                    validationError(`${eventPath}.resolution`, 'is invalid.');
+                assertOptionalString(eventValue.error, `${eventPath}.error`);
+                if (eventValue.modelOutput !== undefined) {
+                    assertToolResultOutput(eventValue.modelOutput, `${eventPath}.modelOutput`);
+                }
+                break;
+            case 'context-compaction':
+                assertStringArray(eventValue.coveredEventIds, `${eventPath}.coveredEventIds`);
+                validateAgentEvents(eventValue.replacementEvents, `${eventPath}.replacementEvents`, true);
+                if (eventValue.archivedTransactions !== undefined) {
+                    assertArchivedTransactions(eventValue.archivedTransactions, `${eventPath}.archivedTransactions`);
+                }
+                break;
+        }
+    }
+    return value;
+};
+/** Validates and returns a canonical schema-2 Agent event snapshot. */
+export const validateAgentEventSnapshotV2 = (value, expectedSessionId) => {
+    assertRecord(value, 'Agent event snapshot');
+    if (value.schemaVersion !== SNAPSHOT_SCHEMA_VERSION) {
+        validationError('Agent event snapshot schemaVersion', 'must be 2.');
+    }
+    assertNonEmptyString(value.sessionId, 'Agent event snapshot sessionId');
+    if (expectedSessionId !== undefined && value.sessionId !== expectedSessionId) {
+        validationError('Agent event snapshot sessionId', `must equal "${expectedSessionId}".`);
+    }
+    assertPositiveInteger(value.revision, 'Agent event snapshot revision');
+    assertTimestamp(value.updatedAt, 'Agent event snapshot updatedAt');
+    validateAgentEvents(value.events, 'Agent event snapshot events');
+    return value;
+};
+/** Validates and returns a canonical schema-2 Agent event archive. */
+export const validateAgentEventArchiveV2 = (value, expectedSessionId, expectedArchiveId) => {
+    assertRecord(value, 'Agent event archive');
+    if (value.schemaVersion !== ARCHIVE_SCHEMA_VERSION) {
+        validationError('Agent event archive schemaVersion', 'must be 2.');
+    }
+    assertNonEmptyString(value.sessionId, 'Agent event archive sessionId');
+    if (expectedSessionId !== undefined && value.sessionId !== expectedSessionId) {
+        validationError('Agent event archive sessionId', `must equal "${expectedSessionId}".`);
+    }
+    assertNonEmptyString(value.archiveId, 'Agent event archive archiveId');
+    if (expectedArchiveId !== undefined && value.archiveId !== expectedArchiveId) {
+        validationError('Agent event archive archiveId', `must equal "${expectedArchiveId}".`);
+    }
+    assertTimestamp(value.createdAt, 'Agent event archive createdAt');
+    validateAgentEvents(value.events, 'Agent event archive events');
+    return value;
+};
+export class AgentEventStoreConflictError extends Error {
+    sessionId;
+    expectedRevision;
+    actualRevision;
+    constructor(sessionId, expectedRevision, actualRevision) {
+        super(`Agent event store conflict for session "${sessionId}": expected revision ${expectedRevision}, found ${actualRevision}.`);
+        this.name = 'AgentEventStoreConflictError';
+        this.sessionId = sessionId;
+        this.expectedRevision = expectedRevision;
+        this.actualRevision = actualRevision;
+    }
+}
+const clone = (value) => structuredClone(value);
+const createSnapshot = (sessionId, revision, events) => ({
+    schemaVersion: SNAPSHOT_SCHEMA_VERSION,
+    sessionId,
+    revision,
+    updatedAt: Date.now(),
+    events: clone([...events]),
+});
+export class InMemoryAgentEventStore {
+    eventSchemaVersion = 2;
+    snapshots = new Map();
+    archives = new Map();
+    async load(sessionId) {
+        const snapshot = this.snapshots.get(sessionId);
+        return snapshot ? clone(snapshot) : undefined;
+    }
+    async save(sessionId, events, expectedRevision) {
+        const actualRevision = this.snapshots.get(sessionId)?.revision ?? 0;
+        if (actualRevision !== expectedRevision) {
+            throw new AgentEventStoreConflictError(sessionId, expectedRevision, actualRevision);
+        }
+        const revision = expectedRevision + 1;
+        this.snapshots.set(sessionId, createSnapshot(sessionId, revision, events));
+        return revision;
+    }
+    async archive(archive) {
+        const nextArchive = clone(archive);
+        const key = `${archive.sessionId}\n${archive.archiveId}`;
+        const existing = this.archives.get(key);
+        if (existing) {
+            const existingIds = existing.events.map((event) => event.id).join('\n');
+            const nextIds = nextArchive.events.map((event) => event.id).join('\n');
+            if (existingIds !== nextIds) {
+                throw new Error(`Archive "${archive.archiveId}" already exists with different events.`);
+            }
+            return;
+        }
+        this.archives.set(key, nextArchive);
+    }
+    async loadArchive(sessionId, archiveId) {
+        const archive = this.archives.get(`${sessionId}\n${archiveId}`);
+        return archive ? clone(archive) : undefined;
+    }
+}
+const assertSessionId = (sessionId) => {
+    if (!sessionId.trim())
+        throw new Error('Agent event store sessionId must not be empty.');
+};
+const decodeSnapshot = (value, sessionId) => {
+    const snapshot = value;
+    if (snapshot?.schemaVersion === SNAPSHOT_SCHEMA_VERSION) {
+        try {
+            return validateAgentEventSnapshotV2(value, sessionId);
+        }
+        catch {
+            throw new Error(`Invalid agent event snapshot for session "${sessionId}".`);
+        }
+    }
+    if (!snapshot
+        || snapshot.schemaVersion !== 1
+        || snapshot.sessionId !== sessionId
+        || !Number.isSafeInteger(snapshot.revision)
+        || (snapshot.revision ?? -1) < 1
+        || !Array.isArray(snapshot.events)) {
+        throw new Error(`Invalid agent event snapshot for session "${sessionId}".`);
+    }
+    return snapshot;
+};
+const decodeArchive = (value, sessionId, archiveId) => {
+    const archive = value;
+    if (archive?.schemaVersion === ARCHIVE_SCHEMA_VERSION) {
+        try {
+            return validateAgentEventArchiveV2(value, sessionId, archiveId);
+        }
+        catch {
+            throw new Error(`Invalid agent event archive "${archiveId}" for session "${sessionId}".`);
+        }
+    }
+    if (!archive
+        || archive.schemaVersion !== 1
+        || archive.sessionId !== sessionId
+        || archive.archiveId !== archiveId
+        || !Array.isArray(archive.events)) {
+        throw new Error(`Invalid agent event archive "${archiveId}" for session "${sessionId}".`);
+    }
+    return archive;
+};
+const sleep = async (milliseconds) => {
+    await new Promise((resolve) => setTimeout(resolve, milliseconds));
+};
+export class FileAgentEventStore {
+    eventSchemaVersion = 2;
+    rootDir;
+    lockTimeoutMs;
+    constructor(options) {
+        if (!options.rootDir.trim())
+            throw new Error('FileAgentEventStore rootDir must not be empty.');
+        this.rootDir = plugins.path.resolve(options.rootDir);
+        this.lockTimeoutMs = options.lockTimeoutMs ?? 10_000;
+        if (!Number.isSafeInteger(this.lockTimeoutMs) || this.lockTimeoutMs <= 0) {
+            throw new Error('lockTimeoutMs must be a positive integer.');
+        }
+    }
+    sessionKey(sessionId) {
+        assertSessionId(sessionId);
+        return plugins.crypto.createHash('sha256').update(sessionId).digest('hex');
+    }
+    snapshotPath(sessionId) {
+        return plugins.path.join(this.rootDir, 'sessions', `${this.sessionKey(sessionId)}.bin`);
+    }
+    archivePath(sessionId, archiveId) {
+        if (!archiveId.trim())
+            throw new Error('Agent event archiveId must not be empty.');
+        const archiveKey = plugins.crypto.createHash('sha256').update(archiveId).digest('hex');
+        return plugins.path.join(this.rootDir, 'archives', this.sessionKey(sessionId), `${archiveKey}.bin`);
+    }
+    async readValue(filePath) {
+        try {
+            return plugins.v8.deserialize(await plugins.fs.readFile(filePath));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return undefined;
+            throw error;
+        }
+    }
+    async syncDirectory(directoryPath) {
+        const handle = await plugins.fs.open(directoryPath, 'r');
+        try {
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    async writeAtomic(filePath, value) {
+        const directoryPath = plugins.path.dirname(filePath);
+        await plugins.fs.mkdir(directoryPath, { recursive: true });
+        const temporaryPath = `${filePath}.${process.pid}.${plugins.crypto.randomUUID()}.tmp`;
+        let handle;
+        try {
+            handle = await plugins.fs.open(temporaryPath, 'wx');
+            await handle.writeFile(plugins.v8.serialize(value));
+            await handle.sync();
+            await handle.close();
+            handle = undefined;
+            await plugins.fs.rename(temporaryPath, filePath);
+            await this.syncDirectory(directoryPath);
+        }
+        finally {
+            if (handle)
+                await handle.close().catch(() => undefined);
+            await plugins.fs.rm(temporaryPath, { force: true });
+        }
+    }
+    async withSessionLock(sessionId, operation) {
+        const lockPath = plugins.path.join(this.rootDir, 'locks', `${this.sessionKey(sessionId)}.lock`);
+        const ownerPath = plugins.path.join(lockPath, 'owner');
+        const ownerToken = plugins.crypto.randomUUID();
+        const ownerRecord = JSON.stringify({ token: ownerToken });
+        await plugins.fs.mkdir(plugins.path.dirname(lockPath), { recursive: true });
+        const startedAt = Date.now();
+        while (true) {
+            try {
+                await plugins.fs.mkdir(lockPath);
+                try {
+                    await plugins.fs.writeFile(ownerPath, ownerRecord, 'utf8');
+                }
+                catch (error) {
+                    await plugins.fs.rm(lockPath, { recursive: true, force: true });
+                    throw error;
+                }
+                break;
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST')
+                    throw error;
+                if (Date.now() - startedAt >= this.lockTimeoutMs) {
+                    throw new Error(`Timed out waiting for the event-store lock for session "${sessionId}" at "${lockPath}".`);
+                }
+                await sleep(20);
+            }
+        }
+        try {
+            return await operation();
+        }
+        finally {
+            let stillOwner = false;
+            try {
+                const owner = JSON.parse(await plugins.fs.readFile(ownerPath, 'utf8'));
+                stillOwner = owner.token === ownerToken;
+            }
+            catch { }
+            if (stillOwner)
+                await plugins.fs.rm(lockPath, { recursive: true, force: true });
+        }
+    }
+    async load(sessionId) {
+        const value = await this.readValue(this.snapshotPath(sessionId));
+        return value === undefined ? undefined : decodeSnapshot(value, sessionId);
+    }
+    async save(sessionId, events, expectedRevision) {
+        return this.withSessionLock(sessionId, async () => {
+            const filePath = this.snapshotPath(sessionId);
+            const currentValue = await this.readValue(filePath);
+            const actualRevision = currentValue === undefined
+                ? 0
+                : decodeSnapshot(currentValue, sessionId).revision;
+            if (actualRevision !== expectedRevision) {
+                throw new AgentEventStoreConflictError(sessionId, expectedRevision, actualRevision);
+            }
+            const revision = expectedRevision + 1;
+            await this.writeAtomic(filePath, createSnapshot(sessionId, revision, events));
+            return revision;
+        });
+    }
+    async archive(archive) {
+        const nextArchive = clone(archive);
+        await this.withSessionLock(archive.sessionId, async () => {
+            const filePath = this.archivePath(archive.sessionId, archive.archiveId);
+            const currentValue = await this.readValue(filePath);
+            if (currentValue !== undefined) {
+                const current = decodeArchive(currentValue, archive.sessionId, archive.archiveId);
+                const currentIds = current.events.map((event) => event.id).join('\n');
+                const nextIds = nextArchive.events.map((event) => event.id).join('\n');
+                if (currentIds !== nextIds) {
+                    throw new Error(`Archive "${archive.archiveId}" already exists with different events.`);
+                }
+                return;
+            }
+            await this.writeAtomic(filePath, nextArchive);
+        });
+    }
+    async loadArchive(sessionId, archiveId) {
+        const value = await this.readValue(this.archivePath(sessionId, archiveId));
+        return value === undefined ? undefined : decodeArchive(value, sessionId, archiveId);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartagent.persistence.js","sourceRoot":"","sources":["../ts_agent/smartagent.persistence.ts"],"names":[],"mappings":"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"}