@posthog/ai 8.6.7 → 8.7.0

package/dist/langchain/index.mjs

@@ -1,6 +1,12 @@
 import 'uuid';
 import { BaseCallbackHandler } from '@langchain/core/callbacks/base';
 
+// Type guards for safer type checking
+
+const isObject = value => {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+};
+
 const DATA_URL_PREFIX_RE = /^data:([^;,\s]+)(?:;[^;,\s]+)*;base64,/i;
 const BASE64_ALPHABET_RE = /^[A-Za-z0-9+/_=-]+$/;
 class Base64Recognizer {
@@ -225,7 +231,7 @@ function sanitizeValues(obj) {
   return jsonSafe;
 }
 
-var version = "8.6.7";
+var version = "8.7.0";
 
 const DEFAULT_MAX_DEPTH = 3;
 const MAX_STACK_LINES = 20;
@@ -655,6 +661,10 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
       if (additionalTokenData.cacheWriteInputTokens) {
         eventProperties['$ai_cache_creation_input_tokens'] = additionalTokenData.cacheWriteInputTokens;
       }
+      if (additionalTokenData.cacheWrite5mInputTokens !== undefined && additionalTokenData.cacheWrite1hInputTokens !== undefined) {
+        eventProperties['$ai_cache_creation_5m_input_tokens'] = additionalTokenData.cacheWrite5mInputTokens;
+        eventProperties['$ai_cache_creation_1h_input_tokens'] = additionalTokenData.cacheWrite1hInputTokens;
+      }
       if (additionalTokenData.reasoningTokens) {
         eventProperties['$ai_reasoning_tokens'] = additionalTokenData.reasoningTokens;
       }
@@ -824,7 +834,52 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
     const stopReason = messageResponseMetadata?.finish_reason || messageResponseMetadata?.stop_reason || gen.generationInfo?.finish_reason || generationResponseMetadata?.stop_reason || generationResponseMetadata?.finish_reason || gen.generationInfo?.stop_reason;
     return stopReason != null ? String(stopReason) : undefined;
   }
