fix(vercel-ai): prevent tool call span map memory leak

packages/core/src/index.ts

@@ -146,7 +146,8 @@ export * as metrics from './metrics/public-api';
 export type { MetricOptions } from './metrics/public-api';
 export { createConsolaReporter } from './integrations/consola';
 export { addVercelAiProcessors } from './tracing/vercel-ai';
-export { _INTERNAL_getSpanForToolCallId, _INTERNAL_cleanupToolCallSpan } from './tracing/vercel-ai/utils';
+export { _INTERNAL_getSpanContextForToolCallId, _INTERNAL_cleanupToolCallSpanContext } from './tracing/vercel-ai/utils';
+export { toolCallSpanContextMap as _INTERNAL_toolCallSpanContextMap } from './tracing/vercel-ai/constants';
 export { instrumentOpenAiClient } from './tracing/openai';
 export { OPENAI_INTEGRATION_NAME } from './tracing/openai/constants';
 export { instrumentAnthropicAiClient } from './tracing/anthropic-ai';

packages/core/src/tracing/vercel-ai/constants.ts

@@ -1,8 +1,9 @@
-import type { Span } from '../../types-hoist/span';
+import type { ToolCallSpanContext } from './types';
 
-// Global Map to track tool call IDs to their corresponding spans
+// Global map to track tool call IDs to their corresponding span contexts.
 // This allows us to capture tool errors and link them to the correct span
