dd-trace 6.0.0 → 6.1.0

package/packages/dd-trace/src/ci-visibility/requests/upload-test-screenshot.js

@@ -0,0 +1,156 @@
+'use strict'
+
+const { readFileSync } = require('node:fs')
+const { extname } = require('node:path')
+
+const getConfig = require('../../config')
+const request = require('../../exporters/common/request')
+const log = require('../../log')
+
+const UPLOAD_TIMEOUT_MS = 30_000
+const TEST_SCREENSHOT_ENDPOINT_PREFIX = '/api/v2/ci/test-runs/'
+const TEST_SCREENSHOT_ENDPOINT_SUFFIX = '/media'
+const UINT64_MAX = 18_446_744_073_709_551_615n
+
+function getContentType (filePath) {
+  const extension = extname(filePath).toLowerCase()
+  if (extension === '.gif') {
+    return 'image/gif'
+  }
+  if (extension === '.jpg' || extension === '.jpeg') {
+    return 'image/jpeg'
+  }
+  if (extension === '.webp') {
+    return 'image/webp'
+  }
+  return 'image/png'
+}
+
+function isValidTraceId (traceId) {
+  if (!/^[1-9]\d*$/.test(traceId)) {
+    return false
+  }
+  return BigInt(traceId) <= UINT64_MAX
+}
+
+/**
+ * Renders the idempotency key (`${traceId}:${basename(filePath)}`) into a value safe to carry in
+ * the upload's query string. The Agent's evp_proxy validates the forwarded query against a
+ * restrictive charset and rejects a raw Cypress filename (spaces, parens, non-ASCII), so the
+ * filename part is hex-encoded to [0-9a-f]; the decimal trace id and ':' separator are already in
+ * the allowed set and stay readable. Deterministic, so a retried upload reproduces the same key
+ * and the backend's UUIDv5 overwrite-on-retry holds.
+ *
+ * @param {string} idempotencyKey - The raw idempotency key (`<traceId>:<filename>`)
+ * @returns {string} A query-safe, deterministic representation of the key
+ */
+function toIdempotencyQueryValue (idempotencyKey) {
+  const separatorIndex = idempotencyKey.indexOf(':')
+  if (separatorIndex === -1) {
+    return Buffer.from(idempotencyKey, 'utf8').toString('hex')
+  }
+  const traceIdPart = idempotencyKey.slice(0, separatorIndex)
+  const filenamePart = idempotencyKey.slice(separatorIndex + 1)
+  return `${traceIdPart}:${Buffer.from(filenamePart, 'utf8').toString('hex')}`
+}
+
+/**
+ * Uploads a single test screenshot to the Test Optimization media intake.
+ * The trace id is included in the request path and the body is the raw image bytes.
+ *
+ * The media service requires two values from the tracer, sent as query params so they
+ * survive the Agent's evp_proxy (which forwards only an allow-listed header set and would
+ * otherwise strip the metadata, leaving the backend with an empty idempotency key):
+ * - `idempotencyKey`: stable per artifact and reused on retry, so a retried
+ *   upload overwrites the same stored object instead of creating a duplicate.
+ * - `capturedAtMs`: the capture time in epoch milliseconds, stamped once at
+ *   capture and resent unchanged on retry (it is part of the stored object key).
+ *
+ * @param {object} options - Upload options
+ * @param {string} options.filePath - Path to the screenshot file
+ * @param {string} options.traceId - Test trace id used as the screenshot key
+ * @param {string} options.idempotencyKey - Stable per-artifact key, reused on retry
+ * @param {number} options.capturedAtMs - Capture time in epoch milliseconds
+ * @param {URL} options.url - The base URL for the screenshot upload
+ * @param {boolean} [options.isEvpProxy] - Whether to upload through the Agent's evp_proxy
+ * @param {string} [options.evpProxyPrefix] - The evp_proxy path prefix (e.g. '/evp_proxy/v4')
+ * @param {Function} callback - Callback function (err)
+ */
+function uploadTestScreenshot (
+  { filePath, traceId, idempotencyKey, capturedAtMs, url, isEvpProxy, evpProxyPrefix },
+  callback
+) {
+  const { DD_API_KEY } = getConfig()
+
+  if (!isValidTraceId(traceId)) {
+    return callback(new Error('A non-zero decimal uint64 trace_id is required for test screenshot upload'))
+  }
+  if (!DD_API_KEY && !isEvpProxy) {
+    return callback(new Error('DD_API_KEY is required for test screenshot upload'))
+  }
+  if (!idempotencyKey) {
+    return callback(new Error('An idempotency key is required for test screenshot upload'))
+  }
+  if (!Number.isInteger(capturedAtMs) || capturedAtMs <= 0) {
+    return callback(new Error('A positive captured-at timestamp (epoch ms) is required for test screenshot upload'))
+  }
+
+  let screenshotContent
+  try {
+    screenshotContent = readFileSync(filePath)
+  } catch (err) {
+    return callback(new Error(`Failed to read screenshot at ${filePath}: ${err.message}`))
+  }
+  if (screenshotContent.length === 0) {
+    return callback(new Error(`Screenshot at ${filePath} is empty`))
+  }
+
+  // Metadata rides the query string, not X-Dd-* headers: the Agent's evp_proxy strips
+  // non-allow-listed headers, so header-borne metadata reached the backend empty. The key is
+  // rendered proxy-safe (see toIdempotencyQueryValue) because evp_proxy also validates the
+  // forwarded query against a restrictive charset. capturedAtMs is a plain integer and part of the
+  // stored object key, so it (and the key) must stay stable across retries.
+  const query = new URLSearchParams({
+    idempotency_key: toIdempotencyQueryValue(idempotencyKey),
+    captured_at_ms: String(capturedAtMs),
+  }).toString()
+  const basePath = `${TEST_SCREENSHOT_ENDPOINT_PREFIX}${traceId}${TEST_SCREENSHOT_ENDPOINT_SUFFIX}`
+
+  const contentType = getContentType(filePath)
+  const options = {
+    method: 'POST',
+    headers: {
+      'Content-Type': contentType,
+    },
+    path: `${basePath}?${query}`,
+    timeout: UPLOAD_TIMEOUT_MS,
+    url,
+  }
+
+  if (isEvpProxy) {
+    // Agent mode: prefix the evp_proxy path, tell the proxy which subdomain to forward to, and
+    // drop the API key — the Agent injects it. The query params survive the proxy.
+    options.path = `${evpProxyPrefix}${basePath}?${query}`
+    options.headers['X-Datadog-EVP-Subdomain'] = 'api'
+  } else {
+    options.headers['DD-API-KEY'] = DD_API_KEY
+  }
+
+  log.debug('Uploading test screenshot %s to %s', filePath, new URL(options.path, url).href)
+
+  request(screenshotContent, options, (err, res, statusCode) => {
+    if (err) {
+      log.error('Error uploading test screenshot: %s', err.message)
+      return callback(err)
+    }
+    if (statusCode === undefined) {
+      const uploadError = new Error('Test screenshot upload request was dropped before it was sent')
+      log.error('Error uploading test screenshot: %s', uploadError.message)
+      return callback(uploadError)
+    }
+    log.debug('Test screenshot uploaded successfully (status: %d)', statusCode)
+    callback(null)
+  })
+}
+
+module.exports = { TEST_SCREENSHOT_ENDPOINT_PREFIX, TEST_SCREENSHOT_ENDPOINT_SUFFIX, uploadTestScreenshot }

