dd-trace 6.18.0 → 6.19.0

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

@@ -4,6 +4,7 @@ const fs = require('node:fs')
 const path = require('node:path')
 const { performance } = require('node:perf_hooks')
 const { fileURLToPath } = require('node:url')
+const { deserialize } = require('node:v8')
 const { isMainThread, parentPort } = require('node:worker_threads')
 
 const { channel } = require('dc-polyfill')
@@ -47,6 +48,7 @@ const {
 
 const EFD_SUITE_ADMISSION_TIMEOUT_MS = 5000
 const logSubmissionFlushCh = channel('ci:log-submission:flush')
+const wrappedTestRunners = new WeakSet()
 const taskToCtx = new WeakMap()
 const taskToTestProperties = new WeakMap()
 const taskToStatuses = new WeakMap()
@@ -412,6 +414,14 @@ function finishEfdSuiteAdmissionRequest (requestId, allowed) {
  * @param {unknown} message
  */
 function handleEfdSuiteAdmissionResponse (message) {
+  // Older Vitest 4 forks serialize parent messages explicitly; newer forks and threads send plain values.
+  if (Buffer.isBuffer(message) || (message?.type === 'Buffer' && Array.isArray(message.data))) {
+    try {
+      message = deserialize(Buffer.from(message))
+    } catch {
+      return
+    }
+  }
   if (!Array.isArray(message) || message[0] !== VITEST_WORKER_EFD_SUITE_ADMISSION_RESPONSE_CODE) return
 
   const { allowed, requestId } = message[1] || {}
@@ -520,6 +530,11 @@ function wrapSuiteHookFn (hookType, fn, fallbackTask) {
 }
 
 function wrapVitestTestRunner (VitestTestRunner) {
+  // ESM hooks can expose the same runner through multiple module identities.
+  // Wrapping its lifecycle methods twice would report each retry twice.
+  if (wrappedTestRunners.has(VitestTestRunner)) return
+  wrappedTestRunners.add(VitestTestRunner)
+
   // `onBeforeRunTask` is run before any repetition or attempt is run
   // `onBeforeRunTask` is an async function
   shimmer.wrap(VitestTestRunner.prototype, 'onBeforeRunTask', onBeforeRunTask => async function (task) {
@@ -623,6 +638,13 @@ function wrapVitestTestRunner (VitestTestRunner) {
   shimmer.wrap(VitestTestRunner.prototype, 'onAfterRunTask', onAfterRunTask => function (task) {
     const { isTestManagementTestsEnabled } = getProvidedContext()
 
+    // Vitest 5 aggregates failed repetitions into the final state. Preserve the last attempt's actual result.
+    if ((attemptToFixTasks.has(task) || efdRetryTasks.has(task)) &&
+        task.result.state === 'fail' && taskToCtx.get(task)?.status === 'pass' &&
+        (task.result.errors?.length ?? 0) === (taskToReportedErrorCount.get(task) ?? 0)) {
+      task.result.state = 'pass'
+    }
+
     if (isTestManagementTestsEnabled) {
       const isAttemptingToFix = attemptToFixTasks.has(task)
       const isQuarantined = quarantinedTasks.has(task)
@@ -745,7 +767,12 @@ function wrapVitestTestRunner (VitestTestRunner) {
       }
     }
 
-    const lastExecutionStatus = task.result.state
+    let lastExecutionStatus = task.result.state
+    if (lastExecutionStatus === 'run' && numRepetition > 0) {
+      // Vitest 5 resets the state before each repetition but retains errors from earlier attempts.
+      const reportedErrorCount = taskToReportedErrorCount.get(task) ?? 0
+      lastExecutionStatus = (task.result.errors?.length ?? 0) > reportedErrorCount ? 'fail' : 'pass'
+    }
     const isAtf = attemptToFixTasks.has(task)
     const isEfd = efdRetryTasks.has(task)
     const shouldTrackStatuses = isEfd || isAtf
@@ -1101,14 +1128,18 @@ function getStartTestsWrapper (frameworkVersion) {
             isDisabled: disabledTasks.has(task),
             isQuarantined: quarantinedTasks.has(task),
           })
-        } else if (state === 'pass' && !isSwitchedStatus) {
+        } else if ((state === 'pass' && !isSwitchedStatus) || switchedStatus === 'pass') {
+          // Attempt-to-fix can pass its last attempt while an earlier failure still fails the suite.
+          if (switchedStatus === 'pass' && errors?.length) {
+            testSuiteError = testError
+          }
           if (testCtx) {
             const isSkippedByTestManagement =
               !attemptToFixTasks.has(task) && (disabledTasks.has(task) || quarantinedTasks.has(task))
             const promises = {}
             testPassCh.publish({
               task,
-              finalStatus: isSkippedByTestManagement ? 'skip' : 'pass',
+              finalStatus: isSkippedByTestManagement ? 'skip' : state,
               earlyFlakeAbortReason: efdSlowAbortedTasks.has(task) ? 'slow' : undefined,
               promises,
               ...testCtx.currentStore,

package/packages/datadog-plugin-aws-sdk/src/services/bedrockruntime/utils.js

@@ -23,6 +23,15 @@ const PROVIDER = {
   MISTRAL: 'MISTRAL',
 }
 
+/**
+ * @typedef {{
+ *   inputTokens?: number,
+ *   outputTokens?: number,
+ *   cacheReadTokens?: number,
+ *   cacheWriteTokens?: number,
+ * }} StreamedUsage
+ */
+
 /**
  * Coerce the chunks into a single response body.
  *
@@ -44,10 +53,7 @@ function extractTextAndResponseReasonFromStream (chunks, modelProvider, modelNam
   }
 
   let message = ''
-  let inputTokens = 0
-  let outputTokens = 0
-  let cacheReadTokens = 0
-  let cacheWriteTokens = 0
+  let usage
 
   for (const { chunk: { bytes } } of chunks) {
     const body = JSON.parse(Buffer.from(bytes).toString('utf8'))
@@ -56,8 +62,6 @@ function extractTextAndResponseReasonFromStream (chunks, modelProvider, modelNam
       case PROVIDER.AMAZON: {
         if (body?.outputText) {
           message += body?.outputText
-          inputTokens = body?.inputTextTokenCount
-          outputTokens = body?.totalOutputTextTokenCount
         } else if (body?.contentBlockDelta?.delta?.text) {
           message += body.contentBlockDelta.delta.text
         }
@@ -79,9 +83,6 @@ function extractTextAndResponseReasonFromStream (chunks, modelProvider, modelNam
           message += body.delta.text
         }
 
-        if (body.message?.usage?.input_tokens) inputTokens = body.message.usage.input_tokens
-        if (body.message?.usage?.output_tokens) outputTokens = body.message.usage.output_tokens
-
         break
       }
       case PROVIDER.COHERE: {
@@ -101,24 +102,61 @@ function extractTextAndResponseReasonFromStream (chunks, modelProvider, modelNam
       }
     }
 
-    // by default, it seems newer versions of the AWS SDK include the input/output token counts in the response body
-    const invocationMetrics = body['amazon-bedrock-invocationMetrics']
-    if (invocationMetrics) {
-      inputTokens = invocationMetrics.inputTokenCount
-      outputTokens = invocationMetrics.outputTokenCount
-      cacheReadTokens = invocationMetrics.cacheReadInputTokenCount
-      cacheWriteTokens = invocationMetrics.cacheWriteInputTokenCount
+    usage = mergeStreamedUsage(usage, body, modelProviderUpper)
+  }
+
+  return new Generation({ message, role: 'assistant', ...usage })
+}
+
+/**
+ * Merge the token counts one streamed `invokeModel` frame reports into the running totals. Each
+ * provider spells them differently, and most report none until the trailing invocation metrics,
+ * so a frame carrying no counts leaves the totals as they were.
+ *
+ * @param {StreamedUsage} [usage]
+ * @param {object} body parsed chunk body
+ * @param {string} modelProviderUpper
+ * @returns {StreamedUsage | undefined}
+ */
+function mergeStreamedUsage (usage, body, modelProviderUpper) {
+  // by default, it seems newer versions of the AWS SDK include the input/output token counts in
+  // the response body; any provider can send them, and they supersede what the frames reported
+  const invocationMetrics = body['amazon-bedrock-invocationMetrics']
+  if (invocationMetrics) {
+    return {
+      inputTokens: invocationMetrics.inputTokenCount,
+      outputTokens: invocationMetrics.outputTokenCount,
+      cacheReadTokens: invocationMetrics.cacheReadInputTokenCount,
+      cacheWriteTokens: invocationMetrics.cacheWriteInputTokenCount,
     }
   }
 
-  return new Generation({
-    message,
-    role: 'assistant',
-    inputTokens,
-    outputTokens,
-    cacheReadTokens,
-    cacheWriteTokens,
-  })
+  switch (modelProviderUpper) {
+    case PROVIDER.AMAZON: {
+      const { inputTextTokenCount, totalOutputTextTokenCount } = body
+      if (inputTextTokenCount === undefined && totalOutputTextTokenCount === undefined) return usage
+
+      return {
+        ...usage,
+        inputTokens: inputTextTokenCount ?? usage?.inputTokens,
+        outputTokens: totalOutputTextTokenCount ?? usage?.outputTokens,
+      }
+    }
+    case PROVIDER.ANTHROPIC: {
+      // `message_start` reports the initial counts under `message.usage`; the closing
+      // `message_delta` reports the final output count at the top level
+      const chunkUsage = body.message?.usage ?? body.usage
+      if (!chunkUsage) return usage
+
+      return {
+        ...usage,
+        inputTokens: chunkUsage.input_tokens ?? usage?.inputTokens,
+        outputTokens: chunkUsage.output_tokens ?? usage?.outputTokens,
+      }
+    }
+  }
+
+  return usage
 }
 
 class Generation {
@@ -568,13 +606,27 @@ function resolveToolResultItem (item) {
   return `[Unsupported content type(s): ${getContentBlockType(item)}]`
 }
 
+/**
+ * Normalize a Converse usage object onto the LLMObs metric names. Returns undefined when the
+ * response reported no counts at all, so a caller cannot mistake an empty record for a measurement.
+ *
+ * @param {object} [usage]
+ * @returns {{
+ *   inputTokens?: number, outputTokens?: number, cacheReadTokens?: number, cacheWriteTokens?: number
+ * } | undefined}
+ */
 function buildUsage (usage = {}) {
-  return {
-    inputTokens: usage.inputTokens,
-    outputTokens: usage.outputTokens,
-    cacheReadTokens: usage.cacheReadInputTokens ?? usage.cacheReadInputTokenCount,
-    cacheWriteTokens: usage.cacheWriteInputTokens ?? usage.cacheWriteInputTokenCount,
+  const inputTokens = usage.inputTokens
+  const outputTokens = usage.outputTokens
+  const cacheReadTokens = usage.cacheReadInputTokens ?? usage.cacheReadInputTokenCount
+  const cacheWriteTokens = usage.cacheWriteInputTokens ?? usage.cacheWriteInputTokenCount
+
+  if (inputTokens === undefined && outputTokens === undefined &&
+      cacheReadTokens === undefined && cacheWriteTokens === undefined) {
+    return
   }
+
+  return { inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens }
 }
 
 /**
@@ -714,6 +766,8 @@ function extractTextAndResponseReasonConverseFromStream (chunks) {
 
 module.exports = {
   Generation,
+  buildUsage,
+  mergeStreamedUsage,
   RequestParams,
   extractTextAndResponseReasonFromStream,
   parseModelId,

package/packages/datadog-plugin-cucumber/src/index.js

@@ -449,7 +449,8 @@ class CucumberPlugin extends CiPlugin {
     })
 
     this.addSub('ci:cucumber:is-modified-test', ({
-      scenarios,
+      gherkinNodes,
+      gherkinScopeRanges,
       testFileAbsolutePath,
       modifiedFiles,
       stepIds,
@@ -457,11 +458,25 @@ class CucumberPlugin extends CiPlugin {
       setIsModified,
     }) => {
       const testScenarioPath = getTestSuitePath(testFileAbsolutePath, this.repositoryRoot || process.cwd())
-      for (const scenario of scenarios) {
+      for (const [startLine, endLine] of gherkinScopeRanges) {
+        if (isModifiedTest(testScenarioPath, startLine, endLine, modifiedFiles, 'cucumber')) {
+          setIsModified(true)
+          return
+        }
+      }
+      for (const gherkinNode of gherkinNodes) {
+        const lastStep = gherkinNode.steps.at(-1)
+        let endLine = lastStep?.location.line ?? gherkinNode.location.line
+        if (lastStep?.dataTable?.rows.length) {
+          endLine = lastStep.dataTable.rows.at(-1).location.line
+        } else if (lastStep?.docString) {
+          const { content, location } = lastStep.docString
+          endLine = location.line + (content ? content.split('\n').length + 1 : 1)
+        }
         const isModified = isModifiedTest(
           testScenarioPath,
-          scenario.location.line,
-          scenario.steps.at(-1).location.line,
+          gherkinNode.location.line,
+          endLine,
           modifiedFiles,
           'cucumber'
         )

package/packages/datadog-plugin-cypress/src/cypress-plugin.js

@@ -94,6 +94,7 @@ const {
 const { ORIGIN_KEY, COMPONENT } = require('../../dd-trace/src/constants')
 const { RESOURCE_NAME } = require('../../../ext/tags')
 const getConfig = require('../../dd-trace/src/config')
+const { getValueFromEnvSources } = require('../../dd-trace/src/config/helper')
 const {
   SCREENSHOT_UPLOAD_RESULT_ERROR,
   SCREENSHOT_UPLOAD_RESULT_UPLOADED,
@@ -857,6 +858,12 @@ class CypressPlugin {
 
     const testOptimizationConfig = getConfig().testOptimization
     this.rumFlushWaitMillis = testOptimizationConfig.DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS
+    if (getValueFromEnvSources('DD_TEST_FAILURE_SCREENSHOTS_ENABLED', true) === true) {
+      cypressConfig.screenshotOnRunFailure = true
+    }
+    if (getValueFromEnvSources('DD_TEST_FAILURE_VIDEOS_ENABLED', true) === true) {
+      cypressConfig.video = true
+    }
     this.warnIfMisconfiguredTestFailureScreenshots(cypressConfig, tracer, testOptimizationConfig)
     this.warnIfMisconfiguredTestFailureVideos(cypressConfig, tracer, testOptimizationConfig)
 

package/packages/datadog-plugin-fetch/src/index.js

@@ -17,6 +17,9 @@ class FetchPlugin extends HttpClientPlugin {
 
     const store = super.bindStart(ctx)
 
+    // Native undici diagnostics also fire for requests already traced by this wrapper.
+    store.skipUndici = true
+
     for (const name in options.headers) {
       if (!req.headers.has(name)) {
         req.headers.set(name, options.headers[name])

package/packages/datadog-plugin-oracledb/src/connection-parser.js

@@ -3,6 +3,8 @@
 const { URL } = require('url')
 const log = require('../../dd-trace/src/log')
 
+const easyConnectProtocol = /^tcps?:\/\//i
+
 function parseOracleDescriptor (descriptor) {
   const hostnameMatch = descriptor.match(/HOST\s*=\s*([^)]+)/i)
   const hostname = hostnameMatch?.[1] || 'localhost' // Default Oracle hostname
@@ -24,7 +26,7 @@ module.exports = function getDBInformation (connAttrs) {
     return parseOracleDescriptor(connectString)
   }
   try {
-    const url = new URL(`oracle://${connectString}`)
+    const url = new URL(easyConnectProtocol.test(connectString) ? connectString : `oracle://${connectString}`)
     return {
       hostname: url.hostname || 'localhost', // Default Oracle hostname
       port: url.port || '1521', // Default Oracle port

package/packages/datadog-plugin-undici/src/index.js

@@ -47,6 +47,8 @@ class UndiciPlugin extends HttpClientPlugin {
     if (!request) return
 
     const store = storage('legacy').getStore()
+    if (store?.skipUndici) return
+
     const { origin = '', path = '/' } = request
     const method = request.method?.toUpperCase() ?? 'GET'
 
@@ -207,6 +209,9 @@ class UndiciPlugin extends HttpClientPlugin {
 
     const store = super.bindStart(ctx)
 
+    // Undici 5.0 emits native diagnostics even though its fetch needs the legacy wrapper.
+    store.skipUndici = true
+
     // Inject trace headers back into the request
     for (const name of Object.keys(options.headers)) {
       if (!req.headers.has(name)) {

package/packages/dd-trace/src/aiguard/client.js

@@ -1,10 +1,15 @@
 'use strict'
 
 const tracerVersion = require('../../../../package.json').version
+const { createAgents } = require('../exporters/common/agents')
+const request = require('../exporters/common/request')
 const { AIGuardClientError } = require('./errors')
 const { parseEvaluationResponse } = require('./evaluation')
 const TAGS = require('./tags')
 
+// Evaluations can run concurrently on the application's request path.
+const { httpAgent, httpsAgent } = createAgents(16)
+
 /**
  * Resolves the AI Guard host for a Datadog site.
  *
@@ -18,29 +23,43 @@ function aiGuardHost (site) {
  * Sends a request to the AI Guard service.
  *
  * @param {object} body
- * @param {{ url: string, headers: Record<string, string>, timeout: number }} opts
+ * @param {{ url: string, headers: Record<string, string|undefined>, timeout: number }} opts
  * @returns {Promise<{ status: number, body: unknown }>}
  */
-async function executeRequest (body, opts) {
-  const postData = JSON.stringify(body)
-  const headers = {
-    'Content-Type': 'application/json',
-    'Content-Length': Buffer.byteLength(postData),
-    ...opts.headers,
-  }
+function executeRequest (body, opts) {
+  return new Promise((resolve, reject) => {
+    const postData = JSON.stringify(body)
+    const url = new URL(opts.url)
+    request(postData, {
+      url,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...opts.headers,
+      },
+      agent: url.protocol === 'https:' ? httpsAgent : httpAgent,
+      timeout: opts.timeout,
+      signal: AbortSignal.timeout(opts.timeout),
+      retry: false,
+      includeErrorResponseBody: true,
+    }, (error, result, status) => {
+      if (status === undefined) {
+        reject(error || new Error('AI Guard request completed without a status'))
+        return
+      }
 
-  const response = await fetch(opts.url, {
-    method: 'POST',
-    headers,
-    body: postData,
-    signal: AbortSignal.timeout(opts.timeout),
+      let responseBody
+      try {
+        const responseText = error ? /** @type {Error & { responseBody?: string }} */ (error).responseBody : result
+        if (typeof responseText !== 'string') throw new TypeError('AI Guard response body is missing')
+        responseBody = JSON.parse(responseText)
+      } catch (cause) {
+        reject(cause)
+        return
+      }
+      resolve({ status, body: responseBody })
+    })
   })
-
-  const responseBody = await response.json()
-  return {
-    status: response.status,
-    body: responseBody,
-  }
 }
 
 class AIGuardClient {

package/packages/dd-trace/src/aiguard/integrations/anthropic.js

@@ -2,10 +2,15 @@
 
 const { channel } = require('dc-polyfill')
 
-const { getMessagesInputMessages, getMessagesOutputMessages } = require('../messages/anthropic')
+const {
+  getMessagesInputMessages,
+  getMessagesOutputMessages,
+  getStreamedMessagesOutputMessages,
+} = require('../messages/anthropic')
 const { decode } = require('../messages/utils')
 const { SOURCE_AUTO } = require('../tags')
 const { evaluate } = require('./evaluate')
+const { interceptStream } = require('./stream')
 
 const messagesPrepareChannel = channel('dd-trace:anthropic:messages:prepare')
 const messagesInterceptChannel = channel('dd-trace:anthropic:messages:intercept')
@@ -13,18 +18,21 @@ const messagesInterceptChannel = channel('dd-trace:anthropic:messages:intercept'
 let isEnabled = false
 let aiguard
 let opts
+let analyzeStreamResponses
 
 /**
  * Subscribes AI Guard to the Anthropic interception channels.
  *
  * @param {object} aiguardInstance
  * @param {boolean} block
+ * @param {boolean} analyzeStreams
  */
-function enable (aiguardInstance, block) {
+function enable (aiguardInstance, block, analyzeStreams) {
   if (isEnabled) return
 
   aiguard = aiguardInstance
   opts = { block, source: SOURCE_AUTO, integration: 'anthropic' }
+  analyzeStreamResponses = analyzeStreams
 
   messagesPrepareChannel.subscribe(onMessagesPrepare)
   messagesInterceptChannel.subscribe(onMessagesIntercept)
@@ -40,6 +48,7 @@ function disable () {
 
   aiguard = undefined
   opts = undefined
+  analyzeStreamResponses = undefined
   isEnabled = false
 }
 
@@ -76,19 +85,35 @@ function onMessagesIntercept (ctx) {
     return inputEvaluation
   }
 
+  const isStream = ctx.arguments[0].stream
+  if (isStream && !analyzeStreamResponses) return
+
   // One model call has one output however many readers observe it: `parse`, `json()`, `text()`
   // and every `clone()` of the raw response share this callback.
   let outputEvaluation
   ctx.onResult = body => {
     if (!isEnabled) return body
 
+    if (isStream) {
+      outputEvaluation ??= interceptStream(body, chunks => {
+        if (!isEnabled) return
+        const outputMessages = decode(
+          () => getStreamedMessagesOutputMessages(chunks),
+          null,
+          'AIGuard: unable to decode the streamed Anthropic response: %s'
+        )
+        if (!outputMessages?.length) return
+        return evaluate(ctx, aiguard, [[...inputMessages, ...outputMessages]], opts)
+      })
+      return outputEvaluation
+    }
+
     const outputMessages = decode(
       () => getMessagesOutputMessages(body),
       null,
       'AIGuard: unable to decode Anthropic response body: %s'
     )
-    if (outputMessages === null) return body
-    if (!outputMessages.length) return body
+    if (!outputMessages?.length) return body
 
     outputEvaluation ??= evaluate(ctx, aiguard, [[...inputMessages, ...outputMessages]], opts)
     return outputEvaluation.then(() => body)

package/packages/dd-trace/src/aiguard/integrations/index.js

@@ -16,7 +16,7 @@ let isEnabled = false
 function enable (aiguard, block, analyzeStreamResponses) {
   if (isEnabled) return
 
-  anthropic.enable(aiguard, block)
+  anthropic.enable(aiguard, block, analyzeStreamResponses)
   openai.enable(aiguard, block, analyzeStreamResponses)
   vercelAi.enable(aiguard, block, analyzeStreamResponses)
 

package/packages/dd-trace/src/aiguard/integrations/openai.js

@@ -13,6 +13,7 @@ const {
 const { decode } = require('../messages/utils')
 const { SOURCE_AUTO } = require('../tags')
 const { evaluate } = require('./evaluate')
+const { interceptStream } = require('./stream')
 
 const chatCompletionsInterceptChannel = channel('dd-trace:openai:chat.completions:intercept')
 const responsesInterceptChannel = channel('dd-trace:openai:responses:intercept')
@@ -74,9 +75,16 @@ function onChatCompletions (ctx) {
 
     if (isStream) {
       outputEvaluation ??= interceptStream(body, chunks => {
-        return getStreamedChatCompletionsOutputMessages(chunks)
-          .map(message => [...inputMessages, message])
-      }, ctx)
+        if (!isEnabled) return
+        const conversations = decode(
+          () => getStreamedChatCompletionsOutputMessages(chunks)
+            .map(message => [...inputMessages, message]),
+          null,
+          'AIGuard: unable to decode the streamed OpenAI response: %s'
+        )
+        if (!conversations?.length) return
+        return evaluate(ctx, aiguard, conversations, opts)
+      })
       return outputEvaluation
     }
 
@@ -112,9 +120,15 @@ function onResponses (ctx) {
 
     if (isStream) {
       outputEvaluation ??= interceptStream(body, chunks => {
-        const outputMessages = getStreamedResponsesOutputMessages(chunks)
-        return outputMessages.length ? [[...inputMessages, ...outputMessages]] : []
-      }, ctx)
+        if (!isEnabled) return
+        const outputMessages = decode(
+          () => getStreamedResponsesOutputMessages(chunks),
+          null,
+          'AIGuard: unable to decode the streamed OpenAI response: %s'
+        )
+        if (!outputMessages?.length) return
+        return evaluate(ctx, aiguard, [[...inputMessages, ...outputMessages]], opts)
+      })
       return outputEvaluation
     }
 
@@ -130,54 +144,4 @@ function onResponses (ctx) {
   }
 }
 
-/**
- * Uses the OpenAI SDK's stream splitting support to evaluate one branch and return the other.
- *
- * @param {object} stream
- * @param {(chunks: Array<object>) => Array<Array<object>>} getConversations
- * @param {object} ctx
- * @returns {object|Promise<object>}
- */
-function interceptStream (stream, getConversations, ctx) {
-  if (typeof stream?.tee !== 'function') return stream
-
-  let branches
-  try {
-    branches = stream.tee()
-  } catch {
-    return stream
-  }
-
-  const [evaluationStream, resultStream] = branches
-  return drainStream(evaluationStream).then(chunks => {
-    if (!isEnabled) return resultStream
-    const conversations = decode(
-      () => getConversations(chunks),
-      null,
-      'AIGuard: unable to decode the streamed OpenAI response: %s'
-    )
-    if (!conversations?.length) return resultStream
-    return evaluate(ctx, aiguard, conversations, opts).then(() => resultStream)
-  }, () => resultStream)
-}
-
-/**
- * @param {object} stream
- * @returns {Promise<Array<object>>}
- */
-function drainStream (stream) {
-  const chunks = []
-  const iterator = stream[Symbol.asyncIterator]()
-
-  function readAll () {
-    return iterator.next().then(({ done, value }) => {
-      if (done) return chunks
-      chunks.push(value)
-      return readAll()
-    })
-  }
-
-  return readAll()
-}
-
 module.exports = { enable, disable }