@modelprofile.com/flexharness 10.13.0 → 10.14.0

package/dist_ts/00_commitinfo_data.js

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

package/dist_ts/classes.codesandbox.d.ts

@@ -0,0 +1,39 @@
+import type { IFlexCodeModeLimits, IFlexCodeRunFailure, TJsonValue } from './interfaces.js';
+/** What one catalog call of a program comes to: a JSON value, or the error the program sees. */
+export type TFlexCodeCallOutcome = {
+    ok: true;
+    value: TJsonValue;
+} | {
+    ok: false;
+    error: TJsonValue;
+};
+export interface IFlexCodeHost {
+    /**
+     * Runs one catalog call of the program; `signal` aborts when the program stops. A rejection is a
+     * failure of the host, which stops the program and rejects `run()` with it.
+     */
+    call(method: string, params: unknown, signal: AbortSignal): Promise<TFlexCodeCallOutcome>;
+    /** Milliseconds the program has waited for permission decisions; they do not count as wall time. */
+    waitedMs?(): number;
+}
+export type TFlexCodeRunResult = {
+    ok: true;
+    value: TJsonValue;
+    calls: number;
+    logs?: string;
+} | {
+    ok: false;
+    failure: IFlexCodeRunFailure;
+};
+/**
+ * Runs `run_code` programs in QuickJS-ng compiled to WebAssembly: every program in a WebAssembly
+ * instance of its own, with no globals beyond the language, `api`, `ApiError` and `console`, and
+ * every limit of `IFlexCodeModeLimits` enforced. Program types are stripped with amaro first.
+ */
+export declare class FlexCodeSandbox {
+    private readonly engine;
+    private constructor();
+    /** Loads QuickJS and amaro, once per process. */
+    static load(): Promise<FlexCodeSandbox>;
+    run(source: string, host: IFlexCodeHost, limits: Readonly<IFlexCodeModeLimits>, signal?: AbortSignal): Promise<TFlexCodeRunResult>;
+}

package/dist_ts/classes.codesandbox.js

