@juspay/neurolink 10.4.1 → 10.4.2

package/dist/lib/tools/toolDiscovery.js

@@ -6,12 +6,19 @@
  * requested tools, and previously discovered tools) plus ONE `search_tools`
  * meta-tool whose description embeds a compact name+summary catalog of the
  * deferred tools. Calling `search_tools` loads matching tools:
- *  - immediately into the live tool record (providers that re-read the tools
- *    record between agent-loop steps — the AI SDK path — can call them on the
- *    very next step), and
+ *  - immediately into the live tool record — the AI SDK path re-reads the
+ *    record between agent-loop steps, and the native loops (Vertex
+ *    Gemini/Claude, AI Studio, chat-completions, direct Anthropic) re-resolve
+ *    against it on a dispatch miss and refresh their wire declarations per
+ *    step — so discovered tools are callable on the very next step, and
  *  - into the session pin set (all providers include them in full on every
  *    subsequent call of the session).
  *
+ * The record additionally carries a symbol-keyed {@link DeferredToolResolver}
+ * (see `resolveDeferredTool`) so a loop can hydrate a cataloged tool the
+ * model called directly by name WITHOUT a prior search_tools call — the
+ * catalog advertises exact names, so models legitimately do this.
+ *
  * Evidence for this design: catalogs past ~30-50 tools measurably degrade
  * tool-selection accuracy, and deferral+search both cuts definition tokens by
  * ~85% and RAISES selection accuracy (Anthropic MCP-eval 49%→74% on Opus 4).
@@ -23,6 +30,14 @@ import { z } from "zod";
 import { tool as createAISDKTool } from "../utils/tool.js";
 import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
 import { logger } from "../utils/logger.js";
+/**
+ * Symbol key under which the hot record carries its deferred-tool resolver.
+ * Symbol-keyed properties are skipped by Object.keys/entries, for-in, and
+ * JSON.stringify, so no declaration builder (or the AI SDK) ever sees the
+ * resolver as a tool. `Symbol.for` (global registry) keeps the key stable
+ * even if this module is loaded twice (ESM/CJS dual load of the bundle).
+ */
+const DEFERRED_TOOL_RESOLVER_KEY = Symbol.for("neurolink.deferredToolResolver");
 /**
  * Above this many tools, a WARN suggests enabling `tools.discovery` when it
  * is off. Chosen from the measured degradation range (30-50 tools).
@@ -162,6 +177,35 @@ export function partitionToolsForDiscovery(tools, args) {
         };
     });
     hot["search_tools"] = buildSearchTool(entries, tools, hot, args.onHydrate);
+    // Dispatch-miss escape hatch for the native agent loops: hydrate a
+    // deferred tool the model called directly by its cataloged name (the
+    // catalog advertises exact names, so this is legitimate model behavior,
+    // not hallucination). Hydration mutates the hot record and persists the
+    // session pin — identical side effects to a search_tools hit.
+    const resolver = (name) => {
+        if (name in hot) {
+            return hot[name];
+        }
+        if (!deferredSet.has(name)) {
+            return undefined;
+        }
+        const toolDef = tools[name];
+        if (!toolDef) {
+            return undefined;
+        }
+        hot[name] = toolDef;
+        args.onHydrate([name]);
+        logger.debug("[ToolDiscovery] Auto-hydrated deferred tool on direct call", {
+            name,
+        });
+        return toolDef;
+    };
+    Object.defineProperty(hot, DEFERRED_TOOL_RESOLVER_KEY, {
+        value: resolver,
+        enumerable: false,
+        writable: false,
+        configurable: true,
+    });
     logger.debug("[ToolDiscovery] Deferred external tools behind search_tools", {
         hotCount: Object.keys(hot).length - 1,
         deferredCount: deferredNames.length,
@@ -169,6 +213,34 @@ export function partitionToolsForDiscovery(tools, args) {
     });
     return hot;
 }
+/**
+ * Hydrate-and-return a deferred tool by name, when `record` was produced by
+ * `partitionToolsForDiscovery` and `name` is in its deferred catalog.
+ * Returns `undefined` for records without a resolver (discovery off) and for
+ * names that are genuinely unknown — callers keep their hallucinated-name
+ * handling for that case.
+ */
+export function resolveDeferredTool(record, name) {
+    if (!record) {
+        return undefined;
+    }
+    const resolver = record[DEFERRED_TOOL_RESOLVER_KEY];
+    return typeof resolver === "function"
+        ? resolver(name)
+        : undefined;
+}
+/**
+ * Live tool lookup for native agent loops on a dispatch miss: first re-reads
+ * the record (a tool hydrated by search_tools after the loop built its
+ * pre-step snapshot), then falls back to auto-hydrating from the deferred
+ * catalog. Returns `undefined` only when the name is genuinely unknown.
+ */
+export function resolveLiveTool(record, name) {
+    if (!record) {
+        return undefined;
+    }
+    return record[name] ?? resolveDeferredTool(record, name);
+}
 function buildSearchTool(entries, allTools, hotRecord, onHydrate) {
     const catalog = renderCatalog(entries);
     const searchTool = createAISDKTool({
@@ -221,7 +293,7 @@ function buildSearchTool(entries, allTools, hotRecord, onHydrate) {
             return {
                 found: loaded.length,
                 tools: loaded,
-                message: "These tools are now loaded for this session. Call them directly by name with arguments matching their inputSchema. If a call reports the tool as unavailable, it will be available from the next message onward.",
+                message: "These tools are now loaded for this session. Call them directly by name with arguments matching their inputSchema.",
             };
         },
     });

package/dist/lib/types/toolResolution.d.ts

@@ -8,6 +8,7 @@
  * `BaseProvider` that every generate/stream path passes through.
  */
 import type { ToolConfig } from "./config.js";
+import type { Tool } from "./tools.js";
 /**
  * The resolved, merged tool policy for one request. Produced by
  * `resolveToolPolicy()` (src/lib/tools/toolPolicy.ts) and consumed by
@@ -71,3 +72,12 @@ export type DeferredToolIndexEntry = {
     /** Originating MCP server id, when known. */
     serverId?: string;
 };
