@modelprofile.com/flexharness 10.23.0 → 10.24.1

package/dist_ts/classes.flexharness.callbacks.js

@@ -0,0 +1,313 @@
+import * as plugins from './plugins.js';
+import { FlexHarnessCallbackOverflowError } from './errors.js';
+import { FLEX_TOOL_CATALOG_TOOL_NAMES, } from './interfaces.js';
+import { normalizeJsonValue } from './utils.json.js';
+import { jsonBytes } from './utils.transfer.js';
+import { observeSessionMetricsCall, settleSessionMetricsOperation, } from './utils.sessionmetrics.js';
+/** The model stream callbacks of a run: text, reasoning, tool, retry and usage events. */
+export class FlexHarnessRunCallbacks {
+    core;
+    constructor(core) {
+        this.core = core;
+    }
+    onTextDelta(state, sessionId, delta) {
+        const run = this.callbackRun(state, sessionId);
+        if (!run || !delta)
+            return;
+        const lastPart = run.callbackParts.at(-1);
+        const created = lastPart?.type !== 'text';
+        const part = lastPart?.type === 'text'
+            ? lastPart
+            : { partId: plugins.crypto.randomUUID(), type: 'text', text: '' };
+        const accounting = this.textAppendAccounting(run, part, delta, created);
+        if (!accounting)
+            return;
+        if (!this.reserveCallbackCapacity(run, created ? 2 : 1, accounting.textUtf8Bytes - accounting.baseTextUtf8Bytes, created ? 1 : 0))
+            return;
+        if (created) {
+            run.callbackParts.push(part);
+            run.partTextUtf8Bytes.set(part.partId, 0);
+            this.core.emitPartEvent(run, 'part.started', part);
+        }
+        part.text += delta;
+        run.partTextUtf8Bytes.set(part.partId, accounting.textUtf8Bytes);
+        this.core.emitPartDeltaEvent(run, part, delta, accounting);
+    }
+    onReasoningStart(state, sessionId, id) {
+        const run = this.callbackRun(state, sessionId);
+        if (!run || run.reasoningPartIds.has(id))
+            return;
+        if (!this.reserveCallbackCapacity(run, 1, 0, 1))
+            return;
+        const part = {
+            partId: plugins.crypto.randomUUID(),
+            type: 'reasoning',
+            text: '',
+            status: 'running',
+            startedAt: new Date().toISOString(),
+        };
+        run.reasoningPartIds.set(id, part.partId);
+        run.callbackParts.push(part);
+        run.partTextUtf8Bytes.set(part.partId, 0);
+        this.core.emitPartEvent(run, 'part.started', part);
+    }
+    onReasoningDelta(state, sessionId, id, delta) {
+        const run = this.callbackRun(state, sessionId);
+        if (!run || !delta)
+            return;
+        if (!run.reasoningPartIds.has(id))
+            this.onReasoningStart(state, sessionId, id);
+        const partId = run.reasoningPartIds.get(id);
+        const part = run.callbackParts.find((entry) => entry.partId === partId && entry.type === 'reasoning');
+        if (!part || part.type !== 'reasoning' || part.status !== 'running')
+            return;
+        const accounting = this.textAppendAccounting(run, part, delta);
+        if (!accounting)
+            return;
+        if (!this.reserveCallbackCapacity(run, 1, accounting.textUtf8Bytes - accounting.baseTextUtf8Bytes, 0))
+            return;
+        part.text += delta;
+        run.partTextUtf8Bytes.set(part.partId, accounting.textUtf8Bytes);
+        this.core.emitPartDeltaEvent(run, part, delta, accounting);
+    }
+    onReasoningEnd(state, sessionId, id, text) {
+        const run = this.callbackRun(state, sessionId);
+        if (!run)
+            return;
+        if (!run.reasoningPartIds.has(id))
+            this.onReasoningStart(state, sessionId, id);
+        const partId = run.reasoningPartIds.get(id);
+        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 ? '' : text;
+        const missingTextUtf8Bytes = Buffer.byteLength(missingText, 'utf8');
+        if (!this.reserveCallbackCapacity(run, 1, missingTextUtf8Bytes, 0))
+            return;
+        if (missingText) {
+            part.text = missingText;
+            run.partTextUtf8Bytes.set(part.partId, missingTextUtf8Bytes);
+        }
+        part.status = 'completed';
+        part.completedAt = new Date().toISOString();
+        this.core.emitPartEvent(run, 'part.completed', part);
+    }
+    textAppendAccounting(run, part, delta, created = false) {
+        const baseTextUtf8Bytes = created ? 0 : run.partTextUtf8Bytes.get(part.partId);
+        if (baseTextUtf8Bytes === undefined) {
+            throw new Error('Flex part text byte accounting is unavailable.');
+        }
+        const trailingCodeUnit = part.text.charCodeAt(part.text.length - 1);
+        const leadingCodeUnit = delta.charCodeAt(0);
+        const joinsSurrogatePair = trailingCodeUnit >= 0xD800
+            && trailingCodeUnit <= 0xDBFF
+            && leadingCodeUnit >= 0xDC00
+            && leadingCodeUnit <= 0xDFFF;
+        const textUtf8Bytes = baseTextUtf8Bytes
+            + Buffer.byteLength(delta, 'utf8')
+            - (joinsSurrogatePair ? 2 : 0);
+        if (!Number.isSafeInteger(textUtf8Bytes)) {
+            this.failCallback(run, this.core.trustInternalError(new FlexHarnessCallbackOverflowError('Callback text byte accounting exceeded the safe integer range.')));
+            return undefined;
+        }
+        return { baseTextUtf8Bytes, textUtf8Bytes };
+    }
+    onToolStart(state, sessionId, event) {
+        const run = this.callbackRun(state, sessionId);
+        if (!run || run.toolPartIds.has(event.toolCallId))
+            return;
+        try {
+            // An execute call is the call of the catalog method it names.
+            const target = event.toolName === FLEX_TOOL_CATALOG_TOOL_NAMES.execute
+                ? run.toolCatalog?.callTarget(event.input)
+                : undefined;
+            const input = normalizeJsonValue(target ? target.params : event.input, this.core.toolOutputLimits);
+            if (!this.reserveCallbackCapacity(run, 1, jsonBytes(input), 1))
+                return;
+            const part = {
+                partId: plugins.crypto.randomUUID(),
+                type: 'tool',
+                toolCallId: this.core.boundedIdentifier(event.toolCallId, 'toolCallId'),
+                toolName: this.core.boundedIdentifier(target ? target.method : event.toolName, 'toolName'),
+                status: 'running',
+                input,
+                ...(event.parentToolCallId === undefined
+                    ? {}
+                    : { parentToolCallId: this.core.boundedIdentifier(event.parentToolCallId, 'parentToolCallId') }),
+                startedAt: new Date().toISOString(),
+            };
+            run.toolPartIds.set(event.toolCallId, part.partId);
+            run.callbackParts.push(part);
+            this.core.emitPartEvent(run, 'part.started', part);
+        }
+        catch (error) {
+            this.failCallback(run, this.core.projectExternalError(run, error, 'toolCallback'));
+        }
+    }
+    onToolFinish(state, sessionId, event) {
+        const run = this.callbackRun(state, sessionId);
+        if (!run)
+            return;
+        if (!run.toolPartIds.has(event.toolCallId))
+            this.onToolStart(state, sessionId, event);
+        const partId = run.toolPartIds.get(event.toolCallId);
+        const part = run.callbackParts.find((entry) => entry.partId === partId && entry.type === 'tool');
+        if (!part || part.type !== 'tool' || part.status !== 'running')
+            return;
+        try {
+            const trustedExecutionError = run.trustedToolExecutionErrors.get(event.toolCallId);
+            run.trustedToolExecutionErrors.delete(event.toolCallId);
+            const output = event.success ? normalizeJsonValue(event.output, this.core.toolOutputLimits) : undefined;
+            const projectedError = event.success
+                ? undefined
+                : this.core.projectExternalError(run, trustedExecutionError ?? event.error, 'toolCallback');
+            const bytes = event.success ? jsonBytes(output) : Buffer.byteLength(projectedError.message);
+            if (!this.reserveCallbackCapacity(run, 1, bytes - (part.output === undefined ? 0 : jsonBytes(part.output)), 0))
+                return;
+            if (event.success) {
+                part.status = 'completed';
+                part.output = output;
+            }
+            else {
+                part.status = 'failed';
+                delete part.output;
+                part.error = projectedError.message;
+            }
+            const original = run.deduplicatedToolCalls.get(event.toolCallId);
+            if (original !== undefined) {
+                part.deduplicatedFrom = this.core.boundedIdentifier(original, 'deduplicatedFrom');
+            }
+            part.completedAt = new Date().toISOString();
+            this.core.emitPartEvent(run, 'part.completed', part);
+        }
+        catch (error) {
+            this.failCallback(run, this.core.projectExternalError(run, error, 'toolCallback'));
+        }
+    }
+    onToolUpdate(state, sessionId, event) {
+        let run = this.callbackRun(state, sessionId);
+        if (!run)
+            return;
+        if (!run.toolPartIds.has(event.toolCallId)) {
+            this.onToolStart(state, sessionId, event);
+            run = this.callbackRun(state, sessionId);
+            if (!run)
+                return;
+        }
+        const partId = run.toolPartIds.get(event.toolCallId);
+        const part = run.callbackParts.find((entry) => entry.partId === partId && entry.type === 'tool');
+        if (!part || part.type !== 'tool' || part.status !== 'running')
+            return;
+        try {
+            const output = normalizeJsonValue(event.output, this.core.toolOutputLimits);
+            if (!this.reserveCallbackCapacity(run, 1, jsonBytes(output) - (part.output === undefined ? 0 : jsonBytes(part.output)), 0))
+                return;
+            part.output = output;
+            this.core.emitPartEvent(run, 'part.updated', part);
+        }
+        catch (error) {
+            this.failCallback(run, this.core.projectExternalError(run, error, 'toolCallback'));
+        }
+    }
+    onRetry(state, sessionId, retry) {
+        const run = this.callbackRun(state, sessionId);
+        if (!run || !this.reserveCallbackCapacity(run, 1, 0, 0))
+            return;
+        this.core.emitEvent(run.scopeId, run.stored.session, {
+            type: 'run.retrying',
+            runId: run.runId,
+            attempt: retry.attempt,
+            maxAttempts: retry.maxAttempts,
+            delayMs: retry.delayMs,
+            reason: retry.reason,
+        });
+    }
+    /**
+     * Emits the usage of every model call and adds reported usage to its run. A run executes a
+     * transactional generation, and `AgentSession.generate()` settles a transactional generation only
+     * after it has reported each of its model calls, also when it is aborted. `executeRun()` awaits
+     * that settlement before it builds the terminal, so the run is still active for each of its
+     * events: they all reach `run.usage` and precede its `run.finished`. The events bypass the
+     * callback limits and a failed callback: their number is bounded by the run's model calls, and
+     * the usage of a run that exhausted its callback budget or failed in a callback must not be lost.
+     */
+    onModelCallUsage(state, stored, event) {
+        try {
+            const { source, generationId, ...call } = event;
+            const sessionId = stored.session.sessionId;
+            const activeRun = state.activeRuns.get(sessionId);
+            const run = generationId !== undefined && activeRun?.runId === generationId ? activeRun : undefined;
+            const operation = source === 'compaction' ? stored.metricsCompaction : run?.metricsOperation;
+            if (!operation)
+                throw new Error('Model call usage has no owning metrics operation.');
+            observeSessionMetricsCall(operation, call);
+            let scopeId = run?.scopeId;
+            if (scopeId === undefined) {
+                const ambientContext = this.core.compaction.compactorInvocationContext.getStore();
+                const invocationContext = ambientContext
+                    ? this.core.compaction.deferredCompactorContexts.get(ambientContext) ?? ambientContext
+                    : undefined;
+                if (!invocationContext
+                    || invocationContext.storageKey !== state.storageKey
+                    || invocationContext.sessionId !== sessionId) {
+                    throw new Error('Model call usage is missing its exact FlexHarness invocation context.');
+                }
+                scopeId = invocationContext.scopeId;
+            }
+            if (run && call.status === 'reported') {
+                for (const key of Object.keys(run.usage))
+                    run.usage[key] += call.usage[key];
+            }
+            this.core.emitEvent(scopeId, stored.session, {
+                type: 'model.usage',
+                ...(generationId === undefined ? {} : { runId: generationId }),
+                source,
+                ...call,
+            });
+        }
+        catch (error) {
+            // AgentSession isolates the entire callback, including event/context failures. Join it later.
+            stored.metricsFailure ??= error;
+            throw error;
+        }
+    }
+    async settleMetricsOperation(state, stored, operation) {
+        try {
+            if (stored.metricsFailure !== undefined)
+                throw stored.metricsFailure;
+            await this.core.mutateProjection(state, stored, () => settleSessionMetricsOperation(stored.metrics, operation), true);
+        }
+        catch (error) {
+            stored.metricsFailure ??= error;
+            // Never allow a later operation to overwrite a marker whose spend was not durably joined.
+            state.lifecycle = 'fenced';
+            throw error;
+        }
+    }
+    callbackRun(state, sessionId) {
+        const run = state.activeRuns.get(sessionId);
+        return !run || run.callbacksClosed || run.callbackError ? undefined : run;
+    }
+    reserveCallbackCapacity(run, eventCount, outputBytes, partCount) {
+        const nextEvents = run.callbackEventCount + eventCount;
+        const nextOutputBytes = run.callbackOutputBytes + outputBytes;
+        const nextParts = run.callbackParts.length + partCount;
+        if (!Number.isSafeInteger(nextEvents)
+            || !Number.isSafeInteger(nextOutputBytes)
+            || !Number.isSafeInteger(nextParts)
+            || nextEvents > this.core.callbackLimits.maxEvents
+            || nextOutputBytes > this.core.callbackLimits.maxOutputBytes
+            || nextParts > this.core.callbackLimits.maxParts) {
+            this.failCallback(run, this.core.trustInternalError(new FlexHarnessCallbackOverflowError(`Callback buffer exceeded its limit (${nextEvents} events, ${nextOutputBytes} bytes, ${nextParts} parts).`)));
+            return false;
+        }
+        run.callbackEventCount = nextEvents;
+        run.callbackOutputBytes = nextOutputBytes;
+        return true;
+    }
+    failCallback(run, error) {
+        run.callbackError ??= error;
+        this.core.runs.abortRunInternally(run, error);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.flexharness.callbacks.js","sourceRoot":"","sources":["../ts/classes.flexharness.callbacks.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,25 @@
+import * as plugins from './plugins.js';
+import { FlexHarnessAbortError } from './errors.js';
+import type { IFlexAgentContextCompactionOptions, IFlexAgentContextInvocation, IFlexCompactSessionOptions } from './interfaces.js';
+import type { ICompactorInvocation, IStoredSessionState, IStorageState, IActiveRun } from './interfaces.flexharness.js';
+import type { FlexHarnessCore } from './classes.flexharness.core.js';
+/** Compaction hooks: compactor contexts and session compaction. */
+export declare class FlexHarnessCompaction<TScope> {
+    private readonly core;
+    readonly compactorInvocationContext: plugins.AsyncLocalStorage<ICompactorInvocation<TScope>>;
+    readonly deferredCompactorContexts: WeakMap<IFlexAgentContextInvocation<unknown>, IFlexAgentContextInvocation<unknown>>;
+    constructor(core: FlexHarnessCore<TScope>);
+    compactSession(scopeId: string, sessionId: string, options?: IFlexCompactSessionOptions): Promise<void>;
+    compactStoredSession(scopeId: string, scope: TScope, state: IStorageState, stored: IStoredSessionState, modelHint: string | undefined, signal?: AbortSignal): Promise<void>;
+    abortCompactorLifecycle(stored: IStoredSessionState, reason: FlexHarnessAbortError): void;
+    createCompactorContext(scopeId: string, scope: TScope, storageKey: string, sessionId: string, modelHint?: string): ICompactorInvocation<TScope>;
+    /**
+     * The model the compacted work was dispatched on: the resolved model of the run whose context
+     * overflowed, or the model hint a manual compaction was requested with. Retention states none.
+     */
+    compactionModel(state: IStorageState, sessionId: string, ambientContext: IFlexAgentContextInvocation<TScope>, reason: IFlexAgentContextCompactionOptions['reason'], modelHint: string | undefined): Pick<IFlexAgentContextCompactionOptions<TScope>, 'resolvedModel' | 'modelHint'>;
+    withCompactorContext<TResult>(context: IFlexAgentContextInvocation<unknown>, operation: () => TResult): TResult;
+    createRunCompactorContext(run: IActiveRun): IFlexAgentContextInvocation<TScope>;
+    effectiveRunCompactorContext(run: IActiveRun): IFlexAgentContextInvocation<TScope>;
+    withRunCompactorContext<TResult>(run: IActiveRun, operation: () => TResult): TResult;
+}

package/dist_ts/classes.flexharness.compaction.js

@@ -0,0 +1,87 @@
+import * as plugins from './plugins.js';
+import { FlexHarnessAbortError, FlexHarnessSlashCommandReentryError, FlexHarnessSlashCommandUnavailableError, } from './errors.js';
+import { validateCompactSessionOptions } from './utils.validation.js';
+/** Compaction hooks: compactor contexts and session compaction. */
+export class FlexHarnessCompaction {
+    core;
+    compactorInvocationContext = new plugins.AsyncLocalStorage();
+    deferredCompactorContexts = new WeakMap();
+    constructor(core) {
+        this.core = core;
+    }
+    async compactSession(scopeId, sessionId, options = {}) {
+        const { modelHint } = validateCompactSessionOptions(options);
+        const { scope, state } = await this.core.resolveState(scopeId);
+        const stored = this.core.requireSession(state, sessionId);
+        this.core.assertSessionWritable(stored);
+        const invocationOwner = this.core.commands.slashCommandInvocationContext.getStore();
+        if (invocationOwner?.sessionKey === this.core.commands.slashCommandSessionKey(state.storageKey, sessionId)) {
+            throw this.core.trustInternalError(new FlexHarnessSlashCommandReentryError(sessionId));
+        }
+        this.core.assertStateAcceptingWork(state);
+        if (!this.core.agentSessionPolicy.contextCompactor) {
+            throw new FlexHarnessSlashCommandUnavailableError('compact', 'No context compactor is configured.');
+        }
+        this.core.commands.requireSessionAvailableForSlashCommand(state, stored, 'compact');
+        await this.core.commands.trackSlashCommandExecution(scopeId, state, sessionId, 'operation', undefined, async (signal) => {
+            await this.core.reversions.commitRevertedBranch(state, stored, scopeId, scope.scope);
+            await this.compactStoredSession(scopeId, scope.scope, state, stored, modelHint, signal);
+        });
+    }
+    async compactStoredSession(scopeId, scope, state, stored, modelHint, signal) {
+        try {
+            await this.withCompactorContext(this.createCompactorContext(scopeId, scope, state.storageKey, stored.session.sessionId, modelHint), () => stored.agentSession.compact(signal === undefined ? {} : { abort: signal }));
+        }
+        catch (error) {
+            throw this.core.projectOperationError(error, 'agentSession', scopeId, stored.session.sessionId, 'compaction');
+        }
+    }
+    abortCompactorLifecycle(stored, reason) {
+        if (!stored.compactorLifecycleController.signal.aborted) {
+            stored.compactorLifecycleController.abort(reason);
+        }
+    }
+    createCompactorContext(scopeId, scope, storageKey, sessionId, modelHint) {
+        return Object.freeze({
+            scopeId,
+            scope,
+            storageKey,
+            sessionId,
+            ...(modelHint === undefined ? {} : { modelHint }),
+        });
+    }
+    /**
+     * The model the compacted work was dispatched on: the resolved model of the run whose context
+     * overflowed, or the model hint a manual compaction was requested with. Retention states none.
+     */
+    compactionModel(state, sessionId, ambientContext, reason, modelHint) {
+        if (reason === 'manual')
+            return modelHint === undefined ? {} : { modelHint };
+        if (reason !== 'context-overflow' && reason !== 'context-budget')
+            return {};
+        const run = state.activeRuns.get(sessionId);
+        if (!run
+            || (ambientContext !== run.originCompactorContext && ambientContext !== run.deferredCompactorContext)) {
+            throw new Error('Context-overflow compaction is missing its exact FlexHarness run.');
+        }
+        const resolved = run.modelResolution;
+        if (!resolved)
+            throw new Error('Context-overflow compaction ran before its run resolved a model.');
+        return {
+            resolvedModel: Object.freeze({ ...resolved, identity: Object.freeze({ ...resolved.identity }) }),
+        };
+    }
+    withCompactorContext(context, operation) {
+        return this.compactorInvocationContext.run(context, operation);
+    }
+    createRunCompactorContext(run) {
+        return run.originCompactorContext;
+    }
+    effectiveRunCompactorContext(run) {
+        return (run.deferredCompactorContext ?? run.originCompactorContext);
+    }
+    withRunCompactorContext(run, operation) {
+        return this.withCompactorContext(this.effectiveRunCompactorContext(run), operation);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,11 @@
+import { FlexHarnessAbortError } from './errors.js';
+import type { IStoredSessionState, IStorageState, IResolvedSessionConfiguration, ISessionConfigurationOwner } from './interfaces.flexharness.js';
+import type { FlexHarnessCore } from './classes.flexharness.core.js';
+/** Session configurations from the session configuration resolver, and their owners. */
+export declare class FlexHarnessSessionConfigurations<TScope> {
+    private readonly core;
+    readonly sessionConfigurations: Map<string, ISessionConfigurationOwner<TScope>>;
+    constructor(core: FlexHarnessCore<TScope>);
+    resolveSessionConfiguration(scopeId: string, scope: TScope, state: IStorageState, stored: IStoredSessionState, signal?: AbortSignal): Promise<IResolvedSessionConfiguration<TScope>>;
+    abortSessionConfigurations(storageKey: string, reason: FlexHarnessAbortError, sessionIds?: ReadonlySet<string>): Promise<void> | undefined;
+}

package/dist_ts/classes.flexharness.configurations.js

@@ -0,0 +1,137 @@
+import { FlexHarnessAbortError, FlexHarnessValidationError } from './errors.js';
+import { normalizeAllowedTools, normalizeSlashCommands, normalizeSubagents, } from './utils.harnessoptions.js';
+import { requireSessionGeneration } from './utils.flexharness.js';
+/** Session configurations from the session configuration resolver, and their owners. */
+export class FlexHarnessSessionConfigurations {
+    core;
+    sessionConfigurations = new Map();
+    constructor(core) {
+        this.core = core;
+    }
+    async resolveSessionConfiguration(scopeId, scope, state, stored, signal) {
+        const configurationRef = stored.session.configurationRef;
+        if (configurationRef === undefined) {
+            return { subagents: this.core.subagents, slashCommands: this.core.slashCommands };
+        }
+        const sessionId = stored.session.sessionId;
+        const generation = requireSessionGeneration(stored.session);
+        const key = JSON.stringify([
+            state.storageKey,
+            sessionId,
+            generation.sessionGenerationId,
+            generation.sessionGenerationSequence,
+            configurationRef,
+        ]);
+        let owner = this.sessionConfigurations.get(key);
+        if (!owner) {
+            const controller = new AbortController();
+            const parent = stored.session.parentSessionId === undefined
+                ? undefined
+                : state.sessions.get(stored.session.parentSessionId);
+            if (stored.session.parentSessionId !== undefined && !parent) {
+                throw this.core.trustInternalError(new FlexHarnessAbortError('The session parent is no longer available.'));
+            }
+            const parentGeneration = parent === undefined ? undefined : requireSessionGeneration(parent.session);
+            const context = Object.freeze({
+                scopeId,
+                scope,
+                storageKey: state.storageKey,
+                sessionId,
+                ...generation,
+                configurationRef,
+                ...(parent === undefined ? {} : {
+                    parentSessionId: parent.session.sessionId,
+                    parentSessionGenerationId: parentGeneration.sessionGenerationId,
+                    parentSessionGenerationSequence: parentGeneration.sessionGenerationSequence,
+                }),
+                ...(stored.session.agent === undefined ? {} : { agent: stored.session.agent }),
+                depth: stored.session.depth ?? 0,
+                signal: controller.signal,
+            });
+            let rejectAbort;
+            const aborted = new Promise((_resolve, reject) => { rejectAbort = reject; });
+            const onAbort = () => rejectAbort(controller.signal.reason);
+            controller.signal.addEventListener('abort', onAbort, { once: true });
+            const resolved = Promise.resolve().then(() => {
+                if (!this.core.sessionConfigurationResolver) {
+                    throw new Error('A sessionConfigurationResolver is required for bound sessions.');
+                }
+                return this.core.sessionConfigurationResolver.resolveSessionConfiguration(context);
+            });
+            const completion = Promise.race([resolved, aborted]).then((configuration) => {
+                controller.signal.throwIfAborted();
+                if (state.lifecycle !== 'active'
+                    || state.sessions.get(sessionId) !== stored
+                    || stored.session.configurationRef !== configurationRef
+                    || stored.session.sessionGenerationId !== generation.sessionGenerationId
+                    || stored.session.sessionGenerationSequence !== generation.sessionGenerationSequence) {
+                    throw this.core.trustInternalError(new FlexHarnessAbortError('The session configuration lost its session generation ownership.'));
+                }
+                if (!configuration
+                    || typeof configuration !== 'object'
+                    || Array.isArray(configuration)
+                    || ![Object.prototype, null].includes(Object.getPrototypeOf(configuration))
+                    || Reflect.ownKeys(configuration).some((name) => typeof name !== 'string' || !['subagents', 'slashCommands', 'allowedTools', 'permissionPolicy'].includes(name)))
+                    throw new FlexHarnessValidationError('Resolved session configuration is invalid.');
+                if (configuration.permissionPolicy !== undefined && typeof configuration.permissionPolicy !== 'function') {
+                    throw new FlexHarnessValidationError('Resolved session permissionPolicy must be a function.');
+                }
+                return Object.freeze({
+                    subagents: normalizeSubagents(configuration.subagents),
+                    slashCommands: normalizeSlashCommands(configuration.slashCommands),
+                    allowedTools: normalizeAllowedTools(configuration.allowedTools),
+                    permissionPolicy: configuration.permissionPolicy,
+                });
+            }).catch((error) => {
+                if (this.sessionConfigurations.get(key)?.completion === completion) {
+                    this.sessionConfigurations.delete(key);
+                }
+                if (controller.signal.aborted)
+                    throw controller.signal.reason;
+                throw this.core.projectOperationError(error, 'sessionConfigurationResolver', scopeId, sessionId, 'session-configuration');
+            }).finally(() => {
+                controller.signal.removeEventListener('abort', onAbort);
+                const current = this.sessionConfigurations.get(key);
+                if (current?.completion === completion)
+                    current.settled = true;
+            });
+            owner = { storageKey: state.storageKey, sessionId, controller, completion, settled: false, waiters: 0 };
+            this.sessionConfigurations.set(key, owner);
+        }
+        owner.waiters++;
+        let onConsumerAbort;
+        const consumerAbort = signal && new Promise((_resolve, reject) => {
+            onConsumerAbort = () => reject(signal.reason ?? this.core.trustInternalError(new FlexHarnessAbortError('Session configuration resolution was aborted.')));
+            signal.addEventListener('abort', onConsumerAbort, { once: true });
+            if (signal.aborted)
+                onConsumerAbort();
+        });
+        try {
+            return await (consumerAbort
+                ? Promise.race([owner.completion, consumerAbort])
+                : owner.completion);
+        }
+        finally {
+            if (signal && onConsumerAbort)
+                signal.removeEventListener('abort', onConsumerAbort);
+            owner.waiters--;
+            if (owner.waiters === 0 && !owner.settled && !owner.controller.signal.aborted) {
+                if (this.sessionConfigurations.get(key) === owner)
+                    this.sessionConfigurations.delete(key);
+                owner.controller.abort(this.core.trustInternalError(new FlexHarnessAbortError('Session configuration resolution has no active callers.')));
+            }
+        }
+    }
+    abortSessionConfigurations(storageKey, reason, sessionIds) {
+        const owners = [...this.sessionConfigurations.entries()].filter(([, owner]) => owner.storageKey === storageKey && (sessionIds === undefined || sessionIds.has(owner.sessionId)));
+        if (owners.length === 0)
+            return undefined;
+        for (const [key, owner] of owners) {
+            this.sessionConfigurations.delete(key);
+            if (!owner.controller.signal.aborted)
+                owner.controller.abort(reason);
+        }
+        return Promise.allSettled(owners.map(([, owner]) => owner.completion)).then(() => undefined);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.flexharness.configurations.js","sourceRoot":"","sources":["../ts/classes.flexharness.configurations.ts"],"names":[],"mappings":"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"}