dd-trace 5.105.0 → 5.107.0

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

@@ -206,6 +206,32 @@ function wrapConnection (Connection, version) {
     })
   }
 }
+/**
+ * mysql2 defers a busy pool's `getConnection` callback and runs it in the releasing connection's
+ * async context; capture the caller's context and restore it around the callback so spans created
+ * by the queued query attach to the caller rather than the previous query that freed the connection.
+ *
+ * @param {Function} Pool
+ * @returns {Function}
+ */
+function wrapGetConnection (Pool) {
+  const connectionStartCh = channel('apm:mysql2:connection:start')
+  const connectionFinishCh = channel('apm:mysql2:connection:finish')
+
+  shimmer.wrap(Pool.prototype, 'getConnection', getConnection => function (cb) {
+    const ctx = {}
+    arguments[0] = function (...args) {
+      return connectionFinishCh.runStores(ctx, cb, this, ...args)
+    }
+
+    connectionStartCh.publish(ctx)
+
+    return getConnection.apply(this, arguments)
+  })
+
+  return Pool
+}
+
 /**
  * @param {Function} Pool
  * @param {string} version
@@ -215,6 +241,8 @@ function wrapPool (Pool, version) {
   const startOuterQueryCh = channel('datadog:mysql2:outerquery:start')
   const shouldEmitEndAfterQueryAbort = satisfies(version, '>=1.3.3')
 
+  wrapGetConnection(Pool)
+
   shimmer.wrap(Pool.prototype, 'query', query => function (sql, values, cb) {
     if (!startOuterQueryCh.hasSubscribers) return query.apply(this, arguments)
 
@@ -373,6 +401,12 @@ addHook(
   /** @type {(moduleExports: unknown, version: string) => unknown} */ (wrapPool)
 )
 
