@qvac/harness 0.7.1 → 1.0.0-rc.1

package/dist-lib/lib/capabilities/completion-loop/round.js

@@ -0,0 +1,353 @@
+import { contextCandidates } from '../../context-window.js';
+import { bufferBurst } from '../../helpers/buffer-burst.js';
+import { endsTurn, stopAtControlToken } from '../../helpers/control-tokens.js';
+import { createMarkupStreamFilter } from '../../helpers/markup-stream-filter.js';
+import { AbortedError, raceAbort } from '../../helpers/race-abort.js';
+import { raceTimeout } from '../../helpers/race-timeout.js';
+import { splitThinking } from '../../helpers/thinking.js';
+import { errorMessage, isRecord } from '../../guards.js';
+import { hlog } from '../../log.js';
+import { isContextOverflowError, isSdkModelWedgedError } from '../../models/sdk-faults.js';
+import { copy, isFailureResultReference, stableStringify } from '../../machine/index.js';
+import { detachJson } from '../../helpers/detach-json.js';
+import { materializeCompletionHistory } from '../tool-turns.js';
+const BURST_WINDOW_MS = 100;
+export const CONTEXT_OVERFLOW_MESSAGE = 'This message is too large for the model context window.';
+const noop = () => { };
+function unprovenReplay(state, final) {
+    if (!state.unproven)
+        return null;
+    if (state.stopToken) {
+        return endsTurn(state.stopToken) ? state.unproven : null;
+    }
+    if (final.stopReason === 'length' || final.stopReason === 'cancelled') {
+        return null;
+    }
+    return state.unproven;
+}
+function cancelOnce(sdk, requestId) {
+    let done = false;
+    let pending = Promise.resolve();
+    const cancel = () => {
+        if (done || !requestId)
+            return;
+        done = true;
+        pending = sdk.cancel?.({ requestId }).catch(noop) ?? Promise.resolve();
+    };
+    return Object.assign(cancel, { flush: () => pending });
+}
+async function* runRoundTokens({ result, state, cancelThisRound, signal, startInThink }) {
+    signal?.addEventListener('abort', cancelThisRound, { once: true });
+    const tokens = stopAtControlToken(result.tokenStream, (token) => {
+        state.stopToken = token;
+    });
+    let tokenEvents = 0;
+    const events = splitThinking(bufferBurst(tokens, BURST_WINDOW_MS), { startInThink });
+    const thinkingFilter = createMarkupStreamFilter();
+    const contentFilter = createMarkupStreamFilter();
+    try {
+        tokenEvents = yield* processRoundTokenEvents({
+            events,
+            state,
+            cancelThisRound,
+            signal,
+            thinkingFilter,
+            contentFilter
+        });
+        hlog('stream ended', { events: tokenEvents, stopToken: state.stopToken });
+        if (state.stopToken) {
+            cancelThisRound();
+        }
+    }
+    finally {
+        if (signal?.aborted) {
+            cancelThisRound();
+        }
+        signal?.removeEventListener('abort', cancelThisRound);
+        await events.return(null);
+    }
+}
+async function* processRoundTokenEvents({ events, state, cancelThisRound, signal, thinkingFilter, contentFilter }) {
+    let tokenEvents = 0;
+    while (true) {
+        const next = await events.next();
+        if (next.done) {
+            state.unproven = next.value;
+            yield* flushFilterTails(thinkingFilter, contentFilter);
+            break;
+        }
+        if (signal?.aborted) {
+            cancelThisRound();
+            throw new AbortedError();
+        }
+        tokenEvents++;
+        if (next.value.type === 'content') {
+            state.rawContentText += next.value.text;
+        }
+        const filter = next.value.type === 'thinking' ? thinkingFilter : contentFilter;
+        const text = filter.push(next.value.text);
+        if (text) {
+            yield { type: next.value.type, text };
+        }
+    }
+    return tokenEvents;
+}
+async function* flushFilterTails(thinkingFilter, contentFilter) {
+    const thinkingTail = thinkingFilter.flush();
+    if (thinkingTail) {
+        yield { type: 'thinking', text: thinkingTail };
+    }
+    const contentTail = contentFilter.flush();
+    if (contentTail) {
+        yield { type: 'content', text: contentTail };
+    }
+}
+function sentMessages(stats) {
+    if (!stats || !('sentMessages' in stats) || !Array.isArray(stats.sentMessages)) {
+        return undefined;
+    }
+    if (!stats.sentMessages.every(isMessage))
+        return undefined;
+    return detachJson(stats.sentMessages);
+}
+function isMessage(value) {
+    return isRecord(value) && typeof value.role === 'string' && typeof value.content === 'string';
+}
+function roundTokens(stats) {
+    if (!stats)
+        return undefined;
+    const tokens = {
+        prompt: stats.promptTokens,
+        generated: stats.generatedTokens,
+        cached: stats.cacheTokens,
+        timeToFirstToken: stats.timeToFirstToken
+    };
+    return Object.values(tokens).some((value) => value !== undefined) ? tokens : undefined;
+}
+const TRUNCATED_FINAL_MS = 2000;
+function truncatedFinal(final, contentText) {
+    const accepted = { contentText, toolCalls: [], raw: { fullText: contentText } };
+    const guarded = final.catch((err) => {
+        if (isSdkModelWedgedError(err))
+            throw err;
+        return accepted;
+    });
+    guarded.catch(noop);
+    return raceTimeout(guarded, { ms: TRUNCATED_FINAL_MS, fallback: accepted });
+}
+export async function* runRecoveredRound(sdk, args) {
+    const lease = args.acquireRound ? await args.acquireRound(args.signal) : null;
+    try {
+        const roundSdk = lease?.sdk ?? sdk;
+        if (!roundSdk) {
+            throw new Error('A completion round requires an SDK');
+        }
+        return yield* runRecoveredRoundWith(roundSdk, args, lease?.modelId ?? args.modelId);
+    }
+    finally {
+        try {
+            lease?.release();
+        }
+        catch (error) {
+            hlog('completion round lease release failed', { error: errorMessage(error) });
+        }
+    }
+}
+async function* runRecoveredRoundWith(sdk, args, modelId) {
+    let lastOverflow = null;
+    const history = materializeCompletionHistory(args.history, args.failureResults);
+    const origins = historyOrigins(args.history, history);
+    for (const candidate of contextCandidates(history)) {
+        if (args.signal?.aborted)
+            throw new AbortedError();
+        const progress = {
+            cancel: cancelOnce(sdk, undefined),
+            emitted: false
+        };
+        try {
+            const attempt = yield* runCandidate({
+                sdk,
+                args,
+                modelId,
+                candidate,
+                progress,
+                baseHistory: history
+            });
+            return recoveredRound({ candidate, attempt, origins });
+        }
+        catch (err) {
+            if (err instanceof AbortedError || args.signal?.aborted) {
+                progress.cancel();
+            }
+            if (args.capture) {
+                yield candidateFailureEvent({ args, candidate, error: err });
+            }
+            if (!isContextOverflowError(err)) {
+                throw err;
+            }
+            if (progress.emitted) {
+                throw errorWithCause(CONTEXT_OVERFLOW_MESSAGE, err);
+            }
+            lastOverflow = err;
+        }
+        finally {
+            await flushCandidate(args, progress);
+        }
+    }
+    if (lastOverflow) {
+        throw errorWithCause(CONTEXT_OVERFLOW_MESSAGE, lastOverflow);
+    }
+    throw new Error('context recovery produced no completion candidate');
+}
+async function flushCandidate(args, progress) {
+    if (args.signal?.aborted) {
+        progress.cancel();
+    }
+    await raceTimeout(progress.cancel.flush(), { ms: TRUNCATED_FINAL_MS, fallback: undefined });
+}
+function recoveredRound({ candidate, attempt, origins }) {
+    const replay = unprovenReplay(attempt.state, attempt.final);
+    logCandidateFinal(attempt.state, attempt.final, replay);
+    return {
+        contentText: attempt.contentText,
+        final: attempt.final,
+        history: restoreHistory(candidate.history, origins),
+        cacheable: attempt.cacheable,
+        unproven: attempt.state.unproven,
+        replay
+    };
+}
+function historyOrigins(entries, messages) {
+    const origins = new WeakMap();
+    entries.forEach((entry, index) => {
+        if (!isFailureResultReference(entry))
+            return;
+        const message = messages[index];
+        if (!message) {
+            throw new Error('Materialized history lost an entry');
+        }
+        origins.set(message, { entry, fingerprint: stableStringify(message) });
+    });
+    return origins;
+}
+async function* runCandidate({ sdk, args, modelId, candidate, progress, baseHistory }) {
+    const cacheable = candidate.history === baseHistory;
+    const params = inferenceParams({ args, modelId, history: candidate.history, cacheable });
+    if (args.capture) {
+        yield inferenceCall({
+            args,
+            candidate,
+            modelId,
+            params,
+            cacheKey: cacheable ? args.cacheKey : undefined
+        });
+    }
+    const result = sdk.completion(params);
+    result.final.catch(noop);
+    progress.cancel = cancelOnce(sdk, result.requestId);
+    const state = { stopToken: null, unproven: null, rawContentText: '' };
+    const contentText = yield* streamCandidateTokens({ result, state, args, progress });
+    const final = state.stopToken
+        ? await truncatedFinal(result.final, state.rawContentText)
+        : await raceAbort(result.final, args.signal);
+    const detachedFinal = {
+        ...final,
+        toolCalls: copy(final.toolCalls ?? []),
+        stats: copy(final.stats)
+    };
+    if (args.capture) {
+        yield inferenceSent({ args, candidate, final: detachedFinal });
+    }
+    return { contentText, final: detachedFinal, state, cacheable };
+}
+function inferenceParams({ args, modelId, history, cacheable }) {
+    return {
+        modelId,
+        history: detachJson(history),
+        stream: true,
+        tools: args.tools ? detachJson(args.tools) : undefined,
+        generationParams: args.generationParams ? detachJson(args.generationParams) : undefined,
+        responseFormat: args.responseFormat ? detachJson(args.responseFormat) : undefined,
+        toolDialect: args.toolDialect,
+        kvCache: cacheable ? args.cacheKey : undefined
+    };
+}
+function inferenceCall({ args, candidate, modelId, params, cacheKey }) {
+    return {
+        type: 'inference-call',
+        call: {
+            round: args.round,
+            droppedTurns: candidate.droppedTurns,
+            modelId,
+            messages: params.history,
+            tools: params.tools,
+            generationParams: params.generationParams,
+            responseFormat: params.responseFormat,
+            toolDialect: params.toolDialect,
+            cacheKey,
+            promptPrefix: args.promptPrefix
+        }
+    };
+}
+function inferenceSent({ args, candidate, final }) {
+    return {
+        type: 'inference-sent',
+        round: args.round,
+        droppedTurns: candidate.droppedTurns,
+        messages: sentMessages(final.stats),
+        tokens: roundTokens(final.stats),
+        outcome: 'completed',
+        reason: undefined
+    };
+}
+async function* streamCandidateTokens({ result, state, args, progress }) {
+    let contentText = '';
+    const startInThink = args.generationParams?.reasoning_budget === -1;
+    for await (const event of runRoundTokens({
+        result,
+        state,
+        cancelThisRound: progress.cancel,
+        signal: args.signal,
+        startInThink
+    })) {
+        if (event.type === 'content') {
+            contentText += event.text;
+        }
+        progress.emitted = true;
+        yield event;
+    }
+    return contentText;
+}
+function candidateFailureEvent({ args, candidate, error }) {
+    return {
+        type: 'inference-sent',
+        round: args.round,
+        droppedTurns: candidate.droppedTurns,
+        messages: undefined,
+        tokens: undefined,
+        outcome: isContextOverflowError(error) ? 'overflowed' : 'failed',
+        reason: errorMessage(error)
+    };
+}
+function logCandidateFinal(state, final, replay) {
+    hlog('final', {
+        stopReason: final.stopReason,
+        toolCalls: final.toolCalls.length,
+        stopToken: state.stopToken,
+        replay: replay !== null
+    });
+}
+function restoreHistory(messages, origins) {
+    return messages.map((message) => {
+        const origin = origins.get(message);
+        if (!origin || stableStringify(message) !== origin.fingerprint) {
+            return message;
+        }
+        return origin.entry;
+    });
+}
+function errorWithCause(message, cause) {
+    const error = new Error(message);
+    Object.defineProperty(error, 'cause', { value: cause, configurable: true });
+    return error;
+}

