@posthog/ai 7.3.1 → 7.4.0

package/dist/langchain/index.cjs

@@ -2,8 +2,10 @@
 
 require('buffer');
 var uuid = require('uuid');
+require('@posthog/core');
 
-function _interopNamespaceDefault(e) {
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
   var n = Object.create(null);
   if (e) {
     Object.keys(e).forEach(function (k) {
@@ -20,9 +22,9 @@ function _interopNamespaceDefault(e) {
   return Object.freeze(n);
 }
 
-var uuid__namespace = /*#__PURE__*/_interopNamespaceDefault(uuid);
+var uuid__namespace = /*#__PURE__*/_interopNamespace(uuid);
 
-var version = "7.3.1";
+var version = "7.4.0";
 
 // Type guards for safer type checking
 
@@ -246,6 +248,64 @@ function mapKeys(fields, mapper, map) {
 	return mapped;
 }
 
+//#region src/load/validation.ts
+/**
+* Sentinel key used to mark escaped user objects during serialization.
+*
+* When a plain object contains 'lc' key (which could be confused with LC objects),
+* we wrap it as `{"__lc_escaped__": {...original...}}`.
+*/
+const LC_ESCAPED_KEY = "__lc_escaped__";
+/**
+* Check if an object needs escaping to prevent confusion with LC objects.
+*
+* An object needs escaping if:
+* 1. It has an `'lc'` key (could be confused with LC serialization format)
+* 2. It has only the escape key (would be mistaken for an escaped object)
+*/
+function needsEscaping(obj) {
+	return "lc" in obj || Object.keys(obj).length === 1 && LC_ESCAPED_KEY in obj;
+}
+/**
+* Wrap an object in the escape marker.
+*
+* @example
+* ```typescript
+* {"key": "value"}  // becomes {"__lc_escaped__": {"key": "value"}}
+* ```
+*/
+function escapeObject(obj) {
+	return { [LC_ESCAPED_KEY]: obj };
+}
+/**
+* Check if an object looks like a Serializable instance (duck typing).
+*/
+function isSerializableLike(obj) {
+	return obj !== null && typeof obj === "object" && "lc_serializable" in obj && typeof obj.toJSON === "function";
+}
+/**
+* Escape a value if it needs escaping (contains `lc` key).
+*
+* This is a simpler version of `serializeValue` that doesn't handle Serializable
+* objects - it's meant to be called on kwargs values that have already been
+* processed by `toJSON()`.
+*
+* @param value - The value to potentially escape.
+* @returns The value with any `lc`-containing objects wrapped in escape markers.
+*/
+function escapeIfNeeded(value) {
+	if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+		if (isSerializableLike(value)) return value;
+		const record = value;
+		if (needsEscaping(record)) return escapeObject(record);
+		const result = {};
+		for (const [key, val] of Object.entries(record)) result[key] = escapeIfNeeded(val);
+		return result;
+	}
+	if (Array.isArray(value)) return value.map((item) => escapeIfNeeded(item));
+	return value;
+}
+
 //#region src/load/serializable.ts
 var serializable_exports = {};
 __export(serializable_exports, {
@@ -367,11 +427,15 @@ var Serializable = class Serializable {
 			}
 			if (last in read && read[last] !== void 0) write[last] = write[last] || read[last];
 		});
+		const escapedKwargs = {};
+		for (const [key, value] of Object.entries(kwargs)) escapedKwargs[key] = escapeIfNeeded(value);
+		const kwargsWithSecrets = Object.keys(secrets).length ? replaceSecrets(escapedKwargs, secrets) : escapedKwargs;
+		const processedKwargs = mapKeys(kwargsWithSecrets, keyToJson, aliases);
 		return {
 			lc: 1,
 			type: "constructor",
 			id: this.lc_id,
-			kwargs: mapKeys(Object.keys(secrets).length ? replaceSecrets(kwargs, secrets) : kwargs, keyToJson, aliases)
+			kwargs: processedKwargs
 		};
 	}
 	toJSONNotImplemented() {
@@ -971,7 +1035,10 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
 
       // Add additional token data to properties
       if (additionalTokenData.cacheReadInputTokens) {
-        eventProperties['$ai_cache_read_tokens'] = additionalTokenData.cacheReadInputTokens;
+        eventProperties['$ai_cache_read_input_tokens'] = additionalTokenData.cacheReadInputTokens;
+      }
+      if (additionalTokenData.cacheWriteInputTokens) {
+        eventProperties['$ai_cache_creation_input_tokens'] = additionalTokenData.cacheWriteInputTokens;
       }
       if (additionalTokenData.reasoningTokens) {
         eventProperties['$ai_reasoning_tokens'] = additionalTokenData.reasoningTokens;
@@ -1139,6 +1206,15 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
       additionalTokenData.cacheReadInputTokens = usage.input_token_details.cache_read;
     } else if (usage.cachedPromptTokens != null) {
       additionalTokenData.cacheReadInputTokens = usage.cachedPromptTokens;
+    } else if (usage.cache_read_input_tokens != null) {
+      additionalTokenData.cacheReadInputTokens = usage.cache_read_input_tokens;
+    }
+
+    // Check for cache write/creation tokens in various formats
+    if (usage.cache_creation_input_tokens != null) {
+      additionalTokenData.cacheWriteInputTokens = usage.cache_creation_input_tokens;
+    } else if (usage.input_token_details?.cache_creation != null) {
+      additionalTokenData.cacheWriteInputTokens = usage.input_token_details.cache_creation;
     }
 
     // Check for reasoning tokens in various formats
@@ -1188,8 +1264,10 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
       additionalTokenData.webSearchCount = webSearchCount;
     }
 
-    // For Anthropic providers, LangChain reports input_tokens as the sum of input and cache read tokens.
+    // For Anthropic providers, LangChain reports input_tokens as the sum of all input tokens.
     // Our cost calculation expects them to be separate for Anthropic, so we subtract cache tokens.
+    // Both cache_read and cache_write tokens should be subtracted since Anthropic's raw API
+    // reports input_tokens as tokens NOT read from or used to create a cache.
     // For other providers (OpenAI, etc.), input_tokens already excludes cache tokens as expected.
     // Match logic consistent with plugin-server: exact match on provider OR substring match on model
     let isAnthropic = false;
@@ -1198,8 +1276,11 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
     } else if (model && model.toLowerCase().includes('anthropic')) {
       isAnthropic = true;
     }
-    if (isAnthropic && parsedUsage.input && additionalTokenData.cacheReadInputTokens) {
-      parsedUsage.input = Math.max(parsedUsage.input - additionalTokenData.cacheReadInputTokens, 0);
+    if (isAnthropic && parsedUsage.input) {
+      const cacheTokens = (additionalTokenData.cacheReadInputTokens || 0) + (additionalTokenData.cacheWriteInputTokens || 0);
+      if (cacheTokens > 0) {
+        parsedUsage.input = Math.max(parsedUsage.input - cacheTokens, 0);
+      }
     }
     return [parsedUsage.input, parsedUsage.output, additionalTokenData];
   }