@posthog/ai 7.3.2 → 7.4.1

package/dist/langchain/index.cjs

@@ -2,6 +2,7 @@
 
 require('buffer');
 var uuid = require('uuid');
+require('@posthog/core');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -23,7 +24,7 @@ function _interopNamespace(e) {
 
 var uuid__namespace = /*#__PURE__*/_interopNamespace(uuid);
 
-var version = "7.3.2";
+var version = "7.4.1";
 
 // Type guards for safer type checking
 
@@ -247,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, {
@@ -368,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() {