@juspay/neurolink 10.5.2 → 10.6.0

package/dist/lib/agent/structuredRecovery.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Structured-output recovery ladder for the isolated-agent runner.
+ *
+ * Ports the production-hardened pattern the framework's consumers built by
+ * hand: candidates are tried in a fixed order — provider `structuredData` →
+ * raw JSON object → ```json fence → first/last-brace span → top-level array —
+ * each passed through the caller's `coerce` normalizer and validated against
+ * the (lenient) local schema. The first schema-valid candidate wins;
+ * validation errors are collected for corrective re-asks.
+ */
+import type { z } from "zod";
+import type { StructuredRecoveryCandidate, StructuredRecoveryResult } from "../types/index.js";
+/**
+ * Collect parse candidates from model text (and provider structuredData) in
+ * ladder order. Never throws.
+ */
+export declare function collectStructuredCandidates(content: string | undefined, structuredData?: unknown): StructuredRecoveryCandidate[];
+/**
+ * Run the full ladder: candidates (through `coerce`) validated against
+ * `schema`; first success wins. Never throws — coerce/validation failures
+ * become entries in `errors`.
+ */
+export declare function recoverStructuredData(args: {
+    content: string | undefined;
+    structuredData?: unknown;
+    schema: z.ZodSchema;
+    coerce?: (candidate: unknown) => unknown;
+}): StructuredRecoveryResult;
+/** Bounded, prompt-friendly summary of a Zod validation error. */
+export declare function summarizeZodError(error: z.ZodError): string;

package/dist/lib/agent/structuredRecovery.js

@@ -0,0 +1,105 @@
+/**
+ * Structured-output recovery ladder for the isolated-agent runner.
+ *
+ * Ports the production-hardened pattern the framework's consumers built by
+ * hand: candidates are tried in a fixed order — provider `structuredData` →
+ * raw JSON object → ```json fence → first/last-brace span → top-level array —
+ * each passed through the caller's `coerce` normalizer and validated against
+ * the (lenient) local schema. The first schema-valid candidate wins;
+ * validation errors are collected for corrective re-asks.
+ */
+function tryParse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Collect parse candidates from model text (and provider structuredData) in
+ * ladder order. Never throws.
+ */
+export function collectStructuredCandidates(content, structuredData) {
+    const candidates = [];
+    if (structuredData !== undefined && structuredData !== null) {
+        candidates.push({ source: "structured-data", value: structuredData });
+    }
+    const text = (content ?? "").trim();
+    if (!text) {
+        return candidates;
+    }
+    // Raw JSON object/array/scalar
+    const raw = tryParse(text);
+    if (raw !== undefined) {
+        candidates.push({ source: "raw-json", value: raw });
+    }
+    // ```json fenced block (first fence wins)
+    const fenceMatch = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/i);
+    if (fenceMatch?.[1]) {
+        const fenced = tryParse(fenceMatch[1].trim());
+        if (fenced !== undefined) {
+            candidates.push({ source: "json-fence", value: fenced });
+        }
+    }
+    // First-brace .. last-brace span
+    const firstBrace = text.indexOf("{");
+    const lastBrace = text.lastIndexOf("}");
+    if (firstBrace !== -1 && lastBrace > firstBrace) {
+        const span = tryParse(text.slice(firstBrace, lastBrace + 1));
+        if (span !== undefined) {
+            candidates.push({ source: "brace-span", value: span });
+        }
+    }
+    // Top-level array span
+    const firstBracket = text.indexOf("[");
+    const lastBracket = text.lastIndexOf("]");
+    if (firstBracket !== -1 && lastBracket > firstBracket) {
+        const arraySpan = tryParse(text.slice(firstBracket, lastBracket + 1));
+        if (arraySpan !== undefined && Array.isArray(arraySpan)) {
+            candidates.push({ source: "top-level-array", value: arraySpan });
+        }
+    }
+    return candidates;
+}
+/**
+ * Run the full ladder: candidates (through `coerce`) validated against
+ * `schema`; first success wins. Never throws — coerce/validation failures
+ * become entries in `errors`.
+ */
+export function recoverStructuredData(args) {
+    const errors = [];
+    const candidates = collectStructuredCandidates(args.content, args.structuredData);
+    for (const candidate of candidates) {
+        let value = candidate.value;
+        if (args.coerce) {
+            try {
+                value = args.coerce(value);
+            }
+            catch (coerceError) {
+                errors.push(`${candidate.source}: coerce failed — ${coerceError instanceof Error
+                    ? coerceError.message
+                    : String(coerceError)}`);
+                continue;
+            }
+        }
+        const parsed = args.schema.safeParse(value);
+        if (parsed.success) {
+            return { data: parsed.data, source: candidate.source, errors };
+        }
+        errors.push(`${candidate.source}: ${summarizeZodError(parsed.error)}`);
+    }
+    if (candidates.length === 0) {
+        errors.push("no JSON-shaped candidates found in output");
+    }
+    return { errors };
+}
+/** Bounded, prompt-friendly summary of a Zod validation error. */
+export function summarizeZodError(error) {
+    const issues = error.issues
+        .slice(0, 5)
+        .map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`);
+    const extra = error.issues.length > 5 ? ` (+${error.issues.length - 5})` : "";
+    return issues.join("; ") + extra;
+}
+//# sourceMappingURL=structuredRecovery.js.map

package/dist/lib/core/baseProvider.d.ts

@@ -132,6 +132,14 @@ export declare abstract class BaseProvider implements AIProvider {
      * All providers should call this instead of getAllTools() directly.
      */
     protected getToolsForStream(options: StreamOptions | TextGenerationOptions): Promise<Record<string, Tool>>;
+    /**
+     * Create (or reuse) the per-call ToolExecutionRecorder and wrap the final
+     * tool record with it. The recorder rides on the options object so provider
+     * loops and result assembly observe the same capture state; wrapping is
+     * idempotent, so paths that re-enter (stream→generate fallback) never
+     * double-record.
+     */
+    protected wrapToolsForExecutionCapture(tools: Record<string, Tool>, options: StreamOptions | TextGenerationOptions): Record<string, Tool>;
     /**
      * Build messages array for generation - delegated to MessageBuilder
      */

package/dist/lib/core/baseProvider.js

@@ -12,6 +12,7 @@ import { withTimeoutFn } from "../utils/async/withTimeout.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
 import { getKeyCount, getKeysAsString } from "../utils/transformationUtils.js";
+import { ToolExecutionRecorder, resolveToolExecutionRecords, } from "./toolExecutionRecorder.js";
 import { TTSProcessor } from "../utils/ttsProcessor.js";
 import { executeVideoAnalysis, hasVideoFrames, } from "../utils/videoAnalysisProcessor.js";
 import { dedupeTools } from "./toolDedup.js";
@@ -759,6 +760,11 @@ export class BaseProvider {
             : {};
         // Apply per-call tool filtering (whitelist/blacklist)
         tools = this.applyToolFiltering(tools, options);
+        // Per-call execution capture: wrap every executable tool so real
+        // params/results/timing surface on result.toolExecutions. Must run
+        // BEFORE discovery — search_tools hydration mutates the discovery
+        // record in place, so tools hydrated mid-turn stay wrapped.
+        tools = this.wrapToolsForExecutionCapture(tools, options);
         // On-demand discovery: defer external MCP schemas behind search_tools
         tools = await this.applyToolDiscovery(tools, options);
         logger.debug(`Final tools prepared for AI`, {
@@ -792,6 +798,10 @@ export class BaseProvider {
         let merged = { ...baseTools, ...externalTools };
         // Apply per-call tool filtering (whitelist/blacklist)
         merged = this.applyToolFiltering(merged, options);
+        // Per-call execution capture (native loops obtain their tools here, so
+        // this single wrap covers the Gemini/Anthropic native paths too). Must
+        // run BEFORE discovery so tools hydrated mid-turn stay wrapped.
+        merged = this.wrapToolsForExecutionCapture(merged, options);
         // On-demand discovery: defer external MCP schemas behind search_tools
         merged = await this.applyToolDiscovery(merged, options);
         logger.debug(`Tools prepared for streaming`, {
@@ -802,6 +812,24 @@ export class BaseProvider {
         });
         return merged;
     }
+    /**
+     * Create (or reuse) the per-call ToolExecutionRecorder and wrap the final
+     * tool record with it. The recorder rides on the options object so provider
+     * loops and result assembly observe the same capture state; wrapping is
+     * idempotent, so paths that re-enter (stream→generate fallback) never
+     * double-record.
+     */
+    wrapToolsForExecutionCapture(tools, options) {
+        if (Object.keys(tools).length === 0) {
+            return tools;
+        }
+        let recorder = ToolExecutionRecorder.from(options);
+        if (!recorder) {
+            recorder = new ToolExecutionRecorder(options.toolExecutionCapture);
+            recorder.attachTo(options);
+        }
+        return recorder.wrapTools(tools);
+    }
     /**
      * Build messages array for generation - delegated to MessageBuilder
      */
@@ -1091,7 +1119,11 @@ export class BaseProvider {
         const responseTime = Date.now() - startTime;
         await this.recordPerformanceMetrics(generateResult.usage, responseTime);
         const { toolsUsed, toolExecutions } = this.extractToolInformation(generateResult);
-        let enhancedResult = this.formatEnhancedResult(generateResult, tools, toolsUsed, toolExecutions, options);
+        // Prefer the per-call recorder's real records (params/result/timing per
+        // execution); fall back to a conversion of the step-extraction entries
+        // for tools the recorder could not wrap (provider-executed tools).
+        const toolExecutionRecords = resolveToolExecutionRecords(options, toolExecutions);
+        let enhancedResult = this.formatEnhancedResult(generateResult, tools, toolsUsed, toolExecutionRecords, options);
         enhancedResult = await this.synthesizeAIResponseIfNeeded(enhancedResult, options);
         const finalResult = await this.enhanceResult(enhancedResult, options, startTime);
         return finalResult;
@@ -1160,24 +1192,13 @@ export class BaseProvider {
             },
             responseTime: 0, // BaseProvider doesn't track response time directly
             toolsUsed: result.toolsUsed || [],
-            // Map toolExecutions from EnhancedGenerateResult shape to TextGenerationResult shape
-            // Preserve original timing/status fields when present, fall back to safe defaults
-            toolExecutions: result.toolExecutions?.map((te) => {
-                const t = te;
-                return {
-                    // Spread original fields first so normalized fields take precedence
-                    ...te,
-                    toolName: te.name,
-                    executionTime: typeof t.executionTime === "number"
-                        ? t.executionTime
-                        : typeof t.duration === "number"
-                            ? t.duration
-                            : 0,
-                    success: typeof t.success === "boolean"
-                        ? t.success
-                        : t.status === undefined || t.status === "success",
-                };
-            }),
+            // Map ToolExecutionRecord entries to the legacy TextGenerationResult
+            // shape: real timing and error status now come from the records.
+            toolExecutions: result.toolExecutions?.map((te) => ({
+                toolName: te.toolName,
+                executionTime: te.durationMs,
+                success: !te.isError,
+            })),
             enhancedWithTools: !!(result.toolsUsed && result.toolsUsed.length > 0),
             analytics: result.analytics,
             evaluation: result.evaluation,

package/dist/lib/core/modules/GenerationHandler.d.ts

@@ -12,7 +12,7 @@
  *
  * @module core/modules/GenerationHandler
  */
-import type { AIProviderName, EnhancedGenerateResult, NeuroLinkEvents, StandardRecord, TextGenerationOptions, TypedEventEmitter } from "../../types/index.js";
+import type { AIProviderName, EnhancedGenerateResult, NeuroLinkEvents, StandardRecord, TextGenerationOptions, ToolExecutionRecord, TypedEventEmitter } from "../../types/index.js";
 import type { LanguageModel, ModelMessage, Tool } from "../../types/index.js";
 import { generateText } from "../../utils/generation.js";
 /**
@@ -87,11 +87,7 @@ export declare class GenerationHandler {
     /**
      * Format the enhanced result
      */
-    formatEnhancedResult(generateResult: Awaited<ReturnType<typeof generateText>>, tools: Record<string, Tool>, toolsUsed: string[], toolExecutions: Array<{
-        name: string;
-        input: StandardRecord;
-        output: unknown;
-    }>, options: TextGenerationOptions): EnhancedGenerateResult;
+    formatEnhancedResult(generateResult: Awaited<ReturnType<typeof generateText>>, tools: Record<string, Tool>, toolsUsed: string[], toolExecutions: ToolExecutionRecord[], options: TextGenerationOptions): EnhancedGenerateResult;
     /**
      * Analyze AI response structure and log detailed debugging information
      */

package/dist/lib/core/modules/GenerationHandler.js

@@ -14,6 +14,7 @@
  */
 import { SpanKind, SpanStatusCode } from "@opentelemetry/api";
 import { getModelId } from "../../providers/providerTypeUtils.js";
+import { resolveSamplingParams } from "../../models/modelRegistry.js";
 import { tracers } from "../../telemetry/tracers.js";
 import { logger } from "../../utils/logger.js";
 import { emitToolEndFromStepFinish } from "../../utils/toolEndEmitter.js";
@@ -256,6 +257,14 @@ export class GenerationHandler {
                 return cachedOverhead.tokens;
             },
         });
+        // Registry-driven strip: models that reject sampling params (Sonnet 5 /
+        // Opus 4.7+ / Fable 5 families — e.g. Claude on Bedrock or behind any
+        // AI-SDK provider) must not receive temperature. Applies uniformly to
+        // every provider on this loop path; the reactive
+        // isTemperatureDeprecatedError retry below remains the safety net.
+        const samplingParams = resolveSamplingParams(this.providerName, getModelId(model, this.modelName || ""), options.temperature !== undefined
+            ? { temperature: options.temperature }
+            : {}, "aiSdk.generateText");
         const result = await generateText({
             model,
             ...(system && { system }),
@@ -308,7 +317,7 @@ export class GenerationHandler {
                 }
                 return prepared;
             }),
-            temperature: options.temperature,
+            temperature: samplingParams.temperature,
             maxOutputTokens: options.maxTokens,
             maxRetries: 0, // NL11: Disable AI SDK's invisible internal retries; we handle retries with OTel instrumentation
             abortSignal: options.abortSignal,

package/dist/lib/core/toolExecutionRecorder.d.ts

@@ -0,0 +1,76 @@
+/**
+ * ToolExecutionRecorder — real per-call tool execution capture.
+ *
+ * One recorder is created per generate()/stream() call and attached to the
+ * request options (surviving option spreads). Tools are wrapped exactly once
+ * at the central tool-assembly points (BaseProvider.prepareGenerationContext /
+ * getToolsForStream), so every loop — the AI-SDK loop and the native
+ * Gemini/Anthropic loops alike — records through the same wrapper with real
+ * params, timing, and error status. Memory is bounded: serialized results are
+ * capped at `maxResultChars` and the record list at `maxRecords`.
+ */
+import type { Tool, ToolExecutionCaptureOptions, ToolExecutionRecord } from "../types/index.js";
+/** Default cap on serialized result characters kept per record (~8KB). */
+export declare const DEFAULT_TOOL_RESULT_CAPTURE_CHARS = 8192;
+/** Default cap on records kept per turn. */
+export declare const DEFAULT_TOOL_EXECUTION_MAX_RECORDS = 500;
+/**
+ * Serialize a tool result to bounded text. JSON when serializable, else
+ * String(); truncation is explicit so consumers know the text is partial.
+ */
+export declare function serializeToolResult(result: unknown, maxChars: number): string;
+/**
+ * Error-shaped tool results (MCP `isError`, `{error}` payloads) count as
+ * failures even though the loop received them as normal returns.
+ */
+export declare function isErrorShapedToolResult(result: unknown): boolean;
+/**
+ * Per-call recorder for tool executions. See module doc.
+ */
+export declare class ToolExecutionRecorder {
+    #private;
+    constructor(capture?: ToolExecutionCaptureOptions);
+    /** Record one completed (or failed) execution. Never throws. */
+    record(entry: {
+        toolName: string;
+        params: unknown;
+        result?: unknown;
+        error?: unknown;
+        startedAt: number;
+        durationMs: number;
+    }): void;
+    /** All records captured so far (oldest first, bounded by maxRecords). */
+    getRecords(): ToolExecutionRecord[];
+    /** True when at least one execution was recorded. */
+    hasRecords(): boolean;
+    /** Number of records evicted by the maxRecords cap. */
+    getDroppedCount(): number;
+    /**
+     * Wrap every executable tool so its invocations are recorded. Wrapping is
+     * idempotent — already-wrapped executes are left untouched, so a generate
+     * that falls back to another path never double-records.
+     */
+    wrapTools(tools: Record<string, Tool>): Record<string, Tool>;
+    /**
+     * Attach this recorder to a request options object. The property is
+     * enumerable on purpose: downstream stages spread options (`{...options}`)
+     * and the recorder must survive into the provider loops.
+     */
+    attachTo(options: Record<string, unknown>): void;
+    /** Retrieve the recorder a request is carrying, if any. */
+    static from(options: unknown): ToolExecutionRecorder | undefined;
+}
+/**
+ * Convert legacy loop-local `{name, input, output}` entries (plus optional
+ * timing/error fields) into `ToolExecutionRecord`s. Used as the fallback when
+ * a path produced executions the recorder did not see (e.g. results captured
+ * before the recorder existed, or breaker/not-found entries that never
+ * reached a real execute()).
+ */
+export declare function toToolExecutionRecords(legacyExecutions: unknown[] | undefined, capture?: ToolExecutionCaptureOptions): ToolExecutionRecord[];
+/**
+ * Resolve the toolExecutions for a result: recorder records when the request
+ * carried a recorder that saw executions, else a conversion of the loop's
+ * legacy accumulator entries.
+ */
+export declare function resolveToolExecutionRecords(options: unknown, legacyExecutions?: unknown[]): ToolExecutionRecord[];

package/dist/lib/core/toolExecutionRecorder.js

@@ -0,0 +1,262 @@
+/**
+ * ToolExecutionRecorder — real per-call tool execution capture.
+ *
+ * One recorder is created per generate()/stream() call and attached to the
+ * request options (surviving option spreads). Tools are wrapped exactly once
+ * at the central tool-assembly points (BaseProvider.prepareGenerationContext /
+ * getToolsForStream), so every loop — the AI-SDK loop and the native
+ * Gemini/Anthropic loops alike — records through the same wrapper with real
+ * params, timing, and error status. Memory is bounded: serialized results are
+ * capped at `maxResultChars` and the record list at `maxRecords`.
+ */
+import { logger } from "../utils/logger.js";
+/** Default cap on serialized result characters kept per record (~8KB). */
+export const DEFAULT_TOOL_RESULT_CAPTURE_CHARS = 8192;
+/** Default cap on records kept per turn. */
+export const DEFAULT_TOOL_EXECUTION_MAX_RECORDS = 500;
+/** Marker set on execute functions the recorder has already wrapped. */
+const RECORDER_WRAPPED = Symbol.for("neurolink.toolExecutionRecorder.wrapped");
+/** Internal options key the per-call recorder rides on (enumerable so it survives option spreads). */
+const RECORDER_OPTIONS_KEY = "toolExecutionRecorder";
+/**
+ * Serialize a tool result to bounded text. JSON when serializable, else
+ * String(); truncation is explicit so consumers know the text is partial.
+ */
+export function serializeToolResult(result, maxChars) {
+    let text;
+    if (typeof result === "string") {
+        text = result;
+    }
+    else {
+        try {
+            text = JSON.stringify(result) ?? String(result);
+        }
+        catch {
+            text = String(result);
+        }
+    }
+    if (text.length > maxChars) {
+        const dropped = text.length - maxChars;
+        text = `${text.slice(0, maxChars)}…[truncated ${dropped} chars]`;
+    }
+    return text;
+}
+/**
+ * Error-shaped tool results (MCP `isError`, `{error}` payloads) count as
+ * failures even though the loop received them as normal returns.
+ */
+export function isErrorShapedToolResult(result) {
+    if (!result || typeof result !== "object") {
+        return false;
+    }
+    const record = result;
+    if (record.isError === true) {
+        return true;
+    }
+    if (record.error !== undefined && record.error !== null) {
+        return true;
+    }
+    if (typeof record.status === "string") {
+        return ["error", "failed", "failure", "fail"].includes(record.status.toLowerCase().trim());
+    }
+    return false;
+}
+/**
+ * Per-call recorder for tool executions. See module doc.
+ */
+export class ToolExecutionRecorder {
+    // ES #private fields on purpose: the recorder rides on request options as
+    // an ENUMERABLE property (spread survival), so TS-only `private` fields
+    // would still be dragged into any JSON.stringify(options) — up to
+    // maxRecords × maxResultChars of tool results in a debug dump. #fields are
+    // invisible to serialization: the recorder stringifies as `{}`.
+    #maxResultChars;
+    #maxRecords;
+    #onRecord;
+    #records = [];
+    #droppedRecords = 0;
+    constructor(capture) {
+        this.#maxResultChars =
+            capture?.maxResultChars ?? DEFAULT_TOOL_RESULT_CAPTURE_CHARS;
+        this.#maxRecords =
+            capture?.maxRecords ?? DEFAULT_TOOL_EXECUTION_MAX_RECORDS;
+        this.#onRecord = capture?.onRecord;
+    }
+    /** Record one completed (or failed) execution. Never throws. */
+    record(entry) {
+        try {
+            const failed = entry.error !== undefined;
+            const record = {
+                toolName: entry.toolName,
+                params: entry.params,
+                resultText: serializeToolResult(failed
+                    ? entry.error instanceof Error
+                        ? entry.error.message
+                        : entry.error
+                    : entry.result, this.#maxResultChars),
+                isError: failed || isErrorShapedToolResult(entry.result),
+                startedAt: entry.startedAt,
+                durationMs: entry.durationMs,
+            };
+            this.#records.push(record);
+            if (this.#records.length > this.#maxRecords) {
+                this.#records.splice(0, this.#records.length - this.#maxRecords);
+                this.#droppedRecords++;
+            }
+            if (this.#onRecord) {
+                try {
+                    // Swallow async rejections too — the contract is that listener
+                    // errors (sync OR async) never disrupt the turn.
+                    void Promise.resolve(this.#onRecord(record)).catch(() => {
+                        // Listener errors never break the run.
+                    });
+                }
+                catch {
+                    // Listener errors never break the run.
+                }
+            }
+        }
+        catch (recordError) {
+            logger.debug("[ToolExecutionRecorder] Failed to record execution", {
+                error: recordError instanceof Error
+                    ? recordError.message
+                    : String(recordError),
+            });
+        }
+    }
+    /** All records captured so far (oldest first, bounded by maxRecords). */
+    getRecords() {
+        return [...this.#records];
+    }
+    /** True when at least one execution was recorded. */
+    hasRecords() {
+        return this.#records.length > 0;
+    }
+    /** Number of records evicted by the maxRecords cap. */
+    getDroppedCount() {
+        return this.#droppedRecords;
+    }
+    /**
+     * Wrap every executable tool so its invocations are recorded. Wrapping is
+     * idempotent — already-wrapped executes are left untouched, so a generate
+     * that falls back to another path never double-records.
+     */
+    wrapTools(tools) {
+        // Null prototype: a tool named "__proto__" must stay an own entry
+        // (mirrors BaseProvider.sortToolRecord / toolDiscovery partitioning).
+        const wrapped = Object.create(null);
+        for (const [name, tool] of Object.entries(tools)) {
+            const execute = tool.execute;
+            if (typeof execute !== "function" ||
+                execute[RECORDER_WRAPPED]) {
+                wrapped[name] = tool;
+                continue;
+            }
+            const recorder = this;
+            const recordingExecute = async (params, execOptions) => {
+                const startedAt = Date.now();
+                try {
+                    const result = await execute(params, execOptions);
+                    recorder.record({
+                        toolName: name,
+                        params,
+                        result,
+                        startedAt,
+                        durationMs: Date.now() - startedAt,
+                    });
+                    return result;
+                }
+                catch (error) {
+                    recorder.record({
+                        toolName: name,
+                        params,
+                        error,
+                        startedAt,
+                        durationMs: Date.now() - startedAt,
+                    });
+                    throw error;
+                }
+            };
+            recordingExecute[RECORDER_WRAPPED] = true;
+            wrapped[name] = { ...tool, execute: recordingExecute };
+        }
+        return wrapped;
+    }
+    /**
+     * Attach this recorder to a request options object. The property is
+     * enumerable on purpose: downstream stages spread options (`{...options}`)
+     * and the recorder must survive into the provider loops.
+     */
+    attachTo(options) {
+        options[RECORDER_OPTIONS_KEY] = this;
+    }
+    /** Retrieve the recorder a request is carrying, if any. */
+    static from(options) {
+        if (!options || typeof options !== "object") {
+            return undefined;
+        }
+        const candidate = options[RECORDER_OPTIONS_KEY];
+        return candidate instanceof ToolExecutionRecorder ? candidate : undefined;
+    }
+}
+/**
+ * Convert legacy loop-local `{name, input, output}` entries (plus optional
+ * timing/error fields) into `ToolExecutionRecord`s. Used as the fallback when
+ * a path produced executions the recorder did not see (e.g. results captured
+ * before the recorder existed, or breaker/not-found entries that never
+ * reached a real execute()).
+ */
+export function toToolExecutionRecords(legacyExecutions, capture) {
+    if (!legacyExecutions || !Array.isArray(legacyExecutions)) {
+        return [];
+    }
+    const maxChars = capture?.maxResultChars ?? DEFAULT_TOOL_RESULT_CAPTURE_CHARS;
+    const maxRecords = capture?.maxRecords ?? DEFAULT_TOOL_EXECUTION_MAX_RECORDS;
+    return legacyExecutions.slice(-maxRecords).map((entry, index) => {
+        const record = (entry ?? {});
+        // A canonical record round-tripping through this converter keeps its
+        // already-serialized resultText verbatim instead of re-serializing an
+        // absent `output` into the string "undefined".
+        const output = record.output ??
+            record.result ??
+            record.response ??
+            (typeof record.resultText === "string" ? record.resultText : undefined);
+        const durationMs = typeof record.durationMs === "number"
+            ? record.durationMs
+            : typeof record.duration === "number"
+                ? record.duration
+                : typeof record.executionTime === "number"
+                    ? record.executionTime
+                    : 0;
+        return {
+            toolName: record.name ||
+                record.toolName ||
+                `tool_execution_${index}`,
+            params: record.input ?? record.params ?? record.args ?? {},
+            resultText: serializeToolResult(output, maxChars),
+            isError: record.isError === true ||
+                record.success === false ||
+                record.error !== undefined ||
+                isErrorShapedToolResult(output),
+            startedAt: typeof record.startedAt === "number" ? record.startedAt : 0,
+            durationMs,
+        };
+    });
+}
+/**
+ * Resolve the toolExecutions for a result: recorder records when the request
+ * carried a recorder that saw executions, else a conversion of the loop's
+ * legacy accumulator entries.
+ */
+export function resolveToolExecutionRecords(options, legacyExecutions) {
+    const recorder = ToolExecutionRecorder.from(options);
+    if (recorder?.hasRecords()) {
+        return recorder.getRecords();
+    }
+    const capture = options && typeof options === "object"
+        ? options
+            .toolExecutionCapture
+        : undefined;
+    return toToolExecutionRecords(legacyExecutions, capture);
+}
+//# sourceMappingURL=toolExecutionRecorder.js.map

package/dist/lib/evaluation/contextBuilder.js

@@ -116,15 +116,15 @@ export class ContextBuilder {
         }
         return result.toolExecutions.map((exec) => {
             const toolResult = {
-                success: true,
-                data: exec.output,
+                success: !exec.isError,
+                data: exec.resultText,
             };
             return {
-                toolName: exec.name,
-                params: exec.input,
+                toolName: exec.toolName,
+                params: exec.params,
                 result: toolResult,
-                executionTime: 0,
-                timestamp: Date.now(),
+                executionTime: exec.durationMs,
+                timestamp: exec.startedAt || Date.now(),
             };
         });
     }