@juspay/neurolink 11.15.1 → 11.15.3

package/dist/core/loopEngine.js

@@ -107,8 +107,11 @@ export function runAgenticLoop(adapter, initialConversation, options) {
                         catch (err) {
                             throw hasEmitted ? new PostEmissionStepError(err) : err;
                         }
-                    }, undefined, // no OTel span threaded through the engine today; adapters instrument their own steps if they need span-level detail
-                    `${adapter.providerLabel}.step`);
+                    }, 
+                    // The caller's span, when it passes one. withProviderRetry writes
+                    // gen_ai.provider.total_attempts here, so a loop that threaded a
+                    // span before it moved onto this engine keeps emitting it.
+                    options.span, `${adapter.providerLabel}.step`);
                 }
                 catch (err) {
                     throw err instanceof PostEmissionStepError ? err.cause : err;

package/dist/providers/anthropic/client.js

@@ -1697,9 +1697,17 @@ export class AnthropicProvider extends BaseProvider {
                     },
                 };
             }
+            // The active span goes with it. Before this loop moved onto the shared
+            // engine it called
+            //   withProviderRetry(fn, trace.getActiveSpan() ?? undefined, label)
+            // and that span is where gen_ai.provider.total_attempts is recorded.
+            // The engine passed `undefined` in its place, so the attribute silently
+            // stopped being emitted for every native Anthropic turn.
+            const activeSpan = trace.getActiveSpan();
             const { stream, resultPromise } = runAgenticLoop(adapter, payload.messages.slice(), {
                 tools: engineTools,
                 ...(abortSignal ? { abortSignal } : {}),
+                ...(activeSpan ? { span: activeSpan } : {}),
             });
             // Structured turns buffer their text rather than streaming it: a caller
             // that passed a schema needs parseable JSON, and deltas emitted before

package/dist/providers/googleAiStudio/client.js

@@ -17,7 +17,7 @@ import { withTimeout } from "../../utils/async/index.js";
 import { estimateTokens } from "../../utils/tokenEstimation.js";
 import { transformToolExecutions } from "../../utils/transformationUtils.js";
 import { resolveToolExecutionRecords } from "../../core/toolExecutionRecorder.js";
-import { buildGeminiResponseSchema, buildNativeConfig, computeMaxSteps, createContextGuard, buildUserPartsWithMultimodal, extractThoughtSignature, handleMaxStepsTermination, prependConversationMessages, } from "../googleNativeGemini3/index.js";
+import { buildDedupedEngineTools, buildGeminiResponseSchema, buildNativeConfig, computeMaxSteps, createContextGuard, buildUserPartsWithMultimodal, extractThoughtSignature, handleMaxStepsTermination, prependConversationMessages, } from "../googleNativeGemini3/index.js";
 import { createStreamChannel } from "../../core/streamChannel.js";
 import { toNativeToolDeclarations } from "../../core/nativeToolFormat.js";
 import { warnGoogleSdkIgnoresProxy } from "../../proxy/proxyFetch.js";
@@ -835,16 +835,10 @@ export class GoogleAIStudioProvider extends BaseProvider {
                                 return next;
                             },
                         };
