@modelprofile.com/flexharness 10.23.0 → 10.24.1

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

@@ -0,0 +1,19 @@
+import type { IFlexPermissionRequest, IFlexPermissionRequestInput, TFlexPermissionDecision, TJsonValue } from './interfaces.js';
+import type { IStorageState, IActiveRun, IPendingPermission } from './interfaces.flexharness.js';
+import type { FlexHarnessCore } from './classes.flexharness.core.js';
+/** Permission requests and responses, and the permission policy of sessions. */
+export declare class FlexHarnessPermissions<TScope> {
+    private readonly core;
+    constructor(core: FlexHarnessCore<TScope>);
+    listPendingPermissions(scopeId: string, sessionId?: string): Promise<IFlexPermissionRequest[]>;
+    respondToPermission(scopeId: string, sessionId: string, permissionId: string, decision: TFlexPermissionDecision): Promise<void>;
+    requestPermission(state: IStorageState, run: IActiveRun, input: IFlexPermissionRequestInput, exactMetadata?: TJsonValue): Promise<void>;
+    private decideSessionPermissionPolicy;
+    private applyPermissionResponse;
+    private rollbackRememberedGrant;
+    private reconcileRememberedPermissionRemoval;
+    rejectRunPermissions(state: IStorageState, run: IActiveRun, error: unknown): void;
+    rejectPending(state: IStorageState, pending: IPendingPermission, error: unknown): void;
+    private forceRejectPending;
+    private mutatePermissions;
+}

package/dist_ts/classes.flexharness.permissions.js

