@modelprofile.com/flexharness 10.24.0 → 10.24.1

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

@@ -0,0 +1,18 @@
+import type { IFlexToolHandle, IFlexToolProviderContext } from './interfaces.js';
+import type { IStorageState, IActiveRun, IResolverOutcome } from './interfaces.flexharness.js';
+import type { FlexHarnessCore } from './classes.flexharness.core.js';
+/** Tool provider plumbing: run tool handles, resource tool providers and detached cleanups. */
+export declare class FlexHarnessToolProviders<TScope> {
+    private readonly core;
+    constructor(core: FlexHarnessCore<TScope>);
+    normalizeToolHandle(run: IActiveRun, handle: IFlexToolHandle | undefined): IFlexToolHandle | undefined;
+    provideRunToolHandle(run: IActiveRun, context: Readonly<IFlexToolProviderContext<TScope>>): Promise<IFlexToolHandle | undefined>;
+    private normalizeResourceToolProviderDescriptors;
+    closePartialToolHandle(handle: IFlexToolHandle, run: IActiveRun): Promise<void>;
+    private retainDetachedCleanup;
+    observeDetachedToolProvider(outcome: Promise<IResolverOutcome<IFlexToolHandle | undefined>>, run: IActiveRun): void;
+    private trackDetachedCleanup;
+    private runDetachedCleanup;
+    beginDetachedCleanupSettlement(state: IStorageState): Promise<void>[];
+    settleDetachedCleanups(state: IStorageState, attempts: readonly Promise<void>[]): Promise<Error[]>;
+}

package/dist_ts/classes.flexharness.providers.js

