@posthog/ai 8.7.1 → 8.8.1

package/dist/openai/index.cjs

@@ -13,6 +13,33 @@ const isString = value => {
   return typeof value === 'string';
 };
 
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+function isFullAiCaptureEnabled(client) {
+  return client?.enableFullAiCapture === true;
+}
+
+/** @internal */
+function captureAiEvent(client, event) {
+  if (isFullAiCaptureEnabled(client) && typeof client.captureAi === 'function') {
+    client.captureAi(event);
+    return;
+  }
+  client.capture(event);
+}
+
+/** @internal */
+async function captureAiEventImmediate(client, event) {
+  if (isFullAiCaptureEnabled(client) && typeof client.captureAiImmediate === 'function') {
+    await client.captureAiImmediate(event);
+    return;
+  }
+  await client.captureImmediate(event);
+}
+
 const DATA_URL_PREFIX_RE = /^data:([^;,\s]+)(?:;[^;,\s]+)*;base64,/i;
 const BASE64_ALPHABET_RE = /^[A-Za-z0-9+/_=-]+$/;
 class Base64Recognizer {
@@ -118,7 +145,6 @@ class BinaryContentRedactor {
     this.recognizer = recognizer;
   }
   redact(value, mediaType) {
-    if (this.isMultimodalEnabled()) return value;
     this.visited = new WeakSet();
     return this.walk(value, mediaType ? new MediaTypeContext(undefined, undefined, mediaType) : MediaTypeContext.EMPTY);
   }
@@ -162,15 +188,12 @@ class BinaryContentRedactor {
     if (mediaType === 'application/octet-stream') return '[base64 file redacted]';
     return `[base64 ${mediaType} redacted]`;
   }
-  isMultimodalEnabled() {
-    const val = process.env._INTERNAL_LLMA_MULTIMODAL || '';
-    return val.toLowerCase() === 'true' || val === '1' || val.toLowerCase() === 'yes';
-  }
 }
 
 const redactor = new BinaryContentRedactor();
-const sanitizeOpenAI = data => redactor.redact(data);
-const sanitizeOpenAIResponse = data => redactor.redact(data);
+const sanitize = (data, client) => isFullAiCaptureEnabled(client) ? data : redactor.redact(data);
+const sanitizeOpenAI = (data, client) => sanitize(data, client);
+const sanitizeOpenAIResponse = (data, client) => sanitize(data, client);
 
 const TOKEN_PROPERTY_KEYS = new Set(['$ai_input_tokens', '$ai_output_tokens', '$ai_cache_read_input_tokens', '$ai_cache_creation_input_tokens', '$ai_total_tokens', '$ai_reasoning_tokens']);
 
@@ -321,6 +344,11 @@ const formatResponseOpenAI = response => {
             arguments: item.arguments || {}
           }
         });
