@posthog/ai 7.17.4 → 7.18.0

package/dist/index.cjs

@@ -33,228 +33,160 @@ var AnthropicOriginal__default = /*#__PURE__*/_interopDefault(AnthropicOriginal)
 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]';
-// ============================================
-// Multimodal Feature Toggle
-// ============================================
-const isMultimodalEnabled = () => {
-  const val = process.env._INTERNAL_LLMA_MULTIMODAL || '';
-  return val.toLowerCase() === 'true' || val === '1' || val.toLowerCase() === 'yes';
-};
-// ============================================
-// 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 (isMultimodalEnabled()) return 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;
-}
-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)
+const DATA_URL_PREFIX_RE = /^data:([^;,\s]+)(?:;[^;,\s]+)*;base64,/i;
+const BASE64_ALPHABET_RE = /^[A-Za-z0-9+/_=-]+$/;
+class Base64Recognizer {
+  recognize(value, minLength) {
+    const dataUrl = DATA_URL_PREFIX_RE.exec(value);
+    if (dataUrl) return {
+      kind: 'data-url',
+      mediaType: dataUrl[1]
     };
-  };
-  // 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)
-      }
-    };
-  }
-  // Handle video_url format
-  if (item.type === 'video_url' && 'video_url' in item && isObject(item.video_url) && 'url' in item.video_url) {
-    return {
-      ...item,
-      video_url: {
-        ...item.video_url,
-        url: redactBase64DataUrl(item.video_url.url)
-      }
-    };
-  }
-  // Handle audio format
-  if (item.type === 'audio' && 'data' in item) {
-    if (isMultimodalEnabled()) return item;
-    return {
-      ...item,
-      data: REDACTED_IMAGE_PLACEHOLDER
+    if (value.length < minLength) return {
+      kind: 'none'
     };
+    const confidencePrefix = value.slice(0, minLength);
+    if (BASE64_ALPHABET_RE.test(confidencePrefix)) {
+      return {
+        kind: 'raw'
+      };
+    } else {
+      return {
+        kind: 'none'
+      };
+    }
   }
-  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)
-    };
+}
+
+const MIME_HINT_KEYS = ['mediaType', 'media_type', 'mimeType', 'mime_type'];
+const STRONG_CONTEXT_KEYS = new Set(['data', 'file_data', 'fileData', 'image_url', 'imageUrl', 'video_url', 'videoUrl', 'audio', 'audio_data', 'audioData', 'inline_data', 'inlineData', 'source', 'result']);
+const STRONG_CONTEXT_TYPES = new Set(['image', 'image_url', 'input_image', 'audio', 'input_audio', 'video', 'video_url', 'file', 'input_file', 'document', 'media', 'file-data']);
+const FILE_FAMILY_TYPES = new Set(['file', 'input_file', 'document', 'media', 'file-data']);
+const KNOWN_AUDIO_FORMATS = new Set(['wav', 'mp3', 'ogg', 'flac', 'm4a', 'aac', 'webm']);
+class MediaTypeContext {
+  constructor(parent, key) {
+    this.parent = parent;
+    this.key = key;
+  }
+  inferMediaType() {
+    return this.inferFromSiblingMime() ?? this.inferFromSiblingFormat() ?? this.inferFromParentType() ?? this.inferFromKey();
+  }
+  inferFromSiblingMime() {
+    if (!this.parent) return undefined;
+    for (const hint of MIME_HINT_KEYS) {
+      const v = this.parent[hint];
+      if (typeof v === 'string') return v;
+    }
+    return undefined;
   }
-  return item;
-};
-const sanitizeAnthropicImage = item => {
-  if (isMultimodalEnabled()) return item;
-  if (!isObject(item)) return item;
-  // Handle Anthropic's image and document formats (same structure, different type field)
-  if ((item.type === 'image' || item.type === 'document') && 'source' in item && isObject(item.source) && item.source.type === 'base64' && 'data' in item.source) {
-    return {
-      ...item,
-      source: {
-        ...item.source,
-        data: REDACTED_IMAGE_PLACEHOLDER
-      }
-    };
+  inferFromSiblingFormat() {
+    if (!this.parent) return undefined;
+    const fmt = this.parent.format;
+    if (typeof fmt === 'string' && KNOWN_AUDIO_FORMATS.has(fmt.toLowerCase())) {
+      return `audio/${fmt.toLowerCase()}`;
+    }
+    return undefined;
   }
-  return item;
-};
-const sanitizeGeminiPart = part => {
-  if (isMultimodalEnabled()) return part;
-  if (!isObject(part)) return part;
-  // Handle Gemini's inline data format (images, audio, PDFs all use inlineData)
-  if ('inlineData' in part && isObject(part.inlineData) && 'data' in part.inlineData) {
-    return {
-      ...part,
-      inlineData: {
-        ...part.inlineData,
-        data: REDACTED_IMAGE_PLACEHOLDER
-      }
-    };
+  inferFromParentType() {
+    if (!this.parent) return undefined;
+    const t = this.parent.type;
+    if (typeof t !== 'string') return undefined;
+    if (t === 'image' || t === 'image_url' || t === 'input_image') return 'image';
+    if (t === 'audio' || t === 'input_audio') return 'audio';
+    if (t === 'video' || t === 'video_url') return 'video';
+    if (FILE_FAMILY_TYPES.has(t)) return 'application/octet-stream';
+    return undefined;
   }
-  return part;
-};
-const processGeminiItem = item => {
-  if (!isObject(item)) return item;
-  // If it has parts, process them
-  if ('parts' in item && item.parts) {
-    const parts = Array.isArray(item.parts) ? item.parts.map(sanitizeGeminiPart) : sanitizeGeminiPart(item.parts);
-    return {
-      ...item,
-      parts
-    };
+  inferFromKey() {
+    if (!this.key) return undefined;
+    const key = this.key.toLowerCase();
+    if (key.includes('audio')) return 'audio';
+    if (key.includes('video')) return 'video';
+    if (key.includes('image')) return 'image';
+    if (key.includes('file') || key.includes('document')) return 'application/octet-stream';
+    return undefined;
   }
-  return item;
-};
-const sanitizeLangChainImage = item => {
-  if (!isObject(item)) return item;
-  // OpenAI style
-  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)
+  signalsBinary() {
+    if (this.parent) {
+      for (const hint of MIME_HINT_KEYS) {
+        if (typeof this.parent[hint] === 'string') return true;
       }
-    };
+      const fmt = this.parent.format;
+      if (typeof fmt === 'string' && KNOWN_AUDIO_FORMATS.has(fmt.toLowerCase())) return true;
+      const t = this.parent.type;
+      if (typeof t === 'string' && STRONG_CONTEXT_TYPES.has(t)) return true;
+    }
+    if (this.key && STRONG_CONTEXT_KEYS.has(this.key)) return true;
+    return false;
   }
-  // Direct image with data field
-  if (item.type === 'image' && 'data' in item) {
-    return {
-      ...item,
-      data: redactBase64DataUrl(item.data)
-    };
+}
+MediaTypeContext.EMPTY = new MediaTypeContext(undefined, undefined);
+
+const STRONG_CONTEXT_MIN_LENGTH = 64;
+const WEAK_CONTEXT_MIN_LENGTH = 1024;
+class BinaryContentRedactor {
+  constructor(recognizer = new Base64Recognizer()) {
+    this.recognizer = recognizer;
+    this.visited = new WeakSet();
+  }
+  redact(value) {
+    if (this.isMultimodalEnabled()) return value;
+    this.visited = new WeakSet();
+    return this.walk(value, MediaTypeContext.EMPTY);
+  }
+  walk(value, ctx) {
+    if (value === null || value === undefined) return value;
+    if (typeof value === 'string') return this.redactString(value, ctx);
+    if (typeof value !== 'object') return value;
+    // Buffer extends Uint8Array, so this branch catches both.
+    if (typeof Uint8Array !== 'undefined' && value instanceof Uint8Array) {
+      return this.placeholderFor(ctx.inferMediaType());
+    }
+    if (this.visited.has(value)) return null;
+    this.visited.add(value);
+    if (Array.isArray(value)) {
+      return value.map(item => this.walk(item, ctx));
+    }
+    const obj = value;
+    const out = {};
+    for (const k of Object.keys(obj)) {
+      out[k] = this.walk(obj[k], new MediaTypeContext(obj, k));
+    }
+    return out;
+  }
+  redactString(value, ctx) {
+    const minLength = ctx.signalsBinary() ? STRONG_CONTEXT_MIN_LENGTH : WEAK_CONTEXT_MIN_LENGTH;
+    const recognition = this.recognizer.recognize(value, minLength);
+    switch (recognition.kind) {
+      case 'data-url':
+        return this.placeholderFor(recognition.mediaType);
+      case 'raw':
+        return this.placeholderFor(ctx.inferMediaType());
+      case 'none':
+        return value;
+    }
   }
-  // Anthropic style
-  if (item.type === 'image' && 'source' in item && isObject(item.source) && 'data' in item.source) {
-    if (isMultimodalEnabled()) return item;
-    return {
-      ...item,
-      source: {
-        ...item.source,
-        data: redactBase64DataUrl(item.source.data)
-      }
-    };
+  placeholderFor(mediaType) {
+    if (!mediaType) return '[base64 redacted]';
+    if (mediaType === 'application/octet-stream') return '[base64 file redacted]';
+    return `[base64 ${mediaType} redacted]`;
   }
-  // Google style
-  if (item.type === 'media' && 'data' in item) {
-    return {
-      ...item,
-      data: redactBase64DataUrl(item.data)
-    };
+  isMultimodalEnabled() {
+    const val = process.env._INTERNAL_LLMA_MULTIMODAL || '';
+    return val.toLowerCase() === 'true' || val === '1' || val.toLowerCase() === 'yes';
   }
-  return item;
-};
-// Export individual sanitizers for tree-shaking
-const sanitizeOpenAI = data => {
-  return processMessages(data, sanitizeOpenAIImage);
-};
-const sanitizeOpenAIResponse = data => {
-  return processMessages(data, sanitizeOpenAIResponseImage);
-};
-const sanitizeAnthropic = data => {
-  return processMessages(data, sanitizeAnthropicImage);
-};
-const sanitizeGemini = data => {
-  // Gemini has a different structure with 'parts' directly on items instead of 'content'
-  // So we need custom processing instead of using processMessages
-  if (!data) return data;
-  if (Array.isArray(data)) {
-    return data.map(processGeminiItem);
-  }
-  return processGeminiItem(data);
-};
-const sanitizeLangChain = data => {
-  return processMessages(data, sanitizeLangChainImage);
-};
+}
+
+const redactor = new BinaryContentRedactor();
+function redactBase64DataUrl(str) {
+  return redactor.redact(str);
+}
+const sanitizeOpenAI = data => redactor.redact(data);
+const sanitizeOpenAIResponse = data => redactor.redact(data);
+const sanitizeAnthropic = data => redactor.redact(data);
+const sanitizeGemini = data => redactor.redact(data);
+const sanitizeLangChain = data => redactor.redact(data);
 
 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']);
 function getTokensSource(posthogProperties) {
@@ -801,7 +733,7 @@ function formatOpenAIResponsesInput(input, instructions) {
   return messages;
 }
 
-var version = "7.17.4";
+var version = "7.18.0";
 
 /**
  * Capture an `$ai_generation` (or `$ai_embedding`) event to PostHog.