@juspay/neurolink 10.5.3 → 10.6.1

package/dist/providers/googleNativeGemini3.d.ts

@@ -107,6 +107,8 @@ export declare function buildNativeConfig(options: {
     temperature?: number;
     maxTokens?: number;
     systemPrompt?: string;
+    /** Model id, used for the registry-driven sampling-param strip. */
+    model?: string;
     thinkingConfig?: ThinkingConfig;
     /**
      * When true (and `toolsConfig` is undefined), set

package/dist/providers/googleNativeGemini3.js

@@ -13,6 +13,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { extname } from "node:path";
 import { DEFAULT_CONTEXT_GUARD_RATIO, DEFAULT_MAX_STEPS, DEFAULT_TOOL_MAX_RETRIES, DEFAULT_WRAPUP_TIME_LEAD_MS, } from "../core/constants.js";
 import { logger } from "../utils/logger.js";
+import { resolveSamplingParams } from "../models/modelRegistry.js";
 import { convertZodToJsonSchema, ensureNestedSchemaTypes, inlineJsonSchema, isZodSchema, normalizeJsonSchemaObject, } from "../utils/schemaConversion.js";
 import { createNativeThinkingConfig } from "../utils/thinkingConfig.js";
 import { resolveLiveTool } from "../tools/toolDiscovery.js";
@@ -487,8 +488,14 @@ export function refreshNativeToolDeclarations(liveTools, current) {
  * `disableTools: true` whenever JSON/schema output is requested.
  */
 export function buildNativeConfig(options, toolsConfig) {
+    // Registry-driven sampling strip applied for uniformity with every other
+    // provider path (inert for current Gemini models).
+    const samplingParams = resolveSamplingParams("google-ai", options.model, { temperature: options.temperature ?? 1.0 }, // Gemini 3 requires 1.0 for tool calling
+    "googleAiStudio.buildNativeConfig");
     const config = {
-        temperature: options.temperature ?? 1.0, // Gemini 3 requires 1.0 for tool calling
+        ...(samplingParams.temperature !== undefined && {
+            temperature: samplingParams.temperature,
+        }),
         maxOutputTokens: options.maxTokens,
     };
     if (toolsConfig) {

package/dist/providers/googleVertex.js

@@ -31,6 +31,8 @@ import { ATTR, LANGFUSE_ATTR, spanJsonAttribute, tracers, withClientSpan, withCl
 import { SpanKind, SpanStatusCode, context as otelContext, trace as otelTrace, } from "@opentelemetry/api";
 import { calculateCost } from "../utils/pricing.js";
 import { transformToolExecutions } from "../utils/transformationUtils.js";
+import { resolveToolExecutionRecords } from "../core/toolExecutionRecorder.js";
+import { resolveSamplingParams } from "../models/modelRegistry.js";
 import { sanitizeAnthropicMessagesForTrace } from "../utils/anthropicTraceSanitizer.js";
 import { extractMcpToolErrorMessage, extractToolFailureText, } from "../utils/mcpErrorText.js";
 // Import proper types for multimodal message handling
@@ -1344,9 +1346,16 @@ export class GoogleVertexProvider extends BaseProvider {
                 totalTools: existingDeclarations.length,
             });
         }
-        // Build config
-        const config = {
+        // Build config. Registry-driven sampling strip applied for uniformity
+        // with every other provider path (inert for current Gemini models).
+        const geminiSampling = resolveSamplingParams(this.providerName, modelName, {
             temperature: options.temperature ?? 1.0, // Gemini 3 requires 1.0 for tool calling
+            ...(options.topP !== undefined && { topP: options.topP }),
+        }, "vertex.gemini");
+        const config = {
+            ...(geminiSampling.temperature !== undefined && {
+                temperature: geminiSampling.temperature,
+            }),
             maxOutputTokens: options.maxTokens,
         };
         // Cap maxOutputTokens for models with restricted output token limits (32768)
@@ -1363,8 +1372,8 @@ export class GoogleVertexProvider extends BaseProvider {
             }
         }
         // Add topP, topK, stopSequences if provided
-        if (options.topP !== undefined) {
-            config.topP = options.topP;
+        if (geminiSampling.topP !== undefined) {
+            config.topP = geminiSampling.topP;
         }
         if (options.topK !== undefined) {
             config.topK = options.topK;
@@ -2272,9 +2281,16 @@ export class GoogleVertexProvider extends BaseProvider {
                 totalTools: existingDeclarations.length,
             });
         }
-        // Build config
-        const config = {
+        // Build config. Registry-driven sampling strip applied for uniformity
+        // with every other provider path (inert for current Gemini models).
+        const geminiSampling = resolveSamplingParams(this.providerName, modelName, {
             temperature: options.temperature ?? 1.0, // Gemini 3 requires 1.0 for tool calling
+            ...(options.topP !== undefined && { topP: options.topP }),
+        }, "vertex.gemini");
+        const config = {
+            ...(geminiSampling.temperature !== undefined && {
+                temperature: geminiSampling.temperature,
+            }),
             maxOutputTokens: options.maxTokens,
         };
         // Cap maxOutputTokens for models with restricted output token limits (32768)
@@ -2291,8 +2307,8 @@ export class GoogleVertexProvider extends BaseProvider {
             }
         }
         // Add topP, topK, stopSequences if provided
-        if (options.topP !== undefined) {
-            config.topP = options.topP;
+        if (geminiSampling.topP !== undefined) {
+            config.topP = geminiSampling.topP;
         }
         if (options.topK !== undefined) {
             config.topK = options.topK;
@@ -2954,7 +2970,7 @@ export class GoogleVertexProvider extends BaseProvider {
             },
             responseTime,
             toolsUsed: externalToolCalls.map((tc) => tc.toolName),
-            toolExecutions: transformToolExecutions(externalToolExecutions),
+            toolExecutions: resolveToolExecutionRecords(options, externalToolExecutions),
             enhancedWithTools: externalToolCalls.length > 0,
         };
         // Add structured output if final_result tool was used
@@ -3301,6 +3317,16 @@ export class GoogleVertexProvider extends BaseProvider {
             : schemaSystemPromptSuffix
                 ? schemaSystemPromptSuffix.trim()
                 : undefined;
+        // Registry-driven strip: Sonnet 5 / Opus 4.7+ / Fable 5 on Vertex reject
+        // sampling params. Applied here so every rebuild that spreads
+        // `...requestParams` (forced finalization, tools-off backstop) inherits
+        // the strip automatically.
+        const streamSampling = resolveSamplingParams(this.providerName, modelName, {
+            ...(options.temperature !== undefined && {
+                temperature: options.temperature,
+            }),
+            ...(options.topP !== undefined && { topP: options.topP }),
+        }, "vertex.anthropic.stream");
         const requestParams = {
             model: modelName,
             // Default to the model's real output ceiling (e.g. 64K for Sonnet 4.x)
@@ -3312,10 +3338,12 @@ export class GoogleVertexProvider extends BaseProvider {
             ...(tools && tools.length > 0 && { tools }),
             ...(useFinalResultTool && { tool_choice: { type: "any" } }),
             ...(systemPromptWithSchema && { system: systemPromptWithSchema }),
-            ...(options.temperature !== undefined && {
-                temperature: options.temperature,
+            ...(streamSampling.temperature !== undefined && {
+                temperature: streamSampling.temperature,
+            }),
+            ...(streamSampling.topP !== undefined && {
+                top_p: streamSampling.topP,
             }),
-            ...(options.topP !== undefined && { top_p: options.topP }),
             ...(options.stopSequences &&
                 options.stopSequences.length > 0 && {
                 stop_sequences: options.stopSequences,
@@ -4596,6 +4624,16 @@ export class GoogleVertexProvider extends BaseProvider {
             : schemaSystemPromptSuffix
                 ? schemaSystemPromptSuffix.trim()
                 : undefined;
+        // Registry-driven strip: Sonnet 5 / Opus 4.7+ / Fable 5 on Vertex reject
+        // sampling params. Applied at the requestParams build so the forced
+        // finalization and tools-off backstop rebuilds (`...requestParams`)
+        // inherit the strip automatically.
+        const generateSampling = resolveSamplingParams(this.providerName, modelName, {
+            ...(options.temperature !== undefined && {
+                temperature: options.temperature,
+            }),
+            ...(options.topP !== undefined && { topP: options.topP }),
+        }, "vertex.anthropic.generate");
         const requestParams = {
             model: modelName,
             // Default to the model's real output ceiling (see stream path note).
@@ -4604,10 +4642,12 @@ export class GoogleVertexProvider extends BaseProvider {
             ...(tools && tools.length > 0 && { tools }),
             ...(useFinalResultTool && { tool_choice: { type: "any" } }),
             ...(systemPromptWithSchema && { system: systemPromptWithSchema }),
-            ...(options.temperature !== undefined && {
-                temperature: options.temperature,
+            ...(generateSampling.temperature !== undefined && {
+                temperature: generateSampling.temperature,
+            }),
+            ...(generateSampling.topP !== undefined && {
+                top_p: generateSampling.topP,
             }),
-            ...(options.topP !== undefined && { top_p: options.topP }),
             ...(options.stopSequences &&
                 options.stopSequences.length > 0 && {
                 stop_sequences: options.stopSequences,
@@ -5357,7 +5397,7 @@ export class GoogleVertexProvider extends BaseProvider {
             },
             responseTime,
             toolsUsed: externalToolCalls.map((tc) => tc.toolName),
-            toolExecutions: transformToolExecutions(externalToolExecutions),
+            toolExecutions: resolveToolExecutionRecords(options, externalToolExecutions),
             enhancedWithTools: externalToolCalls.length > 0,
         };
         // Route through enhanceResult so analytics/evaluation/tracing are picked

package/dist/providers/openaiChatCompletionsClient.js

@@ -15,6 +15,7 @@
  */
 import { createParser } from "eventsource-parser";
 import { sanitizeToolName } from "../mcp/toolConverter.js";
+import { resolveSamplingParams } from "../models/modelRegistry.js";
 import { convertZodToJsonSchema, normalizeWireToolSchema, } from "../utils/schemaConversion.js";
 import { estimateTokens, TOKENS_PER_MESSAGE, } from "../utils/tokenEstimation.js";
 export const stripTrailingSlash = (s) => s.replace(/\/+$/, "");
@@ -454,11 +455,23 @@ export const buildBody = (args) => {
     if (options.maxTokens !== undefined && options.maxTokens !== null) {
         body.max_tokens = options.maxTokens;
     }
-    if (options.temperature !== undefined && options.temperature !== null) {
-        body.temperature = options.temperature;
-    }
-    if (options.topP !== undefined && options.topP !== null) {
-        body.top_p = options.topP;
+    // Registry-driven strip: models that reject sampling params (Sonnet 5 /
+    // Opus 4.7+ / Fable 5 families — e.g. Claude served through litellm)
+    // must not receive temperature/top_p. Applied in buildBody so the 400
+    // one-shot retries, which reuse the built body, inherit the strip.
+    const samplingParams = resolveSamplingParams("openai-compatible", modelId, {
+        ...(options.temperature !== undefined && options.temperature !== null
+            ? { temperature: options.temperature }
+            : {}),
+        ...(options.topP !== undefined && options.topP !== null
+            ? { topP: options.topP }
+            : {}),
+    }, "openaiCompatible.buildBody");
+    if (samplingParams.temperature !== undefined) {
+        body.temperature = samplingParams.temperature;
+    }
+    if (samplingParams.topP !== undefined) {
+        body.top_p = samplingParams.topP;
     }
     if (options.presencePenalty !== undefined &&
         options.presencePenalty !== null) {

package/dist/tasks/autoresearchTaskExecutor.js

@@ -15,6 +15,7 @@
 import { ResearchWorker } from "../autoresearch/worker.js";
 import { withTimeout } from "../utils/errorHandling.js";
 import { logger } from "../utils/logger.js";
+import { toolExecutionRecordsToToolCalls } from "../utils/transformationUtils.js";
 // ── Worker cache ────────────────────────────────────────
 const workerCache = new Map();
 /**
@@ -252,7 +253,11 @@ export async function executeAutoresearchTick(task, neurolink, emitter) {
         const calledTools = (result.toolExecutions ?? [])
             .map((te) => {
             const t = te;
-            return typeof t.name === "string" ? t.name : "";
+            return typeof t.toolName === "string"
+                ? t.toolName
+                : typeof t.name === "string"
+                    ? t.name
+                    : "";
         })
             .filter(Boolean);
         const currentState = await worker.getState();
@@ -271,11 +276,7 @@ export async function executeAutoresearchTick(task, neurolink, emitter) {
             runId,
             status: "success",
             output: result.content,
-            toolCalls: result.toolExecutions?.map((te) => ({
-                name: te.name,
-                input: te.input,
-                output: te.output,
-            })),
+            toolCalls: toolExecutionRecordsToToolCalls(result.toolExecutions),
             tokensUsed: result.usage
                 ? { input: result.usage.input ?? 0, output: result.usage.output ?? 0 }
                 : undefined,

package/dist/tasks/taskExecutor.js

@@ -9,6 +9,7 @@
  */
 import { nanoid } from "nanoid";
 import { logger } from "../utils/logger.js";
+import { toolExecutionRecordsToToolCalls } from "../utils/transformationUtils.js";
 import { executeAutoresearchTick } from "./autoresearchTaskExecutor.js";
 /** Errors that are transient and should be retried */
 const TRANSIENT_PATTERNS = [
@@ -134,11 +135,7 @@ export class TaskExecutor {
             runId,
             status: "success",
             output: result.content,
-            toolCalls: result.toolExecutions?.map((te) => ({
-                name: te.name,
-                input: te.input,
-                output: te.output,
-            })),
+            toolCalls: toolExecutionRecordsToToolCalls(result.toolExecutions),
             tokensUsed: result.usage
                 ? {
                     input: result.usage.input ?? 0,

package/dist/types/agentNetwork.d.ts

@@ -7,6 +7,7 @@
 import type { z } from "zod";
 import type { AIProviderName } from "../constants/enums.js";
 import type { TokenUsage } from "./analytics.js";
+import type { GenerateStopReason, ToolExecutionRecord } from "./generate.js";
 /**
  * Agent definition for creating agents in the network
  */
@@ -56,13 +57,16 @@ export type AgentResult = {
     usage?: TokenUsage;
     /** Tools used during execution */
     toolsUsed?: string[];
-    /** Detailed tool execution info */
-    toolExecutions?: Array<{
-        name: string;
-        input: Record<string, unknown>;
-        output: unknown;
-        duration: number;
-    }>;
+    /**
+     * Real per-call tool execution records from the underlying generate()
+     * turn (params, bounded result text, error flag, timing per call).
+     */
+    toolExecutions?: ToolExecutionRecord[];
+    /**
+     * Why the agentic turn ended (`completed`, `step-cap`, `time-limit`,
+     * `stalled`, `aborted`, …) — see {@link GenerateStopReason}.
+     */
+    stopReason?: GenerateStopReason;
     /** Execution duration in milliseconds */
     duration: number;
     /** Execution status */
@@ -84,8 +88,19 @@ export type AgentExecutionOptions = {
     traceId?: string;
     /** Parent span ID for nested tracing */
     parentSpanId?: string;
-    /** Timeout in milliseconds */
+    /** Per-model-call timeout in milliseconds (see GenerateOptions.timeout) */
     timeout?: number;
+    /**
+     * Abort signal threaded into every generate() the agent makes. An aborted
+     * parent stops the agent — no ghost runs.
+     */
+    abortSignal?: AbortSignal;
+    /** Wall-clock cap for the whole agentic turn (ms). See GenerateOptions.turnTimeoutMs. */
+    turnTimeoutMs?: number;
+    /** Remaining-time threshold for the wrap-up nudge (ms). See GenerateOptions.wrapupTimeLeadMs. */
+    wrapupTimeLeadMs?: number;
+    /** Max time with no progress before the turn ends as "stalled" (ms). See GenerateOptions.stallTimeoutMs. */
+    stallTimeoutMs?: number;
     /** Per-execution credentials override */
     credentials?: Record<string, unknown>;
 };

package/dist/types/generate.d.ts

@@ -363,6 +363,13 @@ export type GenerateOptions = {
     toolTimeoutMs?: number;
     /** AbortSignal for external cancellation of the AI call */
     abortSignal?: AbortSignal;
+    /**
+     * Bounds for the per-call tool execution records surfaced on
+     * `GenerateResult.toolExecutions`. Capture is on by default
+     * (maxResultChars 8192, maxRecords 500); pass larger caps when the caller
+     * needs full result texts.
+     */
+    toolExecutionCapture?: ToolExecutionCaptureOptions;
     /** Disable the schema-driven tool call repair mechanism (BZ-665). Default: false (repair enabled). */
     disableToolCallRepair?: boolean;
     /**
@@ -677,6 +684,52 @@ export type AdditionalMemoryUser = {
     /** Max words for this user's condensed memory. Overrides the default maxWords. */
     maxWords?: number;
 };
+/**
+ * One real tool invocation captured during an agentic turn.
+ *
+ * Replaces the historical `{name, input, output}` stub on `GenerateResult`:
+ * every record is produced at the actual execution site (AI-SDK loop and the
+ * native Gemini/Anthropic loops alike), so `params`, timing, and error status
+ * reflect what really ran — consumers no longer need proxy "recorder" tools
+ * to observe their own tool traffic.
+ */
+export type ToolExecutionRecord = {
+    /** Tool name as the model called it. */
+    toolName: string;
+    /** Parameters the tool was invoked with, as parsed by the loop. */
+    params: unknown;
+    /**
+     * Serialized tool result (JSON when serializable, else String()), bounded
+     * by `toolExecutionCapture.maxResultChars` (default ~8KB). Truncated text
+     * ends with a `…[truncated N chars]` marker.
+     */
+    resultText: string;
+    /** True when the execution threw or returned an error-shaped result. */
+    isError: boolean;
+    /** Epoch milliseconds when the execution started. */
+    startedAt: number;
+    /** Wall-clock duration of the execution in milliseconds. */
+    durationMs: number;
+};
+/**
+ * Bounds for per-call tool execution capture (see `ToolExecutionRecord`).
+ * Capture is ON by default with these caps; raise them when a caller needs
+ * full result texts (e.g. caller-side evidence verification).
+ */
+export type ToolExecutionCaptureOptions = {
+    /** Max serialized result characters kept per record (default 8192). */
+    maxResultChars?: number;
+    /** Max records kept per turn; oldest are dropped first (default 500). */
+    maxRecords?: number;
+    /**
+     * Fire-and-forget per-record callback, invoked as each tool execution
+     * completes. Listener errors — synchronous throws AND async rejections —
+     * are swallowed; they never break the turn. Used by supervisors (e.g. the
+     * isolated-agent runner's waste detection) and callers that stream
+     * evidence as it is gathered.
+     */
+    onRecord?: (record: ToolExecutionRecord) => void | Promise<void>;
+};
 /**
  * Why an agentic turn ended — the discriminator consumers should branch on
  * instead of sniffing the provider-shaped `finishReason` (whose values are
@@ -832,11 +885,13 @@ export type GenerateResult = {
     }>;
     toolResults?: unknown[];
     toolsUsed?: string[];
-    toolExecutions?: Array<{
-        name: string;
-        input: StandardRecord;
-        output: unknown;
-    }>;
+    /**
+     * Real per-call tool execution records captured in the tool loop —
+     * params, bounded serialized result, error flag, and timing per call.
+     * Populated on the AI-SDK loop and the native agentic loops alike.
+     * Bounded by `toolExecutionCapture` (default on, ~8KB per result).
+     */
+    toolExecutions?: ToolExecutionRecord[];
     enhancedWithTools?: boolean;
     availableTools?: Array<{
         name: string;
@@ -1042,6 +1097,8 @@ export type TextGenerationOptions = {
     toolTimeoutMs?: number;
     /** AbortSignal for external cancellation of the AI call */
     abortSignal?: AbortSignal;
+    /** Bounds for tool execution capture. See GenerateOptions.toolExecutionCapture. */
+    toolExecutionCapture?: ToolExecutionCaptureOptions;
     disableTools?: boolean;
     /** Disable the schema-driven tool call repair mechanism (BZ-665). Default: false (repair enabled). */
     disableToolCallRepair?: boolean;

package/dist/types/index.d.ts

@@ -28,6 +28,7 @@ export * from "./generate.js";
 export * from "./grounding.js";
 export * from "./guardrails.js";
 export * from "./hitl.js";
+export * from "./isolatedAgent.js";
 export * from "./knowledge.js";
 export * from "./livekit.js";
 export * from "./mcp.js";

package/dist/types/index.js

@@ -29,6 +29,7 @@ export * from "./generate.js";
 export * from "./grounding.js";
 export * from "./guardrails.js";
 export * from "./hitl.js";
+export * from "./isolatedAgent.js";
 export * from "./knowledge.js";
 export * from "./livekit.js";
 export * from "./mcp.js";