@modelprofile.com/flexharness 10.23.0 → 10.24.1

package/dist_ts/classes.flexharness.runs.js

@@ -0,0 +1,1058 @@
+import * as plugins from './plugins.js';
+import { FlexHarnessAbortError, FlexHarnessExternalError, FlexHarnessNotFoundError, FlexHarnessRunError, FlexHarnessStepLimitError, FlexHarnessValidationError, errorToInfo, } from './errors.js';
+import { FLEX_PROJECT_MANAGEMENT_LIMITS, FLEX_RESULT_METHOD, } from './interfaces.js';
+import { FlexToolCatalog, assertNoCatalogCollisions } from './classes.toolcatalog.js';
+import { FlexCodeSandbox } from './classes.codesandbox.js';
+import { cloneSerializable } from './utils.json.js';
+import { describeAttachment, maxTransferMetadataBytes, normalizeResolvedModel, normalizeRunResult, publicSnapshot, truncateUtf8, } from './utils.transfer.js';
+import { wrapToolSet } from './utils.tooloutput.js';
+import { validateUtf8String } from './utils.validation.js';
+import { externalErrorFallback, requireSessionGeneration, combineErrors, terminalActivityError, } from './utils.flexharness.js';
+/** The run execution engine: generations, terminal outcomes, steering and cancellation. */
+export class FlexHarnessRuns {
+    core;
+    constructor(core) {
+        this.core = core;
+    }
+    async abort(scopeId, sessionId) {
+        const { scope, state } = await this.core.resolveState(scopeId);
+        const run = state.activeRuns.get(sessionId);
+        if (!run || run.phase === 'finalizing' || run.phase === 'promoting')
+            return false;
+        this.cancelRun(run, this.core.trustInternalError(new FlexHarnessAbortError()), this.core.compaction.createCompactorContext(scopeId, scope.scope, state.storageKey, sessionId));
+        return true;
+    }
+    createActiveRun(queued) {
+        const steering = {
+            input: new plugins.AgentPendingInputQueue(),
+            stored: queued.stored,
+            accepted: new Map(),
+            applied: new Set(),
+        };
+        queued.steering = steering;
+        return {
+            steering,
+            stop: new AbortController(),
+            subagents: this.core.subagents,
+            state: queued.state,
+            stored: queued.stored,
+            originCompactorContext: this.core.compaction.createCompactorContext(queued.scopeId, queued.scope, queued.state.storageKey, queued.sessionId),
+            scopeId: queued.scopeId,
+            scope: queued.scope,
+            sessionId: queued.sessionId,
+            queueId: queued.queueId,
+            runId: queued.runId,
+            userMessageId: plugins.crypto.randomUUID(),
+            assistantMessageId: plugins.crypto.randomUUID(),
+            controller: new AbortController(),
+            ...(queued.scheduleKey === undefined
+                ? {}
+                : { scheduleKey: queued.scheduleKey, debounceMs: queued.debounceMs }),
+            callbackEventCount: 0,
+            callbackOutputBytes: 0,
+            callbackParts: [],
+            partTextUtf8Bytes: new Map(),
+            callbacksClosed: false,
+            finishedEventEmitted: false,
+            usage: {
+                inputTokens: 0,
+                outputTokens: 0,
+                totalTokens: 0,
+                cacheReadTokens: 0,
+                cacheWriteTokens: 0,
+            },
+            reasoningPartIds: new Map(),
+            toolPartIds: new Map(),
+            trustedToolExecutionErrors: new Map(),
+            unconfirmedToolCalls: new Map(),
+            readCalls: new Map(),
+            deduplicatedToolCalls: new Map(),
+            subagentCallCount: 0,
+            subagentSessionIds: new Set(),
+            backgroundSubagents: new Set(),
+            pendingPermissionIds: new Set(),
+            phase: 'admitting',
+            completion: queued.completion,
+        };
+    }
+    async executeRun(run, generation) {
+        let generated = false;
+        try {
+            // The transactional generation settles only after its model calls are reported, so
+            // `run.usage` is complete once it settles, also for a cancelled run.
+            let rawResult;
+            try {
+                rawResult = await generation;
+                generated = true;
+            }
+            finally {
+                await this.core.callbacks.settleMetricsOperation(run.state, run.stored, run.metricsOperation);
+            }
+            if (rawResult.terminationReason === 'step-limit') {
+                throw this.core.trustInternalError(new FlexHarnessStepLimitError(rawResult.steps));
+            }
+            // Background tools do not block inference, but the owning turn joins its admitted children
+            // before releasing its authority or committing its terminal projection.
+            await Promise.all([...run.backgroundSubagents]);
+            if (run.callbackError)
+                throw run.callbackError;
+            if (run.controller.signal.aborted)
+                throw run.controller.signal.reason;
+            const result = normalizeRunResult(rawResult);
+            if (!run.modelResolution)
+                throw new FlexHarnessValidationError('Generation completed without a resolved model.');
+            await this.core.reversions.finalizeRunReversion(run, 'completed');
+            await this.core.admission.closeRunDelegatedRunAdmission(run);
+            const terminal = this.buildTerminal(run, 'completed', result);
+            try {
+                await this.core.mutateProjection(run.state, run.stored, () => {
+                    this.replaceStagedTerminal(run.stored, terminal);
+                }, true);
+            }
+            catch (error) {
+                throw this.core.projectExternalError(run, error, 'persistence');
+            }
+            if (run.controller.signal.aborted)
+                throw run.controller.signal.reason;
+            run.phase = 'finalizing';
+            try {
+                await this.core.compaction.withRunCompactorContext(run, () => run.stored.agentSession.finalizeGeneration(run.transaction, 'accepted'));
+            }
+            catch (error) {
+                const projected = this.core.projectExternalError(run, error, 'agentSession');
+                await this.core.lifecycle.fenceNamespace(run.state, run, projected);
+                throw projected;
+            }
+            run.steering.keptInContext = true;
+            this.core.reversions.refreshAutomaticArchiveHorizon(run.stored);
+            run.phase = 'promoting';
+            const closePublication = this.core.openPublication(run.state, run.sessionId);
+            try {
+                try {
+                    await this.promoteCompletedTerminal(run, terminal);
+                }
+                catch (error) {
+                    const projected = this.core.projectExternalError(run, error, 'persistence');
+                    await this.core.lifecycle.fenceNamespace(run.state, run, projected);
+                    throw projected;
+                }
+                this.emitTerminalProjection(run, terminal);
+                this.emitFinalRunEvent(run, terminal.assistantMessage, undefined, false);
+            }
+            finally {
+                closePublication();
+            }
+            await this.core.reversions.drainReversionReleases(run.state, run.stored, run.scopeId, run.scope, false);
+            return {
+                runId: run.runId,
+                sessionId: run.sessionId,
+                userMessage: publicSnapshot(terminal.userMessage),
+                assistantMessage: publicSnapshot(terminal.assistantMessage),
+                model: publicSnapshot(terminal.model),
+                usage: publicSnapshot(terminal.usage),
+                finishReason: terminal.finishReason,
+                steps: terminal.steps,
+                unappliedSteerIds: [...this.closeRunSteering(run.steering).unappliedSteerIds],
+            };
+        }
+        catch (error) {
+            // A failed parent must cancel its admitted children before joining them. Otherwise a
+            // child waiting for permission or model I/O can keep a failed parent alive indefinitely.
+            if (run.backgroundSubagents.size > 0 && !run.controller.signal.aborted)
+                run.controller.abort(error);
+            await Promise.allSettled([...run.backgroundSubagents]);
+            try {
+                if (run.state.lifecycle === 'fenced') {
+                    await this.core.lifecycle.fenceNamespace(run.state, run, error);
+                    throw error;
+                }
+                if (run.state.lifecycle === 'retired')
+                    throw error;
+                return await this.finishFailedRun(run, error, generated);
+            }
+            catch (finalError) {
+                this.emitUnpublishedRunFinish(run, finalError, generated);
+                throw finalError;
+            }
+        }
+        finally {
+            run.callbacksClosed = true;
+            this.core.permissions.rejectRunPermissions(run.state, run, run.ownerCancellation ?? new FlexHarnessAbortError('The run ended before permission was resolved.'));
+            if (run.state.activeRuns.get(run.sessionId) === run)
+                run.state.activeRuns.delete(run.sessionId);
+        }
+    }
+    async finishFailedRun(run, error, generated) {
+        run.callbacksClosed = true;
+        run.phase = 'closing';
+        const cancelled = run.ownerCancellation !== undefined && run.internalFailure === undefined;
+        const safeError = cancelled
+            ? run.ownerCancellation
+            : this.core.projectExternalError(run, error, generated ? 'persistence' : 'agentSession');
+        const errors = [safeError];
+        let reversionFailed = false;
+        try {
+            await this.core.reversions.finalizeRunReversion(run, cancelled ? 'cancelled' : 'failed');
+        }
+        catch (reversionError) {
+            errors.push(reversionError);
+            reversionFailed = true;
+        }
+        try {
+            await this.core.admission.closeRunDelegatedRunAdmission(run);
+        }
+        catch (closeError) {
+            if (!errors.includes(closeError))
+                errors.push(closeError);
+        }
+        if (reversionFailed) {
+            const combined = combineErrors(errors);
+            await this.core.lifecycle.fenceNamespace(run.state, run, combined);
+            throw combined;
+        }
+        if (generated && !this.core.isTombstoned(run)) {
+            const failedStage = this.buildTerminal(run, cancelled ? 'cancelled' : 'failed', undefined, safeError);
+            try {
+                await this.core.mutateProjection(run.state, run.stored, () => {
+                    this.replaceStagedTerminal(run.stored, failedStage);
+                }, true);
+            }
+            catch (stageError) {
+                errors.push(this.core.projectExternalError(run, stageError, 'persistence'));
+            }
+        }
+        run.phase = 'finalizing';
+        const desiredOutcome = cancelled || !generated ? 'interrupted' : 'rejected';
+        try {
+            await this.core.compaction.withRunCompactorContext(run, () => run.stored.agentSession.finalizeGeneration(run.transaction, desiredOutcome, { stopped: desiredOutcome === 'interrupted' && cancelled }));
+        }
+        catch (finalizationError) {
+            errors.push(this.core.projectExternalError(run, finalizationError, 'agentSession'));
+        }
+        let outcome;
+        try {
+            const snapshot = await run.stored.eventStore.load(run.stored.session.sessionId);
+            const events = snapshot?.events ?? [];
+            outcome = this.core.canonicalOutcomes(events).get(run.runId);
+            // A generation without a durable outcome is interrupted by the next load, which leaves it
+            // out of the model context.
+            run.steering.keptInContext = outcome !== undefined
+                && plugins.isGenerationInModelContext(events, run.runId);
+            this.core.reversions.refreshAutomaticArchiveHorizon(run.stored);
+        }
+        catch (outcomeError) {
+            errors.push(this.core.projectExternalError(run, outcomeError, 'persistence'));
+        }
+        if (!outcome) {
+            const combined = combineErrors(errors);
+            await this.core.lifecycle.fenceNamespace(run.state, run, combined);
+            throw combined;
+        }
+        if (outcome === 'accepted') {
+            const combined = combineErrors(errors);
+            await this.core.lifecycle.fenceNamespace(run.state, run, combined);
+            throw combined;
+        }
+        const publicStatus = outcome === 'rejected' || !cancelled ? 'failed' : 'cancelled';
+        const terminalError = publicStatus === 'cancelled'
+            ? run.ownerCancellation ?? this.core.trustInternalError(new FlexHarnessAbortError())
+            : safeError;
+        const terminal = this.buildTerminal(run, publicStatus, undefined, terminalError);
+        if (!this.core.isTombstoned(run)) {
+            const closePublication = this.core.openPublication(run.state, run.sessionId);
+            try {
+                try {
+                    await this.publishFailedTerminal(run, terminal);
+                }
+                catch (persistenceError) {
+                    errors.push(this.core.projectExternalError(run, persistenceError, 'persistence'));
+                    const combined = combineErrors(errors);
+                    await this.core.lifecycle.fenceNamespace(run.state, run, combined);
+                    throw combined;
+                }
+                this.emitTerminalProjection(run, terminal);
+                this.emitFinalRunEvent(run, terminal.assistantMessage, terminalError, publicStatus === 'cancelled');
+            }
+            finally {
+                closePublication();
+            }
+        }
+        await this.core.reversions.drainReversionReleases(run.state, run.stored, run.scopeId, run.scope, false);
+        throw errors.length > 1 ? combineErrors(errors) : terminalError;
+    }
+    async prepareGeneration(run, options, signal) {
+        signal.throwIfAborted();
+        const configuration = await this.core.configurations.resolveSessionConfiguration(run.scopeId, run.scope, run.state, run.stored, signal);
+        run.subagents = configuration.subagents;
+        run.allowedTools = configuration.allowedTools;
+        run.permissionPolicy = configuration.permissionPolicy;
+        const agent = run.stored.session.agent;
+        if (agent !== undefined) {
+            const definition = configuration.subagents.get(agent);
+            if (!definition)
+                throw new FlexHarnessValidationError(`Subagent "${agent}" is disabled.`);
+            run.agentAllowedTools = definition.allowedTools;
+        }
+        await this.core.reversions.prepareRunReversion(run, signal);
+        run.phase = 'running';
+        const queued = run.stored.outstandingPromptsById.get(run.queueId);
+        if (queued && (queued.status === 'starting' || queued.status === 'scheduled')) {
+            queued.status = 'running';
+            this.core.prompts.emitPromptQueueEvent(queued, 'prompt.running');
+        }
+        const resolverRelationship = {
+            ...(run.stored.session.parentSessionId === undefined
+                ? {}
+                : { parentSessionId: run.stored.session.parentSessionId }),
+            ...(run.stored.session.agent === undefined ? {} : { agent: run.stored.session.agent }),
+        };
+        const modelOutcome = Promise.resolve()
+            .then(() => this.core.modelResolver.resolveModel(Object.freeze({
+            scopeId: run.scopeId,
+            scope: run.scope,
+            sessionId: run.sessionId,
+            ...requireSessionGeneration(run.stored.session),
+            runId: run.runId,
+            ...(options.modelHint ? { modelHint: options.modelHint } : {}),
+            ...resolverRelationship,
+            signal,
+        })))
+            .then((value) => ({ source: 'model', success: true, value }), (error) => ({ source: 'model', success: false, error }));
+        const toolProviderContext = Object.freeze({
+            scopeId: run.scopeId,
+            scope: run.scope,
+            sessionId: run.sessionId,
+            ...requireSessionGeneration(run.stored.session),
+            runId: run.runId,
+            ...resolverRelationship,
+            signal,
+            requestPermission: async (request) => {
+                // A call that started early asks once the model's response confirmed it.
+                const confirmed = request.toolCallId === undefined
+                    ? undefined
+                    : run.unconfirmedToolCalls.get(request.toolCallId);
+                if (confirmed)
+                    await confirmed;
+                return this.core.permissions.requestPermission(run.state, run, request);
+            },
+        });
+        const toolOutcome = Promise.resolve()
+            .then(() => this.core.providers.provideRunToolHandle(run, toolProviderContext))
+            .then((value) => ({ source: 'tools', success: true, value }), (error) => ({ source: 'tools', success: false, error }));
+        let resolveAbort;
+        const abortOutcome = new Promise((resolve) => {
+            resolveAbort = resolve;
+        });
+        const onAbort = () => resolveAbort({
+            source: 'abort',
+            success: false,
+            error: signal.reason ?? new FlexHarnessAbortError(),
+        });
+        signal.addEventListener('abort', onAbort, { once: true });
+        if (signal.aborted)
+            onAbort();
+        let model;
+        let toolHandle;
+        try {
+            const first = await Promise.race([modelOutcome, toolOutcome, abortOutcome]);
+            if (!first.success) {
+                const failure = first.source === 'abort'
+                    ? first.error
+                    : this.core.projectExternalError(run, first.error, first.source === 'model' ? 'modelResolver' : 'toolProvider');
+                if (first.source !== 'abort')
+                    this.abortRunInternally(run, failure);
+                if (first.source !== 'tools')
+                    this.core.providers.observeDetachedToolProvider(toolOutcome, run);
+                throw failure;
+            }
+            try {
+                if (first.source === 'model')
+                    model = normalizeResolvedModel(first.value);
+                else
+                    toolHandle = this.core.providers.normalizeToolHandle(run, first.value);
+            }
+            catch (error) {
+                const projected = first.source === 'model'
+                    ? this.core.projectExternalError(run, error, 'modelResolver')
+                    : this.core.projectExternalError(run, error, 'toolProvider');
+                this.abortRunInternally(run, projected);
+                if (first.source === 'model')
+                    this.core.providers.observeDetachedToolProvider(toolOutcome, run);
+                throw projected;
+            }
+            const second = await Promise.race([
+                first.source === 'model' ? toolOutcome : modelOutcome,
+                abortOutcome,
+            ]);
+            if (!second.success) {
+                const failure = second.source === 'abort'
+                    ? second.error
+                    : this.core.projectExternalError(run, second.error, second.source === 'model' ? 'modelResolver' : 'toolProvider');
+                if (second.source !== 'abort')
+                    this.abortRunInternally(run, failure);
+                if (!toolHandle && first.source === 'model' && second.source === 'abort') {
+                    this.core.providers.observeDetachedToolProvider(toolOutcome, run);
+                }
+                throw failure;
+            }
+            try {
+                if (second.source === 'model')
+                    model = normalizeResolvedModel(second.value);
+                else
+                    toolHandle = this.core.providers.normalizeToolHandle(run, second.value);
+            }
+            catch (error) {
+                const projected = second.source === 'model'
+                    ? this.core.projectExternalError(run, error, 'modelResolver')
+                    : this.core.projectExternalError(run, error, 'toolProvider');
+                this.abortRunInternally(run, projected);
+                throw projected;
+            }
+            signal.throwIfAborted();
+            run.modelResolution = model;
+            run.toolProviderContext = toolProviderContext;
+            run.isReadOnlyHostCall = toolHandle?.isReadOnlyToolCall;
+            let catalog;
+            if (toolHandle?.catalog) {
+                try {
+                    catalog = await FlexToolCatalog.create(toolHandle.catalog, this.core.toolCatalogOptions, {
+                        results: this.core.stores.results !== undefined,
+                    });
+                    if (catalog.codeMode)
+                        run.codeSandbox = await FlexCodeSandbox.load();
+                }
+                catch (error) {
+                    throw this.core.projectExternalError(run, error, 'toolProvider');
+                }
+                signal.throwIfAborted();
+            }
+            let tools;
+            try {
+                const providedTools = toolHandle?.tools;
+                const combinedTools = { ...(providedTools ?? {}) };
+                Object.assign(combinedTools, this.createBuiltInTools(run));
+                if (catalog)
+                    assertNoCatalogCollisions(catalog, combinedTools);
+                const globalNames = run.allowedTools === undefined ? undefined : new Set(run.allowedTools);
+                const agentNames = run.agentAllowedTools === undefined ? undefined : new Set(run.agentAllowedTools);
+                const admitted = (name) => (globalNames === undefined || globalNames.has(name))
+                    && (agentNames === undefined || agentNames.has(name));
+                const admittedTools = globalNames === undefined && agentNames === undefined
+                    ? combinedTools
+                    : Object.fromEntries(Object.entries(combinedTools).filter(([name]) => admitted(name)));
+                const admittedCatalog = catalog && (globalNames === undefined && agentNames === undefined
+                    ? catalog
+                    : catalog.restrict(catalog.methods.filter((name) => name === FLEX_RESULT_METHOD || admitted(name))));
+                if (admittedCatalog && admittedCatalog.methods.length > 0) {
+                    run.toolCatalog = admittedCatalog;
+                    Object.assign(admittedTools, this.core.toolDispatch.createCatalogTools(run, admittedCatalog));
+                }
+                tools = Object.keys(admittedTools).length > 0
+                    ? this.core.toolDispatch.trackToolCalls(run, wrapToolSet(admittedTools, this.core.toolOutputLimits, (toolError) => this.core.projectExternalError(run, toolError, 'toolExecution'), (output) => this.core.results.budgetOutput(run, output)))
+                    : undefined;
+            }
+            catch (error) {
+                throw this.core.projectExternalError(run, error, 'toolProvider');
+            }
+            let closed = false;
+            let closePromise;
+            const close = toolHandle?.close
+                ? async () => {
+                    if (closed)
+                        return;
+                    // Inference has ended before its tool lease closes. Fence follow-up admission
+                    // synchronously, even when external cleanup has not settled yet.
+                    run.steering.input.close();
+                    closePromise ??= Promise.resolve()
+                        .then(() => toolHandle.close())
+                        .then(() => {
+                        closed = true;
+                    })
+                        .catch((cleanupError) => {
+                        closePromise = undefined;
+                        throw this.core.projectExternalError(run, cleanupError, 'toolCleanup');
+                    });
+                    await closePromise;
+                }
+                : undefined;
+            return {
+                model: model.model,
+                ...(options.system ?? model.system ? { system: options.system ?? model.system } : {}),
+                ...(tools ? {
+                    tools,
+                    isReadOnlyToolCall: ({ toolName, input }) => this.core.toolDispatch.isReadOnlyToolCall(run, toolName, input),
+                } : {}),
+                ...(model.providerOptions ? { providerOptions: model.providerOptions } : {}),
+                ...(model.cache === undefined ? {} : { cache: model.cache }),
+                ...(options.maxSteps ?? model.maxSteps ? { maxSteps: options.maxSteps ?? model.maxSteps } : {}),
+                ...(close ? { close } : {}),
+            };
+        }
+        catch (error) {
+            if (toolHandle) {
+                try {
+                    await this.core.providers.closePartialToolHandle(toolHandle, run);
+                }
+                catch (cleanupError) {
+                    throw combineErrors([error, cleanupError]);
+                }
+            }
+            throw error;
+        }
+        finally {
+            signal.removeEventListener('abort', onAbort);
+        }
+    }
+    enabledBuiltInToolNames(run) {
+        const names = new Set();
+        if (run.subagents.size > 0 && (run.stored.session.depth ?? 0) < this.core.maxSubagentDepth) {
+            names.add('delegate');
+            names.add('delegate_result');
+            names.add('delegate_send');
+        }
+        if (this.core.builtInTools.renameSession)
+            names.add('rename_session');
+        const projectManagement = this.core.builtInTools.projectManagement;
+        if (projectManagement?.task)
+            names.add('task');
+        if (projectManagement?.goal)
+            names.add('goal');
+        if (projectManagement?.scratchpad)
+            names.add('scratchpad');
+        return names;
+    }
+    assertNoBuiltInToolCollisions(run, tools) {
+        const reserved = this.enabledBuiltInToolNames(run);
+        const collision = Object.keys(tools).find((name) => reserved.has(name));
+        if (collision) {
+            throw new FlexHarnessValidationError(`Tool provider cannot define enabled built-in tool "${collision}".`);
+        }
+    }
+    createBuiltInTools(run) {
+        const tools = {};
+        if (run.subagents.size > 0 && (run.stored.session.depth ?? 0) < this.core.maxSubagentDepth) {
+            tools.delegate = this.core.subagentTasks.createSubagentTool(run);
+            tools.delegate_result = this.core.subagentTasks.createSubagentResultTool(run);
+            tools.delegate_send = this.core.subagentTasks.createSubagentSendTool(run);
+        }
+        if (this.core.builtInTools.renameSession)
+            tools.rename_session = this.createRenameSessionTool(run);
+        const projectManagement = this.core.builtInTools.projectManagement;
+        if (projectManagement?.task)
+            tools.task = this.core.projects.createProjectTaskTool(run);
+        if (projectManagement?.goal)
+            tools.goal = this.core.projects.createProjectGoalTool(run);
+        if (projectManagement?.scratchpad)
+            tools.scratchpad = this.core.projects.createProjectScratchpadTool(run);
+        return tools;
+    }
+    createRenameSessionTool(run) {
+        return plugins.tool({
+            description: 'Set the current FlexHarness session title.',
+            inputSchema: plugins.z.object({
+                title: plugins.z.string().min(1).max(FLEX_PROJECT_MANAGEMENT_LIMITS.maxTitleBytes),
+            }).strict(),
+            execute: async ({ title }) => {
+                validateUtf8String(title, 'title', FLEX_PROJECT_MANAGEMENT_LIMITS.maxTitleBytes, true);
+                let session;
+                await this.core.mutateScope(run.state, () => {
+                    if (run.state.sessions.get(run.sessionId) !== run.stored) {
+                        throw new FlexHarnessNotFoundError('Session', run.sessionId);
+                    }
+                    run.stored.session.title = title;
+                    run.stored.session.updatedAt = new Date().toISOString();
+                    session = publicSnapshot(run.stored.session);
+                });
+                this.core.emitEvent(run.scopeId, session, {
+                    type: 'session.updated',
+                    session,
+                });
+                return { session };
+            },
+        });
+    }
+    abortExactRun(state, sessionId, runId, reason) {
+        const active = state.activeRuns.get(sessionId);
+        if (!active || active.runId !== runId || active.phase === 'finalizing' || active.phase === 'promoting') {
+            return false;
+        }
+        const cancellation = reason instanceof FlexHarnessAbortError
+            ? reason
+            : this.core.trustInternalError(new FlexHarnessAbortError('The parent run was aborted.'));
+        this.cancelRun(active, cancellation);
+        return true;
+    }
+    createReservation(run, prompt) {
+        const timestamp = new Date().toISOString();
+        const userMessage = {
+            messageId: run.userMessageId,
+            sessionId: run.sessionId,
+            runId: run.runId,
+            role: 'user',
+            status: 'streaming',
+            createdAt: timestamp,
+            parts: this.userMessageParts(prompt),
+        };
+        const assistantMessage = {
+            messageId: run.assistantMessageId,
+            sessionId: run.sessionId,
+            runId: run.runId,
+            role: 'assistant',
+            status: 'streaming',
+            createdAt: timestamp,
+            parts: [],
+        };
+        return { userMessage, assistantMessage };
+    }
+    userMessageParts(prompt) {
+        return prompt.parts.map((part) => {
+            if (part.type === 'text') {
+                return { partId: plugins.crypto.randomUUID(), type: 'text', text: part.text };
+            }
+            return {
+                partId: plugins.crypto.randomUUID(),
+                type: 'attachment',
+                attachmentType: part.type,
+                ...describeAttachment(part),
+            };
+        });
+    }
+    /**
+     * Ends steering intake once the run's generation has settled and fixes what became of its
+     * steers. A run that stays in the model context reports the steers its generation did not
+     * record; a run that does not, because it failed, was stopped before any model output or its
+     * outcome could not be established, reports every steer it accepted, since the model context
+     * of later turns holds none of them. The bytes of the steers not taken in are released.
+     */
+    closeRunSteering(steering) {
+        if (steering.outcome)
+            return steering.outcome;
+        steering.input.close();
+        const keptInContext = steering.keptInContext === true;
+        const unappliedSteerIds = [];
+        let heldBytes = 0;
+        for (const [steerId, entry] of steering.accepted) {
+            const applied = steering.applied.has(steerId);
+            if (!applied)
+                heldBytes += entry.byteSize;
+            if (!keptInContext || !applied)
+                unappliedSteerIds.push(steerId);
+        }
+        steering.stored.outstandingPromptBytes = Math.max(0, steering.stored.outstandingPromptBytes - heldBytes);
+        steering.outcome = Object.freeze({
+            keptInContext,
+            unappliedSteerIds: Object.freeze(unappliedSteerIds),
+        });
+        return steering.outcome;
+    }
+    /**
+     * Projects a steer the run's generation took in as a user message of the run. The assistant
+     * message that answered before it is completed and the run answers on in a new one; a steer
+     * taken in before the run answered anything is placed before its still empty assistant message.
+     */
+    async applyRunSteer(run, applied) {
+        const steering = run.steering;
+        const accepted = steering.accepted.get(applied.inputId);
+        if (!accepted
+            || applied.generationId !== run.runId
+            || steering.applied.has(applied.inputId)
+            || steering.outcome !== undefined) {
+            throw new Error(`Steer "${applied.inputId}" was taken in without being accepted by its run.`);
+        }
+        // The generation recorded the steer durably: it is in the model context whenever the run is.
+        steering.applied.add(applied.inputId);
+        steering.stored.outstandingPromptBytes = Math.max(0, steering.stored.outstandingPromptBytes - accepted.byteSize);
+        const timestamp = new Date().toISOString();
+        const steerMessage = {
+            messageId: plugins.crypto.randomUUID(),
+            sessionId: run.sessionId,
+            runId: run.runId,
+            role: 'user',
+            status: 'completed',
+            createdAt: timestamp,
+            completedAt: timestamp,
+            steerId: applied.inputId,
+            parts: this.userMessageParts(accepted.prompt),
+        };
+        const answered = run.callbackParts.length > 0;
+        const answeredAssistantId = run.assistantMessageId;
+        let completedAssistant;
+        const nextAssistant = answered
+            ? {
+                messageId: plugins.crypto.randomUUID(),
+                sessionId: run.sessionId,
+                runId: run.runId,
+                role: 'assistant',
+                status: 'streaming',
+                createdAt: timestamp,
+                parts: [],
+            }
+            : undefined;
+        const closePublication = this.core.openPublication(run.state, run.sessionId);
+        try {
+            await this.core.mutateProjection(run.state, run.stored, () => {
+                const index = run.stored.messages.findIndex((message) => message.messageId === answeredAssistantId);
+                if (index < 0)
+                    throw new Error('The steered run has no projected assistant message.');
+                if (!nextAssistant) {
+                    run.stored.messages.splice(index, 0, cloneSerializable(steerMessage));
+                    return;
+                }
+                completedAssistant = {
+                    ...cloneSerializable(run.stored.messages[index]),
+                    status: 'completed',
+                    completedAt: timestamp,
+                    parts: cloneSerializable(run.callbackParts),
+                    ...(run.modelResolution ? { model: cloneSerializable(run.modelResolution.identity) } : {}),
+                };
+                run.stored.messages.splice(index, 1, cloneSerializable(completedAssistant), cloneSerializable(steerMessage), cloneSerializable(nextAssistant));
+            });
+            if (completedAssistant && nextAssistant) {
+                run.assistantMessageId = nextAssistant.messageId;
+                run.reservedAssistantMessage = publicSnapshot(nextAssistant);
+                run.callbackParts = [];
+                run.reasoningPartIds.clear();
+                this.core.emitEvent(run.scopeId, run.stored.session, {
+                    type: 'message.updated',
+                    runId: run.runId,
+                    messageId: completedAssistant.messageId,
+                    message: publicSnapshot(completedAssistant),
+                });
+            }
+            this.core.emitEvent(run.scopeId, run.stored.session, {
+                type: 'message.created',
+                runId: run.runId,
+                messageId: steerMessage.messageId,
+                message: publicSnapshot(steerMessage),
+            });
+            if (nextAssistant) {
+                this.core.emitEvent(run.scopeId, run.stored.session, {
+                    type: 'message.created',
+                    runId: run.runId,
+                    messageId: nextAssistant.messageId,
+                    message: publicSnapshot(nextAssistant),
+                });
+            }
+            this.core.emitEvent(run.scopeId, run.stored.session, {
+                type: 'prompt.steer.applied',
+                queueId: run.queueId,
+                runId: run.runId,
+                steerId: applied.inputId,
+                messageId: steerMessage.messageId,
+            });
+        }
+        finally {
+            closePublication();
+        }
+    }
+    buildTerminal(run, status, result, error) {
+        const timestamp = new Date().toISOString();
+        const userMessage = cloneSerializable(run.reservedUserMessage
+            ?? run.stored.messages.find((message) => message.messageId === run.userMessageId)
+            ?? {
+                messageId: run.userMessageId,
+                sessionId: run.sessionId,
+                runId: run.runId,
+                role: 'user',
+                status: 'streaming',
+                createdAt: timestamp,
+                parts: [],
+            });
+        const assistantMessage = cloneSerializable(run.reservedAssistantMessage
+            ?? run.stored.messages.find((message) => message.messageId === run.assistantMessageId)
+            ?? {
+                messageId: run.assistantMessageId,
+                sessionId: run.sessionId,
+                runId: run.runId,
+                role: 'assistant',
+                status: 'streaming',
+                createdAt: timestamp,
+                parts: [],
+            });
+        assistantMessage.parts = cloneSerializable(run.callbackParts);
+        const terminalParts = assistantMessage.parts;
+        for (const part of terminalParts) {
+            if (part.type === 'reasoning' && part.status === 'running') {
+                part.status = status === 'completed' ? 'completed' : 'cancelled';
+                part.completedAt = timestamp;
+            }
+            else if (part.type === 'tool' && part.status === 'running') {
+                part.status = status === 'cancelled' ? 'cancelled' : 'failed';
+                delete part.output;
+                part.error = status === 'cancelled'
+                    ? 'Tool execution was cancelled.'
+                    : 'Tool execution ended without a terminal event.';
+                part.completedAt = timestamp;
+            }
+        }
+        userMessage.status = status;
+        userMessage.completedAt = timestamp;
+        assistantMessage.status = status;
+        assistantMessage.completedAt = timestamp;
+        if (run.modelResolution)
+            assistantMessage.model = cloneSerializable(run.modelResolution.identity);
+        if (status === 'completed' && result) {
+            if (!assistantMessage.parts.some((part) => part.type === 'text')) {
+                assistantMessage.parts.push({
+                    partId: plugins.crypto.randomUUID(),
+                    type: 'text',
+                    text: truncateUtf8(result.text, this.core.callbackLimits.maxOutputBytes),
+                });
+            }
+            assistantMessage.usage = cloneSerializable(result.usage);
+        }
+        else {
+            assistantMessage.usage = cloneSerializable(run.usage);
+            const message = truncateUtf8(error?.message ?? externalErrorFallback.message, maxTransferMetadataBytes);
+            const limit = error instanceof FlexHarnessExternalError ? error.limit : undefined;
+            for (const failedMessage of [userMessage, assistantMessage]) {
+                failedMessage.error = message;
+                if (limit)
+                    failedMessage.limit = cloneSerializable(limit);
+            }
+        }
+        return {
+            runId: run.runId,
+            status,
+            userMessage,
+            assistantMessage,
+            ...(run.modelResolution ? { model: cloneSerializable(run.modelResolution.identity) } : {}),
+            ...(status === 'completed' && result
+                ? {
+                    usage: cloneSerializable(result.usage),
+                    finishReason: result.finishReason,
+                    steps: result.steps,
+                }
+                : { usage: cloneSerializable(run.usage) }),
+        };
+    }
+    async promoteCompletedTerminal(run, terminal) {
+        await this.core.mutateProjection(run.state, run.stored, () => {
+            this.replaceVisibleRun(run.stored, terminal);
+            run.stored.stagedTerminals = run.stored.stagedTerminals.filter((entry) => entry.runId !== run.runId);
+        }, true);
+        if (!this.core.isTombstoned(run)) {
+            await this.core.mutateScope(run.state, () => {
+                if (run.state.sessions.get(run.sessionId) !== run.stored)
+                    return;
+                const timestamp = terminal.assistantMessage.completedAt;
+                run.stored.session.status = 'idle';
+                run.stored.session.activity = {
+                    runId: run.runId,
+                    status: 'idle',
+                    startedAt: run.stored.session.activity.startedAt,
+                    completedAt: timestamp,
+                };
+                run.stored.session.updatedAt = timestamp;
+            }, true);
+        }
+    }
+    async publishFailedTerminal(run, terminal) {
+        await this.core.mutateProjection(run.state, run.stored, () => {
+            this.replaceVisibleRun(run.stored, terminal);
+            run.stored.stagedTerminals = run.stored.stagedTerminals.filter((entry) => entry.runId !== run.runId);
+        }, true);
+        await this.core.mutateScope(run.state, () => {
+            if (run.state.sessions.get(run.sessionId) !== run.stored)
+                return;
+            const timestamp = terminal.assistantMessage.completedAt;
+            const activityStatus = terminal.status === 'completed' ? 'idle' : terminal.status;
+            run.stored.session.status = activityStatus;
+            run.stored.session.activity = {
+                runId: run.runId,
+                status: activityStatus,
+                startedAt: run.stored.session.activity.startedAt,
+                completedAt: timestamp,
+                ...terminalActivityError(terminal.assistantMessage),
+            };
+            run.stored.session.updatedAt = timestamp;
+        }, true);
+    }
+    replaceStagedTerminal(stored, terminal) {
+        stored.stagedTerminals = stored.stagedTerminals.filter((entry) => entry.runId !== terminal.runId);
+        stored.stagedTerminals.push(cloneSerializable(terminal));
+    }
+    /**
+     * Puts a run's terminal messages in place of their projected versions: its prompt, and its last
+     * assistant message. The steers a run took in, and the assistant messages it completed before
+     * them, stay where they are. A terminal message that is not projected yet is added: the prompt
+     * before the run's other messages, the assistant message after them.
+     */
+    replaceVisibleRun(stored, terminal) {
+        const replacements = new Map([
+            [terminal.userMessage.messageId, terminal.userMessage],
+            [terminal.assistantMessage.messageId, terminal.assistantMessage],
+        ]);
+        const placed = new Set();
+        stored.messages = stored.messages.map((message) => {
+            const replacement = message.runId === terminal.runId
+                ? replacements.get(message.messageId)
+                : undefined;
+            if (!replacement)
+                return message;
+            placed.add(replacement.messageId);
+            return cloneSerializable(replacement);
+        });
+        const firstIndex = stored.messages.findIndex((message) => message.runId === terminal.runId);
+        if (!placed.has(terminal.userMessage.messageId)) {
+            stored.messages.splice(firstIndex < 0 ? stored.messages.length : firstIndex, 0, cloneSerializable(terminal.userMessage));
+        }
+        if (!placed.has(terminal.assistantMessage.messageId)) {
+            const lastIndex = stored.messages.reduce((last, message, index) => message.runId === terminal.runId ? index : last, -1);
+            stored.messages.splice(lastIndex < 0 ? stored.messages.length : lastIndex + 1, 0, cloneSerializable(terminal.assistantMessage));
+        }
+    }
+    emitTerminalProjection(run, terminal) {
+        for (const part of terminal.assistantMessage.parts) {
+            const callbackPart = run.callbackParts.find((entry) => entry.partId === part.partId);
+            const shouldComplete = part.type === 'text'
+                ? callbackPart?.type === 'text'
+                : part.type === 'reasoning'
+                    ? callbackPart?.type === 'reasoning' && callbackPart.status === 'running'
+                    : part.type === 'tool'
+                        ? callbackPart?.type === 'tool' && callbackPart.status === 'running'
+                        : false;
+            if (shouldComplete) {
+                this.core.emitPartEvent(run, 'part.completed', part);
+            }
+        }
+        for (const message of [terminal.userMessage, terminal.assistantMessage]) {
+            this.core.emitEvent(run.scopeId, run.stored.session, {
+                type: 'message.updated',
+                runId: run.runId,
+                messageId: message.messageId,
+                message: publicSnapshot(message),
+            });
+        }
+    }
+    /**
+     * Ends a run that fails without publishing a terminal projection, because its namespace was
+     * fenced or retired or its durable outcome could not be established: listeners still receive
+     * its terminal message events and its one `run.finished`. Nothing here is persisted; the next
+     * load of the namespace repairs the stored projection from the canonical outcome.
+     */
+    emitUnpublishedRunFinish(run, error, generated) {
+        if (run.finishedEventEmitted || run.state.tombstones.has(run.sessionId))
+            return;
+        const cancelled = run.ownerCancellation !== undefined && run.internalFailure === undefined;
+        const terminalError = cancelled
+            ? run.ownerCancellation
+            : error instanceof FlexHarnessRunError
+                ? error
+                : this.core.projectExternalError(run, error, generated ? 'persistence' : 'agentSession');
+        const terminal = this.buildTerminal(run, cancelled ? 'cancelled' : 'failed', undefined, terminalError);
+        this.emitTerminalProjection(run, terminal);
+        this.emitFinalRunEvent(run, terminal.assistantMessage, terminalError, cancelled);
+    }
+    emitFinalRunEvent(run, message, error, cancelled) {
+        const status = error
+            ? cancelled ? 'cancelled' : 'failed'
+            : 'completed';
+        run.finishedEventEmitted = true;
+        const steering = this.closeRunSteering(run.steering);
+        this.core.emitEvent(run.scopeId, run.stored.session, {
+            type: 'run.finished',
+            runId: run.runId,
+            messageId: run.assistantMessageId,
+            status,
+            message: publicSnapshot(message),
+            ...(error === undefined ? {} : { error: errorToInfo(error) }),
+            keptInContext: steering.keptInContext,
+            unappliedSteerIds: [...steering.unappliedSteerIds],
+        });
+    }
+    cancelRun(run, reason, context) {
+        const invocationContext = context ?? this.core.compaction.createRunCompactorContext(run);
+        // A stopped run takes no further steers; the ones it has not taken in are reported unapplied.
+        run.steering.input.close();
+        if (run.internalFailure === undefined && run.ownerCancellation === undefined) {
+            run.ownerCancellation = reason;
+            run.deferredCompactorContext = invocationContext;
+            this.core.compaction.deferredCompactorContexts.set(run.originCompactorContext, invocationContext);
+        }
+        this.core.compaction.withCompactorContext((run.deferredCompactorContext ?? invocationContext), () => {
+            this.core.permissions.rejectRunPermissions(run.state, run, reason);
+            // The owner stops the generation: what its model produced stays in the model context.
+            if (run.ownerCancellation === reason && !run.stop.signal.aborted)
+                run.stop.abort(reason);
+            if (!run.controller.signal.aborted)
+                run.controller.abort(reason);
+            if (run.phase === 'admitting')
+                return;
+            if (run.scheduleKey) {
+                run.stored.agentSession.cancelScheduledGeneration(run.scheduleKey, reason);
+            }
+            else {
+                run.stored.agentSession.abortCurrentGeneration(reason);
+            }
+        });
+    }
+    abortRunInternally(run, error, context) {
+        const invocationContext = context ?? this.core.compaction.createRunCompactorContext(run);
+        run.steering.input.close();
+        if (run.internalFailure === undefined) {
+            run.internalFailure = error ?? new Error('Internal FlexHarness run failure.');
+            run.deferredCompactorContext = invocationContext;
+            this.core.compaction.deferredCompactorContexts.set(run.originCompactorContext, invocationContext);
+        }
+        this.core.compaction.withCompactorContext((run.deferredCompactorContext ?? invocationContext), () => {
+            if (!run.controller.signal.aborted)
+                run.controller.abort(run.internalFailure);
+            run.stored.agentSession.abortCurrentGeneration(run.internalFailure);
+        });
+    }
+    async rollbackAdmission(run, projectionReserved, originalError) {
+        const errors = [];
+        if (run.transaction) {
+            try {
+                await this.core.compaction.withRunCompactorContext(run, () => run.stored.agentSession.finalizeGeneration(run.transaction, 'interrupted'));
+            }
+            catch (error) {
+                errors.push(this.core.projectExternalError(run, error, 'agentSession'));
+            }
+            try {
+                const outcome = (await this.core.durableCanonicalOutcomes(run.stored)).get(run.runId);
+                if (outcome !== 'interrupted') {
+                    errors.push(this.core.projectExternalError(run, new Error('Prompt admission interruption is not durably established.'), 'persistence'));
+                }
+            }
+            catch (error) {
+                errors.push(this.core.projectExternalError(run, error, 'persistence'));
+            }
+        }
+        if (projectionReserved || run.stored.metrics.pendingGenerationId === run.runId) {
+            try {
+                await this.core.mutateProjection(run.state, run.stored, () => {
+                    if (run.stored.metrics.pendingGenerationId === run.runId) {
+                        delete run.stored.metrics.pendingGenerationId;
+                    }
+                    run.stored.messages = run.stored.messages.filter((message) => message.runId !== run.runId);
+                    run.stored.stagedTerminals = run.stored.stagedTerminals.filter((entry) => entry.runId !== run.runId);
+                    run.stored.reversionSegments = run.stored.reversionSegments.filter((segment) => segment.runId !== run.runId);
+                    if (run.stored.pendingReversion?.kind === 'capture'
+                        && run.stored.pendingReversion.runId === run.runId)
+                        delete run.stored.pendingReversion;
+                }, true);
+            }
+            catch (error) {
+                errors.push(this.core.projectExternalError(run, error, 'persistence'));
+            }
+        }
+        if (run.state.sessions.get(run.sessionId) === run.stored && run.stored.session.activity.runId === run.runId) {
+            try {
+                await this.core.mutateScope(run.state, () => {
+                    run.stored.session.status = 'idle';
+                    run.stored.session.activity = { status: 'idle' };
+                    run.stored.session.updatedAt = new Date().toISOString();
+                }, true);
+            }
+            catch (error) {
+                errors.push(this.core.projectExternalError(run, error, 'persistence'));
+            }
+        }
+        if (errors.length > 0)
+            await this.core.lifecycle.fenceNamespace(run.state, run, combineErrors([originalError, ...errors]));
+        return errors;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.flexharness.runs.js","sourceRoot":"","sources":["../ts/classes.flexharness.runs.ts"],"names":[],"mappings":"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"}