dd-trace 6.16.0 → 6.17.0

package/packages/dd-trace/src/llmobs/audio-utils.js

@@ -0,0 +1,121 @@
+'use strict'
+
+// Building `audioPart`s for LLM Observability messages: mapping provider audio formats to MIME
+// types, and keeping inline audio within the per-span-event size budget. The raw-audio primitives
+// these build on (WAV wrapping, G.711 decoding, byte rates) live in `audio-codec.js`.
+
+const log = require('../log')
+const { LLMOBS_AUDIO_INLINE_MAX_BYTES } = require('./constants/audio')
+
+/**
+ * @typedef {{ mimeType: string, content: string }} AudioPart
+ */
+
+// Raw audio formats the UI cannot render as a player. For these we keep the transcript as the
+// message content and skip the inline audio part, since raw bytes would only bloat the payload.
+const NON_RENDERABLE_AUDIO_MIME_TYPES = new Set([
+  'audio/pcm',
+  'audio/pcm16',
+  'audio/l16',
+  'audio/pcmu',
+  'audio/pcma',
+  'audio/g711_ulaw',
+  'audio/g711_alaw',
+  'audio/basic',
+])
+
+/**
+ * Length of `byteLength` bytes after standard base64 encoding: 4 characters per 3 bytes, padded.
+ *
+ * @param {number} byteLength
+ */
+function base64EncodedLength (byteLength) {
+  return Math.ceil(byteLength / 3) * 4
+}
+
+// Maps an audio `format` (e.g. "wav", "mp3") to a MIME type. Defaults to `audio/wav` when the
+// format is missing. Provider-specific overrides (e.g. OpenAI's mp3 -> audio/mpeg) are passed in
+// via `mimeTypeLookup` so this stays provider-agnostic. A non-string `format` is treated as missing
+// so a malformed auto-instrumented payload can't throw and disable the plugin.
+/**
+ * @param {string} fmt
+ * @param {Record<string, string>} [mimeTypeLookup]
+ */
+function audioMimeTypeFromFormat (fmt, mimeTypeLookup = {}) {
+  fmt = typeof fmt === 'string' ? fmt.trim().toLowerCase() : ''
+  if (!fmt) return 'audio/wav'
+  // `hasOwn` rather than a plain lookup: a format of "constructor" would otherwise resolve to
+  // something off Object.prototype and be returned as the MIME type.
+  return Object.hasOwn(mimeTypeLookup, fmt) ? mimeTypeLookup[fmt] : `audio/${fmt}`
+}
+
+/**
+ * Whether a MIME type can be rendered as an audio player in the UI. Raw PCM cannot.
+ *
+ * @param {string} mimeType
+ */
+function isRenderableAudioMime (mimeType) {
+  return typeof mimeType === 'string' &&
+    mimeType.length > 0 &&
+    !NON_RENDERABLE_AUDIO_MIME_TYPES.has(mimeType.trim().toLowerCase())
+}
+
+// Builds an audio part from raw audio bytes (base64-encoded) or an existing base64 string. Only
+// Buffer/Uint8Array inputs are base64-encoded; any other shape is passed through so a malformed
+// auto-instrumented payload can't throw (the tagger soft-skips a non-string `content`).
+/**
+ * @param {Buffer | Uint8Array | string} data
+ * @param {string} mimeType
+ * @returns {AudioPart}
+ */
+function formatAudioPart (data, mimeType) {
+  const content = Buffer.isBuffer(data) || ArrayBuffer.isView(data)
+    ? Buffer.from(data).toString('base64')
+    : data
+  return { mimeType, content }
+}
+
+/**
+ * Whether `byteLength` bytes of audio fit the inline budget once base64-encoded.
+ *
+ * Compares the *encoded* size: `formatAudioPart` base64-encodes the bytes (~4/3 expansion), and it
+ * is that encoded content which counts against the per-span-event limit. Exposed separately so a
+ * caller that has to allocate to produce those bytes — decoding G.711 to PCM16, wrapping raw PCM in
+ * a WAV container — can check the size it is about to produce before paying for it.
+ *
+ * @param {number} byteLength
+ * @param {number} [maxBytes]
+ */
+function fitsInlineAudioBudget (byteLength, maxBytes = LLMOBS_AUDIO_INLINE_MAX_BYTES) {
+  const encodedLength = base64EncodedLength(byteLength)
+  if (encodedLength <= maxBytes) return true
+
+  log.debug('Audio (%d encoded bytes) exceeds inline budget %d; omitting inline audio content',
+    encodedLength, maxBytes)
+  return false
+}
+
+/**
+ * Build a playable audio part, but only for renderable formats within the size budget. Returns
+ * `undefined` for a non-renderable format (e.g. raw PCM) or oversize audio; callers fall back to the
+ * transcript as the message content in that case.
+ *
+ * @param {Buffer} audioBytes
+ * @param {string} mimeType
+ * @param {number} [maxBytes]
+ * @returns {AudioPart | undefined}
+ */
+function formatAudioPartWithGuard (audioBytes, mimeType, maxBytes = LLMOBS_AUDIO_INLINE_MAX_BYTES) {
+  if (!audioBytes?.length || !isRenderableAudioMime(mimeType)) return
+  if (!fitsInlineAudioBudget(audioBytes.length, maxBytes)) return
+
+  return formatAudioPart(audioBytes, mimeType)
+}
+
+module.exports = {
+  audioMimeTypeFromFormat,
+  fitsInlineAudioBudget,
+  formatAudioPart,
+  formatAudioPartWithGuard,
+  isRenderableAudioMime,
+}

