dd-trace 5.129.0 → 5.131.0

package/LICENSE-3rdparty.csv

@@ -1,5 +1,6 @@
 "component","origin","license","copyright"
 "@apm-js-collab/code-transformer","https://github.com/nodejs/orchestrion-js","['Apache-2.0']","['nodejs']"
+"@bufbuild/protobuf","https://github.com/bufbuild/protobuf-es","['(Apache-2.0 AND BSD-3-Clause)']","['bufbuild']"
 "@datadog/flagging-core","https://github.com/DataDog/openfeature-js-client","['Apache-2.0']","['DataDog']"
 "@datadog/libdatadog","https://github.com/DataDog/libdatadog-nodejs","['Apache-2.0']","['DataDog']"
 "@datadog/libdatadog-extras","https://github.com/DataDog/libdatadog-nodejs","['Apache-2.0']","['Datadog Inc.']"

package/ci/vitest-no-worker-init-setup.mjs

@@ -114,14 +114,12 @@ if (isNoWorkerInitActive) {
     onTestFinished(() => {
       recordTestAttemptTiming(task, attemptIndex, attemptStart)
       recordRetryErrorCount(task)
-      if (
-        (isAttemptToFixTest || isEarlyFlakeDetectionTestAttempt || isQuarantinedTest) &&
-        attemptIndex === getFinalAttemptIndex(task)
-      ) {
+      if (isEarlyFlakeDetectionTestAttempt || isQuarantinedTest ||
+        (isAttemptToFixTest && attemptIndex === getFinalAttemptIndex(task))) {
         if (isAttemptToFixTest || isEarlyFlakeDetectionTestAttempt) {
-          recordTestOptimizationStatus(task, attemptIndex, true)
+          recordTestOptimizationStatus(task, attemptIndex, attemptIndex === getFinalAttemptIndex(task))
         }
-        switchQuarantinedFinalFailure(task, attemptIndex)
+        switchQuarantinedFinalFailure(task)
       }
       finishRumCorrelation(task, attemptIndex)
     })
@@ -134,7 +132,7 @@ if (isNoWorkerInitActive) {
       recordTestOptimizationStatus(task, attemptIndex)
     }
     if (!restoredEarlyFlakeDetectionResult) {
-      switchQuarantinedFinalFailure(task, attemptIndex)
+      switchQuarantinedFinalFailure(task)
     }
   })
 }
@@ -433,7 +431,10 @@ function recordEarlyFlakeDetectionStatus (task, attemptIndex, onlyIfNewErrors) {
     return
   }
 
