@modelprofile.com/flexharness 1.0.0

package/dist_ts/classes.flexharness.js

@@ -0,0 +1,1312 @@
+import * as plugins from './plugins.js';
+import { FlexHarnessAbortError, FlexHarnessCallbackOverflowError, FlexHarnessClosedError, FlexHarnessNotFoundError, FlexHarnessPermissionRejectedError, FlexHarnessPermissionStateError, FlexHarnessRunError, FlexHarnessSessionBusyError, FlexHarnessValidationError, errorMessage, errorToInfo, } from './errors.js';
+import { InMemoryFlexHarnessStore } from './classes.stores.js';
+import { assertFlexHarnessSnapshot, cloneSerializable, deepFreeze, normalizeJsonValue, resolveJsonLimits, serializeAgentMessages, } from './utils.json.js';
+import { hydrateAgentMessages, normalizeFlexPrompt, } from './utils.prompt.js';
+const DEFAULT_CALLBACK_LIMITS = {
+    maxEvents: 10_000,
+    maxOutputBytes: 1024 * 1024,
+    maxParts: 2_000,
+};
+function isAsyncIterable(value) {
+    return Boolean(value &&
+        typeof value === 'object' &&
+        typeof value[Symbol.asyncIterator] === 'function');
+}
+async function* normalizeAsyncIterable(iterable, limits) {
+    for await (const value of iterable) {
+        yield normalizeJsonValue(value, limits);
+    }
+}
+function wrapToolSet(tools, limits) {
+    const wrapped = {};
+    for (const [name, tool] of Object.entries(tools)) {
+        const toolRecord = tool;
+        if (typeof toolRecord.execute !== 'function') {
+            wrapped[name] = tool;
+            continue;
+        }
+        const execute = toolRecord.execute;
+        wrapped[name] = {
+            ...toolRecord,
+            execute(input, options) {
+                const output = execute.call(tool, input, options);
+                if (isAsyncIterable(output)) {
+                    return normalizeAsyncIterable(output, limits);
+                }
+                return Promise.resolve(output).then((value) => normalizeJsonValue(value, limits));
+            },
+        };
+    }
+    return wrapped;
+}
+function publicSnapshot(value) {
+    return deepFreeze(cloneSerializable(value));
+}
+function validateIdentifier(value, name) {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new FlexHarnessValidationError(`${name} must be a non-empty string.`);
+    }
+}
+function validateModelIdentity(identity) {
+    validateIdentifier(identity.provider, 'model identity provider');
+    validateIdentifier(identity.model, 'model identity model');
+    if (identity.displayName !== undefined) {
+        validateIdentifier(identity.displayName, 'model identity displayName');
+    }
+}
+function combineErrors(errors) {
+    if (errors.length === 1) {
+        return errors[0];
+    }
+    return new FlexHarnessRunError(errors);
+}
+function isAbortError(error) {
+    return (error instanceof FlexHarnessAbortError ||
+        (error instanceof DOMException && error.name === 'AbortError') ||
+        (error instanceof Error && error.name === 'AbortError'));
+}
+function makeUsage(result) {
+    return {
+        inputTokens: result.usage.inputTokens,
+        outputTokens: result.usage.outputTokens,
+        totalTokens: result.usage.totalTokens,
+        cacheReadTokens: result.usage.cacheReadTokens,
+        cacheWriteTokens: result.usage.cacheWriteTokens,
+    };
+}
+function base64Size(data) {
+    const compact = data.replace(/\s/g, '');
+    if (!/^[A-Za-z0-9+/]*={0,2}$/.test(compact) || compact.length % 4 === 1) {
+        return undefined;
+    }
+    return Buffer.from(compact, 'base64').byteLength;
+}
+function describeAttachment(part) {
+    let source = 'inline-base64';
+    let sizeBytes;
+    let inferredMediaType;
+    if (/^data:/i.test(part.data)) {
+        source = 'data-url';
+        const commaIndex = part.data.indexOf(',');
+        if (commaIndex >= 0) {
+            const metadata = part.data.slice(5, commaIndex);
+            const payload = part.data.slice(commaIndex + 1);
+            const metadataParts = metadata.split(';');
+            if (metadataParts[0]?.includes('/'))
+                inferredMediaType = metadataParts[0];
+            if (metadataParts.some((entry) => entry.toLowerCase() === 'base64')) {
+                sizeBytes = base64Size(payload);
+            }
+            else {
+                try {
+                    sizeBytes = Buffer.byteLength(decodeURIComponent(payload));
+                }
+                catch {
+                    // Malformed URL encoding keeps size indeterminate without exposing the payload.
+                }
+            }
+        }
+    }
+    else {
+        try {
+            const url = new URL(part.data);
+            if (url.protocol === 'http:' || url.protocol === 'https:') {
+                source = 'remote-url';
+            }
+            else {
+                sizeBytes = base64Size(part.data);
+            }
+        }
+        catch {
+            sizeBytes = base64Size(part.data);
+        }
+    }
+    return {
+        source,
+        ...(sizeBytes !== undefined ? { sizeBytes } : {}),
+        ...(part.mediaType ?? inferredMediaType
+            ? { mediaType: part.mediaType ?? inferredMediaType }
+            : {}),
+        ...(part.name ? { name: part.name } : {}),
+    };
+}
+function validateUpdateSessionOptions(options) {
+    if (!options || typeof options !== 'object' || Array.isArray(options)) {
+        throw new FlexHarnessValidationError('updateSession options must be a plain object.');
+    }
+    const keys = Object.keys(options);
+    if (keys.length === 0) {
+        throw new FlexHarnessValidationError('updateSession requires title or archived.');
+    }
+    const unsupportedKey = keys.find((key) => key !== 'title' && key !== 'archived');
+    if (unsupportedKey) {
+        throw new FlexHarnessValidationError(`updateSession does not support "${unsupportedKey}".`);
+    }
+    if (Object.prototype.hasOwnProperty.call(options, 'title')) {
+        if (options.title !== null)
+            validateIdentifier(options.title, 'title');
+    }
+    if (Object.prototype.hasOwnProperty.call(options, 'archived') &&
+        typeof options.archived !== 'boolean') {
+        throw new FlexHarnessValidationError('archived must be a boolean.');
+    }
+}
+function resolveCallbackLimits(limits = {}) {
+    const resolved = {
+        maxEvents: limits.maxEvents ?? DEFAULT_CALLBACK_LIMITS.maxEvents,
+        maxOutputBytes: limits.maxOutputBytes ?? DEFAULT_CALLBACK_LIMITS.maxOutputBytes,
+        maxParts: limits.maxParts ?? DEFAULT_CALLBACK_LIMITS.maxParts,
+    };
+    for (const [name, value] of Object.entries(resolved)) {
+        if (!Number.isSafeInteger(value) || value < 1) {
+            throw new FlexHarnessValidationError(`callbackLimits.${name} must be a positive integer.`);
+        }
+    }
+    return resolved;
+}
+export class FlexHarness {
+    scopeResolver;
+    modelResolver;
+    toolProvider;
+    store;
+    runner;
+    toolOutputLimits;
+    callbackLimits;
+    stateLoads = new Map();
+    listeners = new Set();
+    detachedToolCleanups = new Set();
+    sequence = 0;
+    closed = false;
+    disposePromise;
+    constructor(options) {
+        this.scopeResolver = options.scopeResolver;
+        this.modelResolver = options.modelResolver;
+        this.toolProvider = options.toolProvider;
+        this.store = options.store ?? new InMemoryFlexHarnessStore();
+        this.runner = options.runner ?? plugins.runAgent;
+        this.toolOutputLimits = resolveJsonLimits(options.toolOutputLimits);
+        this.callbackLimits = resolveCallbackLimits(options.callbackLimits);
+    }
+    async listSessions(scopeId) {
+        const { state } = await this.resolveState(scopeId);
+        await state.saveTail;
+        return publicSnapshot([...state.sessions.values()]
+            .map((entry) => entry.session)
+            .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)));
+    }
+    async createSession(scopeId, options = {}) {
+        const { state } = await this.resolveState(scopeId);
+        const sessionId = options.sessionId ?? plugins.crypto.randomUUID();
+        validateIdentifier(sessionId, 'sessionId');
+        if (options.title !== undefined) {
+            validateIdentifier(options.title, 'title');
+        }
+        const session = await this.mutateAndSave(state, () => {
+            if (state.sessions.has(sessionId)) {
+                throw new FlexHarnessValidationError(`Session "${sessionId}" already exists.`);
+            }
+            const timestamp = new Date().toISOString();
+            const nextSession = {
+                scopeId,
+                sessionId,
+                ...(options.title ? { title: options.title } : {}),
+                createdAt: timestamp,
+                updatedAt: timestamp,
+                status: 'idle',
+                activity: { status: 'idle' },
+            };
+            state.sessions.set(sessionId, {
+                session: nextSession,
+                messages: [],
+                modelHistory: [],
+                rememberedPermissionKeys: new Set(),
+            });
+            return publicSnapshot(nextSession);
+        });
+        this.emitEvent(scopeId, sessionId, {
+            type: 'session.created',
+            session,
+        });
+        return session;
+    }
+    async getSession(scopeId, sessionId) {
+        const { state } = await this.resolveState(scopeId);
+        await state.saveTail;
+        return publicSnapshot(this.requireSession(state, sessionId).session);
+    }
+    async updateSession(scopeId, sessionId, options) {
+        validateUpdateSessionOptions(options);
+        const { state } = await this.resolveState(scopeId);
+        const session = await this.mutateAndSave(state, () => {
+            const stored = this.requireMutableSession(state, sessionId);
+            const timestamp = new Date().toISOString();
+            if (Object.prototype.hasOwnProperty.call(options, 'title')) {
+                if (options.title === null) {
+                    delete stored.session.title;
+                }
+                else {
+                    stored.session.title = options.title;
+                }
+            }
+            if (options.archived === true) {
+                stored.session.archivedAt ??= timestamp;
+            }
+            else if (options.archived === false) {
+                delete stored.session.archivedAt;
+            }
+            stored.session.updatedAt = timestamp;
+            return publicSnapshot(stored.session);
+        });
+        this.emitEvent(scopeId, sessionId, {
+            type: 'session.updated',
+            session,
+        });
+        return session;
+    }
+    async deleteSession(scopeId, sessionId) {
+        const { state } = await this.resolveState(scopeId);
+        const session = await this.mutateAndSave(state, () => {
+            const stored = this.requireMutableSession(state, sessionId);
+            const deletedSession = publicSnapshot(stored.session);
+            state.sessions.delete(sessionId);
+            return deletedSession;
+        });
+        this.emitEvent(scopeId, sessionId, {
+            type: 'session.deleted',
+            session,
+        });
+    }
+    async getMessages(scopeId, sessionId) {
+        const { state } = await this.resolveState(scopeId);
+        await state.saveTail;
+        return publicSnapshot(this.requireSession(state, sessionId).messages);
+    }
+    async prompt(scopeId, sessionId, prompt, options = {}) {
+        const normalizedPrompt = normalizeFlexPrompt(prompt);
+        if (options.maxSteps !== undefined && (!Number.isSafeInteger(options.maxSteps) || options.maxSteps < 1)) {
+            throw new FlexHarnessValidationError('maxSteps must be a positive integer.');
+        }
+        const resolved = await this.resolveState(scopeId);
+        await resolved.state.saveTail;
+        this.assertOpen();
+        this.requireSession(resolved.state, sessionId);
+        if (resolved.state.activeRuns.has(sessionId)) {
+            throw new FlexHarnessSessionBusyError(sessionId);
+        }
+        const run = {
+            scopeId,
+            sessionId,
+            runId: plugins.crypto.randomUUID(),
+            userMessageId: plugins.crypto.randomUUID(),
+            assistantMessageId: plugins.crypto.randomUUID(),
+            controller: new AbortController(),
+            finalizer: Promise.reject(new Error('Run finalizer was not initialized.')),
+            callbackEventCount: 0,
+            callbackOutputBytes: 0,
+            callbackParts: [],
+            callbacksClosed: false,
+            previousHistory: [],
+            reasoningPartIds: new Map(),
+            toolPartIds: new Map(),
+            pendingPermissionIds: new Set(),
+            phase: 'resolving',
+        };
+        void run.finalizer.catch(() => undefined);
+        resolved.state.activeRuns.set(sessionId, run);
+        run.finalizer = this.executeRun(resolved, run, normalizedPrompt, options);
+        return run.finalizer;
+    }
+    async abort(scopeId, sessionId, reason) {
+        const { state } = await this.resolveState(scopeId);
+        const run = state.activeRuns.get(sessionId);
+        if (!run || run.phase === 'committing') {
+            return false;
+        }
+        const error = new FlexHarnessAbortError(reason ?? 'The run was aborted by the caller.');
+        if (run.internalFailure === undefined)
+            run.ownerCancellation ??= error;
+        this.rejectRunPermissions(state, run, error);
+        run.controller.abort(error);
+        return true;
+    }
+    async listPendingPermissions(scopeId, sessionId) {
+        const { state } = await this.resolveState(scopeId);
+        await state.saveTail;
+        return publicSnapshot([...state.pendingPermissions.values()]
+            .map((pending) => pending.request)
+            .filter((request) => !sessionId || request.sessionId === sessionId)
+            .sort((left, right) => left.createdAt.localeCompare(right.createdAt)));
+    }
+    async respondToPermission(scopeId, sessionId, permissionId, decision) {
+        const { state } = await this.resolveState(scopeId);
+        const pending = state.pendingPermissions.get(permissionId);
+        if (!pending || pending.request.sessionId !== sessionId) {
+            throw new FlexHarnessNotFoundError('Permission', permissionId);
+        }
+        const response = pending.responseTail.then(() => this.applyPermissionResponse(state, pending, decision));
+        pending.responseTail = response.then(() => undefined, () => undefined);
+        return response;
+    }
+    subscribe(listener) {
+        this.assertOpen();
+        this.listeners.add(listener);
+        let subscribed = true;
+        return () => {
+            if (!subscribed)
+                return;
+            subscribed = false;
+            this.listeners.delete(listener);
+        };
+    }
+    async dispose() {
+        if (this.disposePromise) {
+            return this.disposePromise;
+        }
+        this.closed = true;
+        this.disposePromise = this.disposeInternal();
+        return this.disposePromise;
+    }
+    async disposeInternal() {
+        const states = (await Promise.allSettled([...this.stateLoads.values()])).flatMap((result) => (result.status === 'fulfilled' ? [result.value] : []));
+        const finalizers = [];
+        for (const state of states) {
+            for (const run of state.activeRuns.values()) {
+                finalizers.push(run.finalizer);
+                if (run.phase === 'committing')
+                    continue;
+                const error = new FlexHarnessAbortError('The run was aborted because FlexHarness was disposed.');
+                if (run.internalFailure === undefined)
+                    run.ownerCancellation ??= error;
+                this.rejectRunPermissions(state, run, error);
+                run.controller.abort(error);
+            }
+            for (const pending of [...state.pendingPermissions.values()]) {
+                this.rejectPending(state, pending, new FlexHarnessAbortError('Permission was rejected because FlexHarness was disposed.'));
+            }
+        }
+        const results = await Promise.allSettled(finalizers);
+        await Promise.all(states.map((state) => state.saveTail));
+        const detachedCleanupResults = await Promise.allSettled([...this.detachedToolCleanups]);
+        this.listeners.clear();
+        this.stateLoads.clear();
+        this.detachedToolCleanups.clear();
+        for (const state of states) {
+            state.sessions.clear();
+            state.activeRuns.clear();
+            state.pendingPermissions.clear();
+        }
+        const unexpectedErrors = [];
+        for (const result of results) {
+            if (result.status === 'fulfilled')
+                continue;
+            if (result.reason instanceof FlexHarnessRunError) {
+                for (const error of result.reason.errors) {
+                    if (!isAbortError(error))
+                        unexpectedErrors.push(error);
+                }
+            }
+            else if (!isAbortError(result.reason)) {
+                unexpectedErrors.push(result.reason);
+            }
+        }
+        for (const result of detachedCleanupResults) {
+            if (result.status === 'rejected')
+                unexpectedErrors.push(result.reason);
+        }
+        if (unexpectedErrors.length > 0) {
+            throw combineErrors(unexpectedErrors);
+        }
+    }
+    async executeRun(resolved, run, prompt, options) {
+        let modelResolution;
+        let toolHandle;
+        let result;
+        let serializedResultMessages;
+        let originalError;
+        let reserved = false;
+        try {
+            const reservation = await this.reserveRun(resolved.state, run, prompt);
+            reserved = true;
+            this.emitEvent(run.scopeId, run.sessionId, {
+                type: 'run.started',
+                runId: run.runId,
+                messageId: run.userMessageId,
+                session: reservation.session,
+            });
+            this.emitEvent(run.scopeId, run.sessionId, {
+                type: 'message.created',
+                runId: run.runId,
+                messageId: run.userMessageId,
+                message: reservation.userMessage,
+            });
+            this.emitEvent(run.scopeId, run.sessionId, {
+                type: 'message.created',
+                runId: run.runId,
+                messageId: run.assistantMessageId,
+                message: reservation.assistantMessage,
+            });
+            const modelOutcome = Promise.resolve()
+                .then(() => this.modelResolver.resolveModel({
+                scopeId: run.scopeId,
+                scope: resolved.scope.scope,
+                sessionId: run.sessionId,
+                runId: run.runId,
+                ...(options.modelHint ? { modelHint: options.modelHint } : {}),
+                signal: run.controller.signal,
+            }))
+                .then((value) => ({ source: 'model', success: true, value }), (error) => ({ source: 'model', success: false, error }));
+            const toolOutcome = Promise.resolve()
+                .then(() => this.toolProvider
+                ? this.toolProvider.provideTools({
+                    scopeId: run.scopeId,
+                    scope: resolved.scope.scope,
+                    sessionId: run.sessionId,
+                    runId: run.runId,
+                    signal: run.controller.signal,
+                    requestPermission: (request) => this.requestPermission(resolved.state, run, request),
+                })
+                : undefined)
+                .then((value) => ({ source: 'tools', success: true, value }), (error) => ({ source: 'tools', success: false, error }));
+            let resolveAbort;
+            const abortOutcome = new Promise((resolve) => {
+                resolveAbort = resolve;
+            });
+            const onResolverAbort = () => {
+                resolveAbort({
+                    source: 'abort',
+                    success: false,
+                    error: run.controller.signal.reason ?? new FlexHarnessAbortError(),
+                });
+            };
+            run.controller.signal.addEventListener('abort', onResolverAbort, { once: true });
+            if (run.controller.signal.aborted)
+                onResolverAbort();
+            const firstResolver = await Promise.race([modelOutcome, toolOutcome, abortOutcome]);
+            if (!firstResolver.success) {
+                run.controller.signal.removeEventListener('abort', onResolverAbort);
+                if (firstResolver.source !== 'abort') {
+                    this.abortRunInternally(run, firstResolver.error);
+                }
+                if (firstResolver.source !== 'tools') {
+                    this.observeDetachedToolProvider(toolOutcome);
+                }
+                throw firstResolver.error;
+            }
+            if (firstResolver.source === 'model') {
+                modelResolution = firstResolver.value;
+                try {
+                    validateModelIdentity(modelResolution.identity);
+                }
+                catch (error) {
+                    run.controller.signal.removeEventListener('abort', onResolverAbort);
+                    this.abortRunInternally(run, error);
+                    this.observeDetachedToolProvider(toolOutcome);
+                    throw error;
+                }
+            }
+            else {
+                toolHandle = firstResolver.value;
+            }
+            const secondResolver = await Promise.race([
+                firstResolver.source === 'model' ? toolOutcome : modelOutcome,
+                abortOutcome,
+            ]);
+            run.controller.signal.removeEventListener('abort', onResolverAbort);
+            if (!secondResolver.success) {
+                if (secondResolver.source !== 'abort') {
+                    this.abortRunInternally(run, secondResolver.error);
+                }
+                if (firstResolver.source === 'model' && secondResolver.source === 'abort') {
+                    this.observeDetachedToolProvider(toolOutcome);
+                }
+                throw secondResolver.error;
+            }
+            if (secondResolver.source === 'model') {
+                modelResolution = secondResolver.value;
+                try {
+                    validateModelIdentity(modelResolution.identity);
+                }
+                catch (error) {
+                    this.abortRunInternally(run, error);
+                    throw error;
+                }
+            }
+            else {
+                toolHandle = secondResolver.value;
+            }
+            if (run.controller.signal.aborted) {
+                throw run.controller.signal.reason;
+            }
+            const runnerOptions = {
+                model: modelResolution.model,
+                prompt: prompt.agentPrompt,
+                messages: hydrateAgentMessages(run.previousHistory),
+                sessionId: run.sessionId,
+                abort: run.controller.signal,
+                ...(options.system ?? modelResolution.system
+                    ? { system: options.system ?? modelResolution.system }
+                    : {}),
+                ...(toolHandle ? { tools: wrapToolSet(toolHandle.tools, this.toolOutputLimits) } : {}),
+                ...(modelResolution.providerOptions
+                    ? { providerOptions: modelResolution.providerOptions }
+                    : {}),
+                ...(modelResolution.cache !== undefined ? { cache: modelResolution.cache } : {}),
+                ...(options.maxSteps ?? modelResolution.maxSteps
+                    ? { maxSteps: options.maxSteps ?? modelResolution.maxSteps }
+                    : {}),
+                onToken: (delta) => this.onTextDelta(run, delta),
+                onReasoningStart: (id) => this.onReasoningStart(run, id),
+                onReasoningDelta: (id, delta) => this.onReasoningDelta(run, id, delta),
+                onReasoningEnd: (id, text) => this.onReasoningEnd(run, id, text),
+                onToolCallStart: (event) => this.onToolStart(run, event),
+                onToolCallFinish: (event) => this.onToolFinish(run, event),
+            };
+            run.phase = 'running';
+            result = await this.runner(runnerOptions);
+            if (run.callbackError) {
+                throw run.callbackError;
+            }
+            if (run.controller.signal.aborted) {
+                throw run.controller.signal.reason;
+            }
+            serializedResultMessages = serializeAgentMessages(result.messages);
+        }
+        catch (error) {
+            originalError = error ?? new Error('The run failed without an error value.');
+        }
+        run.callbacksClosed = true;
+        run.phase = 'closing';
+        if (run.callbackError && originalError !== run.callbackError) {
+            originalError = originalError === undefined
+                ? run.callbackError
+                : combineErrors([originalError, run.callbackError]);
+        }
+        if (originalError !== undefined && run.ownerCancellation === undefined) {
+            run.internalFailure ??= originalError;
+        }
+        if (!reserved) {
+            resolved.state.activeRuns.delete(run.sessionId);
+            throw originalError;
+        }
+        this.rejectRunPermissions(resolved.state, run, originalError ??
+            run.ownerCancellation ??
+            new FlexHarnessAbortError('The run ended before permission was resolved.'));
+        const closeResult = await Promise.allSettled([
+            Promise.resolve().then(() => toolHandle?.close?.()),
+        ]).then(([settled]) => settled);
+        const errorsBeforePersistence = [];
+        if (originalError !== undefined)
+            errorsBeforePersistence.push(originalError);
+        if (originalError === undefined &&
+            run.ownerCancellation !== undefined) {
+            errorsBeforePersistence.push(run.ownerCancellation);
+        }
+        if (closeResult.status === 'rejected') {
+            errorsBeforePersistence.push(closeResult.reason);
+            run.internalFailure ??= closeResult.reason;
+        }
+        run.phase = 'committing';
+        if (originalError === undefined &&
+            run.ownerCancellation !== undefined &&
+            !errorsBeforePersistence.includes(run.ownerCancellation)) {
+            errorsBeforePersistence.push(run.ownerCancellation);
+        }
+        const cancelled = run.ownerCancellation !== undefined && run.internalFailure === undefined;
+        const terminalError = errorsBeforePersistence.length > 0
+            ? combineErrors(errorsBeforePersistence)
+            : undefined;
+        const persistenceResult = await Promise.allSettled([this.finalizeRun(resolved.state, run, prompt, modelResolution, result, serializedResultMessages, terminalError, cancelled)]).then(([settled]) => settled);
+        if (persistenceResult.status === 'rejected') {
+            const allErrors = [...errorsBeforePersistence, persistenceResult.reason];
+            const combinedError = combineErrors(allErrors);
+            const fallback = this.applyRunFinalState(resolved.state, run, prompt, modelResolution, result, serializedResultMessages, combinedError, cancelled);
+            resolved.state.activeRuns.delete(run.sessionId);
+            this.emitFinalMutationEvents(run, fallback);
+            this.emitFinalRunEvent(run, fallback.assistantMessage, combinedError, cancelled);
+            throw combinedError;
+        }
+        const finalized = persistenceResult.value;
+        resolved.state.activeRuns.delete(run.sessionId);
+        this.emitFinalRunEvent(run, finalized.assistantMessage, terminalError, cancelled);
+        if (terminalError !== undefined)
+            throw terminalError;
+        return {
+            runId: run.runId,
+            sessionId: run.sessionId,
+            userMessage: finalized.userMessage,
+            assistantMessage: finalized.assistantMessage,
+            model: publicSnapshot(modelResolution.identity),
+            usage: publicSnapshot(makeUsage(result)),
+            finishReason: result.finishReason,
+            steps: result.steps,
+        };
+    }
+    async reserveRun(state, run, prompt) {
+        return this.mutateAndSave(state, () => {
+            const stored = this.requireSession(state, run.sessionId);
+            const timestamp = new Date().toISOString();
+            run.previousHistory = cloneSerializable(stored.modelHistory);
+            const userMessage = {
+                messageId: run.userMessageId,
+                sessionId: run.sessionId,
+                runId: run.runId,
+                role: 'user',
+                status: 'streaming',
+                createdAt: timestamp,
+                parts: prompt.parts.map((part) => {
+                    if (part.type === 'text') {
+                        return {
+                            partId: plugins.crypto.randomUUID(),
+                            type: 'text',
+                            text: part.text,
+                        };
+                    }
+                    const attachment = {
+                        partId: plugins.crypto.randomUUID(),
+                        type: 'attachment',
+                        attachmentType: part.type,
+                        ...describeAttachment(part),
+                    };
+                    return attachment;
+                }),
+            };
+            const assistantMessage = {
+                messageId: run.assistantMessageId,
+                sessionId: run.sessionId,
+                runId: run.runId,
+                role: 'assistant',
+                status: 'streaming',
+                createdAt: timestamp,
+                parts: [],
+            };
+            stored.messages.push(userMessage, assistantMessage);
+            stored.session.status = 'running';
+            stored.session.activity = {
+                runId: run.runId,
+                status: 'running',
+                startedAt: timestamp,
+            };
+            stored.session.updatedAt = timestamp;
+            return {
+                session: publicSnapshot(stored.session),
+                userMessage: publicSnapshot(userMessage),
+                assistantMessage: publicSnapshot(assistantMessage),
+            };
+        });
+    }
+    async finalizeRun(state, run, prompt, model, result, serializedResultMessages, originalError, cancelled) {
+        const final = await this.mutateAndSave(state, () => this.applyRunFinalState(state, run, prompt, model, result, serializedResultMessages, originalError, cancelled));
+        this.emitFinalMutationEvents(run, final);
+        return final;
+    }
+    applyRunFinalState(state, run, prompt, model, result, serializedResultMessages, originalError, cancelled) {
+        const stored = this.requireSession(state, run.sessionId);
+        const userMessage = this.requireMessage(stored, run.userMessageId);
+        const assistantMessage = this.requireMessage(stored, run.assistantMessageId);
+        assistantMessage.parts = cloneSerializable(run.callbackParts);
+        const timestamp = new Date().toISOString();
+        const terminalParts = [];
+        const success = originalError === undefined &&
+            !cancelled &&
+            model !== undefined &&
+            result !== undefined &&
+            serializedResultMessages !== undefined;
+        for (const part of assistantMessage.parts) {
+            if (part.type === 'reasoning' && part.status === 'running') {
+                part.status = success ? 'completed' : 'cancelled';
+                terminalParts.push(publicSnapshot(part));
+            }
+            if (part.type === 'tool' && part.status === 'running') {
+                part.status = success ? 'failed' : cancelled ? 'cancelled' : 'failed';
+                part.error = success
+                    ? 'Tool execution ended without a terminal event.'
+                    : cancelled
+                        ? 'Tool execution was cancelled.'
+                        : errorMessage(originalError);
+                terminalParts.push(publicSnapshot(part));
+            }
+        }
+        if (success) {
+            if (!assistantMessage.parts.some((part) => part.type === 'text')) {
+                assistantMessage.parts.push({
+                    partId: plugins.crypto.randomUUID(),
+                    type: 'text',
+                    text: result.text,
+                });
+            }
+            const usage = makeUsage(result);
+            userMessage.status = 'completed';
+            userMessage.completedAt = timestamp;
+            assistantMessage.status = 'completed';
+            assistantMessage.completedAt = timestamp;
+            assistantMessage.model = cloneSerializable(model.identity);
+            assistantMessage.usage = usage;
+            stored.modelHistory = [
+                ...run.previousHistory,
+                cloneSerializable(prompt.modelMessage),
+                ...serializedResultMessages,
+            ];
+            stored.session.status = 'idle';
+            stored.session.activity = {
+                runId: run.runId,
+                status: 'idle',
+                startedAt: stored.session.activity.startedAt,
+                completedAt: timestamp,
+            };
+        }
+        else {
+            const status = cancelled ? 'cancelled' : 'failed';
+            const message = errorMessage(originalError);
+            userMessage.status = status;
+            userMessage.completedAt = timestamp;
+            userMessage.error = message;
+            assistantMessage.status = status;
+            assistantMessage.completedAt = timestamp;
+            assistantMessage.error = message;
+            if (model)
+                assistantMessage.model = cloneSerializable(model.identity);
+            stored.session.status = status;
+            stored.session.activity = {
+                runId: run.runId,
+                status,
+                startedAt: stored.session.activity.startedAt,
+                completedAt: timestamp,
+                error: message,
+            };
+        }
+        stored.session.updatedAt = timestamp;
+        return {
+            userMessage: publicSnapshot(userMessage),
+            assistantMessage: publicSnapshot(assistantMessage),
+            terminalParts,
+        };
+    }
+    emitFinalMutationEvents(run, final) {
+        for (const part of final.terminalParts) {
+            this.emitPartEvent(run, 'part.completed', part);
+        }
+        this.emitEvent(run.scopeId, run.sessionId, {
+            type: 'message.updated',
+            runId: run.runId,
+            messageId: run.userMessageId,
+            message: final.userMessage,
+        });
+        this.emitEvent(run.scopeId, run.sessionId, {
+            type: 'message.updated',
+            runId: run.runId,
+            messageId: run.assistantMessageId,
+            message: final.assistantMessage,
+        });
+    }
+    emitFinalRunEvent(run, message, error, cancelled) {
+        const status = error
+            ? cancelled
+                ? 'cancelled'
+                : 'failed'
+            : 'completed';
+        this.emitEvent(run.scopeId, run.sessionId, {
+            type: 'run.finished',
+            runId: run.runId,
+            messageId: run.assistantMessageId,
+            status,
+            message,
+            ...(error !== undefined ? { error: errorToInfo(error) } : {}),
+        });
+    }
+    onTextDelta(run, delta) {
+        if (!delta || run.callbacksClosed || run.callbackError)
+            return;
+        const lastPart = run.callbackParts.at(-1);
+        const created = lastPart?.type !== 'text';
+        const byteLength = Buffer.byteLength(delta);
+        if (!this.reserveCallbackCapacity(run, created ? 2 : 1, byteLength, created ? 1 : 0))
+            return;
+        const part = lastPart?.type === 'text'
+            ? lastPart
+            : { partId: plugins.crypto.randomUUID(), type: 'text', text: '' };
+        if (created)
+            run.callbackParts.push(part);
+        part.text += delta;
+        if (created)
+            this.emitPartEvent(run, 'part.started', part);
+        this.emitPartEvent(run, 'part.delta', part, delta);
+    }
+    onReasoningStart(run, id) {
+        if (run.callbacksClosed || run.callbackError || run.reasoningPartIds.has(id))
+            return;
+        if (!this.reserveCallbackCapacity(run, 1, 0, 1))
+            return;
+        const part = {
+            partId: plugins.crypto.randomUUID(),
+            type: 'reasoning',
+            text: '',
+            status: 'running',
+        };
+        run.reasoningPartIds.set(id, part.partId);
+        run.callbackParts.push(part);
+        this.emitPartEvent(run, 'part.started', part);
+    }
+    onReasoningDelta(run, id, delta) {
+        if (run.callbacksClosed || run.callbackError || !delta)
+            return;
+        if (!run.reasoningPartIds.has(id))
+            this.onReasoningStart(run, id);
+        const partId = run.reasoningPartIds.get(id);
+        if (!partId || run.callbackError)
+            return;
+        const part = run.callbackParts.find((entry) => entry.partId === partId && entry.type === 'reasoning');
+        if (!part || part.type !== 'reasoning' || part.status !== 'running')
+            return;
+        if (!this.reserveCallbackCapacity(run, 1, Buffer.byteLength(delta), 0))
+            return;
+        part.text += delta;
+        this.emitPartEvent(run, 'part.delta', part, delta);
+    }
+    onReasoningEnd(run, id, text) {
+        if (run.callbacksClosed || run.callbackError)
+            return;
+        if (!run.reasoningPartIds.has(id))
+            this.onReasoningStart(run, id);
+        const partId = run.reasoningPartIds.get(id);
+        if (!partId || run.callbackError)
+            return;
+        const part = run.callbackParts.find((entry) => entry.partId === partId && entry.type === 'reasoning');
+        if (!part || part.type !== 'reasoning' || part.status !== 'running')
+            return;
+        const missingText = part.text.length === 0 ? text : '';
+        if (!this.reserveCallbackCapacity(run, 1, Buffer.byteLength(missingText), 0))
+            return;
+        if (missingText)
+            part.text = missingText;
+        part.status = 'completed';
+        this.emitPartEvent(run, 'part.completed', part);
+    }
+    onToolStart(run, event) {
+        if (run.callbacksClosed || run.callbackError || run.toolPartIds.has(event.toolCallId))
+            return;
+        const input = normalizeJsonValue(event.input, this.toolOutputLimits);
+        const byteLength = Buffer.byteLength(JSON.stringify(input));
+        if (!this.reserveCallbackCapacity(run, 1, byteLength, 1))
+            return;
+        const part = {
+            partId: plugins.crypto.randomUUID(),
+            type: 'tool',
+            toolCallId: event.toolCallId,
+            toolName: event.toolName,
+            status: 'running',
+            input,
+        };
+        run.toolPartIds.set(event.toolCallId, part.partId);
+        run.callbackParts.push(part);
+        this.emitPartEvent(run, 'part.started', part);
+    }
+    onToolFinish(run, event) {
+        if (run.callbacksClosed || run.callbackError)
+            return;
+        if (!run.toolPartIds.has(event.toolCallId))
+            this.onToolStart(run, event);
+        const partId = run.toolPartIds.get(event.toolCallId);
+        if (!partId || run.callbackError)
+            return;
+        const part = run.callbackParts.find((entry) => entry.partId === partId && entry.type === 'tool');
+        if (!part || part.type !== 'tool' || part.status !== 'running')
+            return;
+        const output = event.success
+            ? normalizeJsonValue(event.output, this.toolOutputLimits)
+            : undefined;
+        const byteLength = event.success
+            ? Buffer.byteLength(JSON.stringify(output))
+            : Buffer.byteLength(event.error);
+        if (!this.reserveCallbackCapacity(run, 1, byteLength, 0))
+            return;
+        if (event.success) {
+            part.status = 'completed';
+            part.output = output;
+        }
+        else {
+            part.status = 'failed';
+            part.error = event.error;
+        }
+        this.emitPartEvent(run, 'part.completed', part);
+    }
+    reserveCallbackCapacity(run, eventCount, outputBytes, partCount) {
+        const nextEvents = run.callbackEventCount + eventCount;
+        const nextOutputBytes = run.callbackOutputBytes + outputBytes;
+        const nextParts = run.callbackParts.length + partCount;
+        if (nextEvents > this.callbackLimits.maxEvents ||
+            nextOutputBytes > this.callbackLimits.maxOutputBytes ||
+            nextParts > this.callbackLimits.maxParts) {
+            const error = new FlexHarnessCallbackOverflowError(`Callback buffer exceeded its limit (${nextEvents} events, ${nextOutputBytes} bytes, ${nextParts} parts).`);
+            run.callbackError = error;
+            this.abortRunInternally(run, error);
+            return false;
+        }
+        run.callbackEventCount = nextEvents;
+        run.callbackOutputBytes = nextOutputBytes;
+        return true;
+    }
+    async requestPermission(state, run, input) {
+        validateIdentifier(input.kind, 'permission kind');
+        validateIdentifier(input.description, 'permission description');
+        if (input.rememberKey !== undefined)
+            validateIdentifier(input.rememberKey, 'rememberKey');
+        if (input.toolCallId !== undefined)
+            validateIdentifier(input.toolCallId, 'toolCallId');
+        if (run.controller.signal.aborted) {
+            throw run.controller.signal.reason;
+        }
+        await state.saveTail;
+        if (run.controller.signal.aborted) {
+            throw run.controller.signal.reason;
+        }
+        if (state.activeRuns.get(run.sessionId) !== run ||
+            run.callbacksClosed ||
+            run.phase === 'closing' ||
+            run.phase === 'committing') {
+            throw new FlexHarnessPermissionStateError(`Run "${run.runId}" no longer accepts permission requests.`);
+        }
+        const stored = this.requireSession(state, run.sessionId);
+        if (input.rememberKey && stored.rememberedPermissionKeys.has(input.rememberKey)) {
+            return;
+        }
+        const request = {
+            permissionId: plugins.crypto.randomUUID(),
+            scopeId: run.scopeId,
+            sessionId: run.sessionId,
+            runId: run.runId,
+            kind: input.kind,
+            description: input.description,
+            ...(input.toolCallId ? { toolCallId: input.toolCallId } : {}),
+            ...(input.rememberKey ? { rememberKey: input.rememberKey } : {}),
+            ...(input.metadata !== undefined ? { metadata: cloneSerializable(input.metadata) } : {}),
+            createdAt: new Date().toISOString(),
+        };
+        let resolvePermission;
+        let rejectPermission;
+        const permissionPromise = new Promise((resolve, reject) => {
+            resolvePermission = resolve;
+            rejectPermission = reject;
+        });
+        void permissionPromise.catch(() => undefined);
+        const abortListener = () => {
+            const pending = state.pendingPermissions.get(request.permissionId);
+            if (pending)
+                this.rejectPending(state, pending, run.controller.signal.reason);
+        };
+        const pending = {
+            request,
+            run,
+            resolve: resolvePermission,
+            reject: rejectPermission,
+            settled: false,
+            responding: false,
+            responseTail: Promise.resolve(),
+            abortListener,
+        };
+        state.pendingPermissions.set(request.permissionId, pending);
+        run.pendingPermissionIds.add(request.permissionId);
+        run.controller.signal.addEventListener('abort', abortListener, { once: true });
+        try {
+            await this.mutateAndSave(state, () => {
+                const current = this.requireSession(state, run.sessionId);
+                current.session.status = 'waiting_permission';
+                current.session.activity.status = 'waiting_permission';
+                current.session.updatedAt = new Date().toISOString();
+            });
+        }
+        catch (error) {
+            state.pendingPermissions.delete(request.permissionId);
+            run.pendingPermissionIds.delete(request.permissionId);
+            run.controller.signal.removeEventListener('abort', abortListener);
+            throw error;
+        }
+        if (pending.settled) {
+            return permissionPromise;
+        }
+        this.emitEvent(run.scopeId, run.sessionId, {
+            type: 'permission.requested',
+            runId: run.runId,
+            request: publicSnapshot(request),
+        });
+        return permissionPromise;
+    }
+    async applyPermissionResponse(state, pending, decision) {
+        if (pending.settled) {
+            throw new FlexHarnessPermissionStateError(`Permission "${pending.request.permissionId}" has already been resolved.`);
+        }
+        if (!['once', 'always', 'reject'].includes(decision)) {
+            throw new FlexHarnessPermissionStateError(`Unknown permission decision "${decision}".`);
+        }
+        if (decision === 'always' && !pending.request.rememberKey) {
+            throw new FlexHarnessPermissionStateError('The always decision requires the permission request to provide rememberKey.');
+        }
+        const rememberKey = pending.request.rememberKey;
+        let addedRememberKey = false;
+        pending.responding = true;
+        try {
+            await this.mutateAndSave(state, () => {
+                const stored = this.requireSession(state, pending.request.sessionId);
+                if (decision === 'always' && rememberKey) {
+                    addedRememberKey = !stored.rememberedPermissionKeys.has(rememberKey);
+                    stored.rememberedPermissionKeys.add(rememberKey);
+                }
+                const hasOtherPending = [...state.pendingPermissions.values()].some((entry) => entry !== pending &&
+                    !entry.settled &&
+                    entry.request.sessionId === pending.request.sessionId);
+                stored.session.status = hasOtherPending ? 'waiting_permission' : 'running';
+                stored.session.activity.status = hasOtherPending ? 'waiting_permission' : 'running';
+                stored.session.updatedAt = new Date().toISOString();
+            });
+        }
+        catch (error) {
+            pending.responding = false;
+            if (pending.abortReason !== undefined) {
+                const abortReason = pending.abortReason;
+                this.forceRejectPending(state, pending, abortReason);
+                throw combineErrors([abortReason, error]);
+            }
+            throw error;
+        }
+        if (pending.abortReason !== undefined) {
+            const abortReason = pending.abortReason;
+            const rollbackPromise = addedRememberKey && rememberKey
+                ? this.mutateAndSave(state, () => {
+                    this.requireSession(state, pending.request.sessionId).rememberedPermissionKeys.delete(rememberKey);
+                })
+                : Promise.resolve();
+            pending.responding = false;
+            this.forceRejectPending(state, pending, abortReason);
+            try {
+                await rollbackPromise;
+            }
+            catch (rollbackError) {
+                throw combineErrors([abortReason, rollbackError]);
+            }
+            throw abortReason;
+        }
+        pending.settled = true;
+        pending.responding = false;
+        state.pendingPermissions.delete(pending.request.permissionId);
+        pending.run.pendingPermissionIds.delete(pending.request.permissionId);
+        pending.run.controller.signal.removeEventListener('abort', pending.abortListener);
+        this.emitEvent(pending.request.scopeId, pending.request.sessionId, {
+            type: 'permission.resolved',
+            runId: pending.request.runId,
+            request: publicSnapshot(pending.request),
+            decision,
+        });
+        if (decision === 'reject') {
+            pending.reject(new FlexHarnessPermissionRejectedError(pending.request.permissionId));
+        }
+        else {
+            pending.resolve();
+        }
+    }
+    rejectRunPermissions(state, run, error) {
+        for (const permissionId of [...run.pendingPermissionIds]) {
+            const pending = state.pendingPermissions.get(permissionId);
+            if (pending)
+                this.rejectPending(state, pending, error);
+        }
+    }
+    rejectPending(state, pending, error) {
+        if (pending.settled)
+            return;
+        if (pending.responding) {
+            pending.abortReason ??= error;
+            return;
+        }
+        this.forceRejectPending(state, pending, error);
+    }
+    forceRejectPending(state, pending, error) {
+        if (pending.settled)
+            return;
+        pending.settled = true;
+        state.pendingPermissions.delete(pending.request.permissionId);
+        pending.run.pendingPermissionIds.delete(pending.request.permissionId);
+        pending.run.controller.signal.removeEventListener('abort', pending.abortListener);
+        pending.reject(error);
+    }
+    emitPartEvent(run, type, part, delta) {
+        this.emitEvent(run.scopeId, run.sessionId, {
+            type,
+            runId: run.runId,
+            messageId: run.assistantMessageId,
+            partId: part.partId,
+            part: publicSnapshot(part),
+            ...(delta !== undefined ? { delta } : {}),
+        });
+    }
+    abortRunInternally(run, error) {
+        run.internalFailure ??= error ?? new Error('Internal FlexHarness run failure.');
+        if (!run.controller.signal.aborted) {
+            run.controller.abort(run.internalFailure);
+        }
+    }
+    observeDetachedToolProvider(outcomePromise) {
+        const cleanup = outcomePromise.then(async (outcome) => {
+            if (outcome.success && outcome.source === 'tools' && outcome.value?.close) {
+                await Promise.resolve().then(() => outcome.value.close());
+            }
+        });
+        this.detachedToolCleanups.add(cleanup);
+        void cleanup.then(() => this.detachedToolCleanups.delete(cleanup), () => undefined);
+    }
+    emitEvent(scopeId, sessionId, details) {
+        const event = deepFreeze(cloneSerializable({
+            eventId: plugins.crypto.randomUUID(),
+            sequence: ++this.sequence,
+            timestamp: new Date().toISOString(),
+            scopeId,
+            sessionId,
+            ...details,
+        }));
+        for (const listener of this.listeners) {
+            try {
+                listener(event);
+            }
+            catch {
+                // Listener failures are isolated from the run and from other listeners.
+            }
+        }
+    }
+    async resolveState(scopeId) {
+        this.assertOpen();
+        validateIdentifier(scopeId, 'scopeId');
+        const scope = await this.scopeResolver.resolveScope(scopeId);
+        this.assertOpen();
+        validateIdentifier(scope.storageKey, 'resolved storageKey');
+        let stateLoad = this.stateLoads.get(scope.storageKey);
+        if (!stateLoad) {
+            stateLoad = this.loadState(scope.storageKey);
+            this.stateLoads.set(scope.storageKey, stateLoad);
+            void stateLoad.catch(() => {
+                if (this.stateLoads.get(scope.storageKey) === stateLoad) {
+                    this.stateLoads.delete(scope.storageKey);
+                }
+            });
+        }
+        const state = await stateLoad;
+        this.assertOpen();
+        return { scope, state };
+    }
+    async loadState(storageKey) {
+        const loaded = await this.store.load(storageKey);
+        if (loaded)
+            assertFlexHarnessSnapshot(loaded);
+        const snapshot = loaded ? cloneSerializable(loaded) : undefined;
+        const sessions = new Map();
+        const timestamp = new Date().toISOString();
+        for (const stored of snapshot?.sessions ?? []) {
+            if (stored.session.status === 'running' || stored.session.status === 'waiting_permission') {
+                stored.session.status = 'idle';
+                stored.session.activity = { status: 'idle' };
+                stored.session.updatedAt = timestamp;
+            }
+            for (const message of stored.messages) {
+                if (message.status === 'streaming') {
+                    message.status = 'cancelled';
+                    message.completedAt = timestamp;
+                    message.error = 'The process stopped before this message completed.';
+                }
+                for (const part of message.parts) {
+                    if (part.type === 'reasoning' && part.status === 'running') {
+                        part.status = 'cancelled';
+                    }
+                    if (part.type === 'tool' && part.status === 'running') {
+                        part.status = 'cancelled';
+                        part.error = 'The process stopped before this tool call completed.';
+                    }
+                }
+            }
+            sessions.set(stored.session.sessionId, {
+                session: stored.session,
+                messages: stored.messages,
+                modelHistory: stored.modelHistory,
+                rememberedPermissionKeys: new Set(stored.rememberedPermissionKeys),
+            });
+        }
+        return {
+            storageKey,
+            revision: snapshot?.revision ?? 0,
+            sessions,
+            activeRuns: new Map(),
+            pendingPermissions: new Map(),
+            saveTail: Promise.resolve(),
+        };
+    }
+    mutateAndSave(state, mutation) {
+        const operation = state.saveTail.then(async () => {
+            const beforeMutation = this.createSnapshot(state, state.revision);
+            try {
+                const result = mutation();
+                const expectedRevision = state.revision;
+                const snapshot = this.createSnapshot(state, expectedRevision + 1);
+                assertFlexHarnessSnapshot(snapshot);
+                await this.store.save(state.storageKey, snapshot, expectedRevision);
+                state.revision = snapshot.revision;
+                return result;
+            }
+            catch (error) {
+                this.restorePersistentState(state, beforeMutation);
+                throw error;
+            }
+        });
+        state.saveTail = operation.then(() => undefined, () => undefined);
+        return operation;
+    }
+    restorePersistentState(state, snapshot) {
+        state.revision = snapshot.revision;
+        state.sessions.clear();
+        for (const stored of snapshot.sessions) {
+            state.sessions.set(stored.session.sessionId, {
+                session: cloneSerializable(stored.session),
+                messages: cloneSerializable(stored.messages),
+                modelHistory: cloneSerializable(stored.modelHistory),
+                rememberedPermissionKeys: new Set(stored.rememberedPermissionKeys),
+            });
+        }
+    }
+    createSnapshot(state, revision) {
+        const sessions = [...state.sessions.values()]
+            .sort((left, right) => left.session.sessionId.localeCompare(right.session.sessionId))
+            .map((stored) => ({
+            session: cloneSerializable(stored.session),
+            messages: cloneSerializable(stored.messages),
+            modelHistory: cloneSerializable(stored.modelHistory),
+            rememberedPermissionKeys: [...stored.rememberedPermissionKeys].sort(),
+        }));
+        return {
+            schemaVersion: 1,
+            revision,
+            sessions,
+        };
+    }
+    requireSession(state, sessionId) {
+        validateIdentifier(sessionId, 'sessionId');
+        const session = state.sessions.get(sessionId);
+        if (!session)
+            throw new FlexHarnessNotFoundError('Session', sessionId);
+        return session;
+    }
+    requireMessage(stored, messageId) {
+        const message = stored.messages.find((entry) => entry.messageId === messageId);
+        if (!message)
+            throw new FlexHarnessNotFoundError('Message', messageId);
+        return message;
+    }
+    requireMutableSession(state, sessionId) {
+        const stored = this.requireSession(state, sessionId);
+        const hasPendingPermission = [...state.pendingPermissions.values()].some((pending) => !pending.settled && pending.request.sessionId === sessionId);
+        if (state.activeRuns.has(sessionId) || hasPendingPermission) {
+            throw new FlexHarnessSessionBusyError(sessionId, 'cannot be changed while it has an active run or pending permission');
+        }
+        return stored;
+    }
+    assertOpen() {
+        if (this.closed)
+            throw new FlexHarnessClosedError();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.flexharness.js","sourceRoot":"","sources":["../ts/classes.flexharness.ts"],"names":[],"mappings":"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"}