+      } else if (item.type === 'image_generation_call' && item.result) {
+        content.push({
+          type: 'image',
+          image: item.result
+        });
       }
     }
     if (content.length > 0) {
@@ -553,7 +581,7 @@ function formatOpenAIResponsesInput(input, instructions) {
   return messages;
 }
 
-var version = "8.7.1";
+var version = "8.8.1";
 
 const DEFAULT_MAX_DEPTH = 3;
 const MAX_STACK_LINES = 20;
@@ -802,9 +830,9 @@ const captureAiGeneration$1 = async (client, options) => {
       groups: options.groups
     };
     if (options.captureImmediate) {
-      await client.captureImmediate(event);
+      await captureAiEventImmediate(client, event);
     } else {
-      client.capture(event);
+      captureAiEvent(client, event);
     }
   } catch (error) {
     // Telemetry failures must never affect the instrumented provider call.
@@ -1299,6 +1327,340 @@ function monitoredStreamTee(source, createStream) {
   return [monitoringStream, callerStream];
 }
 
+/** Pure state accumulator for OpenAI-compatible Chat Completions chunks. */
+class OpenAIChatStreamAccumulator {
+  accumulatedContent = '';
+  usage = {
+    inputTokens: 0,
+    outputTokens: 0,
+    webSearchCount: 0
+  };
+  toolCalls = new Map();
+  consume(chunk, receivedAt = Date.now()) {
+    this.model ||= chunk.model || undefined;
+    this.completionId ||= chunk.id || undefined;
+    this.systemFingerprint ||= chunk.system_fingerprint || undefined;
+    if (chunk.service_tier != null) {
+      this.serviceTier = chunk.service_tier;
+    }
+    const choice = chunk.choices?.[0];
+    if (choice?.finish_reason) {
+      this.stopReason = choice.finish_reason;
+    }
+    const webSearchCount = calculateWebSearchCount(chunk);
+    if (webSearchCount > (this.usage.webSearchCount ?? 0)) {
+      this.usage.webSearchCount = webSearchCount;
+    }
+    if (choice?.delta?.content) {
+      this.firstTokenTime ??= receivedAt;
+      this.accumulatedContent += choice.delta.content;
+    }
+    if (Array.isArray(choice?.delta?.tool_calls)) {
+      this.firstTokenTime ??= receivedAt;
+      for (const toolCall of choice.delta.tool_calls) {
+        if (toolCall.index === undefined) {
+          continue;
+        }
+        const current = this.toolCalls.get(toolCall.index) ?? {
+          id: '',
+          name: '',
+          arguments: ''
+        };
+        if (toolCall.id) {
+          current.id = toolCall.id;
+        }
+        if (toolCall.function?.name) {
+          current.name = toolCall.function.name;
+        }
+        if (toolCall.function?.arguments) {
+          current.arguments += toolCall.function.arguments;
+        }
+        this.toolCalls.set(toolCall.index, current);
+      }
+    }
+    if (chunk.usage) {
+      this.usage = {
+        ...this.usage,
+        inputTokens: chunk.usage.prompt_tokens ?? 0,
+        outputTokens: chunk.usage.completion_tokens ?? 0,
+        reasoningTokens: chunk.usage.completion_tokens_details?.reasoning_tokens ?? 0,
+        cacheReadInputTokens: chunk.usage.prompt_tokens_details?.cached_tokens ?? 0,
+        cacheCreationInputTokens: extractCacheWriteTokens(chunk.usage.prompt_tokens_details),
+        rawUsage: chunk.usage
+      };
+    }
+  }
+  result() {
+    const content = [];
+    if (this.accumulatedContent) {
+      content.push({
+        type: 'text',
+        text: this.accumulatedContent
+      });
+    }
+    for (const toolCall of this.toolCalls.values()) {
+      if (toolCall.name) {
+        content.push({
+          type: 'function',
+          id: toolCall.id,
+          function: {
+            name: toolCall.name,
+            arguments: toolCall.arguments
+          }
+        });
+      }
+    }
+    return {
+      output: [{
+        role: 'assistant',
+        content: content.length > 0 ? content : [{
+          type: 'text',
+          text: ''
+        }]
+      }],
+      model: this.model,
+      completionId: this.completionId,
+      systemFingerprint: this.systemFingerprint,
+      serviceTier: this.serviceTier,
+      firstTokenTime: this.firstTokenTime,
+      stopReason: this.stopReason,
+      usage: {
+        ...this.usage
+      }
+    };
+  }
+}
+/** Pure state accumulator for OpenAI-compatible Responses stream events. */
+class OpenAIResponsesStreamAccumulator {
+  output = [];
+  usage = {
+    inputTokens: 0,
+    outputTokens: 0,
+    webSearchCount: 0
+  };
+  consume(event, receivedAt = Date.now()) {
+    if (this.firstTokenTime === undefined && isResponseTokenChunk(event)) {
+      this.firstTokenTime = receivedAt;
+    }
+    if (!('response' in event) || !event.response) {
+      return;
+    }
+    const response = event.response;
+    this.model ||= response.model || undefined;
+    this.completionId ||= response.id || undefined;
+    if (response.service_tier != null) {
+      this.serviceTier = response.service_tier;
+    }
+    const webSearchCount = calculateWebSearchCount(response);
+    if (webSearchCount > (this.usage.webSearchCount ?? 0)) {
+      this.usage.webSearchCount = webSearchCount;
+    }
+    if (response.usage) {
+      this.usage = {
+        ...this.usage,
+        inputTokens: response.usage.input_tokens ?? 0,
+        outputTokens: response.usage.output_tokens ?? 0,
+        reasoningTokens: response.usage.output_tokens_details?.reasoning_tokens ?? 0,
+        cacheReadInputTokens: response.usage.input_tokens_details?.cached_tokens ?? 0,
+        cacheCreationInputTokens: extractCacheWriteTokens(response.usage.input_tokens_details),
+        rawUsage: response.usage
+      };
+    }
+    if (isTerminalResponse(response)) {
+      this.terminalResponse = response;
+      this.output = response.output ?? [];
+      this.stopReason = response.status;
+    }
+  }
+  result() {
+    return {
+      output: [...this.output],
+      model: this.model,
+      completionId: this.completionId,
+      serviceTier: this.serviceTier,
+      firstTokenTime: this.firstTokenTime,
+      stopReason: this.stopReason,
+      usage: {
+        ...this.usage
+      },
+      terminalResponse: this.terminalResponse
+    };
+  }
+}
+
+function captureAiGenerationInBackground(...args) {
+  void captureAiGeneration(...args).catch(() => undefined);
+}
+
+/** Preserve immediate delivery while isolating normal telemetry from provider latency/failures. */
+async function captureAiGenerationAfterSuccess(...args) {
+  if (args[1].captureImmediate) {
+    await captureAiGeneration(...args);
+  } else {
+    captureAiGenerationInBackground(...args);
+  }
+}
+function buildChatUsage(usage, webSearchSource) {
+  return {
+    inputTokens: usage?.prompt_tokens ?? 0,
+    outputTokens: usage?.completion_tokens ?? 0,
+    reasoningTokens: usage?.completion_tokens_details?.reasoning_tokens ?? 0,
+    cacheReadInputTokens: usage?.prompt_tokens_details?.cached_tokens ?? 0,
+    cacheCreationInputTokens: extractCacheWriteTokens(usage?.prompt_tokens_details),
+    webSearchCount: calculateWebSearchCount(webSearchSource),
+    rawUsage: usage
+  };
+}
+function buildResponsesUsage(usage, webSearchSource) {
+  return {
+    inputTokens: usage?.input_tokens ?? 0,
+    outputTokens: usage?.output_tokens ?? 0,
+    reasoningTokens: usage?.output_tokens_details?.reasoning_tokens ?? 0,
+    cacheReadInputTokens: usage?.input_tokens_details?.cached_tokens ?? 0,
+    cacheCreationInputTokens: extractCacheWriteTokens(usage?.input_tokens_details),
+    webSearchCount: calculateWebSearchCount(webSearchSource),
+    rawUsage: usage
+  };
+}
+function buildChatSuccessOptions(context, result) {
+  return {
+    ...context.monitoring,
+    model: context.params.model ?? result.model,
+    provider: context.provider,
+    input: sanitizeOpenAI(context.params.messages, context.client),
+    output: sanitizeOpenAIResponse(result.output, context.client),
+    latency: result.latency,
+    timeToFirstToken: result.timeToFirstToken,
+    baseURL: context.baseURL,
+    modelParameters: getModelParams(context.modelParametersSource, result.serviceTier),
+    httpStatus: 200,
+    usage: result.usage,
+    stopReason: result.stopReason,
+    tools: extractAvailableToolCalls('openai', context.params),
+    completionId: result.completionId,
+    providerMetadata: buildProviderMetadata({
+      systemFingerprint: result.systemFingerprint,
+      requestId: result.requestId
+    })
+  };
+}
+function buildChatErrorOptions(context, error, metadata = {}) {
+  return {
+    ...context.monitoring,
+    model: context.params.model,
+    provider: context.provider,
+    input: sanitizeOpenAI(context.params.messages, context.client),
+    output: [],
+    latency: 0,
+    baseURL: context.baseURL,
+    modelParameters: getModelParams(context.modelParametersSource),
+    usage: {
+      inputTokens: 0,
+      outputTokens: 0
+    },
+    completionId: metadata.completionId,
+    providerMetadata: buildProviderMetadata({
+      systemFingerprint: metadata.systemFingerprint
+    }),
+    error
+  };
+}
+function buildSanitizedResponsesInput(context) {
+  return formatOpenAIResponsesInput(sanitizeOpenAIResponse(context.params.input, context.client), sanitizeOpenAIResponse(context.params.instructions, context.client));
+}
+function buildResponsesSuccessOptions(context, result) {
+  const response = result.response;
+  return {
+    ...context.monitoring,
+    model: context.params.model ?? response.model,
+    provider: context.provider,
+    input: buildSanitizedResponsesInput(context),
+    output: sanitizeOpenAIResponse(result.output, context.client),
+    latency: result.latency,
+    timeToFirstToken: result.timeToFirstToken,
+    baseURL: context.baseURL,
+    modelParameters: getModelParams(context.modelParametersSource, response.service_tier),
+    httpStatus: 200,
+    usage: result.usage ?? buildResponsesUsage(response.usage, response),
+    stopReason: response.status ?? undefined,
+    tools: result.includeTools ? extractAvailableToolCalls('openai', context.params) : undefined,
+    completionId: response.id,
+    providerMetadata: buildProviderMetadata({
+      requestId: result.includeRequestId ? extractRequestId(response) : undefined,
+      incompleteDetails: response.incomplete_details
+    }),
+    error: getResponseFailure({
+      id: response.id,
+      status: response.status,
+      error: response.error ?? null
+    })
+  };
+}
+function buildBackgroundResponseOptions(context, response) {
+  return buildResponsesSuccessOptions(context, {
+    response,
+    output: formatResponseOpenAI({
+      output: response.output
+    }),
+    latency: getBackgroundResponseLatency(response),
+    includeTools: true,
+    includeRequestId: true
+  });
+}
+function buildResponsesErrorOptions(context, error, completionId) {
+  return {
+    ...context.monitoring,
+    model: context.params.model,
+    provider: context.provider,
+    input: buildSanitizedResponsesInput(context),
+    output: [],
+    latency: 0,
+    baseURL: context.baseURL,
+    modelParameters: getModelParams(context.modelParametersSource),
+    usage: {
+      inputTokens: 0,
+      outputTokens: 0
+    },
+    completionId,
+    error
+  };
+}
+function buildEmbeddingSuccessOptions(context, usage, latency) {
+  return {
+    eventType: AIEvent.Embedding,
+    ...context.monitoring,
+    model: context.params.model,
+    provider: context.provider,
+    input: withPrivacyMode(context.client, context.monitoring.privacyMode, context.params.input),
+    output: null,
+    latency,
+    baseURL: context.baseURL,
+    modelParameters: getModelParams(context.modelParametersSource),
+    httpStatus: 200,
+    usage: {
+      inputTokens: usage?.prompt_tokens ?? 0,
+      rawUsage: usage
+    }
+  };
+}
+function buildEmbeddingErrorOptions(context, error) {
+  return {
+    eventType: AIEvent.Embedding,
+    ...context.monitoring,
+    model: context.params.model,
+    provider: context.provider,
+    input: withPrivacyMode(context.client, context.monitoring.privacyMode, context.params.input),
+    output: null,
+    latency: 0,
+    baseURL: context.baseURL,
+    modelParameters: getModelParams(context.modelParametersSource),
+    usage: {
+      inputTokens: 0
+    },
+    error
+  };
+}
+
 class PostHogAzureOpenAI extends openai.AzureOpenAI {
   constructor(config) {
     const {
@@ -1344,169 +1706,37 @@ let WrappedCompletions$1 = class WrappedCompletions extends openai.AzureOpenAI.C
         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.
-            let completionIdFromResponse;
-            let systemFingerprintFromResponse;
+            const accumulator = new OpenAIChatStreamAccumulator();
             try {
-              const contentBlocks = [];
-              let accumulatedContent = '';
-              let modelFromResponse;
-              let serviceTierFromResponse;
-              let firstTokenTime;
-              let usage = {
-                inputTokens: 0,
-                outputTokens: 0
-              };
-
-              // Map to track in-progress tool calls
-              const toolCallsInProgress = new Map();
               for await (const chunk of stream1) {
-                // Extract model and completion metadata from chunk (Chat Completions chunks carry these fields)
-                if (!modelFromResponse && chunk.model) {
-                  modelFromResponse = chunk.model;
-                }
-                if (!completionIdFromResponse && chunk.id) {
-                  completionIdFromResponse = chunk.id;
-                }
-                if (!systemFingerprintFromResponse && chunk.system_fingerprint) {
-                  systemFingerprintFromResponse = chunk.system_fingerprint;
-                }
-                if (chunk.service_tier != null) {
-                  serviceTierFromResponse = chunk.service_tier;
-                }
-                const choice = chunk?.choices?.[0];
-
-                // Handle text content
-                const deltaContent = choice?.delta?.content;
-                if (deltaContent) {
-                  if (firstTokenTime === undefined) {
-                    firstTokenTime = Date.now();
-                  }
-                  accumulatedContent += deltaContent;
-                }
-
-                // Handle tool calls
-                const deltaToolCalls = choice?.delta?.tool_calls;
-                if (deltaToolCalls && Array.isArray(deltaToolCalls)) {
-                  if (firstTokenTime === undefined) {
-                    firstTokenTime = Date.now();
-                  }
-                  for (const toolCall of deltaToolCalls) {
-                    const index = toolCall.index;
-                    if (index !== undefined) {
-                      if (!toolCallsInProgress.has(index)) {
-                        // New tool call
-                        toolCallsInProgress.set(index, {
-                          id: toolCall.id || '',
-                          name: toolCall.function?.name || '',
-                          arguments: ''
-                        });
-                      }
-                      const inProgressCall = toolCallsInProgress.get(index);
-                      if (inProgressCall) {
-                        // Update tool call data
-                        if (toolCall.id) {
-                          inProgressCall.id = toolCall.id;
-                        }
-                        if (toolCall.function?.name) {
-                          inProgressCall.name = toolCall.function.name;
-                        }
-                        if (toolCall.function?.arguments) {
-                          inProgressCall.arguments += toolCall.function.arguments;
-                        }
-                      }
-                    }
-                  }
-                }
-
-                // Handle usage information
-                if (chunk.usage) {
-                  usage = {
-                    inputTokens: chunk.usage.prompt_tokens ?? 0,
-                    outputTokens: chunk.usage.completion_tokens ?? 0,
-                    reasoningTokens: chunk.usage.completion_tokens_details?.reasoning_tokens ?? 0,
-                    cacheReadInputTokens: chunk.usage.prompt_tokens_details?.cached_tokens ?? 0,
-                    cacheCreationInputTokens: extractCacheWriteTokens(chunk.usage.prompt_tokens_details)
-                  };
-                }
-              }
-
-              // Build final content blocks
-              if (accumulatedContent) {
-                contentBlocks.push({
-                  type: 'text',
-                  text: accumulatedContent
-                });
+                accumulator.consume(chunk);
               }
-
-              // Add completed tool calls to content blocks
-              for (const toolCall of toolCallsInProgress.values()) {
-                if (toolCall.name) {
-                  contentBlocks.push({
-                    type: 'function',
-                    id: toolCall.id,
-                    function: {
-                      name: toolCall.name,
-                      arguments: toolCall.arguments
-                    }
-                  });
-                }
-              }
-
-              // Format output to match non-streaming version
-              const formattedOutput = contentBlocks.length > 0 ? [{
-                role: 'assistant',
-                content: contentBlocks
-              }] : [{
-                role: 'assistant',
-                content: [{
-                  type: 'text',
-                  text: ''
-                }]
-              }];
-              const latency = (Date.now() - startTime) / 1000;
-              const timeToFirstToken = firstTokenTime !== undefined ? (firstTokenTime - startTime) / 1000 : undefined;
-              await captureAiGeneration(this.phClient, {
-                ...posthogParams,
-                model: openAIParams.model ?? modelFromResponse,
+              const accumulated = accumulator.result();
+              await captureAiGeneration(this.phClient, buildChatSuccessOptions({
+                client: this.phClient,
                 provider: 'azure',
-                input: sanitizeOpenAI(openAIParams.messages),
-                output: sanitizeOpenAIResponse(formattedOutput),
-                latency,
-                timeToFirstToken,
                 baseURL: this.baseURL,
-                modelParameters: getModelParams(body, serviceTierFromResponse),
-                httpStatus: 200,
-                usage,
-                completionId: completionIdFromResponse,
-                providerMetadata: buildProviderMetadata({
-                  systemFingerprint: systemFingerprintFromResponse
-                })
-              });
+                params: openAIParams,
+                monitoring: posthogParams,
+                modelParametersSource: body
+              }, {
+                ...accumulated,
+                latency: (Date.now() - startTime) / 1000,
+                timeToFirstToken: accumulated.firstTokenTime === undefined ? undefined : (accumulated.firstTokenTime - startTime) / 1000
+              }));
             } catch (error) {
-              await captureAiGeneration(this.phClient, {
-                ...posthogParams,
-                model: openAIParams.model,
+              const accumulated = accumulator.result();
+              await captureAiGeneration(this.phClient, buildChatErrorOptions({
+                client: this.phClient,
                 provider: 'azure',
-                input: sanitizeOpenAI(openAIParams.messages),
-                output: [],
-                latency: 0,
                 baseURL: this.baseURL,
-                modelParameters: getModelParams(body),
-                usage: {
-                  inputTokens: 0,
-                  outputTokens: 0
-                },
-                // If the stream fails mid-flight, surface whatever completion
-                // metadata the consumed chunks already provided so the error
-                // event can still be correlated to OpenAI's Logs dashboard.
-                completionId: completionIdFromResponse,
-                providerMetadata: buildProviderMetadata({
-                  systemFingerprint: systemFingerprintFromResponse
-                }),
-                error: error
-              });
+                params: openAIParams,
+                monitoring: posthogParams,
+                modelParametersSource: body
+              }, error, {
+                completionId: accumulated.completionId,
+                systemFingerprint: accumulated.systemFingerprint
+              }));
               throw error;
             }
           })().catch(() => {
@@ -1523,50 +1753,35 @@ let WrappedCompletions$1 = class WrappedCompletions extends openai.AzureOpenAI.C
     } else {
       const wrappedPromise = parentPromise.then(async result => {
         if ('choices' in result) {
-          const latency = (Date.now() - startTime) / 1000;
-          await captureAiGeneration(this.phClient, {
-            ...posthogParams,
-            model: openAIParams.model ?? result.model,
+          await captureAiGenerationAfterSuccess(this.phClient, buildChatSuccessOptions({
+            client: this.phClient,
             provider: 'azure',
-            input: sanitizeOpenAI(openAIParams.messages),
-            output: sanitizeOpenAIResponse(formatResponseOpenAI(result)),
-            latency,
             baseURL: this.baseURL,
-            modelParameters: getModelParams(body, result.service_tier),
-            httpStatus: 200,
-            usage: {
-              inputTokens: result.usage?.prompt_tokens ?? 0,
-              outputTokens: result.usage?.completion_tokens ?? 0,
-              reasoningTokens: result.usage?.completion_tokens_details?.reasoning_tokens ?? 0,
-              cacheReadInputTokens: result.usage?.prompt_tokens_details?.cached_tokens ?? 0,
-              cacheCreationInputTokens: extractCacheWriteTokens(result.usage?.prompt_tokens_details)
-            },
+            params: openAIParams,
+            monitoring: posthogParams,
+            modelParametersSource: body
+          }, {
+            output: formatResponseOpenAI(result),
+            model: result.model,
+            serviceTier: result.service_tier ?? undefined,
+            latency: (Date.now() - startTime) / 1000,
+            usage: buildChatUsage(result.usage, result),
+            stopReason: result.choices[0]?.finish_reason ?? undefined,
             completionId: result.id,
-            providerMetadata: buildProviderMetadata({
-              systemFingerprint: result.system_fingerprint,
-              requestId: extractRequestId(result)
-            })
-          });
+            systemFingerprint: result.system_fingerprint,
+            requestId: result._request_id
+          }));
         }
         return result;
       }, async error => {
-        const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
-        await captureAiGeneration(this.phClient, {
-          ...posthogParams,
-          model: openAIParams.model,
+        await captureAiGeneration(this.phClient, buildChatErrorOptions({
+          client: this.phClient,
           provider: 'azure',
-          input: sanitizeOpenAI(openAIParams.messages),
-          output: [],
-          latency: 0,
           baseURL: this.baseURL,
-          modelParameters: getModelParams(body),
-          httpStatus,
-          usage: {
-            inputTokens: 0,
-            outputTokens: 0
-          },
-          error
-        });
+          params: openAIParams,
+          monitoring: posthogParams,
+          modelParametersSource: body
+        }, error));
         throw error;
       });
       return preserveProviderPromise(parentPromise, wrappedPromise);
@@ -1585,32 +1800,14 @@ let WrappedResponses$1 = class WrappedResponses extends openai.AzureOpenAI.Respo
       openAIParams,
       posthogParams
     } = context;
-    await captureAiGeneration(this.phClient, {
-      ...posthogParams,
-      model: openAIParams.model ?? result.model,
+    await captureAiGenerationAfterSuccess(this.phClient, buildBackgroundResponseOptions({
+      client: this.phClient,
       provider: 'azure',
-      input: formatOpenAIResponsesInput(openAIParams.input, openAIParams.instructions),
-      output: result.output,
-      latency: getBackgroundResponseLatency(result),
       baseURL: this.baseURL,
-      modelParameters: getModelParams(openAIParams, 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,
-        cacheCreationInputTokens: extractCacheWriteTokens(result.usage?.input_tokens_details),
-        rawUsage: result.usage
-      },
-      stopReason: result.status ?? undefined,
-      completionId: result.id,
-      providerMetadata: buildProviderMetadata({
-        requestId: extractRequestId(result),
-        incompleteDetails: result.incomplete_details
-      }),
-      error: getResponseFailure(result)
-    });
+      params: openAIParams,
+      monitoring: posthogParams,
+      modelParametersSource: openAIParams
+    }, result));
   }
 
   // --- Overload #1: Non-streaming
@@ -1632,108 +1829,61 @@ let WrappedResponses$1 = class WrappedResponses extends openai.AzureOpenAI.Respo
         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.
-            let completionIdFromResponse;
+            const accumulator = new OpenAIResponsesStreamAccumulator();
             try {
-              let finalContent = [];
-              let modelFromResponse;
-              let serviceTierFromResponse;
-              let firstTokenTime;
-              let usage = {
-                inputTokens: 0,
-                outputTokens: 0
-              };
-              let terminalResponse;
               for await (const chunk of stream1) {
-                // Track first token time on content delta events
-                if (firstTokenTime === undefined && isResponseTokenChunk(chunk)) {
-                  firstTokenTime = Date.now();
-                }
-                if ('response' in chunk && chunk.response) {
-                  // Extract model and completion ID from the response object in the chunk (for stored prompts)
-                  if (!modelFromResponse && chunk.response.model) {
-                    modelFromResponse = chunk.response.model;
-                  }
-                  if (!completionIdFromResponse && chunk.response.id) {
-                    completionIdFromResponse = chunk.response.id;
-                  }
-                  if (openAIParams.background === true && !this.backgroundResponses.get(chunk.response.id)) {
-                    this.backgroundResponses.set(chunk.response.id, {
-                      openAIParams,
-                      posthogParams
-                    });
-                  }
-                  if (chunk.response.service_tier != null) {
-                    serviceTierFromResponse = chunk.response.service_tier;
-                  }
-                  if (isTerminalResponse(chunk.response)) {
-                    terminalResponse = chunk.response;
-                    finalContent = chunk.response.output ?? [];
-                  }
-                }
-                if ('response' in chunk && chunk.response?.usage) {
-                  usage = {
-                    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,
-                    cacheCreationInputTokens: extractCacheWriteTokens(chunk.response.usage.input_tokens_details)
-                  };
+                accumulator.consume(chunk);
+                if (openAIParams.background === true && 'response' in chunk && chunk.response && !this.backgroundResponses.get(chunk.response.id)) {
+                  this.backgroundResponses.set(chunk.response.id, {
+                    openAIParams,
+                    posthogParams
+                  });
                 }
               }
+              const accumulated = accumulator.result();
               if (openAIParams.background === true) {
-                if (terminalResponse) {
-                  const context = this.backgroundResponses.take(terminalResponse.id);
+                if (accumulated.terminalResponse) {
+                  const context = this.backgroundResponses.take(accumulated.terminalResponse.id);
                   if (context) {
-                    await this.captureBackgroundResponse(terminalResponse, context).catch(() => undefined);
+                    await this.captureBackgroundResponse(accumulated.terminalResponse, context).catch(() => undefined);
                   }
                 }
                 return;
               }
-              const latency = (Date.now() - startTime) / 1000;
-              const timeToFirstToken = firstTokenTime !== undefined ? (firstTokenTime - startTime) / 1000 : undefined;
-              await captureAiGeneration(this.phClient, {
-                ...posthogParams,
-                model: openAIParams.model ?? modelFromResponse,
+              const response = accumulated.terminalResponse ?? {
+                id: accumulated.completionId ?? '',
+                model: accumulated.model ?? openAIParams.model,
+                status: accumulated.stopReason,
+                service_tier: accumulated.serviceTier
+              };
+              await captureAiGeneration(this.phClient, buildResponsesSuccessOptions({
+                client: this.phClient,
                 provider: 'azure',
-                input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
-                output: sanitizeOpenAIResponse(finalContent),
-                latency,
-                timeToFirstToken,
                 baseURL: this.baseURL,
-                modelParameters: getModelParams(body, serviceTierFromResponse),
-                httpStatus: 200,
-                usage,
-                stopReason: terminalResponse?.status ?? undefined,
-                completionId: completionIdFromResponse,
-                providerMetadata: buildProviderMetadata({
-                  incompleteDetails: terminalResponse?.incomplete_details
-                }),
-                error: getResponseFailure(terminalResponse)
-              });
+                params: openAIParams,
+                monitoring: posthogParams,
+                modelParametersSource: body
+              }, {
+                response,
+                output: accumulated.output,
+                latency: (Date.now() - startTime) / 1000,
+                timeToFirstToken: accumulated.firstTokenTime === undefined ? undefined : (accumulated.firstTokenTime - startTime) / 1000,
+                usage: accumulated.usage,
+                includeTools: true
+              }));
             } catch (error) {
-              if (openAIParams.background === true && completionIdFromResponse && this.backgroundResponses.get(completionIdFromResponse)) {
+              const accumulated = accumulator.result();
+              if (openAIParams.background === true && accumulated.completionId && this.backgroundResponses.get(accumulated.completionId)) {
                 throw error;
               }
-              await captureAiGeneration(this.phClient, {
-                ...posthogParams,
-                model: openAIParams.model,
+              await captureAiGeneration(this.phClient, buildResponsesErrorOptions({
+                client: this.phClient,
                 provider: 'azure',
-                input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
-                output: [],
-                latency: 0,
                 baseURL: this.baseURL,
-                modelParameters: getModelParams(body),
-                usage: {
-                  inputTokens: 0,
-                  outputTokens: 0
-                },
-                // Surface the completion ID from any chunks consumed before
-                // the stream failed so the error event remains correlatable.
-                completionId: completionIdFromResponse,
-                error: error
-              });
+                params: openAIParams,
+                monitoring: posthogParams,
+                modelParametersSource: body
+              }, error, accumulated.completionId));
               throw error;
             }
           })().catch(() => {
@@ -1755,53 +1905,33 @@ let WrappedResponses$1 = class WrappedResponses extends openai.AzureOpenAI.Respo
             });
             return result;
           }
-          const latency = (Date.now() - startTime) / 1000;
-          await captureAiGeneration(this.phClient, {
-            ...posthogParams,
-            model: openAIParams.model ?? result.model,
+          await captureAiGenerationAfterSuccess(this.phClient, buildResponsesSuccessOptions({
+            client: this.phClient,
             provider: 'azure',
-            input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
-            output: sanitizeOpenAIResponse(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,
-              cacheCreationInputTokens: extractCacheWriteTokens(result.usage?.input_tokens_details),
-              rawUsage: result.usage
-            },
-            stopReason: result.status ?? undefined,
-            completionId: result.id,
-            providerMetadata: buildProviderMetadata({
-              requestId: extractRequestId(result),
-              incompleteDetails: result.incomplete_details
+            params: openAIParams,
+            monitoring: posthogParams,
+            modelParametersSource: body
+          }, {
+            response: result,
+            output: formatResponseOpenAI({
+              output: result.output
             }),
-            error: getResponseFailure(result)
-          });
+            latency: (Date.now() - startTime) / 1000,
+            includeTools: true,
+            includeRequestId: true
+          }));
         }
         return result;
       }, async error => {
-        const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
-        await captureAiGeneration(this.phClient, {
-          ...posthogParams,
-          model: openAIParams.model,
+        await captureAiGeneration(this.phClient, buildResponsesErrorOptions({
+          client: this.phClient,
           provider: 'azure',
-          input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
-          output: [],
-          latency: 0,
           baseURL: this.baseURL,
-          modelParameters: getModelParams(body),
-          httpStatus,
-          usage: {
-            inputTokens: 0,
-            outputTokens: 0
-          },
-          error
-        });
+          params: openAIParams,
+          monitoring: posthogParams,
+          modelParametersSource: body
+        }, error));
         throw error;
       });
       return preserveProviderPromise(parentPromise, wrappedPromise);
@@ -1871,51 +2001,29 @@ let WrappedResponses$1 = class WrappedResponses extends openai.AzureOpenAI.Respo
         });
         return result;
       }
