fix(core): Preserve OpenAI APIPromise methods like withResponse() by Sai-Tom · Pull Request #18402 · getsentry/sentry-javascript

Sai-Tom · 2025-12-04T09:59:09Z

Summary

The OpenAI SDK returns APIPromise objects with additional methods like .withResponse().
The previous async/await instrumentation converted these to regular Promises, losing those methods.

This PR uses Proxy + handleCallbackErrors pattern (matching anthropic-ai) to preserve the original return type.

Changes

Use Proxy instead of async function wrapper
Use handleCallbackErrors for non-streaming responses (preserves Promise subclass)
Add handleStreamingError helper for consistency
Add tests for APIPromise.withResponse() preservation

Test Plan

yarn build:dev passes
yarn test passes
yarn lint passes
Added tests for APIPromise preservation

The OpenAI SDK returns APIPromise objects with additional methods like .withResponse(). The previous async/await instrumentation converted these to regular Promises, losing those methods. Use Proxy + handleCallbackErrors pattern (matching anthropic-ai) to preserve the original return type.

- Use startInactiveSpan instead of startSpan/startSpanManual because they internally use handleCallbackErrors which calls .then() on Promises, creating a new instance and losing APIPromise methods - Add try-catch for synchronous exceptions - Add tests for error handling (sync throw + async reject) - Update tests to match real OpenAI SDK behavior"

- Use startInactiveSpan instead of startSpan/startSpanManual because they internally use handleCallbackErrors which calls .then() on Promises, creating a new instance and losing APIPromise methods - Add try-catch for synchronous exceptions - Use .finally() to ensure span always ends even if attribute processing throws - Add tests for error handling (sync throw + async reject) - Update tests to match real OpenAI SDK behavior

Sign in to view

+ const span = startInactiveSpan({
+ name: `${operationName} ${model}`,
+ op: getSpanOperation(methodPath),
+ attributes: requestAttributes as Record<string, SpanAttributeValue>,
+ });
+
+ if (options.recordInputs && params) {
+ addRequestAttributes(span, params);
+ }


RulaKhaled

Thank you for contributing! I have a question

RulaKhaled · 2025-12-09T13:53:18Z