-  if (!earlyFlakeDetectionRetriesByTask.has(task)) {
+  // onTestFinished runs before aroundEach fixture teardown. Select the budget
+  // when the next attempt records the completed attempt instead.
+  const isCompletedAttempt = attemptIndex < task.meta.__ddTestOptCurrentAttemptIndex
+  if (isCompletedAttempt && !earlyFlakeDetectionRetriesByTask.has(task)) {
     const retryCount = getEarlyFlakeDetectionRetryCount(task)
     earlyFlakeDetectionRetriesByTask.set(task, retryCount)
     task.repeats = retryCount
@@ -452,9 +453,15 @@ function recordEarlyFlakeDetectionStatus (task, attemptIndex, onlyIfNewErrors) {
   )
   task.meta.__ddTestOptEfdErrorCounts[attemptIndex] = task.result?.errors?.length || 0
 
-  if (attemptIndex === getEarlyFlakeDetectionRetryCountForTask(task) &&
+  // Vitest 5.0.3 retains failures across repeats. Defer EFD's overall failure until
+  // the last attempt, while keeping each attempt's actual outcome in the metadata.
+  if (attemptIndex < getEarlyFlakeDetectionRetryCountForTask(task) ||
     task.meta.__ddTestOptEfdStatuses.includes('pass')) {
     task.result.state = 'pass'
+  } else if (isCompletedAttempt) {
+    // A zero retry budget cancels repeats after we suppressed the initial failure.
+    task.result.state = 'fail'
+    markQuarantinedFailure(task)
   }
 }
 
@@ -525,7 +532,7 @@ function wrapRetryCondition (task) {
         shouldRetry = condition(error)
       }
 
-      if (!shouldRetry && (task.result?.repeatCount || 0) >= (task.repeats || 0)) {
+      if (!shouldRetry) {
         const attemptIndex = task.meta.__ddTestOptCurrentAttemptIndex
         recordTestOptimizationStatus(task, attemptIndex)
         markQuarantinedFailure(task)
@@ -579,7 +586,7 @@ function getFinalAttemptIndex (task) {
   return attemptIndex + retriesRemaining + (repeatsRemaining * (retryLimit + 1))
 }
 
-function switchQuarantinedFinalFailure (task, attemptIndex) {
+function switchQuarantinedFinalFailure (task) {
   const testSuite = getTestSuite(task)
   const testName = getTestName(task)
   if (
@@ -590,7 +597,10 @@ function switchQuarantinedFinalFailure (task, attemptIndex) {
     return
   }
 
-  if (attemptIndex < getFinalAttemptIndex(task)) {
+  // Finish the retries in this repetition before suppressing its failure. A later
+  // repetition cannot undo a failure that Vitest has already aggregated.
+  const retryAttemptIndex = retryAttemptIndexByTask.get(task)?.index || 0
+  if (retryAttemptIndex < getRetryLimit(task)) {
     return
   }
 

package/index.d.ts

@@ -3,6 +3,61 @@ import { LookupFunction } from 'net';
 import * as opentracing from "opentracing";
 import * as otel from "@opentelemetry/api";
 
+declare const baseEvaluatorBrand: unique symbol
+declare const baseSummaryEvaluatorBrand: unique symbol
+
+declare const EvaluatorContext: {
+  new (options: {
+    inputData: tracer.llmobs.JSONType
+    outputData: tracer.llmobs.JSONType
+    expectedOutput?: tracer.llmobs.JSONType
+    metadata?: Record<string, tracer.llmobs.JSONType>
+    spanId?: string
+    traceId?: string
+  }): tracer.llmobs.EvaluatorContext
+}
+
+declare const SummaryEvaluatorContext: {
+  new (options: {
+    inputs: tracer.llmobs.JSONType[]
+    outputs: tracer.llmobs.JSONType[]
+    expectedOutputs: tracer.llmobs.JSONType[]
+    evaluationResults: Record<string, tracer.llmobs.JSONType[]>
+    metadata?: Array<Record<string, tracer.llmobs.JSONType>>
+  }): tracer.llmobs.SummaryEvaluatorContext
+}
+
+declare const EvaluatorResult: {
+  new (value: tracer.llmobs.JSONType, options?: tracer.llmobs.EvaluatorResultOptions): tracer.llmobs.EvaluatorResult
+}
+
+declare const MultiEvaluatorResult: {
+  new (values: Record<string, tracer.llmobs.JSONType | tracer.llmobs.EvaluatorResult>, prefix?: boolean): tracer.llmobs.MultiEvaluatorResult
+}
+
+declare const BaseEvaluator: {
+  new (name?: string): tracer.llmobs.BaseEvaluator
+}
+
+declare const BaseSummaryEvaluator: {
+  new (name?: string): tracer.llmobs.BaseSummaryEvaluator
+}
+
+declare const RemoteEvaluatorError: {
+  new (message: string, options?: {
+    status?: string
+    backendError?: Record<string, tracer.llmobs.JSONType>
+  }): tracer.llmobs.RemoteEvaluatorError
+}
+
+declare const RemoteEvaluator: {
+  new (options: {
+    evalName: string
+    transformFn?: (context: tracer.llmobs.EvaluatorContext) => Record<string, tracer.llmobs.JSONType>
+  }): tracer.llmobs.RemoteEvaluator
+}
+
+
 /**
  * Tracer is the entry-point of the Datadog tracing implementation.
  */
@@ -162,6 +217,7 @@ interface Tracer extends opentracing.Tracer {
    *
    * @env DD_FEATURE_FLAGS_ENABLED
    * @env DD_FEATURE_FLAGS_CONFIGURATION_SOURCE
+   * @env DD_FLAGGING_EVALUATION_COUNTS_ENABLED
    * @beta This feature is in preview and not ready for production use
    */
   openfeature: tracer.OpenFeatureProvider;
@@ -1357,6 +1413,16 @@ declare namespace tracer {
        */
       captureTimeoutMs?: number
 
+      /**
+       * Time budget in milliseconds for evaluating a probe's condition, log message template and capture expressions.
+       * An evaluation that exceeds the budget is reported as an evaluation error and the probe is not evaluated again
+       * for a while.
+       * @default 50
+       * @env DD_DYNAMIC_INSTRUMENTATION_EVALUATION_TIMEOUT_MS
+       * Programmatic configuration takes precedence over the environment variables listed above.
+       */
+      evaluationTimeoutMs?: number
+
       /**
        * Interval in seconds between uploads of probe data.
        * @default 1
@@ -2137,8 +2203,9 @@ declare namespace tracer {
       /**
        * Whether to capture LLM Observability spans for this integration. When set to `false`,
        * the integration keeps emitting APM spans and propagating trace context, but no LLM
-       * Observability spans are produced. Useful when another integration already captures the
-       * same operation and the payloads would otherwise be stored twice.
+       * Observability spans and no basic `gen_ai.*` APM tags are produced. Useful when another
+       * integration already captures the same operation and the payloads would otherwise be
+       * stored twice.
        * @default true
        */
       llmobs?: boolean;
@@ -4248,6 +4315,74 @@ declare namespace tracer {
 
     type ReadonlyJSONType = string | number | boolean | null | ReadonlyArray<ReadonlyJSONType> | { readonly [key: string]: ReadonlyJSONType }
 
+    /** Context passed to a record-level class evaluator. */
+    interface EvaluatorContext {
+      inputData: JSONType
+      outputData: JSONType
+      expectedOutput?: JSONType
+      metadata: Record<string, JSONType>
+      spanId?: string
+      traceId?: string
+    }
+
+    /** Context passed to a summary class evaluator. */
+    interface SummaryEvaluatorContext {
+      inputs: JSONType[]
+      outputs: JSONType[]
+      expectedOutputs: JSONType[]
+      evaluationResults: Record<string, JSONType[]>
+      metadata: Array<Record<string, JSONType>>
+    }
+
+    interface EvaluatorResultOptions {
+      reasoning?: string
+      assessment?: 'pass' | 'fail'
+      metadata?: Record<string, JSONType>
+      tags?: Record<string, JSONType>
+    }
+
+    /** A metric value with optional evaluation details. */
+    interface EvaluatorResult {
+      value: JSONType
+      reasoning?: string
+      assessment?: 'pass' | 'fail'
+      metadata?: Record<string, JSONType>
+      tags?: Record<string, JSONType>
+    }
+
+    /** A result that emits several named metrics from one evaluator invocation. */
+    interface MultiEvaluatorResult {
+      values: Record<string, JSONType | EvaluatorResult>
+      prefix: boolean
+    }
+
+    /** Error returned by a managed evaluator configured in Datadog. */
+    interface RemoteEvaluatorError extends Error {
+      status: string
+      backendError: Record<string, JSONType>
+    }
+
+    /** Evaluator that references an LLM-as-a-judge evaluator configured in Datadog. */
+    interface RemoteEvaluator extends BaseEvaluator {}
+    interface ExperimentSummaryEvaluation extends EvaluatorResultOptions {
+      value: any
+      error: string | null
+    }
+
+    /** Base class for reusable synchronous or asynchronous record-level evaluators. */
+    interface BaseEvaluator {
+      readonly [baseEvaluatorBrand]: never
+      name: string
+      evaluate (context: EvaluatorContext): JSONType | EvaluatorResult | MultiEvaluatorResult | Promise<JSONType | EvaluatorResult | MultiEvaluatorResult>
+    }
+
+    /** Base class for reusable synchronous or asynchronous summary evaluators. */
+    interface BaseSummaryEvaluator {
+      readonly [baseSummaryEvaluatorBrand]: never
+      name: string
+      evaluate (context: SummaryEvaluatorContext): JSONType | EvaluatorResult | MultiEvaluatorResult | Promise<JSONType | EvaluatorResult | MultiEvaluatorResult>
+    }
+
     /**
      * A task run over each dataset record during an experiment.
      */
@@ -4257,26 +4392,25 @@ declare namespace tracer {
       metadata?: Record<string, JSONType>
     ) => JSONType | Promise<JSONType>
 
-    /**
-     * Scores a single task output. The return type selects the metric:
-     * `boolean` -> boolean, `number` -> score, `string` -> categorical, anything else -> json.
-     */
-    type ExperimentEvaluator = (
+    /** Scores a single task output. */
+    type ExperimentEvaluatorFunction = (
       input: JSONType,
       output: JSONType,
       expectedOutput: JSONType
-    ) => JSONType | Promise<JSONType>
+    ) => JSONType | EvaluatorResult | MultiEvaluatorResult | Promise<JSONType | EvaluatorResult | MultiEvaluatorResult>
 
-    /**
-     * Scores all rows in an experiment run and emits a summary metric.
-     */
-    type ExperimentSummaryEvaluator = (
-      inputs: any[],
-      outputs: any[],
-      expectedOutputs: any[],
-      evaluatorResults: Record<string, any[]>,
-      metadata?: Array<Record<string, any>>
-    ) => any | Promise<any>
+    type ExperimentEvaluator = ExperimentEvaluatorFunction | BaseEvaluator
+
+    /** Scores all rows in an experiment run and emits a summary metric. */
+    type ExperimentSummaryEvaluatorFunction = (
+      inputs: JSONType[],
+      outputs: JSONType[],
+      expectedOutputs: JSONType[],
+      evaluatorResults: Record<string, JSONType[]>,
+      metadata?: Array<Record<string, JSONType>>
+    ) => JSONType | EvaluatorResult | MultiEvaluatorResult | Promise<JSONType | EvaluatorResult | MultiEvaluatorResult>
+
+    type ExperimentSummaryEvaluator = ExperimentSummaryEvaluatorFunction | BaseSummaryEvaluator
 
     interface DatasetRecord {
       id: string | null
@@ -4307,9 +4441,9 @@ declare namespace tracer {
       task: ExperimentTask
       /** Override the configured project for this experiment. */
       projectName?: string
-      /** Evaluators keyed by metric label, or named functions. */
+      /** Evaluators keyed by metric label, or named functions or class instances. */
       evaluators?: Record<string, ExperimentEvaluator> | ExperimentEvaluator[]
-      /** Summary evaluators keyed by metric label, or named functions. */
+      /** Summary evaluators keyed by metric label, or named functions or class instances. */
       summaryEvaluators?: Record<string, ExperimentSummaryEvaluator> | ExperimentSummaryEvaluator[]
       description?: string
       config?: Record<string, JSONType>
@@ -4365,7 +4499,7 @@ declare namespace tracer {
       /** Whether this run had a task, row-evaluator, or summary-evaluator error. */
       hasError: boolean
       rows: ExperimentResultRow[]
-      summaryEvaluations: Record<string, { value: any, error: string | null }>
+      summaryEvaluations: Record<string, ExperimentSummaryEvaluation>
     }
 
     interface ExperimentResult {
@@ -4373,7 +4507,7 @@ declare namespace tracer {
       /** Rows from the first run, kept as a compatibility alias. */
       rows: ExperimentResultRow[]
       /** Summary evaluator results from the first run, kept as a compatibility alias. */
-      summaryEvaluations: Record<string, { value: any, error: string | null }>
+      summaryEvaluations: Record<string, ExperimentSummaryEvaluation>
       /** All experiment runs. */
       runs: ExperimentRun[]
       /** Dashboard URL for the experiment. */
@@ -4508,6 +4642,14 @@ declare namespace tracer {
     }
 
     interface Experiments {
+      BaseEvaluator: typeof BaseEvaluator
+      BaseSummaryEvaluator: typeof BaseSummaryEvaluator
+      EvaluatorContext: typeof EvaluatorContext
+      SummaryEvaluatorContext: typeof SummaryEvaluatorContext
+      EvaluatorResult: typeof EvaluatorResult
+      MultiEvaluatorResult: typeof MultiEvaluatorResult
+      RemoteEvaluator: typeof RemoteEvaluator
+      RemoteEvaluatorError: typeof RemoteEvaluatorError
       /** Create a local dataset buffer; pushed on the first experiment run. */
       createDataset (name: string, description?: string): Dataset
       createDataset (name: string, options?: CreateDatasetOptions): Dataset
@@ -4528,12 +4670,12 @@ declare namespace tracer {
       /**
        * The input content associated with the span.
        */
-      input: { content: string, role?: string }[]
+      input: { content: JSONType, role?: string }[]
 
       /**
        * The output content associated with the span.
        */
-      output: { content: string, role?: string }[]
+      output: { content: JSONType, role?: string }[]
 
       /**
        * Get a tag from the span.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.129.0",
+  "version": "5.131.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -190,7 +190,7 @@
   "optionalDependencies": {
     "@datadog/libdatadog": "^0.21.0",
     "@datadog/libdatadog-extras": "^0.21.0",
-    "@datadog/native-appsec": "11.0.2",
+    "@datadog/native-appsec": "11.0.3",
     "@datadog/native-iast-taint-tracking": "4.2.1",
     "@datadog/native-metrics": "4.0.0",
     "@datadog/pprof": "5.19.0",
@@ -206,7 +206,7 @@
     "@eslint/eslintrc": "^3.3.7",
     "@eslint/js": "^10.0.1",
     "@eslint/plugin-kit": "^0.7.3",
-    "@datadog/openfeature-node-server": "2.3.0",
+    "@datadog/openfeature-node-server": "2.4.0",
     "@msgpack/msgpack": "^3.1.3",
     "@openfeature/core": "^1.12.0",
     "@openfeature/server-sdk": "~1.23.0",
@@ -222,14 +222,14 @@
     "bun": "1.4.2",
     "c8": "^12.0.0",
     "codeowners-audit": "^2.9.0",
-    "eslint": "^10.10.0",
+    "eslint": "^10.11.0",
     "eslint-plugin-cypress": "^7.0.2",
     "eslint-plugin-import-x": "^4.16.2",
-    "eslint-plugin-jsdoc": "^64.5.2",
+    "eslint-plugin-jsdoc": "^64.5.4",
     "eslint-plugin-mocha": "^12.0.2",
     "eslint-plugin-n": "^18.3.0",
     "eslint-plugin-promise": "^7.3.0",
-    "eslint-plugin-regexp": "^3.3.0",
+    "eslint-plugin-regexp": "^3.3.1",
     "eslint-plugin-sonarjs": "^4.2.1",
     "eslint-plugin-unicorn": "^74.0.0",
     "express": "^5.1.0",
@@ -251,7 +251,7 @@
     "node-preload": "^0.2.1",
     "nyc": "^18.0.0",
     "octokit": "^5.0.3",
-    "p-limit": "^7.3.2",
+    "p-limit": "^7.3.3",
     "proxyquire": "^2.1.3",
     "retry": "^0.13.1",
     "semifies": "^1.0.0",

package/packages/datadog-esbuild/index.js

@@ -165,8 +165,6 @@ ${build.initialOptions.banner.js}`
     log.warn('No git metadata available - skipping injection')
   }
 
-  // first time is intercepted, proxy should be created, next time the original should be loaded
-  const interceptedESMModules = new Set()
   let resolver
 
   build.onEnd(async () => {
@@ -217,11 +215,18 @@ ${build.initialOptions.banner.js}`
 
     const internal = builtins.has(args.path)
 
+    // Only the generated wrapper module, and the real module importing itself, must reach the real module unwrapped.
+    // Every other importer must get the wrapper regardless of whether it has already been loaded: onLoad runs
+    // concurrently with onResolve, so tracking loaded modules makes which importer sees the wrapper depend on timing,
+    // leaving some bindings uninstrumented. Routing a self-import to the wrapper would create a wrapper -> original ->
+    // wrapper cycle that can hit the wrapper's exports in their temporal dead zone.
+    const isInterceptedImporter = args.importer.endsWith(ESM_INTERCEPTED_SUFFIX) || args.importer === fullPathToModule
+
     if (args.namespace === 'file' && (
       modulesOfInterest.has(args.path) || modulesOfInterest.has(`${extracted.pkg}/${extracted.path}`))
     ) {
       // Internal module like http/fs is imported and the build output is ESM
-      if (internal && args.kind === 'import-statement' && esmBuild && !interceptedESMModules.has(fullPathToModule)) {
+      if (internal && args.kind === 'import-statement' && esmBuild && !isInterceptedImporter) {
         fullPathToModule = `${INTERNAL_ESM_INTERCEPTED_PREFIX}${fullPathToModule}${ESM_INTERCEPTED_SUFFIX}`
 
         return {
@@ -263,7 +268,7 @@ ${build.initialOptions.banner.js}`
         const packageJson = JSON.parse(fs.readFileSync(/** @type {string} */(pathToPackageJson)).toString())
 
         const isESM = isESMFile(fullPathToModule, pathToPackageJson, packageJson)
-        if (isESM && !interceptedESMModules.has(fullPathToModule)) {
+        if (isESM && !isInterceptedImporter) {
           fullPathToModule += ESM_INTERCEPTED_SUFFIX
         }
 
@@ -322,8 +327,6 @@ ${build.initialOptions.banner.js}`
             args.path = args.path.slice(INTERNAL_ESM_INTERCEPTED_PREFIX.length)
           }
 
-          interceptedESMModules.add(args.path)
-
           resolver ??= createEsmResolver()
           const setters = await processModule({
             path: args.path,

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

@@ -194,6 +194,32 @@ for (const hook of getHooks('ai').values()) {
       },
     })
 
+    tracingChannel('orchestrion:ai:includeRuntimeContext').subscribe({
+      start (ctx) {
+        const options = ctx.arguments[0]
+        const runtimeContext = options?.runtimeContext
+        const telemetry = options?.telemetry ?? options?.experimental_telemetry
+
+        if (!runtimeContext || typeof runtimeContext !== 'object' || telemetry?.isEnabled === false) return
+
+        const keys = Object.keys(runtimeContext)
+        if (!keys.length) return
+
+        const includeRuntimeContext = { ...telemetry?.includeRuntimeContext }
+        for (const key of keys) {
+          if (includeRuntimeContext[key] === undefined) includeRuntimeContext[key] = true
+        }
+
+        ctx.arguments[0] = {
+          ...options,
+          telemetry: {
+            ...telemetry,
+            includeRuntimeContext,
+          },
+        }
+      },
+    })
+
     // resolveLanguageModel is called by all LLM entry points (generateText, streamText,
     // generateObject, streamObject)
     tracingChannel('orchestrion:ai:resolveLanguageModel').subscribe({

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

@@ -124,13 +124,48 @@ function wrapStreamIterator (iterator, ctx) {
   }
 }
 
+/**
+ * Gives the SDK a detached copy of the response to decode, leaving the body the caller can still
+ * read through `asResponse()` untouched. The bytes are buffered instead of streamed from a live
+ * clone, and the controller is replaced, because the SDK cancels its reader and aborts its
+ * controller whenever a stream ends early: that abort would kill the caller's request, and on a
+ * cloned body that cancel blocks until the other branch is read, which the caller cannot do while
+ * it is still waiting for this parse.
+ *
+ * Any failure falls back to the original props and tells the wrapper to skip inspection, leaving
+ * the SDK to behave as it does untraced.
+ *
+ * @param {{response: Response}} props
+ * @param {() => void} onFailure
+ * @returns {object|Promise<object>}
+ */
+function detachResponse (props, onFailure) {
+  const { status, statusText, headers } = props.response
+  try {
+    return props.response.clone().arrayBuffer()
+      .then(body => ({
+        ...props,
+        response: new Response(body, { status, statusText, headers }),
+        controller: new AbortController(),
+      }))
+      .catch(() => {
+        onFailure()
+        return props
+      })
+  } catch {
+    onFailure()
+    return props
+  }
+}
+
 function wrapCreate (create) {
   return function (...args) {
     const stream = args[0]?.stream
-    const preparing = !stream && messagesPrepareChannel.hasSubscribers
-    const intercepting = !stream && messagesInterceptChannel.hasSubscribers
+    const tracing = anthropicTracingChannel.start.hasSubscribers
+    const preparing = messagesPrepareChannel.hasSubscribers
+    const intercepting = messagesInterceptChannel.hasSubscribers
 
-    if (!anthropicTracingChannel.start.hasSubscribers && !preparing && !intercepting) {
+    if (!tracing && !preparing && !intercepting) {
       return create.apply(this, args)
     }
 
@@ -160,23 +195,60 @@ function wrapCreate (create) {
 
       let parseResult
       let wrappedResponse
+      // Set around a `parse()` whose body a raw-response reader also holds, so the SDK decodes a
+      // copy and leaves that body to the caller. Plain streaming has no second reader and copies
+      // nothing.
+      let detach = false
 
+      // These helpers live on each returned APIPromise, so there is no module export for
+      // Orchestrion to replace; wrap this instance instead.
       shimmer.wrap(apiPromise, 'parse', parse => function (...parseArgs) {
         if (parseResult) return parseResult
 
-        parseResult = heldUntil(parse.apply(this, parseArgs), interceptCtx?.beforeResult?.())
+        let detachmentFailed = false
+        const responsePromise = detach ? this.responsePromise : undefined
+        if (responsePromise) {
+          this.responsePromise = responsePromise.then(props => detachResponse(props, () => {
+            detachmentFailed = true
+          }))
+        }
+
+        let result
+        try {
+          result = parse.apply(this, parseArgs)
+        } finally {
+          if (responsePromise) this.responsePromise = responsePromise
+        }
+
+        const onResult = interceptCtx?.onResult
+        parseResult = heldUntil(result, interceptCtx?.beforeResult?.())
           .then(response => {
             if (stream) {
-              shimmer.wrap(response, Symbol.asyncIterator, iterator => wrapStreamIterator(iterator, ctx))
-              return response
+              if (!onResult || detachmentFailed) {
+                if (tracing) {
+                  shimmer.wrap(response, Symbol.asyncIterator, iterator => wrapStreamIterator(iterator, ctx))
+                }
+                return response
+              }
+
+              return Promise.resolve(onResult(response)).then(deliveredResponse => {
+                if (tracing) {
+                  shimmer.wrap(
+                    deliveredResponse,
+                    Symbol.asyncIterator,
+                    iterator => wrapStreamIterator(iterator, ctx)
+                  )
+                }
+                return deliveredResponse
+              })
             }
 
-            if (!interceptCtx?.onResult) {
+            if (!onResult) {
               finish(ctx, response)
               return response
             }
 
-            return Promise.resolve(interceptCtx.onResult(response)).then(deliveredResponse => {
+            return Promise.resolve(onResult(response)).then(deliveredResponse => {
               finish(ctx, response)
               return deliveredResponse
             })
@@ -190,9 +262,26 @@ function wrapCreate (create) {
         shimmer.wrap(apiPromise, 'asResponse', origAsResponse => function (...asResponseArgs) {
           return heldUntil(origAsResponse.apply(this, asResponseArgs), interceptCtx?.beforeResult?.())
             .then(response => {
+              if (stream) {
+                // A caller holding the parsed stream closes the span as it drains it. When only
+                // the raw body is read, decode the stream here so it is still evaluated.
+                if (!interceptCtx?.onResult) return response
+                if (parseResult) return parseResult.then(() => response)
+
+                detach = true
+                try {
+                  return apiPromise.parse().then(() => {
+                    finish(ctx)
+                    return response
+                  })
+                } finally {
+                  detach = false
+                }
+              }
+
               // Wrap json()/text()/clone() so the span still closes on the raw-response path,
               // and not twice for the same response.
-              if (!stream && wrappedResponse !== response) {
+              if (wrappedResponse !== response) {
                 wrappedResponse = response
                 wrapRawResponse(response, ctx, interceptCtx)
               }
@@ -202,6 +291,19 @@ function wrapCreate (create) {
         })
       }
 
+      // `withResponse()` is the one SDK call that hands out the raw response *and* the parsed
+      // stream; it invokes `parse()` synchronously, so the flag only has to outlive that call.
+      if (stream && interceptCtx?.onResult && typeof apiPromise.withResponse === 'function') {
+        shimmer.wrap(apiPromise, 'withResponse', withResponse => function (...withResponseArgs) {
+          detach = true
+          try {
+            return withResponse.apply(this, withResponseArgs)
+          } finally {
+            detach = false
+          }
+        })
+      }
+
       anthropicTracingChannel.end.publish(ctx)
 
       return apiPromise