package/packages/dd-trace/src/llmobs/constants/audio.js

@@ -0,0 +1,35 @@
+'use strict'
+
+module.exports = {
+  // Surfaced as a message's content when audio was captured but couldn't be turned into a playable
+  // part (unsupported format, or over the size budget) and there is no transcript to show instead.
+  AUDIO_FALLBACK: '[audio]',
+
+  // G.711 telephony audio is always 8 kHz mono.
+  G711_SAMPLE_RATE: 8000,
+
+  // Budget for inline audio, measured on the *base64-encoded* size, since that is what actually
+  // rides the span event. Kept below the 5 MB per-span-event limit with headroom for the rest of the
+  // event, whose whole I/O is dropped backend-side when oversize. 4 MiB encoded is ~3 MiB of audio.
+  //
+  // Per *event*, not per audio part. An event carrying audio on more than one message — a realtime
+  // turn has both the user's and the agent's — has to divide this between them, or two individually
+  // accepted clips sum past the limit and cost the event all of its I/O.
+  LLMOBS_AUDIO_INLINE_MAX_BYTES: 4 * 1024 * 1024,
+
+  // Cap on the raw audio buffered per side of a realtime turn: the point at which base64 encoding
+  // would put a 1:1 format over `LLMOBS_AUDIO_INLINE_MAX_BYTES` anyway (4 chars per 3 bytes).
+  // Beyond this the size guard would drop the audio at tag time, so we stop retaining it rather
+  // than hold megabytes in memory only to discard them. A memory bound, not a correctness one — the
+  // guard still decides.
+  //
+  // A format that expands on the way to a playable part inlines less than this: G.711 decodes to
+  // PCM16 at 2 bytes per sample, so only about half of it can ever ride the span event. Callers
+  // check the *converted* size against the budget before converting (`fitsInlineAudioBudget`), so
+  // the excess is never paid for in allocations — it is only retained and then dropped.
+  LLMOBS_AUDIO_ACCUMULATE_MAX_BYTES: 3 * 1024 * 1024,
+
+  PCM16_BYTES_PER_SAMPLE: 2,
+
+  WAV_HEADER_BYTES: 44,
+}

package/packages/dd-trace/src/llmobs/constants/prompts.js

@@ -0,0 +1,14 @@
+'use strict'
+
+module.exports = {
+  ERROR_NAMES: {
+    API: 'PromptAPIError',
+    AUTH: 'PromptAuthError',
+    CONFLICT: 'PromptConflictError',
+    NOT_FOUND: 'PromptNotFoundError',
+    SERVER: 'PromptServerError',
+    VALIDATION: 'PromptValidationError',
+  },
+  PROMPTS_PATH: '/api/unstable/llm-obs/v1/prompts',
+  SOURCE_CACHE: 'cache',
+}

