@posthog/ai 6.1.0 → 6.1.2

package/dist/openai/index.cjs

@@ -230,6 +230,129 @@ const sendEventToPosthog = async ({
   }
 };
 
+// Type guards for safer type checking
+
+const isString = value => {
+  return typeof value === 'string';
+};
+const isObject = value => {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+};
+
+const REDACTED_IMAGE_PLACEHOLDER = '[base64 image redacted]';
+
+// ============================================
+// Base64 Detection Helpers
+// ============================================
+
+const isBase64DataUrl = str => {
+  return /^data:([^;]+);base64,/.test(str);
+};
+const isValidUrl = str => {
+  try {
+    new URL(str);
+    return true;
+  } catch {
+    // Not an absolute URL, check if it's a relative URL or path
+    return str.startsWith('/') || str.startsWith('./') || str.startsWith('../');
+  }
+};
+const isRawBase64 = str => {
+  // Skip if it's a valid URL or path
+  if (isValidUrl(str)) {
+    return false;
+  }
+
+  // Check if it's a valid base64 string
+  // Base64 images are typically at least a few hundred chars, but we'll be conservative
+  return str.length > 20 && /^[A-Za-z0-9+/]+=*$/.test(str);
+};
+function redactBase64DataUrl(str) {
+  if (!isString(str)) return str;
+
+  // Check for data URL format
+  if (isBase64DataUrl(str)) {
+    return REDACTED_IMAGE_PLACEHOLDER;
+  }
+
+  // Check for raw base64 (Vercel sends raw base64 for inline images)
+  if (isRawBase64(str)) {
+    return REDACTED_IMAGE_PLACEHOLDER;
+  }
+  return str;
+}
+
+// ============================================
+// Common Message Processing
+// ============================================
+
+const processMessages = (messages, transformContent) => {
+  if (!messages) return messages;
+  const processContent = content => {
+    if (typeof content === 'string') return content;
+    if (!content) return content;
+    if (Array.isArray(content)) {
+      return content.map(transformContent);
+    }
+
+    // Handle single object content
+    return transformContent(content);
+  };
+  const processMessage = msg => {
+    if (!isObject(msg) || !('content' in msg)) return msg;
+    return {
+      ...msg,
+      content: processContent(msg.content)
+    };
+  };
+
+  // Handle both arrays and single messages
+  if (Array.isArray(messages)) {
+    return messages.map(processMessage);
+  }
+  return processMessage(messages);
+};
+
+// ============================================
+// Provider-Specific Image Sanitizers
+// ============================================
+
+const sanitizeOpenAIImage = item => {
+  if (!isObject(item)) return item;
+
+  // Handle image_url format
+  if (item.type === 'image_url' && 'image_url' in item && isObject(item.image_url) && 'url' in item.image_url) {
+    return {
+      ...item,
+      image_url: {
+        ...item.image_url,
+        url: redactBase64DataUrl(item.image_url.url)
+      }
+    };
+  }
+  return item;
+};
+const sanitizeOpenAIResponseImage = item => {
+  if (!isObject(item)) return item;
+
+  // Handle input_image format
+  if (item.type === 'input_image' && 'image_url' in item) {
+    return {
+      ...item,
+      image_url: redactBase64DataUrl(item.image_url)
+    };
+  }
+  return item;
+};
+
+// Export individual sanitizers for tree-shaking
+const sanitizeOpenAI = data => {
+  return processMessages(data, sanitizeOpenAIImage);
+};
+const sanitizeOpenAIResponse = data => {
+  return processMessages(data, sanitizeOpenAIResponseImage);
+};
+
 const Chat = openai.OpenAI.Chat;
 const Completions = Chat.Completions;
 const Responses = openai.OpenAI.Responses;