+ // We use startInactiveSpan instead of startSpan/startSpanManual because those
+ // internally use handleCallbackErrors which calls .then() on Promises, creating
+ // a new Promise instance and losing APIPromise's custom methods like .withResponse().
+ const span = startInactiveSpan({


Have you tried using start span here?
I understand that your purpose here is to use handleCallbackErrors and handle promises, you can still achieve this with start span, and as long as we didn't end the span in a different scope/context, it should work fine.

RulaKhaled · 2026-02-03T09:38:42Z

Closing in favor of #19122

Sai-Tom · 2025-12-04T09:59:09Z

Summary

The OpenAI SDK returns APIPromise objects with additional methods like .withResponse().
The previous async/await instrumentation converted these to regular Promises, losing those methods.

This PR uses Proxy + handleCallbackErrors pattern (matching anthropic-ai) to preserve the original return type.

Changes

Use Proxy instead of async function wrapper
Use handleCallbackErrors for non-streaming responses (preserves Promise subclass)
Add handleStreamingError helper for consistency
Add tests for APIPromise.withResponse() preservation

Test Plan

yarn build:dev passes
yarn test passes
yarn lint passes
Added tests for APIPromise preservation

The OpenAI SDK returns APIPromise objects with additional methods like .withResponse(). The previous async/await instrumentation converted these to regular Promises, losing those methods. Use Proxy + handleCallbackErrors pattern (matching anthropic-ai) to preserve the original return type.

- Use startInactiveSpan instead of startSpan/startSpanManual because they internally use handleCallbackErrors which calls .then() on Promises, creating a new instance and losing APIPromise methods - Add try-catch for synchronous exceptions - Add tests for error handling (sync throw + async reject) - Update tests to match real OpenAI SDK behavior"

- Use startInactiveSpan instead of startSpan/startSpanManual because they internally use handleCallbackErrors which calls .then() on Promises, creating a new instance and losing APIPromise methods - Add try-catch for synchronous exceptions - Use .finally() to ensure span always ends even if attribute processing throws - Add tests for error handling (sync throw + async reject) - Update tests to match real OpenAI SDK behavior

Sign in to view

+ const span = startInactiveSpan({
+ name: `${operationName} ${model}`,
+ op: getSpanOperation(methodPath),
+ attributes: requestAttributes as Record<string, SpanAttributeValue>,
+ });
+
+ if (options.recordInputs && params) {
+ addRequestAttributes(span, params);
+ }


RulaKhaled

Thank you for contributing! I have a question

RulaKhaled · 2025-12-09T13:53:18Z

+ // We use startInactiveSpan instead of startSpan/startSpanManual because those
+ // internally use handleCallbackErrors which calls .then() on Promises, creating
+ // a new Promise instance and losing APIPromise's custom methods like .withResponse().
+ const span = startInactiveSpan({


Have you tried using start span here?
I understand that your purpose here is to use handleCallbackErrors and handle promises, you can still achieve this with start span, and as long as we didn't end the span in a different scope/context, it should work fine.

RulaKhaled · 2026-02-03T09:38:42Z

Closing in favor of #19122

Sai-Tom · 2025-12-04T09:59:09Z

Summary

The OpenAI SDK returns APIPromise objects with additional methods like .withResponse().
The previous async/await instrumentation converted these to regular Promises, losing those methods.

This PR uses Proxy + handleCallbackErrors pattern (matching anthropic-ai) to preserve the original return type.

Changes

Use Proxy instead of async function wrapper
Use handleCallbackErrors for non-streaming responses (preserves Promise subclass)
Add handleStreamingError helper for consistency
Add tests for APIPromise.withResponse() preservation

Test Plan

yarn build:dev passes
yarn test passes
yarn lint passes
Added tests for APIPromise preservation

The OpenAI SDK returns APIPromise objects with additional methods like .withResponse(). The previous async/await instrumentation converted these to regular Promises, losing those methods. Use Proxy + handleCallbackErrors pattern (matching anthropic-ai) to preserve the original return type.

- Use startInactiveSpan instead of startSpan/startSpanManual because they internally use handleCallbackErrors which calls .then() on Promises, creating a new instance and losing APIPromise methods - Add try-catch for synchronous exceptions - Add tests for error handling (sync throw + async reject) - Update tests to match real OpenAI SDK behavior"

- Use startInactiveSpan instead of startSpan/startSpanManual because they internally use handleCallbackErrors which calls .then() on Promises, creating a new instance and losing APIPromise methods - Add try-catch for synchronous exceptions - Use .finally() to ensure span always ends even if attribute processing throws - Add tests for error handling (sync throw + async reject) - Update tests to match real OpenAI SDK behavior

Sign in to view

+ const span = startInactiveSpan({
+ name: `${operationName} ${model}`,
+ op: getSpanOperation(methodPath),
+ attributes: requestAttributes as Record<string, SpanAttributeValue>,
+ });
+
+ if (options.recordInputs && params) {
+ addRequestAttributes(span, params);
+ }


RulaKhaled

Thank you for contributing! I have a question

RulaKhaled · 2025-12-09T13:53:18Z

+ // We use startInactiveSpan instead of startSpan/startSpanManual because those
+ // internally use handleCallbackErrors which calls .then() on Promises, creating
+ // a new Promise instance and losing APIPromise's custom methods like .withResponse().
+ const span = startInactiveSpan({


Have you tried using start span here?
I understand that your purpose here is to use handleCallbackErrors and handle promises, you can still achieve this with start span, and as long as we didn't end the span in a different scope/context, it should work fine.

RulaKhaled · 2026-02-03T09:38:42Z

Closing in favor of #19122

Sai-Tom · 2025-12-04T09:59:09Z

Summary

The OpenAI SDK returns APIPromise objects with additional methods like .withResponse().
The previous async/await instrumentation converted these to regular Promises, losing those methods.

This PR uses Proxy + handleCallbackErrors pattern (matching anthropic-ai) to preserve the original return type.

Changes

Use Proxy instead of async function wrapper
Use handleCallbackErrors for non-streaming responses (preserves Promise subclass)
Add handleStreamingError helper for consistency
Add tests for APIPromise.withResponse() preservation

Test Plan

yarn build:dev passes
yarn test passes
yarn lint passes
Added tests for APIPromise preservation

The OpenAI SDK returns APIPromise objects with additional methods like .withResponse(). The previous async/await instrumentation converted these to regular Promises, losing those methods. Use Proxy + handleCallbackErrors pattern (matching anthropic-ai) to preserve the original return type.

- Use startInactiveSpan instead of startSpan/startSpanManual because they internally use handleCallbackErrors which calls .then() on Promises, creating a new instance and losing APIPromise methods - Add try-catch for synchronous exceptions - Add tests for error handling (sync throw + async reject) - Update tests to match real OpenAI SDK behavior"

- Use startInactiveSpan instead of startSpan/startSpanManual because they internally use handleCallbackErrors which calls .then() on Promises, creating a new instance and losing APIPromise methods - Add try-catch for synchronous exceptions - Use .finally() to ensure span always ends even if attribute processing throws - Add tests for error handling (sync throw + async reject) - Update tests to match real OpenAI SDK behavior

Sign in to view

+ const span = startInactiveSpan({
+ name: `${operationName} ${model}`,
+ op: getSpanOperation(methodPath),
+ attributes: requestAttributes as Record<string, SpanAttributeValue>,
+ });
+
+ if (options.recordInputs && params) {
+ addRequestAttributes(span, params);
+ }


RulaKhaled

Thank you for contributing! I have a question

RulaKhaled · 2025-12-09T13:53:18Z

+ // We use startInactiveSpan instead of startSpan/startSpanManual because those
+ // internally use handleCallbackErrors which calls .then() on Promises, creating
+ // a new Promise instance and losing APIPromise's custom methods like .withResponse().
+ const span = startInactiveSpan({


Have you tried using start span here?
I understand that your purpose here is to use handleCallbackErrors and handle promises, you can still achieve this with start span, and as long as we didn't end the span in a different scope/context, it should work fine.

RulaKhaled · 2026-02-03T09:38:42Z

Closing in favor of #19122

Sai-Tom · 2025-12-04T09:59:09Z

Summary

The OpenAI SDK returns APIPromise objects with additional methods like .withResponse().
The previous async/await instrumentation converted these to regular Promises, losing those methods.

This PR uses Proxy + handleCallbackErrors pattern (matching anthropic-ai) to preserve the original return type.

Changes

Use Proxy instead of async function wrapper
Use handleCallbackErrors for non-streaming responses (preserves Promise subclass)
Add handleStreamingError helper for consistency
Add tests for APIPromise.withResponse() preservation

Test Plan

yarn build:dev passes
yarn test passes
yarn lint passes
Added tests for APIPromise preservation

The OpenAI SDK returns APIPromise objects with additional methods like .withResponse(). The previous async/await instrumentation converted these to regular Promises, losing those methods. Use Proxy + handleCallbackErrors pattern (matching anthropic-ai) to preserve the original return type.

- Use startInactiveSpan instead of startSpan/startSpanManual because they internally use handleCallbackErrors which calls .then() on Promises, creating a new instance and losing APIPromise methods - Add try-catch for synchronous exceptions - Add tests for error handling (sync throw + async reject) - Update tests to match real OpenAI SDK behavior"

- Use startInactiveSpan instead of startSpan/startSpanManual because they internally use handleCallbackErrors which calls .then() on Promises, creating a new instance and losing APIPromise methods - Add try-catch for synchronous exceptions - Use .finally() to ensure span always ends even if attribute processing throws - Add tests for error handling (sync throw + async reject) - Update tests to match real OpenAI SDK behavior

Sign in to view

+ const span = startInactiveSpan({
+ name: `${operationName} ${model}`,
+ op: getSpanOperation(methodPath),
+ attributes: requestAttributes as Record<string, SpanAttributeValue>,
+ });
+
+ if (options.recordInputs && params) {
+ addRequestAttributes(span, params);
+ }


RulaKhaled

Thank you for contributing! I have a question

RulaKhaled · 2025-12-09T13:53:18Z

+ // We use startInactiveSpan instead of startSpan/startSpanManual because those
+ // internally use handleCallbackErrors which calls .then() on Promises, creating
+ // a new Promise instance and losing APIPromise's custom methods like .withResponse().
+ const span = startInactiveSpan({


Have you tried using start span here?
I understand that your purpose here is to use handleCallbackErrors and handle promises, you can still achieve this with start span, and as long as we didn't end the span in a different scope/context, it should work fine.

RulaKhaled · 2026-02-03T09:38:42Z

Closing in favor of #19122

Sai-Tom · 2025-12-04T09:59:09Z

Summary

The OpenAI SDK returns APIPromise objects with additional methods like .withResponse().
The previous async/await instrumentation converted these to regular Promises, losing those methods.

This PR uses Proxy + handleCallbackErrors pattern (matching anthropic-ai) to preserve the original return type.

Changes

Use Proxy instead of async function wrapper
Use handleCallbackErrors for non-streaming responses (preserves Promise subclass)
Add handleStreamingError helper for consistency
Add tests for APIPromise.withResponse() preservation

Test Plan

yarn build:dev passes
yarn test passes
yarn lint passes
Added tests for APIPromise preservation

The OpenAI SDK returns APIPromise objects with additional methods like .withResponse(). The previous async/await instrumentation converted these to regular Promises, losing those methods. Use Proxy + handleCallbackErrors pattern (matching anthropic-ai) to preserve the original return type.

- Use startInactiveSpan instead of startSpan/startSpanManual because they internally use handleCallbackErrors which calls .then() on Promises, creating a new instance and losing APIPromise methods - Add try-catch for synchronous exceptions - Add tests for error handling (sync throw + async reject) - Update tests to match real OpenAI SDK behavior"

- Use startInactiveSpan instead of startSpan/startSpanManual because they internally use handleCallbackErrors which calls .then() on Promises, creating a new instance and losing APIPromise methods - Add try-catch for synchronous exceptions - Use .finally() to ensure span always ends even if attribute processing throws - Add tests for error handling (sync throw + async reject) - Update tests to match real OpenAI SDK behavior

Sign in to view

+ const span = startInactiveSpan({
+ name: `${operationName} ${model}`,
+ op: getSpanOperation(methodPath),
+ attributes: requestAttributes as Record<string, SpanAttributeValue>,
+ });
+
+ if (options.recordInputs && params) {
+ addRequestAttributes(span, params);
+ }


RulaKhaled

Thank you for contributing! I have a question

RulaKhaled · 2025-12-09T13:53:18Z

+ // We use startInactiveSpan instead of startSpan/startSpanManual because those
+ // internally use handleCallbackErrors which calls .then() on Promises, creating
+ // a new Promise instance and losing APIPromise's custom methods like .withResponse().
+ const span = startInactiveSpan({


Have you tried using start span here?
I understand that your purpose here is to use handleCallbackErrors and handle promises, you can still achieve this with start span, and as long as we didn't end the span in a different scope/context, it should work fine.

RulaKhaled · 2026-02-03T09:38:42Z

Closing in favor of #19122

Sai-Tom · 2025-12-04T09:59:09Z

Summary

The OpenAI SDK returns APIPromise objects with additional methods like .withResponse().
The previous async/await instrumentation converted these to regular Promises, losing those methods.

This PR uses Proxy + handleCallbackErrors pattern (matching anthropic-ai) to preserve the original return type.

Changes

Use Proxy instead of async function wrapper
Use handleCallbackErrors for non-streaming responses (preserves Promise subclass)
Add handleStreamingError helper for consistency
Add tests for APIPromise.withResponse() preservation

Test Plan

yarn build:dev passes
yarn test passes
yarn lint passes
Added tests for APIPromise preservation

The OpenAI SDK returns APIPromise objects with additional methods like .withResponse(). The previous async/await instrumentation converted these to regular Promises, losing those methods. Use Proxy + handleCallbackErrors pattern (matching anthropic-ai) to preserve the original return type.

- Use startInactiveSpan instead of startSpan/startSpanManual because they internally use handleCallbackErrors which calls .then() on Promises, creating a new instance and losing APIPromise methods - Add try-catch for synchronous exceptions - Add tests for error handling (sync throw + async reject) - Update tests to match real OpenAI SDK behavior"

- Use startInactiveSpan instead of startSpan/startSpanManual because they internally use handleCallbackErrors which calls .then() on Promises, creating a new instance and losing APIPromise methods - Add try-catch for synchronous exceptions - Use .finally() to ensure span always ends even if attribute processing throws - Add tests for error handling (sync throw + async reject) - Update tests to match real OpenAI SDK behavior

Sign in to view

+ const span = startInactiveSpan({
+ name: `${operationName} ${model}`,
+ op: getSpanOperation(methodPath),
+ attributes: requestAttributes as Record<string, SpanAttributeValue>,
+ });
+
+ if (options.recordInputs && params) {
+ addRequestAttributes(span, params);
+ }


RulaKhaled

Thank you for contributing! I have a question

RulaKhaled · 2025-12-09T13:53:18Z

+ // We use startInactiveSpan instead of startSpan/startSpanManual because those
+ // internally use handleCallbackErrors which calls .then() on Promises, creating
+ // a new Promise instance and losing APIPromise's custom methods like .withResponse().
+ const span = startInactiveSpan({


Have you tried using start span here?
I understand that your purpose here is to use handleCallbackErrors and handle promises, you can still achieve this with start span, and as long as we didn't end the span in a different scope/context, it should work fine.

RulaKhaled · 2026-02-03T09:38:42Z

Closing in favor of #19122

Sai-Tom · 2025-12-04T09:59:09Z

Summary

The OpenAI SDK returns APIPromise objects with additional methods like .withResponse().
The previous async/await instrumentation converted these to regular Promises, losing those methods.

This PR uses Proxy + handleCallbackErrors pattern (matching anthropic-ai) to preserve the original return type.

Changes

Use Proxy instead of async function wrapper
Use handleCallbackErrors for non-streaming responses (preserves Promise subclass)
Add handleStreamingError helper for consistency
Add tests for APIPromise.withResponse() preservation

Test Plan

yarn build:dev passes
yarn test passes
yarn lint passes
Added tests for APIPromise preservation

The OpenAI SDK returns APIPromise objects with additional methods like .withResponse(). The previous async/await instrumentation converted these to regular Promises, losing those methods. Use Proxy + handleCallbackErrors pattern (matching anthropic-ai) to preserve the original return type.

- Use startInactiveSpan instead of startSpan/startSpanManual because they internally use handleCallbackErrors which calls .then() on Promises, creating a new instance and losing APIPromise methods - Add try-catch for synchronous exceptions - Add tests for error handling (sync throw + async reject) - Update tests to match real OpenAI SDK behavior"

- Use startInactiveSpan instead of startSpan/startSpanManual because they internally use handleCallbackErrors which calls .then() on Promises, creating a new instance and losing APIPromise methods - Add try-catch for synchronous exceptions - Use .finally() to ensure span always ends even if attribute processing throws - Add tests for error handling (sync throw + async reject) - Update tests to match real OpenAI SDK behavior

Sign in to view

+ const span = startInactiveSpan({
+ name: `${operationName} ${model}`,
+ op: getSpanOperation(methodPath),
+ attributes: requestAttributes as Record<string, SpanAttributeValue>,
+ });
+
+ if (options.recordInputs && params) {
+ addRequestAttributes(span, params);
+ }


RulaKhaled

Thank you for contributing! I have a question

RulaKhaled · 2025-12-09T13:53:18Z

+ // We use startInactiveSpan instead of startSpan/startSpanManual because those
+ // internally use handleCallbackErrors which calls .then() on Promises, creating
+ // a new Promise instance and losing APIPromise's custom methods like .withResponse().
+ const span = startInactiveSpan({


Have you tried using start span here?
I understand that your purpose here is to use handleCallbackErrors and handle promises, you can still achieve this with start span, and as long as we didn't end the span in a different scope/context, it should work fine.

RulaKhaled · 2026-02-03T09:38:42Z

Closing in favor of #19122