@juspay/neurolink 10.4.0 → 10.4.2

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

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