@posthog/ai 8.6.3 → 8.6.5

package/dist/anthropic/index.cjs

@@ -43,14 +43,16 @@ const FILE_FAMILY_TYPES = new Set(['file', 'input_file', 'document', 'media', 'f
 const KNOWN_AUDIO_FORMATS = new Set(['wav', 'mp3', 'ogg', 'flac', 'm4a', 'aac', 'webm']);
 class MediaTypeContext {
   static EMPTY = new MediaTypeContext(undefined, undefined);
-  constructor(parent, key) {
+  constructor(parent, key, explicitMediaType) {
     this.parent = parent;
     this.key = key;
+    this.explicitMediaType = explicitMediaType;
   }
   inferMediaType() {
     return this.inferFromSiblingMime() ?? this.inferFromSiblingFormat() ?? this.inferFromParentType() ?? this.inferFromKey();
   }
   inferFromSiblingMime() {
+    if (this.explicitMediaType) return this.explicitMediaType;
     if (!this.parent) return undefined;
     for (const hint of MIME_HINT_KEYS) {
       const v = this.parent[hint];
@@ -85,7 +87,13 @@ class MediaTypeContext {
     if (key.includes('file') || key.includes('document')) return 'application/octet-stream';
     return undefined;
   }
+  hasExplicitBinaryMediaType() {
+    if (!this.explicitMediaType && (!this.parent || !this.key || !STRONG_CONTEXT_KEYS.has(this.key))) return false;
+    const mediaType = this.inferFromSiblingMime();
+    return mediaType !== undefined && !mediaType.toLowerCase().startsWith('text/');
+  }
   signalsBinary() {
+    if (this.explicitMediaType) return true;
     if (this.parent) {
       for (const hint of MIME_HINT_KEYS) {
         if (typeof this.parent[hint] === 'string') return true;
@@ -107,10 +115,10 @@ class BinaryContentRedactor {
   constructor(recognizer = new Base64Recognizer()) {
     this.recognizer = recognizer;
   }
-  redact(value) {
+  redact(value, mediaType) {
     if (this.isMultimodalEnabled()) return value;
     this.visited = new WeakSet();
-    return this.walk(value, MediaTypeContext.EMPTY);
+    return this.walk(value, mediaType ? new MediaTypeContext(undefined, undefined, mediaType) : MediaTypeContext.EMPTY);
   }
   walk(value, ctx) {
     if (value === null || value === undefined) return value;
@@ -134,8 +142,10 @@ class BinaryContentRedactor {
     return out;
   }
   redactString(value, ctx) {
-    const minLength = ctx.signalsBinary() ? STRONG_CONTEXT_MIN_LENGTH : WEAK_CONTEXT_MIN_LENGTH;
-    const recognition = this.recognizer.recognize(value, minLength);
+    const hasExplicitBinaryMediaType = ctx.hasExplicitBinaryMediaType();
+    const recognitionValue = hasExplicitBinaryMediaType ? value.replace(/[\r\n]/g, '') : value;
+    const minLength = hasExplicitBinaryMediaType ? Math.min(recognitionValue.length, STRONG_CONTEXT_MIN_LENGTH) : ctx.signalsBinary() ? STRONG_CONTEXT_MIN_LENGTH : WEAK_CONTEXT_MIN_LENGTH;
+    const recognition = this.recognizer.recognize(recognitionValue, minLength);
     switch (recognition.kind) {
       case 'data-url':
         return this.placeholderFor(recognition.mediaType);
@@ -300,7 +310,7 @@ function addDefaults(params) {
   };
 }
 
-var version = "8.6.3";
+var version = "8.6.5";
 
 const DEFAULT_MAX_DEPTH = 3;
 const MAX_STACK_LINES = 20;
@@ -433,6 +443,8 @@ const captureAiGeneration = async (client, options) => {
       if (httpStatus === undefined) {
         if (typeof options.error === 'object' && 'status' in options.error && typeof options.error.status === 'number') {
           httpStatus = options.error.status;
+        } else if (typeof options.error === 'object' && 'statusCode' in options.error && typeof options.error.statusCode === 'number') {
+          httpStatus = options.error.statusCode;
         } else {
           httpStatus = 500;
         }
@@ -539,6 +551,77 @@ const captureAiGeneration = async (client, options) => {
   }
 };
 
+function addRequestId(result, response, requestIdHeader) {
+  if (!result || typeof result !== 'object' || Array.isArray(result)) {
+    return result;
+  }
+  return Object.defineProperty(result, '_request_id', {
+    value: response.headers.get(requestIdHeader),
+    enumerable: false
+  });
+}
+function getResponsePropsPromise(parentPromise) {
+  const responsePromise = parentPromise.responsePromise;
+  if (!responsePromise || typeof responsePromise.then !== 'function') {
+    return undefined;
+  }
+  return responsePromise;
+}
+function decorateProviderPromise(wrappedPromise, responsePropsPromise, requestIdHeader, preserveThenUnwrap) {
+  const providerPromise = wrappedPromise;
+  if (responsePropsPromise) {
+    providerPromise.asResponse = async () => (await responsePropsPromise).response;
+    providerPromise.withResponse = async () => {
+      const [props, data] = await Promise.all([responsePropsPromise, wrappedPromise]);
+      return {
+        response: props.response,
+        data,
+        request_id: props.response.headers.get(requestIdHeader)
+      };
+    };
+  }
+  if (preserveThenUnwrap) {
+    providerPromise._thenUnwrap = transform => {
+      if (!responsePropsPromise) {
+        throw new Error('The provider promise response metadata is unavailable');
+      }
+      const transformedPromise = Promise.all([wrappedPromise, responsePropsPromise]).then(([data, props]) => addRequestId(transform(data, props), props.response, requestIdHeader));
+      return decorateProviderPromise(transformedPromise, responsePropsPromise, requestIdHeader, true);
+    };
+  }
+  return providerPromise;
+}
+
+/**
+ * Keep the provider SDK helpers on a promise whose resolved value is instrumented.
+ * OpenAI's parse helpers compose create calls through `_thenUnwrap`, while both
+ * OpenAI and Anthropic expose the raw response through `asResponse` and
+ * `withResponse`.
+ */
+
+function preserveProviderPromise(parentPromise, wrappedPromise, options = {}) {
+  const responsePropsPromise = getResponsePropsPromise(parentPromise);
+  const preserveThenUnwrap = typeof parentPromise._thenUnwrap === 'function';
+  const providerPromise = decorateProviderPromise(wrappedPromise, responsePropsPromise, options.requestIdHeader ?? 'x-request-id', preserveThenUnwrap);
+  if (!responsePropsPromise) {
+    const asResponse = parentPromise.asResponse?.bind(parentPromise);
+    if (asResponse) {
+      providerPromise.asResponse = asResponse;
+    }
+    const withResponse = parentPromise.withResponse?.bind(parentPromise);
+    if (withResponse) {
+      providerPromise.withResponse = async () => {
+        const [response, data] = await Promise.all([withResponse(), wrappedPromise]);
+        return {
+          ...response,
+          data
+        };
+      };
+    }
+  }
+  return providerPromise;
+}
+
 /**
  * Splits an SDK stream into a monitoring branch and a caller branch without
  * allowing either branch to read ahead of the other. Unlike the SDKs' `tee()`
@@ -776,9 +859,9 @@ class WrappedMessages extends AnthropicOriginal__default.default.Messages {
       posthogParams
     } = extractPosthogParams(body);
     const startTime = Date.now();
-    const parentPromise = super.create(anthropicParams, options);
     if (anthropicParams.stream) {
-      return parentPromise.then(value => {
+      const parentPromise = super.create(anthropicParams, options);
+      const wrappedPromise = parentPromise.then(value => {
         let accumulatedContent = '';
         const contentBlocks = [];
         const toolsInProgress = new Map();
@@ -955,7 +1038,11 @@ class WrappedMessages extends AnthropicOriginal__default.default.Messages {
         }
         return value;
       });
+      return preserveProviderPromise(parentPromise, wrappedPromise, {
+        requestIdHeader: 'request-id'
+      });
     } else {
+      const parentPromise = super.create(anthropicParams, options);
       const wrappedPromise = parentPromise.then(async result => {
         if ('content' in result) {
           const latency = (Date.now() - startTime) / 1000;
@@ -1002,7 +1089,9 @@ class WrappedMessages extends AnthropicOriginal__default.default.Messages {
         });
         throw error;
       });
-      return wrappedPromise;
+      return preserveProviderPromise(parentPromise, wrappedPromise, {
+        requestIdHeader: 'request-id'
+      });
     }
   }
 }