-  _parseUsageModel(usage, provider, model) {
+  _extractCacheCreationTtlBreakdown(cacheCreation, aggregateValues) {
+    if (!isObject(cacheCreation)) {
+      return undefined;
+    }
+    const {
+      ephemeral_5m_input_tokens: cache5m,
+      ephemeral_1h_input_tokens: cache1h
+    } = cacheCreation;
+    const providedValues = [cache5m, cache1h].filter(value => value != null);
+    if (providedValues.length === 0 || !providedValues.every(value => typeof value === 'number' && Number.isFinite(value) && value >= 0)) {
+      return undefined;
+    }
+    const breakdown = [typeof cache5m === 'number' ? cache5m : 0, typeof cache1h === 'number' ? cache1h : 0];
+    const total = breakdown[0] + breakdown[1];
+    const validAggregates = aggregateValues.filter(value => typeof value === 'number' && Number.isFinite(value) && value >= 0);
+    return total > 0 && !validAggregates.some(aggregate => aggregate !== total) ? breakdown : undefined;
+  }
+  _extractBedrockCacheCreationTtlBreakdown(cacheDetails, aggregateValues) {
+    if (!Array.isArray(cacheDetails)) {
+      return undefined;
+    }
+    let cache5m = 0;
+    let cache1h = 0;
+    for (const detail of cacheDetails) {
+      if (!isObject(detail)) {
+        continue;
+      }
+      const ttl = typeof detail.ttl === 'string' ? detail.ttl.toLowerCase() : undefined;
+      const inputTokens = detail.inputTokens;
+      if (ttl !== '5m' && ttl !== 't5m' && ttl !== '1h' && ttl !== 't1h' || typeof inputTokens !== 'number' || !Number.isFinite(inputTokens) || inputTokens < 0) {
+        continue;
+      }
+      if (ttl === '5m' || ttl === 't5m') {
+        cache5m += inputTokens;
+      } else {
+        cache1h += inputTokens;
+      }
+    }
+    const total = cache5m + cache1h;
+    const validAggregates = aggregateValues.filter(value => typeof value === 'number' && Number.isFinite(value) && value >= 0);
+    if (total === 0 || validAggregates.some(aggregate => aggregate !== total)) {
+      return undefined;
+    }
+    return [cache5m, cache1h];
+  }
+  _parseUsageModel(usage, provider, model, inputIncludesCacheTokens = true, rawUsage) {
     const conversionList = [['promptTokens', 'input'], ['completionTokens', 'output'], ['input_tokens', 'input'], ['output_tokens', 'output'], ['prompt_token_count', 'input'], ['candidates_token_count', 'output'], ['inputTokenCount', 'input'], ['outputTokenCount', 'output'], ['input_token_count', 'input'], ['generated_token_count', 'output']];
     const parsedUsage = conversionList.reduce((acc, [modelKey, typeKey]) => {
       const value = usage[modelKey];
@@ -858,6 +913,14 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
     } else if (usage.input_token_details?.cache_creation != null) {
       additionalTokenData.cacheWriteInputTokens = usage.input_token_details.cache_creation;
     }
+    const directCacheCreationAggregates = [usage.cache_creation_input_tokens, usage.input_token_details?.cache_creation, usage.cacheWriteInputTokens, rawUsage?.cache_creation_input_tokens, rawUsage?.input_token_details?.cache_creation, rawUsage?.cacheWriteInputTokens, additionalTokenData.cacheWriteInputTokens];
+    const cacheCreationTtl = this._extractCacheCreationTtlBreakdown(usage.cache_creation, directCacheCreationAggregates) ?? this._extractCacheCreationTtlBreakdown(rawUsage?.cache_creation, directCacheCreationAggregates) ?? this._extractBedrockCacheCreationTtlBreakdown(usage.cacheDetails, [usage.cacheWriteInputTokens, additionalTokenData.cacheWriteInputTokens]) ?? this._extractBedrockCacheCreationTtlBreakdown(rawUsage?.cacheDetails, [rawUsage?.cacheWriteInputTokens, additionalTokenData.cacheWriteInputTokens]);
+    if (cacheCreationTtl) {
+      const [cacheWrite5mInputTokens, cacheWrite1hInputTokens] = cacheCreationTtl;
+      additionalTokenData.cacheWrite5mInputTokens = cacheWrite5mInputTokens;
+      additionalTokenData.cacheWrite1hInputTokens = cacheWrite1hInputTokens;
+      additionalTokenData.cacheWriteInputTokens = cacheWrite5mInputTokens + cacheWrite1hInputTokens;
+    }
 
     // Check for reasoning tokens in various formats
     if (usage.completion_tokens_details?.reasoning_tokens != null) {
@@ -918,7 +981,7 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
     } else if (model && model.toLowerCase().includes('anthropic')) {
       isAnthropic = true;
     }
-    if (isAnthropic && parsedUsage.input) {
+    if (isAnthropic && inputIncludesCacheTokens && parsedUsage.input) {
       const cacheTokens = (additionalTokenData.cacheReadInputTokens || 0) + (additionalTokenData.cacheWriteInputTokens || 0);
       if (cacheTokens > 0) {
         parsedUsage.input = Math.max(parsedUsage.input - cacheTokens, 0);
@@ -927,32 +990,49 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
     return [parsedUsage.input, parsedUsage.output, additionalTokenData];
   }
   parseUsage(response, provider, model) {
-    let llmUsage = [0, 0, {}];
-    const llmUsageKeys = ['token_usage', 'usage', 'tokenUsage'];
-    if (response.llmOutput != null) {
-      const key = llmUsageKeys.find(k => response.llmOutput?.[k] != null);
-      if (key) {
-        llmUsage = this._parseUsageModel(response.llmOutput[key], provider, model);
+    const isNonEmptyUsage = usage => isObject(usage) && Object.keys(usage).length > 0;
+    const firstNonEmptyUsage = (...candidates) => candidates.find(isNonEmptyUsage);
+    let normalizedGenerationUsage;
+    let rawGenerationUsage;
+    let fallbackGenerationUsage;
+    for (const generation of response.generations ?? []) {
+      for (const genChunk of generation) {
+        const generationInfo = genChunk.generationInfo ?? {};
+        const message = 'message' in genChunk ? genChunk.message : undefined;
+        const messageUsage = message && typeof message === 'object' && 'usage_metadata' in message ? message.usage_metadata : undefined;
+        normalizedGenerationUsage = firstNonEmptyUsage(normalizedGenerationUsage, messageUsage, generationInfo.usage_metadata);
+        const messageResponseMetadata = message && typeof message === 'object' && 'response_metadata' in message && isObject(message.response_metadata) ? message.response_metadata : undefined;
+        const generationResponseMetadata = isObject(generationInfo.response_metadata) ? generationInfo.response_metadata : undefined;
+        const messageStreamMetadata = isObject(messageResponseMetadata?.metadata) ? messageResponseMetadata.metadata : undefined;
+        const generationStreamMetadata = isObject(generationResponseMetadata?.metadata) ? generationResponseMetadata.metadata : undefined;
+        rawGenerationUsage = firstNonEmptyUsage(rawGenerationUsage, messageResponseMetadata?.usage, messageStreamMetadata?.usage, generationResponseMetadata?.usage, generationStreamMetadata?.usage);
+        fallbackGenerationUsage = firstNonEmptyUsage(fallbackGenerationUsage, messageResponseMetadata?.['amazon-bedrock-invocationMetrics'], generationResponseMetadata?.['amazon-bedrock-invocationMetrics'], generationInfo.usage_metadata);
       }
     }
-
-    // If top-level usage info was not found, try checking the generations.
-    if (llmUsage[0] === 0 && llmUsage[1] === 0 && response.generations) {
-      for (const generation of response.generations) {
-        for (const genChunk of generation) {
-          const message = genChunk.message ?? {};
-          const messageResponseMetadata = message.response_metadata ?? {};
-          const generationInfo = genChunk.generationInfo ?? {};
-          const generationResponseMetadata = generationInfo.response_metadata ?? {};
-          const chunkUsage = message.usage_metadata ?? messageResponseMetadata['usage'] ?? messageResponseMetadata['amazon-bedrock-invocationMetrics'] ?? generationInfo.usage_metadata ?? generationResponseMetadata['usage'] ?? generationResponseMetadata['amazon-bedrock-invocationMetrics'];
-          if (chunkUsage) {
-            llmUsage = this._parseUsageModel(chunkUsage, provider, model);
-            return llmUsage;
-          }
+    const isAnthropic = provider?.toLowerCase() === 'anthropic' || model?.toLowerCase().includes('anthropic') === true;
+    if (isAnthropic && isNonEmptyUsage(normalizedGenerationUsage)) {
+      return this._parseUsageModel(normalizedGenerationUsage, provider, model, true, rawGenerationUsage);
+    }
+    const llmUsageKeys = ['token_usage', 'usage', 'tokenUsage'];
+    if (response.llmOutput != null) {
+      for (const key of llmUsageKeys) {
+        const llmUsage = response.llmOutput[key];
+        if (!isNonEmptyUsage(llmUsage)) {
+          continue;
         }
+        return this._parseUsageModel(llmUsage, provider, model, key !== 'usage', llmUsage);
       }
     }
-    return llmUsage;
+    if (isNonEmptyUsage(normalizedGenerationUsage)) {
+      return this._parseUsageModel(normalizedGenerationUsage, provider, model, true, rawGenerationUsage);
+    }
+    if (isNonEmptyUsage(rawGenerationUsage)) {
+      return this._parseUsageModel(rawGenerationUsage, provider, model, false, rawGenerationUsage);
+    }
+    if (isNonEmptyUsage(fallbackGenerationUsage)) {
+      return this._parseUsageModel(fallbackGenerationUsage, provider, model);
+    }
+    return [0, 0, {}];
   }
 }