package/dist-lib/lib/capabilities/completion-loop/tool-execution.d.ts

@@ -0,0 +1,60 @@
+import { MAX_BLOCKED_REPEATS, toolCallKey, type ToolPreflight, type ToolPreflightFacts, type TrustedSourceFacts } from '../../machine/index.ts';
+import type { ToolCallWithCall } from '@qvac/sdk';
+import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
+import { HookPipeline } from '../../hooks/pipeline.ts';
+import type { HookRejection } from '../../hooks/types.ts';
+import type { ToolCallDisplay, ToolExecutionOutcome } from '../../tool-call-display.ts';
+import { type TrustedSource } from '../../tools/outbound-guard.ts';
+import type { ApproveFn, ToolActivityFn, ToolDefinition, ToolEffect, ToolExecuteContext } from '../completion.ts';
+export { MAX_BLOCKED_REPEATS, toolCallKey };
+export declare function callSucceeded(result: unknown, outcome: ToolExecutionOutcome): boolean;
+export declare function settledFailure(result: unknown, outcome: ToolExecutionOutcome): boolean;
+export interface ExecuteCallOptions {
+    runId: string;
+    approve?: ApproveFn | undefined;
+    signal?: BareAbortSignal | undefined;
+    denied?: Set<string>;
+    sources?: readonly TrustedSource[];
+    sourceFacts?: readonly TrustedSourceFacts[];
+    pipeline: HookPipeline;
+    callId: string;
+    effect?: ToolEffect | undefined;
+    skipApprovals?: boolean;
+    preflight?: ToolPreflight;
+    onToolActivity?: ToolActivityFn;
+    intent?: string | undefined;
+    display?: ToolCallDisplay | undefined;
+}
+export interface ExecutedCall {
+    readonly result: unknown;
+    readonly outcome: ToolExecutionOutcome;
+    readonly executed: boolean;
+}
+export type { ToolPreflight };
+interface ToolPolicyOptions extends Pick<ExecuteCallOptions, 'sources' | 'sourceFacts' | 'denied' | 'effect' | 'skipApprovals'> {
+    key?: string;
+}
+export declare function preflightToolCall(tool: ToolDefinition, args: Record<string, unknown>, ctx: ToolExecuteContext, options?: ToolPolicyOptions): ToolPreflight;
+export declare function inspectToolPolicy(tool: ToolDefinition, args: Record<string, unknown>, ctx: ToolExecuteContext, options?: ToolPolicyOptions): ToolPreflightFacts;
+type ReadyToolPreflight = Extract<ToolPreflight, {
+    status: 'ready';
+}>;
+export declare function readyPreflightFromFacts(facts: ToolPreflightFacts): ReadyToolPreflight;
+export declare function executeCall(tool: ToolDefinition, args: Record<string, unknown>, ctx: ToolExecuteContext, { runId, approve, signal, denied, sources, sourceFacts, pipeline, callId, effect: classified, skipApprovals, preflight: prepared, onToolActivity, intent, display }: ExecuteCallOptions): Promise<ExecutedCall>;
+export interface ResolvedCall {
+    call: ToolCallWithCall;
+    tool?: ToolDefinition;
+    args: Record<string, unknown>;
+    rawCall?: string;
+    intent?: string;
+    rejection?: HookRejection;
+}
+export interface ResolveToolCallsOptions {
+    runId: string;
+    agentId: string | null;
+    pipeline: HookPipeline;
+    skillNames: readonly string[];
+    sandboxMode: boolean;
+    signal?: BareAbortSignal | undefined;
+}
+export declare function resolveToolCalls(toolCalls: ToolCallWithCall[], enabled: readonly ToolDefinition[], { runId, agentId, pipeline, skillNames, sandboxMode, signal }: ResolveToolCallsOptions): Promise<ResolvedCall[]>;