@@ -284,14 +407,56 @@ class WrappedCompletions extends Completions {
           const [stream1, stream2] = value.tee();
           (async () => {
             try {
+              const contentBlocks = [];
               let accumulatedContent = '';
               let usage = {
                 inputTokens: 0,
                 outputTokens: 0
               };
+
+              // Map to track in-progress tool calls
+              const toolCallsInProgress = new Map();
               for await (const chunk of stream1) {
-                const delta = chunk?.choices?.[0]?.delta?.content ?? '';
-                accumulatedContent += delta;
+                const choice = chunk?.choices?.[0];
+
+                // Handle text content
+                const deltaContent = choice?.delta?.content;
+                if (deltaContent) {
+                  accumulatedContent += deltaContent;
+                }
+
+                // Handle tool calls
+                const deltaToolCalls = choice?.delta?.tool_calls;
+                if (deltaToolCalls && Array.isArray(deltaToolCalls)) {
+                  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,
@@ -301,6 +466,40 @@ class WrappedCompletions extends Completions {
                   };
                 }
               }
+
+              // Build final content blocks
+              if (accumulatedContent) {
+                contentBlocks.push({
+                  type: 'text',
+                  text: accumulatedContent
+                });
+              }
+
+              // 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 availableTools = extractAvailableToolCalls('openai', openAIParams);
               await sendEventToPosthog({
@@ -309,11 +508,8 @@ class WrappedCompletions extends Completions {
                 traceId,
                 model: openAIParams.model,
                 provider: 'openai',
-                input: openAIParams.messages,
-                output: [{
-                  content: accumulatedContent,
-                  role: 'assistant'
-                }],
+                input: sanitizeOpenAI(openAIParams.messages),
+                output: formattedOutput,
                 latency,
                 baseURL: this.baseURL ?? '',
                 params: body,
@@ -323,18 +519,19 @@ class WrappedCompletions extends Completions {
                 captureImmediate: posthogCaptureImmediate
               });
             } catch (error) {
+              const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
               await sendEventToPosthog({
                 client: this.phClient,
                 distinctId: posthogDistinctId,
                 traceId,
                 model: openAIParams.model,
                 provider: 'openai',
-                input: openAIParams.messages,
+                input: sanitizeOpenAI(openAIParams.messages),
                 output: [],
                 latency: 0,
                 baseURL: this.baseURL ?? '',
                 params: body,
-                httpStatus: error?.status ? error.status : 500,
+                httpStatus,
                 usage: {
                   inputTokens: 0,
                   outputTokens: 0
@@ -362,7 +559,7 @@ class WrappedCompletions extends Completions {
             traceId,
             model: openAIParams.model,
             provider: 'openai',
-            input: openAIParams.messages,
+            input: sanitizeOpenAI(openAIParams.messages),
             output: formatResponseOpenAI(result),
             latency,
             baseURL: this.baseURL ?? '',
@@ -380,18 +577,19 @@ class WrappedCompletions extends Completions {
         }
         return result;
       }, async error => {
+        const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
         await sendEventToPosthog({
           client: this.phClient,
           distinctId: posthogDistinctId,
           traceId,
           model: openAIParams.model,
           provider: 'openai',
-          input: openAIParams.messages,
+          input: sanitizeOpenAI(openAIParams.messages),
           output: [],
           latency: 0,
           baseURL: this.baseURL ?? '',
           params: body,
-          httpStatus: error?.status ? error.status : 500,
+          httpStatus,
           usage: {
             inputTokens: 0,
             outputTokens: 0
@@ -466,7 +664,7 @@ class WrappedResponses extends Responses {
                 //@ts-expect-error
                 model: openAIParams.model,
                 provider: 'openai',
-                input: openAIParams.input,
+                input: sanitizeOpenAIResponse(openAIParams.input),
                 output: finalContent,
                 latency,
                 baseURL: this.baseURL ?? '',
@@ -477,6 +675,7 @@ class WrappedResponses extends Responses {
                 captureImmediate: posthogCaptureImmediate
               });
             } catch (error) {
+              const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
               await sendEventToPosthog({
                 client: this.phClient,
                 distinctId: posthogDistinctId,
@@ -484,12 +683,12 @@ class WrappedResponses extends Responses {
                 //@ts-expect-error
                 model: openAIParams.model,
                 provider: 'openai',
-                input: openAIParams.input,
+                input: sanitizeOpenAIResponse(openAIParams.input),
                 output: [],
                 latency: 0,
                 baseURL: this.baseURL ?? '',
                 params: body,
-                httpStatus: error?.status ? error.status : 500,
+                httpStatus,
                 usage: {
                   inputTokens: 0,
                   outputTokens: 0
@@ -516,7 +715,7 @@ class WrappedResponses extends Responses {
             //@ts-expect-error
             model: openAIParams.model,
             provider: 'openai',
-            input: openAIParams.input,
+            input: sanitizeOpenAIResponse(openAIParams.input),
             output: formatResponseOpenAI({
               output: result.output
             }),
@@ -536,6 +735,7 @@ class WrappedResponses extends Responses {
         }
         return result;
       }, async error => {
+        const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
         await sendEventToPosthog({
           client: this.phClient,
           distinctId: posthogDistinctId,
@@ -543,12 +743,12 @@ class WrappedResponses extends Responses {
           //@ts-expect-error
           model: openAIParams.model,
           provider: 'openai',
-          input: openAIParams.input,
+          input: sanitizeOpenAIResponse(openAIParams.input),
           output: [],
           latency: 0,
           baseURL: this.baseURL ?? '',
           params: body,
-          httpStatus: error?.status ? error.status : 500,
+          httpStatus,
           usage: {
             inputTokens: 0,
             outputTokens: 0
@@ -592,7 +792,7 @@ class WrappedResponses extends Responses {
           //@ts-expect-error
           model: openAIParams.model,
           provider: 'openai',
-          input: openAIParams.input,
+          input: sanitizeOpenAIResponse(openAIParams.input),
           output: result.output,
           latency,
           baseURL: this.baseURL ?? '',
@@ -608,6 +808,7 @@ class WrappedResponses extends Responses {
         });
         return result;
       }, async error => {
+        const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
         await sendEventToPosthog({
           client: this.phClient,
           distinctId: posthogDistinctId,
@@ -615,12 +816,12 @@ class WrappedResponses extends Responses {
           //@ts-expect-error
           model: openAIParams.model,
           provider: 'openai',
-          input: openAIParams.input,
+          input: sanitizeOpenAIResponse(openAIParams.input),
           output: [],
           latency: 0,
           baseURL: this.baseURL ?? '',
           params: body,
-          httpStatus: error?.status ? error.status : 500,
+          httpStatus,
           usage: {
             inputTokens: 0,
             outputTokens: 0