@juspay/neurolink 11.24.1 → 11.24.2

package/dist/providers/googleVertex/client.js

@@ -3337,6 +3337,55 @@ export class GoogleVertexProvider extends BaseProvider {
             const contextGuard = createContextGuard(getContextWindowSize("vertex", modelName));
             const failedTools = new Map();
             try {
+                // Restores the per-tool observation the hand-rolled dispatch had.
+                // The execution runs INSIDE the span's context so spans the tool opens
+                // itself nest under this call rather than dangling beside the turn, and
+                // the settled RESULT is inspected — an MCP tool reports failure in its
+                // payload, so an observation that only watches for throws records a
+                // failed call as successful.
+                //
+                // Stream path only: the generate twin never had per-tool spans, and
+                // giving it them here would be behaviour GAINED under cover of a
+                // migration. Shared with resolveToolOnMiss below: the old dispatch
+                // opened the span before the executor lookup, so a tool hydrated
+                // mid-turn was observed exactly like one declared up front.
+                const withToolSpan = (toolCallName, run) => {
+                    const toolSpan = tracers.mcp.startSpan("ai.toolCall", {
+                        kind: SpanKind.INTERNAL,
+                        attributes: {
+                            [LANGFUSE_ATTR.OBSERVATION_TYPE]: "tool",
+                            [ATTR.GEN_AI_TOOL_NAME]: toolCallName,
+                            "ai.toolCall.name": toolCallName,
+                        },
+                    }, turnContext);
+                    const finish = (output, errorMessage) => {
+                        toolSpan.setAttribute("ai.toolCall.result", spanJsonAttribute(output));
+                        toolSpan.setAttribute(LANGFUSE_ATTR.OBSERVATION_OUTPUT, spanJsonAttribute(output));
+                        if (errorMessage) {
+                            toolSpan.setAttribute(LANGFUSE_ATTR.OBSERVATION_LEVEL, "ERROR");
+                            toolSpan.setAttribute(LANGFUSE_ATTR.OBSERVATION_STATUS_MESSAGE, errorMessage);
+                            toolSpan.setStatus({
+                                code: SpanStatusCode.ERROR,
+                                message: errorMessage,
+                            });
+                        }
+                        else {
+                            toolSpan.setStatus({ code: SpanStatusCode.OK });
+                        }
+                        toolSpan.end();
+                    };
+                    return otelContext.with(otelTrace.setSpan(turnContext, toolSpan), async () => {
+                        try {
+                            const result = await run();
+                            finish(result, extractMcpToolErrorMessage(result));
+                            return result;
+                        }
+                        catch (error) {
+                            finish({ error: true }, error instanceof Error ? error.message : String(error));
+                            throw error;
+                        }
+                    });
+                };
                 // Executors handed to the engine, taken through the turn's
                 // DedupExecuteMap so an identical repeated call is answered from the
                 // per-turn cache rather than run again (BZ-3327). `.get()` returns the
@@ -3358,53 +3407,7 @@ export class GoogleVertexProvider extends BaseProvider {
                             toolTimeoutMs: toolExecTimeoutMs,
                             abortSignal: internalAbort.signal,
                             onProgress: () => turnClock.noteProgress(),
-                            // Restores the per-tool observation the hand-rolled dispatch had.
-                            // The execution runs INSIDE the span's context so spans the tool opens
-                            // itself nest under this call rather than dangling beside the turn, and
-                            // the settled RESULT is inspected — an MCP tool reports failure in its
-                            // payload, so an observation that only watches for throws records a
-                            // failed call as successful.
-                            //
-                            // Stream path only: the generate twin never had per-tool spans, and
-                            // giving it them here would be behaviour GAINED under cover of a
-                            // migration.
-                            withToolSpan: (toolCallName, run) => {
-                                const toolSpan = tracers.mcp.startSpan("ai.toolCall", {
-                                    kind: SpanKind.INTERNAL,
-                                    attributes: {
-                                        [LANGFUSE_ATTR.OBSERVATION_TYPE]: "tool",
-                                        [ATTR.GEN_AI_TOOL_NAME]: toolCallName,
-                                        "ai.toolCall.name": toolCallName,
-                                    },
-                                }, turnContext);
-                                const finish = (output, errorMessage) => {
-                                    toolSpan.setAttribute("ai.toolCall.result", spanJsonAttribute(output));
-                                    toolSpan.setAttribute(LANGFUSE_ATTR.OBSERVATION_OUTPUT, spanJsonAttribute(output));
-                                    if (errorMessage) {
-                                        toolSpan.setAttribute(LANGFUSE_ATTR.OBSERVATION_LEVEL, "ERROR");
-                                        toolSpan.setAttribute(LANGFUSE_ATTR.OBSERVATION_STATUS_MESSAGE, errorMessage);
-                                        toolSpan.setStatus({
-                                            code: SpanStatusCode.ERROR,
-                                            message: errorMessage,
-                                        });
-                                    }
-                                    else {
-                                        toolSpan.setStatus({ code: SpanStatusCode.OK });
-                                    }
-                                    toolSpan.end();
-                                };
-                                return otelContext.with(otelTrace.setSpan(turnContext, toolSpan), async () => {
-                                    try {
-                                        const result = await run();
-                                        finish(result, extractMcpToolErrorMessage(result));
-                                        return result;
-                                    }
-                                    catch (error) {
-                                        finish({ error: true }, error instanceof Error ? error.message : String(error));
-                                        throw error;
-                                    }
-                                });
-                            },
+                            withToolSpan,
                         }),
                     };
                 }
@@ -3538,6 +3541,10 @@ export class GoogleVertexProvider extends BaseProvider {
                                 toolTimeoutMs: toolExecTimeoutMs,
                                 abortSignal: internalAbort.signal,
                                 onProgress: () => turnClock.noteProgress(),
+                                // Same observation as an up-front executor: the hand-rolled
+                                // dispatch spanned at the call, after the executor lookup, so
+                                // a hydrated tool was never the one unobserved call in a turn.
+                                withToolSpan,
                             }),
                         };
                     },

package/package.json

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