@posthog/ai 8.6.1 → 8.6.3

package/dist/vercel/index.mjs

@@ -1,5 +1,5 @@
 import { v4 } from 'uuid';
-import { uuidv7 } from '@posthog/core';
+import { toJsonSafeValue, uuidv7 } from '@posthog/core';
 
 // Type guards for safer type checking
 
@@ -395,7 +395,7 @@ function sanitizeValues(obj) {
   return jsonSafe;
 }
 
-var version = "8.6.1";
+var version = "8.6.3";
 
 const DEFAULT_MAX_DEPTH = 3;
 const MAX_STACK_LINES = 20;
@@ -506,120 +506,131 @@ const warnIfPostHogAiGateway = baseURL => {
  * so callers can re-throw the original error reference safely.
  */
 const captureAiGeneration = async (client, options) => {
-  if (!client.capture) {
-    return;
-  }
-  warnIfPostHogAiGateway(options.baseURL);
-  const traceId = options.traceId ?? v4();
-  const eventType = options.eventType ?? AIEvent.Generation;
-  const privacyMode = options.privacyMode ?? false;
-  const usage = options.usage ?? {};
-  const safeInput = sanitizeValues(options.input);
-  const safeOutput = sanitizeValues(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 = 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 ?? 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 : toJsonSafeValue(options.input);
+    const safeOutput = shouldRedact ? null : 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;
+        }
       }
+      let exceptionId;
+      if (client.options?.enableExceptionAutocapture) {
+        exceptionId = 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: withPrivacyMode(client, privacyMode, safeInput),
-    $ai_output_choices: withPrivacyMode(client, privacyMode, 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);
   }
 };
 
