@modelprofile.com/flexharness 10.24.0 → 10.24.1

package/dist_ts/classes.flexharness.imports.js

@@ -0,0 +1,345 @@
+import * as plugins from './plugins.js';
+import { FlexHarnessAbortError, FlexHarnessNotFoundError, FlexHarnessQueueFullError, FlexHarnessSessionBusyError, FlexHarnessValidationError, } from './errors.js';
+import { FLEX_SESSION_IMPORT_MAX_DEPTH, } from './interfaces.js';
+import { cloneSerializable } from './utils.json.js';
+import { publicSnapshot } from './utils.transfer.js';
+import { normalizeBeginSessionImportOptions, normalizeImportedRunPage, sessionImportIdentity, validateSessionImportHandle, } from './utils.sessionimport.js';
+import { createSessionMetricsState } from './utils.sessionmetrics.js';
+import { createSessionGenerationId, requireSessionGeneration, combineErrors, } from './utils.flexharness.js';
+/** Staged imports of finished conversations as read-only sessions. */
+export class FlexHarnessSessionImports {
+    core;
+    stagedSessionImports = new Map();
+    constructor(core) {
+        this.core = core;
+    }
+    async beginSessionImport(scopeId, options) {
+        this.core.assertOpen();
+        const normalized = normalizeBeginSessionImportOptions(options);
+        const { scope, state } = await this.core.resolveState(scopeId);
+        await state.scopeQueue;
+        this.core.assertOpen();
+        this.core.assertStateAcceptingWork(state);
+        const { sessionId } = normalized;
+        const identity = sessionImportIdentity(normalized.origin);
+        for (const staged of state.sessionImports.values()) {
+            if (staged.sessionId === sessionId || staged.identity === identity) {
+                throw new FlexHarnessSessionBusyError(staged.sessionId, 'is already being imported');
+            }
+        }
+        for (const stored of state.sessions.values()) {
+            const origin = stored.session.origin;
+            if (origin === undefined || sessionImportIdentity(origin) !== identity)
+                continue;
+            const existing = {
+                status: origin.digest === normalized.origin.digest ? 'already_imported' : 'digest_mismatch',
+                session: stored.session,
+            };
+            return publicSnapshot(existing);
+        }
+        if (state.sessions.has(sessionId)
+            || state.tombstones.has(sessionId)
+            || state.initializingSessions.has(sessionId)) {
+            throw new FlexHarnessValidationError(`Session "${sessionId}" already exists or is being deleted.`);
+        }
+        if (normalized.parent)
+            this.requireImportParent(state, sessionId, normalized.parent);
+        if (this.stagedSessionImports.size >= this.core.sessionImportLimits.maxOpenImports) {
+            throw new FlexHarnessQueueFullError('FlexHarness has reached its open session import limit.');
+        }
+        const staged = {
+            importId: `import_${plugins.crypto.randomUUID()}`,
+            scopeId,
+            state,
+            scope: scope.scope,
+            sessionId,
+            options: normalized,
+            identity,
+            runs: [],
+            runIds: new Set(),
+            messageIds: new Set(),
+            messageCount: 0,
+            bytes: 0,
+            phase: 'staging',
+        };
+        this.stagedSessionImports.set(staged.importId, staged);
+        this.armStagedImportIdleTimer(staged);
+        state.sessionImports.set(sessionId, staged);
+        state.initializingSessions.add(sessionId);
+        const started = {
+            status: 'started',
+            handle: { importId: staged.importId, scopeId, sessionId },
+        };
+        return publicSnapshot(started);
+    }
+    async appendImportedRuns(handle, runs) {
+        const staged = this.requireStagedSessionImport(handle);
+        this.core.assertOpen();
+        this.core.assertStateAcceptingWork(staged.state);
+        const page = normalizeImportedRunPage(runs, staged.sessionId, this.core.sessionImportLimits.maxPageBytes);
+        const runIds = new Set();
+        const messageIds = new Set();
+        for (const run of page.runs) {
+            if (staged.runIds.has(run.user.runId) || runIds.has(run.user.runId)) {
+                throw new FlexHarnessValidationError(`Imported run "${run.user.runId}" is not unique.`);
+            }
+            runIds.add(run.user.runId);
+            for (const message of [run.user, run.assistant]) {
+                if (staged.messageIds.has(message.messageId) || messageIds.has(message.messageId)) {
+                    throw new FlexHarnessValidationError(`Imported message "${message.messageId}" is not unique.`);
+                }
+                messageIds.add(message.messageId);
+            }
+        }
+        const messageCount = staged.messageCount + page.runs.length * 2;
+        if (messageCount > this.core.sessionImportLimits.maxMessagesPerSession) {
+            throw new FlexHarnessValidationError(`An imported session holds at most ${this.core.sessionImportLimits.maxMessagesPerSession} messages.`);
+        }
+        const bytes = staged.bytes + page.bytes;
+        if (bytes > this.core.sessionImportLimits.maxSessionBytes) {
+            throw new FlexHarnessValidationError(`An imported session holds at most ${this.core.sessionImportLimits.maxSessionBytes} message bytes.`);
+        }
+        staged.runs.push(...page.runs);
+        for (const runId of runIds)
+            staged.runIds.add(runId);
+        for (const messageId of messageIds)
+            staged.messageIds.add(messageId);
+        staged.messageCount = messageCount;
+        staged.bytes = bytes;
+        this.armStagedImportIdleTimer(staged);
+        return publicSnapshot({ runs: staged.runs.length, messages: messageCount, bytes });
+    }
+    async commitSessionImport(handle) {
+        const staged = this.requireStagedSessionImport(handle);
+        this.core.assertOpen();
+        const { state, scopeId, sessionId, options } = staged;
+        this.core.assertStateAcceptingWork(state);
+        if (staged.runs.length === 0) {
+            throw new FlexHarnessValidationError('A session import needs at least one run before it is committed.');
+        }
+        staged.phase = 'committing';
+        this.clearStagedImportIdleTimer(staged);
+        const scope = staged.scope;
+        let resolveInitialization;
+        const initialization = new Promise((resolve) => {
+            resolveInitialization = resolve;
+        });
+        let initializationCompleted = false;
+        const completeInitialization = () => {
+            if (initializationCompleted)
+                return;
+            initializationCompleted = true;
+            if (state.sessionInitializations.get(sessionId) === initialization) {
+                state.sessionInitializations.delete(sessionId);
+            }
+            resolveInitialization();
+        };
+        state.sessionInitializations.set(sessionId, initialization);
+        const importedAt = new Date().toISOString();
+        const origin = {
+            kind: 'import',
+            ...cloneSerializable(options.origin),
+            importedAt,
+        };
+        let metadata;
+        let reserved = false;
+        let loaded;
+        try {
+            // A tombstone reserves the id while the projection is written, so a crash before the session
+            // is published leaves only data that the next load or deletion cleans up.
+            await this.core.mutateScope(state, () => {
+                if (state.sessions.has(sessionId) || state.tombstones.has(sessionId)) {
+                    throw this.core.trustInternalError(new FlexHarnessValidationError(`Session "${sessionId}" already exists or is being deleted.`));
+                }
+                const parent = options.parent
+                    ? this.requireImportParent(state, sessionId, options.parent)
+                    : undefined;
+                metadata = {
+                    scopeId,
+                    sessionId,
+                    sessionGenerationId: createSessionGenerationId(),
+                    sessionGenerationSequence: state.revision + 1,
+                    ...(parent?.session.configurationRef === undefined
+                        ? {}
+                        : { configurationRef: parent.session.configurationRef }),
+                    ...(options.title === undefined ? {} : { title: options.title }),
+                    createdAt: options.createdAt,
+                    updatedAt: options.updatedAt,
+                    archivedAt: importedAt,
+                    status: 'idle',
+                    activity: { status: 'idle' },
+                    ...(options.parent === undefined
+                        ? {}
+                        : {
+                            parentSessionId: options.parent.sessionId,
+                            parentRunId: options.parent.runId,
+                            parentToolCallId: options.parent.toolCallId,
+                            agent: options.parent.agent,
+                        }),
+                    depth: parent === undefined ? 0 : (parent.session.depth ?? 0) + 1,
+                    origin,
+                };
+                state.tombstones.set(sessionId, {
+                    sessionId,
+                    ...requireSessionGeneration(metadata),
+                    deletedAt: importedAt,
+                    rootSessionId: sessionId,
+                    depth: 0,
+                    imported: true,
+                });
+            });
+            reserved = true;
+            await this.core.stores.projections.save(state.storageKey, sessionId, {
+                schemaVersion: 3,
+                revision: 1,
+                metrics: createSessionMetricsState(false),
+                messages: staged.runs.flatMap((run) => [run.user, run.assistant]),
+                stagedTerminals: [],
+                reversionSegments: [],
+                revertCursor: 0,
+                excludedRunIds: [],
+                pendingReversionReleases: [],
+            }, 0);
+            const runtime = await this.core.loadSessionRuntime(state, metadata, scopeId, scope);
+            loaded = runtime;
+            await this.core.mutateScope(state, () => {
+                if (state.sessions.has(sessionId)
+                    || state.tombstones.get(sessionId)?.sessionGenerationId !== metadata.sessionGenerationId) {
+                    throw this.core.trustInternalError(new FlexHarnessAbortError('The session import lost its reservation before it was committed.'));
+                }
+                if (options.parent)
+                    this.requireImportParent(state, sessionId, options.parent);
+                state.tombstones.delete(sessionId);
+                state.sessions.set(sessionId, runtime);
+            });
+        }
+        catch (error) {
+            const projected = this.core.projectOperationError(error, 'persistence', scopeId, sessionId, 'session-import');
+            const errors = [projected];
+            if (loaded && state.sessions.get(sessionId) !== loaded) {
+                try {
+                    await this.core.lifecycle.closeStoredSession(loaded);
+                }
+                catch (closeError) {
+                    this.core.lifecycle.orphanedStoredSessions.add(loaded);
+                    errors.push(closeError);
+                }
+            }
+            // A fenced namespace cannot tell whether its last save was persisted; its next load resolves
+            // the reservation instead: a surviving tombstone is cleaned up, a published session is kept.
+            if (reserved && state.tombstones.has(sessionId) && state.lifecycle !== 'fenced') {
+                completeInitialization();
+                try {
+                    await this.core.deletion.finishTombstoneCleanup(state, sessionId, scopeId, { scopeId, scope });
+                }
+                catch (cleanupError) {
+                    errors.push(this.core.projectOperationError(cleanupError, 'persistence', scopeId, sessionId, 'session-import-cleanup'));
+                }
+            }
+            throw combineErrors(errors);
+        }
+        finally {
+            this.releaseStagedSessionImport(staged);
+            completeInitialization();
+        }
+        const result = publicSnapshot(metadata);
+        this.core.emitEvent(scopeId, metadata, { type: 'session.created', session: result });
+        return result;
+    }
+    async abortSessionImport(handle) {
+        const staged = this.findStagedSessionImport(handle);
+        if (!staged)
+            return;
+        if (staged.phase === 'committing') {
+            throw new FlexHarnessSessionBusyError(staged.sessionId, 'is being committed');
+        }
+        this.releaseStagedSessionImport(staged);
+    }
+    assertNoCommittingSessionImport(state, sessionId) {
+        if (state.sessionImports.get(sessionId)?.phase === 'committing') {
+            throw new FlexHarnessSessionBusyError(sessionId, 'is being imported');
+        }
+    }
+    findStagedSessionImport(handle) {
+        const validated = validateSessionImportHandle(handle);
+        const staged = this.stagedSessionImports.get(validated.importId);
+        if (staged
+            && (staged.scopeId !== validated.scopeId || staged.sessionId !== validated.sessionId)) {
+            throw new FlexHarnessValidationError('The session import handle does not match its import.');
+        }
+        return staged;
+    }
+    requireStagedSessionImport(handle) {
+        const staged = this.findStagedSessionImport(handle);
+        if (!staged)
+            throw new FlexHarnessNotFoundError('Session import', handle.importId);
+        if (staged.phase !== 'staging') {
+            throw new FlexHarnessSessionBusyError(staged.sessionId, 'is being committed');
+        }
+        return staged;
+    }
+    armStagedImportIdleTimer(staged) {
+        this.clearStagedImportIdleTimer(staged);
+        const timer = setTimeout(() => {
+            if (staged.idleTimer !== timer)
+                return;
+            delete staged.idleTimer;
+            if (staged.phase === 'staging')
+                this.releaseStagedSessionImport(staged);
+        }, this.core.sessionImportLimits.stagedImportIdleTimeoutMs);
+        timer.unref();
+        staged.idleTimer = timer;
+    }
+    clearStagedImportIdleTimer(staged) {
+        if (staged.idleTimer === undefined)
+            return;
+        clearTimeout(staged.idleTimer);
+        delete staged.idleTimer;
+    }
+    releaseStagedSessionImport(staged) {
+        this.clearStagedImportIdleTimer(staged);
+        if (this.stagedSessionImports.get(staged.importId) === staged) {
+            this.stagedSessionImports.delete(staged.importId);
+        }
+        if (staged.state.sessionImports.get(staged.sessionId) === staged) {
+            staged.state.sessionImports.delete(staged.sessionId);
+            staged.state.initializingSessions.delete(staged.sessionId);
+        }
+        staged.runs = [];
+        staged.runIds.clear();
+        staged.messageIds.clear();
+    }
+    /**
+     * An imported child session belongs to a committed imported parent whose run `parent.runId` holds
+     * the tool call `parent.toolCallId` naming the child, and no other session claims that tool call.
+     */
+    requireImportParent(state, sessionId, parent) {
+        const parentStored = state.initializingSessions.has(parent.sessionId)
+            || state.tombstones.has(parent.sessionId)
+            ? undefined
+            : state.sessions.get(parent.sessionId);
+        if (!parentStored?.session.origin) {
+            throw this.core.trustInternalError(new FlexHarnessValidationError(`The parent of imported session "${sessionId}" must be a committed imported session.`));
+        }
+        if ((parentStored.session.depth ?? 0) + 1 > FLEX_SESSION_IMPORT_MAX_DEPTH) {
+            throw this.core.trustInternalError(new FlexHarnessValidationError(`Imported sessions nest at most ${FLEX_SESSION_IMPORT_MAX_DEPTH} levels deep.`));
+        }
+        const referenced = parentStored.messages.some((message) => message.role === 'assistant'
+            && message.runId === parent.runId
+            && message.parts.some((part) => part.type === 'tool'
+                && part.toolCallId === parent.toolCallId
+                && part.childSessionId === sessionId));
+        if (!referenced) {
+            throw this.core.trustInternalError(new FlexHarnessValidationError(`Parent run "${parent.runId}" has no tool call "${parent.toolCallId}" whose childSessionId is "${sessionId}".`));
+        }
+        for (const stored of state.sessions.values()) {
+            if (stored.session.parentSessionId === parent.sessionId
+                && stored.session.parentRunId === parent.runId
+                && stored.session.parentToolCallId === parent.toolCallId) {
+                throw this.core.trustInternalError(new FlexHarnessValidationError(`Session "${stored.session.sessionId}" already belongs to tool call "${parent.toolCallId}".`));
+            }
+        }
+        return parentStored;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.flexharness.imports.js","sourceRoot":"","sources":["../ts/classes.flexharness.imports.ts"],"names":[],"mappings":"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"}