package/packages/dd-trace/src/config/generated-config-types.d.ts

@@ -213,6 +213,7 @@ export interface GeneratedConfig {
   DD_TRACE_BUNYAN_ENABLED: boolean;
   DD_TRACE_CASSANDRA_DRIVER_ENABLED: boolean;
   DD_TRACE_CHILD_PROCESS_ENABLED: boolean;
+  DD_TRACE_CLAUDE_AGENT_SDK_ENABLED: boolean;
   DD_TRACE_COLLECTIONS_ENABLED: boolean;
   DD_TRACE_COMMONPLUGIN_ENABLED: boolean;
   DD_TRACE_CONFLUENTINC_KAFKA_JAVASCRIPT_ENABLED: boolean;
@@ -252,11 +253,14 @@ export interface GeneratedConfig {
   DD_TRACE_GOOGLE_CLOUD_VERTEXAI_ENABLED: boolean;
   DD_TRACE_GOOGLE_GAX_ENABLED: boolean;
   DD_TRACE_GOOGLE_GENAI_ENABLED: boolean;
+  DD_TRACE_GRAPHQL_COLLAPSE: boolean;
+  DD_TRACE_GRAPHQL_DEPTH: number;
   DD_TRACE_GRAPHQL_ENABLED: boolean;
   DD_TRACE_GRAPHQL_ERROR_EXTENSIONS: string[];
   DD_TRACE_GRAPHQL_TAG_ENABLED: boolean;
   DD_TRACE_GRAPHQL_TOOLS_ENABLED: boolean;
   DD_TRACE_GRAPHQL_TOOLS_EXECUTOR_ENABLED: boolean;
+  DD_TRACE_GRAPHQL_VARIABLES: string[];
   DD_TRACE_GRAPHQL_YOGA_ENABLED: boolean;
   DD_TRACE_GRPC_ENABLED: boolean;
   DD_TRACE_GRPC_GRPC_JS_ENABLED: boolean;
@@ -558,6 +562,7 @@ export interface GeneratedConfig {
     DD_CIVISIBILITY_TEST_MODULE_ID: string | undefined;
     DD_CIVISIBILITY_TEST_SESSION_ID: string | undefined;
     DD_TEST_FAILED_TEST_REPLAY_ENABLED: boolean;
+    DD_TEST_FAILURE_SCREENSHOTS_ENABLED: boolean | undefined;
     DD_TEST_FLEET_CONFIG_PATH: string | undefined;
     DD_TEST_LOCAL_CONFIG_PATH: string | undefined;
     DD_TEST_MANAGEMENT_ATTEMPT_TO_FIX_RETRIES: number;
@@ -790,6 +795,7 @@ export interface GeneratedEnvVarConfig {
   DD_TELEMETRY_LOG_COLLECTION_ENABLED: boolean;
   DD_TELEMETRY_METRICS_ENABLED: boolean;
   DD_TEST_FAILED_TEST_REPLAY_ENABLED: boolean;
+  DD_TEST_FAILURE_SCREENSHOTS_ENABLED: boolean | undefined;
   DD_TEST_FLEET_CONFIG_PATH: string | undefined;
   DD_TEST_LOCAL_CONFIG_PATH: string | undefined;
   DD_TEST_MANAGEMENT_ATTEMPT_TO_FIX_RETRIES: number;
@@ -868,6 +874,7 @@ export interface GeneratedEnvVarConfig {
   DD_TRACE_BUNYAN_ENABLED: boolean;
   DD_TRACE_CASSANDRA_DRIVER_ENABLED: boolean;
   DD_TRACE_CHILD_PROCESS_ENABLED: boolean;
+  DD_TRACE_CLAUDE_AGENT_SDK_ENABLED: boolean;
   DD_TRACE_CLIENT_IP_ENABLED: boolean;
   DD_TRACE_CLIENT_IP_HEADER: string | undefined;
   DD_TRACE_CLOUD_PAYLOAD_TAGGING_MAX_DEPTH: number;
@@ -917,11 +924,14 @@ export interface GeneratedEnvVarConfig {
   DD_TRACE_GOOGLE_CLOUD_VERTEXAI_ENABLED: boolean;
   DD_TRACE_GOOGLE_GAX_ENABLED: boolean;
   DD_TRACE_GOOGLE_GENAI_ENABLED: boolean;
+  DD_TRACE_GRAPHQL_COLLAPSE: boolean;
+  DD_TRACE_GRAPHQL_DEPTH: number;
   DD_TRACE_GRAPHQL_ENABLED: boolean;
   DD_TRACE_GRAPHQL_ERROR_EXTENSIONS: string[];
   DD_TRACE_GRAPHQL_TAG_ENABLED: boolean;
   DD_TRACE_GRAPHQL_TOOLS_ENABLED: boolean;
   DD_TRACE_GRAPHQL_TOOLS_EXECUTOR_ENABLED: boolean;
+  DD_TRACE_GRAPHQL_VARIABLES: string[];
   DD_TRACE_GRAPHQL_YOGA_ENABLED: boolean;
   DD_TRACE_GRPC_ENABLED: boolean;
   DD_TRACE_GRPC_GRPC_JS_ENABLED: boolean;

package/packages/dd-trace/src/config/supported-configurations.json

@@ -1819,6 +1819,14 @@
         "namespace": "testOptimization"
       }
     ],
+    "DD_TEST_FAILURE_SCREENSHOTS_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": null,
+        "namespace": "testOptimization"
+      }
+    ],
     "DD_TEST_FLEET_CONFIG_PATH": [
       {
         "implementation": "A",
@@ -1946,6 +1954,13 @@
         "default": "true"
       }
     ],
+    "DD_TRACE_CLAUDE_AGENT_SDK_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": "true"
+      }
+    ],
     "DD_TRACE_APOLLO_ENABLED": [
       {
         "implementation": "A",
@@ -2742,6 +2757,21 @@
         "default": "true"
       }
     ],