@@ -1119,86 +1130,97 @@ const wrapVercelLanguageModel = (model, phClient, options) => {
 
         // Map to track in-progress tool calls
         const toolCallsInProgress = new Map();
+        const captureStreamGeneration = async captureOptions => {
+          try {
+            await captureAiGeneration(phClient, captureOptions);
+          } catch (error) {
+            // Telemetry must never change the provider stream's behavior.
+            console.warn('[PostHog AI] Failed to capture Vercel stream telemetry:', error);
+          }
+        };
         try {
           const {
             stream,
             ...rest
           } = await model.doStream(params);
-          const transformStream = new TransformStream({
-            transform(chunk, controller) {
-              // Handle streaming patterns - compatible with both V2 and V3
-              if (chunk.type === 'text-delta') {
-                if (firstTokenTime === undefined) {
-                  firstTokenTime = Date.now();
-                }
-                generatedText += chunk.delta;
+          const reader = stream.getReader();
+          let inBandError;
+          let hasInBandError = false;
+          let finalizationPromise;
+          const observeChunk = chunk => {
+            // Handle streaming patterns - compatible with both V2 and V3
+            if (chunk.type === 'text-delta') {
+              if (firstTokenTime === undefined) {
+                firstTokenTime = Date.now();
               }
-              if (chunk.type === 'reasoning-delta') {
-                if (firstTokenTime === undefined) {
-                  firstTokenTime = Date.now();
-                }
-                reasoningText += chunk.delta;
+              generatedText += chunk.delta;
+            }
+            if (chunk.type === 'reasoning-delta') {
+              if (firstTokenTime === undefined) {
+                firstTokenTime = Date.now();
               }
+              reasoningText += chunk.delta;
+            }
 
-              // Handle tool call chunks
-              if (chunk.type === 'tool-input-start') {
-                if (firstTokenTime === undefined) {
-                  firstTokenTime = Date.now();
-                }
-                // Initialize a new tool call
-                toolCallsInProgress.set(chunk.id, {
-                  toolCallId: chunk.id,
-                  toolName: chunk.toolName,
-                  input: ''
-                });
-              }
-              if (chunk.type === 'tool-input-delta') {
-                // Accumulate tool call arguments
-                const toolCall = toolCallsInProgress.get(chunk.id);
-                if (toolCall) {
-                  toolCall.input += chunk.delta;
-                }
+            // Handle tool call chunks
+            if (chunk.type === 'tool-input-start') {
+              if (firstTokenTime === undefined) {
+                firstTokenTime = Date.now();
               }
-              if (chunk.type === 'tool-input-end') {
-                // Tool call is complete, keep it in the map for final processing
+              toolCallsInProgress.set(chunk.id, {
+                toolCallId: chunk.id,
+                toolName: chunk.toolName,
+                input: ''
+              });
+            }
+            if (chunk.type === 'tool-input-delta') {
+              const toolCall = toolCallsInProgress.get(chunk.id);
+              if (toolCall) {
+                toolCall.input += chunk.delta;
               }
-              if (chunk.type === 'tool-call') {
-                if (firstTokenTime === undefined) {
-                  firstTokenTime = Date.now();
-                }
-                // Direct tool call chunk (complete tool call)
-                toolCallsInProgress.set(chunk.toolCallId, {
-                  toolCallId: chunk.toolCallId,
-                  toolName: chunk.toolName,
-                  input: chunk.input
-                });
+            }
+            if (chunk.type === 'tool-call') {
+              if (firstTokenTime === undefined) {
+                firstTokenTime = Date.now();
               }
-              if (chunk.type === 'finish') {
-                providerMetadata = chunk.providerMetadata;
-                const chunkUsage = chunk.usage || {};
-                const additionalTokenValues = extractAdditionalTokenValues(providerMetadata, chunkUsage);
-                usage = {
-                  inputTokens: extractTokenCount(chunk.usage?.inputTokens),
-                  outputTokens: extractTokenCount(chunk.usage?.outputTokens),
-                  reasoningTokens: extractReasoningTokens(chunkUsage),
-                  cacheReadInputTokens: extractCacheReadTokens(chunkUsage),
-                  ...additionalTokenValues
-                };
+              toolCallsInProgress.set(chunk.toolCallId, {
+                toolCallId: chunk.toolCallId,
+                toolName: chunk.toolName,
+                input: chunk.input
+              });
+            }
+            if (chunk.type === 'error') {
+              hasInBandError = true;
+              inBandError = chunk.error;
+            }
+            if (chunk.type === 'finish') {
+              providerMetadata = chunk.providerMetadata;
+              const chunkUsage = chunk.usage || {};
+              const additionalTokenValues = extractAdditionalTokenValues(providerMetadata, chunkUsage);
+              usage = {
+                inputTokens: extractTokenCount(chunk.usage?.inputTokens),
+                outputTokens: extractTokenCount(chunk.usage?.outputTokens),
+                reasoningTokens: extractReasoningTokens(chunkUsage),
+                cacheReadInputTokens: extractCacheReadTokens(chunkUsage),
+                ...additionalTokenValues
+              };
 
-                // Extract finish reason - V2 returns a string, V3 returns an object with .unified
-                const rawFinishReason = chunk.finishReason;
-                if (typeof rawFinishReason === 'string') {
-                  stopReason = rawFinishReason;
-                } else if (rawFinishReason && typeof rawFinishReason === 'object' && 'unified' in rawFinishReason) {
-                  stopReason = String(rawFinishReason.unified);
-                }
+              // Extract finish reason - V2 returns a string, V3 returns an object with .unified
+              const rawFinishReason = chunk.finishReason;
+              if (typeof rawFinishReason === 'string') {
+                stopReason = rawFinishReason;
+              } else if (rawFinishReason && typeof rawFinishReason === 'object' && 'unified' in rawFinishReason) {
+                stopReason = String(rawFinishReason.unified);
               }
-              controller.enqueue(chunk);
-            },
-            flush: async () => {
+            }
+          };
+          const finalize = (terminalError, isError = false) => {
+            if (finalizationPromise) {
+              return finalizationPromise;
+            }
+            finalizationPromise = (async () => {
               const latency = (Date.now() - startTime) / 1000;
               const timeToFirstToken = firstTokenTime !== undefined ? (firstTokenTime - startTime) / 1000 : undefined;
-              // Build content array similar to mapVercelOutput structure
               const content = [];
               if (reasoningText) {
                 content.push({
@@ -1212,8 +1234,6 @@ const wrapVercelLanguageModel = (model, phClient, options) => {
                   text: truncate(generatedText)
                 });
               }
-
-              // Add completed tool calls to content
               for (const toolCall of toolCallsInProgress.values()) {
                 if (toolCall.toolName) {
                   content.push({
@@ -1226,15 +1246,11 @@ const wrapVercelLanguageModel = (model, phClient, options) => {
                   });
                 }
               }
-
-              // Structure output like mapVercelOutput does
               const output = content.length > 0 ? [{
                 role: 'assistant',
                 content: content.length === 1 && content[0].type === 'text' ? content[0].text : content
               }] : [];
               const webSearchCount = extractWebSearchCount(providerMetadata, usage);
-
-              // Update usage with web search count and raw metadata
               const finalUsage = {
                 ...usage,
                 webSearchCount,
@@ -1244,29 +1260,65 @@ const wrapVercelLanguageModel = (model, phClient, options) => {
                 }
               };
               adjustAnthropicV3CacheTokens(model, modelId, provider, finalUsage);
-              await captureAiGeneration(phClient, {
+              const finishError = stopReason === 'error' ? new Error('Vercel AI SDK stream finished with an error') : undefined;
+              const error = isError ? terminalError ?? new Error('Vercel AI SDK stream failed') : hasInBandError ? inBandError ?? new Error('Vercel AI SDK stream emitted an error chunk') : finishError;
+              await captureStreamGeneration({
                 ...baseOptions,
                 model: modelId,
                 provider: provider,
                 input: mergedOptions.posthogPrivacyMode ? '' : mapVercelPrompt(params.prompt),
-                output: output,
+                output,
                 latency,
                 timeToFirstToken,
                 baseURL,
                 modelParameters: getModelParams(mergedParams),
-                httpStatus: 200,
+                httpStatus: error ? undefined : 200,
                 usage: finalUsage,
                 stopReason,
+                error,
                 tools: availableTools
               });
+            })().catch(error => {
+              // Building telemetry must not change the provider stream's behavior.
+              console.warn('[PostHog AI] Failed to capture Vercel stream telemetry:', error);
+            });
+            return finalizationPromise;
+          };
+          const instrumentedStream = new ReadableStream({
+            async pull(controller) {
+              let result;
+              try {
+                result = await reader.read();
+              } catch (error) {
+                void finalize(error, true);
+                controller.error(error);
+                return;
+              }
+              if (result.done) {
+                controller.close();
+                void finalize();
+                return;
+              }
+              try {
+                observeChunk(result.value);
+              } catch {
+                // Instrumentation must not alter or suppress provider chunks.
+              }
+              controller.enqueue(result.value);
+            },
+            cancel(reason) {
+              void finalize(reason ?? new Error('Vercel AI SDK stream was cancelled'), true);
+              return reader.cancel(reason);
             }
+          }, {
+            highWaterMark: 0
           });
           return {
-            stream: stream.pipeThrough(transformStream),
+            stream: instrumentedStream,
             ...rest
           };
         } catch (error) {
-          await captureAiGeneration(phClient, {
+          await captureStreamGeneration({
             ...baseOptions,
             model: modelId,
             provider: provider,