@juspay/neurolink 11.16.0 → 11.16.1

package/dist/core/geminiLoopAdapter.js

@@ -16,7 +16,8 @@
  * and original -> sanitized when writing `functionResponse` parts. Neither the
  * engine nor any other adapter needs to know sanitization happened.
  */
-import { collectStreamChunksIncremental, extractTextFromParts, mapGeminiFinishReason, pushModelResponseToHistory, refreshNativeToolDeclarations, } from "../providers/googleNativeGemini3/utils.js";
+import { resolveLiveTool } from "../tools/toolDiscovery.js";
+import { collectStreamChunksIncremental, guardToolExecutor, extractTextFromParts, mapGeminiFinishReason, pushModelResponseToHistory, refreshNativeToolDeclarations, } from "../providers/googleNativeGemini3/utils.js";
 export function createGeminiLoopAdapter(config) {
     /**
      * Sanitized wire name -> the name the caller registered. Rebuilt per step
@@ -87,17 +88,34 @@ export function createGeminiLoopAdapter(config) {
             }
             : {}),
         resolveToolOnMiss: (name) => {
-            const tool = config.liveTools?.[name];
+            // resolveLiveTool, NOT a plain record lookup. A deferred-catalog tool is
+            // not a key on the record at all — it lives behind a symbol-keyed
+            // resolver — so `liveTools[name]` returns undefined for exactly the
+            // tools this hook exists to hydrate, and the model gets TOOL_NOT_FOUND
+            // for a tool it was told about.
+            const tool = resolveLiveTool(config.liveTools, name);
             const execute = tool?.execute;
             if (!execute) {
                 return undefined;
             }
-            // Wrapped because the hook types `opts` as `unknown`, and a function
-            // declaring a narrower options type is not assignable to one accepting
-            // `unknown`. One assertion at the boundary, never a double assertion.
-            return {
-                execute: async (args, opts) => execute(args, opts),
-            };
+            // Registered into the turn's DedupExecuteMap and taken back through
+            // `.get()`, so a hydrated tool gets the same per-turn result cache as a
+            // declared one. A tool the model just discovered is the one most likely
+            // to be re-requested with identical arguments.
+            const executeMap = config.declarations?.executeMap;
+            let resolved = execute;
+            if (executeMap) {
+                executeMap.set(name, execute);
+                resolved = executeMap.get(name) ?? execute;
+            }
+            const guarded = config.toolGuards
+                ? guardToolExecutor(name, resolved, config.toolGuards)
+                : // Wrapped because the hook types `opts` as `unknown`, and a function
+                    // declaring a narrower options type is not assignable to one
+                    // accepting `unknown`. One assertion at the boundary, never a double
+                    // assertion.
+                    async (args, opts) => resolved(args, opts);
+            return { execute: guarded };
         },
         async executeStep(request, channel, signal) {
             const rawStream = await config.sendStep(request.raw, signal);

package/dist/core/loopEngine.js

@@ -87,9 +87,19 @@ async function dispatchStepTools(params) {
         // a deferred-catalog placeholder is exactly that shape, and it is
         // precisely what hydration exists to resolve.
         const declaredTool = tools?.[call.name];
-        const tool = declaredTool?.execute
-            ? declaredTool
-            : (adapter.resolveToolOnMiss?.(call.name) ?? declaredTool);
+        let tool = declaredTool;
+        if (!declaredTool?.execute) {
+            const hydrated = adapter.resolveToolOnMiss?.(call.name);
+            if (hydrated) {
+                tool = hydrated;
+                // It resolves NOW, so any strikes standing against this name were
+                // recorded while it genuinely did not resolve — snapshot artifacts of
+                // a deferred catalog, not failures of a tool that exists. Leaving them
+                // in place would disable the tool at the exact moment it became
+                // usable.
+                failedTools.delete(call.name);
+            }
+        }
         if (!tool?.execute) {
             const output = breaker
                 ? {

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

@@ -91,6 +91,22 @@ export declare function buildNativeToolDeclarations(tools: Record<string, Tool>,
  * 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.

package/dist/providers/googleNativeGemini3/utils.js

@@ -456,6 +456,41 @@ export function buildNativeToolDeclarations(tools, reservedNames) {
  * 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 call = () => Promise.resolve(execute(args, opts));
+        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.
@@ -487,29 +522,9 @@ export function buildDedupedEngineTools(declarations, tools, guards) {
      * mark — without them a legitimately slow tool reads as a stalled turn and
      * gets killed.
      */
-    const guard = (name, execute) => {
-        return async (args, opts) => {
-            const call = () => Promise.resolve(execute(args, opts));
-            if (!guards) {
-                return call();
-            }
-            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?.();
-            }
-        };
-    };
+    const guard = (name, execute) => guards
+        ? guardToolExecutor(name, execute, guards)
+        : async (args, opts) => execute(args, opts);
     if (declarations) {
         for (const [safeName, originalName] of declarations.originalNameMap) {
             const execute = declarations.executeMap.get(safeName);

package/dist/providers/googleVertex/client.js

@@ -1613,6 +1613,13 @@ export class GoogleVertexProvider extends BaseProvider {
                     classifyResultFailure: (output) => extractToolFailureText(output) ?? undefined,
                 },
                 liveTools: options.tools ?? {},
+                // A tool hydrated mid-turn gets the SAME bound, abort race and stall
+                // ping as one declared up front — see guardToolExecutor.
+                toolGuards: {
+                    toolTimeoutMs: toolExecTimeoutMs,
+                    abortSignal: effectiveSignal,
+                    onProgress: () => turnClock.noteProgress(),
+                },
                 ...(declarations ? { declarations } : {}),
                 ...(useFinalResultTool
                     ? {
@@ -2401,6 +2408,13 @@ export class GoogleVertexProvider extends BaseProvider {
                     classifyResultFailure: (output) => extractToolFailureText(output) ?? undefined,
                 },
                 liveTools: options.tools ?? {},
+                // A tool hydrated mid-turn gets the SAME bound, abort race and stall
+                // ping as one declared up front — see guardToolExecutor.
+                toolGuards: {
+                    toolTimeoutMs: toolExecTimeoutMs,
+                    abortSignal: effectiveSignal,
+                    onProgress: () => turnClock.noteProgress(),
+                },
                 ...(declarations ? { declarations } : {}),
                 ...(useFinalResultTool
                     ? {

package/dist/types/loopEngine.d.ts

@@ -326,6 +326,16 @@ export type GeminiLoopAdapterCoreConfig = {
      * step with that step's real token counts.
      */
     noteUsage?: (inputTokens: number, outputTokens: number) => void;
+    /**
+     * The same guards `buildDedupedEngineTools` wraps declared tools in, applied
+     * to one hydrated mid-turn.
+     *
+     * Without this a tool discovered during a turn is the ONE executor that runs
+     * raw: no per-turn dedup, no execution timeout, no stall-clock ping. That is
+     * 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;
     /**
      * 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.16.0",
+  "version": "11.16.1",
   "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": {
@@ -22,9 +22,8 @@
     "url": "https://github.com/sponsors/juspay"
   },
   "engines": {
-    "node": ">=20.19.0",
-    "npm": ">=10.0.0",
-    "pnpm": ">=8.0.0"
+    "node": ">=22.0.0",
+    "pnpm": ">=10.0.0"
   },
   "scripts": {
     "dev": "vite dev",
@@ -444,7 +443,7 @@
     "koa": "^3.1.1",
     "koa-bodyparser": "^4.4.1",
     "livekit-server-sdk": "^2.15.4",
-    "mammoth": "^1.11.0",
+    "mammoth": "1.12.0",
     "mediabunny": "^1.40.1",
     "music-metadata": "^11.11.2",
     "pdf-parse": "^2.4.5",
@@ -460,9 +459,7 @@
     "@changesets/cli": "^2.29.8",
     "@electric-sql/pglite": "^0.4.6",
     "@eslint/js": "^10.0.1",
-    "@juspay/hippocampus": ">=0.1.7",
     "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/sdk-trace-base": "^2.6.0",
     "@opentelemetry/sdk-trace-node": "^2.6.0",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/commit-analyzer": "^13.0.1",
@@ -481,7 +478,7 @@
     "@types/koa": "^3.0.1",
     "@types/koa-bodyparser": "^4.3.13",
     "@types/koa__cors": "^5.0.1",
-    "@types/node": "^25.3.3",
+    "@types/node": "^22.20.0",
     "@types/react": "^19.2.10",
     "@types/tar-stream": "^3.1.4",
     "@types/ws": "^8.18.1",
@@ -571,7 +568,6 @@
       "esbuild",
       "protobufjs",
       "puppeteer",
-      "sqlite3",
       "ffmpeg-static",
       "sharp"
     ],