-      const latency = (Date.now() - startTime) / 1000;
-      await captureAiGeneration(this.phClient, {
-        ...posthogParams,
-        model: openAIParams.model ?? result.model,
+      await captureAiGeneration(this.phClient, buildResponsesSuccessOptions({
+        client: this.phClient,
         provider: 'azure',
-        input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
-        output: sanitizeOpenAIResponse(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,
-          cacheCreationInputTokens: extractCacheWriteTokens(result.usage?.input_tokens_details),
-          rawUsage: result.usage
-        },
-        stopReason: result.status ?? undefined,
-        completionId: result.id,
-        providerMetadata: buildProviderMetadata({
-          requestId: extractRequestId(result),
-          incompleteDetails: result.incomplete_details
-        }),
-        error: getResponseFailure(result)
-      });
+        params: openAIParams,
+        monitoring: posthogParams,
+        modelParametersSource: body
+      }, {
+        response: result,
+        output: result.output,
+        latency: (Date.now() - startTime) / 1000,
+        includeRequestId: true
+      }));
       return result;
     }, async error => {
-      await captureAiGeneration(this.phClient, {
-        ...posthogParams,
-        model: openAIParams.model,
+      await captureAiGeneration(this.phClient, buildResponsesErrorOptions({
+        client: this.phClient,
         provider: 'azure',
-        input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
-        output: [],
-        latency: 0,
         baseURL: this.baseURL,
-        modelParameters: getModelParams(body),
-        httpStatus: error?.status ? error.status : 500,
-        usage: {
-          inputTokens: 0,
-          outputTokens: 0
-        },
-        error
-      });
+        params: openAIParams,
+        monitoring: posthogParams,
+        modelParametersSource: body
+      }, error));
       throw error;
     });
     return preserveProviderPromise(parentPromise, wrappedPromise);