package/packages/dd-trace/src/llmobs/constants/tags.js

@@ -69,6 +69,23 @@ module.exports = {
   INSTRUMENTATION_METHOD_ANNOTATED: 'annotated',
   INSTRUMENTATION_METHOD_UNKNOWN: 'unknown',
 
+  GEN_AI_OPERATION_NAME: 'gen_ai.operation.name',
+  GEN_AI_REQUEST_MODEL: 'gen_ai.request.model',
+  GEN_AI_PROVIDER_NAME: 'gen_ai.provider.name',
+  GEN_AI_APPLICATION_NAME: 'gen_ai.application.name',
+  GEN_AI_CONVERSATION_ID: 'gen_ai.conversation.id',
+
+  GEN_AI_USAGE_INPUT_TOKENS_METRIC_KEY: 'gen_ai.usage.input_tokens',
+  GEN_AI_USAGE_OUTPUT_TOKENS_METRIC_KEY: 'gen_ai.usage.output_tokens',
+  GEN_AI_USAGE_TOTAL_TOKENS_METRIC_KEY: 'gen_ai.usage.total_tokens',
+  GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS_METRIC_KEY: 'gen_ai.usage.cache_read_input_tokens',
+  GEN_AI_USAGE_CACHE_WRITE_INPUT_TOKENS_METRIC_KEY: 'gen_ai.usage.cache_write_input_tokens',
+  GEN_AI_USAGE_REASONING_OUTPUT_TOKENS_METRIC_KEY: 'gen_ai.usage.reasoning_output_tokens',
+
+  // Marks the `gen_ai.*` tags on an APM span as tracer-emitted. Without it the backend reads them
+  // as user-set and builds a duplicate LLMObs span out of the APM span.
+  ARTIFICIAL_GEN_AI_TAGS: '_dd.llmobs.artificial_gen_ai_tags',
+
   ROUTING_API_KEY: '_dd.llmobs.routing.api_key',
   ROUTING_SITE: '_dd.llmobs.routing.site',
 }

package/packages/dd-trace/src/llmobs/eval-metric.js

@@ -61,7 +61,6 @@ const TERMS = {
 
 /**
  * @param {string[]} metricTypes
- * @returns {string} the quoted list, e.g. `"categorical", "score" or "json"`
  */
 function formatMetricTypes (metricTypes) {
   const quoted = metricTypes.map(metricType => `"${metricType}"`)
@@ -99,7 +98,6 @@ function invalidTagsError (kind) {
 /**
  * @param {unknown} timestampMs
  * @param {MetricEventKind} kind
- * @returns {void}
  */
 function validateTimestamp (timestampMs, kind) {
   if (typeof timestampMs !== 'number' || timestampMs < 0) {
@@ -137,7 +135,6 @@ function validateLabel (label, kind) {
 /**
  * @param {string | undefined} metricType - Already lower-cased metric type.
  * @param {MetricEventKind} kind
- * @returns {void}
  */
 function validateMetricType (metricType, kind) {
   if (!metricType || !METRIC_TYPES[kind].includes(metricType)) {
@@ -148,7 +145,6 @@ function validateMetricType (metricType, kind) {
 /**
  * @param {string | undefined} metricType - Metric type already validated for the submitted kind.
  * @param {unknown} value
- * @returns {void}
  */
 function validateMetricValue (metricType, value) {
   if (metricType === 'categorical' && typeof value !== 'string') {
@@ -170,7 +166,6 @@ function validateMetricValue (metricType, value) {
 
 /**
  * @param {unknown} assessment
- * @returns {void}
  */
 function validateAssessment (assessment) {
   if (assessment != null && assessment !== 'pass' && assessment !== 'fail') {
@@ -180,7 +175,6 @@ function validateAssessment (assessment) {
 
 /**
  * @param {unknown} reasoning
- * @returns {void}
  */
 function validateReasoning (reasoning) {
   if (reasoning != null && typeof reasoning !== 'string') {

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) {