@juspay/neurolink 11.18.3 → 11.18.5

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/proxy/geminiFormat.js

@@ -20,6 +20,14 @@
  */
 /** Google's role for assistant turns. */
 const MODEL_ROLE = "model";
+/**
+ * Sent as `input.text` when a request's final turn is a model turn.
+ *
+ * Google lets a client continue generation from the assistant's own last turn;
+ * the chat-completions wire format the engine targets has no way to say that,
+ * and an empty prompt is rejected before any provider is reached.
+ */
+const CONTINUATION_PROMPT = "Continue.";
 function partsToText(parts) {
     if (!Array.isArray(parts)) {
         return "";
@@ -91,11 +99,24 @@ export function parseGeminiRequest(model, body, stream) {
     // it, which is the same lost-turn bug one case further along.
     //
     // A terminal placeholder restores the invariant: the slice removes this
-    // instead of the model turn. It is never sent anywhere — `prompt` is
-    // independently "" in exactly this case, so the placeholder only exists to be
-    // consumed by the slice.
+    // instead of the model turn.
+    //
+    // The prompt needs its own answer, and leaving it "" was a 500. A
+    // model-final request carries no user turn to send as `input.text`, and
+    // NeuroLink's stream() rejects an empty one outright — "Stream options must
+    // include either input.text, input.audio, or stt.audio" — so every continue
+    // from a model turn failed at the door rather than reaching a provider. The
+    // placeholder above fixed the history slice but never exercised this path,
+    // because nothing had sent the request.
+    //
+    // Google's semantics for a model-final `contents` are "keep going", and the
+    // chat-completions shape the engine translates into has no assistant-prefill
+    // to express that. An explicit continuation instruction is the closest
+    // faithful equivalent: the full conversation still arrives as history, and
+    // the model is told to continue it rather than being handed an empty turn.
     if (turns.length > 0 && turns[turns.length - 1].role !== "user") {
-        conversationMessages.push({ role: "user", content: "" });
+        conversationMessages.push({ role: "user", content: CONTINUATION_PROMPT });
+        prompt = CONTINUATION_PROMPT;
     }
     const numeric = (v) => typeof v === "number" && Number.isFinite(v) ? v : undefined;
     const stops = generationConfig.stopSequences;

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "11.18.3",
+  "version": "11.18.5",
   "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": {