@modelprofile.com/flexharness 10.24.0 → 10.24.1

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@modelprofile.com/flexharness',
-    version: '10.24.0',
+    version: '10.24.1',
     description: 'The FlexHarness toolbox source repository and shared dependency catalog.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSwrQkFBK0I7SUFDckMsT0FBTyxFQUFFLFNBQVM7SUFDbEIsV0FBVyxFQUFFLDBFQUEwRTtDQUN4RixDQUFBIn0=

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

@@ -0,0 +1,17 @@
+import type { IFlexSession, IFlexSubagentDefinition } from './interfaces.js';
+import type { IStoredSessionState, IStorageState, IActiveRun, IDelegatedRunAdmissionSeed, IDelegatedRunAdmissionOwner, IQueuedPrompt } from './interfaces.flexharness.js';
+import type { FlexHarnessCore } from './classes.flexharness.core.js';
+/** Admission of delegated runs through the delegated run admission provider. */
+export declare class FlexHarnessDelegatedRunAdmission<TScope> {
+    private readonly core;
+    constructor(core: FlexHarnessCore<TScope>);
+    assertDelegatedRunAdmissionOwnership(seed: IDelegatedRunAdmissionSeed, state: IStorageState, childStored: IStoredSessionState, scopeId: string): void;
+    acquireDelegatedRunAdmission(queued: IQueuedPrompt, run: IActiveRun): Promise<void>;
+    private normalizeDelegatedRunAdmissionLease;
+    private requestDelegatedRunAdmissionClose;
+    private startDelegatedRunAdmissionCloseAttempt;
+    closeRunDelegatedRunAdmission(run: IActiveRun, awaitSettlement?: boolean): Promise<void>;
+    createDelegatedRunAdmissionSeed(run: IActiveRun, child: IStoredSessionState, definition: Readonly<IFlexSubagentDefinition>, toolCallId: string): IDelegatedRunAdmissionSeed;
+    delegatedRunAdmissionOwnersForGeneration(state: IStorageState, session: Readonly<Pick<IFlexSession, 'sessionId' | 'sessionGenerationId' | 'sessionGenerationSequence'>>): IDelegatedRunAdmissionOwner[];
+    settleDelegatedRunAdmissionOwners(owners: readonly IDelegatedRunAdmissionOwner[]): Promise<Error[]>;
+}

package/dist_ts/classes.flexharness.admission.js

