@modelprofile.com/flexharness 10.23.0 → 10.24.1

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

@@ -0,0 +1,53 @@
+import { type IFlexUncertainToolExecution, type TFlexAgentToolSet, type TFlexToolExecutionReconciliation } from './interfaces.js';
+import { FlexToolCatalog } from './classes.toolcatalog.js';
+import type { IActiveRun } from './interfaces.flexharness.js';
+import type { FlexHarnessCore } from './classes.flexharness.core.js';
+/**
+ * Tool call dispatch: read-only classification, call tracking, reconciliation and the tool catalog.
+ */
+export declare class FlexHarnessToolDispatch<TScope> {
+    private readonly core;
+    constructor(core: FlexHarnessCore<TScope>);
+    listUncertainToolExecutions(scopeId: string, sessionId: string): Promise<IFlexUncertainToolExecution[]>;
+    reconcileToolExecution(scopeId: string, sessionId: string, intentId: string, reconciliation: TFlexToolExecutionReconciliation): Promise<void>;
+    /**
+     * Whether a call of the run's tools only reads: search_tools and describe_tools, an `execute` of
+     * a method declared read-only, or a call the tool handle classifies as read-only by its real name.
+     */
+    isReadOnlyToolCall(run: IActiveRun, toolName: string, input: unknown): boolean;
+    /** The method's path when the prepared call only reads, for the turn's reads. */
+    private readOnlyMethod;
+    /** A method whose `onCall` decides its calls is gated: its calls run in order, whatever they read. */
+    private isReadOnlyCatalogCall;
+    private classifyHostToolCall;
+    /**
+     * Runs the run's tools through the turn's reads: a read-only call identical to an earlier read of
+     * the turn shares its output, and any other call clears them. Records the confirmation of each
+     * call that started while the model still streamed, which the permission requests naming the
+     * call wait for. The catalog's tools read and run their methods by real name themselves.
+     */
+    trackToolCalls(run: IActiveRun, tools: TFlexAgentToolSet): TFlexAgentToolSet;
+    /**
+     * Answers a read-only call (`name` set) from an identical read earlier in the turn, sharing the
+     * output of one still running, or runs it and keeps its output for the reads after it. A failed
+     * read, and a read whose response was discarded, are not kept. Any other call clears the turn's
+     * reads before it runs.
+     */
+    private readOnce;
+    /**
+     * search_tools, describe_tools and execute. `execute` validates the call and runs the method
+     * inside this tool call, so the tool wrapper bounds its output and projects its errors, and the
+     * call's part, events and permission requests carry the method's path.
+     */
+    createCatalogTools(run: IActiveRun, catalog: FlexToolCatalog<unknown>): Record<string, unknown>;
+    /** 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;
+}

package/dist_ts/classes.flexharness.tooldispatch.js

@@ -0,0 +1,418 @@
+import * as plugins from './plugins.js';
+import { FlexHarnessValidationError } from './errors.js';
+import { FLEX_CODE_MODE_TOOL_NAME, FLEX_RESULT_METHOD, FLEX_TOOL_CATALOG_TOOL_NAMES, } from './interfaces.js';
+import { FlexToolCatalog, catalogToolInputSchema } from './classes.toolcatalog.js';
+import { canonicalJson, normalizeJsonValue } from './utils.json.js';
+import { maxTransferMetadataBytes, publicSnapshot, requireTransferIdentifier, truncateUtf8, } from './utils.transfer.js';
+import { isAsyncIterable, settleToolOutput } from './utils.tooloutput.js';
+import { validateIdentifier } from './utils.validation.js';
+const notShared = Symbol('not shared');
+/**
+ * Tool call dispatch: read-only classification, call tracking, reconciliation and the tool catalog.
+ */
+export class FlexHarnessToolDispatch {
+    core;
+    constructor(core) {
+        this.core = core;
+    }
+    async listUncertainToolExecutions(scopeId, sessionId) {
+        const { state } = await this.core.resolveState(scopeId);
+        const stored = this.core.requireSession(state, sessionId);
+        this.core.assertStateAcceptingWork(state);
+        try {
+            return publicSnapshot(stored.agentSession.listUncertainToolExecutions().map((intent) => ({
+                intentId: this.core.boundedIdentifier(intent.id, 'intentId'),
+                generationId: this.core.boundedIdentifier(intent.generationId, 'generationId'),
+                toolCallId: this.core.boundedIdentifier(intent.toolCallId, 'toolCallId'),
+                toolName: this.core.boundedIdentifier(intent.toolName, 'toolName'),
+                input: normalizeJsonValue(intent.input, this.core.toolOutputLimits),
+                timestamp: new Date(intent.timestamp).toISOString(),
+            })));
+        }
+        catch (error) {
+            throw this.core.projectOperationError(error, 'agentSession', scopeId, sessionId, 'uncertain-tools');
+        }
+    }
+    async reconcileToolExecution(scopeId, sessionId, intentId, reconciliation) {
+        validateIdentifier(intentId, 'intentId');
+        requireTransferIdentifier(intentId, 'intentId');
+        if (!reconciliation || typeof reconciliation !== 'object' || Array.isArray(reconciliation)) {
+            throw new FlexHarnessValidationError('Tool execution reconciliation must be a plain object.');
+        }
+        const { scope, state } = await this.core.resolveState(scopeId);
+        const stored = this.core.requireSession(state, sessionId);
+        this.core.assertSessionWritable(stored);
+        this.core.assertStateAcceptingWork(state);
+        let canonical;
+        if (reconciliation.resolution === 'executed') {
+            const output = normalizeJsonValue(reconciliation.output, this.core.toolOutputLimits);
+            canonical = { resolution: 'executed', output, modelOutput: { type: 'json', value: output } };
+        }
+        else if (reconciliation.resolution === 'not-executed'
+            || reconciliation.resolution === 'abandoned-unknown') {
+            if (reconciliation.error !== undefined && typeof reconciliation.error !== 'string') {
+                throw new FlexHarnessValidationError('Reconciliation error must be a string.');
+            }
+            canonical = {
+                resolution: reconciliation.resolution,
+                ...(reconciliation.error === undefined
+                    ? {}
+                    : { error: truncateUtf8(reconciliation.error, maxTransferMetadataBytes) }),
+            };
+        }
+        else {
+            throw new FlexHarnessValidationError('Unknown tool execution reconciliation.');
+        }
+        try {
+            await this.core.compaction.withCompactorContext(this.core.compaction.createCompactorContext(scopeId, scope.scope, state.storageKey, sessionId), () => stored.agentSession.reconcileToolExecution(intentId, canonical));
+        }
+        catch (error) {
+            throw this.core.projectOperationError(error, 'agentSession', scopeId, sessionId, 'tool-reconciliation');
+        }
+    }
+    /**
+     * Whether a call of the run's tools only reads: search_tools and describe_tools, an `execute` of
+     * a method declared read-only, or a call the tool handle classifies as read-only by its real name.
+     */
+    isReadOnlyToolCall(run, toolName, input) {
+        const names = FLEX_TOOL_CATALOG_TOOL_NAMES;
+        const catalog = run.toolCatalog;
+        if (catalog) {
+            if (toolName === names.search || toolName === names.describe)
+                return true;
+            if (toolName === names.execute) {
+                const target = catalog.callTarget(input);
+                return target !== undefined && this.isReadOnlyCatalogCall(run, catalog, target.method, target.params);
+            }
+            if (toolName === FLEX_CODE_MODE_TOOL_NAME)
+                return false;
+        }
+        if (this.core.runs.enabledBuiltInToolNames(run).has(toolName))
+            return false;
+        return this.classifyHostToolCall(run, toolName, input);
+    }
+    /** The method's path when the prepared call only reads, for the turn's reads. */
+    readOnlyMethod(run, catalog, call) {
+        return this.isReadOnlyCatalogCall(run, catalog, call.method, call.params) ? call.method : undefined;
+    }
+    /** A method whose `onCall` decides its calls is gated: its calls run in order, whatever they read. */
+    isReadOnlyCatalogCall(run, catalog, method, params) {
+        return !catalog.decides(method)
+            && (catalog.isReadOnly(method) || this.classifyHostToolCall(run, method, params));
+    }
+    classifyHostToolCall(run, toolName, input) {
+        try {
+            return run.isReadOnlyHostCall?.({ toolName, input }) === true;
+        }
+        catch (error) {
+            throw this.core.projectExternalError(run, error, 'toolProvider');
+        }
+    }
+    /**
+     * Runs the run's tools through the turn's reads: a read-only call identical to an earlier read of
+     * the turn shares its output, and any other call clears them. Records the confirmation of each
+     * call that started while the model still streamed, which the permission requests naming the
+     * call wait for. The catalog's tools read and run their methods by real name themselves.
+     */
+    trackToolCalls(run, tools) {
+        const catalogTools = new Set(run.toolCatalog
+            ? [...Object.values(FLEX_TOOL_CATALOG_TOOL_NAMES), FLEX_CODE_MODE_TOOL_NAME]
+            : []);
+        const tracked = {};
+        for (const [name, tool] of Object.entries(tools)) {
+            const execute = tool.execute;
+            if (typeof execute !== 'function') {
+                tracked[name] = tool;
+                continue;
+            }
+            tracked[name] = {
+                ...tool,
+                execute: (input, options) => {
+                    const confirmed = options?.confirmed;
+                    const toolCallId = options?.toolCallId ?? '';
+                    if (confirmed && toolCallId) {
+                        run.unconfirmedToolCalls.set(toolCallId, confirmed);
+                        const forget = () => run.unconfirmedToolCalls.delete(toolCallId);
+                        confirmed.then(forget, forget);
+                    }
+                    const executeTool = () => execute.call(tool, input, options);
+                    if (catalogTools.has(name))
+                        return executeTool();
+                    const readName = this.isReadOnlyToolCall(run, name, input) ? name : undefined;
+                    return this.readOnce(run, toolCallId, readName, input, confirmed, executeTool);
+                },
+            };
+        }
+        return tracked;
+    }
+    /**
+     * Answers a read-only call (`name` set) from an identical read earlier in the turn, sharing the
+     * output of one still running, or runs it and keeps its output for the reads after it. A failed
+     * read, and a read whose response was discarded, are not kept. Any other call clears the turn's
+     * reads before it runs.
+     */
+    readOnce(run, toolCallId, name, params, confirmed, execute) {
+        if (name === undefined) {
+            run.readCalls.clear();
+            return execute();
+        }
+        const canonicalParams = canonicalJson(params);
+        if (canonicalParams === undefined)
+            return execute();
+        const key = `${name}\n${canonicalParams}`;
+        const earlier = run.readCalls.get(key);
+        if (earlier) {
+            return earlier.output.then((output) => {
+                if (output === notShared)
+                    return execute();
+                run.deduplicatedToolCalls.set(toolCallId, earlier.toolCallId);
+                return output;
+            }, (error) => {
+                run.deduplicatedToolCalls.set(toolCallId, earlier.toolCallId);
+                throw error;
+            });
+        }
+        const result = execute();
+        const entry = {
+            toolCallId,
+            output: Promise.resolve(result).then((output) => isAsyncIterable(output) ? notShared : output),
+        };
+        run.readCalls.set(key, entry);
+        const forget = () => {
+            if (run.readCalls.get(key) === entry)
+                run.readCalls.delete(key);
+        };
+        entry.output.catch(forget);
+        confirmed?.catch(forget);
+        return result;
+    }
+    /**
+     * search_tools, describe_tools and execute. `execute` validates the call and runs the method
+     * inside this tool call, so the tool wrapper bounds its output and projects its errors, and the
+     * call's part, events and permission requests carry the method's path.
+     */
+    createCatalogTools(run, catalog) {
+        const names = FLEX_TOOL_CATALOG_TOOL_NAMES;
+        const definitions = catalog.toolDefinitions();
+        const describeBytes = Math.max(1024, this.core.toolOutputLimits.maxBytes - 1024);
+        return {
+            [names.search]: plugins.tool({
+                description: definitions[names.search].description,
+                strict: false,
+                inputSchema: catalogToolInputSchema(definitions[names.search]),
+                execute: async (input, options) => catalog.search(input, { declaredTypes: catalog.declaredTypesIn(options?.messages), maxBytes: describeBytes }),
+            }),
+            [names.describe]: plugins.tool({
+                description: definitions[names.describe].description,
+                strict: false,
+                inputSchema: catalogToolInputSchema(definitions[names.describe]),
+                execute: async (input, options) => catalog.describe(input, {
+                    declaredTypes: catalog.declaredTypesIn(options?.messages),
+                    maxBytes: describeBytes,
+                }).output,
+            }),
+            [names.execute]: plugins.tool({
+                description: definitions[names.execute].description,
+                strict: false,
+                inputSchema: catalogToolInputSchema(definitions[names.execute]),
+                execute: async (input, options) => {
+                    const toolCallId = options?.toolCallId ?? '';
+                    const abortSignal = options?.abortSignal ?? run.controller.signal;
+                    const confirmed = options?.confirmed;
+                    const call = await catalog.prepareCall(input.method, input.params);
+                    if (!call.success)
+                        throw this.catalogCallError(run, toolCallId, call.error);
+                    if (call.method === FLEX_RESULT_METHOD) {
+                        const read = await this.core.results.readResult(run, call.params);
+                        if (!read.ok)
+                            throw this.catalogCallError(run, toolCallId, read.error);
+                        return read.value;
+                    }
+                    // A call that started early asks for permission once the response confirmed it.
+                    const base = run.toolProviderContext;
+                    const provider = confirmed
+                        ? Object.freeze({
+                            ...base,
+                            requestPermission: async (request) => {
+                                await confirmed;
+                                return base.requestPermission(request);
+                            },
+                        })
+                        : base;
+                    const context = { method: call.method, toolCallId, abortSignal, provider };
+                    const decision = await call.decide(context);
+                    if (decision === 'run') {
+                        return this.readOnce(run, toolCallId, this.readOnlyMethod(run, catalog, call), call.params, confirmed, () => call.run(context));
+                    }
+                    if (decision === 'propose') {
+                        return catalog.propose([{ id: toolCallId, method: call.method, params: call.params }], { toolCallId, abortSignal, provider: run.toolProviderContext });
+                    }
+                    throw this.catalogCallError(run, toolCallId, { error: 'denied', method: call.method, reason: decision.deny });
+                },
+            }),
+            ...(catalog.codeMode && run.codeSandbox ? {
+                [FLEX_CODE_MODE_TOOL_NAME]: plugins.tool({
+                    description: definitions[FLEX_CODE_MODE_TOOL_NAME].description,
+                    strict: false,
+                    inputSchema: catalogToolInputSchema(definitions[FLEX_CODE_MODE_TOOL_NAME]),
+                    execute: async (input, options) => this.runCatalogProgram(run, catalog, input.code, options?.toolCallId ?? '', options?.abortSignal ?? run.controller.signal),
+                }),
+            } : {}),
+        };
+    }
+    /** A refused catalog call as the trusted error the model and the tool part show. */
+    catalogCallError(run, toolCallId, payload) {
+        const error = this.core.trustInternalError(new FlexHarnessValidationError(JSON.stringify(payload)));
+        if (toolCallId)
+            run.trustedToolExecutionErrors.set(toolCallId, error);
+        return error;
+    }
+    /**
+     * 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.
+     */
+    async runCatalogProgram(run, catalog, code, toolCallId, abortSignal) {
+        const proposals = [];
+        const base = run.toolProviderContext;
+        // Waiting for a permission decision is the user's time, not the program's.
+        let waitedMs = 0;
+        let waiting = 0;
+        let waitingSince = 0;
+        /** The provider context of one call: its permission waits are timed, and end when the program stops. */
+        const providerFor = (signal) => Object.freeze({
+            ...base,
+            requestPermission: async (request) => {
+                signal.throwIfAborted();
+                if (waiting++ === 0)
+                    waitingSince = performance.now();
+                let onAbort;
+                try {
+                    await Promise.race([
+                        base.requestPermission(request),
+                        new Promise((_resolve, reject) => {
+                            onAbort = () => reject(signal.reason);
+                            signal.addEventListener('abort', onAbort, { once: true });
+                        }),
+                    ]);
+                }
+                finally {
+                    if (onAbort)
+                        signal.removeEventListener('abort', onAbort);
+                    if (--waiting === 0)
+                        waitedMs += performance.now() - waitingSince;
+                }
+            },
+        });
+        const stopped = (method) => ({ ok: false, error: { error: 'aborted', method } });
+        let callNumber = 0;
+        // Read-only calls run concurrently; any other call runs after every call the program made before it.
+        const order = new plugins.AgentToolCallScheduler(abortSignal);
+        const finish = (id, method, input, outcome) => {
+            if ('error' in outcome)
+                run.trustedToolExecutionErrors.set(id, outcome.error);
+            this.core.callbacks.onToolFinish(run.state, run.sessionId, 'error' in outcome
+                ? { toolCallId: id, toolName: method, input, success: false, error: outcome.error.message }
+                : { toolCallId: id, toolName: method, input, success: true, output: outcome.output });
+        };
+        const callInTurn = async (id, method, params, signal, classification) => {
+            const call = await catalog.prepareCall(method, params);
+            if (!call.success) {
+                if (catalog.has(method)) {
+                    this.core.callbacks.onToolStart(run.state, run.sessionId, { toolCallId: id, toolName: method, input: params ?? {}, parentToolCallId: toolCallId });
+                    finish(id, method, params, { error: this.catalogCallError(run, id, call.error) });
+                }
+                return { ok: false, error: call.error };
+            }
+            try {
+                await order.waitForTurn(id, signal);
+            }
+            catch {
+                return stopped(call.method);
+            }
+            if (signal.aborted)
+                return stopped(call.method);
+            this.core.callbacks.onToolStart(run.state, run.sessionId, {
+                toolCallId: id, toolName: call.method, input: call.params, parentToolCallId: toolCallId,
+            });
+            if ('error' in classification) {
+                finish(id, call.method, call.params, { error: classification.error });
+                return { ok: false, error: { error: 'failed', method: call.method, message: classification.error.message } };
+            }
+            if (call.method === FLEX_RESULT_METHOD) {
+                const read = await this.core.results.readResult(run, call.params);
+                finish(id, call.method, call.params, read.ok
+                    ? { output: read.value }
+                    : { error: this.catalogCallError(run, id, read.error) });
+                return read;
+            }
+            const readOnly = classification.readOnly;
+            const context = { method: call.method, toolCallId: id, abortSignal: signal, provider: providerFor(signal) };
+            try {
+                const decision = await call.decide(context);
+                signal.throwIfAborted();
+                if (decision === 'propose') {
+                    proposals.push({ id, method: call.method, params: call.params });
+                    const value = { proposed: true, id };
+                    finish(id, call.method, call.params, { output: value });
+                    return { ok: true, value };
+                }
+                if (decision !== 'run') {
+                    const payload = { error: 'denied', method: call.method, reason: decision.deny };
+                    finish(id, call.method, call.params, { error: this.catalogCallError(run, id, payload) });
+                    return { ok: false, error: payload };
+                }
+                const output = this.readOnce(run, id, readOnly ? call.method : undefined, call.params, undefined, () => call.run(context));
+                const value = await this.core.results.budgetOutput(run, await settleToolOutput(output));
+                finish(id, call.method, call.params, { output: value });
+                return { ok: true, value };
+            }
+            catch (error) {
+                const projected = this.core.projectExternalError(run, error, 'toolExecution');
+                finish(id, call.method, call.params, { error: projected });
+                return { ok: false, error: { error: 'failed', method: call.method, message: projected.message } };
+            }
+        };
+        const host = {
+            waitedMs: () => waitedMs + (waiting > 0 ? performance.now() - waitingSince : 0),
+            call: async (method, params, signal) => {
+                if (signal.aborted)
+                    return stopped(method);
+                const id = `${toolCallId}.${++callNumber}`;
+                // The call takes its place in the program's order now, before anything is awaited.
+                let classification;
+                try {
+                    classification = {
+                        readOnly: catalog.has(method) && this.isReadOnlyCatalogCall(run, catalog, method, params ?? {}),
+                    };
+                }
+                catch (error) {
+                    classification = {
+                        error: error instanceof Error ? error : this.core.projectExternalError(run, error, 'toolProvider'),
+                    };
+                }
+                order.begin(id, 'readOnly' in classification && classification.readOnly);
+                try {
+                    return await callInTurn(id, method, params, signal, classification);
+                }
+                finally {
+                    order.settle(id);
+                }
+            },
+        };
+        const result = await run.codeSandbox.run(code, host, catalog.codeMode, abortSignal);
+        if (!result.ok)
+            throw this.catalogCallError(run, toolCallId, result.failure);
+        return {
+            result: result.value,
+            calls: result.calls,
+            ...(result.logs ? { logs: result.logs } : {}),
+            ...(proposals.length > 0
+                ? { proposals: await catalog.propose(proposals, { toolCallId, abortSignal, provider: base }) }
+                : {}),
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.flexharness.tooldispatch.js","sourceRoot":"","sources":["../ts/classes.flexharness.tooldispatch.ts"],"names":[],"mappings":"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"}