@@ -0,0 +1,450 @@
+import * as plugins from './plugins.js';
+import { FlexHarnessAbortError, FlexHarnessNotFoundError, FlexHarnessPermissionRejectedError, FlexHarnessPermissionStateError, FlexHarnessStoreConflictError, FlexHarnessStoreCommitUncertainError, FlexHarnessValidationError, } from './errors.js';
+import { cloneSerializable, normalizeJsonValue } from './utils.json.js';
+import { maxTransferMetadataBytes, publicSnapshot, truncateUtf8 } from './utils.transfer.js';
+import { validateIdentifier } from './utils.validation.js';
+import { requireSessionGeneration, combineErrors } from './utils.flexharness.js';
+/** Permission requests and responses, and the permission policy of sessions. */
+export class FlexHarnessPermissions {
+    core;
+    constructor(core) {
+        this.core = core;
+    }
+    async listPendingPermissions(scopeId, sessionId) {
+        const { state } = await this.core.resolveState(scopeId);
+        await state.scopeQueue;
+        this.core.assertStateAcceptingWork(state);
+        return publicSnapshot([...state.pendingPermissions.values()]
+            .map((pending) => pending.request)
+            .filter((request) => !sessionId || request.sessionId === sessionId)
+            .sort((left, right) => left.createdAt.localeCompare(right.createdAt)));
+    }
+    async respondToPermission(scopeId, sessionId, permissionId, decision) {
+        validateIdentifier(permissionId, 'permissionId');
+        const { scope, state } = await this.core.resolveState(scopeId);
+        const pending = state.pendingPermissions.get(permissionId);
+        if (!pending || pending.request.sessionId !== sessionId) {
+            throw new FlexHarnessNotFoundError('Permission', permissionId);
+        }
+        const context = this.core.compaction.createCompactorContext(scopeId, scope.scope, state.storageKey, sessionId);
+        const response = pending.responseQueue.then(() => this.core.compaction.withCompactorContext(context, () => this.applyPermissionResponse(state, pending, decision, context)));
+        pending.responseQueue = response.then(() => undefined, () => undefined);
+        return response;
+    }
+    async requestPermission(state, run, input, exactMetadata) {
+        validateIdentifier(input.kind, 'permission kind');
+        validateIdentifier(input.description, 'permission description');
+        if (input.rememberKey !== undefined)
+            validateIdentifier(input.rememberKey, 'rememberKey');
+        if (input.toolCallId !== undefined)
+            validateIdentifier(input.toolCallId, 'toolCallId');
+        run.controller.signal.throwIfAborted();
+        await run.stored.permissionQueue;
+        run.controller.signal.throwIfAborted();
+        if (state.activeRuns.get(run.sessionId) !== run || run.callbacksClosed) {
+            throw new FlexHarnessPermissionStateError(`Run "${run.runId}" no longer accepts permission requests.`);
+        }
+        if (!run.permissionPolicy && input.rememberKey && run.stored.rememberedPermissionKeys.has(input.rememberKey)) {
+            return;
+        }
+        const candidate = {
+            permissionId: plugins.crypto.randomUUID(),
+            scopeId: run.scopeId,
+            sessionId: run.sessionId,
+            ...requireSessionGeneration(run.stored.session),
+            runId: run.runId,
+            kind: input.kind,
+            description: truncateUtf8(input.description, maxTransferMetadataBytes),
+            ...(input.toolCallId ? { toolCallId: input.toolCallId } : {}),
+            ...(input.rememberKey ? { rememberKey: input.rememberKey } : {}),
+            ...(exactMetadata !== undefined
+                ? { metadata: cloneSerializable(exactMetadata) }
+                : input.metadata === undefined
+                    ? {}
+                    : { metadata: normalizeJsonValue(input.metadata, this.core.toolOutputLimits) }),
+            createdAt: new Date().toISOString(),
+        };
+        const policyDecision = run.permissionPolicy
+            ? await this.decideSessionPermissionPolicy(state, run, candidate)
+            : 'inherit';
+        if (policyDecision === 'allow' || policyDecision === 'deny') {
+            this.core.emitEvent(run.scopeId, run.stored.session, {
+                type: 'permission.resolved',
+                runId: run.runId,
+                request: publicSnapshot(candidate),
+                decision: policyDecision === 'allow' ? 'once' : 'reject',
+                origin: 'policy',
+            });
+            if (policyDecision === 'deny') {
+                const rejection = this.core.trustInternalError(new FlexHarnessPermissionRejectedError(candidate.permissionId));
+                this.core.runs.abortRunInternally(run, rejection);
+                throw rejection;
+            }
+            return;
+        }
+        if (policyDecision === 'inherit'
+            && input.rememberKey && run.stored.rememberedPermissionKeys.has(input.rememberKey))
+            return;
+        const request = { ...candidate };
+        if (policyDecision === 'ask') {
+            delete request.rememberKey;
+            request.requiresExplicitResponse = true;
+        }
+        let resolvePermission;
+        let rejectPermission;
+        const promise = new Promise((resolve, reject) => {
+            resolvePermission = resolve;
+            rejectPermission = reject;
+        });
+        void promise.catch(() => undefined);
+        const abortListener = () => {
+            const pending = state.pendingPermissions.get(request.permissionId);
+            if (pending)
+                this.rejectPending(state, pending, run.controller.signal.reason);
+        };
+        const pending = {
+            request,
+            run,
+            resolve: resolvePermission,
+            reject: rejectPermission,
+            settled: false,
+            responding: false,
+            responseQueue: Promise.resolve(),
+            abortListener,
+        };
+        const closePublication = this.core.openPublication(state, run.sessionId);
+        try {
+            state.pendingPermissions.set(request.permissionId, pending);
+            run.pendingPermissionIds.add(request.permissionId);
+            run.controller.signal.addEventListener('abort', abortListener, { once: true });
+            try {
+                await this.core.mutateScope(state, () => {
+                    if (state.sessions.get(run.sessionId) !== run.stored) {
+                        throw new FlexHarnessAbortError('The session was deleted while permission was pending.');
+                    }
+                    run.stored.session.status = 'waiting_permission';
+                    run.stored.session.activity.status = 'waiting_permission';
+                    run.stored.session.updatedAt = new Date().toISOString();
+                }, true);
+            }
+            catch (error) {
+                this.forceRejectPending(state, pending, this.core.projectExternalError(run, error, 'persistence'));
+                return promise;
+            }
+            if (!pending.settled) {
+                this.core.emitEvent(run.scopeId, run.stored.session, {
+                    type: 'permission.requested',
+                    runId: run.runId,
+                    request: publicSnapshot(request),
+                });
+            }
+        }
+        finally {
+            closePublication();
+        }
+        return promise;
+    }
+    async decideSessionPermissionPolicy(state, run, request) {
+        const policy = run.permissionPolicy;
+        const signal = run.controller.signal;
+        const context = Object.freeze({
+            scopeId: run.scopeId,
+            scope: run.scope,
+            storageKey: state.storageKey,
+            sessionId: run.sessionId,
+            ...requireSessionGeneration(run.stored.session),
+            runId: run.runId,
+            configurationRef: run.stored.session.configurationRef,
+            ...(run.stored.session.agent === undefined ? {} : { agent: run.stored.session.agent }),
+            request: publicSnapshot(request),
+            signal,
+        });
+        let onAbort;
+        const aborted = new Promise((_resolve, reject) => {
+            onAbort = () => reject(signal.reason ?? this.core.trustInternalError(new FlexHarnessAbortError()));
+        });
+        signal.addEventListener('abort', onAbort, { once: true });
+        if (signal.aborted)
+            onAbort();
+        let decision;
+        try {
+            decision = await Promise.race([
+                Promise.resolve().then(() => {
+                    signal.throwIfAborted();
+                    return policy(context);
+                }),
+                aborted,
+            ]);
+            if (!['inherit', 'allow', 'ask', 'deny'].includes(decision)) {
+                throw new FlexHarnessValidationError('Session permissionPolicy returned an invalid decision.');
+            }
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw signal.reason;
+            const projected = this.core.projectExternalError(run, error, 'permissionPolicy');
+            this.core.runs.abortRunInternally(run, projected);
+            throw projected;
+        }
+        finally {
+            signal.removeEventListener('abort', onAbort);
+        }
+        signal.throwIfAborted();
+        const generation = requireSessionGeneration(run.stored.session);
+        if (state.lifecycle !== 'active'
+            || state.activeRuns.get(run.sessionId) !== run
+            || state.sessions.get(run.sessionId) !== run.stored
+            || run.callbacksClosed
+            || generation.sessionGenerationId !== request.sessionGenerationId
+            || generation.sessionGenerationSequence !== request.sessionGenerationSequence) {
+            const ownershipError = this.core.trustInternalError(new FlexHarnessAbortError('Permission policy lost its exact run ownership.'));
+            this.core.runs.abortRunInternally(run, ownershipError);
+            throw ownershipError;
+        }
+        return decision;
+    }
+    async applyPermissionResponse(state, pending, decision, context) {
+        if (pending.settled) {
+            throw new FlexHarnessPermissionStateError(`Permission "${pending.request.permissionId}" has already been resolved.`);
+        }
+        if (!['once', 'always', 'reject'].includes(decision)) {
+            throw new FlexHarnessPermissionStateError(`Unknown permission decision "${decision}".`);
+        }
+        if (decision === 'always' && !pending.request.rememberKey) {
+            throw new FlexHarnessPermissionStateError('The always decision requires rememberKey.');
+        }
+        const stored = pending.run.stored;
+        const rememberKey = pending.request.rememberKey;
+        let addedRememberKey = false;
+        pending.responding = true;
+        try {
+            if (decision === 'always' && rememberKey) {
+                await this.mutatePermissions(state, stored, () => {
+                    addedRememberKey = !stored.rememberedPermissionKeys.has(rememberKey);
+                    stored.rememberedPermissionKeys.add(rememberKey);
+                });
+            }
+            await this.core.mutateScope(state, () => {
+                if (state.sessions.get(pending.request.sessionId) !== stored) {
+                    throw new FlexHarnessAbortError('The session was deleted while permission was resolving.');
+                }
+                const hasOtherPending = [...state.pendingPermissions.values()].some((entry) => entry !== pending && !entry.settled && entry.request.sessionId === pending.request.sessionId);
+                stored.session.status = hasOtherPending ? 'waiting_permission' : 'running';
+                stored.session.activity.status = hasOtherPending ? 'waiting_permission' : 'running';
+                stored.session.updatedAt = new Date().toISOString();
+            }, true);
+        }
+        catch (error) {
+            pending.responding = false;
+            const projected = this.core.projectExternalError(pending.run, error, 'persistence');
+            const rollbackErrors = await this.rollbackRememberedGrant(state, pending, addedRememberKey, rememberKey);
+            if (pending.abortReason === undefined
+                && state.sessions.get(pending.request.sessionId) === stored
+                && stored.session.status !== 'waiting_permission') {
+                try {
+                    await this.core.mutateScope(state, () => {
+                        stored.session.status = 'waiting_permission';
+                        stored.session.activity.status = 'waiting_permission';
+                        stored.session.updatedAt = new Date().toISOString();
+                    }, true);
+                }
+                catch (rollbackError) {
+                    rollbackErrors.push(this.core.projectExternalError(pending.run, rollbackError, 'persistence'));
+                }
+            }
+            if (pending.abortReason !== undefined) {
+                this.forceRejectPending(state, pending, pending.abortReason);
+            }
+            if (rollbackErrors.length > 0 || state.lifecycle === 'fenced') {
+                if (!pending.settled)
+                    this.forceRejectPending(state, pending, projected);
+                const combined = combineErrors([
+                    ...(pending.abortReason === undefined ? [] : [pending.abortReason]),
+                    projected,
+                    ...rollbackErrors,
+                ]);
+                await this.core.lifecycle.fenceNamespace(state, pending.run, combined);
+                throw combined;
+            }
+            if (pending.abortReason !== undefined)
+                throw pending.abortReason;
+            throw projected;
+        }
+        if (pending.abortReason !== undefined) {
+            const rollbackErrors = await this.rollbackRememberedGrant(state, pending, addedRememberKey, rememberKey);
+            pending.responding = false;
+            this.forceRejectPending(state, pending, pending.abortReason);
+            if (rollbackErrors.length > 0) {
+                const combined = combineErrors([pending.abortReason, ...rollbackErrors]);
+                await this.core.lifecycle.fenceNamespace(state, pending.run, combined);
+                throw combined;
+            }
+            throw pending.abortReason;
+        }
+        pending.settled = true;
+        pending.responding = false;
+        state.pendingPermissions.delete(pending.request.permissionId);
+        pending.run.pendingPermissionIds.delete(pending.request.permissionId);
+        pending.run.controller.signal.removeEventListener('abort', pending.abortListener);
+        this.core.emitEvent(pending.request.scopeId, pending.run.stored.session, {
+            type: 'permission.resolved',
+            runId: pending.request.runId,
+            request: publicSnapshot(pending.request),
+            decision,
+        });
+        if (decision === 'reject') {
+            const rejection = this.core.trustInternalError(new FlexHarnessPermissionRejectedError(pending.request.permissionId));
+            this.core.runs.abortRunInternally(pending.run, rejection, context);
+            pending.reject(rejection);
+        }
+        else {
+            pending.resolve();
+        }
+    }
+    async rollbackRememberedGrant(state, pending, added, rememberKey) {
+        if (!added
+            || !rememberKey
+            || !pending.run.stored.rememberedPermissionKeys.has(rememberKey))
+            return [];
+        try {
+            await this.mutatePermissions(state, pending.run.stored, () => {
+                pending.run.stored.rememberedPermissionKeys.delete(rememberKey);
+            }, true);
+            return [];
+        }
+        catch (error) {
+            const initialError = this.core.projectExternalError(pending.run, error, 'persistence');
+            try {
+                await this.reconcileRememberedPermissionRemoval(pending.run.stored, state.storageKey, rememberKey);
+                return [];
+            }
+            catch (recoveryError) {
+                return [initialError, this.core.projectExternalError(pending.run, recoveryError, 'persistence')];
+            }
+        }
+    }
+    async reconcileRememberedPermissionRemoval(stored, storageKey, rememberKey) {
+        const operation = stored.permissionQueue.then(async () => {
+            let lastError;
+            for (let attempt = 0; attempt < 3; attempt++) {
+                try {
+                    const current = await this.core.stores.permissions.load(storageKey, stored.session.sessionId);
+                    if (!current || !current.rememberedPermissionKeys.includes(rememberKey)) {
+                        stored.rememberedPermissionKeys = new Set(current?.rememberedPermissionKeys ?? []);
+                        stored.permissionRevision = current?.revision ?? 0;
+                        return;
+                    }
+                    const snapshot = {
+                        ...current,
+                        revision: current.revision + 1,
+                        rememberedPermissionKeys: current.rememberedPermissionKeys.filter((entry) => entry !== rememberKey),
+                    };
+                    await this.core.stores.permissions.save(storageKey, stored.session.sessionId, snapshot, current.revision);
+                    stored.rememberedPermissionKeys = new Set(snapshot.rememberedPermissionKeys);
+                    stored.permissionRevision = snapshot.revision;
+                    return;
+                }
+                catch (error) {
+                    lastError = error;
+                }
+            }
+            throw lastError ?? new Error('Remembered permission rollback could not be reconciled.');
+        });
+        stored.permissionQueue = operation.then(() => undefined, () => undefined);
+        await operation;
+    }
+    rejectRunPermissions(state, run, error) {
+        for (const permissionId of [...run.pendingPermissionIds]) {
+            const pending = state.pendingPermissions.get(permissionId);
+            if (pending)
+                this.rejectPending(state, pending, error);
+        }
+    }
+    rejectPending(state, pending, error) {
+        if (pending.settled)
+            return;
+        if (pending.responding) {
+            pending.abortReason ??= error;
+            return;
+        }
+        this.forceRejectPending(state, pending, error);
+    }
+    forceRejectPending(state, pending, error) {
+        if (pending.settled)
+            return;
+        pending.settled = true;
+        state.pendingPermissions.delete(pending.request.permissionId);
+        pending.run.pendingPermissionIds.delete(pending.request.permissionId);
+        pending.run.controller.signal.removeEventListener('abort', pending.abortListener);
+        pending.reject(error);
+    }
+    mutatePermissions(state, stored, mutation, _allowDuringDrain = false) {
+        const operation = stored.permissionQueue.then(async () => {
+            const beforeRevision = stored.permissionRevision;
+            const beforeKeys = new Set(stored.rememberedPermissionKeys);
+            const beforeSnapshot = {
+                schemaVersion: 1,
+                revision: beforeRevision,
+                rememberedPermissionKeys: [...beforeKeys].sort(),
+            };
+            const restore = () => {
+                stored.permissionRevision = beforeRevision;
+                stored.rememberedPermissionKeys = beforeKeys;
+            };
+            let result;
+            try {
+                result = mutation();
+            }
+            catch (error) {
+                restore();
+                throw error;
+            }
+            const snapshot = {
+                schemaVersion: 1,
+                revision: beforeRevision + 1,
+                rememberedPermissionKeys: [...stored.rememberedPermissionKeys].sort(),
+            };
+            try {
+                await this.core.stores.permissions.save(state.storageKey, stored.session.sessionId, snapshot, beforeRevision);
+                stored.permissionRevision = snapshot.revision;
+                return result;
+            }
+            catch (error) {
+                if (error instanceof FlexHarnessStoreConflictError) {
+                    restore();
+                    throw error;
+                }
+                if (error instanceof FlexHarnessStoreCommitUncertainError) {
+                    stored.permissionRevision = snapshot.revision;
+                    state.lifecycle = 'fenced';
+                    throw error;
+                }
+                let current;
+                let reconciliationError;
+                try {
+                    current = await this.core.stores.permissions.load(state.storageKey, stored.session.sessionId);
+                }
+                catch (loadError) {
+                    reconciliationError = loadError;
+                }
+                if (current && JSON.stringify(current) === JSON.stringify(snapshot)) {
+                    stored.permissionRevision = snapshot.revision;
+                    throw error;
+                }
+                if ((current === undefined && beforeRevision === 0)
+                    || (current !== undefined && JSON.stringify(current) === JSON.stringify(beforeSnapshot))) {
+                    restore();
+                    throw error;
+                }
+                stored.permissionRevision = snapshot.revision;
+                state.lifecycle = 'fenced';
+                throw reconciliationError === undefined
+                    ? error
+                    : combineErrors([error, reconciliationError]);
+            }
+        });
+        stored.permissionQueue = operation.then(() => undefined, () => undefined);
+        return operation;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.flexharness.permissions.js","sourceRoot":"","sources":["../ts/classes.flexharness.permissions.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,55 @@
+import { type IFlexCreateProjectTaskInput, type IFlexProjectGoalResult, type IFlexProjectScratchpadResult, type IFlexProjectStateResult, type IFlexProjectTaskResult, type IFlexProjectTasksResult, type IFlexSessionTombstone, type IFlexUpdateProjectTaskInput } from './interfaces.js';
+import type { IStorageState, IActiveRun } from './interfaces.flexharness.js';
+import type { FlexHarnessCore } from './classes.flexharness.core.js';
+/** The project tasks, goal and scratchpad that a session tree shares, and their agent tools. */
+export declare class FlexHarnessProjectManagement<TScope> {
+    private readonly core;
+    readonly projectManagementQueues: Map<string, Promise<void>>;
+    constructor(core: FlexHarnessCore<TScope>);
+    getProjectState(scopeId: string, sessionId: string): Promise<IFlexProjectStateResult>;
+    listProjectTasks(scopeId: string, sessionId: string): Promise<IFlexProjectTasksResult>;
+    createProjectTask(scopeId: string, sessionId: string, input: IFlexCreateProjectTaskInput): Promise<IFlexProjectTaskResult>;
+    updateProjectTask(scopeId: string, sessionId: string, input: IFlexUpdateProjectTaskInput): Promise<IFlexProjectTaskResult>;
+    deleteProjectTask(scopeId: string, sessionId: string, taskId: string): Promise<IFlexProjectTaskResult>;
+    clearProjectTasks(scopeId: string, sessionId: string): Promise<IFlexProjectTasksResult>;
+    getProjectGoal(scopeId: string, sessionId: string): Promise<IFlexProjectGoalResult>;
+    setProjectGoal(scopeId: string, sessionId: string, goal: string): Promise<IFlexProjectGoalResult>;
+    clearProjectGoal(scopeId: string, sessionId: string): Promise<IFlexProjectGoalResult>;
+    getProjectScratchpad(scopeId: string, sessionId: string): Promise<IFlexProjectScratchpadResult>;
+    setProjectScratchpad(scopeId: string, sessionId: string, content: string): Promise<IFlexProjectScratchpadResult>;
+    appendProjectScratchpad(scopeId: string, sessionId: string, content: string): Promise<IFlexProjectScratchpadResult>;
+    clearProjectScratchpad(scopeId: string, sessionId: string): Promise<IFlexProjectScratchpadResult>;
+    private requireProjectManagementTools;
+    projectManagementKey(storageKey: string, sessionId: string): string;
+    private queueProjectManagementOperation;
+    awaitProjectManagementOperations(storageKey: string, sessionIds: Iterable<string>): Promise<void>;
+    private resolveProjectManagementSession;
+    private assertProjectManagementSession;
+    private loadProjectManagementState;
+    private readProjectManagementState;
+    private mutateProjectManagementState;
+    private projectStateResult;
+    private createProjectManagementSessionContext;
+    private projectTaskResult;
+    private projectTasksResult;
+    private projectGoalResult;
+    private projectScratchpadResult;
+    private createProjectTaskInState;
+    private updateProjectTaskInState;
+    private deleteProjectTaskInState;
+    private clearProjectTasksInState;
+    private setProjectGoalInState;
+    private clearProjectGoalInState;
+    private setProjectScratchpadInState;
+    private appendProjectScratchpadInState;
+    private clearProjectScratchpadInState;
+    createProjectTaskTool(run: IActiveRun): unknown;
+    createProjectGoalTool(run: IActiveRun): unknown;
+    createProjectScratchpadTool(run: IActiveRun): unknown;
+    private projectManagementAgentWriteContext;
+    private executeProjectTaskTool;
+    private executeProjectGoalTool;
+    private executeProjectScratchpadTool;
+    private createProjectTaskId;
+    tombstoneProjectManagementSession(state: IStorageState, sessionTombstone: IFlexSessionTombstone): Promise<void>;
+}