@coralai/sps-cli 0.63.5 → 0.65.0

package/dist/openai-agent/storage/checkpoint.js

@@ -0,0 +1,141 @@
+import { resolve } from 'node:path';
+import { RunState, } from '@openai/agents';
+import { atomicWriteJson, readJsonFile, requireInteger, requireRecord, requireString, } from './atomic.js';
+import { OpenAIAgentStorageError } from './errors.js';
+import { ExclusiveFileLock } from './lock.js';
+const CHECKPOINT_SCHEMA_VERSION = 1;
+// @openai/agents 0.13.5 RunState.CURRENT_SCHEMA_VERSION.
+const SDK_RUN_STATE_SCHEMA_VERSION = '1.13';
+export class RunCheckpointStore {
+    sessionRoot;
+    path;
+    lockPath;
+    constructor(sessionRoot) {
+        this.sessionRoot = sessionRoot;
+        this.path = resolve(sessionRoot, 'checkpoint.json');
+        this.lockPath = resolve(sessionRoot, '.checkpoint.lock');
+    }
+    load() {
+        return readJsonFile(this.path, parseCheckpoint);
+    }
+    async compareAndSet(expectedRevision, next) {
+        const lock = await ExclusiveFileLock.acquire(this.lockPath);
+        try {
+            const current = await this.load();
+            const revision = current?.revision ?? 0;
+            if (revision !== expectedRevision) {
+                throw new OpenAIAgentStorageError('conflict', `Checkpoint revision changed from ${expectedRevision} to ${revision}`);
+            }
+            validateSerializedRunState(next.serializedRunState);
+            const now = new Date().toISOString();
+            const checkpoint = {
+                ...next,
+                schemaVersion: CHECKPOINT_SCHEMA_VERSION,
+                revision: revision + 1,
+                createdAt: current?.createdAt ?? next.createdAt ?? now,
+                updatedAt: now,
+            };
+            await atomicWriteJson(this.path, checkpoint, parseCheckpoint);
+            return checkpoint;
+        }
+        finally {
+            await lock.release();
+        }
+    }
+    async clear(expectedRevision) {
+        const lock = await ExclusiveFileLock.acquire(this.lockPath);
+        try {
+            const current = await this.load();
+            if (expectedRevision !== undefined &&
+                (current?.revision ?? 0) !== expectedRevision) {
+                throw new OpenAIAgentStorageError('conflict', 'Checkpoint revision changed before clear');
+            }
+            const { unlink } = await import('node:fs/promises');
+            await unlink(this.path).catch((error) => {
+                if (!(error instanceof Error && 'code' in error && error.code === 'ENOENT')) {
+                    throw error;
+                }
+            });
+        }
+        finally {
+            await lock.release();
+        }
+    }
+    async restore(checkpoint, initialAgent, agentBundleVersion, context) {
+        if (!checkpoint.safeToResume) {
+            throw new OpenAIAgentStorageError('provider_state_unavailable', 'Checkpoint is not safe to resume because tool effects are unresolved');
+        }
+        if (checkpoint.agentBundleVersion !== agentBundleVersion) {
+            throw new OpenAIAgentStorageError('provider_state_unavailable', `Checkpoint needs agent bundle ${checkpoint.agentBundleVersion}`);
+        }
+        if (context) {
+            return RunState.fromStringWithContext(initialAgent, checkpoint.serializedRunState, context);
+        }
+        return RunState.fromString(initialAgent, checkpoint.serializedRunState);
+    }
+}
+function parseCheckpoint(value) {
+    const record = requireRecord(value, 'checkpoint');
+    if (record.schemaVersion !== CHECKPOINT_SCHEMA_VERSION) {
+        throw new OpenAIAgentStorageError('corrupt', 'Unsupported checkpoint schema');
+    }
+    if (record.sdkRunStateSchemaVersion !== SDK_RUN_STATE_SCHEMA_VERSION) {
+        throw new OpenAIAgentStorageError('corrupt', 'Unsupported OpenAI RunState schema');
+    }
+    const status = record.status;
+    if (status !== 'running' &&
+        status !== 'waiting_for_input' &&
+        status !== 'cancelled_safe') {
+        throw new OpenAIAgentStorageError('corrupt', 'Invalid checkpoint status');
+    }
+    const serializedRunState = requireString(record, 'serializedRunState');
+    validateSerializedRunState(serializedRunState);
+    const pending = record.pending === undefined
+        ? undefined
+        : parsePendingCheckpoint(record.pending);
+    return {
+        schemaVersion: CHECKPOINT_SCHEMA_VERSION,
+        revision: requireInteger(record, 'revision', 1),
+        status,
+        serializedRunState,
+        sdkRunStateSchemaVersion: SDK_RUN_STATE_SCHEMA_VERSION,
+        agentBundleVersion: requireString(record, 'agentBundleVersion'),
+        ...(pending ? { pending } : {}),
+        ...(typeof record.workspaceStateRef === 'string'
+            ? { workspaceStateRef: record.workspaceStateRef }
+            : {}),
+        lastSafeSequence: requireInteger(record, 'lastSafeSequence'),
+        safeToResume: record.safeToResume === undefined
+            ? false
+            : record.safeToResume === true,
+        createdAt: requireString(record, 'createdAt'),
+        updatedAt: requireString(record, 'updatedAt'),
+        ...(record.metadata && typeof record.metadata === 'object'
+            ? { metadata: record.metadata }
+            : {}),
+    };
+}
+function parsePendingCheckpoint(value) {
+    const record = requireRecord(value, 'checkpoint.pending');
+    return {
+        kind: requireString(record, 'kind'),
+        ...(typeof record.interactionId === 'string'
+            ? { interactionId: record.interactionId }
+            : {}),
+        ...(typeof record.toolCallId === 'string'
+            ? { toolCallId: record.toolCallId }
+            : {}),
+    };
+}
+function validateSerializedRunState(value) {
+    try {
+        const parsed = JSON.parse(value);
+        if (parsed.$schemaVersion !== SDK_RUN_STATE_SCHEMA_VERSION) {
+            throw new Error(`Expected RunState version ${SDK_RUN_STATE_SCHEMA_VERSION}`);
+        }
+    }
+    catch (error) {
+        throw new OpenAIAgentStorageError('corrupt', 'serializedRunState is invalid or unsupported', error);
+    }
+}
+//# sourceMappingURL=checkpoint.js.map