+// mysql2 >=3.11.5 moved the pool onto BasePool in lib/base/pool.js.
+addHook(
+  { name: 'mysql2', file: 'lib/base/pool.js', versions: ['>=3.11.5'] },
+  /** @type {(moduleExports: unknown, version: string) => unknown} */ (wrapGetConnection)
+)
+
 // PoolNamespace.prototype.query does not exist in mysql2<2.3.0
 addHook(
   { name: 'mysql2', file: 'lib/pool_cluster.js', versions: ['2.3.0 - 3.11.4'] },

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

@@ -49,20 +49,22 @@ addHook({ name: 'net' }, (net) => {
 
       const emit = this.emit
       let pendingReadyEvents = 2
-      this.emit = shimmer.wrapFunction(emit, emit => function (eventName) {
+      // Named `emit`/arity-1 mirrors the socket method so the per-socket wrap
+      // skips its name/length rewrite.
+      this.emit = shimmer.wrapFunction(emit, originalEmit => function emit (eventName) {
         switch (eventName) {
           case 'ready':
           case 'connect':
-            if (--pendingReadyEvents === 0) this.emit = emit
+            if (--pendingReadyEvents === 0) this.emit = originalEmit
             return readyCh.runStores(ctx, () => {
-              return emit.apply(this, arguments)
+              return Reflect.apply(originalEmit, this, arguments)
             })
           case 'error':
           case 'close':
-            this.emit = emit
-            return emit.apply(this, arguments)
+            this.emit = originalEmit
+            return Reflect.apply(originalEmit, this, arguments)
           default:
-            return emit.apply(this, arguments)
+            return Reflect.apply(originalEmit, this, arguments)
         }
       })
 

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

@@ -240,6 +240,10 @@ for (const extension of extensions) {
           }
 
           return ch.start.runStores(ctx, () => {
+            // Explicit childOf rather than async-context: the _thenUnwrap/parse path
+            // decouples the lazy evaluation from the active scope at call time.
+            if (guard) guard.parentSpan = ctx.currentStore?.span
+
             const apiProm = methodFn.apply(this, args)
 
             if (baseResource === 'chat.completions' && typeof apiProm._thenUnwrap === 'function') {
@@ -300,23 +304,31 @@ function handleUnwrappedAPIPromise (apiProm, ctx, stream, guard) {
         return body
       }
 
-      finish(ctx, {
+      const responseData = {
         headers: response.headers,
         data: body,
         request: {
           path: response.url,
           method: options.method,
         },
-      })
+      }
 
-      if (!guard) return body
+      if (!guard) {
+        finish(ctx, responseData)
+        return body
+      }
 
-      return aiGuard.evaluateOutput(guard, body).then(() => body)
+      // Finish after evaluation so a block propagates the error to openai.request
+      // and the span wraps its ai_guard child instead of closing before it.
+      return aiGuard.evaluateOutput(guard, body).then(() => {
+        finish(ctx, responseData)
+        return body
+      })
     })
     .catch(error => {
-      // ctx.result is set inside finish(); if absent, finish never ran (sync throw in
-      // success branch, before-model block, or openai error) — record the error now.
-      // If finish already ran successfully (after-model block), don't double-publish.
+      // ctx.result is set inside finish(); if absent, finish never ran (sync throw in the success
+      // branch, Before Model block, After Model block, or openai error) — record the error now so
+      // the openai.request span is marked errored. If finish already ran, don't double-publish.
       if (!ctx.result) finish(ctx, undefined, error)
       throw error
     })

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

@@ -15,6 +15,9 @@ const errorCh = channel('apm:pg:query:error')
 const startPoolQueryCh = channel('datadog:pg:pool:query:start')
 const finishPoolQueryCh = channel('datadog:pg:pool:query:finish')
 
+const poolConnectStartCh = channel('apm:pg:pool:connect:start')
+const poolConnectFinishCh = channel('apm:pg:pool:connect:finish')
+
 // Drivers like pg-promise reuse the same prepared-statement query object across executions; cache
 // the un-injected `text` so the wrap doesn't capture a previous DBM injection as the new original.
 const originalTextCache = new WeakMap()
@@ -30,6 +33,22 @@ addHook({ name: 'pg', versions: ['>=8.0.3'], file: 'lib/client.js' }, Client =>
 })
 
 addHook({ name: 'pg', versions: ['>=8.0.3'] }, pg => {
+  // pg defers a busy pool's connect callback and runs it in the releasing query's async context;
+  // capture the caller's context and restore it around the callback so spans attach to the caller.
+  shimmer.wrap(pg.Pool.prototype, 'connect', connect => function (cb) {
+    if (typeof cb !== 'function' || !poolConnectStartCh.hasSubscribers) {
+      return connect.apply(this, arguments)
+    }
+
+    const ctx = {}
+    arguments[0] = function (...args) {
+      return poolConnectFinishCh.runStores(ctx, cb, this, ...args)
+    }
+
+    poolConnectStartCh.publish(ctx)
+
+    return connect.apply(this, arguments)
+  })
   shimmer.wrap(pg.Pool.prototype, 'query', query => wrapPoolQuery(query))
   return pg
 })

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

@@ -157,9 +157,9 @@ function createWrapRouterMethod (name, compile) {
   }
 
   function wrapNext (req, originalNext) {
-    // Per layer dispatch, N per request. `shimmer.wrapCallback` preserves
-    // only `name` + `length`; see its JSDoc for the full contract.
-    return shimmer.wrapCallback(originalNext, next => function (error) {
+    // Per layer dispatch, N per request. Named `next`/arity-1 mirrors the
+    // router continuation so wrapCallback skips its name/length rewrite.
+    return shimmer.wrapCallback(originalNext, original => function next (error) {
       if (error && error !== 'route' && error !== 'router') {
         errorChannel.publish({ req, error })
       }
@@ -167,7 +167,7 @@ function createWrapRouterMethod (name, compile) {
       nextChannel.publish({ req })
       finishChannel.publish({ req })
 
-      next.apply(this, arguments)
+      original.apply(this, arguments)
     })
   }
 
@@ -328,7 +328,8 @@ const routerParamStartCh = channel('datadog:router:param:start')
 const visitedParams = new WeakSet()
 
 function wrapHandleRequest (original) {
-  return function wrappedHandleRequest (req, res, next) {
+  return function wrappedHandleRequest (...args) {
+    const req = args[0]
     if (routerParamStartCh.hasSubscribers && !visitedParams.has(req.params) && Object.keys(req.params).length) {
       visitedParams.add(req.params)
 
@@ -336,7 +337,7 @@ function wrapHandleRequest (original) {
 
       routerParamStartCh.publish({
         req,
-        res,
+        res: args[1],
         params: req?.params,
         abortController,
       })
@@ -344,7 +345,7 @@ function wrapHandleRequest (original) {
       if (abortController.signal.aborted) return
     }
 
-    return original.apply(this, arguments)
+    return Reflect.apply(original, this, args)
   }
 }
 
@@ -358,7 +359,8 @@ addHook({
 function wrapParam (original) {
   return function wrappedProcessParams (...args) {
     args[1] = shimmer.wrapFunction(args[1], (originalFn) => {
-      return function wrappedFn (req, res) {
+      return function wrappedFn (...fnArgs) {
+        const req = fnArgs[0]
         if (routerParamStartCh.hasSubscribers && Object.keys(req.params).length && !visitedParams.has(req.params)) {
           visitedParams.add(req.params)
 
@@ -366,7 +368,7 @@ function wrapParam (original) {
 
           routerParamStartCh.publish({
             req,
-            res,
+            res: fnArgs[1],
             params: req?.params,
             abortController,
           })
@@ -374,7 +376,7 @@ function wrapParam (original) {
           if (abortController.signal.aborted) return
         }
 
-        return originalFn.apply(this, arguments)
+        return Reflect.apply(originalFn, this, fnArgs)
       }
     })
 

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

@@ -57,6 +57,7 @@ const codeCoverageReportCh = channel('ci:vitest:coverage-report')
 
 const taskToCtx = new WeakMap()
 const taskToStatuses = new WeakMap()
+const taskToReportedErrorCount = new WeakMap()
 const attemptToFixTaskToStatuses = new WeakMap()
 const originalHookFns = new WeakMap()
 const newTasks = new WeakSet()
@@ -316,6 +317,27 @@ function recordFinalAttemptToFixExecution (task, status, providedContext) {
   })
 }
 
+function disableFrameworkRetries (task) {
+  task.retry = 0
+}
+
+/**
+ * Vitest accumulates retry and repeat errors on one task result. The first error added since
+ * the last reported attempt is the primary error for the failed attempt currently being reported.
+ *
+ * @param {object} task
+ * @param {Array<object> | undefined} errors
+ * @returns {object | undefined}
+ */
+function getCurrentAttemptTestError (task, errors) {
+  if (!errors?.length) return
+
+  const previousErrorCount = taskToReportedErrorCount.get(task) ?? 0
+  const testError = errors[previousErrorCount] ?? errors[0]
+  taskToReportedErrorCount.set(task, errors.length)
+  return testError
+}
+
 /**
  * Wraps a function so it runs inside the current test span context.
  * @param {object} task
@@ -801,6 +823,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
         onDone: (isAttemptToFix) => {
           if (isAttemptToFix) {
             isRetryReasonAttemptToFix = task.repeats !== testManagementAttemptToFixRetries
+            disableFrameworkRetries(task)
             task.repeats = testManagementAttemptToFixRetries
             attemptToFixTasks.add(task)
             attemptToFixTaskToStatuses.set(task, [])
@@ -831,6 +854,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
           if (isImpacted) {
             if (isEarlyFlakeDetectionEnabled) {
               isRetryReasonEfd = true
+              disableFrameworkRetries(task)
               task.repeats = numRepeats
             }
             modifiedTasks.add(task)
@@ -849,6 +873,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
           if (isNew && !attemptToFixTasks.has(task)) {
             if (isEarlyFlakeDetectionEnabled && !modifiedTasks.has(task)) {
               isRetryReasonEfd = true
+              disableFrameworkRetries(task)
               task.repeats = numRepeats
             }
             newTasks.add(task)
@@ -986,7 +1011,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
       const promises = {}
       const shouldSetProbe = isDiEnabled && numAttempt === 1
       const ctx = taskToCtx.get(task)
-      const testError = task.result?.errors?.[0]
+      const testError = getCurrentAttemptTestError(task, task.result?.errors)
       if (ctx) {
         testErrorCh.publish({
           error: testError,
@@ -1016,7 +1041,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
       const ctx = taskToCtx.get(task)
       if (ctx) {
         if (lastExecutionStatus === 'fail') {
-          const testError = task.result?.errors?.[0]
+          const testError = getCurrentAttemptTestError(task, task.result?.errors)
           testErrorCh.publish({ error: testError, ...ctx.currentStore })
         } else {
           testPassCh.publish({ task, ...ctx.currentStore })
@@ -1040,7 +1065,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
 
       const ctx = taskToCtx.get(task)
       if (lastExecutionStatus === 'fail') {
-        const testError = task.result?.errors?.[0]
+        const testError = getCurrentAttemptTestError(task, task.result?.errors)
         testErrorCh.publish({ error: testError, ...ctx.currentStore })
       } else {
         testPassCh.publish({ task, ...ctx.currentStore })
@@ -1389,7 +1414,7 @@ addHook({
 
       if (result) {
         const { state, duration, errors } = result
-        const testError = errors?.[0]
+        const testError = getCurrentAttemptTestError(task, errors)
         if (attemptToFixTasks.has(task)) {
           const status = getFinalAttemptToFixStatus(task, state, isSwitchedStatus, testCtx)
           recordFinalAttemptToFixExecution(task, status, providedContext)

package/packages/datadog-plugin-aws-sdk/src/base.js

@@ -1,6 +1,5 @@
 'use strict'
 
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 const ClientPlugin = require('../../dd-trace/src/plugins/client')
 const { storage } = require('../../datadog-core')
 const { tagsFromRequest, tagsFromResponse } = require('../../dd-trace/src/payload-tagging')
@@ -113,8 +112,6 @@ class BaseAwsSdkPlugin extends ClientPlugin {
         integrationName: 'aws-sdk',
       }, ctx)
 
-      analyticsSampler.sample(span, this.config.measured)
-
       storage('legacy').run(ctx.currentStore, () => {
         this.requestInject(span, request)
       })

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

@@ -3,7 +3,7 @@
 const BaseAwsSdkPlugin = require('../../base')
 const { parseModelId } = require('./utils')
 
-const enabledOperations = new Set(['invokeModel', 'invokeModelWithResponseStream'])
+const enabledOperations = new Set(['invokeModel', 'invokeModelWithResponseStream', 'converse', 'converseStream'])
 
 class BedrockRuntime extends BaseAwsSdkPlugin {
   static id = 'bedrockruntime'

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

@@ -131,6 +131,7 @@ class Generation {
     outputTokens,
     cacheReadTokens,
     cacheWriteTokens,
+    messages,
   } = {}) {
     // stringify message as it could be a single generated message as well as a list of embeddings
     this.message = typeof message === 'string' ? message : JSON.stringify(message) || ''
@@ -143,6 +144,7 @@ class Generation {
       cacheReadTokens,
       cacheWriteTokens,
     }
+    this.messages = messages ?? [{ content: this.message, role: this.role }]
   }
 }
 
@@ -401,10 +403,7 @@ function extractTextAndResponseReason (response, provider, modelName) {
             message: output.message?.content[0]?.text ?? 'Unsupported content type',
             finishReason: body.stopReason,
             role: output.message?.role,
-            inputTokens: body.usage?.inputTokens,
-            outputTokens: body.usage?.outputTokens,
-            cacheReadInputTokenCount: body.usage?.cacheReadInputTokenCount,
-            cacheWriteInputTokenCount: body.usage?.cacheWriteInputTokenCount,
+            ...buildUsage(body.usage),
           })
         }
         break
@@ -476,6 +475,216 @@ function extractTextAndResponseReason (response, provider, modelName) {
   return new Generation()
 }
 
+/**
+ * Convert a Converse content-block array to an LLMObs message array.
+ *
+ * @param {string} role
+ * @param {Array<object>} contentBlocks
+ * @returns {{ content?: string, role: string, toolCalls?: Array, toolResults?: Array } | undefined}
+ */
+function extractMessagesFromConverseContent (role, contentBlocks) {
+  let content = ''
+  const toolCalls = []
+  const toolResults = []
+
+  for (const block of contentBlocks || []) {
+    if (block == null || typeof block !== 'object') continue
+    if (typeof block.text === 'string') {
+      content += block.text
+    } else if (block.toolUse) {
+      toolCalls.push(buildToolCall(block.toolUse))
+    } else if (block.toolResult) {
+      toolResults.push(buildToolResult(block.toolResult))
+    } else {
+      content += `[Unsupported content type: ${getContentBlockType(block)}]`
+    }
+  }
+
+  if (!content && toolCalls.length === 0 && toolResults.length === 0) return
+
+  const message = { role }
+  if (content) message.content = content
+  if (toolCalls.length > 0) message.toolCalls = toolCalls
+  if (toolResults.length > 0) message.toolResults = toolResults
+  return message
+}
+
+/**
+ * Resolve a Converse `ContentBlock`'s member type. The block is a key-presence
+ * tagged union (no `type` discriminator), so the active member is its sole own
+ * key. For forward-compat `$unknown` members the real type is the first element
+ * of the `[name, value]` tuple.
+ *
+ * @param {object} block
+ * @returns {string}
+ */
+function getContentBlockType (block) {
+  const key = Object.keys(block)[0]
+  if (key === '$unknown') return block.$unknown?.[0] ?? 'unknown'
+  return key ?? 'unknown'
+}
+
+// Always emit at least one output message so downstream tagging has a role to attach to.
+function toOutputMessages (role, contentBlocks) {
+  const message = extractMessagesFromConverseContent(role, contentBlocks)
+  return message ? [message] : [{ role, content: '' }]
+}
+
+function buildToolCall ({ name, input, toolUseId }) {
+  return { name: name ?? '', arguments: input ?? {}, toolId: toolUseId ?? '', type: 'toolUse' }
+}
+
+function parseToolInput (inputStr) {
+  try {
+    return JSON.parse(inputStr)
+  } catch {
+    log.warn('Failed to parse Converse stream toolUse.input JSON; emitting empty arguments')
+    return {}
+  }
+}
+
+function buildToolResult ({ toolUseId, content }) {
+  const result = (content || []).map(resolveToolResultItem).join('')
+  return { name: '', result, toolId: toolUseId ?? '', type: 'tool_result' }
+}
+
+function resolveToolResultItem (item) {
+  if (typeof item.text === 'string') return item.text
+  if (item.json != null) return JSON.stringify(item.json)
+  return `[Unsupported content type(s): ${getContentBlockType(item)}]`
+}
+
+function buildUsage (usage = {}) {
+  return {
+    inputTokens: usage.inputTokens,
+    outputTokens: usage.outputTokens,
+    cacheReadTokens: usage.cacheReadInputTokens ?? usage.cacheReadInputTokenCount,
+    cacheWriteTokens: usage.cacheWriteInputTokens ?? usage.cacheWriteInputTokenCount,
+  }
+}
+
+/**
+ * Extract tool definitions from a Converse request's `toolConfig.tools`,
+ * mapping Bedrock's `toolSpec` shape to LLMObs `ToolDefinition` shape.
+ *
+ * @param {object} params - Converse request params with optional `toolConfig.tools[].toolSpec`.
+ * @returns {Array<{ name: string, description: string, schema: object }>}
+ */
+function extractConverseToolDefinitions (params) {
+  const toolDefinitions = []
+  for (const tool of params.toolConfig?.tools || []) {
+    const toolSpec = tool?.toolSpec
+    if (!toolSpec?.name) continue
+    toolDefinitions.push({
+      name: toolSpec.name,
+      description: toolSpec.description ?? '',
+      schema: toolSpec.inputSchema ?? {},
+    })
+  }
+  return toolDefinitions
+}
+
+/**
+ * Extract request metadata + rendered input messages from a Converse /
+ * ConverseStream request.
+ *
+ * @param {{ modelId?: string, messages?: Array, system?: Array, inferenceConfig?: object, toolConfig?: object }} params
+ * @returns {RequestParams}
+ */
+function extractRequestParamsConverse (params) {
+  const prompt = []
+  for (const block of params.system || []) {
+    if (typeof block?.text === 'string') prompt.push({ content: block.text, role: 'system' })
+  }
+  for (const msg of params.messages || []) {
+    if (msg == null || typeof msg !== 'object') continue
+    const message = extractMessagesFromConverseContent(msg.role || 'user', msg.content)
+    if (message) prompt.push(message)
+  }
+
+  const { temperature, topP, maxTokens, stopSequences } = params.inferenceConfig || {}
+  return new RequestParams({ prompt, temperature, topP, maxTokens, stopSequences })
+}
+
+/**
+ * Extract output messages + usage from a non-stream Converse response.
+ *
+ * @param {{ output?: { message?: { role?: string, content?: Array } }, stopReason?: string, usage?: object }} response
+ * @returns {Generation}
+ */
+function extractTextAndResponseReasonConverse (response) {
+  const outputMessage = response?.output?.message
+  const role = outputMessage?.role || 'assistant'
+
+  return new Generation({
+    role,
+    finishReason: response?.stopReason || '',
+    ...buildUsage(response?.usage),
+    messages: toOutputMessages(role, outputMessage?.content),
+  })
+}
+
+/**
+ * Aggregate Converse stream events into a single output message + usage.
+ * One messageStart / messageStop pair per response, so one message out.
+ *
+ * Stream events describe the same content-block structure as the non-stream
+ * response, spread across start/delta chunks. We reassemble those chunks
+ * into a normalized content-block array and reuse the non-stream extractor.
+ *
+ * @param {Array<object>} chunks - Ordered ConverseStreamOutput events.
+ * @returns {Generation}
+ */
+function extractTextAndResponseReasonConverseFromStream (chunks) {
+  let role = 'assistant'
+  let stopReason = ''
+  let usage = {}
+  const blocksByIdx = new Map()
+
+  for (const chunk of chunks || []) {
+    if (chunk.messageStart?.role) {
+      role = chunk.messageStart.role
+    } else if (chunk.messageStop?.stopReason) {
+      stopReason = chunk.messageStop.stopReason
+    } else if (chunk.metadata?.usage) {
+      usage = chunk.metadata.usage
+    } else if (chunk.contentBlockStart?.start?.toolUse) {
+      const { contentBlockIndex, start: { toolUse } } = chunk.contentBlockStart
+      blocksByIdx.set(contentBlockIndex, {
+        toolUse: { toolUseId: toolUse.toolUseId, name: toolUse.name, inputStr: '' },
+      })
+    } else if (chunk.contentBlockDelta) {
+      const { contentBlockIndex, delta } = chunk.contentBlockDelta
+      if (typeof delta?.text === 'string') {
+        const block = blocksByIdx.get(contentBlockIndex) ?? {}
+        block.text = (block.text ?? '') + delta.text
+        blocksByIdx.set(contentBlockIndex, block)
+      } else if (typeof delta?.toolUse?.input === 'string') {
+        const block = blocksByIdx.get(contentBlockIndex) ?? { toolUse: { inputStr: '' } }
+        block.toolUse ??= { inputStr: '' }
+        block.toolUse.inputStr += delta.toolUse.input
+        blocksByIdx.set(contentBlockIndex, block)
+      }
+    }
+  }
+
+  const contentBlocks = [...blocksByIdx.keys()].sort((a, b) => a - b).map(i => {
+    const block = blocksByIdx.get(i)
+    if (block.toolUse) {
+      const { toolUseId, name, inputStr } = block.toolUse
+      block.toolUse = { toolUseId, name, input: parseToolInput(inputStr) }
+    }
+    return block
+  })
+
+  return new Generation({
+    role,
+    finishReason: stopReason,
+    ...buildUsage(usage),
+    messages: toOutputMessages(role, contentBlocks),
+  })
+}
+
 module.exports = {
   Generation,
   RequestParams,
@@ -483,5 +692,10 @@ module.exports = {
   parseModelId,
   extractRequestParams,
   extractTextAndResponseReason,
+  extractMessagesFromConverseContent,
+  extractConverseToolDefinitions,
+  extractRequestParamsConverse,
+  extractTextAndResponseReasonConverse,
+  extractTextAndResponseReasonConverseFromStream,
   PROVIDER,
 }