+    "DD_TRACE_GRAPHQL_COLLAPSE": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": "true"
+      }
+    ],
+    "DD_TRACE_GRAPHQL_DEPTH": [
+      {
+        "implementation": "A",
+        "type": "int",
+        "default": "-1",
+        "allowed": "-1|\\d+"
+      }
+    ],
     "DD_TRACE_GRAPHQL_ENABLED": [
       {
         "implementation": "A",
@@ -2777,6 +2807,13 @@
         "default": "true"
       }
     ],
+    "DD_TRACE_GRAPHQL_VARIABLES": [
+      {
+        "implementation": "A",
+        "type": "array",
+        "default": ""
+      }
+    ],
     "DD_TRACE_GRAPHQL_YOGA_ENABLED": [
       {
         "implementation": "A",

package/packages/dd-trace/src/crashtracking/crashtracker.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { EOL } = require('node:os')
+const { EOL, platform } = require('node:os')
 
 // Load binding first to not import other modules if it throws
 const libdatadog = require('@datadog/libdatadog')
@@ -71,7 +71,7 @@ class Crashtracker {
 
     // Out-of-process symbolication currently works on
     // Linux only, does not work on Mac.
-    const resolveMode = require('os').platform === 'linux'
+    const resolveMode = platform() === 'linux'
       ? 'EnabledWithSymbolsInReceiver'
       : 'EnabledWithInprocessSymbols'
 

package/packages/dd-trace/src/llmobs/plugins/ai/ddTelemetry.js

@@ -0,0 +1,403 @@
+'use strict'
+
+const { channel } = require('dc-polyfill')
+const BaseLLMObsPlugin = require('../base')
+const { getModelProvider } = require('../../../../../datadog-plugin-ai/src/utils')
+
+const toolCreationCh = channel('tracing:orchestrion:ai:tool:start')
+const setAttributesCh = channel('dd-trace:vercel-ai:span:setAttributes')
+
+const { MODEL_NAME, MODEL_PROVIDER, NAME } = require('../../constants/tags')
+const {
+  getSpanTags,
+  getOperation,
+  getUsage,
+  getJsonStringValue,
+  getModelMetadata,
+  getGenerationMetadata,
+  getToolNameFromTags,
+  getToolCallResultContent,
+  getLlmObsSpanName,
+  getTelemetryMetadata,
+} = require('./util')
+
+/**
+ * @typedef {Record<string, unknown> & { description?: string, id?: string }} AvailableToolArgs
+ */
+
+/**
+ * @typedef {string | number | boolean | null | undefined | string[] | number[] | boolean[]} TagValue
+ * @typedef {Record<string, TagValue>} SpanTags
+ *
+ * @typedef {{ name?: string, description?: string }} ToolForModel
+ *
+ * @typedef {{ type: 'text' | 'reasoning' | 'redacted-reasoning', text?: string, data?: string }} TextPart
+ * @typedef {{ type: 'tool-call', toolName: string, toolCallId: string, args?: unknown, input?: unknown }} ToolCallPart
+ * @typedef {(
+ *   { type: 'tool-result', toolCallId: string, output?: { type: string, value?: unknown }, result?: unknown } &
+ *   Record<string, unknown>
+ * )} ToolResultPart
+ *
+ * @typedef {{
+ *   role: 'system',
+ *   content: string
+ * } | {
+ *   role: 'user',
+ *   content: TextPart[]
+ * } | {
+ *   role: 'assistant',
+ *   content: Array<TextPart | ToolCallPart>
+ * } | {
+ *   role: 'tool',
+ *   content: ToolResultPart[]
+ * }} AiSdkMessage
+ */
+
+const SPAN_NAME_TO_KIND_MAPPING = {
+  // embeddings
+  embed: 'workflow',
+  embedMany: 'workflow',
+  doEmbed: 'embedding',
+  // object generation
+  generateObject: 'workflow',
+  streamObject: 'workflow',
+  // text generation
+  generateText: 'workflow',
+  streamText: 'workflow',
+  // llm operations
+  doGenerate: 'llm',
+  doStream: 'llm',
+  // tools
+  toolCall: 'tool',
+}
+
+class DdTelemetryPlugin extends BaseLLMObsPlugin {
+  static id = 'ai_llmobs_dd_telemetry'
+  static integration = 'ai'
+  static prefix = 'tracing:dd-trace:vercel-ai'
+
+  /**
+   * The available tools within the runtime scope of this integration.
+   * This essentially acts as a global registry for all tools made through the Vercel AI SDK.
+   * @type {Set<AvailableToolArgs>}
+   */
+  #availableTools
+
+  /**
+   * A mapping of tool call IDs to tool names.
+   * This is used to map the tool call ID to the tool name for the output message.
+   * @type {Record<string, string>}
+   */
+  #toolCallIdsToName
+
+  constructor (...args) {
+    super(...args)
+
+    this.#toolCallIdsToName = {}
+    this.#availableTools = new Set()
+    toolCreationCh.subscribe(ctx => {
+      const toolArgs = ctx.arguments
+      const tool = toolArgs[0] ?? {}
+      this.#availableTools.add(tool)
+    })
+
+    setAttributesCh.subscribe(({ ctx, attributes }) => {
+      Object.assign(ctx.attributes, attributes)
+    })
+  }
+
+  /**
+   * Does a best-effort attempt to find the right tool name for the given tool description.
+   * This is because the Vercel AI SDK does not tag tools by name properly, but
+   * rather by the index they were passed in. Tool names appear nowhere in the span tags.
+   *
+   * We use the tool description as the next best identifier for a tool.
+   *
+   * @param {string} toolName
+   * @param {string | undefined} toolDescription
+   * @returns {string | undefined}
+   */
+  findToolName (toolName, toolDescription) {
+    if (Number.isNaN(Number.parseInt(toolName))) return toolName
+
+    for (const availableTool of this.#availableTools) {
+      const description = availableTool.description
+      if (description === toolDescription && availableTool.id) {
+        return availableTool.id
+      }
+    }
+  }
+
+  /**
+   * @override
+   */
+  getLLMObsSpanRegisterOptions (ctx) {
+    const span = ctx.currentStore?.span
+    const operation = getOperation(span)
+    const kind = SPAN_NAME_TO_KIND_MAPPING[operation]
+    if (!kind) return
+
+    return { kind, name: getLlmObsSpanName(operation, ctx.attributes['ai.telemetry.functionId']) }
+  }
+
+  /**
+   * @override
+   */
+  setLLMObsTags (ctx) {
+    const span = ctx.currentStore?.span
+    if (!span) return
+
+    const operation = getOperation(span)
+    const kind = SPAN_NAME_TO_KIND_MAPPING[operation]
+    if (!kind) return
+
+    const tags = getSpanTags(ctx)
+
+    if (['embedding', 'llm'].includes(kind)) {
+      this._tagger._setTag(span, MODEL_NAME, tags['ai.model.id'])
+      this._tagger._setTag(span, MODEL_PROVIDER, getModelProvider(tags))
+    }
+
+    switch (operation) {
+      case 'embed':
+      case 'embedMany':
+        this.setEmbeddingWorkflowTags(span, tags)
+        break
+      case 'doEmbed':
+        this.setEmbeddingTags(span, tags)
+        break
+      case 'generateObject':
+      case 'streamObject':
+        this.setObjectGenerationTags(span, tags)
+        break
+      case 'generateText':
+      case 'streamText':
+        this.setTextGenerationTags(span, tags)
+        break
+      case 'doGenerate':
+      case 'doStream':
+        this.setLLMOperationTags(span, tags)
+        break
+      case 'toolCall':
+        this.setToolTags(span, tags)
+        break
+      default:
+        break
+    }
+  }
+
+  setEmbeddingWorkflowTags (span, tags) {
+    const inputs = tags['ai.value'] ?? tags['ai.values']
+    const parsedInputs = Array.isArray(inputs)
+      ? inputs.map(input => getJsonStringValue(input, ''))
+      : getJsonStringValue(inputs, '')
+
+    const embeddingsOutput = tags['ai.embedding'] ?? tags['ai.embeddings']
+    const isSingleEmbedding = !Array.isArray(embeddingsOutput)
+    const numberOfEmbeddings = isSingleEmbedding ? 1 : embeddingsOutput.length
+    const embeddingsLength = getJsonStringValue(isSingleEmbedding ? embeddingsOutput : embeddingsOutput?.[0], []).length
+    const output = `[${numberOfEmbeddings} embedding(s) returned with size ${embeddingsLength}]`
+
+    this._tagger.tagTextIO(span, parsedInputs, output)
+
+    const metadata = getGenerationMetadata(tags)
+    this._tagger.tagMetadata(span, metadata)
+  }
+
+  setEmbeddingTags (span, tags) {
+    const inputs = tags['ai.values']
+    if (!Array.isArray(inputs)) return
+
+    const parsedInputs = inputs.map(input => getJsonStringValue(input, ''))
+
+    const embeddingsOutput = tags['ai.embeddings']
+    const numberOfEmbeddings = embeddingsOutput?.length
+    const embeddingsLength = getJsonStringValue(embeddingsOutput?.[0], []).length
+    const output = `[${numberOfEmbeddings} embedding(s) returned with size ${embeddingsLength}]`
+
+    this._tagger.tagEmbeddingIO(span, parsedInputs, output)
+
+    const metadata = getTelemetryMetadata(tags)
+    this._tagger.tagMetadata(span, metadata)
+
+    const usage = tags['ai.usage.tokens']
+    this._tagger.tagMetrics(span, {
+      inputTokens: usage,
+      totalTokens: usage,
+    })
+  }
+
+  setObjectGenerationTags (span, tags) {
+    const promptInfo = getJsonStringValue(tags['ai.prompt'], {})
+    const lastUserPrompt =
+      promptInfo.prompt ??
+      promptInfo.messages.reverse().find(message => message.role === 'user')?.content
+    const prompt = Array.isArray(lastUserPrompt) ? lastUserPrompt.map(part => part.text ?? '').join('') : lastUserPrompt
+
+    const output = tags['ai.response.object']
+
+    this._tagger.tagTextIO(span, prompt, output)
+
+    const metadata = getGenerationMetadata(tags)
+    metadata.schema = getJsonStringValue(tags['ai.schema'], {})
+    this._tagger.tagMetadata(span, metadata)
+  }
+
+  setTextGenerationTags (span, tags) {
+    const promptInfo = getJsonStringValue(tags['ai.prompt'], {})
+    const lastUserPrompt =
+      promptInfo.prompt ??
+      promptInfo.messages.reverse().find(message => message.role === 'user')?.content
+    const prompt = Array.isArray(lastUserPrompt) ? lastUserPrompt.map(part => part.text ?? '').join('') : lastUserPrompt
+
+    const output = tags['ai.response.text']
+
+    this._tagger.tagTextIO(span, prompt, output)
+
+    const metadata = getGenerationMetadata(tags)
+    this._tagger.tagMetadata(span, metadata)
+  }
+
+  /**
+   * @param {import('../../../opentracing/span')} span
+   * @param {SpanTags} tags
+   */
+  setLLMOperationTags (span, tags) {
+    const toolsForModel = tags['ai.prompt.tools']?.map(getJsonStringValue)
+
+    const inputMessages = getJsonStringValue(tags['ai.prompt.messages'], [])
+    const parsedInputMessages = []
+    for (const message of inputMessages) {
+      const formattedMessages = this.formatMessage(message, toolsForModel)
+      parsedInputMessages.push(...formattedMessages)
+    }
+
+    const outputMessage = this.formatOutputMessage(tags, toolsForModel)
+
+    this._tagger.tagLLMIO(span, parsedInputMessages, outputMessage)
+
+    const metadata = getModelMetadata(tags)
+    this._tagger.tagMetadata(span, metadata)
+
+    const usage = getUsage(tags)
+    this._tagger.tagMetrics(span, usage)
+  }
+
+  setToolTags (span, tags) {
+    const toolCallId = tags['ai.toolCall.id']
+    const name = getToolNameFromTags(tags) ?? this.#toolCallIdsToName[toolCallId]
+    if (name) this._tagger._setTag(span, NAME, name)
+
+    const input = tags['ai.toolCall.args']
+    const output = tags['ai.toolCall.result']
+
+    this._tagger.tagTextIO(span, input, output)
+  }
+
+  formatOutputMessage (tags, toolsForModel) {
+    const outputMessageText = tags['ai.response.text'] ?? tags['ai.response.object']
+    const outputMessageToolCalls = getJsonStringValue(tags['ai.response.toolCalls'], [])
+
+    const formattedToolCalls = []
+    for (const toolCall of outputMessageToolCalls) {
+      const toolArgs = toolCall.args ?? toolCall.input
+      const toolCallArgs = typeof toolArgs === 'string' ? getJsonStringValue(toolArgs, {}) : toolArgs
+      const toolDescription = toolsForModel?.find(tool => toolCall.toolName === tool.name)?.description
+      const name = this.findToolName(toolCall.toolName, toolDescription)
+      this.#toolCallIdsToName[toolCall.toolCallId] = name
+
+      formattedToolCalls.push({
+        arguments: toolCallArgs,
+        name,
+        toolId: toolCall.toolCallId,
+        type: toolCall.toolCallType ?? 'function',
+      })
+    }
+
+    return {
+      role: 'assistant',
+      content: outputMessageText,
+      toolCalls: formattedToolCalls,
+    }
+  }
+
+  /**
+   * Returns a list of formatted messages from a message object.
+   * Most of these will just be one entry, but in the case of a "tool" role,
+   * it is possible to have multiple tool call results in a single message that we
+   * need to split into multiple messages.
+   *
+   * @param {AiSdkMessage} message
+   * @param {ToolForModel[] | null | undefined} toolsForModel
+   * @returns {Array<{role: string, content: string, toolId?: string,
+   *   toolCalls?: Array<{arguments: string, name: string, toolId: string, type: string}>}>}
+   */
+  formatMessage (message, toolsForModel) {
+    const { role, content } = message
+
+    if (role === 'system') {
+      return [{ role, content }]
+    } else if (role === 'user') {
+      let finalContent = ''
+      for (const part of content) {
+        const { type } = part
+        if (type === 'text') {
+          finalContent += part.text
+        }
+      }
+
+      return [{ role, content: finalContent }]
+    } else if (role === 'assistant') {
+      const toolCalls = []
+      let finalContent = ''
+
+      for (const part of content) {
+        const { type } = part
+        // TODO(sabrenner): do we want to include reasoning?
+        if (['text', 'reasoning', 'redacted-reasoning'].includes(type)) {
+          finalContent += part.text ?? part.data
+        } else if (type === 'tool-call') {
+          const toolDescription = toolsForModel?.find(tool => part.toolName === tool.name)?.description
+          const name = this.findToolName(part.toolName, toolDescription)
+
+          toolCalls.push({
+            arguments: part.args ?? part.input,
+            name,
+            toolId: part.toolCallId,
+            type: 'function',
+          })
+        }
+      }
+
+      const finalMessage = {
+        role,
+        content: finalContent,
+      }
+
+      if (toolCalls.length) {
+        finalMessage.toolCalls = toolCalls.length ? toolCalls : undefined
+      }
+
+      return [finalMessage]
+    } else if (role === 'tool') {
+      const finalMessages = []
+      for (const part of content) {
+        if (part.type === 'tool-result') {
+          const safeResult = getToolCallResultContent(part)
+
+          finalMessages.push({
+            role,
+            content: safeResult,
+            toolId: part.toolCallId,
+          })
+        }
+      }
+
+      return finalMessages
+    }
+
+    return []
+  }
+}
+
+module.exports = DdTelemetryPlugin