@posthog/ai 8.6.2 → 8.6.4

package/dist/openai/index.cjs

@@ -5,6 +5,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var openai = require('openai');
 var uuid = require('uuid');
 var core = require('@posthog/core');
+var streaming = require('openai/streaming');
 
 // Type guards for safer type checking
 
@@ -537,7 +538,7 @@ function formatOpenAIResponsesInput(input, instructions) {
   return messages;
 }
 
-var version = "8.6.2";
+var version = "8.6.4";
 
 const DEFAULT_MAX_DEPTH = 3;
 const MAX_STACK_LINES = 20;
@@ -648,125 +649,133 @@ const warnIfPostHogAiGateway = baseURL => {
  * so callers can re-throw the original error reference safely.
  */
 const captureAiGeneration$1 = async (client, options) => {
-  if (!client.capture) {
-    return;
-  }
-  warnIfPostHogAiGateway(options.baseURL);
-  const traceId = options.traceId ?? uuid.v4();
-  const eventType = options.eventType ?? AIEvent.Generation;
-  const privacyMode = options.privacyMode ?? false;
-  const usage = options.usage ?? {};
-
-  // Check privacy before reading or traversing input/output. Besides avoiding
-  // needless work, this ensures hostile getters/proxies cannot observe a value
-  // that the caller explicitly requested us to redact.
-  const shouldRedact = withPrivacyMode(client, privacyMode, false) === null;
-  const safeInput = shouldRedact ? null : core.toJsonSafeValue(options.input);
-  const safeOutput = shouldRedact ? null : core.toJsonSafeValue(options.output);
-  let httpStatus = options.httpStatus;
-  let errorData = {};
-  if (options.error) {
-    if (httpStatus === undefined) {
-      if (typeof options.error === 'object' && 'status' in options.error && typeof options.error.status === 'number') {
-        httpStatus = options.error.status;
-      } else {
-        httpStatus = 500;
-      }
+  try {
+    if (!client.capture) {
+      return;
     }
-    let exceptionId;
-    if (client.options?.enableExceptionAutocapture) {
-      exceptionId = core.uuidv7();
-      client.captureException(options.error, undefined, {
-        $ai_trace_id: traceId
-      }, exceptionId);
-      if (typeof options.error === 'object') {
-        options.error.__posthog_previously_captured_error = true;
+    warnIfPostHogAiGateway(options.baseURL);
+    const traceId = options.traceId ?? uuid.v4();
+    const eventType = options.eventType ?? AIEvent.Generation;
+    const privacyMode = options.privacyMode ?? false;
+    const usage = options.usage ?? {};
+
+    // Check privacy before reading or traversing input/output. Besides avoiding
+    // needless work, this ensures hostile getters/proxies cannot observe a value
+    // that the caller explicitly requested us to redact.
+    const shouldRedact = withPrivacyMode(client, privacyMode, false) === null;
+    const safeInput = shouldRedact ? null : core.toJsonSafeValue(options.input);
+    const safeOutput = shouldRedact ? null : core.toJsonSafeValue(options.output);
+    let httpStatus = options.httpStatus;
+    let errorData = {};
+    if (options.error) {
+      if (httpStatus === undefined) {
+        if (typeof options.error === 'object' && 'status' in options.error && typeof options.error.status === 'number') {
+          httpStatus = options.error.status;
+        } else if (typeof options.error === 'object' && 'statusCode' in options.error && typeof options.error.statusCode === 'number') {
+          httpStatus = options.error.statusCode;
+        } else {
+          httpStatus = 500;
+        }
       }
+      let exceptionId;
+      if (client.options?.enableExceptionAutocapture) {
+        exceptionId = core.uuidv7();
+        client.captureException(options.error, undefined, {
+          $ai_trace_id: traceId
+        }, exceptionId);
+        if (typeof options.error === 'object') {
+          ;
+          options.error.__posthog_previously_captured_error = true;
+        }
+      }
+      errorData = {
+        $ai_is_error: true,
+        $ai_error: stringifyError(options.error),
+        $exception_event_id: exceptionId
+      };
     }
-    errorData = {
-      $ai_is_error: true,
-      $ai_error: stringifyError(options.error),
-      $exception_event_id: exceptionId
+    httpStatus = httpStatus ?? 200;
+    let costOverrideData = {};
+    if (options.costOverride) {
+      const inputCostUSD = (options.costOverride.inputCost ?? 0) * (usage.inputTokens ?? 0);
+      const outputCostUSD = (options.costOverride.outputCost ?? 0) * (usage.outputTokens ?? 0);
+      costOverrideData = {
+        $ai_input_cost_usd: inputCostUSD,
+        $ai_output_cost_usd: outputCostUSD,
+        $ai_total_cost_usd: inputCostUSD + outputCostUSD
+      };
+    }
+    const additionalTokenValues = {
+      ...(usage.reasoningTokens ? {
+        $ai_reasoning_tokens: usage.reasoningTokens
+      } : {}),
+      ...(usage.cacheReadInputTokens ? {
+        $ai_cache_read_input_tokens: usage.cacheReadInputTokens
+      } : {}),
+      ...(usage.cacheCreationInputTokens ? {
+        $ai_cache_creation_input_tokens: usage.cacheCreationInputTokens
+      } : {}),
+      ...(usage.webSearchCount ? {
+        $ai_web_search_count: usage.webSearchCount
+      } : {}),
+      ...(usage.rawUsage ? {
+        $ai_usage: usage.rawUsage
+      } : {})
     };
-  }
-  httpStatus = httpStatus ?? 200;
-  let costOverrideData = {};
-  if (options.costOverride) {
-    const inputCostUSD = (options.costOverride.inputCost ?? 0) * (usage.inputTokens ?? 0);
-    const outputCostUSD = (options.costOverride.outputCost ?? 0) * (usage.outputTokens ?? 0);
-    costOverrideData = {
-      $ai_input_cost_usd: inputCostUSD,
-      $ai_output_cost_usd: outputCostUSD,
-      $ai_total_cost_usd: inputCostUSD + outputCostUSD
+    const properties = {
+      $ai_lib: 'posthog-ai',
+      $ai_lib_version: version,
+      $ai_provider: options.providerOverride ?? options.provider,
+      $ai_model: options.modelOverride ?? options.model,
+      $ai_model_parameters: options.modelParameters ?? {},
+      $ai_input: safeInput,
+      $ai_output_choices: safeOutput,
+      $ai_http_status: httpStatus,
+      $ai_input_tokens: usage.inputTokens ?? 0,
+      ...(usage.outputTokens !== undefined ? {
+        $ai_output_tokens: usage.outputTokens
+      } : {}),
+      ...additionalTokenValues,
+      $ai_latency: options.latency ?? 0,
+      ...(options.timeToFirstToken !== undefined ? {
+        $ai_time_to_first_token: options.timeToFirstToken
+      } : {}),
+      $ai_trace_id: traceId,
+      $ai_base_url: options.baseURL ?? '',
+      ...options.properties,
+      $ai_tokens_source: getTokensSource(options.properties),
+      ...(options.distinctId ? {} : {
+        $process_person_profile: false
+      }),
+      ...(options.stopReason ? {
+        $ai_stop_reason: options.stopReason
+      } : {}),
+      ...(options.tools ? {
+        $ai_tools: options.tools
+      } : {}),
+      ...(options.completionId ? {
+        $ai_completion_id: options.completionId
+      } : {}),
+      ...(options.providerMetadata && Object.keys(options.providerMetadata).length > 0 ? {
+        $ai_provider_metadata: options.providerMetadata
+      } : {}),
+      ...errorData,
+      ...costOverrideData
     };
-  }
-  const additionalTokenValues = {
-    ...(usage.reasoningTokens ? {
-      $ai_reasoning_tokens: usage.reasoningTokens
-    } : {}),
-    ...(usage.cacheReadInputTokens ? {
-      $ai_cache_read_input_tokens: usage.cacheReadInputTokens
-    } : {}),
-    ...(usage.cacheCreationInputTokens ? {
-      $ai_cache_creation_input_tokens: usage.cacheCreationInputTokens
-    } : {}),
-    ...(usage.webSearchCount ? {
-      $ai_web_search_count: usage.webSearchCount
-    } : {}),
-    ...(usage.rawUsage ? {
-      $ai_usage: usage.rawUsage
-    } : {})
-  };
-  const properties = {
-    $ai_lib: 'posthog-ai',
-    $ai_lib_version: version,
-    $ai_provider: options.providerOverride ?? options.provider,
-    $ai_model: options.modelOverride ?? options.model,
-    $ai_model_parameters: options.modelParameters ?? {},
-    $ai_input: safeInput,
-    $ai_output_choices: safeOutput,
-    $ai_http_status: httpStatus,
-    $ai_input_tokens: usage.inputTokens ?? 0,
-    ...(usage.outputTokens !== undefined ? {
-      $ai_output_tokens: usage.outputTokens
-    } : {}),
-    ...additionalTokenValues,
-    $ai_latency: options.latency ?? 0,
-    ...(options.timeToFirstToken !== undefined ? {
-      $ai_time_to_first_token: options.timeToFirstToken
-    } : {}),
-    $ai_trace_id: traceId,
-    $ai_base_url: options.baseURL ?? '',
-    ...options.properties,
-    $ai_tokens_source: getTokensSource(options.properties),
-    ...(options.distinctId ? {} : {
-      $process_person_profile: false
-    }),
-    ...(options.stopReason ? {
-      $ai_stop_reason: options.stopReason
-    } : {}),
-    ...(options.tools ? {
-      $ai_tools: options.tools
-    } : {}),
-    ...(options.completionId ? {
-      $ai_completion_id: options.completionId
-    } : {}),
-    ...(options.providerMetadata && Object.keys(options.providerMetadata).length > 0 ? {
-      $ai_provider_metadata: options.providerMetadata
-    } : {}),
-    ...errorData,
-    ...costOverrideData
-  };
-  const event = {
-    distinctId: options.distinctId ?? traceId,
-    event: eventType,
-    properties,
-    groups: options.groups
-  };
-  if (options.captureImmediate) {
-    await client.captureImmediate(event);
-  } else {
-    client.capture(event);
+    const event = {
+      distinctId: options.distinctId ?? traceId,
+      event: eventType,
+      properties,
+      groups: options.groups
+    };
+    if (options.captureImmediate) {
+      await client.captureImmediate(event);
+    } else {
+      client.capture(event);
+    }
+  } catch (error) {
+    // Telemetry failures must never affect the instrumented provider call.
+    console.warn('[PostHog AI] Failed to capture generation telemetry:', error);
   }
 };
 
@@ -843,6 +852,312 @@ function buildProviderMetadata(fields) {
   return Object.keys(metadata).length > 0 ? metadata : undefined;
 }
 
+function addRequestId(result, response, requestIdHeader) {
+  if (!result || typeof result !== 'object' || Array.isArray(result)) {
+    return result;
+  }
+  return Object.defineProperty(result, '_request_id', {
+    value: response.headers.get(requestIdHeader),
+    enumerable: false
+  });
+}
+function getResponsePropsPromise(parentPromise) {
+  const responsePromise = parentPromise.responsePromise;
+  if (!responsePromise || typeof responsePromise.then !== 'function') {
+    return undefined;
+  }
+  return responsePromise;
+}
+function decorateProviderPromise(wrappedPromise, responsePropsPromise, requestIdHeader, preserveThenUnwrap) {
+  const providerPromise = wrappedPromise;
+  if (responsePropsPromise) {
+    providerPromise.asResponse = async () => (await responsePropsPromise).response;
+    providerPromise.withResponse = async () => {
+      const [props, data] = await Promise.all([responsePropsPromise, wrappedPromise]);
+      return {
+        response: props.response,
+        data,
+        request_id: props.response.headers.get(requestIdHeader)
+      };
+    };
+  }
+  if (preserveThenUnwrap) {
+    providerPromise._thenUnwrap = transform => {
+      if (!responsePropsPromise) {
+        throw new Error('The provider promise response metadata is unavailable');
+      }
+      const transformedPromise = Promise.all([wrappedPromise, responsePropsPromise]).then(([data, props]) => addRequestId(transform(data, props), props.response, requestIdHeader));
+      return decorateProviderPromise(transformedPromise, responsePropsPromise, requestIdHeader, true);
+    };
+  }
+  return providerPromise;
+}
+
+/**
+ * Keep the provider SDK helpers on a promise whose resolved value is instrumented.
+ * OpenAI's parse helpers compose create calls through `_thenUnwrap`, while both
+ * OpenAI and Anthropic expose the raw response through `asResponse` and
+ * `withResponse`.
+ */
+
+function preserveProviderPromise(parentPromise, wrappedPromise, options = {}) {
+  const responsePropsPromise = getResponsePropsPromise(parentPromise);
+  const preserveThenUnwrap = typeof parentPromise._thenUnwrap === 'function';
+  const providerPromise = decorateProviderPromise(wrappedPromise, responsePropsPromise, options.requestIdHeader ?? 'x-request-id', preserveThenUnwrap);
+  if (!responsePropsPromise) {
+    const asResponse = parentPromise.asResponse?.bind(parentPromise);
+    if (asResponse) {
+      providerPromise.asResponse = asResponse;
+    }
+    const withResponse = parentPromise.withResponse?.bind(parentPromise);
+    if (withResponse) {
+      providerPromise.withResponse = async () => {
+        const [response, data] = await Promise.all([withResponse(), wrappedPromise]);
+        return {
+          ...response,
+          data
+        };
+      };
+    }
+  }
+  return providerPromise;
+}
+
+/**
+ * OpenAI's `Responses.parse` dispatches through `this._client.responses.create`.
+ * Temporarily use the provider's original `create` implementation so parsing a
+ * wrapped response does not capture the same request twice.
+ */
+function callWithOriginalCreate(resource, originalCreate, callback) {
+  const resourceRecord = resource;
+  const hadOwnCreate = Object.prototype.hasOwnProperty.call(resource, 'create');
+  const wrappedCreate = resourceRecord['create'];
+  resourceRecord['create'] = originalCreate;
+  try {
+    return callback();
+  } finally {
+    if (hadOwnCreate) {
+      resourceRecord['create'] = wrappedCreate;
+    } else {
+      delete resourceRecord['create'];
+    }
+  }
+}
+
+/**
+ * Splits an SDK stream into a monitoring branch and a caller branch without
+ * allowing either branch to read ahead of the other. Unlike the SDKs' `tee()`
+ * implementations, this keeps at most one result in flight and makes caller
+ * cancellation terminate the monitoring branch and the source iterator.
+ */
+function monitoredStreamTee(source, createStream) {
+  const controller = source.controller ?? new AbortController();
+  const sourceIterator = source[Symbol.asyncIterator]();
+  const callerQueue = [];
+  let monitorPending;
+  let monitorActive = true;
+  let operationInFlight = false;
+  let terminalResult;
+  let bufferedMonitorResult;
+  let terminalError;
+  let hasTerminalError = false;
+  let cancellationPromise;
+  let abortListener;
+  const removeAbortListener = () => {
+    if (abortListener) {
+      controller.signal.removeEventListener('abort', abortListener);
+      abortListener = undefined;
+    }
+  };
+  const settleMonitorTerminal = () => {
+    if (!monitorPending) {
+      return;
+    }
+    const pending = monitorPending;
+    monitorPending = undefined;
+    if (hasTerminalError) {
+      pending.reject(terminalError);
+    } else if (terminalResult) {
+      pending.resolve(terminalResult);
+    }
+  };
+  const settleCallersTerminal = () => {
+    while (callerQueue.length > 0) {
+      const pending = callerQueue.shift();
+      if (hasTerminalError) {
+        pending.reject(terminalError);
+      } else if (terminalResult) {
+        pending.resolve(terminalResult);
+      }
+    }
+  };
+  const pump = () => {
+    if (operationInFlight || callerQueue.length === 0 || monitorActive && !monitorPending) {
+      return;
+    }
+    const pendingCaller = callerQueue.shift();
+    const pendingMonitor = monitorPending;
+    monitorPending = undefined;
+    operationInFlight = true;
+    void sourceIterator.next().then(result => {
+      operationInFlight = false;
+      if (result.done) {
+        terminalResult = result;
+        removeAbortListener();
+      }
+      pendingCaller.resolve(result);
+      pendingMonitor?.resolve(result);
+      if (result.done) {
+        settleCallersTerminal();
+      } else {
+        pump();
+      }
+    }, error => {
+      operationInFlight = false;
+      terminalError = error;
+      hasTerminalError = true;
+      removeAbortListener();
+      pendingCaller.reject(error);
+      pendingMonitor?.reject(error);
+      settleCallersTerminal();
+    });
+  };
+  const monitoringStream = {
+    [Symbol.asyncIterator]() {
+      return {
+        next: () => {
+          if (hasTerminalError) {
+            return Promise.reject(terminalError);
+          }
+          if (terminalResult) {
+            return Promise.resolve(terminalResult);
+          }
+          if (bufferedMonitorResult) {
+            const result = bufferedMonitorResult;
+            bufferedMonitorResult = undefined;
+            return Promise.resolve(result);
+          }
+          return new Promise((resolve, reject) => {
+            monitorPending = {
+              resolve,
+              reject
+            };
+            pump();
+          });
+        },
+        return: async value => {
+          monitorActive = false;
+          monitorPending = undefined;
+          pump();
+          return {
+            done: true,
+            value: value
+          };
+        }
+      };
+    }
+  };
+  const cancelSource = value => {
+    if (cancellationPromise) {
+      return cancellationPromise;
+    }
+    removeAbortListener();
+    if (!controller.signal.aborted) {
+      controller.abort();
+    }
+    cancellationPromise = (async () => {
+      try {
+        const defaultResult = {
+          done: true,
+          value
+        };
+        const result = sourceIterator.return ? await sourceIterator.return(value) : defaultResult;
+        if (result.done) {
+          terminalResult = result;
+          removeAbortListener();
+          settleMonitorTerminal();
+          settleCallersTerminal();
+        } else if (monitorPending) {
+          monitorPending.resolve(result);
+          monitorPending = undefined;
+          cancellationPromise = undefined;
+        } else {
+          bufferedMonitorResult = result;
+          cancellationPromise = undefined;
+        }
+        return result;
+      } catch (error) {
+        terminalError = error;
+        hasTerminalError = true;
+        removeAbortListener();
+        settleMonitorTerminal();
+        settleCallersTerminal();
+        throw error;
+      }
+    })();
+    // An AbortController cancellation has no caller awaiting this promise.
+    void cancellationPromise.catch(() => undefined);
+    return cancellationPromise;
+  };
+  abortListener = () => {
+    void cancelSource();
+  };
+  if (controller.signal.aborted) {
+    abortListener();
+  } else {
+    controller.signal.addEventListener('abort', abortListener, {
+      once: true
+    });
+  }
+  const callerStream = createStream(() => ({
+    next: () => {
+      if (hasTerminalError) {
+        return Promise.reject(terminalError);
+      }
+      if (terminalResult) {
+        return Promise.resolve(terminalResult);
+      }
+      return new Promise((resolve, reject) => {
+        callerQueue.push({
+          resolve,
+          reject
+        });
+        pump();
+      });
+    },
+    return: value => cancelSource(value),
+    throw: async error => {
+      if (!sourceIterator.throw) {
+        await cancelSource();
+        throw error;
+      }
+      try {
+        const result = await sourceIterator.throw(error);
+        if (result.done) {
+          terminalResult = result;
+          removeAbortListener();
+          settleCallersTerminal();
+        }
+        if (monitorPending) {
+          monitorPending.resolve(result);
+          monitorPending = undefined;
+        } else {
+          bufferedMonitorResult = result;
+        }
+        return result;
+      } catch (sourceError) {
+        terminalError = sourceError;
+        hasTerminalError = true;
+        removeAbortListener();
+        settleMonitorTerminal();
+        settleCallersTerminal();
+        throw sourceError;
+      }
+    }
+  }), controller);
+  return [monitoringStream, callerStream];
+}
+
 class PostHogAzureOpenAI extends openai.AzureOpenAI {
   constructor(config) {
     const {
@@ -884,9 +1199,9 @@ let WrappedCompletions$1 = class WrappedCompletions extends openai.AzureOpenAI.C
     const startTime = Date.now();
     const parentPromise = super.create(openAIParams, options);
     if (openAIParams.stream) {
-      return parentPromise.then(value => {
-        if ('tee' in value) {
-          const [stream1, stream2] = value.tee();
+      const wrappedPromise = parentPromise.then(value => {
+        if (Symbol.asyncIterator in value) {
+          const [stream1, stream2] = monitoredStreamTee(value, (iterator, controller) => new streaming.Stream(iterator, controller));
           (async () => {
             // Hoisted so the catch block can surface whatever was accumulated
             // from the streamed chunks before the failure.
@@ -1062,6 +1377,7 @@ let WrappedCompletions$1 = class WrappedCompletions extends openai.AzureOpenAI.C
         }
         return value;
       });
+      return preserveProviderPromise(parentPromise, wrappedPromise);
     } else {
       const wrappedPromise = parentPromise.then(async result => {
         if ('choices' in result) {
@@ -1110,7 +1426,7 @@ let WrappedCompletions$1 = class WrappedCompletions extends openai.AzureOpenAI.C
         });
         throw error;
       });
-      return wrappedPromise;
+      return preserveProviderPromise(parentPromise, wrappedPromise);
     }
   }
 };
@@ -1136,9 +1452,9 @@ let WrappedResponses$1 = class WrappedResponses extends openai.AzureOpenAI.Respo
     const startTime = Date.now();
     const parentPromise = super.create(openAIParams, options);
     if (openAIParams.stream) {
-      return parentPromise.then(value => {
-        if ('tee' in value && typeof value.tee === 'function') {
-          const [stream1, stream2] = value.tee();
+      const wrappedPromise = parentPromise.then(value => {
+        if (Symbol.asyncIterator in value) {
+          const [stream1, stream2] = monitoredStreamTee(value, (iterator, controller) => new streaming.Stream(iterator, controller));
           (async () => {
             // Hoisted so the catch block can surface the completion ID that
             // was accumulated from the streamed chunks before the failure.
@@ -1172,12 +1488,12 @@ let WrappedResponses$1 = class WrappedResponses extends openai.AzureOpenAI.Respo
                 if (chunk.type === 'response.completed' && 'response' in chunk && chunk.response?.output && chunk.response.output.length > 0) {
                   finalContent = chunk.response.output;
                 }
-                if ('usage' in chunk && chunk.usage) {
+                if ('response' in chunk && chunk.response?.usage) {
                   usage = {
-                    inputTokens: chunk.usage.input_tokens ?? 0,
-                    outputTokens: chunk.usage.output_tokens ?? 0,
-                    reasoningTokens: chunk.usage.output_tokens_details?.reasoning_tokens ?? 0,
-                    cacheReadInputTokens: chunk.usage.input_tokens_details?.cached_tokens ?? 0
+                    inputTokens: chunk.response.usage.input_tokens ?? 0,
+                    outputTokens: chunk.response.usage.output_tokens ?? 0,
+                    reasoningTokens: chunk.response.usage.output_tokens_details?.reasoning_tokens ?? 0,
+                    cacheReadInputTokens: chunk.response.usage.input_tokens_details?.cached_tokens ?? 0
                   };
                 }
               }
@@ -1226,6 +1542,7 @@ let WrappedResponses$1 = class WrappedResponses extends openai.AzureOpenAI.Respo
         }
         return value;
       });
+      return preserveProviderPromise(parentPromise, wrappedPromise);
     } else {
       const wrappedPromise = parentPromise.then(async result => {
         if ('output' in result) {
@@ -1273,7 +1590,7 @@ let WrappedResponses$1 = class WrappedResponses extends openai.AzureOpenAI.Respo
         });
         throw error;
       });
-      return wrappedPromise;
+      return preserveProviderPromise(parentPromise, wrappedPromise);
     }
   }
   parse(body, options) {
@@ -1282,7 +1599,7 @@ let WrappedResponses$1 = class WrappedResponses extends openai.AzureOpenAI.Respo
       posthogParams
     } = extractPosthogParams(body);
     const startTime = Date.now();
-    const parentPromise = super.parse(openAIParams, options);
+    const parentPromise = callWithOriginalCreate(this, super.create.bind(this), () => super.parse(openAIParams, options));
     const wrappedPromise = parentPromise.then(async result => {
       const latency = (Date.now() - startTime) / 1000;
       await captureAiGeneration(this.phClient, {
@@ -1326,7 +1643,7 @@ let WrappedResponses$1 = class WrappedResponses extends openai.AzureOpenAI.Respo
       });
       throw error;
     });
-    return wrappedPromise;
+    return preserveProviderPromise(parentPromise, wrappedPromise);
   }
 };
 let WrappedEmbeddings$1 = class WrappedEmbeddings extends openai.AzureOpenAI.Embeddings {
@@ -1381,7 +1698,7 @@ let WrappedEmbeddings$1 = class WrappedEmbeddings extends openai.AzureOpenAI.Emb
       });
       throw error;
     });
-    return wrappedPromise;
+    return preserveProviderPromise(parentPromise, wrappedPromise);
   }
 };
 
@@ -1402,25 +1719,6 @@ async function captureAiGenerationAfterSuccess(...args) {
     captureAiGenerationInBackground(...args);
   }
 }
-function preserveAPIPromiseHelpers(parentPromise, wrappedPromise) {
-  const apiPromise = wrappedPromise;
-  if (typeof parentPromise.asResponse === 'function') {
-    apiPromise.asResponse = () => parentPromise.asResponse();
-  }
-  if (typeof parentPromise.withResponse === 'function') {
-    apiPromise.withResponse = async () => {
-      const [response, data] = await Promise.all([parentPromise.withResponse(), wrappedPromise]);
-      // swaps the `data` payload inside the SDK's generic withResponse shape; the compiler
-      // cannot relate the Input- and Output-instantiated conditional types
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      return {
-        ...response,
-        data
-      };
-    };
-  }
-  return apiPromise;
-}
 const TERMINAL_RESPONSE_STATUSES = new Set(['completed', 'failed', 'cancelled', 'incomplete']);
 function isPendingBackgroundResponse(params, response) {
   return params.background === true && !response.usage && !!response.status && !TERMINAL_RESPONSE_STATUSES.has(response.status);
@@ -1468,8 +1766,8 @@ class WrappedCompletions extends Completions {
     const parentPromise = super.create(openAIParams, options);
     if (openAIParams.stream) {
       const wrappedPromise = parentPromise.then(value => {
-        if ('tee' in value) {
-          const [stream1, stream2] = value.tee();
+        if (Symbol.asyncIterator in value) {
+          const [stream1, stream2] = monitoredStreamTee(value, (iterator, controller) => new streaming.Stream(iterator, controller));
           (async () => {
             // Hoisted so the catch block can surface whatever was accumulated
             // from the streamed chunks before the failure.
@@ -1667,7 +1965,7 @@ class WrappedCompletions extends Completions {
         }
         return value;
       });
-      return preserveAPIPromiseHelpers(parentPromise, wrappedPromise);
+      return preserveProviderPromise(parentPromise, wrappedPromise);
     } else {
       const wrappedPromise = parentPromise.then(async result => {
         if ('choices' in result) {
@@ -1722,7 +2020,7 @@ class WrappedCompletions extends Completions {
         });
         throw error;
       });
-      return preserveAPIPromiseHelpers(parentPromise, wrappedPromise);
+      return preserveProviderPromise(parentPromise, wrappedPromise);
     }
   }
 }
@@ -1749,8 +2047,8 @@ class WrappedResponses extends Responses {
     const parentPromise = super.create(openAIParams, options);
     if (openAIParams.stream) {
       const wrappedPromise = parentPromise.then(value => {
-        if ('tee' in value && typeof value.tee === 'function') {
-          const [stream1, stream2] = value.tee();
+        if (Symbol.asyncIterator in value) {
+          const [stream1, stream2] = monitoredStreamTee(value, (iterator, controller) => new streaming.Stream(iterator, controller));
           (async () => {
             // Hoisted so the catch block can surface the completion ID that
             // was accumulated from the streamed chunks before the failure.
@@ -1860,7 +2158,7 @@ class WrappedResponses extends Responses {
         }
         return value;
       });
-      return preserveAPIPromiseHelpers(parentPromise, wrappedPromise);
+      return preserveProviderPromise(parentPromise, wrappedPromise);
     } else {
       const wrappedPromise = parentPromise.then(async result => {
         if ('output' in result) {
@@ -1919,7 +2217,7 @@ class WrappedResponses extends Responses {
         });
         throw error;
       });
-      return preserveAPIPromiseHelpers(parentPromise, wrappedPromise);
+      return preserveProviderPromise(parentPromise, wrappedPromise);
     }
   }
   parse(body, options) {
@@ -1928,64 +2226,55 @@ class WrappedResponses extends Responses {
       posthogParams
     } = extractPosthogParams(body);
     const startTime = Date.now();
-    const originalCreate = super.create.bind(this);
-    const originalSelfRecord = this;
-    const tempCreate = originalSelfRecord['create'];
-    originalSelfRecord['create'] = originalCreate;
-    try {
-      const parentPromise = super.parse(openAIParams, options);
-      const wrappedPromise = parentPromise.then(async result => {
-        if (isPendingBackgroundResponse(openAIParams, result)) {
-          return result;
-        }
-        const latency = (Date.now() - startTime) / 1000;
-        await captureAiGeneration(this.phClient, {
-          ...posthogParams,
-          model: openAIParams.model ?? result.model,
-          provider: 'openai',
-          input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
-          output: result.output,
-          latency,
-          baseURL: this.baseURL,
-          modelParameters: getModelParams(body, result.service_tier),
-          httpStatus: 200,
-          usage: {
-            inputTokens: result.usage?.input_tokens ?? 0,
-            outputTokens: result.usage?.output_tokens ?? 0,
-            reasoningTokens: result.usage?.output_tokens_details?.reasoning_tokens ?? 0,
-            cacheReadInputTokens: result.usage?.input_tokens_details?.cached_tokens ?? 0,
-            rawUsage: result.usage
-          },
-          stopReason: result.status ?? undefined,
-          completionId: result.id,
-          providerMetadata: buildProviderMetadata({
-            requestId: extractRequestId(result)
-          })
-        });
+    const parentPromise = callWithOriginalCreate(this, super.create.bind(this), () => super.parse(openAIParams, options));
+    const wrappedPromise = parentPromise.then(async result => {
+      if (isPendingBackgroundResponse(openAIParams, result)) {
         return result;
-      }, async error => {
-        await captureAiGeneration(this.phClient, {
-          ...posthogParams,
-          model: openAIParams.model,
-          provider: 'openai',
-          input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
-          output: [],
-          latency: 0,
-          baseURL: this.baseURL,
-          modelParameters: getModelParams(body),
-          usage: {
-            inputTokens: 0,
-            outputTokens: 0
-          },
-          error
-        });
-        throw error;
+      }
+      const latency = (Date.now() - startTime) / 1000;
+      await captureAiGeneration(this.phClient, {
+        ...posthogParams,
+        model: openAIParams.model ?? result.model,
+        provider: 'openai',
+        input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
+        output: result.output,
+        latency,
+        baseURL: this.baseURL,
+        modelParameters: getModelParams(body, result.service_tier),
+        httpStatus: 200,
+        usage: {
+          inputTokens: result.usage?.input_tokens ?? 0,
+          outputTokens: result.usage?.output_tokens ?? 0,
+          reasoningTokens: result.usage?.output_tokens_details?.reasoning_tokens ?? 0,
+          cacheReadInputTokens: result.usage?.input_tokens_details?.cached_tokens ?? 0,
+          rawUsage: result.usage
+        },
+        stopReason: result.status ?? undefined,
+        completionId: result.id,
+        providerMetadata: buildProviderMetadata({
+          requestId: extractRequestId(result)
+        })
       });
-      return preserveAPIPromiseHelpers(parentPromise, wrappedPromise);
-    } finally {
-      // Restore our wrapped create method
-      originalSelfRecord['create'] = tempCreate;
-    }
+      return result;
+    }, async error => {
+      await captureAiGeneration(this.phClient, {
+        ...posthogParams,
+        model: openAIParams.model,
+        provider: 'openai',
+        input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
+        output: [],
+        latency: 0,
+        baseURL: this.baseURL,
+        modelParameters: getModelParams(body),
+        usage: {
+          inputTokens: 0,
+          outputTokens: 0
+        },
+        error
+      });
+      throw error;
+    });
+    return preserveProviderPromise(parentPromise, wrappedPromise);
   }
 }
 class WrappedEmbeddings extends Embeddings {
@@ -2042,7 +2331,7 @@ class WrappedEmbeddings extends Embeddings {
       });
       throw error;
     });
-    return preserveAPIPromiseHelpers(parentPromise, wrappedPromise);
+    return preserveProviderPromise(parentPromise, wrappedPromise);
   }
 }
 class WrappedAudio extends Audio {
@@ -2082,8 +2371,8 @@ class WrappedTranscriptions extends Transcriptions {
     const parentPromise = openAIParams.stream ? super.create(openAIParams, options) : super.create(openAIParams, options);
     if (openAIParams.stream) {
       const wrappedPromise = parentPromise.then(value => {
-        if ('tee' in value && typeof value.tee === 'function') {
-          const [stream1, stream2] = value.tee();
+        if (Symbol.asyncIterator in value) {
+          const [stream1, stream2] = monitoredStreamTee(value, (iterator, controller) => new streaming.Stream(iterator, controller));
           (async () => {
             try {
               let finalContent = '';
@@ -2152,7 +2441,7 @@ class WrappedTranscriptions extends Transcriptions {
         }
         return value;
       });
-      return preserveAPIPromiseHelpers(parentPromise, wrappedPromise);
+      return preserveProviderPromise(parentPromise, wrappedPromise);
     } else {
       const wrappedPromise = parentPromise.then(async result => {
         if (result && typeof result === 'object' && 'text' in result) {
@@ -2193,7 +2482,7 @@ class WrappedTranscriptions extends Transcriptions {
         });
         throw error;
       });
-      return preserveAPIPromiseHelpers(parentPromise, wrappedPromise);
+      return preserveProviderPromise(parentPromise, wrappedPromise);
     }
   }
 }