@juspay/neurolink 12.37.1 → 12.37.3

package/dist/core/geminiLoopAdapter.js

@@ -37,6 +37,14 @@ export function createGeminiLoopAdapter(config) {
         }
         return original;
     };
+    // Per-turn monotonic counter for `toolCallId` generation. `executeStep` is
+    // called once per loop step, and a fresh `createGeminiLoopAdapter` closure
+    // is made per turn (per generate()/stream() call), so this resets at the
+    // right lifetime while staying unique across every step of one turn —
+    // unlike the step-local array index it replaces, which restarted at 0 on
+    // every step and let two calls to the same tool in different steps collide
+    // on one id once both landed in the same flattened per-turn list.
+    let nextCallIndex = 0;
     return {
         providerLabel: config.providerLabel,
         maxSteps: config.maxSteps,
@@ -138,9 +146,11 @@ export function createGeminiLoopAdapter(config) {
             // projects the next request from.
             config.noteUsage?.(collected.inputTokens, collected.outputTokens);
             const text = extractTextFromParts(collected.rawResponseParts);
-            // Names cross the engine boundary in their ORIGINAL form.
-            const allCalls = collected.stepFunctionCalls.map((call, index) => ({
-                id: `${config.providerLabel}_${index}_${call.name}`,
+            // Names cross the engine boundary in their ORIGINAL form. `id` uses the
+            // turn-scoped counter above, not a step-local map index, so two calls
+            // to the same tool in different steps of one turn get distinct ids.
+            const allCalls = collected.stepFunctionCalls.map((call) => ({
+                id: `${config.providerLabel}_${nextCallIndex++}_${call.name}`,
                 name: originalNameFor(call.name),
                 args: call.args,
             }));

package/dist/neurolink.js

@@ -8774,6 +8774,21 @@ Current user's request: ${currentInput}`;
         let availableTools = await this.getAllAvailableTools();
         // Apply per-call tool filtering for system prompt tool descriptions
         availableTools = this.applyToolInfoFiltering(availableTools, options);
+        // M3: a provider whose descriptor declares toolSupport "none" can never
+        // call a tool in ANY form — not natively, not via prompt injection — so
+        // `availableTools` here is dead weight, not a signal. Left non-empty, it
+        // still drives createToolAwareSystemPrompt()'s prompt-injection branch
+        // (that branch triggers on `!provider.supportsTools()`, which is also
+        // true for these providers) and inflates the stream budget check below
+        // via `toolDefinitions`, so an image-generation-only provider like
+        // Recraft can fail a fabricated "exceeds model budget" check before its
+        // own request-kind routing (BaseProvider.stream() -> resolveRequestKind)
+        // ever runs. Clearing it here restores the provider's real outcome —
+        // its own refusal, a genuine vendor error, or success — as what
+        // surfaces, without touching the budget check for any text provider.
+        if (ProviderFactory.getDescriptor(providerName)?.toolSupport === "none") {
+            availableTools = [];
+        }
         // Skip tool prompt injection if skipToolPromptInjection is true.
         // For providers with native tool calling (instance truth via
         // supportsTools()), the listing is skipped and only the short damping

package/dist/providers/googleVertex/client.js

@@ -2595,7 +2595,11 @@ export class GoogleVertexProvider extends BaseProvider {
                 finalText = engineResult.text;
                 lastFinishReason = engineResult.rawStopReason ?? lastFinishReason;
                 for (const call of engineResult.toolCalls) {
-                    allToolCalls.push({ toolName: call.name, args: call.args });
+                    allToolCalls.push({
+                        toolCallId: call.id,
+                        toolName: call.name,
+                        args: call.args,
+                    });
                 }
                 for (const execution of engineResult.toolExecutions) {
                     toolExecutions.push({
@@ -2747,6 +2751,17 @@ export class GoogleVertexProvider extends BaseProvider {
                 reasoningTokens: totalReasoningTokens,
             }),
             responseTime,
+            // The complete attempted-call record (name/args/id), independent of
+            // toolsUsed's success-only names — mirrors the native Anthropic direct
+            // / OpenAI-compatible / SageMaker paths (toolCallsFromSummaries) and
+            // the working Gemini-on-Vertex STREAM path just above. Previously
+            // absent here, so a tool the loop ran internally never reached the
+            // caller's result.toolCalls even though toolsUsed/toolExecutions did.
+            toolCalls: externalToolCalls.map((tc) => ({
+                toolCallId: tc.toolCallId,
+                toolName: tc.toolName,
+                args: tc.args,
+            })),
             toolsUsed: externalToolCalls.map((tc) => tc.toolName),
             toolExecutions: resolveToolExecutionRecords(options, externalToolExecutions),
             enhancedWithTools: externalToolCalls.length > 0,
@@ -4699,7 +4714,11 @@ export class GoogleVertexProvider extends BaseProvider {
             },
             buildToolResultMessages: (conversation, stepResult, toolResults, engineStep) => {
                 for (const result of toolResults) {
-                    allToolCalls.push({ toolName: result.name, args: result.args });
+                    allToolCalls.push({
+                        toolCallId: result.id,
+                        toolName: result.name,
+                        args: result.args,
+                    });
                     // Recorded here as well: `toolExecutions` feeds
                     // resolveToolExecutionRecords and the result's own
                     // toolExecutions, and pushing only to allToolCalls left it empty
@@ -5059,7 +5078,23 @@ export class GoogleVertexProvider extends BaseProvider {
         }
         releaseTurnResources();
         const responseTime = Date.now() - startTime;
-        const externalToolCalls = allToolCalls.filter((tc) => tc.toolName !== "final_result");
+        // Sourced from `engineResult.toolCalls` when the turn produced one, not
+        // the local `allToolCalls` (fed only by the `buildToolResultMessages`
+        // hook below). The engine's own accumulator is pushed to unconditionally
+        // per dispatched batch, before the abortedMidBatch check that skips
+        // `buildToolResultMessages` for that step — so a tool that finished
+        // executing in a batch cut short by an abort is present in
+        // `engineResult.toolCalls` but would otherwise never reach
+        // `allToolCalls`. `allToolCalls` remains the fallback for the rare case
+        // where `resultPromise` itself rejects and `engineResult` never resolves.
+        const engineToolCalls = engineResult
+            ? engineResult.toolCalls.map((call) => ({
+                toolCallId: call.id,
+                toolName: call.name,
+                args: call.args,
+            }))
+            : allToolCalls;
+        const externalToolCalls = engineToolCalls.filter((tc) => tc.toolName !== "final_result");
         const externalToolExecutions = toolExecutions.filter((te) => te.name !== "final_result");
         // Absolute backstop — no code path may surface empty content on a turn
         // that ran tools (the consumer-facing "empty response" incident shape).
@@ -5136,6 +5171,17 @@ export class GoogleVertexProvider extends BaseProvider {
                 ...(totalReasoningTokens > 0 && { reasoning: totalReasoningTokens }),
             },
             responseTime,
+            // The complete attempted-call record (name/args/id), independent of
+            // toolsUsed's success-only names — mirrors the native Anthropic direct
+            // / OpenAI-compatible / SageMaker paths (toolCallsFromSummaries) and
+            // the working Gemini-on-Vertex STREAM path. Previously absent here, so
+            // a tool the loop ran internally never reached the caller's
+            // result.toolCalls even though toolsUsed/toolExecutions did.
+            toolCalls: externalToolCalls.map((tc) => ({
+                toolCallId: tc.toolCallId,
+                toolName: tc.toolName,
+                args: tc.args,
+            })),
             toolsUsed: externalToolCalls.map((tc) => tc.toolName),
             toolExecutions: resolveToolExecutionRecords(options, externalToolExecutions),
             enhancedWithTools: externalToolCalls.length > 0,

package/package.json

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