-export const toolCallSpanMap = new Map<string, Span>();
+// without keeping full Span objects (and their potentially large attributes) alive.
+export const toolCallSpanContextMap = new Map<string, ToolCallSpanContext>();
 
 // Operation sets for efficient mapping to OpenTelemetry semantic convention values
 export const INVOKE_AGENT_OPS = new Set([

packages/core/src/tracing/vercel-ai/index.ts

@@ -19,7 +19,13 @@ import {
   GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE,
   GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE,
 } from '../ai/gen-ai-attributes';
-import { EMBEDDINGS_OPS, GENERATE_CONTENT_OPS, INVOKE_AGENT_OPS, RERANK_OPS, toolCallSpanMap } from './constants';
+import {
+  EMBEDDINGS_OPS,
+  GENERATE_CONTENT_OPS,
+  INVOKE_AGENT_OPS,
+  RERANK_OPS,
+  toolCallSpanContextMap,
+} from './constants';
 import type { TokenSummary } from './types';
 import {
   accumulateTokensForParent,
@@ -232,12 +238,13 @@ function processToolCallSpan(span: Span, attributes: SpanAttributes): void {
   renameAttributeKey(attributes, AI_TOOL_CALL_NAME_ATTRIBUTE, GEN_AI_TOOL_NAME_ATTRIBUTE);
   renameAttributeKey(attributes, AI_TOOL_CALL_ID_ATTRIBUTE, GEN_AI_TOOL_CALL_ID_ATTRIBUTE);
 
-  // Store the span in our global map using the tool call ID
+  // Store the span context in our global map using the tool call ID.
   // This allows us to capture tool errors and link them to the correct span
+  // without retaining the full Span object in memory.
   const toolCallId = attributes[GEN_AI_TOOL_CALL_ID_ATTRIBUTE];
 
   if (typeof toolCallId === 'string') {
-    toolCallSpanMap.set(toolCallId, span);
+    toolCallSpanContextMap.set(toolCallId, span.spanContext());
   }
 
   // https://opentelemetry.io/docs/specs/semconv/registry/attributes/gen-ai/#gen-ai-tool-type

packages/core/src/tracing/vercel-ai/types.ts

@@ -2,3 +2,8 @@ export interface TokenSummary {
   inputTokens: number;
   outputTokens: number;
 }
+
+export interface ToolCallSpanContext {
+  traceId: string;
+  spanId: string;
+}

packages/core/src/tracing/vercel-ai/utils.ts

@@ -17,8 +17,8 @@ import {
   GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE,
 } from '../ai/gen-ai-attributes';
 import { extractSystemInstructions, getTruncatedJsonString } from '../ai/utils';
-import { toolCallSpanMap } from './constants';
-import type { TokenSummary } from './types';
+import { toolCallSpanContextMap } from './constants';
+import type { TokenSummary, ToolCallSpanContext } from './types';
 import { AI_PROMPT_ATTRIBUTE, AI_PROMPT_MESSAGES_ATTRIBUTE } from './vercel-ai-attributes';
 
 /**
@@ -75,17 +75,17 @@ export function applyAccumulatedTokens(
 }
 
 /**
- * Get the span associated with a tool call ID
+ * Get the span context associated with a tool call ID.
  */
-export function _INTERNAL_getSpanForToolCallId(toolCallId: string): Span | undefined {
-  return toolCallSpanMap.get(toolCallId);
+export function _INTERNAL_getSpanContextForToolCallId(toolCallId: string): ToolCallSpanContext | undefined {
+  return toolCallSpanContextMap.get(toolCallId);
 }
 
 /**
  * Clean up the span mapping for a tool call ID
  */
-export function _INTERNAL_cleanupToolCallSpan(toolCallId: string): void {
-  toolCallSpanMap.delete(toolCallId);
+export function _INTERNAL_cleanupToolCallSpanContext(toolCallId: string): void {
+  toolCallSpanContextMap.delete(toolCallId);
 }
 
 /**

packages/node/src/integrations/tracing/vercelai/instrumentation.ts

@@ -1,9 +1,8 @@
 import type { InstrumentationConfig, InstrumentationModuleDefinition } from '@opentelemetry/instrumentation';
 import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-import type { Span } from '@sentry/core';
 import {
-  _INTERNAL_cleanupToolCallSpan,
-  _INTERNAL_getSpanForToolCallId,
+  _INTERNAL_cleanupToolCallSpanContext,
+  _INTERNAL_getSpanContextForToolCallId,
   addNonEnumerableProperty,
   captureException,
   getActiveSpan,
@@ -71,10 +70,12 @@ function isToolError(obj: unknown): obj is ToolError {
 }
 
 /**
- * Check for tool errors in the result and capture them
- * Tool errors are not rejected in Vercel V5, it is added as metadata to the result content
+ * Process tool call results: capture tool errors and clean up span context mappings.
+ *
+ * Error checking runs first (needs span context for linking), then cleanup removes all entries.
+ * Tool errors are not rejected in Vercel AI V5 — they appear as metadata in the result content.
  */
-function checkResultForToolErrors(result: unknown): void {
+export function processToolCallResults(result: unknown): void {
   if (typeof result !== 'object' || result === null || !('content' in result)) {
     return;
   }
@@ -84,53 +85,65 @@ function checkResultForToolErrors(result: unknown): void {
     return;
   }
 
-  for (const item of resultObj.content) {
-    if (isToolError(item)) {
-      // Try to get the span associated with this tool call ID
-      const associatedSpan = _INTERNAL_getSpanForToolCallId(item.toolCallId) as Span;
+  captureToolErrors(resultObj.content);
+  cleanupToolCallSpanContexts(resultObj.content);
+}
 
-      if (associatedSpan) {
-        // We have the span, so link the error using span and trace IDs from the span
-        const spanContext = associatedSpan.spanContext();
+function captureToolErrors(content: Array<object>): void {
+  for (const item of content) {
+    if (!isToolError(item)) {
+      continue;
+    }
 
-        withScope(scope => {
-          // Set the span and trace context for proper linking
-          scope.setContext('trace', {
-            trace_id: spanContext.traceId,
-            span_id: spanContext.spanId,
-          });
+    // Try to get the span context associated with this tool call ID
+    const spanContext = _INTERNAL_getSpanContextForToolCallId(item.toolCallId);
 
-          scope.setTag('vercel.ai.tool.name', item.toolName);
-          scope.setTag('vercel.ai.tool.callId', item.toolCallId);
+    if (spanContext) {
+      // We have the span context, so link the error using span and trace IDs
+      withScope(scope => {
+        scope.setContext('trace', {
+          trace_id: spanContext.traceId,
+          span_id: spanContext.spanId,
+        });
 
-          scope.setLevel('error');
+        scope.setTag('vercel.ai.tool.name', item.toolName);
+        scope.setTag('vercel.ai.tool.callId', item.toolCallId);
+        scope.setLevel('error');
 
-          captureException(item.error, {
-            mechanism: {
-              type: 'auto.vercelai.otel',
-              handled: false,
-            },
-          });
+        captureException(item.error, {
+          mechanism: {
+            type: 'auto.vercelai.otel',
+            handled: false,
+          },
         });
-
-        // Clean up the span mapping since we've processed this tool error
-        // We won't get multiple { type: 'tool-error' } parts for the same toolCallId.
-        _INTERNAL_cleanupToolCallSpan(item.toolCallId);
-      } else {
-        // Fallback: capture without span linking
-        withScope(scope => {
-          scope.setTag('vercel.ai.tool.name', item.toolName);
-          scope.setTag('vercel.ai.tool.callId', item.toolCallId);
-          scope.setLevel('error');
-
-          captureException(item.error, {
-            mechanism: {
-              type: 'auto.vercelai.otel',
-              handled: false,
-            },
-          });
+      });
+    } else {
+      // Fallback: capture without span linking
+      withScope(scope => {
+        scope.setTag('vercel.ai.tool.name', item.toolName);
+        scope.setTag('vercel.ai.tool.callId', item.toolCallId);
+        scope.setLevel('error');
+
+        captureException(item.error, {
+          mechanism: {
+            type: 'auto.vercelai.otel',
+            handled: false,
+          },
         });
-      }
+      });
+    }
+  }
+}
+
+export function cleanupToolCallSpanContexts(content: Array<object>): void {
+  for (const item of content) {
+    if (
+      typeof item === 'object' &&
+      item !== null &&
+      'toolCallId' in item &&
+      typeof (item as Record<string, unknown>).toolCallId === 'string'
+    ) {
+      _INTERNAL_cleanupToolCallSpanContext((item as Record<string, unknown>).toolCallId as string);
     }
   }
 }
@@ -252,7 +265,7 @@ export class SentryVercelAiInstrumentation extends InstrumentationBase {
             },
             () => {},
             result => {
-              checkResultForToolErrors(result);
+              processToolCallResults(result);
             },
           );
         },

packages/node/test/integrations/tracing/vercelai/instrumentation.test.ts

@@ -1,5 +1,9 @@
-import { describe, expect, test } from 'vitest';
-import { determineRecordingSettings } from '../../../../src/integrations/tracing/vercelai/instrumentation';
+import { _INTERNAL_getSpanContextForToolCallId, _INTERNAL_toolCallSpanContextMap } from '@sentry/core';
+import { beforeEach, describe, expect, test } from 'vitest';
+import {
+  cleanupToolCallSpanContexts,
+  determineRecordingSettings,
+} from '../../../../src/integrations/tracing/vercelai/instrumentation';
 
 describe('determineRecordingSettings', () => {
   test('should use integration recording options when provided (recordInputs: true, recordOutputs: false)', () => {
@@ -212,3 +216,48 @@ describe('determineRecordingSettings', () => {
     });
   });
 });
+
+describe('cleanupToolCallSpanContexts', () => {
+  beforeEach(() => {
+    _INTERNAL_toolCallSpanContextMap.clear();
+  });
+
+  test('cleans up span context for tool-result items', () => {
+    _INTERNAL_toolCallSpanContextMap.set('tool-1', { traceId: 't1', spanId: 's1' });
+    _INTERNAL_toolCallSpanContextMap.set('tool-2', { traceId: 't2', spanId: 's2' });
+
+    cleanupToolCallSpanContexts([{ type: 'tool-result', toolCallId: 'tool-1', toolName: 'bash' }]);
+
+    expect(_INTERNAL_getSpanContextForToolCallId('tool-1')).toBeUndefined();
+    expect(_INTERNAL_getSpanContextForToolCallId('tool-2')).toEqual({ traceId: 't2', spanId: 's2' });
+  });
+
+  test('cleans up span context for tool-error items', () => {
+    _INTERNAL_toolCallSpanContextMap.set('tool-1', { traceId: 't1', spanId: 's1' });
+
+    cleanupToolCallSpanContexts([{ type: 'tool-error', toolCallId: 'tool-1', toolName: 'bash', error: new Error('fail') }]);
+
+    expect(_INTERNAL_getSpanContextForToolCallId('tool-1')).toBeUndefined();
+  });
+
+  test('cleans up mixed tool-result and tool-error in same content array', () => {
+    _INTERNAL_toolCallSpanContextMap.set('tool-1', { traceId: 't1', spanId: 's1' });
+    _INTERNAL_toolCallSpanContextMap.set('tool-2', { traceId: 't2', spanId: 's2' });
+
+    cleanupToolCallSpanContexts([
+      { type: 'tool-result', toolCallId: 'tool-1', toolName: 'bash' },
+      { type: 'tool-error', toolCallId: 'tool-2', toolName: 'bash', error: new Error('fail') },
+    ]);
+
+    expect(_INTERNAL_getSpanContextForToolCallId('tool-1')).toBeUndefined();
+    expect(_INTERNAL_getSpanContextForToolCallId('tool-2')).toBeUndefined();
+  });
+
+  test('ignores items without toolCallId', () => {
+    _INTERNAL_toolCallSpanContextMap.set('tool-1', { traceId: 't1', spanId: 's1' });
+
+    cleanupToolCallSpanContexts([{ type: 'text', text: 'hello' } as unknown as object]);
+
+    expect(_INTERNAL_getSpanContextForToolCallId('tool-1')).toEqual({ traceId: 't1', spanId: 's1' });
+  });
+});