fix: Preserve original return value in wrapPromise to avoid losing Promise subclasses

When the instrumented function returns a Promise subclass (e.g. Anthropic
SDK's APIPromise which has a .withResponse() method), the previous
wrapPromise template returned `promise.then(cb)` — which calls the
subclass's overridden .then() and returns a plain native Promise, losing
any subclass-specific methods on the original.

Fix by calling .then() as a side effect for publishing asyncStart/asyncEnd
channel events, then returning the original promise unchanged. This ensures
the caller receives the same type that the wrapped function originally
returned, preserving any subclass API.

Add a test (promise_subclass) to cover this case.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: Qard

lib/transforms.js

@@ -394,21 +394,20 @@ function wrapPromise (state, node) {
             __apm$ctx.result = promise; 
             return promise;
           }
-          return promise.then(
+          promise.then(
             result => {
               __apm$ctx.result = result;
               ${channelVariable}.asyncStart.publish(__apm$ctx);
               ${channelVariable}.asyncEnd.publish(__apm$ctx);
-              return result;
             },
             err => {
               __apm$ctx.error = err;
               ${channelVariable}.error.publish(__apm$ctx);
               ${channelVariable}.asyncStart.publish(__apm$ctx);
               ${channelVariable}.asyncEnd.publish(__apm$ctx);
-              throw err;
             }
           );
+          return promise;
         } catch (err) {
           __apm$ctx.error = err;
           ${channelVariable}.error.publish(__apm$ctx);

tests/promise_subclass/mod.js

@@ -0,0 +1,26 @@
+/**
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2025 Datadog, Inc.
+ **/
+
+/**
+ * A Promise subclass with an extra method, similar to Anthropic SDK's APIPromise.
+ * The instrumented wrapper must preserve the original return type so callers
+ * can still access subclass-specific methods like `.withResponse()`.
+ *
+ * NOTE: This function is intentionally NOT async. Async functions always wrap
+ * their return value in a native Promise, losing the subclass type. The real-
+ * world scenario (e.g. Anthropic SDK's APIPromise) uses a non-async function
+ * that explicitly constructs and returns a Promise subclass instance.
+ */
+class ExtendedPromise extends Promise {
+  withResponse () {
+    return this.then(result => ({ data: result, response: { status: 200 } }))
+  }
+}
+
+function fetch (url) {
+  return new ExtendedPromise(resolve => resolve(42))
+}
+
+module.exports = { fetch }

tests/promise_subclass/test.js

@@ -0,0 +1,21 @@
+/**
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2025 Datadog, Inc.
+ **/
+const { fetch } = require('./instrumented.js')
+const { assert, getContext } = require('../common/preamble.js')
+const context = getContext('orchestrion:undici:fetch_subclass');
+(async () => {
+  const promise = fetch('https://example.com')
+  // The instrumented wrapper must return the original promise, not promise.then(),
+  // so subclass methods like withResponse() remain accessible.
+  assert.strictEqual(typeof promise.withResponse, 'function', 'withResponse should be available on the returned promise')
+  const { data } = await promise.withResponse()
+  assert.strictEqual(data, 42)
+  assert.deepStrictEqual(context, {
+    start: true,
+    end: true,
+    asyncStart: 42,
+    asyncEnd: 42
+  })
+})()

tests/tests.test.mjs

@@ -518,6 +518,18 @@ describe('wrap_promise_non_promise', () => {
   })
 })
 
+describe('promise_subclass', () => {
+  test('instruments async function and preserves original Promise subclass return type', () => {
+    runTest('promise_subclass', [
+      {
+        channelName: 'fetch_subclass',
+        module: { name: TEST_MODULE_NAME, versionRange: '>=0.0.1', filePath: TEST_MODULE_PATH },
+        functionQuery: { functionName: 'fetch', kind: 'Async' }
+      }
+    ])
+  })
+})
+
 describe('IIFE with class', () => {
   test('instruments a class within a IIFE, variable same name as class', () => {
     runTest('iife_nested_class', [