@juspay/neurolink 13.6.3 → 13.6.4

package/dist/core/nativeGenerateLoop.d.ts

@@ -86,6 +86,19 @@ export declare const hasNativeDoGenerate: (value: unknown) => value is {
 };
 /** A tool's inputSchema with its lazy (function) form, if any, resolved. */
 export declare const resolveToolInputSchema: (schema: Tool["inputSchema"]) => Exclude<Tool["inputSchema"], (...args: never[]) => unknown>;
+/**
+ * The provider-neutral declaration of one tool: the shape every provider's
+ * `doGenerate` already converts to its own wire format. The loop uses it for
+ * the tools discovery loads mid-turn, and the providers that run the loop use
+ * it for their initial declarations, so a tool is declared the same way
+ * whether it is there at the start or joins later.
+ */
+export declare const toNativeToolDeclaration: (name: string, tool: Tool) => {
+    type: "function";
+    name: string;
+    description: string;
+    inputSchema: object;
+};
 /**
  * Spell a JSON Schema into the conversation's system turn.
  *

package/dist/core/nativeGenerateLoop.js

@@ -16,6 +16,7 @@
 import { observeGeneration } from "../telemetry/observation.js";
 import { StepSpans, withGeneration } from "../telemetry/withSpan.js";
 import { logger } from "../utils/logger.js";
+import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
 import { guardToolExecutor } from "./toolExecutionGuards.js";
 import { resolveLiveTool } from "../tools/toolDiscovery.js";
 const DEFAULT_TOOL_CHOICE_STEPS = 1;
@@ -339,6 +340,35 @@ const parseToolInput = (raw) => {
 };
 /** A tool's inputSchema with its lazy (function) form, if any, resolved. */
 export const resolveToolInputSchema = (schema) => typeof schema === "function" ? resolveToolInputSchema(schema()) : schema;