-                        const engineTools = {};
-                        for (const [name, tool] of Object.entries(options.tools ?? {})) {
-                            const execute = tool?.execute;
-                            if (!execute) {
-                                continue;
-                            }
-                            engineTools[name] = {
-                                execute: async (args, opts) => execute(args, opts),
-                            };
-                        }
+                        // Through the turn's DedupExecuteMap, NOT the raw executors:
+                        // `.get()` returns the dedup wrapper that answers an identical
+                        // repeated {name, args} from the per-turn cache (BZ-3327).
+                        const engineTools = buildDedupedEngineTools(declarationsResult, options.tools);
                         const { stream: engineStream, resultPromise } = runAgenticLoop(adapter, currentContents, {
                             tools: engineTools,
                             ...(composedSignal ? { abortSignal: composedSignal } : {}),
@@ -1151,16 +1145,8 @@ export class GoogleAIStudioProvider extends BaseProvider {
                         return next;
                     },
                 };
-                const engineTools = {};
-                for (const [name, tool] of Object.entries(options.tools ?? {})) {
-                    const execute = tool?.execute;
-                    if (!execute) {
-                        continue;
-                    }
-                    engineTools[name] = {
-                        execute: async (args, opts) => execute(args, opts),
-                    };
-                }
+                // Same dedup routing as the streaming twin above.
+                const engineTools = buildDedupedEngineTools(declarationsResult, options.tools);
                 const { stream: engineStream, resultPromise } = runAgenticLoop(adapter, currentContents, {
                     tools: engineTools,
                     ...(composedSignal ? { abortSignal: composedSignal } : {}),

package/dist/providers/googleNativeGemini3/utils.d.ts

@@ -8,7 +8,7 @@
  * This module extracts the functions that are duplicated between the two
  * providers so they can share a single implementation.
  */
-import type { GenerateStopReason, ThinkingConfig, ChatMessage, CollectedChunkResult, MinimalChatMessage, NativeFunctionCall, NativeFunctionResponse, NativeToolDeclarationsResult, NativeToolsConfig, StreamChannel, VertexNativePart, GeminiMultimodalInput, MultimodalAudioEntry } from "../../types/index.js";
+import type { GenerateStopReason, ThinkingConfig, AgenticLoopOptions, ChatMessage, CollectedChunkResult, MinimalChatMessage, NativeFunctionCall, NativeFunctionResponse, NativeToolDeclarationsResult, NativeToolsConfig, StreamChannel, VertexNativePart, GeminiMultimodalInput, MultimodalAudioEntry } from "../../types/index.js";
 import type { Tool } from "../../types/index.js";
 /**
  * A per-turn tool execute map that deduplicates identical tool calls.
@@ -91,6 +91,24 @@ 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.
  */
+/**
+ * Build the tool record handed to `runAgenticLoop`, routed through the turn's
+ * DedupExecuteMap.
+ *
+ * The engine looks tools up by the name the adapter reports, which is the
+ * ORIGINAL caller-facing name; `executeMap` is keyed by the SANITIZED wire
+ * name Google actually declares. `originalNameMap` is the bridge, and it
+ * carries an entry for every converted tool (identity mappings included), so
+ * iterating it yields exactly the declared, executable set.
+ *
+ * Going through `executeMap.get()` rather than the raw `tool.execute` is the
+ * entire point: `.get()` returns the dedup wrapper, so an identical
+ * {name, args} repeated within one turn is answered from the per-turn cache
+ * instead of running the tool again (BZ-3327). Passing the raw executor looks
+ * identical in every test that calls a tool once, and silently reintroduces
+ * duplicate side effects the moment the model repeats itself.
+ */
+export declare function buildDedupedEngineTools(declarations: NativeToolDeclarationsResult | undefined, tools: Record<string, Tool> | undefined): NonNullable<AgenticLoopOptions["tools"]>;
 export declare function refreshNativeToolDeclarations(liveTools: Record<string, Tool> | undefined, current: NativeToolDeclarationsResult): boolean;
 /**
  * Build the native @google/genai config object shared by stream and generate.

package/dist/providers/googleNativeGemini3/utils.js

@@ -455,6 +455,51 @@ 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.
  */
+/**
+ * Build the tool record handed to `runAgenticLoop`, routed through the turn's
+ * DedupExecuteMap.
+ *
+ * The engine looks tools up by the name the adapter reports, which is the
+ * ORIGINAL caller-facing name; `executeMap` is keyed by the SANITIZED wire
+ * name Google actually declares. `originalNameMap` is the bridge, and it
+ * carries an entry for every converted tool (identity mappings included), so
+ * iterating it yields exactly the declared, executable set.
+ *
+ * Going through `executeMap.get()` rather than the raw `tool.execute` is the
+ * entire point: `.get()` returns the dedup wrapper, so an identical
+ * {name, args} repeated within one turn is answered from the per-turn cache
+ * instead of running the tool again (BZ-3327). Passing the raw executor looks
+ * identical in every test that calls a tool once, and silently reintroduces
+ * duplicate side effects the moment the model repeats itself.
+ */
+export function buildDedupedEngineTools(declarations, tools) {
+    const engineTools = {};
+    if (declarations) {
+        for (const [safeName, originalName] of declarations.originalNameMap) {
+            const execute = declarations.executeMap.get(safeName);
+            if (!execute) {
+                continue;
+            }
+            engineTools[originalName] = {
+                execute: async (args, opts) => execute(args, opts),
+            };
+        }
+        return engineTools;
+    }
+    // No declarations were built (no tools, or a path that skips the snapshot).
+    // Fall back to the caller's own executors so this helper can never REMOVE a
+    // tool that would otherwise have been callable.
+    for (const [name, tool] of Object.entries(tools ?? {})) {
+        const execute = tool?.execute;
+        if (!execute) {
+            continue;
+        }
+        engineTools[name] = {
+            execute: async (args, opts) => execute(args, opts),
+        };
+    }
+    return engineTools;
+}
 export function refreshNativeToolDeclarations(liveTools, current) {
     if (!liveTools) {
         return false;

package/dist/types/loopEngine.d.ts

@@ -1,4 +1,5 @@
 import type Anthropic from "@anthropic-ai/sdk";
+import type { Span } from "@opentelemetry/api";
 import type { Tool } from "./tools.js";
 import type { CollectedChunkResult, NativeFunctionCall, NativeToolDeclarationsResult } from "./providers.js";
 /**
@@ -292,6 +293,19 @@ export type AgenticLoopOptions = {
         execute?: (args: Record<string, unknown>, opts: unknown) => Promise<unknown>;
     }>;
     abortSignal?: AbortSignal;
+    /**
+     * Span the per-step provider retry annotates, via
+     * `withProviderRetry(..., span, ...)` — it records
+     * `gen_ai.provider.total_attempts` on every completed step, retried or not.
+     *
+     * Caller-supplied rather than read from the ambient context inside the
+     * engine. Reading it here would hand the attribute to every provider on the
+     * engine, including ones whose hand-rolled loops never emitted it, and a
+     * refactor that silently ADDS observable behaviour is the same defect as one
+     * that silently drops it. Today only the direct Anthropic loops set this,
+     * because only they threaded a span before moving onto the engine.
+     */
+    span?: Span;
 };
 export type AgenticLoopResult<TConversation> = {
     text: string;

package/package.json

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