+/**
+ * Resolver attached (under a symbol key, invisible to enumeration) to the
+ * hot tool record by `partitionToolsForDiscovery`. Given a deferred tool's
+ * name it hydrates that tool into the record, persists the session pin, and
+ * returns it — `undefined` when the name is not in the deferred catalog.
+ * Native agent loops call it on a dispatch miss so a model that calls a
+ * cataloged tool directly (without `search_tools` first) still succeeds.
+ */
+export type DeferredToolResolver = (name: string) => Tool | undefined;

package/dist/providers/anthropic.js

@@ -15,6 +15,7 @@ import { logger } from "../utils/logger.js";
 import { redactUrlCredentials } from "../utils/logSanitize.js";
 import { ANTHROPIC_MAX_CACHE_BREAKPOINTS, applyAnthropicHistoryCacheBreakpoints, countAnthropicCacheMarkers, } from "../utils/anthropicCacheBreakpoints.js";
 import { calculateCost } from "../utils/pricing.js";
+import { resolveDeferredTool } from "../tools/toolDiscovery.js";
 import { createAnthropicConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, mergeAbortSignals, TimeoutError, } from "../utils/timeout.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
@@ -1400,6 +1401,18 @@ export class AnthropicProvider extends BaseProvider {
             let totalCacheWrite = 0;
             let lastStop = null;
             for (let step = 0; step < maxSteps; step++) {
+                // Mid-turn discovery sync: search_tools (tools.discovery) hydrates
+                // new tools into toolsRecord between steps; Claude only calls tools
+                // declared in the request, so advertise them now (`params` below
+                // rebuilds from anthropicTools every step).
+                if (anthropicTools) {
+                    const declared = new Set(anthropicTools.map((t) => t.name));
+                    const hydrated = Object.fromEntries(Object.entries(toolsRecord).filter(([name]) => !declared.has(name)));
+                    if (Object.keys(hydrated).length > 0) {
+                        anthropicTools.push(...(toolsToAnthropic(hydrated) ?? []));
+                        logger.info(`[Anthropic] ${Object.keys(hydrated).length} tool(s) hydrated mid-turn via discovery: ${Object.keys(hydrated).join(", ")}`);
+                    }
+                }
                 // Prompt-cache parity with the native Vertex+Claude path — rolling
                 // history breakpoints, re-applied per step so the stable prefix
                 // stays byte-identical while the breakpoint follows the growing
@@ -1566,7 +1579,11 @@ export class AnthropicProvider extends BaseProvider {
                         args,
                     });
                     toolsUsed.push(acc.name);
-                    const tool = toolsRecord[acc.name];
+                    // Live record lookup, then deferred-catalog auto-hydration: with
+                    // tools.discovery on, the model may call a cataloged tool it never
+                    // loaded via search_tools — a real tool, not a hallucination.
+                    const tool = (toolsRecord[acc.name] ??
+                        resolveDeferredTool(toolsRecord, acc.name));
                     try {
                         if (!tool?.execute) {
                             throw new Error(`Tool not found: ${acc.name}`);

package/dist/providers/googleAiStudio.js

@@ -10,7 +10,7 @@ import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../
 import { withTimeout } from "../utils/async/index.js";
 import { estimateTokens } from "../utils/tokenEstimation.js";
 import { transformToolExecutions } from "../utils/transformationUtils.js";
-import { buildGeminiResponseSchema, buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps, createTextChannel, buildUserPartsWithMultimodal, executeNativeToolCalls, extractTextFromParts, extractThoughtSignature, handleMaxStepsTermination, prependConversationMessages, pushModelResponseToHistory, DedupExecuteMap, } from "./googleNativeGemini3.js";
+import { buildGeminiResponseSchema, buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps, createTextChannel, buildUserPartsWithMultimodal, executeNativeToolCalls, extractTextFromParts, extractThoughtSignature, handleMaxStepsTermination, prependConversationMessages, pushModelResponseToHistory, refreshNativeToolDeclarations, DedupExecuteMap, } from "./googleNativeGemini3.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 // Google AI Live API types now imported from ../types/providerSpecific.js
 // Import proper types for multimodal message handling
@@ -523,10 +523,12 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 let toolsConfig;
                 let executeMap = new DedupExecuteMap();
                 let originalNameMap = new Map();
+                let declarationsResult;
                 if (options.tools &&
                     Object.keys(options.tools).length > 0 &&
                     !options.disableTools) {
                     const result = buildNativeToolDeclarations(options.tools);
+                    declarationsResult = result;
                     toolsConfig = result.toolsConfig;
                     executeMap = result.executeMap;
                     originalNameMap = result.originalNameMap;
@@ -597,6 +599,11 @@ export class GoogleAIStudioProvider extends BaseProvider {
                                     : new Error("Request aborted");
                             }
                             step++;
+                            // Mid-turn discovery sync: advertise tools hydrated into the
+                            // live record by search_tools during the previous step.
+                            if (declarationsResult) {
+                                refreshNativeToolDeclarations(options.tools, declarationsResult);
+                            }
                             logger.debug(`[GoogleAIStudio] Native SDK step ${step}/${maxSteps}`);
                             try {
                                 const rawStream = await client.models.generateContentStream({
@@ -640,6 +647,8 @@ export class GoogleAIStudioProvider extends BaseProvider {
                                     abortSignal: composedSignal,
                                     originalNameMap,
                                     toolExecutions,
+                                    liveTools: options.tools,
+                                    declarations: declarationsResult,
                                 });
                                 // Persist this step's tool calls/results into conversation
                                 // memory. Without this, tool_call / tool_result rows never
@@ -810,11 +819,13 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 let toolsConfig;
                 let executeMap = new DedupExecuteMap();
                 let originalNameMap = new Map();
+                let declarationsResult;
                 const shouldUseTools = !options.disableTools;
                 if (shouldUseTools) {
                     const tools = options.tools || {};
                     if (Object.keys(tools).length > 0) {
                         const result = buildNativeToolDeclarations(tools);
+                        declarationsResult = result;
                         toolsConfig = result.toolsConfig;
                         executeMap = result.executeMap;
                         originalNameMap = result.originalNameMap;
@@ -856,6 +867,10 @@ export class GoogleAIStudioProvider extends BaseProvider {
                             : new Error("Request aborted");
                     }
                     step++;
+                    // Mid-turn discovery sync — see the stream twin.
+                    if (declarationsResult) {
+                        refreshNativeToolDeclarations(options.tools, declarationsResult);
+                    }
                     logger.debug(`[GoogleAIStudio] Native SDK generate step ${step}/${maxSteps}`);
                     try {
                         const stream = await client.models.generateContentStream({
@@ -894,6 +909,8 @@ export class GoogleAIStudioProvider extends BaseProvider {
                             toolExecutions,
                             abortSignal: composedSignal,
                             originalNameMap,
+                            liveTools: options.tools,
+                            declarations: declarationsResult,
                         });
                         // Persist this step's tool calls/results into conversation memory.
                         const stepToolCalls = allToolCalls.slice(toolCallsBefore);

package/dist/providers/googleNativeGemini3.d.ts

@@ -82,7 +82,16 @@ export declare function normalizeToolsForJsonSchemaProvider(tools: Record<string
  *
  * This handles both Zod schemas and plain JSON Schema objects for tool parameters.
  */
-export declare function buildNativeToolDeclarations(tools: Record<string, Tool>): NativeToolDeclarationsResult;
+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.
+ */
+export declare function refreshNativeToolDeclarations(liveTools: Record<string, Tool> | undefined, current: NativeToolDeclarationsResult): boolean;
 /**
  * Build the native @google/genai config object shared by stream and generate.
  *
@@ -217,6 +226,15 @@ export declare function executeNativeToolCalls(logLabel: string, stepFunctionCal
     }>;
     abortSignal?: AbortSignal;
     originalNameMap?: Map<string, string>;
+    /**
+     * Live tool record + declaration snapshot for mid-turn discovery: on a
+     * dispatch miss the executor re-resolves against `liveTools` (hydrated
+     * by search_tools, or auto-hydrated from the deferred catalog) and syncs
+     * `declarations` in place. `declarations.executeMap` must be the same
+     * map passed as the `executeMap` argument (true at every call site).
+     */
+    liveTools?: Record<string, Tool>;
+    declarations?: NativeToolDeclarationsResult;
 }): Promise<NativeFunctionResponse[]>;
 /**
  * Handle maxSteps termination by producing a final answer when the model was

package/dist/providers/googleNativeGemini3.js

@@ -15,6 +15,7 @@ import { DEFAULT_CONTEXT_GUARD_RATIO, DEFAULT_MAX_STEPS, DEFAULT_TOOL_MAX_RETRIE
 import { logger } from "../utils/logger.js";
 import { convertZodToJsonSchema, ensureNestedSchemaTypes, inlineJsonSchema, isZodSchema, normalizeJsonSchemaObject, } from "../utils/schemaConversion.js";
 import { createNativeThinkingConfig } from "../utils/thinkingConfig.js";
+import { resolveLiveTool } from "../tools/toolDiscovery.js";
 import { jsonSchema as aiJsonSchema, tool as createAISDKTool, } from "../utils/tool.js";
 // ── Functions ──
 /** Stable, key-order-independent serialization of tool args for the dedup key. */
@@ -367,7 +368,7 @@ export function normalizeToolsForJsonSchemaProvider(tools) {
  *
  * This handles both Zod schemas and plain JSON Schema objects for tool parameters.
  */
-export function buildNativeToolDeclarations(tools) {
+export function buildNativeToolDeclarations(tools, reservedNames) {
     const functionDeclarations = [];
     const executeMap = new DedupExecuteMap();
     const skippedTools = [];
@@ -380,8 +381,10 @@ export function buildNativeToolDeclarations(tools) {
     // execute are still pushed to functionDeclarations). The originalNameMap
     // lets the calling stream loop translate Google-returned function-call
     // names back to the consumer-facing identifier so the sanitization is
-    // transport-only.
-    const usedNames = new Set();
+    // transport-only. `reservedNames` seeds the collision set so a mid-turn
+    // refresh (see refreshNativeToolDeclarations) never re-issues a safe name
+    // already assigned by the pre-loop snapshot.
+    const usedNames = new Set(reservedNames ?? []);
     const originalNameMap = new Map();
     for (const [name, tool] of Object.entries(tools)) {
         try {
@@ -442,6 +445,36 @@ export function buildNativeToolDeclarations(tools) {
         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.
+ */
+export function refreshNativeToolDeclarations(liveTools, current) {
+    if (!liveTools) {
+        return false;
+    }
+    const declaredOriginals = new Set(current.originalNameMap.values());
+    const missing = Object.entries(liveTools).filter(([name]) => !declaredOriginals.has(name));
+    if (missing.length === 0) {
+        return false;
+    }
+    const built = buildNativeToolDeclarations(Object.fromEntries(missing), new Set(current.originalNameMap.keys()));
+    current.toolsConfig[0].functionDeclarations.push(...built.toolsConfig[0].functionDeclarations);
+    for (const [safeName, originalName] of built.originalNameMap) {
+        current.originalNameMap.set(safeName, originalName);
+    }
+    for (const [safeName, execute] of built.executeMap) {
+        current.executeMap.set(safeName, execute);
+    }
+    logger.info(`[buildNativeToolDeclarations] ${missing.length} tool(s) hydrated mid-turn via discovery: ${missing
+        .map(([name]) => name)
+        .join(", ")}`);
+    return true;
+}
 /**
  * Build the native @google/genai config object shared by stream and generate.
  *
@@ -795,7 +828,31 @@ export async function executeNativeToolCalls(logLabel, stepFunctionCalls, execut
             });
             continue;
         }
-        const execute = executeMap.get(call.name);
+        let execute = executeMap.get(call.name);
+        if (!execute && options?.declarations) {
+            // Snapshot miss: the tool may have been hydrated into the live record
+            // by search_tools within this very step batch, or the model called a
+            // deferred catalog tool directly by its advertised name.
+            const liveTool = resolveLiveTool(options.liveTools, exposedName);
+            if (liveTool?.execute) {
+                refreshNativeToolDeclarations(options.liveTools, options.declarations);
+                // NOT_FOUND strikes accrued while the tool was deferred are snapshot
+                // artifacts, not real failures — reset so the breaker starts clean.
+                failedTools.delete(call.name);
+                // The refresh registered the executor under its Google-safe name —
+                // resolve it for this dispatch (later calls use the declared name).
+                for (const [safeName, originalName] of options.declarations
+                    .originalNameMap) {
+                    if (originalName === exposedName) {
+                        execute = executeMap.get(safeName);
+                        break;
+                    }
+                }
+                if (execute) {
+                    logger.info(`${logLabel} Tool "${exposedName}" resolved mid-turn via discovery — executing.`);
+                }
+            }
+        }
         if (execute) {
             try {
                 // AI SDK Tool execute requires (args, options) - provide minimal options

package/dist/providers/googleVertex.d.ts

@@ -152,6 +152,54 @@ export declare class GoogleVertexProvider extends BaseProvider {
      * Create @google/genai client configured for Vertex AI
      */
     private createVertexGenAIClient;
+    /**
+     * Convert one AI-SDK tool into a Vertex Gemini function declaration.
+     * Single source for the pre-loop snapshot AND the mid-turn discovery
+     * refresh, so tools hydrated by search_tools get the exact same schema
+     * treatment (inline, typed, additionalProperties stripped).
+     */
+    private buildGeminiFunctionDeclaration;
+    /**
+     * Mid-turn tool sync for the native Gemini loops. `search_tools` hydrates
+     * discovered tools into the live `options.tools` record between steps, but
+     * the loop's declarations + executeMap are a pre-loop snapshot — without
+     * this refresh, a tool discovered this turn stays invisible to the rest of
+     * the turn and every call to it dies as TOOL_NOT_FOUND. Mutates the
+     * declaration array in place (the request config holds it by reference)
+     * and clears breaker strikes accrued while the tool was still deferred.
+     */
+    private refreshGeminiToolDeclarations;
+    /**
+     * Dispatch-miss recovery for the native Gemini loops: the model called a
+     * name missing from the executeMap snapshot. Re-read the live record (a
+     * tool hydrated by search_tools in this very step batch) or auto-hydrate a
+     * deferred catalog tool the model called directly by its advertised name.
+     * Returns the dedup-wrapped executor, or undefined when the name is
+     * genuinely unknown — callers keep TOOL_NOT_FOUND for that case.
+     */
+    private resolveGeminiToolOnMiss;
+    /**
+     * Convert one AI-SDK tool into an Anthropic (Claude-on-Vertex) tool
+     * declaration. Single source for the pre-loop snapshot AND the mid-turn
+     * discovery refresh — Anthropic validates input_schema as JSON Schema
+     * draft 2020-12 and rejects OpenAPI-3 dialect (`nullable: true`), so this
+     * uses the default JSON Schema target, matching the direct anthropic
+     * provider. The Gemini paths keep "openApi3".
+     */
+    private buildAnthropicToolDeclaration;
+    /**
+     * Mid-turn tool sync for the Claude-on-Vertex loops — the Anthropic
+     * counterpart of refreshGeminiToolDeclarations. Claude only calls tools
+     * present in the request's `tools` array, so without this per-step refresh
+     * a tool discovered via search_tools is unreachable for the rest of the
+     * turn. Mutates the array in place (requestParams holds it by reference).
+     */
+    private refreshAnthropicToolDeclarations;
+    /**
+     * Dispatch-miss recovery for the Claude-on-Vertex loops — the Anthropic
+     * counterpart of resolveGeminiToolOnMiss.
+     */
+    private resolveAnthropicToolOnMiss;
     /**
      * Execute stream using native @google/genai SDK for Gemini 3 models on Vertex AI
      * This bypasses @ai-sdk/google-vertex to properly handle thought_signature