dd-trace 6.20.1 → 6.22.0

package/packages/datadog-instrumentations/src/mocha/webdriverio-protocol.js

@@ -1,5 +1,7 @@
 'use strict'
 
+const { clearTimeout, setTimeout } = require('node:timers')
+
 const {
   createWebdriverioWorkerMessage,
   WEBDRIVERIO_WORKER_ENV,
@@ -11,6 +13,9 @@ const { FINAL_FLUSH_TIMEOUT } = require('../../../dd-trace/src/ci-visibility/fin
 const SCREENSHOT_UPLOAD = 'dd:test-optimization:webdriverio:screenshot:upload'
 const SCREENSHOT_UPLOAD_RESPONSE = 'dd:test-optimization:webdriverio:screenshot:upload:response'
 const SCREENSHOT_UPLOAD_TIMEOUT_MS = FINAL_FLUSH_TIMEOUT + 5000
+const VIDEO_UPLOAD = 'dd:test-optimization:webdriverio:video:upload'
+const VIDEO_UPLOAD_RESPONSE = 'dd:test-optimization:webdriverio:video:upload:response'
+const VIDEO_UPLOAD_TIMEOUT_MS = 5 * FINAL_FLUSH_TIMEOUT + 5000
 
 /**
  * Sends a message over WebdriverIO's worker IPC envelope.
@@ -34,95 +39,113 @@ function sendWebdriverioWorkerMessage (message, onError, onDone) {
   })
 }
 
-let screenshotUploadRequestId = 0
-const screenshotUploadRequests = new Map()
+let mediaUploadRequestId = 0
+const mediaUploadRequests = new Map()
 
 /**
- * Removes shared screenshot response listeners when there are no pending requests.
+ * Removes shared media response listeners when there are no pending requests.
  *
  */
-function removeScreenshotUploadListeners () {
-  if (screenshotUploadRequests.size !== 0) return
+function removeMediaUploadListeners () {
+  if (mediaUploadRequests.size !== 0) return
 
-  process.off('message', onScreenshotUploadResponse)
-  process.off('disconnect', onScreenshotUploadDisconnect)
+  process.off('message', onMediaUploadResponse)
+  process.off('disconnect', onMediaUploadDisconnect)
 }
 
 /**
- * Completes one pending screenshot upload request.
+ * Completes one pending media upload request.
  *
  * @param {string} requestId
  * @param {Error} [error]
  */
-function finishScreenshotUploadRequest (requestId, error) {
-  const request = screenshotUploadRequests.get(requestId)
+function finishMediaUploadRequest (requestId, error) {
+  const request = mediaUploadRequests.get(requestId)
   if (!request) return
 
-  screenshotUploadRequests.delete(requestId)
+  mediaUploadRequests.delete(requestId)
   clearTimeout(request.timeout)
-  removeScreenshotUploadListeners()
+  removeMediaUploadListeners()
   request.onDone(error)
 }
 
 /**
- * Dispatches one coordinator screenshot response to its pending request.
+ * Dispatches one coordinator media response to its pending request.
  *
  * @param {object} message
  */
-function onScreenshotUploadResponse (message) {
-  if (message?.name !== SCREENSHOT_UPLOAD_RESPONSE) return
+function onMediaUploadResponse (message) {
+  if (message?.name !== SCREENSHOT_UPLOAD_RESPONSE && message?.name !== VIDEO_UPLOAD_RESPONSE) return
 
   const { error: errorMessage, requestId } = message.content || {}
   if (!requestId) return
 
-  finishScreenshotUploadRequest(requestId, errorMessage ? new Error(errorMessage) : undefined)
+  finishMediaUploadRequest(requestId, errorMessage ? new Error(errorMessage) : undefined)
 }
 
 /**
- * Fails every pending screenshot upload after coordinator disconnect.
+ * Fails every pending media upload after coordinator disconnect.
  *
  */
-function onScreenshotUploadDisconnect () {
-  for (const requestId of screenshotUploadRequests.keys()) {
-    finishScreenshotUploadRequest(
+function onMediaUploadDisconnect () {
+  for (const requestId of mediaUploadRequests.keys()) {
+    finishMediaUploadRequest(
       requestId,
-      new Error('WebdriverIO coordinator disconnected during screenshot upload')
+      new Error('WebdriverIO coordinator disconnected during media upload')
     )
   }
 }
 
 /**
- * Requests one screenshot upload from the WebdriverIO coordinator.
+ * Requests one media upload from the WebdriverIO coordinator.
  *
- * @param {object} content - Screenshot upload metadata
+ * @param {object} content - Upload metadata
+ * @param {'screenshot'|'video'} kind
  * @param {(error?: Error) => void} onDone - Upload completion callback
  */
-function requestWebdriverioScreenshotUpload (content, onDone) {
-  const requestId = `${process.pid}-${++screenshotUploadRequestId}`
+function requestWebdriverioMediaUpload (content, kind, onDone) {
+  const requestId = `${process.pid}-${++mediaUploadRequestId}`
   const timeout = setTimeout(() => {
-    finishScreenshotUploadRequest(requestId, new Error('WebdriverIO screenshot upload timed out'))
-  }, SCREENSHOT_UPLOAD_TIMEOUT_MS)
+    finishMediaUploadRequest(requestId, new Error(`WebdriverIO ${kind} upload timed out`))
+  }, kind === 'video' ? VIDEO_UPLOAD_TIMEOUT_MS : SCREENSHOT_UPLOAD_TIMEOUT_MS)
   timeout.unref?.()
-  if (screenshotUploadRequests.size === 0) {
-    process.on('message', onScreenshotUploadResponse)
-    process.once('disconnect', onScreenshotUploadDisconnect)
+  if (mediaUploadRequests.size === 0) {
+    process.on('message', onMediaUploadResponse)
+    process.once('disconnect', onMediaUploadDisconnect)
   }
-  screenshotUploadRequests.set(requestId, { onDone, timeout })
+  mediaUploadRequests.set(requestId, { onDone, timeout })
   sendWebdriverioWorkerMessage({
     origin: 'datadog',
-    name: SCREENSHOT_UPLOAD,
+    name: kind === 'video' ? VIDEO_UPLOAD : SCREENSHOT_UPLOAD,
     content: { ...content, requestId },
-  }, error => finishScreenshotUploadRequest(
+  }, error => finishMediaUploadRequest(
     requestId,
-    error || new Error('WebdriverIO screenshot upload IPC failed')
+    error || new Error(`WebdriverIO ${kind} upload IPC failed`)
   ))
 }
 
+/**
+ * @param {object} content
+ * @param {(error?: Error) => void} onDone
+ */
+function requestWebdriverioScreenshotUpload (content, onDone) {
+  requestWebdriverioMediaUpload(content, 'screenshot', onDone)
+}
+
+/**
+ * @param {object} content
+ * @param {(error?: Error) => void} onDone
+ */
+function requestWebdriverioVideoUpload (content, onDone) {
+  requestWebdriverioMediaUpload(content, 'video', onDone)
+}
+
 module.exports = {
   CONFIGURATION_REQUEST: 'dd:test-optimization:webdriverio:configuration:request',
   CONFIGURATION_RESPONSE: 'dd:test-optimization:webdriverio:configuration:response',
   createWebdriverioWorkerMessage,
   requestWebdriverioScreenshotUpload,
+  requestWebdriverioVideoUpload,
   SCREENSHOT_UPLOAD,
   SCREENSHOT_UPLOAD_RESPONSE,
   SCREENSHOT_UPLOAD_TIMEOUT_MS,
@@ -130,6 +153,10 @@ module.exports = {
   SUITE_FINISH: 'dd:test-optimization:webdriverio:test-suite:finish',
   WORKER_READY: 'dd:test-optimization:webdriverio:worker:ready',
   WORKER_READY_RESPONSE: 'dd:test-optimization:webdriverio:worker:ready:response',
+  VIDEO_UPLOAD_FLUSH: 'dd:test-optimization:webdriverio:video:flush',
+  VIDEO_UPLOAD,
+  VIDEO_UPLOAD_RESPONSE,
+  VIDEO_UPLOAD_TIMEOUT_MS,
   WEBDRIVERIO_WORKER_ENV,
   WEBDRIVERIO_WORKER_EVENT,
   WEBDRIVERIO_WORKER_ORIGIN,

package/packages/datadog-instrumentations/src/mocha/worker.js

@@ -416,7 +416,7 @@ function wrapMochaRun (Mocha, frameworkVersion) {
         })
       }
       filterSkippedFiles(runner, skippedFiles)
-      if (isFailedTestReplayEnabled() || config.isFlakyTestRetriesEnabled) {
+      if (isFailedTestReplayEnabled() || config.isFlakyTestRetriesEnabled || config.isTestFailureVideosEnabled) {
         patchFailedTestReplayHookUp(runner.constructor)
       }
       configurationReady = true
@@ -443,8 +443,7 @@ addHook({
   filePattern: String.raw`lib/runner\.(?:c?js)$`,
 }, function (runnerPackage) {
   const Runner = runnerPackage.Runner ?? runnerPackage.default ?? runnerPackage
-  if (typeof Runner !== 'function') return
-  if (patchedRunners.has(Runner)) return
+  if (typeof Runner !== 'function' || patchedRunners.has(Runner)) return
 
   patchedRunners.add(Runner)
   shimmer.wrap(Runner.prototype, 'runTests', runTests => getRunTestsWrapper(runTests, config))
@@ -453,7 +452,7 @@ addHook({
     if (!workerFinishCh.hasSubscribers) {
       return run.apply(this, args)
     }
-    if (isFailedTestReplayEnabled() || config.isFlakyTestRetriesEnabled) {
+    if (isFailedTestReplayEnabled() || config.isFlakyTestRetriesEnabled || config.isTestFailureVideosEnabled) {
       patchFailedTestReplayHookUp(Runner)
     }
     if (isWebdriverioWorker) {
@@ -469,7 +468,10 @@ addHook({
     const onRunDone = args[0]
     if (isWebdriverioWorker && typeof onRunDone === 'function') {
       args[0] = (...onRunDoneArgs) => {
-        finishWebdriverioWorker(this, () => onRunDone(...onRunDoneArgs))
+        const adjustedFailures = Number.isFinite(this.failures)
+          ? Math.max(0, this.failures)
+          : onRunDoneArgs[0]
+        finishWebdriverioWorker(this, () => onRunDone(adjustedFailures, ...onRunDoneArgs.slice(1)))
       }
     } else {
       // Flush after the worker finishes its Mocha run, including grouped spec files.

package/packages/datadog-instrumentations/src/mongodb-core.js

@@ -45,7 +45,7 @@ addHook({ name: 'mongodb', versions: ['>=4.6.0 <6.4.0'], file: 'lib/cmap/connect
 
 addHook({ name: 'mongodb', versions: ['>=6.4.0'], file: 'lib/cmap/connection.js' }, Connection => {
   const proto = Connection.Connection.prototype
-  shimmer.wrap(proto, 'command', command => wrapConnectionCommand(command, 'command', undefined, instrumentPromise))
+  shimmer.wrap(proto, 'command', command => wrapConnectionCommand(command, 'command', instrumentPromise))
 })
 
 addHook({ name: 'mongodb', versions: ['>=3.3 <4'], file: 'lib/core/wireprotocol/index.js' }, wp => wrapWp(wp))
@@ -95,8 +95,8 @@ function wrapUnifiedCommand (command, operation, name) {
   }
 }
 
-function wrapConnectionCommand (command, operation, name, instrumentFn = instrument) {
-  const opts = { name }
+function wrapConnectionCommand (command, operation, instrumentFn = instrument) {
+  const opts = { name: undefined }
   return function (ns, ops) {
     if (!startCh.hasSubscribers) {
       return command.apply(this, arguments)

package/packages/datadog-instrumentations/src/mongoose.js

@@ -83,7 +83,7 @@ addHook({
 
         let callbackWrapped = false
 
-        const wrapCallbackIfExist = (args, ctx) => {
+        const wrapCallbackIfExist = (args) => {
           const lastArgumentIndex = args.length - 1
 
           if (typeof args[lastArgumentIndex] === 'function') {
@@ -106,7 +106,7 @@ addHook({
         }
 
         return startCh.runStores(ctx, () => {
-          wrapCallbackIfExist(args, ctx)
+          wrapCallbackIfExist(args)
 
           // A callback query executes synchronously inside `method.apply`, so the
           // exec scope (and the deferred driver call it spawns) must be entered
@@ -121,7 +121,7 @@ addHook({
             shimmer.wrap(res, 'exec', originalExec => {
               return function wrappedExec (...args) {
                 if (!callbackWrapped) {
-                  wrapCallbackIfExist(args, ctx)
+                  wrapCallbackIfExist(args)
                 }
 
                 const execResult = execCh.runStores(ctx, () => originalExec.apply(this, args))

package/packages/datadog-instrumentations/src/nova-sonic/audio.js

@@ -0,0 +1,173 @@
+'use strict'
+
+const { LLMOBS_AUDIO_ACCUMULATE_MAX_BYTES } = require('../../../dd-trace/src/llmobs/constants/audio')
+
+// Leave room for the WAV header when the retained PCM is encoded.
+const MAX_AUDIO = LLMOBS_AUDIO_ACCUMULATE_MAX_BYTES - 128
+const RATES = new Set([8000, 16_000, 24_000, 48_000])
+const INVALID_BASE64 = /[^A-Za-z0-9+/]/
+
+/** @param {object} configuration */
+function pcmRate (configuration = {}) {
+  return configuration.mediaType === 'audio/lpcm' && configuration.sampleSizeBits === 16 &&
+    configuration.channelCount === 1 && configuration.encoding === 'base64' &&
+    RATES.has(configuration.sampleRateHertz)
+    ? configuration.sampleRateHertz
+    : 0
+}
+
+/** @param {string} encoded */
+function decodedLength (encoded) {
+  if (typeof encoded !== 'string' || encoded.length % 4) return
+  const padding = encoded.endsWith('==') ? 2 : encoded.endsWith('=') ? 1 : 0
+  if (INVALID_BASE64.test(encoded.slice(0, encoded.length - padding))) return
+  return encoded.length / 4 * 3 - padding
+}
+
+/** A bounded, connection-wide sample timeline. Content-name changes do not reset its origin. */
+class InputAudio {
+  rate = 0
+  valid = true
+  total = 0
+  anchor
+  #chunks = []
+  #bytes = 0
+
+  /** @param {object} configuration */
+  configure (configuration) {
+    const rate = pcmRate(configuration)
+    if (!rate || (this.total && rate !== this.rate)) this.valid = false
+    this.rate = rate
+  }
+
+  /**
+   * @param {string} encoded
+   * @param {number} now Milliseconds at SDK consumption, not an acknowledgement from the provider.
+   */
+  append (encoded, now) {
+    const length = decodedLength(encoded)
+    if (length === undefined) {
+      this.valid = false
+      this.clear()
+      return
+    }
+    if (length % 2) this.valid = false
+    this.total += length
+    if (this.rate) this.anchor = now - this.total * 1000 / (2 * this.rate)
+    if (!this.valid || !length) return
+    // Decode from a base64 quartet boundary, retaining at most two alignment bytes
+    // beyond the cap instead of allocating the entire incoming frame.
+    const start = Math.max(0, length - MAX_AUDIO)
+    const retained = Buffer.from(encoded.slice(Math.floor(start / 3) * 4), 'base64').subarray(start % 3)
+    this.#chunks.push(retained)
+    this.#bytes += retained.length
+    while (this.#bytes > MAX_AUDIO) {
+      const first = this.#chunks[0]
+      const excess = this.#bytes - MAX_AUDIO
+      if (first.length <= excess) {
+        this.#chunks.shift()
+        this.#bytes -= first.length
+      } else {
+        this.#chunks[0] = Buffer.from(first.subarray(excess))
+        this.#bytes -= excess
+      }
+    }
+  }
+
+  /**
+   * @param {number} startMs
+   * @param {number} endMs
+   */
+  clip (startMs, endMs) {
+    if (!this.valid || !this.rate || !Number.isFinite(startMs) || !Number.isFinite(endMs) || startMs >= endMs) return
+    const start = Math.floor(startMs * this.rate / 1000) * 2
+    const end = Math.floor(endMs * this.rate / 1000) * 2
+    const base = this.total - this.#bytes
+    if (start < base || end > this.total) return
+    const clip = Buffer.allocUnsafe(end - start)
+    let offset = base
+    let written = 0
+    for (const chunk of this.#chunks) {
+      const chunkEnd = offset + chunk.length
+      if (chunkEnd > start) {
+        written += chunk.copy(clip, written, Math.max(start - offset, 0), Math.min(end - offset, chunk.length))
+      }
+      offset = chunkEnd
+      if (offset >= end) break
+    }
+    return clip
+  }
+
+  clear () {
+    this.#chunks = []
+    this.#bytes = 0
+  }
+}
+
+/** Ordered PCM playback projection for one response, including genuine underrun silence. */
+class OutputAudio {
+  rate = 0
+  start
+  end
+  interrupted
+  generatedBytes = 0
+  timingValid = true
+  omittedReason
+  #chunks = []
+  #bytes = 0
+
+  /**
+   * @param {string} encoded
+   * @param {object} configuration
+   * @param {number} now
+   */
+  append (encoded, configuration, now) {
+    const length = decodedLength(encoded)
+    if (length !== undefined) this.generatedBytes += length
+    // Late chunks cannot resurrect playback or invalidate the clip already cut at interruption.
+    if (this.interrupted !== undefined) return
+    const rate = pcmRate(configuration)
+    if (length === undefined || !rate || length % 2 || (this.rate && this.rate !== rate)) {
+      this.timingValid = false
+      this.omittedReason = 'invalid_audio'
+      this.#chunks = []
+      this.#bytes = 0
+      return
+    }
+    if (!length) return
+    this.rate ||= rate
+    this.start ??= now
+    const previousEnd = this.end ?? now
+    const gap = Math.floor(Math.max(0, now - previousEnd) * rate / 1000) * 2
+    this.end = previousEnd + (gap + length) * 1000 / (2 * rate)
+    if (!this.omittedReason && this.#bytes + gap + length <= MAX_AUDIO) {
+      if (gap) this.#chunks.push(Buffer.alloc(gap))
+      this.#chunks.push(Buffer.from(encoded, 'base64'))
+      this.#bytes += gap + length
+    } else {
+      this.omittedReason ||= 'retention_limit'
+      this.#chunks = []
+      this.#bytes = 0
+    }
+  }
+
+  /** @param {number} now */
+  interrupt (now) {
+    if (this.interrupted !== undefined) return
+    this.interrupted = now
+    if (this.start === undefined || this.end === undefined || !this.rate) return
+    const frames = Math.floor(Math.max(0, now - this.start) * this.rate / 1000)
+    this.end = Math.min(this.end, this.start + frames * 1000 / this.rate)
+    if (this.#bytes > frames * 2) {
+      const clip = Buffer.concat(this.#chunks, this.#bytes).subarray(0, frames * 2)
+      this.#chunks = [Buffer.from(clip)]
+      this.#bytes = clip.length
+    }
+  }
+
+  pcm () {
+    if (!this.omittedReason && this.#bytes) return Buffer.concat(this.#chunks, this.#bytes)
+  }
+}
+
+module.exports = { InputAudio, OutputAudio }

package/packages/datadog-instrumentations/src/nova-sonic/index.js

@@ -0,0 +1,209 @@
+'use strict'
+
+const dc = require('dc-polyfill')
+
+const log = require('../../../dd-trace/src/log')
+const { storage } = require('../../../datadog-core')
+const SonicSession = require('./session')
+
+const captureChannel = dc.channel('dd-trace:aws:bedrockruntime:sonic:capture-context')
+const spanChannel = dc.tracingChannel('apm:aws:bedrockruntime:sonic:span')
+const MODEL = 'amazon.nova-2-sonic-v1:0'
+const FOUNDATION_MODEL_ARN = /^arn:aws(?:-[a-z0-9]+)*:bedrock:[a-z0-9-]{1,20}::foundation-model\/([^/]+)$/
+const sessionStorage = storage('nova-sonic')
+const instrumentedClients = new WeakSet()
+
+function noop () {}
+
+/** @param {unknown} identifier */
+function resolveModel (identifier) {
+  if (identifier === MODEL) return identifier
+  if (typeof identifier !== 'string' || identifier.length > 2048) return
+  // Only foundation-model ARNs directly identify a model. Profile IDs need a service lookup,
+  // and the bidirectional API currently rejects them. Never infer a model from an ARN suffix.
+  const model = FOUNDATION_MODEL_ARN.exec(identifier)?.[1]
+  if (model === MODEL) return model
+}
+
+/**
+ * @param {object} descriptor
+ * @param {(fn: () => void) => void} runInContext
+ * @param {string} model
+ */
+function emitTurn (descriptor, runInContext, model) {
+  const { turn } = descriptor
+  const common = { descriptor, model }
+  runInContext(() => {
+    spanChannel.traceSync(() => {
+      if (turn.inputStart !== undefined && turn.inputEnd !== undefined && turn.inputEnd >= turn.inputStart) {
+        spanChannel.traceSync(noop, {
+          ...common, name: 'user speech', kind: 'workflow', startTime: turn.inputStart, finishTime: turn.inputEnd,
+        })
+      }
+      spanChannel.traceSync(noop, {
+        ...common,
+        name: 'nova sonic response',
+        kind: 'llm',
+        startTime: descriptor.llmStart,
+        finishTime: descriptor.responseEnd,
+      })
+      const output = turn.output
+      if (output.timingValid && output.start !== undefined && output.end > output.start) {
+        spanChannel.traceSync(noop, {
+          ...common, name: 'agent speech', kind: 'workflow', startTime: output.start, finishTime: output.end,
+        })
+      }
+    }, {
+      ...common,
+      name: 'nova sonic audio turn',
+      kind: 'workflow',
+      startTime: descriptor.startTime,
+      finishTime: descriptor.finishTime,
+    })
+  })
+}
+
+/**
+ * These iterators are application/factory-created objects with no matchable source function.
+ * Wrap the concrete iterator, preserving next/return/throw and the SDK's own backpressure/cleanup.
+ * No producer is started here; each next delegates exactly once to the original iterator.
+ * @param {object} source SDK async iterable.
+ * @param {SonicSession} session
+ * @param {boolean} outbound
+ * @param {(error?: Error) => void} finish
+ */
+function observeIterable (source, session, outbound, finish) {
+  if (typeof source?.[Symbol.asyncIterator] !== 'function') return source
+  const rejected = error => {
+    finish(error)
+    throw error
+  }
+  return {
+    [Symbol.asyncIterator] () {
+      let iterator
+      try {
+        iterator = source[Symbol.asyncIterator]()
+      } catch (error) {
+        finish(error)
+        throw error
+      }
+      const observed = { [Symbol.asyncIterator] () { return this } }
+      for (const method of ['next', 'return', 'throw']) {
+        if (typeof iterator[method] !== 'function') continue
+        const fulfilled = result => {
+          if (result.done || method === 'return') {
+            if (!outbound) finish()
+          } else {
+            session.observe(result.value, outbound)
+          }
+          return result
+        }
+        observed[method] = function (...args) {
+          try {
+            const result = iterator[method](...args)
+            return typeof result?.then === 'function' ? result.then(fulfilled, rejected) : fulfilled(result)
+          } catch (error) {
+            return rejected(error)
+          }
+        }
+      }
+      return observed
+    },
+  }
+}
+
+/** @param {object} client */
+function instrumentInput (client) {
+  if (instrumentedClients.has(client)) return true
+  try {
+    // Install before even an uncaptured send can cache the SDK handler. Cached handlers must
+    // look up the invocation's session at execution time, not retain the first session.
+    client.middlewareStack.add((next, context) => args => {
+      const capture = sessionStorage.getStore()
+      if (capture?.client !== client || context.commandName !== 'InvokeModelWithBidirectionalStreamCommand') {
+        return next(args)
+      }
+      const { session, finish } = capture
+      const input = { ...args.input, body: observeIterable(args.input.body, session, true, finish) }
+      // Smithy passes the shared Command as args. Copy it before asynchronous middleware can
+      // read input, so overlapping sends never modify the command or observe another session.
+      return next({ ...args, input })
+    }, { name: 'datadogSonicInput', step: 'initialize', priority: 'high' })
+    instrumentedClients.add(client)
+    return true
+  } catch {
+    log.debug('Cannot observe Nova Sonic input')
+    return false
+  }
+}
+
+/**
+ * Called from the existing Smithy send seam. The bidi operation bypasses the ordinary AWS response
+ * accumulator: retaining every chunk there would retain a whole conversation twice.
+ * @param {Function} send
+ * @param {object} client
+ * @param {object} command
+ * @param {Array<object | Function>} args
+ */
+function sendSonic (send, client, command, args) {
+  const instrumented = instrumentInput(client)
+  const passthrough = () => sessionStorage.run(undefined, () => send.call(client, command, ...args))
+  if (!instrumented || !captureChannel.hasSubscribers) return passthrough()
+  const model = resolveModel(command.input?.modelId)
+  if (!model) return passthrough()
+  const context = {}
+  captureChannel.publish(context)
+  // Only the LLMObs plugin enables capture; the tracing plugin alone does not buffer conversations.
+  if (!context.enabled || !context.runInContext) return passthrough()
+  const session = new SonicSession(descriptor => emitTurn(descriptor, context.runInContext, model))
+  const signal = args[0] !== null && typeof args[0] === 'object' ? args[0]?.abortSignal : undefined
+  // Smithy's legacy AbortSignal only exposes onabort; leave that slot to the SDK's transport.
+  const hasListeners = typeof signal?.addEventListener === 'function' &&
+    typeof signal?.removeEventListener === 'function'
+  const finish = error => {
+    if (hasListeners) signal.removeEventListener('abort', onAbort)
+    // Aborting an already delivered HTTP/2 response can surface as clean iterator EOF.
+    if (!error && signal?.aborted) {
+      error = new Error('Nova Sonic request aborted')
+      error.name = 'AbortError'
+    }
+    session.finish(error)
+  }
+  const onAbort = () => finish()
+  if (signal?.aborted) onAbort()
+  else if (hasListeners) signal.addEventListener('abort', onAbort, { once: true })
+
+  const completed = result => {
+    try {
+      if (typeof result?.body?.[Symbol.asyncIterator] === 'function') {
+        result.body = observeIterable(result.body, session, false, finish)
+      } else {
+        finish()
+      }
+    } catch {
+      finish()
+      log.debug('Cannot observe Nova Sonic output')
+    }
+    return result
+  }
+  const failed = error => {
+    finish(error)
+    throw error
+  }
+  const callback = args.at(-1)
+  if (typeof callback === 'function') {
+    args[args.length - 1] = function (error, result) {
+      if (error) finish(error)
+      else completed(result)
+      return callback.apply(this, arguments)
+    }
+  }
+  try {
+    const result = sessionStorage.run({ client, session, finish }, () => send.call(client, command, ...args))
+    return typeof callback === 'function' ? result : result.then(completed, failed)
+  } catch (error) {
+    return failed(error)
+  }
+}
+
+module.exports = sendSonic