dd-trace 6.18.0 → 6.20.0

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-openai/src/stream-helpers.js

@@ -17,7 +17,13 @@
  * @typedef {JsonObject & { choices: Array<StreamChoice | undefined>, usage?: unknown }} StreamResponseBody
  *
  * @typedef {JsonObject & { status?: string }} ResponsesApiResponse
- * @typedef {JsonObject & { response?: ResponsesApiResponse }} ResponsesApiChunk
+ * @typedef {JsonObject & {
+ *   type?: string,
+ *   response?: ResponsesApiResponse,
+ *   output_index?: number,
+ *   item?: JsonObject,
+ *   delta?: string
+ * }} ResponsesApiChunk
  */
 
 /**
@@ -143,12 +149,55 @@ function constructResponseResponseFromStreamedChunks (chunks) {
   // Find the last chunk with a complete response object (status: done, incomplete, or completed)
   const responseStatusSet = new Set(['done', 'incomplete', 'completed'])
 
+  let latestResponse
   for (let i = chunks.length - 1; i >= 0; i--) {
     const chunk = chunks[i]
     if (chunk.response && responseStatusSet.has(chunk.response.status)) {
       return chunk.response
     }
+    latestResponse ??= chunk.response
   }
+
+  // A stream that ends early (e.g. aborted by the caller) never sends a final response,
+  // so rebuild a partial one from the output streamed so far, as the chat helpers do.
+  if (latestResponse) {
+    return { ...latestResponse, output: constructPartialResponseOutput(chunks) }
+  }
+}
+
+/**
+ * Rebuilds the output items of a Responses API stream that ended before its final response.
+ * Items are shallow-copied so the chunks handed to the application are not mutated.
+ * @param {ResponsesApiChunk[]} chunks
+ * @returns {JsonObject[]}
+ */
+function constructPartialResponseOutput (chunks) {
+  const output = []
+
+  for (const chunk of chunks) {
+    const index = chunk.output_index
+    if (index === undefined) continue
+
+    const item = output[index]
+
+    switch (chunk.type) {
+      case 'response.output_item.added':
+      case 'response.output_item.done':
+        output[index] = { ...chunk.item }
+        break
+      case 'response.output_text.delta':
+        if (item) {
+          const text = (item.content?.[0]?.text ?? '') + (chunk.delta ?? '')
+          item.content = [{ type: 'output_text', text }]
+        }
+        break
+      case 'response.function_call_arguments.delta':
+        if (item) item.arguments = (item.arguments ?? '') + (chunk.delta ?? '')
+        break
+    }
+  }
+
+  return output.filter(Boolean)
 }
 
 module.exports = {

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 }

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

@@ -0,0 +1,60 @@
+'use strict'
+
+const log = require('../../log')
+
+/**
+ * Splits an SDK stream, consumes one branch, and returns the other after inspection.
+ *
+ * @param {object} stream
+ * @param {(chunks: Array<object>) => void|Promise<void>} inspect
+ * @returns {object|Promise<object>}
+ */
+function interceptStream (stream, inspect) {
+  if (typeof stream?.tee !== 'function') return stream
+
+  try {
+    const [inspectionStream, resultStream] = stream.tee()
+    return drainStream(inspectionStream).then(chunks => {
+      return Promise.resolve(inspect(chunks)).then(() => resultStream)
+    })
+  } catch {
+    return stream
+  }
+}
+
+/**
+ * Buffers the whole stream. A stream that ends early still yields what it delivered: truncated
+ * output can carry the very violation the evaluation is looking for, so it is judged rather than
+ * skipped, and the read failure is logged because nothing downstream reports it.
+ *
+ * @param {object} stream
+ * @returns {Promise<Array<object>>}
+ */
+function drainStream (stream) {
+  const chunks = []
+  const iterator = stream[Symbol.asyncIterator]()
+
+  function onReadError (error) {
+    log.error('AIGuard: the streamed response ended after %s chunks: %s', chunks.length, error)
+    return chunks
+  }
+
+  function readAll () {
+    let next
+    try {
+      next = iterator.next()
+    } catch (error) {
+      return Promise.resolve(onReadError(error))
+    }
+
+    return next.then(({ done, value }) => {
+      if (done) return chunks
+      chunks.push(value)
+      return readAll()
+    }, onReadError)
+  }
+
+  return readAll()
+}
+
+module.exports = { interceptStream }