@@ -1935,42 +2043,24 @@ let WrappedEmbeddings$1 = class WrappedEmbeddings extends openai.AzureOpenAI.Emb
     const startTime = Date.now();
     const parentPromise = super.create(openAIParams, options);
     const wrappedPromise = parentPromise.then(async result => {
-      const latency = (Date.now() - startTime) / 1000;
-      await captureAiGeneration(this.phClient, {
-        eventType: AIEvent.Embedding,
-        ...posthogParams,
-        model: openAIParams.model,
+      await captureAiGeneration(this.phClient, buildEmbeddingSuccessOptions({
+        client: this.phClient,
         provider: 'azure',
-        input: withPrivacyMode(this.phClient, posthogParams.privacyMode, openAIParams.input),
-        output: null,
-        // Embeddings don't have output content
-        latency,
         baseURL: this.baseURL,
-        modelParameters: getModelParams(body),
-        httpStatus: 200,
-        usage: {
-          inputTokens: result.usage?.prompt_tokens ?? 0
-        }
-      });
+        params: openAIParams,
+        monitoring: posthogParams,
+        modelParametersSource: body
+      }, result.usage, (Date.now() - startTime) / 1000));
       return result;
     }, async error => {
-      const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
-      await captureAiGeneration(this.phClient, {
-        eventType: AIEvent.Embedding,
-        ...posthogParams,
-        model: openAIParams.model,
+      await captureAiGeneration(this.phClient, buildEmbeddingErrorOptions({
+        client: this.phClient,
         provider: 'azure',
-        input: withPrivacyMode(this.phClient, posthogParams.privacyMode, openAIParams.input),
-        output: null,
-        latency: 0,
         baseURL: this.baseURL,
-        modelParameters: getModelParams(body),
-        httpStatus,
-        usage: {
-          inputTokens: 0
-        },
-        error
-      });
+        params: openAIParams,
+        monitoring: posthogParams,
+        modelParametersSource: body
+      }, error));
       throw error;
     });
     return preserveProviderPromise(parentPromise, wrappedPromise);