@@ -0,0 +1,539 @@
+import * as plugins from './plugins.js';
+import { FlexHarnessValidationError } from './errors.js';
+const programFile = 'program.ts';
+/** How long calls in flight get to settle after their program stopped and their signal aborted. */
+const stopGraceMs = 5_000;
+const programPrefix = 'globalThis.__flexMain = async function () {\n';
+const programSuffix = '\n};';
+/**
+ * Runs in the context before the program: it takes the host functions off the global object and
+ * defines `api`, `ApiError` and `console`. Only strings cross the boundary.
+ */
+const prelude = `'use strict';
+(() => {
+  const call = globalThis.__flexCall;
+  const log = globalThis.__flexLog;
+  const done = globalThis.__flexDone;
+  delete globalThis.__flexCall;
+  delete globalThis.__flexLog;
+  delete globalThis.__flexDone;
+  class ApiError extends Error {
+    constructor(details) {
+      const message = details && typeof details.message === 'string' ? details.message : JSON.stringify(details);
+      super(message);
+      this.name = 'ApiError';
+      this.details = details;
+    }
+  }
+  const invoke = (path, args) => {
+    if (!path) return Promise.reject(new TypeError('Call a method as api.<namespace>.<method>(params).'));
+    let params;
+    try {
+      params = JSON.stringify(args.length === 0 || args[0] === undefined ? {} : args[0]);
+    } catch (error) {
+      return Promise.reject(new TypeError('The params of ' + path + ' are not JSON: ' + error.message));
+    }
+    return call(path, params === undefined ? 'null' : params).then((text) => {
+      const outcome = JSON.parse(text);
+      if (outcome.ok) return outcome.value;
+      throw new ApiError(outcome.error);
+    });
+  };
+  const target = (path) => new Proxy(function () {}, {
+    get: (_target, key) => typeof key === 'string' && key !== 'then' ? target(path ? path + '.' + key : key) : undefined,
+    apply: (_target, _this, args) => invoke(path, args),
+    set: () => false,
+    defineProperty: () => false,
+    deleteProperty: () => false,
+  });
+  const format = (value) => {
+    if (typeof value === 'string') return value;
+    try {
+      const text = JSON.stringify(value);
+      return text === undefined ? String(value) : text;
+    } catch {
+      return String(value);
+    }
+  };
+  const writer = (level) => (...values) => { log(level, values.map(format).join(' ')); };
+  const fixed = (value) => ({ value, enumerable: false, writable: false, configurable: false });
+  Object.defineProperty(globalThis, 'api', fixed(target('')));
+  Object.defineProperty(globalThis, 'ApiError', fixed(ApiError));
+  Object.defineProperty(globalThis, 'console', fixed(Object.freeze({
+    log: writer('log'), info: writer('info'), warn: writer('warn'), error: writer('error'), debug: writer('debug'),
+  })));
+  const settle = (value) => {
+    try {
+      const text = JSON.stringify({ ok: true, value: value === undefined ? null : value });
+      return text === undefined ? JSON.stringify({ ok: true, value: null }) : text;
+    } catch (error) {
+      return JSON.stringify({ ok: false, name: 'TypeError', message: 'The return value is not JSON: ' + error.message });
+    }
+  };
+  const fail = (error) => JSON.stringify({
+    ok: false,
+    name: error && typeof error.name === 'string' ? error.name : 'Error',
+    message: error && typeof error.message === 'string' ? error.message : String(error),
+    stack: error && typeof error.stack === 'string' ? error.stack : '',
+    ...(error instanceof ApiError ? { details: error.details } : {}),
+  });
+  Object.defineProperty(globalThis, '__flexStart', {
+    configurable: true,
+    value: () => {
+      const main = globalThis.__flexMain;
+      delete globalThis.__flexStart;
+      delete globalThis.__flexMain;
+      main().then(settle, fail).then(done);
+    },
+  });
+})();
+`;
+let enginePromise;
+/**
+ * Runs `run_code` programs in QuickJS-ng compiled to WebAssembly: every program in a WebAssembly
+ * instance of its own, with no globals beyond the language, `api`, `ApiError` and `console`, and
+ * every limit of `IFlexCodeModeLimits` enforced. Program types are stripped with amaro first.
+ */
+export class FlexCodeSandbox {
+    engine;
+    constructor(engine) {
+        this.engine = engine;
+    }
+    /** Loads QuickJS and amaro, once per process. */
+    static async load() {
+        enginePromise ??= plugins.importCodeSandboxEngine().catch((error) => {
+            enginePromise = undefined;
+            throw new FlexHarnessValidationError('Code mode needs the optional peers quickjs-emscripten-core, '
+                + '@jitl/quickjs-ng-wasmfile-release-sync and amaro.', { cause: error });
+        });
+        return new FlexCodeSandbox(await enginePromise);
+    }
+    run(source, host, limits, signal) {
+        return new CodeRun(this.engine, source, host, limits, signal).start();
+    }
+}
+class CodeRun {
+    engine;
+    source;
+    host;
+    limits;
+    signal;
+    runtime;
+    vm;
+    deferreds = new Set();
+    calls = new AbortController();
+    queue = [];
+    /** Host calls in flight; the run settles only after every one of them did. */
+    inFlight = new Set();
+    running = 0;
+    callCount = 0;
+    cpuMs = 0;
+    enteredAt;
+    stop;
+    logs = '';
+    logBytes = 0;
+    logsCut = false;
+    settle;
+    reject;
+    /** The outcome is decided; the run waits for its calls in flight, then settles. */
+    closing = false;
+    finished = false;
+    broken = false;
+    wallTimer;
+    startedAt = performance.now();
+    constructor(engine, source, host, limits, signal) {
+        this.engine = engine;
+        this.source = source;
+        this.host = host;
+        this.limits = limits;
+        this.signal = signal;
+    }
+    async start() {
+        if (Buffer.byteLength(this.source, 'utf8') > this.limits.maxSourceBytes) {
+            return this.failure({
+                error: 'limit_exceeded',
+                limit: 'source',
+                message: `The program is longer than ${this.limits.maxSourceBytes} bytes.`,
+            });
+        }
+        try {
+            this.program = this.engine.stripTypes(`${programPrefix}${this.source}${programSuffix}`);
+        }
+        catch (error) {
+            const reported = (error ?? {});
+            return this.failure({
+                error: 'syntax_error',
+                message: typeof reported.message === 'string' ? reported.message : 'The program cannot be parsed.',
+                ...(typeof reported.startLine === 'number' && reported.startLine > 1 ? { line: reported.startLine - 1 } : {}),
+            });
+        }
+        const outcome = new Promise((resolve, reject) => {
+            this.settle = resolve;
+            this.reject = reject;
+        });
+        const onAbort = () => this.halt({ kind: 'aborted', message: 'The program was stopped.' });
+        this.signal?.addEventListener('abort', onAbort, { once: true });
+        try {
+            const module = await this.engine.newModule();
+            // QuickJS runs on the host's stack too: start it from a fresh, shallow one.
+            await new Promise((resolve) => setImmediate(resolve));
+            if (this.signal?.aborted)
+                onAbort();
+            else {
+                this.armWallTimer();
+                this.boot(module);
+            }
+            return await outcome;
+        }
+        finally {
+            this.signal?.removeEventListener('abort', onAbort);
+            this.dispose();
+        }
+    }
+    program = '';
+    boot(module) {
+        const runtime = module.newRuntime();
+        this.runtime = runtime;
+        runtime.setMemoryLimit(this.limits.memoryBytes);
+        runtime.setMaxStackSize(this.limits.stackBytes);
+        runtime.setInterruptHandler(() => this.interrupted());
+        const vm = runtime.newContext();
+        this.vm = vm;
+        this.define('__flexCall', (pathHandle, paramsHandle) => this.bridgeCall(vm.getString(pathHandle), vm.getString(paramsHandle)));
+        this.define('__flexLog', (levelHandle, textHandle) => {
+            this.log(vm.getString(levelHandle), vm.getString(textHandle));
+        });
+        this.define('__flexDone', (textHandle) => {
+            this.complete(vm.getString(textHandle));
+        });
+        if (!this.evaluate(prelude, 'prelude.js', 'prelude'))
+            return;
+        if (!this.evaluate(this.program, programFile, 'parse'))
+            return;
+        if (!this.evaluate('__flexStart();', 'start.js', 'program'))
+            return;
+        this.pump();
+    }
+    define(name, implementation) {
+        const handle = this.vm.newFunction(name, implementation);
+        this.vm.setProp(this.vm.global, name, handle);
+        handle.dispose();
+    }
+    evaluate(code, file, phase) {
+        if (this.closing)
+            return false;
+        let result;
+        this.enter();
+        try {
+            result = this.vm.evalCode(code, file);
+        }
+        catch (error) {
+            this.hostThrow(error);
+            return false;
+        }
+        finally {
+            this.leave();
+        }
+        if (result.error) {
+            this.failWith(result.error, phase);
+            return false;
+        }
+        result.value.dispose();
+        return true;
+    }
+    /** Runs the program's pending jobs after a call settled or the program started. */
+    pump() {
+        if (this.closing || !this.runtime?.alive)
+            return;
+        let result;
+        this.enter();
+        try {
+            result = this.runtime.executePendingJobs();
+        }
+        catch (error) {
+            this.hostThrow(error);
+            return;
+        }
+        finally {
+            this.leave();
+        }
+        if (result.error)
+            this.failWith(result.error, 'program');
+    }
+    /**
+     * An exception out of the WebAssembly instance: the host's stack ran out under deep recursion, or
+     * the instance failed. Its state is not trusted afterwards; `dispose()` abandons it.
+     */
+    hostThrow(error) {
+        this.broken = true;
+        if (error instanceof RangeError) {
+            this.halt({ kind: 'limit', limit: 'stack', message: 'The program exceeded its stack.' });
+            return;
+        }
+        this.halt({ kind: 'host', error });
+    }
+    enter() {
+        this.enteredAt = performance.now();
+    }
+    leave() {
+        if (this.enteredAt === undefined)
+            return;
+        this.cpuMs += performance.now() - this.enteredAt;
+        this.enteredAt = undefined;
+    }
+    interrupted() {
+        if (this.stop)
+            return true;
+        if (this.enteredAt !== undefined && this.cpuMs + performance.now() - this.enteredAt > this.limits.cpuMs) {
+            this.stop = { kind: 'limit', limit: 'cpu', message: `The program computed for more than ${this.limits.cpuMs} ms.` };
+            return true;
+        }
+        return false;
+    }
+    bridgeCall(method, paramsText) {
+        const deferred = this.vm.newPromise();
+        this.deferreds.add(deferred);
+        this.callCount += 1;
+        if (this.callCount > this.limits.maxCalls) {
+            this.halt({
+                kind: 'limit',
+                limit: 'calls',
+                message: `The program made more than ${this.limits.maxCalls} calls.`,
+            });
+            return deferred.handle;
+        }
+        let params;
+        try {
+            params = JSON.parse(paramsText);
+        }
+        catch {
+            params = undefined;
+        }
+        const run = () => {
+            if (this.closing)
+                return;
+            this.running += 1;
+            // A settled call stops counting before the program sees its answer, which may end the program.
+            const settled = () => {
+                this.running -= 1;
+                this.inFlight.delete(call);
+            };
+            const call = this.host.call(method, params, this.calls.signal).then((outcome) => {
+                settled();
+                this.answer(deferred, outcome);
+            }, (error) => {
+                settled();
+                this.halt({ kind: 'host', error });
+            }).finally(() => this.queue.shift()?.());
+            this.inFlight.add(call);
+        };
+        if (this.running < this.limits.maxConcurrentCalls)
+            run();
+        else
+            this.queue.push(run);
+        return deferred.handle;
+    }
+    answer(deferred, outcome) {
+        if (this.closing || !deferred.alive)
+            return;
+        let text;
+        try {
+            text = JSON.stringify(outcome);
+        }
+        catch {
+            text = JSON.stringify({ ok: false, error: { error: 'failed', message: 'The result is not JSON.' } });
+        }
+        const value = this.vm.newString(text);
+        deferred.resolve(value);
+        value.dispose();
+        this.deferreds.delete(deferred);
+        this.pump();
+    }
+    log(level, text) {
+        if (this.logsCut || this.closing)
+            return;
+        const line = `${level === 'log' ? '' : `[${level}] `}${text}\n`;
+        const bytes = Buffer.byteLength(line, 'utf8');
+        if (this.logBytes + bytes > this.limits.maxLogBytes) {
+            this.logsCut = true;
+            this.logs += '[console output cut off]\n';
+            return;
+        }
+        this.logBytes += bytes;
+        this.logs += line;
+    }
+    complete(text) {
+        if (this.closing)
+            return;
+        let outcome;
+        try {
+            outcome = JSON.parse(text);
+        }
+        catch {
+            outcome = { ok: false, name: 'Error', message: 'The program ended without a result.' };
+        }
+        if (outcome.ok) {
+            const unawaited = this.running + this.queue.length;
+            if (unawaited > 0) {
+                // Calls the program did not await are not part of its result: it fails, and proposes nothing.
+                this.done(this.failure({
+                    error: 'program_error',
+                    message: `The program returned with ${unawaited} call${unawaited === 1 ? '' : 's'} it did not await; await every call.`,
+                }));
+                return;
+            }
+            this.done({
+                ok: true,
+                value: outcome.value ?? null,
+                calls: Math.min(this.callCount, this.limits.maxCalls),
+                ...(this.logs ? { logs: this.logs } : {}),
+            });
+            return;
+        }
+        this.done(this.failure(this.classify(outcome, 'program')));
+    }
+    failWith(handle, phase) {
+        let dumped;
+        // Reading the thrown value can run program code, such as a toJSON: it counts as computing.
+        this.enter();
+        try {
+            dumped = this.vm.dump(handle);
+        }
+        catch (error) {
+            if (!(error instanceof Error) || error instanceof RangeError)
+                this.broken = true;
+            dumped = undefined;
+        }
+        finally {
+            this.leave();
+            if (!this.broken && handle.alive)
+                handle.dispose();
+        }
+        if (phase === 'prelude' && !this.stop) {
+            this.halt({ kind: 'host', error: new Error(`The code mode prelude failed: ${JSON.stringify(dumped)}`) });
+            return;
+        }
+        const error = (dumped && typeof dumped === 'object' ? dumped : { message: String(dumped) });
+        this.done(this.failure(this.classify(error, phase)));
+    }
+    classify(error, phase) {
+        if (this.stop?.kind === 'limit')
+            return { error: 'limit_exceeded', limit: this.stop.limit, message: this.stop.message };
+        if (this.stop?.kind === 'aborted')
+            return { error: 'aborted', message: this.stop.message };
+        const message = typeof error.message === 'string' ? error.message : 'The program failed.';
+        if (error.name === 'InternalError' && message === 'out of memory') {
+            return { error: 'limit_exceeded', limit: 'memory', message: `The program used more than ${this.limits.memoryBytes} bytes of memory.` };
+        }
+        if ((error.name === 'InternalError' && message === 'stack overflow')
+            || (error.name === 'RangeError' && message === 'Maximum call stack size exceeded')) {
+            return { error: 'limit_exceeded', limit: 'stack', message: 'The program exceeded its stack.' };
+        }
+        if (error.name === 'InternalError' && message === 'interrupted') {
+            return { error: 'limit_exceeded', limit: 'cpu', message: `The program computed for more than ${this.limits.cpuMs} ms.` };
+        }
+        const line = /program\.ts:(\d+)/.exec(error.stack ?? '')?.[1];
+        return {
+            error: phase === 'parse' && error.name === 'SyntaxError' ? 'syntax_error' : 'program_error',
+            ...(typeof error.name === 'string' ? { name: error.name } : {}),
+            message,
+            ...(line && Number(line) > 1 ? { line: Number(line) - 1 } : {}),
+        };
+    }
+    failure(failure) {
+        return {
+            ok: false,
+            failure: {
+                ...failure,
+                calls: Math.min(this.callCount, this.limits.maxCalls),
+                ...(this.logs ? { logs: this.logs } : {}),
+            },
+        };
+    }
+    /** Stops the program from outside it: a limit, an abort, or a failure of the host. */
+    halt(stop) {
+        if (this.closing)
+            return;
+        this.stop ??= stop;
+        const reason = this.stop;
+        if (reason.kind === 'host') {
+            this.close(() => this.reject(reason.error));
+            return;
+        }
+        this.done(this.failure(reason.kind === 'limit'
+            ? { error: 'limit_exceeded', limit: reason.limit, message: reason.message }
+            : { error: 'aborted', message: reason.message }));
+    }
+    done(result) {
+        this.close(() => this.settle(result));
+    }
+    /**
+     * Decides the run's outcome. Calls not started yet never start. Calls in flight are told to stop
+     * through their signal, and the outcome is delivered once they settled, so no call runs on after
+     * its program; a host call that ignores its signal gets `stopGraceMs`, and its answer is dropped.
+     */
+    close(deliver) {
+        if (this.closing)
+            return;
+        this.closing = true;
+        this.queue.length = 0;
+        if (this.inFlight.size === 0) {
+            this.finished = true;
+            deliver();
+            return;
+        }
+        this.calls.abort();
+        let grace;
+        void Promise.race([
+            Promise.allSettled([...this.inFlight]),
+            new Promise((resolve) => {
+                grace = setTimeout(resolve, stopGraceMs);
+            }),
+        ]).then(() => {
+            clearTimeout(grace);
+            this.finished = true;
+            deliver();
+        });
+    }
+    armWallTimer() {
+        const check = () => {
+            if (this.closing)
+                return;
+            const elapsed = performance.now() - this.startedAt - (this.host.waitedMs?.() ?? 0);
+            if (elapsed > this.limits.wallMs) {
+                this.halt({ kind: 'limit', limit: 'wall', message: `The program ran for more than ${this.limits.wallMs} ms.` });
+                return;
+            }
+            this.wallTimer = setTimeout(check, Math.max(10, Math.min(250, this.limits.wallMs - elapsed)));
+        };
+        this.wallTimer = setTimeout(check, Math.max(10, Math.min(250, this.limits.wallMs)));
+    }
+    /**
+     * Frees the program's runtime. An instance that threw, or whose runtime cannot be freed after a
+     * stack overflow left objects behind, is abandoned instead: it is the program's own, and garbage
+     * collection reclaims its memory.
+     */
+    dispose() {
+        this.closing = true;
+        this.finished = true;
+        if (this.wallTimer)
+            clearTimeout(this.wallTimer);
+        this.queue.length = 0;
+        this.calls.abort();
+        if (this.broken)
+            return;
+        try {
+            for (const deferred of this.deferreds)
+                if (deferred.alive)
+                    deferred.dispose();
+            this.deferreds.clear();
+            this.vm?.dispose();
+            if (this.runtime?.alive)
+                this.runtime.dispose();
+        }
+        catch {
+            this.broken = true;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.codesandbox.js","sourceRoot":"","sources":["../ts/classes.codesandbox.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.flexharness.d.ts

@@ -252,6 +252,16 @@ export declare class FlexHarness<TScope = unknown> {
      * call's part, events and permission requests carry the method's path.
      */
     private createCatalogTools;
+    /** A refused catalog call as the trusted error the model and the tool part show. */
+    private catalogCallError;
+    /**
+     * Runs a `run_code` program. Every catalog call it makes is dispatched like an `execute`
+     * (validation, `onCall`, the method's run with its permission requests, the output limits, error
+     * projection) and recorded as a tool part of its own, named by the method, with the `run_code`
+     * call as its parent. Proposals go to `onProposals` as one batch once the program finished; a
+     * program that fails proposes nothing.
+     */
+    private runCatalogProgram;
     private createBuiltInTools;
     private createRenameSessionTool;
     private createProjectTaskTool;