package/dist-lib/lib/capabilities/completion-loop/tool-execution.js

@@ -0,0 +1,270 @@
+import { MAX_BLOCKED_REPEATS, ToolPolicyChanged, toolCallKey, toolDeniedResult } from '../../machine/index.js';
+import { RecoveryRequired } from '../../helpers/recovery-required.js';
+import { AbortedError, raceAbort } from '../../helpers/race-abort.js';
+import { errorCode, errorMessage, isRecord } from '../../guards.js';
+import { detachJson } from '../../helpers/detach-json.js';
+import { clipRawCall, normalizeToolArgs } from '../../helpers/tool-call-markup.js';
+import { takeToolIntent } from '../../helpers/tool-intent.js';
+import { HookPipeline } from '../../hooks/pipeline.js';
+import { hlog } from '../../log.js';
+import { guardToolCallWithFacts } from '../../tools/outbound-guard.js';
+export { MAX_BLOCKED_REPEATS, toolCallKey };
+function validationMessage(result) {
+    return isRecord(result) && 'error' in result ? result.error : result;
+}
+const RETRYABLE_STATUS = new Set([408, 429]);
+const RETRYABLE_CODE = new Set(['timeout', 'transport', 'busy']);
+export function callSucceeded(result, outcome) {
+    if (outcome.kind !== 'success') {
+        return false;
+    }
+    const exitCode = result === null || result === undefined ? undefined : Reflect.get(Object(result), 'exitCode');
+    return typeof exitCode !== 'number' || exitCode === 0;
+}
+function retryHints(result) {
+    if (!isRecord(result) || Array.isArray(result)) {
+        return {};
+    }
+    const hints = {};
+    if (typeof result.status === 'number') {
+        hints.status = result.status;
+    }
+    if (typeof result.code === 'string') {
+        hints.code = result.code;
+    }
+    return hints;
+}
+export function settledFailure(result, outcome) {
+    if (outcome.kind === 'denied' || callSucceeded(result, outcome)) {
+        return false;
+    }
+    if (outcome.kind === 'error' && outcome.error !== undefined) {
+        return false;
+    }
+    const { code, status } = retryHints(result);
+    if (code !== undefined && RETRYABLE_CODE.has(code)) {
+        return false;
+    }
+    return status === undefined || (status < 500 && !RETRYABLE_STATUS.has(status));
+}
+export function preflightToolCall(tool, args, ctx, options = {}) {
+    const facts = inspectToolPolicy(tool, args, ctx, options);
+    if (facts.validationError) {
+        return {
+            status: 'blocked',
+            reason: 'validation',
+            result: { error: facts.validationError, guidance: true },
+            effect: 'write'
+        };
+    }
+    if (facts.refusal) {
+        return {
+            status: 'blocked',
+            reason: 'refusal',
+            result: { error: facts.refusal, guidance: true },
+            effect: facts.effect
+        };
+    }
+    if (facts.deniedKey) {
+        return { status: 'denied', result: toolDeniedResult(), key: facts.deniedKey };
+    }
+    return {
+        status: 'ready',
+        key: facts.key,
+        effect: facts.effect,
+        resource: facts.resource,
+        autoRun: facts.effect === 'read' || facts.autoApprove || facts.skipApprovals
+    };
+}
+export function inspectToolPolicy(tool, args, ctx, options = {}) {
+    const validationError = tool.validate?.(detachJson(args), ctx) || null;
+    const key = options.key ?? toolCallKey(tool.name, args);
+    const refusal = validationError
+        ? null
+        : guardToolCallWithFacts(tool.name, args, {
+            sources: options.sources ?? [],
+            sourceFacts: options.sourceFacts,
+            externalWrite: tool.externalWrite === true
+        });
+    const deniedKey = !validationError && !refusal && options.denied?.has(key) ? key : null;
+    const effect = options.effect ?? (validationError ? 'write' : tool.effect(detachJson(args), ctx));
+    const resource = validationError || deniedKey ? null : detachJson(tool.resource?.(detachJson(args), ctx) ?? null);
+    return {
+        key,
+        validationError,
+        refusal,
+        deniedKey,
+        effect,
+        autoApprove: tool.autoApprove === true,
+        skipApprovals: options.skipApprovals === true,
+        resource
+    };
+}
+export function readyPreflightFromFacts(facts) {
+    if (facts.validationError || facts.refusal || facts.deniedKey) {
+        throw new Error('tool policy facts are not ready for execution');
+    }
+    return {
+        status: 'ready',
+        key: facts.key,
+        effect: facts.effect,
+        resource: facts.resource,
+        autoRun: facts.effect === 'read' || facts.autoApprove || facts.skipApprovals
+    };
+}
+function decisionFor(options) {
+    if (options.autoApprove || options.effect === 'read') {
+        return 'auto';
+    }
+    if (options.skipApprovals === true) {
+        return 'skip-all';
+    }
+    if (options.approved) {
+        return 'allowed';
+    }
+    return 'denied';
+}
+export async function executeCall(tool, args, ctx, { runId, approve, signal, denied, sources = [], sourceFacts = [], pipeline, callId, effect: classified, skipApprovals, preflight: prepared, onToolActivity, intent, display }) {
+    const preflight = prepared ??
+        preflightToolCall(tool, args, ctx, {
+            sources,
+            sourceFacts,
+            denied,
+            effect: classified,
+            skipApprovals
+        });
+    if (preflight.status === 'blocked' && preflight.reason === 'validation') {
+        hlog('tool rejected: arguments failed validation', { tool: tool.name });
+        return {
+            result: preflight.result,
+            outcome: { kind: 'guidance', message: String(validationMessage(preflight.result)) },
+            executed: false
+        };
+    }
+    if (preflight.status === 'blocked') {
+        hlog('tool refused: unverifiable value in payload', { tool: tool.name });
+        onToolActivity?.({
+            type: 'tool-activity',
+            name: tool.name,
+            args,
+            resource: detachJson(tool.resource?.(detachJson(args), ctx) ?? null),
+            effect: preflight.effect,
+            decision: 'blocked'
+        });
+        return {
+            result: preflight.result,
+            outcome: { kind: 'blocked', reason: String(validationMessage(preflight.result)) },
+            executed: false
+        };
+    }
+    if (preflight.status === 'denied') {
+        hlog('tool denied already, not asking again', { tool: tool.name });
+        return {
+            result: preflight.result,
+            outcome: { kind: 'denied', reason: toolDeniedResult().error },
+            executed: false
+        };
+    }
+    const { key, effect, resource, autoRun } = preflight;
+    hlog('tool decision', {
+        tool: tool.name,
+        effect,
+        auto: autoRun,
+        asks: Boolean(approve)
+    });
+    let approved = autoRun;
+    if (!approved && approve) {
+        approved = await raceAbort(approve({
+            name: tool.name,
+            arguments: detachJson(args),
+            resource: detachJson(resource),
+            effect,
+            intent: intent ?? null,
+            display: detachJson(display ?? null)
+        }), signal);
+    }
+    hlog(`tool ${approved ? 'approved' : 'denied'}`, { tool: tool.name });
+    const decision = decisionFor({
+        autoApprove: tool.autoApprove === true,
+        effect,
+        skipApprovals,
+        approved
+    });
+    onToolActivity?.({ type: 'tool-activity', name: tool.name, args, resource, effect, decision });
+    if (!approved) {
+        denied?.add(key);
+        return {
+            result: toolDeniedResult(),
+            outcome: { kind: 'denied', reason: toolDeniedResult().error },
+            executed: false
+        };
+    }
+    if (signal?.aborted) {
+        throw new AbortedError();
+    }
+    let output;
+    let outcome = { kind: 'success' };
+    const toolArgs = detachJson(args);
+    try {
+        output = await tool.execute(toolArgs, { ...ctx, signal, runId, callId, approval: decision });
+        hlog('tool done', { tool: tool.name });
+    }
+    catch (err) {
+        if (err instanceof RecoveryRequired || err instanceof ToolPolicyChanged) {
+            throw err;
+        }
+        if (err instanceof AbortedError || signal?.aborted) {
+            throw new AbortedError();
+        }
+        const message = errorMessage(err);
+        hlog('tool failed', { tool: tool.name, err: message });
+        output = { error: message, code: errorCode(err) };
+        outcome = { kind: 'error', message, error: err };
+    }
+    const folded = await pipeline.runPostToolFold({
+        runId,
+        callId,
+        toolName: tool.name,
+        args: toolArgs,
+        effect,
+        resource,
+        toolset: tool.toolset,
+        agentId: ctx.agentId ?? null,
+        result: output,
+        outcome,
+        executed: true
+    });
+    return { result: detachJson(folded.result), outcome: folded.outcome ?? outcome, executed: true };
+}
+export async function resolveToolCalls(toolCalls, enabled, { runId, agentId, pipeline, skillNames, sandboxMode, signal }) {
+    const resolved = [];
+    for (const call of toolCalls) {
+        if (signal?.aborted) {
+            throw new AbortedError();
+        }
+        const tool = enabled.find((t) => t.name === call.name);
+        const rawCall = call.raw === undefined ? {} : { rawCall: clipRawCall(call.raw) };
+        if (!tool) {
+            resolved.push({ call, args: detachJson(takeToolIntent(call.arguments).args), ...rawCall });
+            continue;
+        }
+        const taken = takeToolIntent(call.arguments);
+        const intent = taken.intent ? { intent: taken.intent } : {};
+        const args = normalizeToolArgs(taken.args, Object.keys(tool.parameters.properties));
+        const fold = await pipeline.runPreToolFold({
+            runId,
+            callId: call.id,
+            toolName: tool.name,
+            args,
+            agentId,
+            skillNames,
+            parameters: tool.parameters,
+            sandboxMode,
+            signal
+        });
+        resolved.push(fold.ok
+            ? { call, tool, args: detachJson(fold.args), ...rawCall, ...intent }
+            : { call, tool, args: detachJson(args), rejection: fold.rejection, ...rawCall, ...intent });
+    }
+    return resolved;
+}