@modelprofile.com/flexharness 10.24.0 → 11.0.0

package/dist_ts/classes.flexharness.deletion.js

@@ -0,0 +1,396 @@
+import { FlexHarnessAbortError, FlexHarnessNotFoundError, FlexHarnessValidationError, } from './errors.js';
+import { cloneSerializable } from './utils.json.js';
+import { publicSnapshot, requireTransferIdentifier } from './utils.transfer.js';
+import { validateDeleteSessionGenerationCohortInput, validateIdentifier, } from './utils.validation.js';
+import { requireSessionGeneration, combineErrors } from './utils.flexharness.js';
+function matchesSessionGeneration(session, expected) {
+    const actual = requireSessionGeneration(session);
+    return actual.sessionGenerationId === expected.sessionGenerationId
+        && actual.sessionGenerationSequence === expected.sessionGenerationSequence;
+}
+/**
+ * Session deletion: reservations, subtree tombstones and the cleanup of every domain a session
+ * owns.
+ */
+export class FlexHarnessSessionDeletion {
+    core;
+    constructor(core) {
+        this.core = core;
+    }
+    async deleteSessionGenerationCohort(scopeId, input) {
+        const validated = validateDeleteSessionGenerationCohortInput(input);
+        requireTransferIdentifier(validated.root.sessionId, 'root.sessionId');
+        for (const entry of validated.authorizedBySessionId.values()) {
+            requireTransferIdentifier(entry.sessionId, 'authorizedCohort sessionId');
+        }
+        this.core.commands.assertNoAmbientSlashCommandTeardown({
+            scopeId,
+            sessionId: validated.root.sessionId,
+        });
+        const { scope, state } = await this.core.resolveState(scopeId);
+        this.core.commands.assertNoAmbientSlashCommandTeardown({ storageKey: state.storageKey });
+        const plan = await this.core.withScopeMutationOwnership(state, async () => {
+            const stored = state.sessions.get(validated.root.sessionId);
+            if (stored) {
+                if (!matchesSessionGeneration(stored.session, validated.root)) {
+                    return { matched: false };
+                }
+                const subtree = this.collectSessionSubtree(state, validated.root.sessionId);
+                const descendantRoots = this.descendantTombstoneRoots(state, validated.root.sessionId);
+                this.assertAuthorizedSessionGenerationCohort([
+                    ...subtree.map((entry) => entry.session),
+                    ...this.tombstonesForRoots(state, descendantRoots),
+                ], validated.authorizedBySessionId);
+                const reservation = await this.core.mutateScopeOwned(state, () => this.reserveLiveSessionDeletion(state, validated.root.sessionId, stored, subtree, descendantRoots));
+                return {
+                    matched: true,
+                    deletion: this.startReservedSessionDeletion(state, scopeId, scope.scope, validated.root.sessionId, reservation),
+                };
+            }
+            const tombstone = state.tombstones.get(validated.root.sessionId);
+            if (!tombstone || !matchesSessionGeneration(tombstone, validated.root)) {
+                return { matched: false };
+            }
+            this.core.imports.assertNoCommittingSessionImport(state, validated.root.sessionId);
+            const rootSessionId = tombstone.rootSessionId ?? tombstone.sessionId;
+            const descendantRoots = this.descendantTombstoneRoots(state, rootSessionId);
+            this.assertAuthorizedSessionGenerationCohort(this.tombstonesForRoots(state, [rootSessionId, ...descendantRoots]), validated.authorizedBySessionId);
+            return {
+                matched: true,
+                deletion: this.startSessionDeletion(state, scopeId, scope.scope, validated.root.sessionId),
+            };
+        });
+        if (!plan.matched)
+            return publicSnapshot({ matched: false });
+        if (!plan.deletion)
+            throw new Error('Matched session deletion has no cleanup operation.');
+        await plan.deletion;
+        return publicSnapshot({ matched: true });
+    }
+    async deleteSession(scopeId, sessionId) {
+        this.core.commands.assertNoAmbientSlashCommandTeardown({ scopeId, sessionId });
+        const { scope, state } = await this.core.resolveState(scopeId);
+        this.core.commands.assertNoAmbientSlashCommandTeardown({ storageKey: state.storageKey });
+        validateIdentifier(sessionId, 'sessionId');
+        await state.scopeQueue;
+        this.core.imports.assertNoCommittingSessionImport(state, sessionId);
+        return this.startSessionDeletion(state, scopeId, scope.scope, sessionId);
+    }
+    startSessionDeletion(state, scopeId, scope, sessionId) {
+        const deletionKey = state.tombstones.get(sessionId)?.rootSessionId ?? sessionId;
+        return this.registerSessionDeletion(state, deletionKey, () => this.deleteSessionInternal(state, scopeId, scope, sessionId));
+    }
+    startReservedSessionDeletion(state, scopeId, scope, sessionId, reservation) {
+        return this.registerSessionDeletion(state, sessionId, () => this.finishReservedSessionDeletion(state, scopeId, scope, sessionId, reservation));
+    }
+    registerSessionDeletion(state, deletionKey, operation) {
+        const existingDeletion = state.sessionDeletions.get(deletionKey);
+        if (existingDeletion)
+            return existingDeletion;
+        let deletion;
+        deletion = operation().finally(() => {
+            if (state.sessionDeletions.get(deletionKey) === deletion) {
+                state.sessionDeletions.delete(deletionKey);
+            }
+        });
+        state.sessionDeletions.set(deletionKey, deletion);
+        return deletion;
+    }
+    assertAuthorizedSessionGenerationCohort(entries, authorizedBySessionId) {
+        for (const entry of entries) {
+            const authorized = authorizedBySessionId.get(entry.sessionId);
+            if (!authorized || !matchesSessionGeneration(entry, authorized)) {
+                throw new FlexHarnessValidationError(`authorizedCohort does not authorize the exact generation of session "${entry.sessionId}".`);
+            }
+        }
+    }
+    reserveLiveSessionDeletion(state, sessionId, stored, subtree, descendantRoots) {
+        if (state.sessions.get(sessionId) !== stored) {
+            throw new FlexHarnessNotFoundError('Session', sessionId);
+        }
+        const rootDepth = stored.session.depth ?? 0;
+        const deletedAt = new Date().toISOString();
+        const deletedSessions = subtree.map((entry) => cloneSerializable(entry.session));
+        const provenanceBySessionId = new Map(subtree.map((entry) => [
+            entry.session.sessionId,
+            this.core.subagentTasks.createSubagentProvenance(state, entry.session),
+        ]));
+        for (const entry of subtree) {
+            const entrySessionId = entry.session.sessionId;
+            const subagent = provenanceBySessionId.get(entrySessionId);
+            state.sessions.delete(entrySessionId);
+            state.retainedSessionCleanups.set(entrySessionId, {
+                stored: entry,
+                domainsCompleted: false,
+            });
+            state.tombstones.set(entrySessionId, {
+                sessionId: entrySessionId,
+                ...requireSessionGeneration(entry.session),
+                deletedAt,
+                rootSessionId: sessionId,
+                depth: (entry.session.depth ?? rootDepth) - rootDepth,
+                ...(entry.session.parentSessionId === undefined
+                    ? {}
+                    : { parentSessionId: entry.session.parentSessionId }),
+                ...(subagent === undefined ? {} : { subagent: cloneSerializable(subagent) }),
+                ...(entry.session.origin === undefined ? {} : { imported: true }),
+            });
+        }
+        return {
+            deletedSessions,
+            descendantRoots: [...descendantRoots],
+        };
+    }
+    async deleteSessionInternal(state, scopeId, scope, sessionId) {
+        const existingTombstone = state.tombstones.get(sessionId);
+        if (existingTombstone) {
+            const rootSessionId = existingTombstone.rootSessionId ?? existingTombstone.sessionId;
+            const descendantRoots = this.descendantTombstoneRoots(state, sessionId)
+                .filter((candidate) => candidate !== rootSessionId);
+            try {
+                const orphanErrors = await this.core.lifecycle.closeOrphanedResources(state.storageKey);
+                if (orphanErrors.length > 0)
+                    throw combineErrors(orphanErrors);
+                for (const descendantRoot of descendantRoots) {
+                    await this.finishTombstoneCleanup(state, descendantRoot, scopeId, { scopeId, scope });
+                }
+                await this.finishTombstoneCleanup(state, rootSessionId, scopeId, { scopeId, scope });
+            }
+            catch (error) {
+                throw this.core.projectOperationError(error, 'persistence', scopeId, sessionId, 'session-delete');
+            }
+            return;
+        }
+        const stored = this.core.requireSession(state, sessionId);
+        const reservation = await this.core.mutateScope(state, () => {
+            const subtree = this.collectSessionSubtree(state, sessionId);
+            const descendantRoots = this.descendantTombstoneRoots(state, sessionId);
+            return this.reserveLiveSessionDeletion(state, sessionId, stored, subtree, descendantRoots);
+        });
+        await this.finishReservedSessionDeletion(state, scopeId, scope, sessionId, reservation);
+    }
+    async finishReservedSessionDeletion(state, scopeId, scope, sessionId, reservation) {
+        const { deletedSessions, descendantRoots } = reservation;
+        const reason = this.core.trustInternalError(new FlexHarnessAbortError('The session subtree was deleted.'));
+        const configurationSettlement = this.core.configurations.abortSessionConfigurations(state.storageKey, reason, new Set(deletedSessions.map((deleted) => deleted.sessionId)));
+        if (configurationSettlement)
+            await configurationSettlement;
+        const slashCommandErrors = [];
+        for (const deleted of deletedSessions) {
+            const listingSettlement = this.core.commands.abortSlashCommandListings(state.storageKey, reason, deleted.sessionId);
+            if (listingSettlement)
+                await listingSettlement;
+            await this.core.commands.abortSlashCommandExecutions(state.storageKey, reason, slashCommandErrors, deleted.sessionId);
+        }
+        const childFirstDeletedSessions = [...deletedSessions].sort((left, right) => (right.depth ?? 0) - (left.depth ?? 0)
+            || left.sessionId.localeCompare(right.sessionId));
+        for (const deleted of childFirstDeletedSessions) {
+            const active = state.activeRuns.get(deleted.sessionId);
+            if (active) {
+                this.core.runs.cancelRun(active, reason, this.core.compaction.createCompactorContext(scopeId, scope, state.storageKey, deleted.sessionId));
+            }
+        }
+        try {
+            const orphanErrors = [
+                ...slashCommandErrors,
+                ...await this.core.lifecycle.closeOrphanedResources(state.storageKey),
+            ];
+            if (orphanErrors.length > 0)
+                throw combineErrors(orphanErrors);
+            for (const descendantRoot of descendantRoots) {
+                await this.finishTombstoneCleanup(state, descendantRoot, scopeId, { scopeId, scope });
+            }
+            await this.finishTombstoneCleanup(state, sessionId, scopeId, { scopeId, scope });
+        }
+        catch (error) {
+            throw this.core.projectOperationError(error, 'persistence', scopeId, sessionId, 'session-delete');
+        }
+        for (const deleted of childFirstDeletedSessions) {
+            this.core.emitEvent(scopeId, deleted, {
+                type: 'session.deleted',
+                session: publicSnapshot(deleted),
+            });
+        }
+    }
+    async cleanupSessionDomains(state, tombstone) {
+        const storageKey = state.storageKey;
+        const sessionId = tombstone.sessionId;
+        const projectManagementCleanup = async () => {
+            await this.core.projects.projectManagementQueues.get(this.core.projects.projectManagementKey(storageKey, sessionId));
+            await this.core.projects.tombstoneProjectManagementSession(state, tombstone);
+        };
+        const resultStore = this.core.stores.results;
+        const resultCleanup = async () => {
+            // A result being saved for the session is written before its results are deleted.
+            await this.core.results.resultQueues.get(this.core.results.resultQueueKey(storageKey, sessionId));
+            await resultStore.deleteSession(storageKey, sessionId);
+        };
+        const results = await Promise.allSettled([
+            this.core.stores.agentEvents.deleteSession(storageKey, sessionId),
+            this.core.stores.jobs.deleteSession(storageKey, sessionId),
+            this.core.stores.projections.deleteSession(storageKey, sessionId),
+            this.core.stores.permissions.deleteSession(storageKey, sessionId),
+            ...(resultStore ? [resultCleanup()] : []),
+            // An imported session refuses every project-management write, so it has no state to fence.
+            ...(tombstone.imported ? [] : [projectManagementCleanup()]),
+        ]);
+        const errors = results
+            .filter((result) => result.status === 'rejected')
+            .map((result) => result.reason);
+        if (errors.length > 0)
+            throw combineErrors(errors);
+    }
+    collectSessionSubtree(state, rootSessionId) {
+        const subtree = [];
+        const pending = [rootSessionId];
+        const seen = new Set();
+        while (pending.length > 0) {
+            const sessionId = pending.pop();
+            if (seen.has(sessionId)) {
+                throw new FlexHarnessValidationError('Session relationships contain a cycle.');
+            }
+            seen.add(sessionId);
+            const stored = state.sessions.get(sessionId);
+            if (!stored)
+                continue;
+            subtree.push(stored);
+            const children = [...state.sessions.values()]
+                .filter((candidate) => candidate.session.parentSessionId === sessionId)
+                .map((candidate) => candidate.session.sessionId)
+                .sort()
+                .reverse();
+            pending.push(...children);
+        }
+        return subtree;
+    }
+    tombstoneGroup(state, rootSessionId) {
+        return [...state.tombstones.values()]
+            .filter((tombstone) => (tombstone.rootSessionId ?? tombstone.sessionId) === rootSessionId)
+            .sort((left, right) => (right.depth ?? 0) - (left.depth ?? 0)
+            || left.sessionId.localeCompare(right.sessionId));
+    }
+    tombstonesForRoots(state, rootSessionIds) {
+        return [...new Set(rootSessionIds)]
+            .flatMap((rootSessionId) => this.tombstoneGroup(state, rootSessionId));
+    }
+    descendantTombstoneRoots(state, ancestorSessionId) {
+        return [...new Set([...state.tombstones.values()]
+                .map((tombstone) => tombstone.rootSessionId ?? tombstone.sessionId)
+                .filter((rootSessionId) => rootSessionId !== ancestorSessionId
+                && this.core.isSessionAncestor(state, ancestorSessionId, rootSessionId)))]
+            .sort((left, right) => this.core.sessionAncestryDepth(state, right) - this.core.sessionAncestryDepth(state, left)
+            || left.localeCompare(right));
+    }
+    orderTombstoneRootsChildFirst(state, rootSessionIds) {
+        return [...rootSessionIds].sort((left, right) => this.core.sessionAncestryDepth(state, right) - this.core.sessionAncestryDepth(state, left)
+            || left.localeCompare(right));
+    }
+    finishTombstoneCleanup(state, rootSessionId, scopeId, invocation) {
+        const existing = state.tombstoneCleanups.get(rootSessionId);
+        if (existing)
+            return existing;
+        let cleanup;
+        cleanup = this.finishTombstoneCleanupInternal(state, rootSessionId, scopeId, invocation).finally(() => {
+            if (state.tombstoneCleanups.get(rootSessionId) === cleanup) {
+                state.tombstoneCleanups.delete(rootSessionId);
+            }
+        });
+        state.tombstoneCleanups.set(rootSessionId, cleanup);
+        return cleanup;
+    }
+    async finishTombstoneCleanupInternal(state, rootSessionId, scopeId, invocation) {
+        for (const descendantRoot of this.descendantTombstoneRoots(state, rootSessionId)) {
+            await this.finishTombstoneCleanup(state, descendantRoot, scopeId, invocation);
+        }
+        const group = this.tombstoneGroup(state, rootSessionId);
+        if (group.length === 0)
+            return;
+        const exactInvocation = invocation ?? {
+            scopeId: state.scopeContext.scopeId,
+            scope: state.scopeContext.scope,
+        };
+        const groupIds = new Set(group.map((tombstone) => tombstone.sessionId));
+        const reason = this.core.trustInternalError(new FlexHarnessAbortError('The session subtree was deleted.'));
+        const contextFor = (sessionId, retained) => exactInvocation
+            ? this.core.compaction.createCompactorContext(exactInvocation.scopeId, exactInvocation.scope, state.storageKey, sessionId)
+            : retained?.stored.compactorContext;
+        for (const sessionId of groupIds) {
+            const retained = state.retainedSessionCleanups.get(sessionId);
+            const context = contextFor(sessionId, retained);
+            if (retained) {
+                this.core.compaction.abortCompactorLifecycle(retained.stored, reason);
+                this.core.prompts.cancelStoredPromptQueue(retained.stored, reason, undefined, context);
+            }
+            const run = state.activeRuns.get(sessionId);
+            if (run)
+                this.core.runs.cancelRun(run, reason, context);
+        }
+        await Promise.allSettled([...groupIds]
+            .map((sessionId) => state.sessionInitializations.get(sessionId))
+            .filter((completion) => completion !== undefined));
+        for (const tombstone of group) {
+            const sessionId = tombstone.sessionId;
+            const retained = state.retainedSessionCleanups.get(sessionId);
+            const errors = [];
+            const run = state.activeRuns.get(sessionId);
+            const context = contextFor(sessionId, retained);
+            if (retained && !retained.stored.agentSessionAbortCompleted) {
+                try {
+                    await this.core.lifecycle.abortStoredSession(retained.stored, reason, context);
+                }
+                catch (error) {
+                    errors.push(this.core.projectOperationError(error, 'agentSession', scopeId, sessionId, 'session-delete'));
+                }
+            }
+            if (run) {
+                const settled = await Promise.allSettled([run.completion]);
+                if (settled[0].status === 'rejected') {
+                    this.core.appendUnexpectedErrors(errors, settled[0].reason);
+                }
+            }
+            errors.push(...await this.core.admission.settleDelegatedRunAdmissionOwners(this.core.admission.delegatedRunAdmissionOwnersForGeneration(state, tombstone)));
+            if (retained) {
+                if (retained.stored.promptQueueDrain) {
+                    const settled = await Promise.allSettled([retained.stored.promptQueueDrain]);
+                    if (settled[0].status === 'rejected')
+                        errors.push(settled[0].reason);
+                }
+                try {
+                    await this.core.lifecycle.closeStoredSession(retained.stored, context);
+                }
+                catch (error) {
+                    this.core.appendUnexpectedErrors(errors, this.core.projectOperationError(error, 'toolCleanup', scopeId, sessionId, 'session-delete'));
+                }
+            }
+            if (errors.length > 0) {
+                if (retained
+                    && state.lifecycle === 'retired'
+                    && !this.core.lifecycle.storedSessionCleanupCompleted(retained.stored))
+                    this.core.lifecycle.orphanedStoredSessions.add(retained.stored);
+                throw combineErrors(errors);
+            }
+            if (retained)
+                this.core.prompts.purgeStoredPromptQueue(retained.stored);
+            if (!retained?.domainsCompleted) {
+                if (this.core.lifecycle.hasOrphanedSessionResources(state.storageKey, sessionId)) {
+                    throw new Error(`Session "${sessionId}" still has runtime cleanup ownership.`);
+                }
+                const releaseContext = exactInvocation ?? retained?.stored.compactorContext;
+                if (!releaseContext) {
+                    throw new FlexHarnessValidationError('Tombstone cleanup requires its exact scope context before deleting projection data.');
+                }
+                await this.core.reversions.releaseDeletedSessionReversions(state, state.storageKey, tombstone, releaseContext.scopeId, releaseContext.scope, retained?.stored);
+                await this.cleanupSessionDomains(state, tombstone);
+                if (retained)
+                    retained.domainsCompleted = true;
+            }
+        }
+        await this.core.mutateScope(state, () => {
+            for (const tombstone of group) {
+                state.tombstones.delete(tombstone.sessionId);
+                state.retainedSessionCleanups.delete(tombstone.sessionId);
+            }
+        }, true);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.flexharness.deletion.js","sourceRoot":"","sources":["../ts/classes.flexharness.deletion.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.flexharness.imports.d.ts

@@ -0,0 +1,24 @@
+import { type IFlexBeginSessionImportOptions, type IFlexImportedRun, type IFlexSession, type IFlexSessionImportHandle, type IFlexSessionImportProgress, type TFlexBeginSessionImportResult } from './interfaces.js';
+import type { IStagedSessionImport, IStorageState } from './interfaces.flexharness.js';
+import type { FlexHarnessCore } from './classes.flexharness.core.js';
+/** Staged imports of finished conversations as read-only sessions. */
+export declare class FlexHarnessSessionImports<TScope> {
+    private readonly core;
+    private readonly stagedSessionImports;
+    constructor(core: FlexHarnessCore<TScope>);
+    beginSessionImport(scopeId: string, options: IFlexBeginSessionImportOptions): Promise<TFlexBeginSessionImportResult>;
+    appendImportedRuns(handle: IFlexSessionImportHandle, runs: readonly IFlexImportedRun[]): Promise<IFlexSessionImportProgress>;
+    commitSessionImport(handle: IFlexSessionImportHandle): Promise<IFlexSession>;
+    abortSessionImport(handle: IFlexSessionImportHandle): Promise<void>;
+    assertNoCommittingSessionImport(state: IStorageState, sessionId: string): void;
+    private findStagedSessionImport;
+    private requireStagedSessionImport;
+    private armStagedImportIdleTimer;
+    private clearStagedImportIdleTimer;
+    releaseStagedSessionImport(staged: IStagedSessionImport): void;
+    /**
+     * 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.
+     */
+    private requireImportParent;
+}