dd-trace 6.15.0 → 6.17.0

package/packages/dd-trace/src/llmobs/experiments/dataset.js

@@ -330,7 +330,6 @@ class Dataset {
    * @param {string} recordId Dataset record id.
    * @param {'add' | 'remove' | 'replace'} operation Tag operation to queue.
    * @param {string[]} tags Tags in key:value format.
-   * @returns {void}
    */
   #queueTagOperation (recordId, operation, tags) {
     if (operation !== 'replace' && tags.length === 0) return
@@ -503,7 +502,6 @@ class Dataset {
    * Detach tag changes sent by this batch so edits made while the request is in flight
    * are queued relative to the response that this batch will commit.
    * @param {PendingBatch} pending
-   * @returns {void}
    */
   #detachCommittedTagOperations (pending) {
     pending.inFlightTagOperations = new Map()
@@ -527,7 +525,6 @@ class Dataset {
   /**
    * Restore tag changes when a batch request fails, including edits made while it was in flight.
    * @param {PendingBatch} pending
-   * @returns {void}
    */
   #restoreFailedTagOperations (pending) {
     if (!pending.inFlightTagOperations) return
@@ -549,7 +546,6 @@ class Dataset {
   /**
    * Clear the changes represented by a completed batch while retaining concurrent local edits.
    * @param {PendingBatch} pending
-   * @returns {void}
    */
   #clearCommittedChanges (pending) {
     for (const [recordId, payload] of pending.insertPayloads) {

package/packages/dd-trace/src/llmobs/experiments/experiment.js

@@ -1015,9 +1015,6 @@ class ExternalExperiment {
     this.#experiment = experiment
   }
 
-  /**
-   * @returns {string}
-   */
   name () {
     return this.#experiment.name()
   }

package/packages/dd-trace/src/llmobs/experiments/index.js

@@ -35,8 +35,8 @@ class Experiments {
 
   constructor (config, llmobs) {
     this.#config = config
-    this.#llmobs = config.llmobs?.mlApp || config.service ? llmobs : undefined
-    this.#projectName = config.llmobs?.projectName || DEFAULT_PROJECT_NAME
+    this.#llmobs = config.llmobs?.DD_LLMOBS_ML_APP || config.service ? llmobs : undefined
+    this.#projectName = config.llmobs?.DD_LLMOBS_PROJECT_NAME || DEFAULT_PROJECT_NAME
     this.#client = this.#clientForProject(this.#projectName)
   }
 
@@ -179,9 +179,9 @@ class Experiments {
     const projectName = options?.projectName ?? datasetProjectName
     const client = this.#clientForOperation(projectName)
     const usesDatasetOverride = datasetProjectName !== undefined && datasetProjectName !== this.#projectName
-    const resolvedProjectName = projectName ?? this.#config.llmobs?.projectName
+    const resolvedProjectName = projectName ?? this.#config.llmobs?.DD_LLMOBS_PROJECT_NAME
     const experimentOptions = options?.projectName === undefined &&
-      (usesDatasetOverride || this.#config.llmobs?.projectName !== undefined) &&
+      (usesDatasetOverride || this.#config.llmobs?.DD_LLMOBS_PROJECT_NAME !== undefined) &&
       resolvedProjectName !== undefined
       ? { ...options, projectName: resolvedProjectName }
       : options
@@ -198,8 +198,9 @@ class Experiments {
    */
   startExperiment (options) {
     const client = this.#clientForOperation(options?.projectName)
-    const experimentOptions = options?.projectName === undefined && this.#config.llmobs?.projectName !== undefined
-      ? { ...options, projectName: this.#config.llmobs.projectName }
+    const experimentOptions = options?.projectName === undefined &&
+      this.#config.llmobs?.DD_LLMOBS_PROJECT_NAME !== undefined
+      ? { ...options, projectName: this.#config.llmobs.DD_LLMOBS_PROJECT_NAME }
       : options
     return new Experiment(client, { ...experimentOptions, external: true }).start()
       .then(experiment => new ExternalExperiment(experiment))

package/packages/dd-trace/src/llmobs/experiments/util.js

@@ -14,7 +14,6 @@ const EVALUATOR_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/
 
 /**
  * @param {object | null | undefined} value
- * @returns {boolean}
  */
 function hasEntries (value) {
   if (!value) return false
@@ -47,16 +46,12 @@ function tagOperationsAreEmpty (operations) {
 /**
  * @param {unknown} value
  * @param {string} name
- * @returns {number}
  */
 function normalizePositiveInteger (value, name) {
   if (!Number.isInteger(value) || value < 1) throw new Error(`${name} must be a positive integer`)
-  return value
+  return /** @type {number} */ (value)
 }
 
-/**
- * @returns {string}
- */
 function generateRunId () {
   return randomUUID()
 }
@@ -77,7 +72,6 @@ function validateEvaluatorName (name) {
 /**
  * @param {(...args: unknown[]) => unknown} fn
  * @param {string} fallback
- * @returns {string}
  */
 function functionName (fn, fallback) {
   return typeof fn.name === 'string' && fn.name.length > 0 ? fn.name : fallback
@@ -124,7 +118,6 @@ function normalizeEvaluators (evaluators, kind) {
 
 /**
  * @param {unknown} value
- * @returns {string}
  */
 function inferMetricType (value) {
   if (typeof value === 'boolean') return 'boolean'
@@ -184,7 +177,6 @@ function normalizeJsonMetricValue (value) {
 
 /**
  * @param {unknown} value
- * @returns {string}
  */
 function stringify (value) {
   if (value == null) return ''
@@ -270,7 +262,6 @@ function sleep (ms) {
 /**
  * @param {unknown} value
  * @param {number} fallback
- * @returns {number}
  */
 function timestampMs (value, fallback = Date.now()) {
   if (value === null || value === undefined) return fallback
@@ -286,7 +277,6 @@ function timestampMs (value, fallback = Date.now()) {
 /**
  * @param {{ durationMs?: unknown, completedAt?: unknown }} row
  * @param {number} startMs
- * @returns {number}
  */
 function durationNs (row, startMs) {
   if (typeof row.durationMs === 'number' && Number.isFinite(row.durationMs)) {

package/packages/dd-trace/src/llmobs/index.js

@@ -152,7 +152,6 @@ function disable () {
  * Keeps retired writers reachable until their destroy-triggered deliveries complete.
  * @param {LLMObsSpanWriter | null} retiredSpanWriter
  * @param {LLMObsEvalMetricsWriter | null} retiredEvalWriter
- * @returns {void}
  */
 function retireWriters (retiredSpanWriter, retiredEvalWriter) {
   const retiredWriters = [retiredSpanWriter, retiredEvalWriter].filter(Boolean)
@@ -183,7 +182,7 @@ function handleLLMObsInjection (injection) {
   const mlApp =
     mlObsSpanTags?.[ML_APP] ||
     parentContext?._trace?.tags?.[PROPAGATED_ML_APP_KEY] ||
-    globalTracerConfig.llmobs.mlApp
+    globalTracerConfig.llmobs.DD_LLMOBS_ML_APP
 
   const sampleRate =
     mlObsSpanTags?.[SAMPLE_RATE] ?? parentContext?._trace?.tags?.[PROPAGATED_SAMPLE_RATE_KEY]
@@ -239,7 +238,6 @@ function handleLLMObsInjection (injection) {
  * @param {Function} [done]
  * @param {LLMObsSpanWriter | null} [currentSpanWriter]
  * @param {LLMObsEvalMetricsWriter | null} [currentEvalWriter]
- * @returns {boolean} `true` when a writer throws synchronously.
  */
 function flushWriters (done, currentSpanWriter = spanWriter, currentEvalWriter = evalWriter) {
   let failed = false

package/packages/dd-trace/src/llmobs/noop.js

@@ -1,5 +1,7 @@
 'use strict'
 
+const NoopPrompts = require('./prompts/noop')
+
 let NoopExperiments
 
 class NoopLLMObs {
@@ -16,6 +18,14 @@ class NoopLLMObs {
     return new NoopExperiments('LLM Observability is not enabled')
   }
 
+  /**
+   * Prompt Management API.
+   * @returns {import('../../../../index').llmobs.Prompts}
+   */
+  get prompts () {
+    return new NoopPrompts()
+  }
+
   enable (options) {}
 
   disable () {}

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

@@ -337,7 +337,6 @@ function getToolNameFromTags (tags) {
 
 /**
  * @param {unknown} value
- * @returns {string}
  */
 function stringifyToolCallResult (value) {
   return JSON.stringify(value) ?? UNPARSABLE_TOOL_RESULT
@@ -345,7 +344,6 @@ function stringifyToolCallResult (value) {
 
 /**
  * @param {ToolCallContentPart[]} value
- * @returns {string}
  */
 function formatToolCallContent (value) {
   if (!Array.isArray(value)) return UNPARSABLE_TOOL_RESULT
@@ -388,7 +386,6 @@ function formatToolCallContent (value) {
 
 /**
  * @param {ToolCallResultContent | null | undefined} content
- * @returns {string}
  */
 function getToolCallResultContent (content) {
   try {
@@ -426,7 +423,6 @@ function getToolCallResultContent (content) {
  * Computes the LLM Observability `ai` span name
  * @param {string} operation
  * @param {string} functionId
- * @returns {string}
  */
 function getLlmObsSpanName (operation, functionId) {
   return functionId ? `${functionId}.${operation}` : operation

package/packages/dd-trace/src/llmobs/plugins/anthropic/util.js

@@ -62,7 +62,6 @@ function formatAnthropicToolResultContent (content) {
  *
  * @param {AnthropicLlmObsMessage[]} messages
  * @param {{ role: string, content: string | Array<TextBlock | ImageBlock | ToolUseBlock | ToolResultBlock> }} message
- * @returns {void}
  */
 function appendMessage (messages, { role, content }) {
   if (typeof content === 'string') {

package/packages/dd-trace/src/llmobs/plugins/genai/util.js

@@ -55,7 +55,6 @@ function groupPartsByRole (parts) {
 /**
  * Check if parts contain thought/reasoning content
  * @param {Array<{thought?: boolean}>} parts
- * @returns {boolean}
  */
 function hasThoughtParts (parts) {
   return parts.some(part => part.thought === true)
@@ -65,7 +64,6 @@ function hasThoughtParts (parts) {
  * Determine the role from a candidate and its parts
  * @param {object} candidate
  * @param {Array<{thought?: boolean}>} parts
- * @returns {string}
  */
 function determineRole (candidate, parts = []) {
   // Check parts for thought indicators
@@ -84,7 +82,6 @@ function determineRole (candidate, parts = []) {
 /**
  * Normalize role to standard values
  * @param {string} role
- * @returns {string}
  */
 function normalizeRole (role) {
   if (role === ROLES.MODEL) return ROLES.ASSISTANT
@@ -520,7 +517,6 @@ function formatOutputMessages (response, isStreaming = false) {
 /**
  * Format embedding output from response
  * @param {object} response
- * @returns {string}
  */
 function formatEmbeddingOutput (response) {
   if (!response?.embeddings?.length) {

package/packages/dd-trace/src/llmobs/plugins/modelcontextprotocol-sdk/utils.js

@@ -4,7 +4,6 @@
  * Formats tool call input as a JSON string.
  * @param {string} toolName - The name of the tool being called
  * @param {object} toolArguments - The arguments passed to the tool
- * @returns {string} Formatted input string
  */
 function formatInput (toolName, toolArguments) {
   if (!toolName && !toolArguments) return ''
@@ -25,7 +24,6 @@ function formatInput (toolName, toolArguments) {
  * MCP tool results contain a `content` array with items like:
  * `[{ type: 'text', text: '...' }, { type: 'image', data: '...', mimeType: '...' }]`
  * @param {object} result - The MCP CallToolResult
- * @returns {string} JSON string of `{ content: Array<{type, text, annotations, meta}>, isError: boolean }`
  */
 function formatOutput (result) {
   if (!result) return ''

package/packages/dd-trace/src/llmobs/plugins/openai/constants.js

@@ -6,7 +6,6 @@ const INPUT_TYPE_TEXT = 'input_text'
 
 const IMAGE_FALLBACK = '[image]'
 const FILE_FALLBACK = '[file]'
-const AUDIO_FALLBACK = '[audio]'
 
 // OpenAI audio `format` values that don't map cleanly to `audio/<format>`.
 const AUDIO_MIME_TYPES = {
@@ -19,6 +18,5 @@ module.exports = {
   INPUT_TYPE_TEXT,
   IMAGE_FALLBACK,
   FILE_FALLBACK,
-  AUDIO_FALLBACK,
   AUDIO_MIME_TYPES,
 }

package/packages/dd-trace/src/llmobs/plugins/openai/index.js

@@ -6,7 +6,8 @@ const {
   PROMPT_MULTIMODAL,
   INSTRUMENTATION_METHOD_AUTO,
 } = require('../../constants/tags')
-const { audioMimeTypeFromFormat, formatAudioPart, safeJsonParse } = require('../../util')
+const { audioMimeTypeFromFormat, formatAudioPart } = require('../../audio-utils')
+const { safeJsonParse } = require('../../util')
 const { AUDIO_MIME_TYPES } = require('./constants')
 const {
   extractChatTemplateFromInstructions,
@@ -14,7 +15,7 @@ const {
   extractTextFromContentItem,
   extractContentParts,
   hasMultimodalInputs,
-  getOpenAIModelProvider,
+  getModelProviderAndClient,
 } = require('./utils')
 
 const allowedParamKeys = new Set([
@@ -108,10 +109,7 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
   }
 
   _getModelProviderAndClient (baseUrl = '') {
-    const modelProvider = getOpenAIModelProvider(baseUrl)
-    if (modelProvider === 'azure_openai') return { modelProvider, client: 'AzureOpenAI' }
-    if (modelProvider === 'deepseek') return { modelProvider, client: 'DeepSeek' }
-    return { modelProvider, client: 'OpenAI' }
+    return getModelProviderAndClient(baseUrl)
   }
 
   _extractMetrics (response) {

package/packages/dd-trace/src/llmobs/plugins/openai/realtime.js

@@ -0,0 +1,285 @@
+'use strict'
+
+const {
+  g711ToPcm16,
+  g711Variant,
+  isPcm16AudioMime,
+  pcm16ToWav,
+} = require('../../audio-codec')
+const { fitsInlineAudioBudget, formatAudioPartWithGuard } = require('../../audio-utils')
+const {
+  AUDIO_FALLBACK,
+  G711_SAMPLE_RATE,
+  LLMOBS_AUDIO_INLINE_MAX_BYTES,
+  PCM16_BYTES_PER_SAMPLE,
+  WAV_HEADER_BYTES,
+} = require('../../constants/audio')
+const { storage: llmobsStorage } = require('../../storage')
+const { safeJsonParse } = require('../../util')
+const LLMObsPlugin = require('../base')
+const { getModelProviderAndClient } = require('./utils')
+
+/**
+ * @typedef {import('../../audio-utils').AudioPart} AudioPart
+ * @typedef {{
+ *   role: string,
+ *   content: string,
+ *   audioParts?: AudioPart[],
+ *   toolCalls?: object[],
+ *   toolResults?: object[],
+ * }} Message
+ */
+
+/**
+ * Turn a turn side's raw audio into a playable audio part.
+ *
+ * Realtime audio is raw PCM16 (24 kHz mono) by default, which the UI can't render, so it is wrapped
+ * in a WAV container — lossless, just a header. G.711 telephony audio, used by phone-call
+ * integrations, is decoded to PCM16 and likewise WAV-wrapped at its fixed 8 kHz rate. Anything else
+ * is passed to the size guard as-is, which keeps it only if it is renderable and within budget.
+ *
+ * Both conversions expand what they are given — G.711 doubles it, and either way a WAV header is
+ * prepended — so the budget is checked against the size the conversion *would* produce before
+ * running it. Checking afterwards, as the guard alone does, means decoding and copying megabytes
+ * only to discard them: the retention cap admits roughly twice what a G.711 turn can ever inline.
+ *
+ * @param {Buffer} audio
+ * @param {string} mimeType
+ * @param {number} sampleRate
+ * @param {number} maxBytes - Encoded bytes still available to this turn. See `setLLMObsTags`.
+ * @returns {AudioPart | undefined}
+ */
+function buildAudioPart (audio, mimeType, sampleRate, maxBytes) {
+  if (!audio.length) return
+
+  if (isPcm16AudioMime(mimeType)) {
+    if (!fitsInlineAudioBudget(audio.length + WAV_HEADER_BYTES, maxBytes)) return
+    return formatAudioPartWithGuard(pcm16ToWav(audio, sampleRate), 'audio/wav', maxBytes)
+  }
+
+  const variant = g711Variant(mimeType)
+  if (variant !== undefined) {
+    if (!fitsInlineAudioBudget(audio.length * PCM16_BYTES_PER_SAMPLE + WAV_HEADER_BYTES, maxBytes)) return
+    return formatAudioPartWithGuard(
+      pcm16ToWav(g711ToPcm16(audio, variant), G711_SAMPLE_RATE), 'audio/wav', maxBytes
+    )
+  }
+
+  return formatAudioPartWithGuard(audio, mimeType, maxBytes)
+}
+
+/**
+ * Encoded size an already-built message contributes to the span event, which for audio is the
+ * base64 content itself.
+ *
+ * @param {Message | undefined} message
+ */
+function audioBytesOf (message) {
+  return message?.audioParts?.[0]?.content?.length ?? 0
+}
+
+/**
+ * @param {object[]} toolCalls
+ * @returns {object[]}
+ */
+function parseToolCallArguments (toolCalls) {
+  return toolCalls.map(toolCall => ({ ...toolCall, arguments: safeJsonParse(toolCall.arguments ?? '', {}) }))
+}
+
+/**
+ * Build the message for one side of a turn.
+ *
+ * @param {string} role
+ * @param {import('../../../../../datadog-instrumentations/src/openai-realtime/session').TurnSide} side
+ * @param {number} maxAudioBytes - Encoded audio bytes still available to this turn.
+ * @returns {Message | undefined}
+ */
+function buildMessage (role, side, maxAudioBytes) {
+  const audioPart = buildAudioPart(side.audio, side.mimeType, side.sampleRate, maxAudioBytes)
+
+  let content = side.transcript || side.text
+  if (!content && audioPart === undefined && side.audioPresent) {
+    // Audio was captured but couldn't be turned into a playable part — an unsupported format, or
+    // over the size budget — and there is no transcript, so surface a marker rather than let the
+    // turn look silently empty.
+    content = AUDIO_FALLBACK
+  }
+
+  const toolCalls = side.toolCalls?.length ? parseToolCallArguments(side.toolCalls) : undefined
+  const toolResults = side.toolResults.length ? side.toolResults : undefined
+
+  if (!content && audioPart === undefined && toolCalls === undefined && toolResults === undefined) return
+
+  /** @type {Message} */
+  const message = { role, content: content || '' }
+  if (audioPart !== undefined) message.audioParts = [audioPart]
+  if (toolCalls !== undefined) message.toolCalls = toolCalls
+  if (toolResults !== undefined) message.toolResults = toolResults
+
+  return message
+}
+
+/**
+ * @param {{ input_tokens?: number, output_tokens?: number, total_tokens?: number } | undefined} usage
+ * @returns {Record<string, number> | undefined}
+ */
+function usageMetrics (usage) {
+  if (!usage) return
+
+  const { input_tokens: inputTokens, output_tokens: outputTokens } = usage
+  let { total_tokens: totalTokens } = usage
+
+  /** @type {Record<string, number>} */
+  const metrics = {}
+  if (inputTokens != null) metrics.input_tokens = inputTokens
+  if (outputTokens != null) metrics.output_tokens = outputTokens
+  // Mirror the chat and responses fallback.
+  if (totalTokens == null && inputTokens != null && outputTokens != null) {
+    totalTokens = inputTokens + outputTokens
+  }
+  if (totalTokens != null) metrics.total_tokens = totalTokens
+
+  return metrics.total_tokens === undefined && metrics.input_tokens === undefined ? undefined : metrics
+}
+
+/**
+ * LLM Observability spans for one OpenAI Realtime turn.
+ *
+ * The turn is modelled as a small tree — a `workflow` root with a `user speech` window, the `llm`
+ * generation span, and an `agent speech` window — so span duration is meaningful (the llm span
+ * measures model work, not the human's speaking time) and time-to-first-agent-audio falls out of the
+ * span boundaries. Consumers identify the phase spans by span kind and name, so those strings are a
+ * contract: renaming one is a breaking change for the UI and the backend metric alike.
+ */
+class RealtimeLLMObsPlugin extends LLMObsPlugin {
+  static integration = 'openai'
+  static system = 'openai'
+
+  /**
+   * The instrumentation replays the turn with `traceSync`, which never publishes `asyncEnd`, so tag
+   * on `end` instead — before the sibling tracing plugin's `end` finishes the span, since the LLM
+   * Observability plugins are registered first.
+   *
+   * @param {object} ctx
+   */
+  end (ctx) {
+    super.end(ctx)
+    super.asyncEnd(ctx)
+  }
+}
+
+/** The whole perceived turn. Carries the transcripts so the waterfall row reads as a conversation. */
+class RealtimeTurnLLMObsPlugin extends RealtimeLLMObsPlugin {
+  static id = 'openai_realtime_turn_llmobs'
+  static prefix = 'tracing:apm:openai:realtime:turn'
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('dd-trace:openai:realtime:capture-context', turn => {
+      if (!this._tracerConfig.llmobs.DD_LLMOBS_ENABLED) return
+
+      // Composed on top of the tracing plugin's, so the replayed tree restores both the APM and the
+      // LLM Observability context the caller had active when the turn began.
+      const store = llmobsStorage.getStore()
+      const previous = turn.runInContext ?? (fn => fn())
+      turn.runInContext = fn => previous(() => llmobsStorage.run(store, fn))
+    })
+  }
+
+  getLLMObsSpanRegisterOptions (ctx) {
+    return {
+      kind: 'workflow',
+      // Provider-agnostic `audio turn` marker, so a consumer can gate on "is this a voice turn?".
+      name: 'realtime audio turn',
+      sessionId: ctx.turn.sessionId,
+    }
+  }
+
+  setLLMObsTags (ctx) {
+    const span = ctx.currentStore?.span
+    if (!span) return
+
+    const { input, output } = ctx.turn
+    this._tagger.tagTextIO(span, input.transcript || input.text, output.transcript || output.text)
+  }
+}
+
+/** The model's generation work. The turn's audio, tool calls and token usage ride here. */
+class RealtimeResponseLLMObsPlugin extends RealtimeLLMObsPlugin {
+  static id = 'openai_realtime_response_llmobs'
+  static prefix = 'tracing:apm:openai:realtime:response'
+
+  constructor (...args) {
+    super(...args)
+
+    // This plugin is the only consumer of a turn's audio bytes, and the instrumentation keeps them
+    // only while something is subscribed here — a disabled plugin unsubscribes, so an APM-only
+    // process never buffers audio it cannot use. Nothing is ever published; the subscription is the
+    // signal. Keep it if `buildMessage` stops reading `side.audio`, and the buffering stops with it.
+    this.addSub('dd-trace:openai:realtime:audio', () => {})
+  }
+
+  getLLMObsSpanRegisterOptions (ctx) {
+    const { turn } = ctx
+    const { modelProvider, client } = getModelProviderAndClient(turn.basePath)
+
+    return {
+      kind: 'llm',
+      name: `${client}.createRealtimeResponse`,
+      modelName: turn.model || 'unknown_model',
+      modelProvider,
+      sessionId: turn.sessionId,
+    }
+  }
+
+  setLLMObsTags (ctx) {
+    const span = ctx.currentStore?.span
+    if (!span) return
+
+    const { turn } = ctx
+
+    // One budget for the whole event, spent across both sides rather than offered to each.
+    // A turn normally carries audio on both sides, so a per-message budget lets two individually
+    // accepted clips add up to twice the limit — and `writers/spans.js` responds by truncating the
+    // event's *entire* input and output, losing the transcripts too. Input is served first and the
+    // output falls back to its transcript when nothing is left, which is the same graceful
+    // degradation an oversize single clip already gets.
+    const inputMessage = buildMessage('user', turn.input, LLMOBS_AUDIO_INLINE_MAX_BYTES)
+    const remainingAudioBytes = LLMOBS_AUDIO_INLINE_MAX_BYTES - audioBytesOf(inputMessage)
+    const outputMessage = buildMessage('assistant', turn.output, remainingAudioBytes)
+
+    this._tagger.tagLLMIO(span, inputMessage ? [inputMessage] : [], outputMessage ? [outputMessage] : [])
+    this._tagger.tagMetadata(span, turn.metadata)
+
+    const metrics = usageMetrics(turn.usage)
+    if (metrics !== undefined) this._tagger.tagMetrics(span, metrics)
+  }
+}
+
+/** A speaking window — the human's or the agent's. These are timing regions; the audio rides on the llm span. */
+class RealtimeSpeechLLMObsPlugin extends RealtimeLLMObsPlugin {
+  static id = 'openai_realtime_speech_llmobs'
+  static prefix = 'tracing:apm:openai:realtime:speech'
+
+  getLLMObsSpanRegisterOptions (ctx) {
+    return {
+      kind: 'workflow',
+      name: ctx.phase.llmobsName,
+      sessionId: ctx.turn.sessionId,
+    }
+  }
+
+  setLLMObsTags (ctx) {
+    const span = ctx.currentStore?.span
+    if (!span) return
+
+    this._tagger.tagTextIO(span, undefined, ctx.transcript)
+  }
+}
+
+module.exports = [
+  RealtimeTurnLLMObsPlugin,
+  RealtimeResponseLLMObsPlugin,
+  RealtimeSpeechLLMObsPlugin,
+]

package/packages/dd-trace/src/llmobs/plugins/openai/utils.js

@@ -1,13 +1,13 @@
 'use strict'
 
+const { audioMimeTypeFromFormat, formatAudioPart } = require('../../audio-utils')
+const { AUDIO_FALLBACK } = require('../../constants/audio')
 const { UNKNOWN_MODEL_PROVIDER } = require('../../constants/tags')
-const { audioMimeTypeFromFormat, formatAudioPart } = require('../../util')
 const {
   INPUT_TYPE_IMAGE,
   INPUT_TYPE_FILE,
   IMAGE_FALLBACK,
   FILE_FALLBACK,
-  AUDIO_FALLBACK,
   AUDIO_MIME_TYPES,
 } = require('./constants')
 
@@ -177,7 +177,6 @@ function extractContentParts (parts) {
  * client baseURL convention.
  *
  * @param {string} baseUrl
- * @returns {string}
  */
 function getOpenAIModelProvider (baseUrl = '') {
   if (baseUrl.includes('azure')) return 'azure_openai'
@@ -186,11 +185,25 @@ function getOpenAIModelProvider (baseUrl = '') {
   return UNKNOWN_MODEL_PROVIDER
 }
 
+/**
+ * Pair an OpenAI-compatible base URL's model provider with the client label used in span names.
+ *
+ * @param {string} [baseUrl]
+ * @returns {{ modelProvider: string, client: string }}
+ */
+function getModelProviderAndClient (baseUrl = '') {
+  const modelProvider = getOpenAIModelProvider(baseUrl)
+  if (modelProvider === 'azure_openai') return { modelProvider, client: 'AzureOpenAI' }
+  if (modelProvider === 'deepseek') return { modelProvider, client: 'DeepSeek' }
+  return { modelProvider, client: 'OpenAI' }
+}
+
 module.exports = {
   extractChatTemplateFromInstructions,
   normalizePromptVariables,
   extractTextFromContentItem,
   extractContentParts,
   hasMultimodalInputs,
+  getModelProviderAndClient,
   getOpenAIModelProvider,
 }