@juspay/neurolink 11.18.2 → 11.18.4

package/dist/core/geminiLoopAdapter.js

@@ -16,8 +16,9 @@
  * and original -> sanitized when writing `functionResponse` parts. Neither the
  * engine nor any other adapter needs to know sanitization happened.
  */
+import { guardToolExecutor } from "./toolExecutionGuards.js";
 import { resolveLiveTool } from "../tools/toolDiscovery.js";
-import { collectStreamChunksIncremental, guardToolExecutor, extractTextFromParts, mapGeminiFinishReason, pushModelResponseToHistory, refreshNativeToolDeclarations, } from "../providers/googleNativeGemini3/utils.js";
+import { collectStreamChunksIncremental, extractTextFromParts, mapGeminiFinishReason, pushModelResponseToHistory, refreshNativeToolDeclarations, } from "../providers/googleNativeGemini3/utils.js";
 export function createGeminiLoopAdapter(config) {
     /**
      * Sanitized wire name -> the name the caller registered. Rebuilt per step

package/dist/core/toolExecutionGuards.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Guards applied around a single tool execution inside a native provider loop.
+ *
+ * Lives here rather than beside any one provider because it is used by all of
+ * them: both Vertex+Claude loops call it directly, and the Gemini paths reach
+ * it through `buildDedupedEngineTools`. It previously sat in
+ * `providers/googleNativeGemini3/utils.ts`, which meant the Anthropic loops
+ * imported a tool-execution primitive out of a Gemini module — accurate about
+ * where it was written, misleading about what depends on it.
+ *
+ * Nothing in here is provider-specific: it takes an executor and a guards
+ * object and returns a wrapped executor.
+ */
+import type { Tool, ToolExecutionGuards } from "../types/index.js";
+/**
+ * Mid-turn tool sync for the native Gemini loops that build their snapshot
+ * via buildNativeToolDeclarations. `search_tools` (tools.discovery) hydrates
+ * discovered tools into the live record between steps; without this refresh
+ * they stay invisible to the rest of the turn and every call dies as
+ * TOOL_NOT_FOUND. Mutates the snapshot in place — the request config holds
+ * `toolsConfig` by reference — and returns true when anything was added.
+ */
+/**
+ * Everything a native Gemini loop wraps around a tool call that the shared
+ * engine does not do itself.
+ *
+ * Order matters. `raceWithAbort` sits INSIDE `withTimeout` so a turn-level
+ * abort is observed the moment it fires rather than after the tool settles,
+ * and the timeout still bounds a tool that neither settles nor honours its
+ * signal. The progress pings bracket the await because the stall watchdog is
+ * a whole-turn interval comparing wall-clock against the last progress mark —
+ * without them a legitimately slow tool reads as a stalled turn and is killed.
+ *
+ * Exported because a tool hydrated MID-TURN has to be wrapped the same way as
+ * one declared up front; keeping this inline made the discovered tool the one
+ * executor in the system that ran raw.
+ */
+export declare function guardToolExecutor(name: string, execute: NonNullable<Tool["execute"]>, guards: ToolExecutionGuards): (args: Record<string, unknown>, opts: unknown) => Promise<unknown>;

package/dist/core/toolExecutionGuards.js

@@ -0,0 +1,61 @@
+/**
+ * Guards applied around a single tool execution inside a native provider loop.
+ *
+ * Lives here rather than beside any one provider because it is used by all of
+ * them: both Vertex+Claude loops call it directly, and the Gemini paths reach
+ * it through `buildDedupedEngineTools`. It previously sat in
+ * `providers/googleNativeGemini3/utils.ts`, which meant the Anthropic loops
+ * imported a tool-execution primitive out of a Gemini module — accurate about
+ * where it was written, misleading about what depends on it.
+ *
+ * Nothing in here is provider-specific: it takes an executor and a guards
+ * object and returns a wrapped executor.
+ */
+import { raceWithAbort, withTimeout } from "../utils/async/index.js";
+/**
+ * Mid-turn tool sync for the native Gemini loops that build their snapshot
+ * via buildNativeToolDeclarations. `search_tools` (tools.discovery) hydrates
+ * discovered tools into the live record between steps; without this refresh
+ * they stay invisible to the rest of the turn and every call dies as
+ * TOOL_NOT_FOUND. Mutates the snapshot in place — the request config holds
+ * `toolsConfig` by reference — and returns true when anything was added.
+ */
+/**
+ * Everything a native Gemini loop wraps around a tool call that the shared
+ * engine does not do itself.
+ *
+ * Order matters. `raceWithAbort` sits INSIDE `withTimeout` so a turn-level
+ * abort is observed the moment it fires rather than after the tool settles,
+ * and the timeout still bounds a tool that neither settles nor honours its
+ * signal. The progress pings bracket the await because the stall watchdog is
+ * a whole-turn interval comparing wall-clock against the last progress mark —
+ * without them a legitimately slow tool reads as a stalled turn and is killed.
+ *
+ * Exported because a tool hydrated MID-TURN has to be wrapped the same way as
+ * one declared up front; keeping this inline made the discovered tool the one
+ * executor in the system that ran raw.
+ */
+export function guardToolExecutor(name, execute, guards) {
+    return async (args, opts) => {
+        const invoke = () => Promise.resolve(execute(args, opts));
+        // The span wraps the CALL, not the guard: a timeout or an abort is a fact
+        // about this tool invocation and belongs inside its observation.
+        const wrapInSpan = guards.withToolSpan;
+        const call = wrapInSpan ? () => wrapInSpan(name, invoke) : invoke;
+        guards.onProgress?.();
+        try {
+            const raced = guards.abortSignal
+                ? raceWithAbort(call(), guards.abortSignal)
+                : call();
+            return await (guards.toolTimeoutMs === undefined
+                ? raced
+                : withTimeout(raced, guards.toolTimeoutMs, `Tool "${name}" execution timed out after ${guards.toolTimeoutMs}ms`));
+        }
+        finally {
+            // In `finally`, not after a successful await: a tool that times out or
+            // throws has still consumed real time, and skipping the mark there would
+            // leave the watchdog measuring from before the call.
+            guards.onProgress?.();
+        }
+    };
+}

package/dist/providers/googleNativeGemini3/utils.d.ts

@@ -9,7 +9,7 @@
  * providers so they can share a single implementation.
  */
 import type { GenerateStopReason, ThinkingConfig, AgenticLoopOptions, ChatMessage, CollectedChunkResult, MinimalChatMessage, NativeFunctionCall, NativeFunctionResponse, NativeToolDeclarationsResult, NativeToolsConfig, StreamChannel, VertexNativePart, GeminiMultimodalInput, MultimodalAudioEntry } from "../../types/index.js";
-import type { Tool, GeminiToolExecutionGuards } from "../../types/index.js";
+import type { Tool, ToolExecutionGuards } from "../../types/index.js";
 /**
  * A per-turn tool execute map that deduplicates identical tool calls.
  *
@@ -34,30 +34,6 @@ export declare class DedupExecuteMap extends Map<string, Tool["execute"]> {
  * This handles both Zod schemas and plain JSON Schema objects for tool parameters.
  */
 export declare function buildNativeToolDeclarations(tools: Record<string, Tool>, reservedNames?: ReadonlySet<string>): NativeToolDeclarationsResult;
-/**
- * Mid-turn tool sync for the native Gemini loops that build their snapshot
- * via buildNativeToolDeclarations. `search_tools` (tools.discovery) hydrates
- * discovered tools into the live record between steps; without this refresh
- * they stay invisible to the rest of the turn and every call dies as
- * TOOL_NOT_FOUND. Mutates the snapshot in place — the request config holds
- * `toolsConfig` by reference — and returns true when anything was added.
- */
-/**
- * Everything a native Gemini loop wraps around a tool call that the shared
- * engine does not do itself.
- *
- * Order matters. `raceWithAbort` sits INSIDE `withTimeout` so a turn-level
- * abort is observed the moment it fires rather than after the tool settles,
- * and the timeout still bounds a tool that neither settles nor honours its
- * signal. The progress pings bracket the await because the stall watchdog is
- * a whole-turn interval comparing wall-clock against the last progress mark —
- * without them a legitimately slow tool reads as a stalled turn and is killed.
- *
- * Exported because a tool hydrated MID-TURN has to be wrapped the same way as
- * one declared up front; keeping this inline made the discovered tool the one
- * executor in the system that ran raw.
- */
-export declare function guardToolExecutor(name: string, execute: NonNullable<Tool["execute"]>, guards: GeminiToolExecutionGuards): (args: Record<string, unknown>, opts: unknown) => Promise<unknown>;
 /**
  * Build the tool record handed to `runAgenticLoop`, routed through the turn's
  * DedupExecuteMap.
@@ -75,7 +51,7 @@ export declare function guardToolExecutor(name: string, execute: NonNullable<Too
  * identical in every test that calls a tool once, and silently reintroduces
  * duplicate side effects the moment the model repeats itself.
  */
-export declare function buildDedupedEngineTools(declarations: NativeToolDeclarationsResult | undefined, tools: Record<string, Tool> | undefined, guards?: GeminiToolExecutionGuards): NonNullable<AgenticLoopOptions["tools"]>;
+export declare function buildDedupedEngineTools(declarations: NativeToolDeclarationsResult | undefined, tools: Record<string, Tool> | undefined, guards?: ToolExecutionGuards): NonNullable<AgenticLoopOptions["tools"]>;
 export declare function refreshNativeToolDeclarations(liveTools: Record<string, Tool> | undefined, current: NativeToolDeclarationsResult): string[];
 /**
  * Build the native @google/genai config object shared by stream and generate.

package/dist/providers/googleNativeGemini3/utils.js

@@ -14,11 +14,11 @@ 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 { needsAudioTranscode, toProviderCompatibleAudio, } from "../../adapters/audioFormatSupport.js";
 import { logger } from "../../utils/logger.js";
+import { guardToolExecutor } from "../../core/toolExecutionGuards.js";
 import { resolveSamplingParams } from "../../models/modelRegistry.js";
 import { convertZodToJsonSchema, ensureNestedSchemaTypes, inlineJsonSchema, isZodSchema, } from "../../utils/schemaConversion.js";
 import { createNativeThinkingConfig } from "../../utils/thinkingConfig.js";
 import { resolveLiveTool } from "../../tools/toolDiscovery.js";
-import { raceWithAbort, withTimeout } from "../../utils/async/index.js";
 // ── Functions ──
 /** Stable, key-order-independent serialization of tool args for the dedup key. */
 function stableStringifyForDedup(value) {
@@ -324,53 +324,6 @@ export function buildNativeToolDeclarations(tools, reservedNames) {
         originalNameMap,
     };
 }
-/**
- * Mid-turn tool sync for the native Gemini loops that build their snapshot
- * via buildNativeToolDeclarations. `search_tools` (tools.discovery) hydrates
- * discovered tools into the live record between steps; without this refresh
- * they stay invisible to the rest of the turn and every call dies as
- * TOOL_NOT_FOUND. Mutates the snapshot in place — the request config holds
- * `toolsConfig` by reference — and returns true when anything was added.
- */
-/**
- * Everything a native Gemini loop wraps around a tool call that the shared
- * engine does not do itself.
- *
- * Order matters. `raceWithAbort` sits INSIDE `withTimeout` so a turn-level
- * abort is observed the moment it fires rather than after the tool settles,
- * and the timeout still bounds a tool that neither settles nor honours its
- * signal. The progress pings bracket the await because the stall watchdog is
- * a whole-turn interval comparing wall-clock against the last progress mark —
- * without them a legitimately slow tool reads as a stalled turn and is killed.
- *
- * Exported because a tool hydrated MID-TURN has to be wrapped the same way as
- * one declared up front; keeping this inline made the discovered tool the one
- * executor in the system that ran raw.
- */
-export function guardToolExecutor(name, execute, guards) {
-    return async (args, opts) => {
-        const invoke = () => Promise.resolve(execute(args, opts));
-        // The span wraps the CALL, not the guard: a timeout or an abort is a fact
-        // about this tool invocation and belongs inside its observation.
-        const wrapInSpan = guards.withToolSpan;
-        const call = wrapInSpan ? () => wrapInSpan(name, invoke) : invoke;
-        guards.onProgress?.();
-        try {
-            const raced = guards.abortSignal
-                ? raceWithAbort(call(), guards.abortSignal)
-                : call();
-            return await (guards.toolTimeoutMs === undefined
-                ? raced
-                : withTimeout(raced, guards.toolTimeoutMs, `Tool "${name}" execution timed out after ${guards.toolTimeoutMs}ms`));
-        }
-        finally {
-            // In `finally`, not after a successful await: a tool that times out or
-            // throws has still consumed real time, and skipping the mark there would
-            // leave the watchdog measuring from before the call.
-            guards.onProgress?.();
-        }
-    };
-}
 /**
  * Build the tool record handed to `runAgenticLoop`, routed through the turn's
  * DedupExecuteMap.

package/dist/providers/googleVertex/client.js

@@ -1,6 +1,7 @@
 /* eslint-disable max-lines-per-function */
 // Native SDK imports - no more @ai-sdk/google-vertex dependency
 import fs from "fs";
+import { guardToolExecutor } from "../../core/toolExecutionGuards.js";
 import path from "path";
 import { ErrorCategory, ErrorSeverity, } from "../../constants/enums.js";
 import { BaseProvider } from "../../core/baseProvider.js";
@@ -33,7 +34,6 @@ import { appendStepText, buildAbortedTurnMessage, buildContextCapMessage, buildD
 import { createGeminiLoopAdapter } from "../../core/geminiLoopAdapter.js";
 import { runAgenticLoop } from "../../core/loopEngine.js";
 import { createAnthropicLoopAdapter } from "../anthropic/loopAdapter.js";
-import { guardToolExecutor } from "../googleNativeGemini3/utils.js";
 import { extractMcpToolErrorMessage } from "../../utils/mcpErrorText.js";
 import { createStreamChannel } from "../../core/streamChannel.js";
 import { toNativeToolDeclarations } from "../../core/nativeToolFormat.js";

package/dist/types/loopEngine.d.ts

@@ -289,16 +289,22 @@ export type AnthropicLoopAdapterConfig<TMessage = Anthropic.Messages.MessagePara
     abortSignal?: AbortSignal;
 };
 /**
- * The three things a native Gemini loop wraps around every tool call that the
- * shared engine does not do itself.
+ * The things a native loop wraps around every tool call that the shared engine
+ * does not do itself.
  *
- * All optional, and the whole object is optional, because the two Gemini
- * providers differ here: Vertex bounds tool execution and runs a stall
- * watchdog, AI Studio does neither. Passing nothing leaves an executor exactly
- * as the caller supplied it, so this cannot quietly give AI Studio behaviour
- * its hand-rolled loops never had.
+ * NOT Gemini-specific, despite where this started. Both Vertex+Claude loops
+ * apply these guards directly via `guardToolExecutor`, and the Gemini adapter
+ * applies them to hydrated tools, so the former `GeminiToolExecutionGuards`
+ * name described the first caller rather than the contract — and pointed the
+ * next reader at the wrong provider family.
+ *
+ * All optional, and the whole object is optional, because callers differ:
+ * Vertex bounds tool execution and runs a stall watchdog, AI Studio does
+ * neither. Passing nothing leaves an executor exactly as the caller supplied
+ * it, so this cannot quietly give a provider behaviour its hand-rolled loops
+ * never had.
  */
-export type GeminiToolExecutionGuards = {
+export type ToolExecutionGuards = {
     /** Upper bound on a single execute(); omit for no bound. */
     toolTimeoutMs?: number;
     /**
@@ -328,6 +334,13 @@ export type GeminiToolExecutionGuards = {
      */
     withToolSpan?: <T>(name: string, run: () => Promise<T>) => Promise<T>;
 };
+/**
+ * @deprecated Renamed to `ToolExecutionGuards` — the guards were never
+ * Gemini-specific. Kept because this name is re-exported from the package root
+ * via the types barrel, so removing it outright would break any consumer that
+ * imports it (CLAUDE.md rule 5). Safe to drop at the next major.
+ */
+export type GeminiToolExecutionGuards = ToolExecutionGuards;
 /** What one Gemini step produced, carried to `buildToolResultMessages`. */
 export type GeminiStepRaw = {
     rawResponseParts: unknown[];
@@ -394,7 +407,7 @@ export type GeminiLoopAdapterCoreConfig = {
      * the opposite of what discovery is for — the tool the model just found is
      * the one most likely to be called repeatedly with the same arguments.
      */
-    toolGuards?: GeminiToolExecutionGuards;
+    toolGuards?: ToolExecutionGuards;
     /**
      * Name of the terminal structured-output tool when one is in play. A call
      * to it ends the turn: its arguments ARE the answer, so it is reported as

package/dist/utils/fileDetector.js

@@ -5,7 +5,8 @@
  */
 import { open, readFile, realpath } from "fs/promises";
 import { basename, isAbsolute as isAbsolutePath, relative as relativePath, resolve as resolvePath, sep, } from "path";
-import { getGlobalDispatcher, interceptors, request } from "undici";
+import { request } from "undici";
+import { redirectFollowingDispatcher } from "./redirectDispatcher.js";
 // Lazy-loaded processor singletons — avoids loading heavy media deps
 // (mediabunny, fluent-ffmpeg, music-metadata, adm-zip) on every generate() call.
 async function getVideoProcessor() {
@@ -1519,7 +1520,7 @@ export class FileDetector {
         if (getCachedUrlContentType(url, Date.now()) === undefined) {
             try {
                 const head = await request(url, {
-                    dispatcher: getGlobalDispatcher().compose(interceptors.redirect({ maxRedirections: 5 })),
+                    dispatcher: redirectFollowingDispatcher(5),
                     method: "HEAD",
                     headersTimeout: FileDetector.DEFAULT_HEAD_TIMEOUT,
                     bodyTimeout: FileDetector.DEFAULT_HEAD_TIMEOUT,
@@ -1550,7 +1551,7 @@ export class FileDetector {
         return withRetry(async () => {
             try {
                 const response = await request(url, {
-                    dispatcher: getGlobalDispatcher().compose(interceptors.redirect({ maxRedirections: 5 })),
+                    dispatcher: redirectFollowingDispatcher(5),
                     method: "GET",
                     headersTimeout: timeout,
                     bodyTimeout: timeout,
@@ -2283,7 +2284,7 @@ class MimeTypeStrategy {
                 // dump() can't hang detection, per the project's async-timeout guideline.
                 contentType = await withTimeout((async () => {
                     const response = await request(input, {
-                        dispatcher: getGlobalDispatcher().compose(interceptors.redirect({ maxRedirections: 5 })),
+                        dispatcher: redirectFollowingDispatcher(5),
                         method: "HEAD",
                         headersTimeout: FileDetector.DEFAULT_HEAD_TIMEOUT,
                         bodyTimeout: FileDetector.DEFAULT_HEAD_TIMEOUT,

package/dist/utils/messageBuilder.js

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, statSync } from "fs";
 import { readFile as readFileAsync, stat as statAsync } from "fs/promises";
-import { getGlobalDispatcher, interceptors, request } from "undici";
+import { request } from "undici";
+import { redirectFollowingDispatcher } from "./redirectDispatcher.js";
 import { MultimodalLogger, ProviderImageAdapter, } from "../adapters/providerImageAdapter.js";
 import { CONVERSATION_INSTRUCTIONS, STRUCTURED_OUTPUT_INSTRUCTIONS, } from "../config/conversationMemory.js";
 import { getAvailableInputTokens } from "../constants/contextWindows.js";
@@ -1660,7 +1661,7 @@ async function downloadImageFromUrl(url) {
     await urlDownloadRateLimiter.acquire();
     try {
         const response = await request(url, {
-            dispatcher: getGlobalDispatcher().compose(interceptors.redirect({ maxRedirections: 5 })),
+            dispatcher: redirectFollowingDispatcher(5),
             method: "GET",
             headersTimeout: 10000, // 10 second timeout for headers
             bodyTimeout: 30000, // 30 second timeout for body,

package/dist/utils/redirectDispatcher.d.ts

@@ -0,0 +1,28 @@
+import type { Dispatcher } from "undici";
+/**
+ * A dispatcher that follows redirects, when composing one is safe here.
+ *
+ * `getGlobalDispatcher()` returns Node's **built-in** undici dispatcher, whose
+ * major tracks the runtime rather than this package's dependency. The composed
+ * result is then passed to the **npm** undici's `request()`, and the two majors
+ * do not share a handler contract:
+ *
+ *   node 24   built-in 7.24.4 + npm 7.28.0   request() succeeds
+ *   node 22   built-in 6.28.0 + npm 7.28.0   throws "invalid onError method"
+ *
+ * Node 22 is this package's declared minimum, so the broken combination is not
+ * exotic — it is the floor. The throw happens at request time rather than at
+ * compose(), which is why it surfaces as an opaque runtime error instead of
+ * something recognisably about versions.
+ *
+ * When the majors disagree, return the global dispatcher uncomposed. That drops
+ * redirect-following from the pre-flight HEAD only. Callers already treat any
+ * non-2xx HEAD — a redirect included — as untrustworthy and fall through to the
+ * streaming size guard on the GET, so the size protection is unchanged and the
+ * cost is one extra round trip.
+ *
+ * Composing onto the global dispatcher rather than a fresh `Agent` is
+ * deliberate: it preserves whatever the host application configured globally,
+ * such as a corporate ProxyAgent.
+ */
+export declare function redirectFollowingDispatcher(maxRedirections: number): Dispatcher;

package/dist/utils/redirectDispatcher.js

@@ -0,0 +1,43 @@
+import { getGlobalDispatcher, interceptors } from "undici";
+/**
+ * The major of the `undici` this package depends on.
+ *
+ * `dependencies.undici` is `>=7.24.0 <8.0.0`, and `pnpm.overrides` maps
+ * `undici@>=8.0.0` back into that same range, so major 7 is a declared
+ * invariant rather than an observation. Update both together if it ever moves.
+ */
+const NPM_UNDICI_MAJOR = 7;
+/**
+ * A dispatcher that follows redirects, when composing one is safe here.
+ *
+ * `getGlobalDispatcher()` returns Node's **built-in** undici dispatcher, whose
+ * major tracks the runtime rather than this package's dependency. The composed
+ * result is then passed to the **npm** undici's `request()`, and the two majors
+ * do not share a handler contract:
+ *
+ *   node 24   built-in 7.24.4 + npm 7.28.0   request() succeeds
+ *   node 22   built-in 6.28.0 + npm 7.28.0   throws "invalid onError method"
+ *
+ * Node 22 is this package's declared minimum, so the broken combination is not
+ * exotic — it is the floor. The throw happens at request time rather than at
+ * compose(), which is why it surfaces as an opaque runtime error instead of
+ * something recognisably about versions.
+ *
+ * When the majors disagree, return the global dispatcher uncomposed. That drops
+ * redirect-following from the pre-flight HEAD only. Callers already treat any
+ * non-2xx HEAD — a redirect included — as untrustworthy and fall through to the
+ * streaming size guard on the GET, so the size protection is unchanged and the
+ * cost is one extra round trip.
+ *
+ * Composing onto the global dispatcher rather than a fresh `Agent` is
+ * deliberate: it preserves whatever the host application configured globally,
+ * such as a corporate ProxyAgent.
+ */
+export function redirectFollowingDispatcher(maxRedirections) {
+    const globalDispatcher = getGlobalDispatcher();
+    const builtinMajor = Number.parseInt(process.versions.undici?.split(".")[0] ?? "", 10);
+    if (!Number.isFinite(builtinMajor) || builtinMajor !== NPM_UNDICI_MAJOR) {
+        return globalDispatcher;
+    }
+    return globalDispatcher.compose(interceptors.redirect({ maxRedirections }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "11.18.2",
+  "version": "11.18.4",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {