dd-trace 6.6.0 → 6.8.0

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

@@ -2,6 +2,8 @@
 
 const { addHook, channel } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
+const { getEnvironmentVariable } = require('../../../dd-trace/src/config/helper')
+const log = require('../../../dd-trace/src/log')
 const { DD_MAJOR } = require('../../../../version')
 
 const {
@@ -14,14 +16,351 @@ const {
   getOnTestRetryHandler,
   getRunTestsWrapper,
   patchFailedTestReplayHookUp,
+  adjustRunnerFailuresForTestOptimization,
+  efdTests,
+  getTestFullName,
 } = require('./utils')
+const {
+  CONFIGURATION_REQUEST,
+  CONFIGURATION_RESPONSE,
+  createWebdriverioWorkerMessage,
+  SUITE_FINISH,
+  WEBDRIVERIO_WORKER_ENV,
+  WORKER_READY,
+} = require('./webdriverio-protocol')
 require('./common')
 
 const MINIMUM_MOCHA_VERSION = DD_MAJOR >= 6 ? '>=8.0.0' : '>=5.2.0'
 
 const workerFinishCh = channel('ci:mocha:worker:finish')
+const workerConfigurationCh = channel('ci:mocha:worker:configuration')
 
 const config = {}
+const runnerToFiles = new WeakMap()
+const runnerToFailedHooks = new WeakMap()
+const isWebdriverioWorker = !!getEnvironmentVariable(WEBDRIVERIO_WORKER_ENV)
+let configurationRequestId = 0
+
+/**
+ * Sends a message to the WebdriverIO launcher without surfacing closed IPC channels.
+ *
+ * @param {object} message
+ * @param {() => void} [onError]
+ * @param {() => void} [onDone]
+ * @returns {void}
+ */
+function sendWebdriverioMessage (message, onError, onDone) {
+  if (!process.send || !process.connected) {
+    onError?.()
+    onDone?.()
+    return
+  }
+
+  process.send(createWebdriverioWorkerMessage(message), (error) => {
+    if (error) {
+      log.error('WebdriverIO Test Optimization IPC error', error)
+      onError?.()
+    }
+    onDone?.()
+  })
+}
+
+/**
+ * Applies configuration encoded as private Mocha options by its parallel runner.
+ *
+ * @param {object} options
+ * @returns {void}
+ */
+function applyMochaOptions (options) {
+  if (options._ddIsKnownTestsEnabled) {
+    config.isKnownTestsEnabled = true
+    config.isEarlyFlakeDetectionEnabled = options._ddIsEfdEnabled
+    config.knownTests = options._ddKnownTests
+    config.earlyFlakeDetectionNumRetries = options._ddEfdNumRetries
+    config.earlyFlakeDetectionSlowTestRetries = options._ddEfdSlowTestRetries ?? {}
+    delete options._ddIsEfdEnabled
+    delete options._ddKnownTests
+    delete options._ddEfdNumRetries
+    delete options._ddEfdSlowTestRetries
+    delete options._ddIsKnownTestsEnabled
+  }
+  if (options._ddIsImpactedTestsEnabled) {
+    config.isImpactedTestsEnabled = true
+    config.modifiedFiles = options._ddModifiedFiles
+    delete options._ddIsImpactedTestsEnabled
+    delete options._ddModifiedFiles
+  }
+  if (options._ddIsTestManagementTestsEnabled) {
+    config.isTestManagementTestsEnabled = true
+    config.testManagementAttemptToFixRetries = options._ddTestManagementAttemptToFixRetries
+    config.testManagementTests = options._ddTestManagementTests
+    delete options._ddIsTestManagementTestsEnabled
+    delete options._ddTestManagementAttemptToFixRetries
+    delete options._ddTestManagementTests
+  }
+  if (options._ddIsFlakyTestRetriesEnabled) {
+    config.isFlakyTestRetriesEnabled = true
+    config.flakyTestRetriesCount = options._ddFlakyTestRetriesCount
+    delete options._ddIsFlakyTestRetriesEnabled
+    delete options._ddFlakyTestRetriesCount
+  }
+  if (options._ddIsFailedTestReplayEnabled) {
+    config.isTestDynamicInstrumentationEnabled = true
+    config.isDiEnabled = true
+    delete options._ddIsFailedTestReplayEnabled
+  }
+}
+
+/**
+ * Removes files selected for suite-level skipping from an already loaded Mocha root suite.
+ *
+ * @param {object} runner
+ * @param {string[]} skippedFiles
+ * @returns {void}
+ */
+function filterSkippedFiles (runner, skippedFiles) {
+  if (!skippedFiles.length) {
+    return
+  }
+
+  const skippedFilesSet = new Set(skippedFiles)
+  runner.suite.suites = runner.suite.suites.filter(suite => !skippedFilesSet.has(suite.file))
+  runner.suite.tests = runner.suite.tests.filter(test => !skippedFilesSet.has(test.file))
+}
+
+/**
+ * Requests configuration from the WebdriverIO launcher before releasing Mocha's delayed root suite.
+ *
+ * @param {string} frameworkVersion
+ * @param {string[]} files
+ * @param {(response: object) => void} onDone
+ * @returns {void}
+ */
+function requestWebdriverioConfiguration (frameworkVersion, files, onDone) {
+  const requestId = `${process.pid}-${++configurationRequestId}`
+  let finished = false
+
+  /**
+   * Finishes the configuration request exactly once.
+   *
+   * @param {object} response
+   * @returns {void}
+   */
+  function finish (response) {
+    if (finished) {
+      return
+    }
+    finished = true
+    clearTimeout(timeout)
+    process.off('message', onMessage)
+    process.off('disconnect', onDisconnect)
+    onDone(response)
+  }
+
+  /**
+   * Receives the matching coordinator response.
+   *
+   * @param {object} message
+   * @returns {void}
+   */
+  function onMessage (message) {
+    if (message?.name === CONFIGURATION_RESPONSE && message.content?.requestId === requestId) {
+      finish(message.content)
+    }
+  }
+
+  /**
+   * Releases the runner if its parent disconnects.
+   *
+   * @returns {void}
+   */
+  function onDisconnect () {
+    finish({})
+  }
+
+  const timeout = setTimeout(() => finish({}), 30_000)
+  process.on('message', onMessage)
+  process.once('disconnect', onDisconnect)
+  sendWebdriverioMessage({
+    origin: 'datadog',
+    name: CONFIGURATION_REQUEST,
+    content: {
+      files,
+      frameworkVersion,
+      requestId,
+    },
+  }, () => finish({}))
+}
+
+/**
+ * Reports the Mocha version as soon as WebdriverIO loads its framework adapter.
+ *
+ * @param {string} frameworkVersion
+ * @returns {void}
+ */
+function reportWebdriverioWorkerReady (frameworkVersion) {
+  if (!isWebdriverioWorker) {
+    return
+  }
+
+  sendWebdriverioMessage({
+    origin: 'datadog',
+    name: WORKER_READY,
+    content: { frameworkVersion },
+  })
+}
+
+/**
+ * Checks whether Test Optimization converts a failed WebdriverIO test attempt to a passing result.
+ *
+ * @param {object|undefined} test
+ * @returns {boolean}
+ */
+function isWebdriverioFailureSuppressed (test) {
+  if (!test) {
+    return false
+  }
+  const hasPassingEfdAttempt = config.isEarlyFlakeDetectionEnabled &&
+    efdTests[getTestFullName(test)]?.some(attempt => attempt.state === 'passed' && !attempt._ddHookFailed)
+  return (test._ddIsQuarantined && !test._ddIsAttemptToFix) || hasPassingEfdAttempt
+}
+
+/**
+ * Gets the test owned by a per-test hook without associating suite hooks with boundary tests.
+ *
+ * @param {object} hook
+ * @returns {object|undefined}
+ */
+function getWebdriverioHookTest (hook) {
+  const { parent } = hook
+  const isTestHook = parent?._beforeEach?.includes(hook) || parent?._afterEach?.includes(hook)
+  return isTestHook ? hook.ctx?.currentTest : undefined
+}
+
+/**
+ * Removes managed hook failures from WebdriverIO's Mocha runner totals.
+ *
+ * @param {object} runner
+ * @returns {void}
+ */
+function adjustWebdriverioHookFailures (runner) {
+  let suppressedFailures = 0
+  for (const { test } of runnerToFailedHooks.get(runner) || []) {
+    if (isWebdriverioFailureSuppressed(test)) {
+      suppressedFailures++
+    }
+  }
+  if (runner.stats) {
+    runner.stats.failures -= suppressedFailures
+  }
+  runner.failures -= suppressedFailures
+}
+
+/**
+ * Computes a final result for every file loaded into one Mocha worker.
+ *
+ * @param {object} runner
+ * @returns {object[]}
+ */
+function getWebdriverioSuiteResults (runner) {
+  const resultsByFile = new Map()
+  const files = runnerToFiles.get(runner) || []
+
+  for (const file of files) {
+    resultsByFile.set(file, {
+      file,
+      hasPassingTest: false,
+      status: 'skip',
+    })
+  }
+
+  runner.suite.eachTest(test => {
+    const result = resultsByFile.get(test.file)
+    if (!result) {
+      return
+    }
+    const isSuppressedFailure = isWebdriverioFailureSuppressed(test)
+    if ((test.state === 'failed' || test.timedOut || test._ddHookFailed) && !isSuppressedFailure) {
+      result.status = 'fail'
+    } else if (test.state === 'passed' || isSuppressedFailure) {
+      result.hasPassingTest = true
+    }
+  })
+
+  for (const { file, test } of runnerToFailedHooks.get(runner) || []) {
+    const result = resultsByFile.get(file)
+    if (result && !isWebdriverioFailureSuppressed(test)) {
+      result.status = 'fail'
+    }
+  }
+
+  const results = []
+  let hasFailedSuite = false
+  for (const result of resultsByFile.values()) {
+    if (result.status === 'fail') {
+      hasFailedSuite = true
+    } else if (result.hasPassingTest) {
+      result.status = 'pass'
+    }
+    delete result.hasPassingTest
+    results.push(result)
+  }
+
+  if (runner.failures > 0 && !hasFailedSuite) {
+    for (const result of results) {
+      result.status = 'fail'
+    }
+  }
+
+  return results
+}
+
+/**
+ * Sends suite results to the WebdriverIO launcher.
+ *
+ * @param {object} runner
+ * @param {() => void} [onDone]
+ * @returns {void}
+ */
+function reportWebdriverioSuiteResults (runner, onDone) {
+  if (!isWebdriverioWorker) {
+    onDone?.()
+    return
+  }
+
+  sendWebdriverioMessage({
+    origin: 'datadog',
+    name: SUITE_FINISH,
+    content: {
+      results: getWebdriverioSuiteResults(runner),
+    },
+  }, undefined, onDone)
+}
+
+/**
+ * Flushes worker payloads before reporting suite results and completing Mocha.
+ *
+ * @param {object} runner
+ * @param {() => void} onDone
+ * @returns {void}
+ */
+function finishWebdriverioWorker (runner, onDone) {
+  try {
+    workerFinishCh.publish({
+      onDone: () => {
+        try {
+          reportWebdriverioSuiteResults(runner, onDone)
+        } catch (error) {
+          log.error('WebdriverIO Test Optimization worker completion error', error)
+          onDone()
+        }
+      },
+    })
+  } catch (error) {
+    log.error('WebdriverIO Test Optimization worker completion error', error)
+    onDone()
+  }
+}
 
 function isFailedTestReplayEnabled () {
   return config.isTestDynamicInstrumentationEnabled && config.isDiEnabled
@@ -31,46 +370,77 @@ addHook({
   name: 'mocha',
   versions: ['>=8.0.0'],
   file: 'lib/mocha.js',
-}, (Mocha) => {
+}, (Mocha, frameworkVersion) => {
+  reportWebdriverioWorkerReady(frameworkVersion)
+
   shimmer.wrap(Mocha.prototype, 'run', run => function (...args) {
-    if (this.options._ddIsKnownTestsEnabled) {
-      config.isKnownTestsEnabled = true
-      config.isEarlyFlakeDetectionEnabled = this.options._ddIsEfdEnabled
-      config.knownTests = this.options._ddKnownTests
-      config.earlyFlakeDetectionNumRetries = this.options._ddEfdNumRetries
-      config.earlyFlakeDetectionSlowTestRetries = this.options._ddEfdSlowTestRetries ?? {}
-      delete this.options._ddIsEfdEnabled
-      delete this.options._ddKnownTests
-      delete this.options._ddEfdNumRetries
-      delete this.options._ddEfdSlowTestRetries
-      delete this.options._ddIsKnownTestsEnabled
-    }
-    if (this.options._ddIsImpactedTestsEnabled) {
-      config.isImpactedTestsEnabled = true
-      config.modifiedFiles = this.options._ddModifiedFiles
-      delete this.options._ddIsImpactedTestsEnabled
-      delete this.options._ddModifiedFiles
-    }
-    if (this.options._ddIsTestManagementTestsEnabled) {
-      config.isTestManagementTestsEnabled = true
-      config.testManagementAttemptToFixRetries = this.options._ddTestManagementAttemptToFixRetries
-      config.testManagementTests = this.options._ddTestManagementTests
-      delete this.options._ddIsTestManagementTestsEnabled
-      delete this.options._ddTestManagementAttemptToFixRetries
-      delete this.options._ddTestManagementTests
-    }
-    if (this.options._ddIsFlakyTestRetriesEnabled) {
-      config.isFlakyTestRetriesEnabled = true
-      config.flakyTestRetriesCount = this.options._ddFlakyTestRetriesCount
-      delete this.options._ddIsFlakyTestRetriesEnabled
-      delete this.options._ddFlakyTestRetriesCount
-    }
-    if (this.options._ddIsFailedTestReplayEnabled) {
-      config.isTestDynamicInstrumentationEnabled = true
-      config.isDiEnabled = true
-      delete this.options._ddIsFailedTestReplayEnabled
+    applyMochaOptions(this.options)
+    if (!isWebdriverioWorker || !workerFinishCh.hasSubscribers) {
+      return run.apply(this, args)
     }
-    return run.apply(this, args)
+
+    const isUserDelayed = this.options.delay
+    const rootSuite = this.suite
+    const rootSuiteRun = rootSuite.run
+    const hasOwnRootSuiteRun = Object.hasOwn(rootSuite, 'run')
+    let configurationReady = false
+    let userReady = !isUserDelayed
+
+    /**
+     * Restores the root suite method after both delayed-mode gates are open.
+     *
+     * @returns {void}
+     */
+    function restoreRootSuiteRun () {
+      if (hasOwnRootSuiteRun) {
+        rootSuite.run = rootSuiteRun
+      } else {
+        delete rootSuite.run
+      }
+    }
+
+    if (isUserDelayed) {
+      rootSuite.run = function (...args) {
+        userReady = true
+        if (!configurationReady) {
+          return
+        }
+        restoreRootSuiteRun()
+        return rootSuiteRun.apply(this, args)
+      }
+    }
+
+    this.options.delay = true
+    const files = [...this.files]
+    const runner = run.apply(this, args)
+    runnerToFiles.set(runner, files)
+
+    requestWebdriverioConfiguration(frameworkVersion, files, ({
+      configuration,
+      skippedFiles = [],
+    }) => {
+      if (configuration) {
+        Object.assign(config, configuration)
+        workerConfigurationCh.publish({
+          libraryConfig: config,
+          repositoryRoot: config.repositoryRoot,
+          testFramework: config.testFramework,
+        })
+      }
+      filterSkippedFiles(runner, skippedFiles)
+      if (isFailedTestReplayEnabled()) {
+        patchFailedTestReplayHookUp(runner.constructor)
+      }
+      configurationReady = true
+      if (userReady) {
+        if (isUserDelayed) {
+          restoreRootSuiteRun()
+        }
+        rootSuite.run()
+      }
+    })
+
+    return runner
   })
 
   return Mocha
@@ -91,10 +461,32 @@ addHook({
     if (isFailedTestReplayEnabled()) {
       patchFailedTestReplayHookUp(Runner)
     }
-    // We flush when the worker ends with its test file (a mocha instance in a worker runs a single test file)
-    this.once('end', () => {
-      workerFinishCh.publish()
-    })
+    if (isWebdriverioWorker) {
+      this.prependOnceListener('end', () => {
+        try {
+          adjustRunnerFailuresForTestOptimization(this, config)
+          adjustWebdriverioHookFailures(this)
+        } catch (error) {
+          log.error('WebdriverIO Test Optimization failure adjustment error', error)
+        }
+      })
+    }
+    const onRunDone = args[0]
+    if (isWebdriverioWorker && typeof onRunDone === 'function') {
+      args[0] = (...onRunDoneArgs) => {
+        finishWebdriverioWorker(this, () => onRunDone(...onRunDoneArgs))
+      }
+    } else {
+      // Flush after the worker finishes its Mocha run, including grouped spec files.
+      this.once('end', () => {
+        try {
+          workerFinishCh.publish()
+          reportWebdriverioSuiteResults(this)
+        } catch (error) {
+          log.error('WebdriverIO Test Optimization worker completion error', error)
+        }
+      })
+    }
     this.on('test', getOnTestHandler(false))
 
     this.on('test end', getOnTestEndHandler(config))
@@ -104,6 +496,18 @@ addHook({
     // If the hook passes, 'hook end' will be emitted. Otherwise, 'fail' will be emitted
     this.on('hook end', getOnHookEndHandler(config))
 
+    if (isWebdriverioWorker) {
+      const failedHooks = []
+      runnerToFailedHooks.set(this, failedHooks)
+      this.on('fail', runnable => {
+        if (runnable.type === 'hook' && runnable.file) {
+          failedHooks.push({
+            file: runnable.file,
+            test: getWebdriverioHookTest(runnable),
+          })
+        }
+      })
+    }
     this.on('fail', getOnFailHandler(false, config))
 
     this.on('pending', getOnPendingHandler())

package/packages/datadog-instrumentations/src/moleculer/client.js

@@ -10,7 +10,7 @@ const errorChannel = channel('apm:moleculer:call:error')
 function wrapCall (call) {
   return function (actionName, params, opts) {
     opts = arguments[2] = opts || {}
-    opts.meta = opts.meta || {}
+    opts.meta ||= {}
 
     arguments.length = Math.max(3, arguments.length)
 

package/packages/datadog-instrumentations/src/openai-agents.js

@@ -0,0 +1,159 @@
+'use strict'
+
+const { channel, tracingChannel } = require('dc-polyfill')
+const shimmer = require('../../datadog-shimmer')
+const { addHook, getHooks } = require('./helpers/instrument')
+
+// `WeakSet` keyed by module exports — replaces the underscored
+// `mod._datadogPatched` flag while keeping dedupe semantics. Mods are kept
+// alive by `require.cache` anyway, so this doesn't add lifetime to anything.
+const patchedMods = new WeakSet()
+const modelBaseURLs = new WeakMap()
+const chatCompletionsModelConstructorCh =
+  tracingChannel('orchestrion:@openai/agents-openai:OpenAIChatCompletionsModel_constructor')
+
+/**
+ * Capture the client base URL before the SDK stores the client in a #private field.
+ *
+ * @param {{ arguments?: [{ baseURL?: string }], self?: object }} ctx
+ */
+function captureChatCompletionsModelBaseURL (ctx) {
+  const baseURL = ctx.arguments?.[0]?.baseURL
+  if (ctx.self && typeof baseURL === 'string') modelBaseURLs.set(ctx.self, baseURL)
+}
+
+chatCompletionsModelConstructorCh.end.subscribe(captureChatCompletionsModelBaseURL)
+
+for (const hook of getHooks('@openai/agents-openai')) {
+  addHook(hook, moduleExports => moduleExports)
+}
+
+// Plugin subscribes to this and registers its TracingProcessor when
+// `@openai/agents` loads. Publishing from here keeps this file free of
+// any cross-package import from the plugin.
+const agentsCoreLoadedCh = channel('apm:openai-agents:agents-core:loaded')
+
+// Plugin uses addBind on this channel so that legacyStorage.run(store, fn) wraps
+// the model call — including async iterator advancement for streaming responses.
+// This ensures the active dd-trace span is visible to the openai plugin when it
+// creates its openai.request span, correctly parenting it under the agent span.
+const modelStartCh = channel('apm:openai-agents:model:start')
+
+// Tool.invoke runs inside agents-core's public function-span context. Bind the
+// corresponding dd-trace tool span around that public invocation boundary so
+// spans created by user tool code inherit it.
+const toolStartCh = channel('apm:openai-agents:tool:start')
+
+// Reference to the loaded @openai/agents module, captured in the first hook
+// so that wrapResponseMethod can call getCurrentSpan() without an additional
+// require (and without triggering n/no-missing-require on agents-core internals).
+let agentsMod
+
+// @openai/agents >=0.8.0 moved addTraceProcessor / getCurrentSpan out of the
+// top-level re-exports.  The new public surface uses getGlobalTraceProvider():
+//   provider.registerProcessor(processor)  (replaces addTraceProcessor)
+//   provider.getCurrentSpan()              (replaces getCurrentSpan)
+// Both APIs are tried so this file works across the full supported version range.
+// The plugin subscriber (index.js) handles processor registration via the channel.
+function getCurrentSpan () {
+  if (typeof agentsMod?.getCurrentSpan === 'function') {
+    return agentsMod.getCurrentSpan()
+  }
+  if (typeof agentsMod?.getGlobalTraceProvider === 'function') {
+    return agentsMod.getGlobalTraceProvider().getCurrentSpan()
+  }
+}
+
+function getCurrentSpanId () {
+  return getCurrentSpan()?.spanId
+}
+
+addHook({ name: '@openai/agents', versions: ['>=0.7.0'] }, (mod) => {
+  if (patchedMods.has(mod)) return mod
+  if (typeof mod?.addTraceProcessor !== 'function' && typeof mod?.getGlobalTraceProvider !== 'function') return mod
+  patchedMods.add(mod)
+  agentsMod = mod
+  if (typeof mod.tool === 'function') {
+    shimmer.wrap(mod, 'tool', wrapToolFactory, { replaceGetter: true })
+  }
+  agentsCoreLoadedCh.publish({ mod })
+  return mod
+})
+
+function wrapToolFactory (original) {
+  return function (...args) {
+    const tool = original.apply(this, args)
+    if (typeof tool?.invoke === 'function') {
+      shimmer.wrap(tool, 'invoke', wrapToolInvoke)
+    }
+    return tool
+  }
+}
+
+function wrapToolInvoke (original) {
+  return function (...args) {
+    const agentsCoreSpan = getCurrentSpan()
+    return toolStartCh.runStores({ agentsCoreSpan }, () => original.apply(this, args))
+  }
+}
+
+function wrapResponseMethod (original) {
+  return function (...args) {
+    const agentsCoreSpanId = getCurrentSpanId()
+    const baseURL = getClientBaseURL(this)
+    return modelStartCh.runStores({ agentsCoreSpanId, baseURL }, () => original.apply(this, args))
+  }
+}
+
+function wrapStreamedResponseMethod (original) {
+  return function (...args) {
+    const agentsCoreSpanId = getCurrentSpanId()
+    const baseURL = getClientBaseURL(this)
+    const context = { agentsCoreSpanId, baseURL }
+    const iterator = modelStartCh.runStores(context, () => original.apply(this, args))
+    return wrapAsyncIterator(iterator, context)
+  }
+}
+
+function getClientBaseURL (model) {
+  return model?.client?.baseURL ?? model?._client?.baseURL ?? modelBaseURLs.get(model)
+}
+
+function wrapAsyncIterator (iterator, context) {
+  if (!iterator || typeof iterator !== 'object') return iterator
+
+  return {
+    next () {
+      return modelStartCh.runStores(context, () => iterator.next.apply(iterator, arguments))
+    },
+    throw () {
+      if (typeof iterator.throw !== 'function') return Promise.reject(arguments[0])
+      return modelStartCh.runStores(context, () => iterator.throw.apply(iterator, arguments))
+    },
+    return () {
+      if (typeof iterator.return !== 'function') return Promise.resolve({ done: true, value: arguments[0] })
+      return modelStartCh.runStores(context, () => iterator.return.apply(iterator, arguments))
+    },
+    [Symbol.asyncIterator] () {
+      return this
+    },
+  }
+}
+
+addHook({ name: '@openai/agents-openai', versions: ['>=0.7.0'] }, (mod) => {
+  if (patchedMods.has(mod)) return mod
+  const responseProto = mod?.OpenAIResponsesModel?.prototype
+  const chatCompletionsProto = mod?.OpenAIChatCompletionsModel?.prototype
+  if (!responseProto && !chatCompletionsProto) return mod
+
+  patchedMods.add(mod)
+  for (const proto of [responseProto, chatCompletionsProto]) {
+    if (typeof proto?.getResponse === 'function') {
+      shimmer.wrap(proto, 'getResponse', wrapResponseMethod)
+    }
+    if (typeof proto?.getStreamedResponse === 'function') {
+      shimmer.wrap(proto, 'getStreamedResponse', wrapStreamedResponseMethod)
+    }
+  }
+  return mod
+})