@posthog/ai 7.17.4 → 7.18.0

package/dist/gemini/index.cjs

@@ -11,100 +11,157 @@ var core = require('@posthog/core');
 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 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]
+    };
+    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'
+      };
+    }
+  }
+}
 
-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 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 {
+  static EMPTY = new MediaTypeContext(undefined, undefined);
+  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;
   }
-};
-const isRawBase64 = str => {
-  // Skip if it's a valid URL or path
-  if (isValidUrl(str)) {
+  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;
+  }
+  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;
+  }
+  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;
+  }
+  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;
   }
+}
 
-  // 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;
+const STRONG_CONTEXT_MIN_LENGTH = 64;
+const WEAK_CONTEXT_MIN_LENGTH = 1024;
+class BinaryContentRedactor {
+  visited = new WeakSet();
+  constructor(recognizer = new Base64Recognizer()) {
+    this.recognizer = recognizer;
+  }
+  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;
+    }
   }
-
-  // Check for raw base64 (Vercel sends raw base64 for inline images)
-  if (isRawBase64(str)) {
-    return REDACTED_IMAGE_PLACEHOLDER;
+  placeholderFor(mediaType) {
+    if (!mediaType) return '[base64 redacted]';
+    if (mediaType === 'application/octet-stream') return '[base64 file redacted]';
+    return `[base64 ${mediaType} redacted]`;
   }
-  return str;
-}
-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
-      }
-    };
+  isMultimodalEnabled() {
+    const val = process.env._INTERNAL_LLMA_MULTIMODAL || '';
+    return val.toLowerCase() === 'true' || val === '1' || val.toLowerCase() === 'yes';
   }
-  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
-    };
-  }
-  return item;
-};
-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 redactor = new BinaryContentRedactor();
+function redactBase64DataUrl(str) {
+  return redactor.redact(str);
+}
+const sanitizeGemini = 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) {
@@ -327,7 +384,7 @@ function addDefaults(params) {
   };
 }
 
-var version = "7.17.4";
+var version = "7.18.0";
 
 /**
  * Options for `captureAiGeneration`. Mirrors the `$ai_generation` event shape