+/**
+ * The provider-neutral declaration of one tool: the shape every provider's
+ * `doGenerate` already converts to its own wire format. The loop uses it for
+ * the tools discovery loads mid-turn, and the providers that run the loop use
+ * it for their initial declarations, so a tool is declared the same way
+ * whether it is there at the start or joins later.
+ */
+export const toNativeToolDeclaration = (name, tool) => ({
+    type: "function",
+    name,
+    description: tool.description ?? "",
+    inputSchema: declaredInputSchema(name, tool),
+});
+// A lazy schema that throws must not take the whole request down: SageMaker and
+// Anthropic declared any function-valued schema as the empty object schema
+// before the lazy form was resolved here, so a broken one falls back to that.
+function declaredInputSchema(name, tool) {
+    const empty = { type: "object", properties: {} };
+    if (!tool.inputSchema) {
+        return empty;
+    }
+    try {
+        return convertZodToJsonSchema(resolveToolInputSchema(tool.inputSchema));
+    }
+    catch (error) {
+        logger.warn(`[nativeGenerateLoop] input schema of tool "${name}" could not be resolved; declaring it with an empty object schema`, { error: error instanceof Error ? error.message : String(error) });
+        return empty;
+    }
+}
 /**
  * Validate parsed input against the tool's own schema when it exposes one.
  *
@@ -486,20 +516,23 @@ async function runGenerateSteps(args, toolExecutionSummaries, stepSpans) {
     // answer is that result — not a thrown turn.
     let preReask;
     const hasTools = Boolean(args.tools && args.tools.length > 0);
-    // The declarations actually sent. Starts as the caller's list and grows when
-    // a tool joins toolsRecord mid-turn (discovery loads tools into it).
-    const liveTools = args.tools ? [...args.tools] : undefined;
+    // The declarations actually sent. It is the caller's own array and grows in
+    // place when a tool joins toolsRecord mid-turn (discovery loads tools into
+    // it), so anything the caller sized from it, such as the context guard's
+    // fixed-overhead estimate, counts the new tools too.
+    const liveTools = args.tools;
+    const declare = args.declareTool ?? toNativeToolDeclaration;
     const declaredNames = declaredToolRecord(args.tools);
     // Completed-step records for `prepareStep`; one per step that returned.
     const stepRecords = [];
     for (let step = 0; step < args.maxSteps; step++) {
         steps = step + 1;
         stepSpans.begin(steps);
-        if (liveTools && args.declareTool) {
+        if (liveTools) {
             const loaded = [];
             for (const name of Object.keys(args.toolsRecord)) {
                 if (!declaredNames[name]) {
-                    liveTools.push(args.declareTool(name, args.toolsRecord[name]));
+                    liveTools.push(declare(name, args.toolsRecord[name]));
                     declaredNames[name] = true;
                     loaded.push(name);
                 }

package/dist/providers/amazonSagemaker.js

@@ -9,7 +9,7 @@ import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
 import { withProviderRetry } from "../utils/providerRetry.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
-import { hasNativeDoGenerate, runNativeGenerateLoop, } from "../core/nativeGenerateLoop.js";
+import { hasNativeDoGenerate, runNativeGenerateLoop, toNativeToolDeclaration, } from "../core/nativeGenerateLoop.js";
 import { generationName } from "../telemetry/observationNames.js";
 import { observeGeneration } from "../telemetry/observation.js";
 import { tracers } from "../telemetry/tracers.js";
@@ -208,17 +208,7 @@ export class AmazonSageMakerProvider extends BaseProvider {
         const toolsRecord = shouldUseTools
             ? options.tools || {}
             : {};
-        const v3Tools = Object.entries(toolsRecord).map(([name, t]) => {
-            const tool = t;
-            return {
-                type: "function",
-                name,
-                description: tool.description ?? "",
-                inputSchema: (tool.inputSchema
-                    ? convertZodToJsonSchema(tool.inputSchema)
-                    : { type: "object", properties: {} }),
-            };
-        });
+        const v3Tools = Object.entries(toolsRecord).map(([name, t]) => toNativeToolDeclaration(name, t));
         // Structured output was dropped entirely on this path: the schema never
         // reached the request, and nothing downstream re-imposed it, so a caller
         // asking for an object got whatever JSON coerceJsonToSchema could scrape

package/dist/providers/anthropic/client.js

@@ -25,7 +25,7 @@ import { stringifyAnthropicToolOutput } from "./toolOutput.js";
 import { createAnthropicLoopAdapter } from "./loopAdapter.js";
 import { DEFAULT_BEFORE_STEP_TIMEOUT_MS } from "../../utils/parameterValidation.js";
 import { runAgenticLoop } from "../../core/loopEngine.js";
-import { hasNativeDoGenerate, resolveStepToolChoice, runNativeGenerateLoop, toPrepareStepRecord, } from "../../core/nativeGenerateLoop.js";
+import { hasNativeDoGenerate, resolveStepToolChoice, runNativeGenerateLoop, toNativeToolDeclaration, toPrepareStepRecord, } from "../../core/nativeGenerateLoop.js";
 import { withProviderRetry } from "../../utils/providerRetry.js";
 import { resolveRequestKind } from "../../core/resolveRequestKind.js";
 import { resolveToolExecutionRecords, toolCallsFromSummaries, } from "../../core/toolExecutionRecorder.js";
@@ -1528,17 +1528,7 @@ export class AnthropicProvider extends BaseProvider {
         const toolsRecord = shouldUseTools
             ? options.tools || {}
             : {};
-        const v3Tools = Object.entries(toolsRecord).map(([name, t]) => {
-            const tool = t;
-            return {
-                type: "function",
-                name,
-                description: tool.description ?? "",
-                inputSchema: (tool.inputSchema
-                    ? convertZodToJsonSchema(tool.inputSchema)
-                    : { type: "object", properties: {} }),
-            };
-        });
+        const v3Tools = Object.entries(toolsRecord).map(([name, t]) => toNativeToolDeclaration(name, t));
         const hasTools = v3Tools.length > 0;
         // Two structured-output routes, and doGenerate implements both. With no
         // tools it replaces the tool list with one forced json tool; with tools it

package/dist/providers/openaiChatCompletionsBase.js

@@ -36,7 +36,7 @@ import { NoOutputGeneratedError } from "../utils/generationErrors.js";
 import { buildNoOutputSentinel, stampNoOutputSpan, } from "../utils/noOutputSentinel.js";
 import { composeAbortSignalsScoped, createTimeoutController, mergeAbortSignals, TimeoutError, } from "../utils/timeout.js";
 import { resolveRequestKind } from "../core/resolveRequestKind.js";
-import { appendJsonSchemaInstruction, hasNativeDoGenerate, resolveToolInputSchema, resolveStepToolChoice, runNativeGenerateLoop, toPrepareStepRecord, } from "../core/nativeGenerateLoop.js";
+import { appendJsonSchemaInstruction, hasNativeDoGenerate, resolveStepToolChoice, runNativeGenerateLoop, toNativeToolDeclaration, toPrepareStepRecord, } from "../core/nativeGenerateLoop.js";
 import { resolveToolExecutionRecords, toolCallsFromSummaries, } from "../core/toolExecutionRecorder.js";
 import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
 import { coerceJsonToSchema, recoverScalarRoot, schemaAccepts, } from "../utils/json/coerce.js";
@@ -925,19 +925,8 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             ? options.tools || (await this.getAllTools())
             : {};
         // v3 tool shape — the same one doGenerate already converts internally.
-        // Also handed to the loop, which declares tools discovery loads mid-turn.
-        const declareTool = (name, tool) => {
-            return {
-                type: "function",
-                name,
-                description: tool.description ?? "",
-                inputSchema: tool.inputSchema
-                    ? convertZodToJsonSchema(resolveToolInputSchema(tool.inputSchema))
-                    : { type: "object", properties: {} },
-            };
-        };
         const v3Tools = shouldUseTools
-            ? Object.entries(toolsRecord).map(([name, t]) => declareTool(name, t))
+            ? Object.entries(toolsRecord).map(([name, t]) => toNativeToolDeclaration(name, t))
             : undefined;
         const hasTools = !!v3Tools && v3Tools.length > 0;
         // Structured output rides response_format, which is what Output.object did
@@ -965,14 +954,9 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         // model has already given. Dropping them is what makes `response_format`
         // legal again on a vendor that refuses the two together.
         withTools = true) => {
-            // What this pass sends: the initial declarations plus any the loop adds
-            // for tools discovery loads mid-turn, so the guard counts them too.
+            // What this pass sends: the initial declarations, which the loop appends
+            // to for tools discovery loads mid-turn, so the guard counts them too.
             const passTools = withTools && v3Tools ? [...v3Tools] : undefined;
-            const declarePassTool = (name, tool) => {
-                const declaration = declareTool(name, tool);
-                passTools?.push(declaration);
-                return declaration;
-            };
             return runNativeGenerateLoop({
                 doGenerate,
                 provider: this.providerName,
@@ -997,9 +981,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                     }), this.providerName),
                 }),
                 conversation: conv,
-                ...(passTools
-                    ? { tools: [...passTools], declareTool: declarePassTool }
-                    : {}),
+                ...(passTools ? { tools: passTools } : {}),
                 toolsRecord,
                 ...(withTools && hasTools && options.toolChoice
                     ? { toolChoice: resolveToolChoice(options, toolsRecord, true) }

package/dist/types/generate.d.ts

@@ -1846,11 +1846,12 @@ export type NativeGenerateLoopArgs = {
      */
     toolsRecord: Record<string, Tool>;
     /**
-     * Builds the v3 declaration for one tool. When set, every step declares any
-     * tool that joined `toolsRecord` mid-turn (discovery's search_tools loads
-     * tools into it), so the model can call what it just loaded. Only the
-     * OpenAI-compatible `generate()` path supplies it; the other providers that
-     * run this loop do not declare a tool `search_tools` loaded mid-turn.
+     * Builds the declaration for a tool that joined `toolsRecord` mid-turn
+     * (discovery's search_tools loads tools into it). Optional: by default the
+     * loop declares such a tool in the provider-neutral shape every provider's
+     * `doGenerate` converts (`toNativeToolDeclaration`), for every provider that
+     * runs this loop. Set it only to declare in another shape. The loop appends
+     * the declarations to `tools` in place.
      */
     declareTool?: (name: string, tool: Tool) => Record<string, unknown>;
     /** The turn's resolved tool choice, applied per step via `resolveStepToolChoice`. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "13.6.3",
+  "version": "13.6.4",
   "packageManager": "pnpm@10.15.1",
   "description": "The pipe layer of an AI nervous system: one interface connecting provider neurons to your application, across three inference types — generate, stream and decide. `decide` returns typed, calibrated judgements from a non-generative model (~400ms, ~$0.00002/call) for routing, tool selection and context budgeting. MCP-native (4 transports), voice TTS/STT/realtime, RAG, agents, memory, compaction, 9 observability exporters. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · TypeSafe Jev and more.",
   "author": {