@@ -1983,17 +2073,6 @@ const Responses = openai.OpenAI.Responses;
 const Embeddings = openai.OpenAI.Embeddings;
 const Audio = openai.OpenAI.Audio;
 const Transcriptions = openai.OpenAI.Audio.Transcriptions;
-function captureAiGenerationInBackground(...args) {
-  void captureAiGeneration(...args).catch(() => undefined);
-}
-async function captureAiGenerationAfterSuccess(...args) {
-  const [, options] = args;
-  if (options.captureImmediate) {
-    await captureAiGeneration(...args);
-  } else {
-    captureAiGenerationInBackground(...args);
-  }
-}
 class PostHogOpenAI extends openai.OpenAI {
   constructor(config) {
     const {
@@ -2040,192 +2119,37 @@ class WrappedCompletions extends Completions {
         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.
-            let completionIdFromResponse;
-            let systemFingerprintFromResponse;
+            const accumulator = new OpenAIChatStreamAccumulator();
             try {
-              const contentBlocks = [];
-              let accumulatedContent = '';
-              let modelFromResponse;
-              let serviceTierFromResponse;
-              let firstTokenTime;
-              let stopReason;
-              let usage = {
-                inputTokens: 0,
-                outputTokens: 0,
-                webSearchCount: 0
-              };
-
-              // Map to track in-progress tool calls
-              const toolCallsInProgress = new Map();
-              let rawUsageData;
               for await (const chunk of stream1) {
-                // Extract model and completion metadata from chunk (Chat Completions chunks carry these fields)
-                if (!modelFromResponse && chunk.model) {
-                  modelFromResponse = chunk.model;
-                }
-                if (!completionIdFromResponse && chunk.id) {
-                  completionIdFromResponse = chunk.id;
-                }
-                if (!systemFingerprintFromResponse && chunk.system_fingerprint) {
-                  systemFingerprintFromResponse = chunk.system_fingerprint;
-                }
-                if (chunk.service_tier != null) {
-                  serviceTierFromResponse = chunk.service_tier;
-                }
-                const choice = chunk?.choices?.[0];
-                if (choice?.finish_reason) {
-                  stopReason = choice.finish_reason;
-                }
-                const chunkWebSearchCount = calculateWebSearchCount(chunk);
-                if (chunkWebSearchCount > 0 && chunkWebSearchCount > (usage.webSearchCount ?? 0)) {
-                  usage.webSearchCount = chunkWebSearchCount;
-                }
-
-                // Handle text content
-                const deltaContent = choice?.delta?.content;
-                if (deltaContent) {
-                  if (firstTokenTime === undefined) {
-                    firstTokenTime = Date.now();
-                  }
-                  accumulatedContent += deltaContent;
-                }
-
-                // Handle tool calls
-                const deltaToolCalls = choice?.delta?.tool_calls;
-                if (deltaToolCalls && Array.isArray(deltaToolCalls)) {
-                  if (firstTokenTime === undefined) {
-                    firstTokenTime = Date.now();
-                  }
-                  for (const toolCall of deltaToolCalls) {
-                    const index = toolCall.index;
-                    if (index !== undefined) {
-                      if (!toolCallsInProgress.has(index)) {
-                        // New tool call
-                        toolCallsInProgress.set(index, {
-                          id: toolCall.id || '',
-                          name: toolCall.function?.name || '',
-                          arguments: ''
-                        });
-                      }
-                      const inProgressCall = toolCallsInProgress.get(index);
-                      if (inProgressCall) {
-                        // Update tool call data
-                        if (toolCall.id) {
-                          inProgressCall.id = toolCall.id;
-                        }
-                        if (toolCall.function?.name) {
-                          inProgressCall.name = toolCall.function.name;
-                        }
-                        if (toolCall.function?.arguments) {
-                          inProgressCall.arguments += toolCall.function.arguments;
-                        }
-                      }
-                    }
-                  }
-                }
-
-                // Handle usage information
-                if (chunk.usage) {
-                  rawUsageData = chunk.usage;
-                  usage = {
-                    ...usage,
-                    inputTokens: chunk.usage.prompt_tokens ?? 0,
-                    outputTokens: chunk.usage.completion_tokens ?? 0,
-                    reasoningTokens: chunk.usage.completion_tokens_details?.reasoning_tokens ?? 0,
-                    cacheReadInputTokens: chunk.usage.prompt_tokens_details?.cached_tokens ?? 0,
-                    cacheCreationInputTokens: extractCacheWriteTokens(chunk.usage.prompt_tokens_details)
-                  };
-                }
-              }
-
-              // Build final content blocks
-              if (accumulatedContent) {
-                contentBlocks.push({
-                  type: 'text',
-                  text: accumulatedContent
-                });
+                accumulator.consume(chunk);
               }
-
-              // Add completed tool calls to content blocks
-              for (const toolCall of toolCallsInProgress.values()) {
-                if (toolCall.name) {
-                  contentBlocks.push({
-                    type: 'function',
-                    id: toolCall.id,
-                    function: {
-                      name: toolCall.name,
-                      arguments: toolCall.arguments
-                    }
-                  });
-                }
-              }
-
-              // Format output to match non-streaming version
-              const formattedOutput = contentBlocks.length > 0 ? [{
-                role: 'assistant',
-                content: contentBlocks
-              }] : [{
-                role: 'assistant',
-                content: [{
-                  type: 'text',
-                  text: ''
-                }]
-              }];
-              const latency = (Date.now() - startTime) / 1000;
-              const timeToFirstToken = firstTokenTime !== undefined ? (firstTokenTime - startTime) / 1000 : undefined;
-              const availableTools = extractAvailableToolCalls('openai', openAIParams);
-              await captureAiGeneration(this.phClient, {
-                ...posthogParams,
-                model: openAIParams.model ?? modelFromResponse,
+              const accumulated = accumulator.result();
+              await captureAiGeneration(this.phClient, buildChatSuccessOptions({
+                client: this.phClient,
                 provider: 'openai',
-                input: sanitizeOpenAI(openAIParams.messages),
-                output: sanitizeOpenAIResponse(formattedOutput),
-                latency,
-                timeToFirstToken,
                 baseURL: this.baseURL,
-                modelParameters: getModelParams(body, serviceTierFromResponse),
-                httpStatus: 200,
-                usage: {
-                  inputTokens: usage.inputTokens,
-                  outputTokens: usage.outputTokens,
-                  reasoningTokens: usage.reasoningTokens,
-                  cacheReadInputTokens: usage.cacheReadInputTokens,
-                  cacheCreationInputTokens: usage.cacheCreationInputTokens,
-                  webSearchCount: usage.webSearchCount,
-                  rawUsage: rawUsageData
-                },
-                stopReason,
-                tools: availableTools,
-                completionId: completionIdFromResponse,
-                providerMetadata: buildProviderMetadata({
-                  systemFingerprint: systemFingerprintFromResponse
-                })
-              });
+                params: openAIParams,
+                monitoring: posthogParams,
+                modelParametersSource: body
+              }, {
+                ...accumulated,
+                latency: (Date.now() - startTime) / 1000,
+                timeToFirstToken: accumulated.firstTokenTime === undefined ? undefined : (accumulated.firstTokenTime - startTime) / 1000
+              }));
             } catch (error) {
-              await captureAiGeneration(this.phClient, {
-                ...posthogParams,
-                model: openAIParams.model,
+              const accumulated = accumulator.result();
+              await captureAiGeneration(this.phClient, buildChatErrorOptions({
+                client: this.phClient,
                 provider: 'openai',
-                input: sanitizeOpenAI(openAIParams.messages),
-                output: [],
-                latency: 0,
                 baseURL: this.baseURL,
-                modelParameters: getModelParams(body),
-                usage: {
-                  inputTokens: 0,
-                  outputTokens: 0
-                },
-                // If the stream fails mid-flight, surface whatever completion
-                // metadata the consumed chunks already provided so the error
-                // event can still be correlated to OpenAI's Logs dashboard.
-                completionId: completionIdFromResponse,
-                providerMetadata: buildProviderMetadata({
-                  systemFingerprint: systemFingerprintFromResponse
-                }),
-                error
-              });
+                params: openAIParams,
+                monitoring: posthogParams,
+                modelParametersSource: body
+              }, error, {
+                completionId: accumulated.completionId,
+                systemFingerprint: accumulated.systemFingerprint
+              }));
               throw error;
             }
           })().catch(() => {
@@ -2242,56 +2166,35 @@ class WrappedCompletions extends Completions {
     } else {
       const wrappedPromise = parentPromise.then(async result => {
         if ('choices' in result) {
-          const latency = (Date.now() - startTime) / 1000;
-          const availableTools = extractAvailableToolCalls('openai', openAIParams);
-          const formattedOutput = formatResponseOpenAI(result);
-          await captureAiGenerationAfterSuccess(this.phClient, {
-            ...posthogParams,
-            model: openAIParams.model ?? result.model,
+          await captureAiGenerationAfterSuccess(this.phClient, buildChatSuccessOptions({
+            client: this.phClient,
             provider: 'openai',
-            input: sanitizeOpenAI(openAIParams.messages),
-            output: sanitizeOpenAIResponse(formattedOutput),
-            latency,
             baseURL: this.baseURL,
-            modelParameters: getModelParams(body, result.service_tier),
-            httpStatus: 200,
-            usage: {
-              inputTokens: result.usage?.prompt_tokens ?? 0,
-              outputTokens: result.usage?.completion_tokens ?? 0,
-              reasoningTokens: result.usage?.completion_tokens_details?.reasoning_tokens ?? 0,
-              cacheReadInputTokens: result.usage?.prompt_tokens_details?.cached_tokens ?? 0,
-              cacheCreationInputTokens: extractCacheWriteTokens(result.usage?.prompt_tokens_details),
-              webSearchCount: calculateWebSearchCount(result),
-              rawUsage: result.usage
-            },
+            params: openAIParams,
+            monitoring: posthogParams,
+            modelParametersSource: body
+          }, {
+            output: formatResponseOpenAI(result),
+            model: result.model,
+            serviceTier: result.service_tier ?? undefined,
+            latency: (Date.now() - startTime) / 1000,
+            usage: buildChatUsage(result.usage, result),
             stopReason: result.choices[0]?.finish_reason ?? undefined,
-            tools: availableTools,
             completionId: result.id,
-            providerMetadata: buildProviderMetadata({
-              systemFingerprint: result.system_fingerprint,
-              requestId: extractRequestId(result)
-            })
-          });
+            systemFingerprint: result.system_fingerprint,
+            requestId: extractRequestId(result)
+          }));
         }
         return result;
       }, async error => {
-        const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
-        await captureAiGeneration(this.phClient, {
-          ...posthogParams,
-          model: openAIParams.model,
+        await captureAiGeneration(this.phClient, buildChatErrorOptions({
+          client: this.phClient,
           provider: 'openai',
-          input: sanitizeOpenAI(openAIParams.messages),
-          output: [],
-          latency: 0,
           baseURL: this.baseURL,
-          modelParameters: getModelParams(body),
-          httpStatus,
-          usage: {
-            inputTokens: 0,
-            outputTokens: 0
-          },
-          error
-        });
+          params: openAIParams,
+          monitoring: posthogParams,
+          modelParametersSource: body
+        }, error));
         throw error;
       });
       return preserveProviderPromise(parentPromise, wrappedPromise);
@@ -2310,36 +2213,14 @@ class WrappedResponses extends Responses {
       openAIParams,
       posthogParams
     } = context;
-    await captureAiGenerationAfterSuccess(this.phClient, {
-      ...posthogParams,
-      model: openAIParams.model ?? result.model,
+    await captureAiGenerationAfterSuccess(this.phClient, buildBackgroundResponseOptions({
+      client: this.phClient,
       provider: 'openai',
-      input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
-      output: formatResponseOpenAI({
-        output: result.output
-      }),
-      latency: getBackgroundResponseLatency(result),
       baseURL: this.baseURL,
-      modelParameters: getModelParams(openAIParams, 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,
-        cacheCreationInputTokens: extractCacheWriteTokens(result.usage?.input_tokens_details),
-        webSearchCount: calculateWebSearchCount(result),
-        rawUsage: result.usage
-      },
-      stopReason: result.status ?? undefined,
-      tools: extractAvailableToolCalls('openai', openAIParams),
-      completionId: result.id,
-      providerMetadata: buildProviderMetadata({
-        requestId: extractRequestId(result),
-        incompleteDetails: result.incomplete_details
-      }),
-      error: getResponseFailure(result)
-    });
+      params: openAIParams,
+      monitoring: posthogParams,
+      modelParametersSource: openAIParams
+    }, result));
   }
 
   // --- Overload #1: Non-streaming
@@ -2361,128 +2242,61 @@ class WrappedResponses extends Responses {
         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.
-            let completionIdFromResponse;
+            const accumulator = new OpenAIResponsesStreamAccumulator();
             try {
-              let finalContent = [];
-              let modelFromResponse;
-              let serviceTierFromResponse;
-              let firstTokenTime;
-              let stopReason;
-              let usage = {
-                inputTokens: 0,
-                outputTokens: 0,
-                webSearchCount: 0
-              };
-              let rawUsageData;
-              let terminalResponse;
               for await (const chunk of stream1) {
-                // Track first token time on content delta events
-                if (firstTokenTime === undefined && isResponseTokenChunk(chunk)) {
-                  firstTokenTime = Date.now();
-                }
-                if ('response' in chunk && chunk.response) {
-                  // Extract model and completion ID from the response object in the chunk (for stored prompts)
-                  if (!modelFromResponse && chunk.response.model) {
-                    modelFromResponse = chunk.response.model;
-                  }
-                  if (!completionIdFromResponse && chunk.response.id) {
-                    completionIdFromResponse = chunk.response.id;
-                  }
-                  if (openAIParams.background === true && !this.backgroundResponses.get(chunk.response.id)) {
-                    this.backgroundResponses.set(chunk.response.id, {
-                      openAIParams,
-                      posthogParams
-                    });
-                  }
-                  if (chunk.response.service_tier != null) {
-                    serviceTierFromResponse = chunk.response.service_tier;
-                  }
-                  const chunkWebSearchCount = calculateWebSearchCount(chunk.response);
-                  if (chunkWebSearchCount > 0 && chunkWebSearchCount > (usage.webSearchCount ?? 0)) {
-                    usage.webSearchCount = chunkWebSearchCount;
-                  }
-                  if (isTerminalResponse(chunk.response)) {
-                    terminalResponse = chunk.response;
-                    finalContent = chunk.response.output ?? [];
-                    stopReason = chunk.response.status;
-                  }
-                }
-                if ('response' in chunk && chunk.response?.usage) {
-                  rawUsageData = chunk.response.usage;
-                  usage = {
-                    ...usage,
-                    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,
-                    cacheCreationInputTokens: extractCacheWriteTokens(chunk.response.usage.input_tokens_details)
-                  };
+                accumulator.consume(chunk);
+                if (openAIParams.background === true && 'response' in chunk && chunk.response && !this.backgroundResponses.get(chunk.response.id)) {
+                  this.backgroundResponses.set(chunk.response.id, {
+                    openAIParams,
+                    posthogParams
+                  });
                 }
               }
+              const accumulated = accumulator.result();
               if (openAIParams.background === true) {
-                if (terminalResponse) {
-                  const context = this.backgroundResponses.take(terminalResponse.id);
+                if (accumulated.terminalResponse) {
+                  const context = this.backgroundResponses.take(accumulated.terminalResponse.id);
                   if (context) {
-                    await this.captureBackgroundResponse(terminalResponse, context).catch(() => undefined);
+                    await this.captureBackgroundResponse(accumulated.terminalResponse, context).catch(() => undefined);
                   }
                 }
                 return;
               }
-              const latency = (Date.now() - startTime) / 1000;
-              const timeToFirstToken = firstTokenTime !== undefined ? (firstTokenTime - startTime) / 1000 : undefined;
-              const availableTools = extractAvailableToolCalls('openai', openAIParams);
-              await captureAiGeneration(this.phClient, {
-                ...posthogParams,
-                model: openAIParams.model ?? modelFromResponse,
+              const response = accumulated.terminalResponse ?? {
+                id: accumulated.completionId ?? '',
+                model: accumulated.model ?? openAIParams.model,
+                status: accumulated.stopReason,
+                service_tier: accumulated.serviceTier
+              };
+              await captureAiGeneration(this.phClient, buildResponsesSuccessOptions({
+                client: this.phClient,
                 provider: 'openai',
-                input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
-                output: sanitizeOpenAIResponse(finalContent),
-                latency,
-                timeToFirstToken,
                 baseURL: this.baseURL,
-                modelParameters: getModelParams(body, serviceTierFromResponse),
-                httpStatus: 200,
-                usage: {
-                  inputTokens: usage.inputTokens,
-                  outputTokens: usage.outputTokens,
-                  reasoningTokens: usage.reasoningTokens,
-                  cacheReadInputTokens: usage.cacheReadInputTokens,
-                  cacheCreationInputTokens: usage.cacheCreationInputTokens,
-                  webSearchCount: usage.webSearchCount,
-                  rawUsage: rawUsageData
-                },
-                stopReason,
-                tools: availableTools,
-                completionId: completionIdFromResponse,
-                providerMetadata: buildProviderMetadata({
-                  incompleteDetails: terminalResponse?.incomplete_details
-                }),
-                error: getResponseFailure(terminalResponse)
-              });
+                params: openAIParams,
+                monitoring: posthogParams,
+                modelParametersSource: body
+              }, {
+                response,
+                output: accumulated.output,
+                latency: (Date.now() - startTime) / 1000,
+                timeToFirstToken: accumulated.firstTokenTime === undefined ? undefined : (accumulated.firstTokenTime - startTime) / 1000,
+                usage: accumulated.usage,
+                includeTools: true
+              }));
             } catch (error) {
-              if (openAIParams.background === true && completionIdFromResponse && this.backgroundResponses.get(completionIdFromResponse)) {
+              const accumulated = accumulator.result();
+              if (openAIParams.background === true && accumulated.completionId && this.backgroundResponses.get(accumulated.completionId)) {
                 throw error;
               }
-              await captureAiGeneration(this.phClient, {
-                ...posthogParams,
-                model: openAIParams.model,
+              await captureAiGeneration(this.phClient, buildResponsesErrorOptions({
+                client: this.phClient,
                 provider: 'openai',
-                input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
-                output: [],
-                latency: 0,
                 baseURL: this.baseURL,
-                modelParameters: getModelParams(body),
-                usage: {
-                  inputTokens: 0,
-                  outputTokens: 0
-                },
-                // Surface the completion ID from any chunks consumed before
-                // the stream failed so the error event remains correlatable.
-                completionId: completionIdFromResponse,
-                error
-              });
+                params: openAIParams,
+                monitoring: posthogParams,
+                modelParametersSource: body
+              }, error, accumulated.completionId));
               throw error;
             }
           })().catch(() => {
@@ -2504,59 +2318,33 @@ class WrappedResponses extends Responses {
             });
             return result;
           }
-          const latency = (Date.now() - startTime) / 1000;
-          const availableTools = extractAvailableToolCalls('openai', openAIParams);
-          const formattedOutput = formatResponseOpenAI({
-            output: result.output
-          });
-          await captureAiGenerationAfterSuccess(this.phClient, {
-            ...posthogParams,
-            model: openAIParams.model ?? result.model,
+          await captureAiGenerationAfterSuccess(this.phClient, buildResponsesSuccessOptions({
+            client: this.phClient,
             provider: 'openai',
-            input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
-            output: sanitizeOpenAIResponse(formattedOutput),
-            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,
-              cacheCreationInputTokens: extractCacheWriteTokens(result.usage?.input_tokens_details),
-              webSearchCount: calculateWebSearchCount(result),
-              rawUsage: result.usage
-            },
-            stopReason: result.status ?? undefined,
-            tools: availableTools,
-            completionId: result.id,
-            providerMetadata: buildProviderMetadata({
-              requestId: extractRequestId(result),
-              incompleteDetails: result.incomplete_details
+            params: openAIParams,
+            monitoring: posthogParams,
+            modelParametersSource: body
+          }, {
+            response: result,
+            output: formatResponseOpenAI({
+              output: result.output
             }),
-            error: getResponseFailure(result)
-          });
+            latency: (Date.now() - startTime) / 1000,
+            includeTools: true,
+            includeRequestId: true
+          }));
         }
         return result;
       }, async error => {
-        const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
-        await captureAiGeneration(this.phClient, {
-          ...posthogParams,
-          model: openAIParams.model,
+        await captureAiGeneration(this.phClient, buildResponsesErrorOptions({
+          client: this.phClient,
           provider: 'openai',
-          input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
-          output: [],
-          latency: 0,
           baseURL: this.baseURL,
-          modelParameters: getModelParams(body),
-          httpStatus,
-          usage: {
-            inputTokens: 0,
-            outputTokens: 0
-          },
-          error
-        });
+          params: openAIParams,
+          monitoring: posthogParams,
+          modelParametersSource: body
+        }, error));
         throw error;
       });
       return preserveProviderPromise(parentPromise, wrappedPromise);
@@ -2626,50 +2414,29 @@ class WrappedResponses extends Responses {
         });
         return result;
       }
-      const latency = (Date.now() - startTime) / 1000;
-      await captureAiGeneration(this.phClient, {
-        ...posthogParams,
-        model: openAIParams.model ?? result.model,
+      await captureAiGeneration(this.phClient, buildResponsesSuccessOptions({
+        client: this.phClient,
         provider: 'openai',
-        input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
-        output: sanitizeOpenAIResponse(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,
-          cacheCreationInputTokens: extractCacheWriteTokens(result.usage?.input_tokens_details),
-          rawUsage: result.usage
-        },
-        stopReason: result.status ?? undefined,
-        completionId: result.id,
-        providerMetadata: buildProviderMetadata({
-          requestId: extractRequestId(result),
-          incompleteDetails: result.incomplete_details
-        }),
-        error: getResponseFailure(result)
-      });
+        params: openAIParams,
+        monitoring: posthogParams,
+        modelParametersSource: body
+      }, {
+        response: result,
+        output: result.output,
+        latency: (Date.now() - startTime) / 1000,
+        includeRequestId: true
+      }));
       return result;
     }, async error => {
-      await captureAiGeneration(this.phClient, {
-        ...posthogParams,
-        model: openAIParams.model,
+      await captureAiGeneration(this.phClient, buildResponsesErrorOptions({
+        client: this.phClient,
         provider: 'openai',
-        input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
-        output: [],
-        latency: 0,
         baseURL: this.baseURL,
-        modelParameters: getModelParams(body),
-        usage: {
-          inputTokens: 0,
-          outputTokens: 0
-        },
-        error
-      });
+        params: openAIParams,
+        monitoring: posthogParams,
+        modelParametersSource: body
+      }, error));
       throw error;
     });
     return preserveProviderPromise(parentPromise, wrappedPromise);