@@ -0,0 +1,263 @@
+import { FlexHarnessAbortError, FlexHarnessValidationError } from './errors.js';
+import { requireSessionGeneration } from './utils.flexharness.js';
+/** Admission of delegated runs through the delegated run admission provider. */
+export class FlexHarnessDelegatedRunAdmission {
+    core;
+    constructor(core) {
+        this.core = core;
+    }
+    assertDelegatedRunAdmissionOwnership(seed, state, childStored, scopeId) {
+        const child = childStored.session;
+        const parentRun = seed.parentRun;
+        const parent = seed.parentStored.session;
+        const parentPartId = parentRun.toolPartIds.get(seed.parentToolCallId);
+        const parentPart = parentRun.callbackParts.find((part) => part.type === 'tool'
+            && part.partId === parentPartId
+            && part.toolCallId === seed.parentToolCallId);
+        if (seed.state !== state
+            || seed.storageKey !== state.storageKey
+            || seed.scopeId !== scopeId
+            || seed.childStored !== childStored
+            || childStored.storageKey !== seed.storageKey
+            || state.sessions.get(seed.sessionId) !== childStored
+            || state.tombstones.has(seed.sessionId)
+            || state.initializingSessions.has(seed.sessionId)
+            || child.sessionId !== seed.sessionId
+            || child.sessionGenerationId !== seed.sessionGenerationId
+            || child.sessionGenerationSequence !== seed.sessionGenerationSequence
+            || child.parentSessionId !== seed.parentSessionId
+            || child.parentRunId !== seed.originParentRunId
+            || child.parentToolCallId !== seed.originParentToolCallId
+            || child.agent !== seed.agent
+            || child.depth !== seed.depth
+            || seed.parentStored !== parentRun.stored
+            || seed.parentStored.storageKey !== seed.storageKey
+            || parentRun.state !== state
+            || parentRun.scopeId !== seed.scopeId
+            || parentRun.scope !== seed.scope
+            || parentRun.sessionId !== seed.parentSessionId
+            || parentRun.queueId !== seed.parentQueueId
+            || parentRun.runId !== seed.parentRunId
+            || state.sessions.get(seed.parentSessionId) !== seed.parentStored
+            || state.tombstones.has(seed.parentSessionId)
+            || parent.sessionId !== seed.parentSessionId
+            || parent.sessionGenerationId !== seed.parentSessionGenerationId
+            || parent.sessionGenerationSequence !== seed.parentSessionGenerationSequence
+            || state.activeRuns.get(seed.parentSessionId) !== parentRun
+            || parentRun.callbacksClosed
+            || parentRun.controller.signal.aborted
+            || parentPart?.status !== 'running') {
+            throw this.core.trustInternalError(new FlexHarnessAbortError('The delegated prompt lost its exact parent or child ownership.'));
+        }
+    }
+    async acquireDelegatedRunAdmission(queued, run) {
+        const seed = queued.delegationSeed;
+        const provider = this.core.delegatedRunAdmissionProvider;
+        if (!seed || !provider)
+            return;
+        const context = Object.freeze({
+            scopeId: seed.scopeId,
+            scope: seed.scope,
+            storageKey: seed.storageKey,
+            sessionId: seed.sessionId,
+            sessionGenerationId: seed.sessionGenerationId,
+            sessionGenerationSequence: seed.sessionGenerationSequence,
+            queueId: queued.queueId,
+            runId: run.runId,
+            parentSessionId: seed.parentSessionId,
+            parentSessionGenerationId: seed.parentSessionGenerationId,
+            parentSessionGenerationSequence: seed.parentSessionGenerationSequence,
+            parentQueueId: seed.parentQueueId,
+            parentRunId: seed.parentRunId,
+            parentToolCallId: seed.parentToolCallId,
+            originParentRunId: seed.originParentRunId,
+            originParentToolCallId: seed.originParentToolCallId,
+            agent: seed.agent,
+            depth: seed.depth,
+            signal: run.controller.signal,
+        });
+        const owner = {
+            storageState: run.state,
+            run,
+            context,
+            status: 'acquiring',
+            acquisitionSettled: false,
+            acquisitionDetached: false,
+            closeAttemptSequence: 0,
+        };
+        run.state.delegatedRunAdmissionOwners.add(owner);
+        run.delegatedRunAdmissionOwner = owner;
+        const acquisition = Promise.resolve()
+            .then(() => provider.acquireDelegatedRunAdmission(context))
+            .then((lease) => this.normalizeDelegatedRunAdmissionLease(lease))
+            .then((lease) => {
+            owner.lease = lease;
+            owner.acquisitionSettled = true;
+            if (owner.status === 'acquiring')
+                owner.status = 'acquired';
+            if (owner.status === 'close-requested') {
+                void this.startDelegatedRunAdmissionCloseAttempt(owner).catch(() => undefined);
+            }
+        }, (error) => {
+            owner.acquisitionError = this.core.projectExternalError(run, error, 'delegatedRunAdmissionProvider');
+            owner.acquisitionSettled = true;
+            owner.status = 'closed';
+            run.state.delegatedRunAdmissionOwners.delete(owner);
+        });
+        owner.acquisitionCompletion = acquisition;
+        let resolveAbort;
+        const abort = new Promise((resolve) => {
+            resolveAbort = () => resolve('aborted');
+        });
+        run.controller.signal.addEventListener('abort', resolveAbort, { once: true });
+        if (run.controller.signal.aborted)
+            resolveAbort();
+        try {
+            const outcome = await Promise.race([
+                acquisition.then(() => 'settled'),
+                abort,
+            ]);
+            if (outcome === 'aborted') {
+                owner.acquisitionDetached = true;
+                throw run.controller.signal.reason ?? this.core.trustInternalError(new FlexHarnessAbortError());
+            }
+            if (run.controller.signal.aborted) {
+                throw run.controller.signal.reason ?? this.core.trustInternalError(new FlexHarnessAbortError());
+            }
+            if (owner.acquisitionError)
+                throw owner.acquisitionError;
+            if (owner.status !== 'acquired' || !owner.lease) {
+                throw this.core.trustInternalError(new FlexHarnessAbortError('The delegated run admission was retired during acquisition.'));
+            }
+        }
+        finally {
+            run.controller.signal.removeEventListener('abort', resolveAbort);
+        }
+    }
+    normalizeDelegatedRunAdmissionLease(value) {
+        if (!value || (typeof value !== 'object' && typeof value !== 'function')) {
+            throw new FlexHarnessValidationError('Delegated run admission provider returned an invalid lease.');
+        }
+        const close = value.close;
+        if (typeof close !== 'function') {
+            throw new FlexHarnessValidationError('Delegated run admission provider returned an invalid lease.');
+        }
+        return Object.freeze({ close: () => close.call(value) });
+    }
+    requestDelegatedRunAdmissionClose(owner) {
+        const priorAttemptSequence = owner.closeAttemptSequence;
+        const joinedAttempt = owner.closeAttempt;
+        if (owner.status === 'closed')
+            return Promise.resolve();
+        if (owner.status !== 'retrying')
+            owner.status = 'close-requested';
+        return (async () => {
+            await owner.acquisitionCompletion;
+            if (owner.status === 'closed')
+                return;
+            if (joinedAttempt) {
+                await joinedAttempt;
+                return;
+            }
+            if (owner.closeAttempt) {
+                await owner.closeAttempt;
+                return;
+            }
+            if (owner.closeFailure && owner.closeFailure.sequence > priorAttemptSequence) {
+                throw owner.closeFailure.error;
+            }
+            await this.startDelegatedRunAdmissionCloseAttempt(owner);
+        })();
+    }
+    startDelegatedRunAdmissionCloseAttempt(owner) {
+        if (owner.closeAttempt)
+            return owner.closeAttempt;
+        if (!owner.lease) {
+            throw new Error('Acquired delegated run admission has no lease.');
+        }
+        owner.status = 'retrying';
+        owner.closeFailure = undefined;
+        const sequence = ++owner.closeAttemptSequence;
+        let attempt;
+        attempt = Promise.resolve()
+            .then(() => owner.lease.close())
+            .then(() => {
+            owner.status = 'closed';
+            delete owner.lease;
+            owner.storageState.delegatedRunAdmissionOwners.delete(owner);
+        }, (error) => {
+            const projected = this.core.projectExternalError(owner.run, error, 'delegatedRunAdmissionProvider');
+            owner.closeFailure = { sequence, error: projected };
+            owner.status = 'close-requested';
+            throw projected;
+        })
+            .finally(() => {
+            if (owner.closeAttempt === attempt)
+                owner.closeAttempt = undefined;
+        });
+        owner.closeAttempt = attempt;
+        return attempt;
+    }
+    async closeRunDelegatedRunAdmission(run, awaitSettlement = true) {
+        const owner = run.delegatedRunAdmissionOwner;
+        if (!owner)
+            return;
+        if (!run.delegatedRunAdmissionClose) {
+            run.delegatedRunAdmissionClose = this.requestDelegatedRunAdmissionClose(owner);
+            void run.delegatedRunAdmissionClose.catch(() => undefined);
+        }
+        if (awaitSettlement)
+            await run.delegatedRunAdmissionClose;
+    }
+    createDelegatedRunAdmissionSeed(run, child, definition, toolCallId) {
+        const childGeneration = requireSessionGeneration(child.session);
+        const parentGeneration = requireSessionGeneration(run.stored.session);
+        if (!child.session.parentRunId || !child.session.parentToolCallId) {
+            throw new FlexHarnessValidationError('Subagent session origin metadata is missing.');
+        }
+        const seed = Object.freeze({
+            state: run.state,
+            childStored: child,
+            parentRun: run,
+            parentStored: run.stored,
+            scopeId: run.scopeId,
+            scope: run.scope,
+            storageKey: run.state.storageKey,
+            sessionId: child.session.sessionId,
+            ...childGeneration,
+            originParentRunId: child.session.parentRunId,
+            originParentToolCallId: child.session.parentToolCallId,
+            parentSessionId: run.sessionId,
+            parentSessionGenerationId: parentGeneration.sessionGenerationId,
+            parentSessionGenerationSequence: parentGeneration.sessionGenerationSequence,
+            parentQueueId: run.queueId,
+            parentRunId: run.runId,
+            parentToolCallId: toolCallId,
+            ...(run.stored.session.configurationRef === undefined
+                ? {}
+                : { configurationRef: run.stored.session.configurationRef }),
+            agent: definition.name,
+            depth: (run.stored.session.depth ?? 0) + 1,
+        });
+        this.assertDelegatedRunAdmissionOwnership(seed, run.state, child, run.scopeId);
+        return seed;
+    }
+    delegatedRunAdmissionOwnersForGeneration(state, session) {
+        return [...state.delegatedRunAdmissionOwners].filter((owner) => owner.storageState === state
+            && owner.context.sessionId === session.sessionId
+            && owner.context.sessionGenerationId === session.sessionGenerationId
+            && owner.context.sessionGenerationSequence === session.sessionGenerationSequence);
+    }
+    async settleDelegatedRunAdmissionOwners(owners) {
+        const results = await Promise.allSettled(owners.map((owner) => this.requestDelegatedRunAdmissionClose(owner)));
+        return results.flatMap((result, index) => {
+            if (result.status === 'fulfilled')
+                return [];
+            const error = result.reason instanceof Error
+                ? result.reason
+                : this.core.projectExternalError(owners[index].run, result.reason, 'delegatedRunAdmissionProvider');
+            return [error];
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.flexharness.admission.js","sourceRoot":"","sources":["../ts/classes.flexharness.admission.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,38 @@
+import * as plugins from './plugins.js';
+import { type TFlexAgentToolCallUpdateEvent, type TFlexAgentToolCallFinishEvent } from './interfaces.js';
+import { type ISessionMetricsOperation } from './utils.sessionmetrics.js';
+import type { IStoredSessionState, IStorageState, IActiveRun } from './interfaces.flexharness.js';
+import type { FlexHarnessCore } from './classes.flexharness.core.js';
+/** The model stream callbacks of a run: text, reasoning, tool, retry and usage events. */
+export declare class FlexHarnessRunCallbacks<TScope> {
+    private readonly core;
+    constructor(core: FlexHarnessCore<TScope>);
+    onTextDelta(state: IStorageState, sessionId: string, delta: string): void;
+    onReasoningStart(state: IStorageState, sessionId: string, id: string): void;
+    onReasoningDelta(state: IStorageState, sessionId: string, id: string, delta: string): void;
+    onReasoningEnd(state: IStorageState, sessionId: string, id: string, text: string): void;
+    private textAppendAccounting;
+    onToolStart(state: IStorageState, sessionId: string, event: {
+        toolCallId: string;
+        toolName: string;
+        input: unknown;
+        parentToolCallId?: string;
+    }): void;
+    onToolFinish(state: IStorageState, sessionId: string, event: TFlexAgentToolCallFinishEvent): void;
+    onToolUpdate(state: IStorageState, sessionId: string, event: TFlexAgentToolCallUpdateEvent): void;
+    onRetry(state: IStorageState, sessionId: string, retry: plugins.IAgentRetryEvent): void;
+    /**
+     * 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: IStorageState, stored: IStoredSessionState, event: plugins.TAgentModelCallUsageEvent): void;
+    settleMetricsOperation(state: IStorageState, stored: IStoredSessionState, operation: ISessionMetricsOperation): Promise<void>;
+    private callbackRun;
+    reserveCallbackCapacity(run: IActiveRun, eventCount: number, outputBytes: number, partCount: number): boolean;
+    private failCallback;
+}