@modelprofile.com/flexharness 10.17.1 → 10.19.0

package/dist_ts/00_commitinfo_data.js

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

package/dist_ts/errors.d.ts

@@ -60,6 +60,10 @@ export declare class FlexHarnessExternalError extends FlexHarnessError {
 export declare class FlexHarnessPermissionRejectedError extends FlexHarnessError {
     constructor(permissionId: string, options?: ErrorOptions);
 }
+export declare class FlexHarnessToolPermissionDeniedError extends FlexHarnessError {
+    readonly permissionType: string;
+    constructor(permissionType: string);
+}
 export declare class FlexHarnessPermissionStateError extends FlexHarnessError {
     constructor(message: string);
 }

package/dist_ts/errors.js

@@ -118,6 +118,14 @@ export class FlexHarnessPermissionRejectedError extends FlexHarnessError {
         this.name = 'FlexHarnessPermissionRejectedError';
     }
 }
+export class FlexHarnessToolPermissionDeniedError extends FlexHarnessError {
+    permissionType;
+    constructor(permissionType) {
+        super('FLEX_TOOL_PERMISSION_DENIED', `The tool policy denies "${permissionType}" requests.`);
+        this.name = 'FlexHarnessToolPermissionDeniedError';
+        this.permissionType = permissionType;
+    }
+}
 export class FlexHarnessPermissionStateError extends FlexHarnessError {
     constructor(message) {
         super('FLEX_PERMISSION_STATE', message);
@@ -194,4 +202,4 @@ export function modelLimitErrorInfo(error) {
 export function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvZXJyb3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBR3hDLE1BQU0sb0JBQW9CLEdBQTRDO0lBQ3BFLFdBQVcsRUFBRSxrQkFBa0I7SUFDL0IsVUFBVSxFQUFFLGlCQUFpQjtDQUM5QixDQUFDO0FBRUYsTUFBTSxPQUFPLGdCQUFpQixTQUFRLEtBQUs7SUFDekIsSUFBSSxDQUFTO0lBRTdCLFlBQVksSUFBWSxFQUFFLE9BQWUsRUFBRSxPQUFzQjtRQUMvRCxLQUFLLENBQUMsT0FBTyxFQUFFLE9BQU8sQ0FBQyxDQUFDO1FBQ3hCLElBQUksQ0FBQyxJQUFJLEdBQUcsa0JBQWtCLENBQUM7UUFDL0IsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUM7SUFDbkIsQ0FBQztDQUNGO0FBRUQsTUFBTSxPQUFPLDBCQUEyQixTQUFRLGdCQUFnQjtJQUM5RCxZQUFZLE9BQWUsRUFBRSxPQUFzQjtRQUNqRCxLQUFLLENBQUMsaUJBQWlCLEVBQUUsT0FBTyxFQUFFLE9BQU8sQ0FBQyxDQUFDO1FBQzNDLElBQUksQ0FBQyxJQUFJLEdBQUcsNEJBQTRCLENBQUM7SUFDM0MsQ0FBQztDQUNGO0FBRUQsTUFBTSxPQUFPLHNCQUF1QixTQUFRLGdCQUFnQjtJQUMxRDtRQUNFLEtBQUssQ0FBQyxhQUFhLEVBQUUsMEJBQTBCLENBQUMsQ0FBQztRQUNqRCxJQUFJLENBQUMsSUFBSSxHQUFHLHdCQUF3QixDQUFDO0lBQ3ZDLENBQUM7Q0FDRjtBQUVELE1BQU0sT0FBTyx3QkFBeUIsU0FBUSxnQkFBZ0I7SUFDNUQsWUFBWSxRQUFnQixFQUFFLEVBQVU7UUFDdEMsS0FBSyxDQUFDLGdCQUFnQixFQUFFLEdBQUcsUUFBUSxLQUFLLEVBQUUsa0JBQWtCLENBQUMsQ0FBQztRQUM5RCxJQUFJLENBQUMsSUFBSSxHQUFHLDBCQUEwQixDQUFDO0lBQ3pDLENBQUM7Q0FDRjtBQUVELE1BQU0sT0FBTywyQkFBNEIsU0FBUSxnQkFBZ0I7SUFDL0QsWUFBWSxTQUFpQixFQUFFLE1BQU0sR0FBRywyQkFBMkI7UUFDakUsS0FBSyxDQUFDLG1CQUFtQixFQUFFLFlBQVksU0FBUyxLQUFLLE1BQU0sR0FBRyxDQUFDLENBQUM7UUFDaEUsSUFBSSxDQUFDLElBQUksR0FBRyw2QkFBNkIsQ0FBQztJQUM1QyxDQUFDO0NBQ0Y7QUFJRDs7OztHQUlHO0FBQ0gsTUFBTSxPQUFPLDZCQUE4QixTQUFRLGdCQUFnQjtJQUNqRCxNQUFNLENBQXNCO0lBQzVCLE9BQU8sQ0FBUztJQUVoQyxZQUFZLE1BQTJCLEVBQUUsT0FBZTtRQUN0RCxLQUFLLENBQ0gsTUFBTSxLQUFLLFdBQVcsQ0FBQyxDQUFDLENBQUMsc0JBQXNCLENBQUMsQ0FBQyxDQUFDLHdCQUF3QixFQUMxRSxNQUFNLEtBQUssV0FBVztZQUNwQixDQUFDLENBQUMsVUFBVSxPQUFPLHlCQUF5QjtZQUM1QyxDQUFDLENBQUMsVUFBVSxPQUFPLGdDQUFnQyxDQUN0RCxDQUFDO1FBQ0YsSUFBSSxDQUFDLElBQUksR0FBRywrQkFBK0IsQ0FBQztRQUM1QyxJQUFJLENBQUMsTUFBTSxHQUFHLE1BQU0sQ0FBQztRQUNyQixJQUFJLENBQUMsT0FBTyxHQUFHLE9BQU8sQ0FBQztJQUN6QixDQUFDO0NBQ0Y7QUFFRCxnR0FBZ0c7QUFDaEcsTUFBTSxPQUFPLCtCQUFnQyxTQUFRLGdCQUFnQjtJQUNuRCxTQUFTLENBQVM7SUFFbEMsWUFBWSxTQUFpQjtRQUMzQixLQUFLLENBQUMsd0JBQXdCLEVBQUUsWUFBWSxTQUFTLGlEQUFpRCxDQUFDLENBQUM7UUFDeEcsSUFBSSxDQUFDLElBQUksR0FBRyxpQ0FBaUMsQ0FBQztRQUM5QyxJQUFJLENBQUMsU0FBUyxHQUFHLFNBQVMsQ0FBQztJQUM3QixDQUFDO0NBQ0Y7QUFFRCxNQUFNLE9BQU8sdUNBQXdDLFNBQVEsZ0JBQWdCO0lBQzNELFdBQVcsQ0FBUztJQUNwQixpQkFBaUIsQ0FBUztJQUUxQyxZQUFZLFdBQW1CLEVBQUUsaUJBQXlCO1FBQ3hELEtBQUssQ0FDSCxnQ0FBZ0MsRUFDaEMsbUJBQW1CLFdBQVcscUJBQXFCLGlCQUFpQixFQUFFLENBQ3ZFLENBQUM7UUFDRixJQUFJLENBQUMsSUFBSSxHQUFHLHlDQUF5QyxDQUFDO1FBQ3RELElBQUksQ0FBQyxXQUFXLEdBQUcsV0FBVyxDQUFDO1FBQy9CLElBQUksQ0FBQyxpQkFBaUIsR0FBRyxpQkFBaUIsQ0FBQztJQUM3QyxDQUFDO0NBQ0Y7QUFFRCxNQUFNLE9BQU8sbUNBQW9DLFNBQVEsZ0JBQWdCO0lBQ3ZFLFlBQVksU0FBaUI7UUFDM0IsS0FBSyxDQUNILDRCQUE0QixFQUM1QixZQUFZLFNBQVMsMkNBQTJDLENBQ2pFLENBQUM7UUFDRixJQUFJLENBQUMsSUFBSSxHQUFHLHFDQUFxQyxDQUFDO0lBQ3BELENBQUM7Q0FDRjtBQUVELE1BQU0sT0FBTyx5QkFBMEIsU0FBUSxnQkFBZ0I7SUFDN0QsWUFBWSxPQUFlO1FBQ3pCLEtBQUssQ0FBQyxpQkFBaUIsRUFBRSxPQUFPLENBQUMsQ0FBQztRQUNsQyxJQUFJLENBQUMsSUFBSSxHQUFHLDJCQUEyQixDQUFDO0lBQzFDLENBQUM7Q0FDRjtBQUVELE1BQU0sT0FBTyxxQkFBc0IsU0FBUSxnQkFBZ0I7SUFDekQsWUFBWSxPQUFPLEdBQUcsc0JBQXNCLEVBQUUsT0FBc0I7UUFDbEUsS0FBSyxDQUFDLGNBQWMsRUFBRSxPQUFPLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFDeEMsSUFBSSxDQUFDLElBQUksR0FBRyx1QkFBdUIsQ0FBQztJQUN0QyxDQUFDO0NBQ0Y7QUFFRCx3RkFBd0Y7QUFDeEYsTUFBTSxPQUFPLHlCQUEwQixTQUFRLGdCQUFnQjtJQUNqQztJQUE1QixZQUE0QixLQUFhO1FBQ3ZDLEtBQUssQ0FBQyxpQkFBaUIsRUFBRSx5QkFBeUIsS0FBSyw0Q0FBNEMsQ0FBQyxDQUFDO1FBRDNFLFVBQUssR0FBTCxLQUFLLENBQVE7UUFFdkMsSUFBSSxDQUFDLElBQUksR0FBRywyQkFBMkIsQ0FBQztJQUMxQyxDQUFDO0NBQ0Y7QUFFRCxNQUFNLE9BQU8sZ0NBQWlDLFNBQVEsZ0JBQWdCO0lBQ3BFLFlBQVksT0FBZTtRQUN6QixLQUFLLENBQUMsd0JBQXdCLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFDekMsSUFBSSxDQUFDLElBQUksR0FBRyxrQ0FBa0MsQ0FBQztJQUNqRCxDQUFDO0NBQ0Y7QUFFRCxNQUFNLE9BQU8sd0JBQXlCLFNBQVEsZ0JBQWdCO0lBQzVDLEtBQUssQ0FBOEI7SUFFbkQsWUFBWSxJQUFvQjtRQUM5QixLQUFLLENBQUMsSUFBSSxDQUFDLElBQUksSUFBSSxxQkFBcUIsRUFBRSxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDeEQsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDO1FBQ3RCLElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQztJQUMxQixDQUFDO0NBQ0Y7QUFFRCxNQUFNLE9BQU8sa0NBQW1DLFNBQVEsZ0JBQWdCO0lBQ3RFLFlBQVksWUFBb0IsRUFBRSxPQUFzQjtRQUN0RCxLQUFLLENBQUMsMEJBQTBCLEVBQUUsZUFBZSxZQUFZLGlCQUFpQixFQUFFLE9BQU8sQ0FBQyxDQUFDO1FBQ3pGLElBQUksQ0FBQyxJQUFJLEdBQUcsb0NBQW9DLENBQUM7SUFDbkQsQ0FBQztDQUNGO0FBRUQsTUFBTSxPQUFPLCtCQUFnQyxTQUFRLGdCQUFnQjtJQUNuRSxZQUFZLE9BQWU7UUFDekIsS0FBSyxDQUFDLHVCQUF1QixFQUFFLE9BQU8sQ0FBQyxDQUFDO1FBQ3hDLElBQUksQ0FBQyxJQUFJLEdBQUcsaUNBQWlDLENBQUM7SUFDaEQsQ0FBQztDQUNGO0FBRUQsTUFBTSxPQUFPLDZCQUE4QixTQUFRLGdCQUFnQjtJQUNqRCxVQUFVLENBQVM7SUFDbkIsZ0JBQWdCLENBQVM7SUFDekIsY0FBYyxDQUFTO0lBRXZDLFlBQVksVUFBa0IsRUFBRSxnQkFBd0IsRUFBRSxjQUFzQjtRQUM5RSxLQUFLLENBQ0gscUJBQXFCLEVBQ3JCLHNDQUFzQyxVQUFVLHdCQUF3QixnQkFBZ0IsV0FBVyxjQUFjLEdBQUcsQ0FDckgsQ0FBQztRQUNGLElBQUksQ0FBQyxJQUFJLEdBQUcsK0JBQStCLENBQUM7UUFDNUMsSUFBSSxDQUFDLFVBQVUsR0FBRyxVQUFVLENBQUM7UUFDN0IsSUFBSSxDQUFDLGdCQUFnQixHQUFHLGdCQUFnQixDQUFDO1FBQ3pDLElBQUksQ0FBQyxjQUFjLEdBQUcsY0FBYyxDQUFDO0lBQ3ZDLENBQUM7Q0FDRjtBQUVELE1BQU0sT0FBTywyQkFBNEIsU0FBUSxnQkFBZ0I7SUFDL0QsWUFBWSxPQUFlLEVBQUUsT0FBc0I7UUFDakQsS0FBSyxDQUFDLG1CQUFtQixFQUFFLE9BQU8sRUFBRSxPQUFPLENBQUMsQ0FBQztRQUM3QyxJQUFJLENBQUMsSUFBSSxHQUFHLDZCQUE2QixDQUFDO0lBQzVDLENBQUM7Q0FDRjtBQVFELE1BQU0sT0FBTyxvQ0FBcUMsU0FBUSxnQkFBZ0I7SUFDeEQsSUFBSSxDQUFTO0lBQ2IsU0FBUyxDQUE0QjtJQUVyRCxZQUNFLElBQVksRUFDWixTQUFvQyxFQUNwQyxPQUFxQjtRQUVyQixLQUFLLENBQ0gsNkJBQTZCLEVBQzdCLFNBQVMsU0FBUyxRQUFRLElBQUksMERBQTBELEVBQ3hGLE9BQU8sQ0FDUixDQUFDO1FBQ0YsSUFBSSxDQUFDLElBQUksR0FBRyxzQ0FBc0MsQ0FBQztRQUNuRCxJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQztRQUNqQixJQUFJLENBQUMsU0FBUyxHQUFHLFNBQVMsQ0FBQztJQUM3QixDQUFDO0NBQ0Y7QUFFRCxNQUFNLE9BQU8sbUJBQW9CLFNBQVEsY0FBYztJQUNyQyxJQUFJLEdBQUcsaUJBQWlCLENBQUM7SUFFekMsWUFBWSxNQUFpQjtRQUMzQixLQUFLLENBQUMsTUFBTSxFQUFFLHdEQUF3RCxDQUFDLENBQUM7UUFDeEUsSUFBSSxDQUFDLElBQUksR0FBRyxxQkFBcUIsQ0FBQztJQUNwQyxDQUFDO0NBQ0Y7QUFFRCxNQUFNLFVBQVUsV0FBVyxDQUFDLEtBQWM7SUFDeEMsSUFBSSxLQUFLLFlBQVksZ0JBQWdCLEVBQUUsQ0FBQztRQUN0QyxPQUFPO1lBQ0wsSUFBSSxFQUFFLEtBQUssQ0FBQyxJQUFJO1lBQ2hCLE9BQU8sRUFBRSxLQUFLLENBQUMsT0FBTztZQUN0QixJQUFJLEVBQUUsS0FBSyxDQUFDLElBQUk7WUFDaEIsR0FBRyxDQUFDLEtBQUssWUFBWSx3QkFBd0IsSUFBSSxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxFQUFFLEtBQUssRUFBRSxLQUFLLENBQUMsS0FBSyxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztTQUM1RixDQUFDO0lBQ0osQ0FBQztJQUNELElBQUksS0FBSyxZQUFZLEtBQUssRUFBRSxDQUFDO1FBQzNCLE9BQU87WUFDTCxJQUFJLEVBQUUsS0FBSyxDQUFDLElBQUk7WUFDaEIsT0FBTyxFQUFFLEtBQUssQ0FBQyxPQUFPO1lBQ3RCLEdBQUcsQ0FBQyxNQUFNLElBQUksS0FBSyxJQUFJLE9BQU8sS0FBSyxDQUFDLElBQUksS0FBSyxRQUFRLENBQUMsQ0FBQyxDQUFDLEVBQUUsSUFBSSxFQUFFLEtBQUssQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDO1NBQ25GLENBQUM7SUFDSixDQUFDO0lBQ0QsT0FBTztRQUNMLElBQUksRUFBRSxPQUFPO1FBQ2IsT0FBTyxFQUFFLE1BQU0sQ0FBQyxLQUFLLENBQUM7S0FDdkIsQ0FBQztBQUNKLENBQUM7QUFFRCw4RkFBOEY7QUFDOUYsTUFBTSxVQUFVLG1CQUFtQixDQUFDLEtBQWM7SUFDaEQsSUFBSSxDQUFDLE9BQU8sQ0FBQyxpQkFBaUIsQ0FBQyxLQUFLLENBQUM7UUFBRSxPQUFPLFNBQVMsQ0FBQztJQUN4RCxPQUFPO1FBQ0wsSUFBSSxFQUFFLDBCQUEwQjtRQUNoQyxPQUFPLEVBQUUsS0FBSyxDQUFDLE9BQU87UUFDdEIsSUFBSSxFQUFFLG9CQUFvQixDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDO1FBQzVDLEtBQUssRUFBRSxLQUFLLENBQUMsS0FBSztLQUNuQixDQUFDO0FBQ0osQ0FBQztBQUVELE1BQU0sVUFBVSxZQUFZLENBQUMsS0FBYztJQUN6QyxPQUFPLEtBQUssWUFBWSxLQUFLLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQztBQUNoRSxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/functions.toolpermissions.d.ts

@@ -0,0 +1,24 @@
+import * as plugins from './plugins.js';
+import type { IFlexToolProviderContext } from './interfaces.js';
+/** What a tool permission request of one `type` gets: granted, asked of the session's controller, or refused. */
+export type TFlexToolPermissionDecision = 'allow' | 'ask' | 'deny';
+export interface IFlexToolPermissionRequesterOptions {
+    /** The decision per tool request `type`, such as `{ write: 'allow', shell: 'ask' }`. */
+    policy?: Readonly<Record<string, TFlexToolPermissionDecision>>;
+    /** The decision for a type the policy does not name. Defaults to `ask`. */
+    defaultDecision?: TFlexToolPermissionDecision;
+    /**
+     * The key an `always` answer is remembered under for the session. Defaults to the request's type
+     * and a digest of its metadata, so an approval covers exactly the same request again. Return
+     * `undefined` to require an answer for every request.
+     */
+    rememberKey?: (request: plugins.IToolPermissionRequest) => string | undefined;
+}
+/** A tool permission handler, as `IToolExecutionContext.requestPermission` takes it. */
+export type TFlexToolPermissionRequester = (request: plugins.IToolPermissionRequest) => Promise<void>;
+/**
+ * Connects the permission requests of the `/tools` factories (`write`, `delete`, `shell`, ...) to a
+ * FlexHarness run: a request the policy allows passes, one it denies fails the tool call, and every
+ * other one becomes a pending FlexHarness permission the session's controller answers.
+ */
+export declare function createFlexToolPermissionRequester(context: Pick<IFlexToolProviderContext<unknown>, 'requestPermission'>, options?: IFlexToolPermissionRequesterOptions): TFlexToolPermissionRequester;

package/dist_ts/functions.toolpermissions.js

@@ -0,0 +1,38 @@
+import * as plugins from './plugins.js';
+import { FlexHarnessToolPermissionDeniedError } from './errors.js';
+import { normalizeJsonValue } from './utils.json.js';
+const defaultRememberKey = (requestArg) => {
+    const digest = plugins.crypto
+        .createHash('sha256')
+        .update(JSON.stringify(normalizeJsonValue(requestArg.metadata ?? null)))
+        .digest('hex')
+        .slice(0, 32);
+    return `tool:${requestArg.type}:${digest}`;
+};
+/**
+ * Connects the permission requests of the `/tools` factories (`write`, `delete`, `shell`, ...) to a
+ * FlexHarness run: a request the policy allows passes, one it denies fails the tool call, and every
+ * other one becomes a pending FlexHarness permission the session's controller answers.
+ */
+export function createFlexToolPermissionRequester(context, options = {}) {
+    const policy = options.policy ?? {};
+    const defaultDecision = options.defaultDecision ?? 'ask';
+    const rememberKeyOf = options.rememberKey ?? defaultRememberKey;
+    return async (requestArg) => {
+        requestArg.abortSignal?.throwIfAborted();
+        const decision = Object.hasOwn(policy, requestArg.type) ? policy[requestArg.type] : defaultDecision;
+        if (decision === 'allow')
+            return;
+        if (decision === 'deny')
+            throw new FlexHarnessToolPermissionDeniedError(requestArg.type);
+        const rememberKey = rememberKeyOf(requestArg);
+        await context.requestPermission({
+            kind: requestArg.type,
+            description: requestArg.title,
+            ...(requestArg.toolCallId === undefined ? {} : { toolCallId: requestArg.toolCallId }),
+            ...(rememberKey === undefined ? {} : { rememberKey }),
+            ...(requestArg.metadata === undefined ? {} : { metadata: normalizeJsonValue(requestArg.metadata) }),
+        });
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/index.d.ts

@@ -3,6 +3,7 @@ export * from './classes.stores.js';
 export { FlexToolCatalog } from './classes.toolcatalog.js';
 export * from './errors.js';
 export * from './interfaces.js';
+export { createFlexToolPermissionRequester, type IFlexToolPermissionRequesterOptions, type TFlexToolPermissionDecision, type TFlexToolPermissionRequester, } from './functions.toolpermissions.js';
 export { normalizeJsonValue } from './utils.json.js';
 export { assertFlexProjectManagementSnapshot, assertFlexProjectManagementRecord, assertFlexProjectManagementTombstone, createEmptyFlexProjectManagementSnapshot, } from './utils.projectmanagement.js';
 export { FLEX_SLASH_COMMAND_MAX_INPUT_BYTES, isReservedSlashCommandName, isValidSlashCommandName, parseSlashCommand, } from './utils.slashcommands.js';

package/dist_ts/index.js

@@ -3,7 +3,8 @@ export * from './classes.stores.js';
 export { FlexToolCatalog } from './classes.toolcatalog.js';
 export * from './errors.js';
 export * from './interfaces.js';
+export { createFlexToolPermissionRequester, } from './functions.toolpermissions.js';
 export { normalizeJsonValue } from './utils.json.js';
 export { assertFlexProjectManagementSnapshot, assertFlexProjectManagementRecord, assertFlexProjectManagementTombstone, createEmptyFlexProjectManagementSnapshot, } from './utils.projectmanagement.js';
 export { FLEX_SLASH_COMMAND_MAX_INPUT_BYTES, isReservedSlashCommandName, isValidSlashCommandName, parseSlashCommand, } from './utils.slashcommands.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQzNELGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDckQsT0FBTyxFQUNMLG1DQUFtQyxFQUNuQyxpQ0FBaUMsRUFDakMsb0NBQW9DLEVBQ3BDLHdDQUF3QyxHQUN6QyxNQUFNLDhCQUE4QixDQUFDO0FBQ3RDLE9BQU8sRUFDTCxrQ0FBa0MsRUFDbEMsMEJBQTBCLEVBQzFCLHVCQUF1QixFQUN2QixpQkFBaUIsR0FDbEIsTUFBTSwwQkFBMEIsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQzNELGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsT0FBTyxFQUNMLGlDQUFpQyxHQUlsQyxNQUFNLGdDQUFnQyxDQUFDO0FBQ3hDLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQ3JELE9BQU8sRUFDTCxtQ0FBbUMsRUFDbkMsaUNBQWlDLEVBQ2pDLG9DQUFvQyxFQUNwQyx3Q0FBd0MsR0FDekMsTUFBTSw4QkFBOEIsQ0FBQztBQUN0QyxPQUFPLEVBQ0wsa0NBQWtDLEVBQ2xDLDBCQUEwQixFQUMxQix1QkFBdUIsRUFDdkIsaUJBQWlCLEdBQ2xCLE1BQU0sMEJBQTBCLENBQUMifQ==

package/dist_ts/plugins.d.ts

@@ -70,7 +70,7 @@ export interface ICodeSandboxEngine {
 export declare const importCodeSandboxEngine: () => Promise<ICodeSandboxEngine>;
 import { AgentEventStoreConflictError, AgentPendingInputQueue, AgentPendingInputRejectedError, AgentSession, AgentToolCallScheduler, buildModelMessages, ToolJobStoreConflictError, createAgentEvent, filterModelVisibleAgentEvents, getAgentGenerationTransactions, isGenerationInModelContext, modelMessagesToAgentEvents, tool, validateAgentEventArchiveV2, validateAgentEventSnapshotV2, z } from '@modelprofile.com/flexharness-agent';
 export { AgentEventStoreConflictError, AgentPendingInputQueue, AgentPendingInputRejectedError, AgentSession, AgentToolCallScheduler, buildModelMessages, ToolJobStoreConflictError, createAgentEvent, filterModelVisibleAgentEvents, getAgentGenerationTransactions, isGenerationInModelContext, modelMessagesToAgentEvents, tool, validateAgentEventArchiveV2, validateAgentEventSnapshotV2, z, };
-export type { IAgentAppliedInput, ISmartAiCacheDispatch, IAgentEventArchiveV2, IAgentContextCompactionOptions, IAgentEventSnapshotV2, IAgentEventStoreV2, IAgentGenerateResult, IAgentGenerationHandle, IAgentGenerationLease, IAgentRetryEvent, IAgentRunResult, IAgentSession, IAgentSessionOptions, IAgentToolCallUpdateEvent, IAgentToolExecutionOptions, IAgentRuntimeEventPayload, IGenerationBegunEvent, IGenerationExecutionCompletedEvent, IGenerationExecutionStartedEvent, IGenerationOutcomeEvent, IToolExecutionContext, IToolExecutionIntentEvent, IToolJobSnapshot, IToolJobState, IToolJobStore, TAgentContextBuilder, TAgentContextCompactor, TAgentEvent, TAgentGenerationOutcome, TAgentModelCallUsage, TAgentModelCallUsageEvent, TAgentObservedModelCallUsage, TAgentRetryReason, TAgentToolCallFinishEvent, TAgentToolExecutionReconciliationOptions, } from '@modelprofile.com/flexharness-agent';
+export type { IAgentAppliedInput, ISmartAiCacheDispatch, IAgentEventArchiveV2, IAgentContextCompactionOptions, IAgentEventSnapshotV2, IAgentEventStoreV2, IAgentGenerateResult, IAgentGenerationHandle, IAgentGenerationLease, IAgentRetryEvent, IAgentRunResult, IAgentSession, IAgentSessionOptions, IAgentToolCallUpdateEvent, IAgentToolExecutionOptions, IAgentRuntimeEventPayload, IGenerationBegunEvent, IGenerationExecutionCompletedEvent, IGenerationExecutionStartedEvent, IGenerationOutcomeEvent, IToolExecutionContext, IToolExecutionIntentEvent, IToolJobSnapshot, IToolJobState, IToolJobStore, IToolPermissionRequest, TAgentContextBuilder, TAgentContextCompactor, TAgentEvent, TAgentGenerationOutcome, TAgentModelCallUsage, TAgentModelCallUsageEvent, TAgentObservedModelCallUsage, TAgentRetryReason, TAgentToolCallFinishEvent, TAgentToolExecutionReconciliationOptions, } from '@modelprofile.com/flexharness-agent';
 import { getSmartAiCacheWaitMs, isModelLimitError, isModelLimitInfo } from '@modelprofile.com/flexharness-models';
 export { getSmartAiCacheWaitMs, isModelLimitError, isModelLimitInfo };
 export type { IModelLimitInfo } from '@modelprofile.com/flexharness-models';

package/dist_ts/plugins.js

@@ -27,4 +27,4 @@ import { AgentEventStoreConflictError, AgentPendingInputQueue, AgentPendingInput
 export { AgentEventStoreConflictError, AgentPendingInputQueue, AgentPendingInputRejectedError, AgentSession, AgentToolCallScheduler, buildModelMessages, ToolJobStoreConflictError, createAgentEvent, filterModelVisibleAgentEvents, getAgentGenerationTransactions, isGenerationInModelContext, modelMessagesToAgentEvents, tool, validateAgentEventArchiveV2, validateAgentEventSnapshotV2, z, };
 import { getSmartAiCacheWaitMs, isModelLimitError, isModelLimitInfo } from '@modelprofile.com/flexharness-models';
 export { getSmartAiCacheWaitMs, isModelLimitError, isModelLimitInfo };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_chat_harness/classes.chatclient.d.ts

@@ -0,0 +1,95 @@
+import type * as plugins from './plugins.js';
+import type { TJsonValue } from '@modelprofile.com/flexharness';
+import type { IFlexHarnessChatHistoryState, IFlexHarnessChatSessionsPush, IFlexHarnessChatSteerOutcome, IFlexHarnessChatToolRequest, IFlexHarnessChatUpdate, TFlexHarnessChatMethod, TFlexHarnessChatRequest, TFlexHarnessChatResponse } from './interfaces.chat.js';
+/** Where a `FlexHarnessChatClient` hands the hub's pushes. */
+export interface IFlexHarnessChatPushHandlers {
+    update(push: IFlexHarnessChatUpdate): void;
+    sessions(push: IFlexHarnessChatSessionsPush): void;
+    /** Runs a tool of a turn; settles at once when the signal aborts. */
+    tool(request: IFlexHarnessChatToolRequest, abortSignal: AbortSignal | undefined): Promise<TJsonValue>;
+}
+/** The tab's connection to the hub. It names the tab in every request it carries. */
+export interface IFlexHarnessChatClientTransport {
+    request<TMethod extends TFlexHarnessChatMethod>(method: TMethod, request: TFlexHarnessChatRequest<TMethod>): Promise<TFlexHarnessChatResponse<TMethod>>;
+    /** Routes the hub's pushes to the handlers until the returned function is called. */
+    listen(handlers: IFlexHarnessChatPushHandlers): () => void;
+    /** Calls back whenever the connection was lost and is restored, until the returned function is called. */
+    onReconnect(callback: () => void): () => void;
+}
+/** What the chat view learns; every member is optional. */
+export interface IFlexHarnessChatClientListener {
+    /** the tab (re)attached; its conversations, newest first */
+    attached?(sessions: plugins.IHarnessSessionMeta[]): void;
+    sessions?(sessions: plugins.IHarnessSessionMeta[]): void;
+    /** the rows of the open conversation, in order; deltas mutate these objects */
+    rows?(rows: plugins.IHarnessMessage[]): void;
+    delta?(delta: plugins.THarnessStreamDelta): void;
+    status?(status: plugins.IHarnessStatus): void;
+    usage?(usage: plugins.IHarnessUsage): void;
+    permissions?(permissions: plugins.IHarnessPermissionRequest[]): void;
+    history?(history: IFlexHarnessChatHistoryState): void;
+    steer?(outcome: IFlexHarnessChatSteerOutcome): void;
+    /** the open conversation could not be followed again and was closed; the message says why */
+    closed?(message: string): void;
+    /** attaching again after a reconnect failed; the message says why */
+    error?(message: string): void;
+}
+/** Runs one tool of a turn in this tab and answers with what the model reads. */
+export type TFlexHarnessChatToolExecutor = (input: TJsonValue, context: {
+    toolCallId: string;
+    abortSignal?: AbortSignal;
+}) => Promise<TJsonValue>;
+export interface IFlexHarnessChatClientOptions {
+    transport: IFlexHarnessChatClientTransport;
+}
+/**
+ * A tab's side of a `FlexHarnessChatHub`: attaches the tab, follows one conversation through
+ * numbered updates and opens it again after a gap or a reconnect, sends what the composer emits,
+ * and runs the tools of the tab's turns, one after another. `dispose()` releases the transport.
+ */
+export declare class FlexHarnessChatClient {
+    private readonly transport;
+    private readonly tools;
+    private readonly stopListening;
+    private readonly stopWatchingReconnects;
+    private listener;
+    private sessionsById;
+    private open;
+    /** counts opens and closes, so a failed reopen closes only what nothing replaced meanwhile */
+    private openEpoch;
+    /** tools run one after another, so a tool never races the one the model called before it */
+    private toolQueue;
+    private disposed;
+    constructor(optionsArg: IFlexHarnessChatClientOptions);
+    setListener(listenerArg: IFlexHarnessChatClientListener | null): void;
+    /** Runs the named tool when a turn of this tab calls it, until the returned function is called. */
+    registerTool(nameArg: string, executorArg: TFlexHarnessChatToolExecutor): () => void;
+    /** The conversation the tab follows, if any. */
+    get sessionId(): string | null;
+    /** Attaches the tab, and follows its open conversation again. */
+    attach(): Promise<plugins.IHarnessSessionMeta[]>;
+    /** Follows a conversation; its transcript arrives as updates. */
+    openSession(sessionIdArg: string): Promise<TFlexHarnessChatResponse<'flexHarnessChatOpen'>>;
+    /** Stops following the open conversation; the next message starts a new one. */
+    newConversation(): Promise<void>;
+    /** Sends a message to the open conversation, or starts a new one with it. */
+    send(detailArg: plugins.IHarnessComposerSendDetail, contextArg: TJsonValue): Promise<TFlexHarnessChatResponse<'flexHarnessChatSend'>>;
+    abort(): Promise<void>;
+    /** Answers a permission card of the open conversation (`harness-permission-response`). */
+    respondToPermission(detailArg: plugins.IHarnessPermissionResponseDetail): Promise<void>;
+    /** Undoes the open conversation's last turn; the conversation is shown again from a reset. */
+    undo(): Promise<string>;
+    redo(): Promise<string>;
+    renameSession(sessionIdArg: string, titleArg: string): Promise<void>;
+    deleteSession(sessionIdArg: string): Promise<void>;
+    /** Stops taking pushes and reconnects; the tab's tools are no longer run. */
+    dispose(): void;
+    private requireOpenSessionId;
+    private sessionList;
+    private clear;
+    /** Follows the conversation again; when that fails, closes it and says why. */
+    private reopen;
+    private applySessions;
+    private applyUpdate;
+    private runTool;
+}

package/dist_ts_chat_harness/classes.chatclient.js

@@ -0,0 +1,263 @@
+const errorText = (errorArg, fallbackArg) => (errorArg instanceof Error && errorArg.message) || fallbackArg;
+/** 128 random bits as hex; `getRandomValues` works on plain http too, unlike `randomUUID`. */
+const randomId = () => Array.from(globalThis.crypto.getRandomValues(new Uint8Array(16)), (byte) => byte.toString(16).padStart(2, '0')).join('');
+/**
+ * A tab's side of a `FlexHarnessChatHub`: attaches the tab, follows one conversation through
+ * numbered updates and opens it again after a gap or a reconnect, sends what the composer emits,
+ * and runs the tools of the tab's turns, one after another. `dispose()` releases the transport.
+ */
+export class FlexHarnessChatClient {
+    transport;
+    tools = new Map();
+    stopListening;
+    stopWatchingReconnects;
+    listener = null;
+    sessionsById = new Map();
+    open = null;
+    /** counts opens and closes, so a failed reopen closes only what nothing replaced meanwhile */
+    openEpoch = 0;
+    /** tools run one after another, so a tool never races the one the model called before it */
+    toolQueue = Promise.resolve();
+    disposed = false;
+    constructor(optionsArg) {
+        this.transport = optionsArg.transport;
+        this.stopListening = this.transport.listen({
+            update: (pushArg) => this.applyUpdate(pushArg),
+            sessions: (pushArg) => this.applySessions(pushArg),
+            tool: (requestArg, abortSignalArg) => this.runTool(requestArg, abortSignalArg),
+        });
+        this.stopWatchingReconnects = this.transport.onReconnect(() => {
+            void this.attach().catch((error) => this.listener?.error?.(errorText(error, 'The conversation could not be reattached after a reconnect.')));
+        });
+    }
+    setListener(listenerArg) {
+        this.listener = listenerArg;
+    }
+    /** Runs the named tool when a turn of this tab calls it, until the returned function is called. */
+    registerTool(nameArg, executorArg) {
+        this.tools.set(nameArg, executorArg);
+        return () => {
+            if (this.tools.get(nameArg) === executorArg)
+                this.tools.delete(nameArg);
+        };
+    }
+    /** The conversation the tab follows, if any. */
+    get sessionId() {
+        return this.open?.sessionId ?? null;
+    }
+    /** Attaches the tab, and follows its open conversation again. */
+    async attach() {
+        const result = await this.transport.request('flexHarnessChatAttach', {});
+        this.sessionsById = new Map(result.sessions.map((session) => [session.id, session]));
+        // attaching ends the hub's subscription of this tab
+        const reopen = this.open?.sessionId;
+        this.open = null;
+        this.listener?.attached?.(result.sessions);
+        if (reopen && this.sessionsById.has(reopen))
+            await this.reopen(reopen);
+        else if (reopen)
+            this.clear();
+        return result.sessions;
+    }
+    /** Follows a conversation; its transcript arrives as updates. */
+    async openSession(sessionIdArg) {
+        this.openEpoch++;
+        const open = {
+            sessionId: sessionIdArg,
+            subscriptionId: randomId(),
+            nextSeq: 1,
+            rows: new Map(),
+            order: [],
+        };
+        // registered before the request: updates can overtake its answer
+        this.open = open;
+        try {
+            return await this.transport.request('flexHarnessChatOpen', {
+                sessionId: sessionIdArg,
+                subscriptionId: open.subscriptionId,
+            });
+        }
+        catch (error) {
+            if (this.open === open)
+                this.open = null;
+            throw error;
+        }
+    }
+    /** Stops following the open conversation; the next message starts a new one. */
+    async newConversation() {
+        const open = this.open;
+        this.clear();
+        if (open)
+            await this.transport.request('flexHarnessChatClose', { subscriptionId: open.subscriptionId });
+    }
+    /** Sends a message to the open conversation, or starts a new one with it. */
+    async send(detailArg, contextArg) {
+        const sessionId = this.open?.sessionId;
+        const result = await this.transport.request('flexHarnessChatSend', {
+            ...(sessionId ? { sessionId } : {}),
+            send: { delivery: detailArg.delivery, text: detailArg.text, attachments: detailArg.attachments },
+            context: contextArg,
+        });
+        if (result.sessionId !== this.open?.sessionId)
+            await this.openSession(result.sessionId);
+        return result;
+    }
+    async abort() {
+        const sessionId = this.open?.sessionId;
+        if (sessionId)
+            await this.transport.request('flexHarnessChatAbort', { sessionId });
+    }
+    /** Answers a permission card of the open conversation (`harness-permission-response`). */
+    async respondToPermission(detailArg) {
+        // the card reports a remembered approval as `remember`, which FlexHarness calls `always`
+        await this.transport.request('flexHarnessChatPermission', {
+            sessionId: this.requireOpenSessionId(),
+            permissionId: detailArg.requestId,
+            decision: detailArg.response === 'reject' ? 'reject' : detailArg.remember ? 'always' : 'once',
+        });
+    }
+    /** Undoes the open conversation's last turn; the conversation is shown again from a reset. */
+    async undo() {
+        return (await this.transport.request('flexHarnessChatHistory', {
+            sessionId: this.requireOpenSessionId(),
+            direction: 'undo',
+        })).runId;
+    }
+    async redo() {
+        return (await this.transport.request('flexHarnessChatHistory', {
+            sessionId: this.requireOpenSessionId(),
+            direction: 'redo',
+        })).runId;
+    }
+    async renameSession(sessionIdArg, titleArg) {
+        const result = await this.transport.request('flexHarnessChatSessionUpdate', { sessionId: sessionIdArg, title: titleArg });
+        this.sessionsById.set(result.session.id, result.session);
+        this.listener?.sessions?.(this.sessionList());
+    }
+    async deleteSession(sessionIdArg) {
+        await this.transport.request('flexHarnessChatSessionDelete', { sessionId: sessionIdArg });
+        this.sessionsById.delete(sessionIdArg);
+        this.listener?.sessions?.(this.sessionList());
+        if (this.open?.sessionId === sessionIdArg)
+            this.clear();
+    }
+    /** Stops taking pushes and reconnects; the tab's tools are no longer run. */
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.stopListening();
+        this.stopWatchingReconnects();
+        this.tools.clear();
+        this.listener = null;
+        this.open = null;
+    }
+    requireOpenSessionId() {
+        const sessionId = this.open?.sessionId;
+        if (!sessionId)
+            throw new Error('No conversation is open.');
+        return sessionId;
+    }
+    sessionList() {
+        return [...this.sessionsById.values()].sort((left, right) => (right.updatedAt ?? 0) - (left.updatedAt ?? 0));
+    }
+    clear() {
+        this.openEpoch++;
+        this.open = null;
+        this.listener?.rows?.([]);
+        this.listener?.permissions?.([]);
+        this.listener?.status?.({ type: 'idle' });
+        this.listener?.usage?.({});
+    }
+    /** Follows the conversation again; when that fails, closes it and says why. */
+    async reopen(sessionIdArg) {
+        const reopening = this.openSession(sessionIdArg);
+        const epoch = this.openEpoch;
+        try {
+            await reopening;
+        }
+        catch (error) {
+            // another conversation was opened or a new one started meanwhile: that one stays
+            if (this.openEpoch !== epoch)
+                return;
+            this.clear();
+            this.listener?.closed?.(errorText(error, 'The conversation could not be opened again.'));
+        }
+    }
+    applySessions(pushArg) {
+        for (const id of pushArg.deletedIds)
+            this.sessionsById.delete(id);
+        for (const session of pushArg.upserts)
+            this.sessionsById.set(session.id, session);
+        this.listener?.sessions?.(this.sessionList());
+    }
+    applyUpdate(updateArg) {
+        const open = this.open;
+        if (!open || updateArg.subscriptionId !== open.subscriptionId)
+            return;
+        if (updateArg.seq !== open.nextSeq) {
+            // an update was lost: read the conversation again
+            void this.reopen(open.sessionId);
+            return;
+        }
+        open.nextSeq++;
+        if (updateArg.reset)
+            open.rows.clear();
+        if (updateArg.rows) {
+            for (const row of updateArg.rows.upserts)
+                open.rows.set(row.id, row);
+            open.order = updateArg.rows.order;
+            const kept = new Set(open.order);
+            for (const id of [...open.rows.keys()]) {
+                if (!kept.has(id))
+                    open.rows.delete(id);
+            }
+            this.listener?.rows?.(open.order.flatMap((id) => open.rows.get(id) ?? []));
+        }
+        for (const delta of updateArg.deltas ?? [])
+            this.listener?.delta?.(delta);
+        if (updateArg.status)
+            this.listener?.status?.(updateArg.status);
+        if (updateArg.usage)
+            this.listener?.usage?.(updateArg.usage);
+        if (updateArg.permissions)
+            this.listener?.permissions?.(updateArg.permissions);
+        if (updateArg.history)
+            this.listener?.history?.(updateArg.history);
+        for (const steer of updateArg.steers ?? [])
+            this.listener?.steer?.(steer);
+    }
+    runTool(requestArg, abortSignalArg) {
+        const run = this.toolQueue.then(() => {
+            abortSignalArg?.throwIfAborted();
+            const executor = this.tools.get(requestArg.name);
+            if (!executor)
+                throw new Error(`This tab does not run the tool "${requestArg.name}".`);
+            return untilAborted(executor(requestArg.input, {
+                toolCallId: requestArg.toolCallId,
+                ...(abortSignalArg ? { abortSignal: abortSignalArg } : {}),
+            }), abortSignalArg);
+        });
+        this.toolQueue = run.catch(() => undefined);
+        return run;
+    }
+}
+/** The work's result, or a rejection as soon as the signal aborts; the work itself may run on. */
+const untilAborted = (workArg, signalArg) => {
+    if (!signalArg)
+        return workArg;
+    if (signalArg.aborted)
+        return Promise.reject(signalArg.reason ?? new Error('The tool call was cancelled.'));
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(signalArg.reason ?? new Error('The tool call was cancelled.'));
+        signalArg.addEventListener('abort', onAbort, { once: true });
+        workArg.then((value) => {
+            signalArg.removeEventListener('abort', onAbort);
+            resolve(value);
+        }, (error) => {
+            signalArg.removeEventListener('abort', onAbort);
+            reject(error);
+        });
+    });
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.chatclient.js","sourceRoot":"","sources":["../ts_chat_harness/classes.chatclient.ts"],"names":[],"mappings":"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"}

package/dist_ts_chat_harness/classes.chatrequesterror.d.ts

@@ -0,0 +1,4 @@
+/** A chat request the hub refuses; its message is written for the person in the tab. */
+export declare class FlexHarnessChatRequestError extends Error {
+    constructor(message: string);
+}

package/dist_ts_chat_harness/classes.chatrequesterror.js

@@ -0,0 +1,8 @@
+/** A chat request the hub refuses; its message is written for the person in the tab. */
+export class FlexHarnessChatRequestError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'FlexHarnessChatRequestError';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5jaGF0cmVxdWVzdGVycm9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHNfY2hhdF9oYXJuZXNzL2NsYXNzZXMuY2hhdHJlcXVlc3RlcnJvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSx3RkFBd0Y7QUFDeEYsTUFBTSxPQUFPLDJCQUE0QixTQUFRLEtBQUs7SUFDcEQsWUFBWSxPQUFlO1FBQ3pCLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUNmLElBQUksQ0FBQyxJQUFJLEdBQUcsNkJBQTZCLENBQUM7SUFDNUMsQ0FBQztDQUNGIn0=

package/dist_ts_chat_harness/classes.transcript.d.ts

@@ -1,5 +1,5 @@
 import type * as plugins from './plugins.js';
-import type { IFlexMessage, IFlexPermissionRequest, IFlexProjectStateResult, IFlexSession, TFlexHarnessEvent } from '../dist_ts/interfaces.js';
+import type { IFlexMessage, IFlexPermissionRequest, IFlexProjectStateResult, IFlexSession, TFlexHarnessEvent } from '@modelprofile.com/flexharness';
 export interface IFlexHarnessTranscriptOptions {
     scopeId: string;
     sessionId: string;