@@ -0,0 +1,267 @@
+import { FlexHarnessValidationError } from './errors.js';
+import { requireSessionGeneration, createFlexResourceIdentityDigest, createFlexResourceToolNamespace, createFlexResourceToolName, combineErrors, } from './utils.flexharness.js';
+const maxResourceToolProviders = 128;
+/** Tool provider plumbing: run tool handles, resource tool providers and detached cleanups. */
+export class FlexHarnessToolProviders {
+    core;
+    constructor(core) {
+        this.core = core;
+    }
+    normalizeToolHandle(run, handle) {
+        if (handle === undefined)
+            return undefined;
+        let close;
+        try {
+            close = handle.close;
+            if (close !== undefined && typeof close !== 'function') {
+                throw new FlexHarnessValidationError('Tool handle close must be a function.');
+            }
+            const tools = handle.tools;
+            this.core.runs.assertNoBuiltInToolCollisions(run, tools);
+            const catalog = handle.catalog;
+            if (catalog !== undefined && (typeof catalog !== 'object' || catalog === null)) {
+                throw new FlexHarnessValidationError('Tool handle catalog must be an object.');
+            }
+            const isReadOnlyToolCall = handle.isReadOnlyToolCall;
+            if (isReadOnlyToolCall !== undefined && typeof isReadOnlyToolCall !== 'function') {
+                throw new FlexHarnessValidationError('Tool handle isReadOnlyToolCall must be a function.');
+            }
+            const closeHandle = close;
+            return {
+                tools,
+                ...(catalog === undefined ? {} : { catalog }),
+                ...(isReadOnlyToolCall === undefined ? {} : {
+                    isReadOnlyToolCall: (call) => isReadOnlyToolCall.call(handle, call),
+                }),
+                ...(closeHandle ? { close: () => closeHandle.call(handle) } : {}),
+            };
+        }
+        catch (error) {
+            if (close)
+                this.trackDetachedCleanup(run.state, run, () => close.call(handle));
+            throw this.core.projectExternalError(run, error, 'toolProvider');
+        }
+    }
+    async provideRunToolHandle(run, context) {
+        if (!this.core.resourceToolProviderResolver)
+            return this.core.toolProvider?.provideTools(context);
+        const resolverContext = Object.freeze({
+            scopeId: context.scopeId,
+            scope: context.scope,
+            sessionId: context.sessionId,
+            ...requireSessionGeneration(run.stored.session),
+            runId: context.runId,
+            ...(context.parentSessionId === undefined ? {} : { parentSessionId: context.parentSessionId }),
+            ...(context.agent === undefined ? {} : { agent: context.agent }),
+            signal: context.signal,
+        });
+        const resolved = await this.core.resourceToolProviderResolver.resolveResourceToolProviders(resolverContext);
+        const descriptors = this.normalizeResourceToolProviderDescriptors(resolved);
+        const owned = [];
+        const tools = Object.create(null);
+        /** The handle and own name of each exposed resource tool, for the handle's classifier. */
+        const resourceTools = new Map();
+        const closeOwned = async () => {
+            const errors = [];
+            for (const entry of [...owned].reverse()) {
+                if (entry.closed || !entry.handle.close)
+                    continue;
+                try {
+                    await entry.handle.close();
+                    entry.closed = true;
+                }
+                catch (error) {
+                    errors.push(error);
+                }
+            }
+            if (errors.length > 0)
+                throw combineErrors(errors);
+        };
+        try {
+            context.signal.throwIfAborted();
+            const applicationHandle = this.normalizeToolHandle(run, await this.core.toolProvider?.provideTools(context));
+            if (applicationHandle) {
+                owned.push({ handle: applicationHandle, closed: false });
+                for (const [toolName, tool] of Object.entries(applicationHandle.tools)) {
+                    tools[toolName] = tool;
+                }
+            }
+            for (const descriptor of descriptors) {
+                context.signal.throwIfAborted();
+                const namespace = createFlexResourceToolNamespace(descriptor.resourceId, descriptor.attachmentRevision);
+                const resourceIdentity = createFlexResourceIdentityDigest(descriptor.resourceId, descriptor.attachmentRevision);
+                const resourceContext = Object.freeze({
+                    ...context,
+                    requestPermission: (request) => context.requestPermission({
+                        ...request,
+                        kind: `resource.${resourceIdentity}.${request.kind}`,
+                        ...(request.rememberKey === undefined
+                            ? {}
+                            : { rememberKey: `resource:${resourceIdentity}:${request.rememberKey}` }),
+                        metadata: {
+                            resourceId: descriptor.resourceId,
+                            attachmentRevision: descriptor.attachmentRevision,
+                            resourceIdentity,
+                            toolNamespace: namespace,
+                            ...(request.metadata === undefined ? {} : { providerMetadata: request.metadata }),
+                        },
+                    }),
+                });
+                const handle = this.normalizeToolHandle(run, await descriptor.provider.provideTools(resourceContext));
+                if (!handle)
+                    continue;
+                owned.push({ handle, closed: false });
+                if (handle.catalog !== undefined) {
+                    throw new FlexHarnessValidationError('Resource tool providers cannot supply a tool catalog.');
+                }
+                for (const [toolName, tool] of Object.entries(handle.tools)) {
+                    const exposedName = createFlexResourceToolName(namespace, toolName);
+                    if (Object.prototype.hasOwnProperty.call(tools, exposedName)) {
+                        throw new FlexHarnessValidationError(`Duplicate exposed tool "${exposedName}".`);
+                    }
+                    tools[exposedName] = tool;
+                    resourceTools.set(exposedName, { handle, toolName });
+                }
+            }
+            if (owned.length === 0 && Object.keys(tools).length === 0)
+                return undefined;
+            const classifies = applicationHandle?.isReadOnlyToolCall !== undefined
+                || [...resourceTools.values()].some((entry) => entry.handle.isReadOnlyToolCall !== undefined);
+            return {
+                tools: tools,
+                ...(applicationHandle?.catalog === undefined ? {} : { catalog: applicationHandle.catalog }),
+                ...(classifies ? {
+                    isReadOnlyToolCall: ({ toolName, input }) => {
+                        const resource = resourceTools.get(toolName);
+                        return resource
+                            ? resource.handle.isReadOnlyToolCall?.({ toolName: resource.toolName, input }) === true
+                            : applicationHandle?.isReadOnlyToolCall?.({ toolName, input }) === true;
+                    },
+                } : {}),
+                ...(owned.some((entry) => entry.handle.close) ? { close: closeOwned } : {}),
+            };
+        }
+        catch (error) {
+            if (owned.some((entry) => entry.handle.close && !entry.closed)) {
+                try {
+                    await this.closePartialToolHandle({ tools: {}, close: closeOwned }, run);
+                }
+                catch (cleanupError) {
+                    throw combineErrors([error, cleanupError]);
+                }
+            }
+            throw error;
+        }
+    }
+    normalizeResourceToolProviderDescriptors(descriptors) {
+        if (!Array.isArray(descriptors) || descriptors.length > maxResourceToolProviders) {
+            throw new FlexHarnessValidationError(`Resource tool providers must be an array with at most ${maxResourceToolProviders} descriptors.`);
+        }
+        const resourceIds = new Set();
+        const namespaces = new Set();
+        return descriptors.map((descriptor, index) => {
+            if (!descriptor
+                || typeof descriptor !== 'object'
+                || Array.isArray(descriptor)
+                || ![Object.prototype, null].includes(Object.getPrototypeOf(descriptor))) {
+                throw new FlexHarnessValidationError(`Resource tool provider descriptor ${index} is invalid.`);
+            }
+            const unsupported = Object.keys(descriptor).find((key) => !['resourceId', 'attachmentRevision', 'provider'].includes(key));
+            if (unsupported) {
+                throw new FlexHarnessValidationError(`Resource tool provider descriptor ${index} does not support "${unsupported}".`);
+            }
+            const resourceId = descriptor.resourceId;
+            const attachmentRevision = descriptor.attachmentRevision;
+            const provider = descriptor.provider;
+            const provideTools = provider?.provideTools;
+            const namespace = createFlexResourceToolNamespace(resourceId, attachmentRevision);
+            if (resourceIds.has(resourceId)) {
+                throw new FlexHarnessValidationError(`Duplicate resourceId "${resourceId}".`);
+            }
+            if (namespaces.has(namespace)) {
+                throw new FlexHarnessValidationError(`Duplicate resource tool namespace "${namespace}".`);
+            }
+            if (!provider || typeof provideTools !== 'function') {
+                throw new FlexHarnessValidationError(`Resource tool provider descriptor ${index} has no tool provider.`);
+            }
+            resourceIds.add(resourceId);
+            namespaces.add(namespace);
+            return {
+                resourceId,
+                attachmentRevision,
+                provider: {
+                    provideTools: (context) => provideTools.call(provider, context),
+                },
+            };
+        });
+    }
+    async closePartialToolHandle(handle, run) {
+        try {
+            await handle.close?.();
+        }
+        catch (error) {
+            const projected = this.core.projectExternalError(run, error, 'toolCleanup');
+            this.retainDetachedCleanup(run.state, run, () => handle.close?.(), projected);
+            throw projected;
+        }
+    }
+    retainDetachedCleanup(state, run, cleanup, error) {
+        state.detachedCleanups.add({
+            cleanup,
+            projectError: (cleanupError) => this.core.projectExternalError(run, cleanupError, 'toolCleanup'),
+            error,
+        });
+    }
+    observeDetachedToolProvider(outcome, run) {
+        this.trackDetachedCleanup(run.state, run, async () => {
+            const result = await outcome;
+            if (!result.success || result.source !== 'tools' || !result.value)
+                return;
+            const close = result.value.close;
+            if (close !== undefined && typeof close !== 'function') {
+                throw new FlexHarnessValidationError('Tool handle close must be a function.');
+            }
+            await close?.call(result.value);
+        });
+    }
+    trackDetachedCleanup(state, run, cleanup) {
+        const retained = {
+            cleanup,
+            projectError: (error) => this.core.projectExternalError(run, error, 'toolCleanup'),
+        };
+        state.detachedCleanups.add(retained);
+        void this.runDetachedCleanup(state, retained);
+    }
+    runDetachedCleanup(state, retained) {
+        if (retained.completion)
+            return retained.completion;
+        retained.error = undefined;
+        let completion;
+        completion = Promise.resolve()
+            .then(retained.cleanup)
+            .then(() => {
+            state.detachedCleanups.delete(retained);
+        }, (error) => {
+            retained.error = retained.projectError(error);
+        })
+            .finally(() => {
+            if (retained.completion === completion)
+                retained.completion = undefined;
+        });
+        retained.completion = completion;
+        return completion;
+    }
+    beginDetachedCleanupSettlement(state) {
+        return [...state.detachedCleanups].map((cleanup) => cleanup.completion ?? this.runDetachedCleanup(state, cleanup));
+    }
+    async settleDetachedCleanups(state, attempts) {
+        await Promise.all(attempts);
+        await Promise.all([...state.detachedCleanups]
+            .map((cleanup) => cleanup.completion)
+            .filter((completion) => completion !== undefined));
+        return [...state.detachedCleanups]
+            .map((cleanup) => cleanup.error)
+            .filter((error) => error !== undefined);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.flexharness.providers.js","sourceRoot":"","sources":["../ts/classes.flexharness.providers.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,26 @@
+import { type TJsonValue } from './interfaces.js';
+import type { IActiveRun, IResultRead } from './interfaces.flexharness.js';
+import type { FlexHarnessCore } from './classes.flexharness.core.js';
+/** Budgeted tool output: oversized results stored behind result handles and read back by page. */
+export declare class FlexHarnessResults<TScope> {
+    private readonly core;
+    /** A session's result writes, one at a time: they share the session's index of results. */
+    readonly resultQueues: Map<string, Promise<void>>;
+    constructor(core: FlexHarnessCore<TScope>);
+    /**
+     * The output the model gets: the output itself within the output budget, or, in a run with a
+     * catalog whose stores keep results, a handle to the stored output with a summary of it.
+     */
+    budgetOutput(run: IActiveRun, output: unknown): Promise<TJsonValue>;
+    resultQueueKey(storageKey: string, sessionId: string): string;
+    /** The JSON bytes of one `results.get` page: the output budget, less room for the page's fields. */
+    private resultPageBytes;
+    /** One page of a stored result of the run's session, or the error `results.get` reports. */
+    readResult(run: IActiveRun, params: IResultRead): Promise<{
+        ok: true;
+        value: TJsonValue;
+    } | {
+        ok: false;
+        error: TJsonValue;
+    }>;
+}

package/dist_ts/classes.flexharness.results.js

@@ -0,0 +1,89 @@
+import * as plugins from './plugins.js';
+import { FLEX_RESULT_LIMITS, FLEX_RESULT_METHOD, } from './interfaces.js';
+import { describeShape, resultPage, selectPath, summarizeResult } from './utils.results.js';
+import { normalizeJsonValue } from './utils.json.js';
+import { jsonBytes } from './utils.transfer.js';
+import { queueOperation } from './utils.flexharness.js';
+/** Budgeted tool output: oversized results stored behind result handles and read back by page. */
+export class FlexHarnessResults {
+    core;
+    /** A session's result writes, one at a time: they share the session's index of results. */
+    resultQueues = new Map();
+    constructor(core) {
+        this.core = core;
+    }
+    /**
+     * The output the model gets: the output itself within the output budget, or, in a run with a
+     * catalog whose stores keep results, a handle to the stored output with a summary of it.
+     */
+    async budgetOutput(run, output) {
+        const results = this.core.stores.results;
+        const maxBytes = this.core.toolOutputLimits.maxBytes;
+        if (!results || !run.toolCatalog)
+            return normalizeJsonValue(output, this.core.toolOutputLimits);
+        const stored = normalizeJsonValue(output, {
+            ...this.core.toolOutputLimits,
+            maxBytes: Math.max(maxBytes, FLEX_RESULT_LIMITS.maxStoredBytes),
+        });
+        const bytes = jsonBytes(stored);
+        if (bytes <= maxBytes)
+            return stored;
+        const handle = `res_${plugins.crypto.randomBytes(8).toString('hex')}`;
+        const read = `Too large to return whole: read it page by page with execute({ method: "${FLEX_RESULT_METHOD}", `
+            + `params: { handle: "${handle}", page: 1 } })${run.toolCatalog.codeMode
+                ? `, or in run_code with await api.results.get("${handle}", { page: 1 })`
+                : ''}; a dotted \`path\` reads a part of it.`;
+        const result = {
+            $flexType: 'result',
+            handle,
+            bytes,
+            pages: resultPage(stored, '', 1, this.resultPageBytes()).pages,
+            summary: summarizeResult(stored, Math.min(FLEX_RESULT_LIMITS.summaryBytes, Math.floor(maxBytes / 4))),
+            read,
+        };
+        // A budget too small for even the handle keeps the truncated output.
+        if (jsonBytes(result) > maxBytes)
+            return normalizeJsonValue(output, this.core.toolOutputLimits);
+        const { storageKey } = run.state;
+        await queueOperation(this.resultQueues, this.resultQueueKey(storageKey, run.sessionId), async () => {
+            await results.save(storageKey, run.sessionId, handle, stored);
+            // The session keeps its latest results; older ones are deleted.
+            const handles = await results.list(storageKey, run.sessionId);
+            for (const old of handles.slice(0, Math.max(0, handles.length - FLEX_RESULT_LIMITS.maxResultsPerSession))) {
+                await results.delete(storageKey, run.sessionId, old);
+            }
+        });
+        return result;
+    }
+    resultQueueKey(storageKey, sessionId) {
+        return JSON.stringify([storageKey, sessionId]);
+    }
+    /** The JSON bytes of one `results.get` page: the output budget, less room for the page's fields. */
+    resultPageBytes() {
+        return Math.max(64, this.core.toolOutputLimits.maxBytes - 512);
+    }
+    /** One page of a stored result of the run's session, or the error `results.get` reports. */
+    async readResult(run, params) {
+        const method = FLEX_RESULT_METHOD;
+        const stored = await this.core.stores.results.load(run.state.storageKey, run.sessionId, params.handle);
+        if (stored === undefined) {
+            return { ok: false, error: { error: 'unknown_handle', method, handle: params.handle, hint: `A handle reads one of the latest ${FLEX_RESULT_LIMITS.maxResultsPerSession} results this session stored.` } };
+        }
+        const path = params.path ?? '';
+        const value = selectPath(stored, path);
+        if (value === undefined) {
+            return { ok: false, error: { error: 'unknown_path', method, path, hint: `The result is ${describeShape(stored)}.` } };
+        }
+        const page = params.page ?? 1;
+        const content = resultPage(value, path, page, this.resultPageBytes());
+        if (!content) {
+            const pages = resultPage(value, path, 1, this.resultPageBytes()).pages;
+            return { ok: false, error: { error: 'unknown_page', method, page, pages } };
+        }
+        return {
+            ok: true,
+            value: { handle: params.handle, path, page, pages: content.pages, ...content.range, value: content.value },
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,52 @@
+import * as plugins from './plugins.js';
+import { type IFlexReversionSegment, type IFlexRedoSessionResult, type IFlexSessionReversionInfo, type IFlexSessionTombstone, type IFlexUndoSessionResult } from './interfaces.js';
+import type { TCanonicalOutcome, IStoredSessionState, IReversionGroup, IStorageState, IActiveRun } from './interfaces.flexharness.js';
+import type { FlexHarnessCore } from './classes.flexharness.core.js';
+/** Turn reversion: capture, undo and redo, and the release of reversion state. */
+export declare class FlexHarnessReversions<TScope> {
+    private readonly core;
+    constructor(core: FlexHarnessCore<TScope>);
+    getSessionReversionInfo(scopeId: string, sessionId: string): Promise<IFlexSessionReversionInfo>;
+    undoSession(scopeId: string, sessionId: string, signal?: AbortSignal): Promise<IFlexUndoSessionResult>;
+    redoSession(scopeId: string, sessionId: string, signal?: AbortSignal): Promise<IFlexRedoSessionResult>;
+    reversionUnit(stored: IStoredSessionState, direction: 'undo' | 'redo'): {
+        target: IFlexReversionSegment;
+        segments: IFlexReversionSegment[];
+        toCursor: number;
+    } | undefined;
+    reversionGroups(stored: IStoredSessionState): IReversionGroup[];
+    private requireReversionIdle;
+    reversionUnavailableReason(state: IStorageState, stored: IStoredSessionState, allowPendingApply?: boolean, operationSignal?: AbortSignal): Promise<string | undefined>;
+    awaitReversionOperation<TResult>(operation: Promise<TResult>, signal?: AbortSignal): Promise<TResult>;
+    private changeReversionCursor;
+    changeReversionCursorResolved(scopeId: string, sessionId: string, direction: 'undo' | 'redo', scope: TScope, state: IStorageState, signal?: AbortSignal): Promise<string>;
+    reconcileContextAvailability(state: IStorageState, stored: IStoredSessionState): Promise<boolean>;
+    resumePendingApply(state: IStorageState, stored: IStoredSessionState, scopeId: string, scope: TScope, signal?: AbortSignal): Promise<void>;
+    private persistKnownNotApplied;
+    recoverPendingCapture(state: IStorageState, stored: IStoredSessionState, scopeId: string, scope: TScope, outcomes: Map<string, TCanonicalOutcome>): Promise<void>;
+    reversionId(kind: 'capture' | 'apply', storageKey: string, sessionId: string, value: string): string;
+    reversionProviderProtocolVersion(): 1 | 2 | undefined;
+    private reversionCaptureContext;
+    private withReversionMaintenanceSignal;
+    private inspectReversionCapture;
+    private finalizeReversionCapture;
+    private resolveReversionCaptureOutcome;
+    private normalizeReversionReference;
+    private normalizeReversionOutcome;
+    private normalizeAffectedWorkspaces;
+    prepareRunReversion(run: IActiveRun, signal: AbortSignal): Promise<void>;
+    finalizeRunReversion(run: IActiveRun, status: 'completed' | 'failed' | 'cancelled'): Promise<void>;
+    private applyFinalizedReversionOutcome;
+    private hiddenReversionSegments;
+    private enqueueReversionRelease;
+    private enqueueReversionReleaseReference;
+    pruneReversionState(stored: IStoredSessionState, reserveSegment?: boolean, dropNonUndoablePrefix?: boolean): void;
+    commitRevertedBranch(state: IStorageState, stored: IStoredSessionState, scopeId: string, scope: TScope): Promise<void>;
+    commitRevertedBranchState(stored: IStoredSessionState): boolean;
+    commitArchivedHiddenBranchState(stored: IStoredSessionState): boolean;
+    refreshAutomaticArchiveHorizon(stored: IStoredSessionState): void;
+    filterReversionContextEvents(stored: IStoredSessionState, events: readonly plugins.TAgentEvent[]): plugins.TAgentEvent[];
+    drainReversionReleases(state: IStorageState, stored: IStoredSessionState, scopeId: string, scope: TScope, throwOnFailure: boolean): Promise<void>;
+    releaseDeletedSessionReversions(state: IStorageState, storageKey: string, tombstone: IFlexSessionTombstone, scopeId: string, scope: TScope, stored?: IStoredSessionState): Promise<void>;
+    completedReversionCandidates(stored: IStoredSessionState): IFlexReversionSegment[];
+}