@juspay/neurolink 10.5.2 → 10.6.0

package/dist/cli/loop/optionsSchema.d.ts

@@ -4,4 +4,4 @@ import type { OptionSchema, TextGenerationOptions } from "../../lib/types/index.
  * This object provides metadata for validation and help text in the CLI loop.
  * It is derived from the main TextGenerationOptions interface to ensure consistency.
  */
-export declare const textGenerationOptionsSchema: Record<keyof Omit<TextGenerationOptions, "prompt" | "input" | "schema" | "tools" | "context" | "conversationHistory" | "conversationMessages" | "conversationMemoryConfig" | "originalPrompt" | "middleware" | "expectedOutcome" | "evaluationCriteria" | "region" | "csvOptions" | "pdfOptions" | "tts" | "stt" | "thinkingConfig" | "requestId" | "fileRegistry" | "abortSignal" | "toolFilter" | "excludeTools" | "toolChoice" | "prepareStep" | "credentials" | "onFinish" | "onError" | "processors" | "piiDetection" | "responseValidation" | "inputValidation">, OptionSchema>;
+export declare const textGenerationOptionsSchema: Record<keyof Omit<TextGenerationOptions, "prompt" | "input" | "schema" | "tools" | "context" | "conversationHistory" | "conversationMessages" | "conversationMemoryConfig" | "originalPrompt" | "middleware" | "expectedOutcome" | "evaluationCriteria" | "region" | "csvOptions" | "pdfOptions" | "tts" | "stt" | "thinkingConfig" | "requestId" | "fileRegistry" | "abortSignal" | "toolFilter" | "excludeTools" | "toolChoice" | "prepareStep" | "credentials" | "onFinish" | "onError" | "processors" | "piiDetection" | "responseValidation" | "inputValidation" | "toolExecutionCapture" | "toolExecutionRecorder">, OptionSchema>;

package/dist/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/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/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/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/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/core/toolExecutionRecorder.js

@@ -0,0 +1,261 @@
+/**
+ * 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);
+}

package/dist/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(),
             };
         });
     }

package/dist/lib/agent/agent.js

@@ -108,6 +108,12 @@ export class Agent {
             timestamp: startTime,
         });
         try {
+            // No ghost runs: an already-aborted parent stops the agent before any
+            // model call is made. Typed so callers can branch on the ABORT
+            // category instead of parsing free text.
+            if (options?.abortSignal?.aborted) {
+                throw ErrorFactory.aborted(new Error("Agent execution aborted before start"));
+            }
             // Validate input if schema provided
             if (this.inputSchema && typeof input !== "string") {
                 const validation = this.inputSchema.safeParse(input);
@@ -149,19 +155,14 @@ export class Agent {
                 contentLength: result.content?.length || 0,
                 toolsUsed: result.toolsUsed?.length || 0,
             });
-            // Pass through toolExecutions, adding duration (not provided by generate())
-            const toolExecutions = result.toolExecutions?.map((te) => ({
-                name: te.name,
-                input: te.input,
-                output: te.output,
-                duration: 0,
-            }));
             const agentResult = {
                 content: result.content || "",
                 object: parsedOutput,
                 usage: result.usage,
                 toolsUsed: result.toolsUsed,
-                toolExecutions,
+                // Real per-call records straight from the tool loop (N2)
+                toolExecutions: result.toolExecutions,
+                stopReason: result.stopReason,
                 duration,
                 status: "success",
                 agentId: this.id,
@@ -219,6 +220,10 @@ export class Agent {
             traceId,
         };
         try {
+            // Mirror execute(): an already-aborted parent never starts the stream.
+            if (options?.abortSignal?.aborted) {
+                throw ErrorFactory.aborted(new Error("Agent stream aborted before start"));
+            }
             // Validate input if schema provided
             if (this.inputSchema && typeof input !== "string") {
                 const validation = this.inputSchema.safeParse(input);
@@ -367,6 +372,20 @@ export class Agent {
             ...(this.tools && this.tools.length > 0 && { toolFilter: this.tools }),
             maxSteps: options?.maxSteps ?? this.maxSteps,
             requestId: traceId,
+            // Turn budget + cancellation, forwarded verbatim to generate() — the
+            // machinery (wrap-up nudge, stall watchdog, honest stopReason) lives
+            // in the tool loop; the agent layer just passes it through.
+            ...(options?.abortSignal && { abortSignal: options.abortSignal }),
+            ...(options?.timeout !== undefined && { timeout: options.timeout }),
+            ...(options?.turnTimeoutMs !== undefined && {
+                turnTimeoutMs: options.turnTimeoutMs,
+            }),
+            ...(options?.wrapupTimeLeadMs !== undefined && {
+                wrapupTimeLeadMs: options.wrapupTimeLeadMs,
+            }),
+            ...(options?.stallTimeoutMs !== undefined && {
+                stallTimeoutMs: options.stallTimeoutMs,
+            }),
             context: {
                 agentId: this.id,
                 agentName: this.name,
@@ -390,6 +409,18 @@ export class Agent {
             // toolFilter delegates to BaseProvider.applyToolFiltering() natively
             ...(this.tools && this.tools.length > 0 && { toolFilter: this.tools }),
             maxSteps: options?.maxSteps ?? this.maxSteps,
+            // Turn budget + cancellation, forwarded verbatim to stream()
+            ...(options?.abortSignal && { abortSignal: options.abortSignal }),
+            ...(options?.timeout !== undefined && { timeout: options.timeout }),
+            ...(options?.turnTimeoutMs !== undefined && {
+                turnTimeoutMs: options.turnTimeoutMs,
+            }),
+            ...(options?.wrapupTimeLeadMs !== undefined && {
+                wrapupTimeLeadMs: options.wrapupTimeLeadMs,
+            }),
+            ...(options?.stallTimeoutMs !== undefined && {
+                stallTimeoutMs: options.stallTimeoutMs,
+            }),
             context: {
                 agentId: this.id,
                 agentName: this.name,