@juspay/neurolink 11.15.9 → 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

@@ -373,9 +373,19 @@ const hasGoogleCredentials = () => {
             process.env.GOOGLE_AUTH_PRIVATE_KEY));
 };
 // Create Anthropic-specific Vertex settings for native @anthropic-ai/vertex-sdk
-const createVertexAnthropicSettings = async (region, timeoutMs) => {
+const createVertexAnthropicSettings = async (region, timeoutMs, direct, baseURL) => {
     const location = region || getVertexLocation();
-    const project = getVertexProjectId();
+    // Express-style auth carries its own credentials, so the ADC-derived project
+    // is neither available nor needed; asking for it would throw before the
+    // request is ever built. It cannot be EMPTY either — the SDK rejects a
+    // falsy projectId outright ("No projectId was given and it could not be
+    // resolved from credentials") — so a configured project is used when there
+    // is one and a placeholder stands in otherwise. The value only ever appears
+    // in the request path, which an endpoint reached this way is expected to
+    // route on its own.
+    const project = direct
+        ? direct.projectId?.trim() || "express"
+        : getVertexProjectId();
     return {
         projectId: project,
         region: location,
@@ -384,6 +394,26 @@ const createVertexAnthropicSettings = async (region, timeoutMs) => {
         // bound (a 429 with retry-after: 8549 sleeps 2.4h per retry, invisible
         // to fallback orchestration). Retries are the orchestrator's job.
         maxRetries: 0,
+        // Outside the express branch too: an endpoint override is about WHERE the
+        // request goes, not how it is authenticated, so a caller using ADC against
+        // a gateway needs it just as much.
+        ...(baseURL ? { baseURL } : {}),
+        ...(direct
+            ? {
+                // The token goes on the request directly. `accessToken` on the SDK's
+                // own options looks like it should do this and does not — the client
+                // stores it and never reads it for auth, so prepareOptions() still
+                // awaits Application Default Credentials and the call fails with a
+                // credentials error that names nothing useful. `authClient` is the
+                // option the SDK actually consults.
+                authClient: {
+                    getRequestHeaders: async () => ({
+                        Authorization: `Bearer ${direct.apiKey}`,
+                    }),
+                    projectId: null,
+                },
+            }
+            : {}),
     };
 };
 // Helper function to determine if a model is an Anthropic model
@@ -1583,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
                     ? {
@@ -2371,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
                     ? {
@@ -2844,7 +2888,20 @@ export class GoogleVertexProvider extends BaseProvider {
      */
     async createAnthropicVertexClient(timeoutMs) {
         const mod = await getAnthropicVertexModule();
-        const settings = await createVertexAnthropicSettings(this.location, timeoutMs);
+        const expressApiKey = this.resolveExpressApiKey();
+        const directBaseURL = this.baseURL?.trim() || process.env.GOOGLE_VERTEX_BASE_URL?.trim();
+        const settings = await createVertexAnthropicSettings(this.location, timeoutMs, expressApiKey
+            ? {
+                apiKey: expressApiKey,
+                ...(this.projectId ? { projectId: this.projectId } : {}),
+            }
+            : undefined, directBaseURL);
+        // One assertion, at the one place the shapes genuinely differ. The SDK
+        // declares `authClient` as its full `AuthClient` (24-plus members) while
+        // `prepareOptions()` only ever calls `getRequestHeaders()` and reads
+        // `projectId`. Naming the narrow surface in our own type and widening it
+        // here is the honest version of that gap; the alternative is standing up a
+        // real AuthClient to satisfy a contract the SDK does not exercise.
         const client = new mod.AnthropicVertex(settings);
         // The vertex SDK eagerly starts Google ADC resolution in its constructor
         // (`this._authClientPromise = this._auth.getClient()`) and only awaits it

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/dist/types/providers.d.ts

@@ -1052,6 +1052,18 @@ export type GoogleVertexProviderSettings = {
  * Anthropic Vertex AI settings for Claude models on Vertex
  * Used with @anthropic-ai/vertex-sdk
  */
+/**
+ * The two members `@anthropic-ai/vertex-sdk` actually uses off an auth client.
+ *
+ * Its declared `AuthClient` is far wider, but `prepareOptions()` only ever
+ * awaits `getRequestHeaders()` and reads `projectId` (client.js:109-111).
+ * Naming that narrow surface is what lets a caller supply a token directly
+ * instead of standing up Application Default Credentials.
+ */
+export type VertexAnthropicAuthClient = {
+    getRequestHeaders: () => Promise<Record<string, string>>;
+    projectId?: string | null;
+};
 export type AnthropicVertexSettings = {
     /** Google Cloud project ID */
     projectId: string;
@@ -1061,6 +1073,22 @@ export type AnthropicVertexSettings = {
     timeout?: number;
     /** SDK-internal retry budget (transport retries are the orchestrator's job) */
     maxRetries?: number;
+    /**
+     * Endpoint override. The SDK derives
+     * `https://${region}-aiplatform.googleapis.com/v1` by default; a gateway or
+     * a compatible endpoint is reached by setting this instead.
+     */
+    baseURL?: string;
+    /**
+     * Supply the request credentials directly, bypassing Application Default
+     * Credentials.
+     *
+     * Note that `accessToken` on the SDK's own options does NOT do this: the
+     * client stores it and never reads it for auth, so `prepareOptions()` still
+     * awaits ADC and a token-only caller fails with a credentials error that
+     * names nothing useful. `authClient` is the option that actually works.
+     */
+    authClient?: VertexAnthropicAuthClient;
 };
 /**
  * OpenAI-compatible models endpoint response structure

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "11.15.9",
+  "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",
@@ -211,7 +210,8 @@
     "test:sagemaker-streaming": "tsx test/continuous-test-suite-sagemaker-streaming.ts",
     "test:anthropic-loop-characterization": "tsx test/continuous-test-suite-anthropic-loop-characterization.ts",
     "test:aistudio-loop-characterization": "tsx test/continuous-test-suite-aistudio-loop-characterization.ts",
-    "test:docs-mcp": "npx tsx test/continuous-test-suite-docs-mcp.ts"
+    "test:docs-mcp": "npx tsx test/continuous-test-suite-docs-mcp.ts",
+    "test:vertex-claude-characterization": "tsx test/continuous-test-suite-vertex-claude-characterization.ts"
   },
   "files": [
     "dist",
@@ -443,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",
@@ -459,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",
@@ -480,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",
@@ -570,7 +568,6 @@
       "esbuild",
       "protobufjs",
       "puppeteer",
-      "sqlite3",
       "ffmpeg-static",
       "sharp"
     ],