package/dist/openai-agent/storage/checkpoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint.js","sourceRoot":"","sources":["../../../src/openai-agent/storage/checkpoint.ts"],"names":[],"mappings":"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"}

package/dist/openai-agent/storage/errors.d.ts

@@ -0,0 +1,8 @@
+import type { AgentProcessErrorCodeV1 } from '../../runtime/index.js';
+export type OpenAIAgentStorageErrorCode = Extract<AgentProcessErrorCodeV1, 'not_found' | 'corrupt' | 'provider_state_unavailable' | 'persistence_error'> | 'conflict' | 'busy';
+export declare class OpenAIAgentStorageError extends Error {
+    readonly code: OpenAIAgentStorageErrorCode;
+    readonly cause?: unknown | undefined;
+    constructor(code: OpenAIAgentStorageErrorCode, message: string, cause?: unknown | undefined);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/openai-agent/storage/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/openai-agent/storage/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAEtE,MAAM,MAAM,2BAA2B,GACnC,OAAO,CACL,uBAAuB,EACvB,WAAW,GAAG,SAAS,GAAG,4BAA4B,GAAG,mBAAmB,CAC7E,GACD,UAAU,GACV,MAAM,CAAC;AAEX,qBAAa,uBAAwB,SAAQ,KAAK;aAE9B,IAAI,EAAE,2BAA2B;aAEjC,KAAK,CAAC,EAAE,OAAO;gBAFf,IAAI,EAAE,2BAA2B,EACjD,OAAO,EAAE,MAAM,EACC,KAAK,CAAC,EAAE,OAAO,YAAA;CAKlC"}

package/dist/openai-agent/storage/errors.js

@@ -0,0 +1,11 @@
+export class OpenAIAgentStorageError extends Error {
+    code;
+    cause;
+    constructor(code, message, cause) {
+        super(message);
+        this.code = code;
+        this.cause = cause;
+        this.name = 'OpenAIAgentStorageError';
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/openai-agent/storage/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../src/openai-agent/storage/errors.ts"],"names":[],"mappings":"AAUA,MAAM,OAAO,uBAAwB,SAAQ,KAAK;IAE9B;IAEA;IAHlB,YACkB,IAAiC,EACjD,OAAe,EACC,KAAe;QAE/B,KAAK,CAAC,OAAO,CAAC,CAAC;QAJC,SAAI,GAAJ,IAAI,CAA6B;QAEjC,UAAK,GAAL,KAAK,CAAU;QAG/B,IAAI,CAAC,IAAI,GAAG,yBAAyB,CAAC;IACxC,CAAC;CACF"}

package/dist/openai-agent/storage/index.d.ts

@@ -0,0 +1,12 @@
+export * from './atomic.js';
+export * from './checkpoint.js';
+export * from './errors.js';
+export * from './interaction.js';
+export * from './lock.js';
+export * from './output.js';
+export * from './session.js';
+export * from './toolLedger.js';
+export * from './metrics.js';
+export * from './workerStorage.js';
+export * from './workspace.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/openai-agent/storage/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/openai-agent/storage/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC"}

package/dist/openai-agent/storage/index.js

@@ -0,0 +1,12 @@
+export * from './atomic.js';
+export * from './checkpoint.js';
+export * from './errors.js';
+export * from './interaction.js';
+export * from './lock.js';
+export * from './output.js';
+export * from './session.js';
+export * from './toolLedger.js';
+export * from './metrics.js';
+export * from './workerStorage.js';
+export * from './workspace.js';
+//# sourceMappingURL=index.js.map

package/dist/openai-agent/storage/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/openai-agent/storage/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC"}

package/dist/openai-agent/storage/interaction.d.ts

@@ -0,0 +1,45 @@
+import type { JsonValue } from '../../runtime/index.js';
+export type InteractionKind = 'approval' | 'choices' | 'form';
+export type InteractionStatus = 'pending' | 'answered' | 'consumed' | 'cancelled';
+export interface InteractionRecord {
+    interactionId: string;
+    sessionId: string;
+    runId: string;
+    toolCallId: string;
+    toolName: string;
+    kind: InteractionKind;
+    title: string;
+    schema: JsonValue;
+    input: JsonValue;
+    status: InteractionStatus;
+    revision: number;
+    answer?: JsonValue;
+    createdAt: string;
+    updatedAt: string;
+    expiresAt?: string;
+    checkpointRevision?: number;
+}
+export type PendingInteraction = Omit<InteractionRecord, 'status' | 'revision' | 'answer' | 'createdAt' | 'updatedAt'> & {
+    createdAt?: string;
+};
+export type InteractionSubmitResult = 'accepted' | 'duplicate';
+export declare class InteractionStore {
+    private readonly path;
+    private readonly lockPath;
+    constructor(sessionRoot: string);
+    create(interaction: PendingInteraction): Promise<InteractionRecord>;
+    get(interactionId: string): Promise<InteractionRecord | null>;
+    findByToolCallId(toolCallId: string): Promise<InteractionRecord | null>;
+    listPending(): Promise<InteractionRecord[]>;
+    submit(interactionId: string, expectedRevision: number, answer: unknown): Promise<InteractionSubmitResult>;
+    attachCheckpoint(interactionId: string, checkpointRevision: number): Promise<InteractionRecord>;
+    consume(interactionId: string): Promise<InteractionRecord>;
+    cancel(interactionId: string, expectedRevision?: number): Promise<InteractionRecord>;
+    private updatePending;
+    private updateAnswered;
+    private updateWithStatus;
+    private loadDocument;
+    private writeDocument;
+}
+export declare function validateJsonSchema(schema: JsonValue, value: JsonValue): void;
+//# sourceMappingURL=interaction.d.ts.map

package/dist/openai-agent/storage/interaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interaction.d.ts","sourceRoot":"","sources":["../../../src/openai-agent/storage/interaction.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAcxD,MAAM,MAAM,eAAe,GAAG,UAAU,GAAG,SAAS,GAAG,MAAM,CAAC;AAC9D,MAAM,MAAM,iBAAiB,GACzB,SAAS,GACT,UAAU,GACV,UAAU,GACV,WAAW,CAAC;AAEhB,MAAM,WAAW,iBAAiB;IAChC,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,SAAS,CAAC;IAClB,KAAK,EAAE,SAAS,CAAC;IACjB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,MAAM,kBAAkB,GAAG,IAAI,CACnC,iBAAiB,EACjB,QAAQ,GAAG,UAAU,GAAG,QAAQ,GAAG,WAAW,GAAG,WAAW,CAC7D,GAAG;IACF,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAQF,MAAM,MAAM,uBAAuB,GAAG,UAAU,GAAG,WAAW,CAAC;AAE/D,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;gBAEtB,WAAW,EAAE,MAAM;IAKzB,MAAM,CAAC,WAAW,EAAE,kBAAkB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IA+BnE,GAAG,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAI7D,gBAAgB,CACpB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAS9B,WAAW,IAAI,OAAO,CAAC,iBAAiB,EAAE,CAAC;IAO3C,MAAM,CACV,aAAa,EAAE,MAAM,EACrB,gBAAgB,EAAE,MAAM,EACxB,MAAM,EAAE,OAAO,GACd,OAAO,CAAC,uBAAuB,CAAC;IA+D7B,gBAAgB,CACpB,aAAa,EAAE,MAAM,EACrB,kBAAkB,EAAE,MAAM,GACzB,OAAO,CAAC,iBAAiB,CAAC;IASvB,OAAO,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAS1D,MAAM,CACV,aAAa,EAAE,MAAM,EACrB,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,iBAAiB,CAAC;YA0Cf,aAAa;YAOb,cAAc;YAOd,gBAAgB;YA+BhB,YAAY;IAU1B,OAAO,CAAC,aAAa;CAGtB;AA2ID,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,CAQ5E"}

package/dist/openai-agent/storage/interaction.js

@@ -0,0 +1,372 @@
+import { resolve } from 'node:path';
+import { atomicWriteJson, readJsonFile, requireInteger, requireRecord, requireString, } from './atomic.js';
+import { OpenAIAgentStorageError } from './errors.js';
+import { ExclusiveFileLock } from './lock.js';
+const INTERACTION_STORE_SCHEMA_VERSION = 1;
+const MAX_ANSWER_BYTES = 1024 * 1024;
+export class InteractionStore {
+    path;
+    lockPath;
+    constructor(sessionRoot) {
+        this.path = resolve(sessionRoot, 'interactions.json');
+        this.lockPath = resolve(sessionRoot, '.interactions.lock');
+    }
+    async create(interaction) {
+        const lock = await ExclusiveFileLock.acquire(this.lockPath);
+        try {
+            const document = await this.loadDocument();
+            const existing = document.interactions[interaction.interactionId];
+            if (existing) {
+                if (!sameInteraction(existing, interaction)) {
+                    throw new OpenAIAgentStorageError('conflict', `Interaction ${interaction.interactionId} already has different durable metadata`);
+                }
+                return existing;
+            }
+            const now = new Date().toISOString();
+            const record = {
+                ...interaction,
+                status: 'pending',
+                revision: 1,
+                createdAt: interaction.createdAt ?? now,
+                updatedAt: now,
+            };
+            document.interactions[record.interactionId] = record;
+            document.revision += 1;
+            await this.writeDocument(document);
+            return record;
+        }
+        finally {
+            await lock.release();
+        }
+    }
+    async get(interactionId) {
+        return (await this.loadDocument()).interactions[interactionId] ?? null;
+    }
+    async findByToolCallId(toolCallId) {
+        const document = await this.loadDocument();
+        return (Object.values(document.interactions).find((record) => record.toolCallId === toolCallId) ?? null);
+    }
+    async listPending() {
+        const document = await this.loadDocument();
+        return Object.values(document.interactions).filter((record) => record.status === 'pending');
+    }
+    async submit(interactionId, expectedRevision, answer) {
+        const normalized = normalizeJsonValue(answer, 'interaction answer');
+        if (Buffer.byteLength(JSON.stringify(normalized), 'utf8') > MAX_ANSWER_BYTES) {
+            throw new OpenAIAgentStorageError('persistence_error', `Interaction answer exceeds ${MAX_ANSWER_BYTES} bytes`);
+        }
+        const lock = await ExclusiveFileLock.acquire(this.lockPath);
+        try {
+            const document = await this.loadDocument();
+            const record = document.interactions[interactionId];
+            if (!record) {
+                throw new OpenAIAgentStorageError('not_found', `Interaction ${interactionId} was not found`);
+            }
+            if (record.status === 'cancelled') {
+                throw new OpenAIAgentStorageError('conflict', `Interaction ${interactionId} was cancelled`);
+            }
+            if (record.status === 'answered' || record.status === 'consumed') {
+                if (deepEqualJson(record.answer, normalized))
+                    return 'duplicate';
+                throw new OpenAIAgentStorageError('conflict', `Interaction ${interactionId} already has a different answer`);
+            }
+            if (record.revision !== expectedRevision) {
+                throw new OpenAIAgentStorageError('conflict', `Interaction revision changed from ${expectedRevision} to ${record.revision}`);
+            }
+            if (record.expiresAt &&
+                Date.parse(record.expiresAt) <= Date.now()) {
+                throw new OpenAIAgentStorageError('conflict', `Interaction ${interactionId} expired`);
+            }
+            validateJsonSchema(record.schema, normalized);
+            const next = {
+                ...record,
+                status: 'answered',
+                revision: record.revision + 1,
+                answer: normalized,
+                updatedAt: new Date().toISOString(),
+            };
+            document.interactions[interactionId] = next;
+            document.revision += 1;
+            await this.writeDocument(document);
+            return 'accepted';
+        }
+        finally {
+            await lock.release();
+        }
+    }
+    async attachCheckpoint(interactionId, checkpointRevision) {
+        return this.updatePending(interactionId, (record) => ({
+            ...record,
+            checkpointRevision,
+            revision: record.revision + 1,
+            updatedAt: new Date().toISOString(),
+        }));
+    }
+    async consume(interactionId) {
+        return this.updateAnswered(interactionId, (record) => ({
+            ...record,
+            status: 'consumed',
+            revision: record.revision + 1,
+            updatedAt: new Date().toISOString(),
+        }));
+    }
+    async cancel(interactionId, expectedRevision) {
+        const lock = await ExclusiveFileLock.acquire(this.lockPath);
+        try {
+            const document = await this.loadDocument();
+            const record = document.interactions[interactionId];
+            if (!record) {
+                throw new OpenAIAgentStorageError('not_found', `Interaction ${interactionId} was not found`);
+            }
+            if (record.status === 'cancelled')
+                return record;
+            if (record.status !== 'pending') {
+                throw new OpenAIAgentStorageError('conflict', `Interaction ${interactionId} is already ${record.status}`);
+            }
+            if (expectedRevision !== undefined &&
+                expectedRevision !== record.revision) {
+                throw new OpenAIAgentStorageError('conflict', `Interaction revision changed from ${expectedRevision} to ${record.revision}`);
+            }
+            const next = {
+                ...record,
+                status: 'cancelled',
+                revision: record.revision + 1,
+                updatedAt: new Date().toISOString(),
+            };
+            document.interactions[interactionId] = next;
+            document.revision += 1;
+            await this.writeDocument(document);
+            return next;
+        }
+        finally {
+            await lock.release();
+        }
+    }
+    async updatePending(interactionId, update) {
+        return this.updateWithStatus(interactionId, 'pending', update);
+    }
+    async updateAnswered(interactionId, update) {
+        return this.updateWithStatus(interactionId, 'answered', update);
+    }
+    async updateWithStatus(interactionId, status, update) {
+        const lock = await ExclusiveFileLock.acquire(this.lockPath);
+        try {
+            const document = await this.loadDocument();
+            const record = document.interactions[interactionId];
+            if (!record) {
+                throw new OpenAIAgentStorageError('not_found', `Interaction ${interactionId} was not found`);
+            }
+            if (record.status !== status) {
+                throw new OpenAIAgentStorageError('conflict', `Interaction ${interactionId} is ${record.status}, expected ${status}`);
+            }
+            const next = update(record);
+            document.interactions[interactionId] = next;
+            document.revision += 1;
+            await this.writeDocument(document);
+            return next;
+        }
+        finally {
+            await lock.release();
+        }
+    }
+    async loadDocument() {
+        return ((await readJsonFile(this.path, parseDocument)) ?? {
+            schemaVersion: INTERACTION_STORE_SCHEMA_VERSION,
+            revision: 0,
+            interactions: {},
+        });
+    }
+    writeDocument(document) {
+        return atomicWriteJson(this.path, document, parseDocument);
+    }
+}
+function parseDocument(value) {
+    const document = requireRecord(value, 'interactions');
+    if (document.schemaVersion !== INTERACTION_STORE_SCHEMA_VERSION) {
+        throw new OpenAIAgentStorageError('corrupt', 'Unsupported interaction store schema');
+    }
+    const records = requireRecord(document.interactions, 'interactions.records');
+    return {
+        schemaVersion: INTERACTION_STORE_SCHEMA_VERSION,
+        revision: requireInteger(document, 'revision'),
+        interactions: Object.fromEntries(Object.entries(records).map(([key, record]) => {
+            const parsed = parseInteraction(record);
+            if (parsed.interactionId !== key) {
+                throw new OpenAIAgentStorageError('corrupt', 'Interaction key does not match interactionId');
+            }
+            return [key, parsed];
+        })),
+    };
+}
+function parseInteraction(value) {
+    const record = requireRecord(value, 'interaction');
+    const kind = record.kind;
+    const status = record.status;
+    if (kind !== 'approval' && kind !== 'choices' && kind !== 'form') {
+        throw new OpenAIAgentStorageError('corrupt', 'Invalid interaction kind');
+    }
+    if (status !== 'pending' &&
+        status !== 'answered' &&
+        status !== 'consumed' &&
+        status !== 'cancelled') {
+        throw new OpenAIAgentStorageError('corrupt', 'Invalid interaction status');
+    }
+    const schema = normalizeJsonValue(record.schema, 'interaction schema');
+    const input = normalizeJsonValue(record.input, 'interaction input');
+    const answer = record.answer === undefined
+        ? undefined
+        : normalizeJsonValue(record.answer, 'interaction answer');
+    if ((status === 'answered' || status === 'consumed') &&
+        answer === undefined) {
+        throw new OpenAIAgentStorageError('corrupt', 'Answered interaction has no answer');
+    }
+    return {
+        interactionId: requireString(record, 'interactionId'),
+        sessionId: requireString(record, 'sessionId'),
+        runId: requireString(record, 'runId'),
+        toolCallId: requireString(record, 'toolCallId'),
+        toolName: requireString(record, 'toolName'),
+        kind,
+        title: requireString(record, 'title'),
+        schema,
+        input,
+        status,
+        revision: requireInteger(record, 'revision', 1),
+        ...(answer === undefined ? {} : { answer }),
+        createdAt: requireString(record, 'createdAt'),
+        updatedAt: requireString(record, 'updatedAt'),
+        ...(typeof record.expiresAt === 'string'
+            ? { expiresAt: record.expiresAt }
+            : {}),
+        ...(record.checkpointRevision === undefined
+            ? {}
+            : {
+                checkpointRevision: requireInteger(record, 'checkpointRevision', 1),
+            }),
+    };
+}
+function sameInteraction(existing, next) {
+    return (existing.sessionId === next.sessionId &&
+        existing.runId === next.runId &&
+        existing.toolCallId === next.toolCallId &&
+        existing.toolName === next.toolName &&
+        existing.kind === next.kind &&
+        existing.title === next.title &&
+        deepEqualJson(existing.schema, next.schema) &&
+        deepEqualJson(existing.input, next.input));
+}
+function normalizeJsonValue(value, label) {
+    try {
+        const serialized = JSON.stringify(value);
+        if (serialized === undefined)
+            throw new Error(`${label} is undefined`);
+        return JSON.parse(serialized);
+    }
+    catch (error) {
+        throw new OpenAIAgentStorageError('persistence_error', `${label} must be JSON serializable`, error);
+    }
+}
+function deepEqualJson(left, right) {
+    return left !== undefined && stableStringify(left) === stableStringify(right);
+}
+function stableStringify(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map(stableStringify).join(',')}]`;
+    }
+    if (value && typeof value === 'object') {
+        return `{${Object.keys(value)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`)
+            .join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+export function validateJsonSchema(schema, value) {
+    if (!schema || typeof schema !== 'object' || Array.isArray(schema)) {
+        throw new OpenAIAgentStorageError('corrupt', 'Interaction schema must be an object');
+    }
+    validateSchemaNode(schema, value, '$');
+}
+function validateSchemaNode(schema, value, path) {
+    if (Array.isArray(schema.enum)) {
+        const matches = schema.enum.some((candidate) => stableStringify(candidate) === stableStringify(value));
+        if (!matches)
+            schemaFailure(path, 'is not one of the allowed values');
+    }
+    const type = schema.type;
+    if (type === 'object') {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            schemaFailure(path, 'must be an object');
+        }
+        const objectValue = value;
+        const properties = schema.properties &&
+            typeof schema.properties === 'object' &&
+            !Array.isArray(schema.properties)
+            ? schema.properties
+            : {};
+        const required = Array.isArray(schema.required)
+            ? schema.required.filter((entry) => typeof entry === 'string')
+            : [];
+        for (const key of required) {
+            if (!(key in objectValue))
+                schemaFailure(`${path}.${key}`, 'is required');
+        }
+        if (schema.additionalProperties === false) {
+            for (const key of Object.keys(objectValue)) {
+                if (!(key in properties)) {
+                    schemaFailure(`${path}.${key}`, 'is not allowed');
+                }
+            }
+        }
+        for (const [key, child] of Object.entries(properties)) {
+            if (key in objectValue) {
+                if (!child || typeof child !== 'object' || Array.isArray(child)) {
+                    throw new OpenAIAgentStorageError('corrupt', `Invalid schema at ${path}.${key}`);
+                }
+                validateSchemaNode(child, objectValue[key], `${path}.${key}`);
+            }
+        }
+        return;
+    }
+    if (type === 'array') {
+        if (!Array.isArray(value))
+            schemaFailure(path, 'must be an array');
+        const arrayValue = value;
+        checkLength(schema, arrayValue.length, path, 'Items');
+        if (schema.items &&
+            typeof schema.items === 'object' &&
+            !Array.isArray(schema.items)) {
+            arrayValue.forEach((item, index) => validateSchemaNode(schema.items, item, `${path}[${index}]`));
+        }
+        return;
+    }
+    if (type === 'string') {
+        if (typeof value !== 'string')
+            schemaFailure(path, 'must be a string');
+        checkLength(schema, value.length, path, 'Length');
+        return;
+    }
+    if (type === 'boolean' && typeof value !== 'boolean') {
+        schemaFailure(path, 'must be a boolean');
+    }
+    if ((type === 'number' || type === 'integer') &&
+        (typeof value !== 'number' ||
+            !Number.isFinite(value) ||
+            (type === 'integer' && !Number.isInteger(value)))) {
+        schemaFailure(path, `must be ${type === 'integer' ? 'an integer' : 'a number'}`);
+    }
+}
+function checkLength(schema, length, path, suffix) {
+    const minimum = schema[`min${suffix}`];
+    const maximum = schema[`max${suffix}`];
+    if (typeof minimum === 'number' && length < minimum) {
+        schemaFailure(path, `must contain at least ${minimum}`);
+    }
+    if (typeof maximum === 'number' && length > maximum) {
+        schemaFailure(path, `must contain at most ${maximum}`);
+    }
+}
+function schemaFailure(path, message) {
+    throw new OpenAIAgentStorageError('conflict', `Interaction answer ${path} ${message}`);
+}
+//# sourceMappingURL=interaction.js.map