@@ -2689,44 +2456,24 @@ class WrappedEmbeddings extends Embeddings {
     const startTime = Date.now();
     const parentPromise = super.create(openAIParams, options);
     const wrappedPromise = parentPromise.then(async result => {
-      const latency = (Date.now() - startTime) / 1000;
-      await captureAiGeneration(this.phClient, {
-        ...posthogParams,
-        eventType: AIEvent.Embedding,
-        model: openAIParams.model,
+      await captureAiGeneration(this.phClient, buildEmbeddingSuccessOptions({
+        client: this.phClient,
         provider: 'openai',
-        input: withPrivacyMode(this.phClient, posthogParams.privacyMode, openAIParams.input),
-        output: null,
-        // Embeddings don't have output content
-        latency,
         baseURL: this.baseURL,
-        modelParameters: getModelParams(body),
-        httpStatus: 200,
-        usage: {
-          inputTokens: result.usage?.prompt_tokens ?? 0,
-          rawUsage: result.usage
-        }
-      });
+        params: openAIParams,
+        monitoring: posthogParams,
+        modelParametersSource: body
+      }, result.usage, (Date.now() - startTime) / 1000));
       return result;
     }, async error => {
-      const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
-      await captureAiGeneration(this.phClient, {
-        eventType: AIEvent.Embedding,
-        ...posthogParams,
-        model: openAIParams.model,
+      await captureAiGeneration(this.phClient, buildEmbeddingErrorOptions({
+        client: this.phClient,
         provider: 'openai',
-        input: withPrivacyMode(this.phClient, posthogParams.privacyMode, openAIParams.input),
-        output: null,
-        // Embeddings don't have output content
-        latency: 0,
         baseURL: this.baseURL,
-        modelParameters: getModelParams(body),
-        httpStatus,
-        usage: {
-          inputTokens: 0
-        },
-        error
-      });
+        params: openAIParams,
+        monitoring: posthogParams,
+        modelParametersSource: body
+      }, error));
       throw error;
     });
     return preserveProviderPromise(parentPromise, wrappedPromise);
@@ -2804,7 +2551,7 @@ class WrappedTranscriptions extends Transcriptions {
                 model: openAIParams.model,
                 provider: 'openai',
                 input: openAIParams.prompt,
-                output: sanitizeOpenAIResponse(finalContent),
+                output: sanitizeOpenAIResponse(finalContent, this.phClient),
                 latency,
                 timeToFirstToken,
                 baseURL: this.baseURL,
@@ -2849,7 +2596,7 @@ class WrappedTranscriptions extends Transcriptions {
             model: openAIParams.model,
             provider: 'openai',
             input: openAIParams.prompt,
-            output: sanitizeOpenAIResponse(result.text),
+            output: sanitizeOpenAIResponse(result.text, this.phClient),
             latency,
             baseURL: this.baseURL,
             modelParameters: getModelParams(body),