@posthog/ai 7.21.0 → 8.0.1

package/dist/langchain/index.mjs

@@ -1,4 +1,5 @@
-import * as uuid from 'uuid';
+import 'uuid';
+import { BaseCallbackHandler } from '@langchain/core/callbacks/base';
 
 const DATA_URL_PREFIX_RE = /^data:([^;,\s]+)(?:;[^;,\s]+)*;base64,/i;
 const BASE64_ALPHABET_RE = /^[A-Za-z0-9+/_=-]+$/;
@@ -214,470 +215,7 @@ function sanitizeValues(obj) {
   return jsonSafe;
 }
 
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-var decamelize;
-var hasRequiredDecamelize;
-
-function requireDecamelize () {
-	if (hasRequiredDecamelize) return decamelize;
-	hasRequiredDecamelize = 1;
-	decamelize = function (str, sep) {
-		if (typeof str !== 'string') {
-			throw new TypeError('Expected a string');
-		}
-
-		sep = typeof sep === 'undefined' ? '_' : sep;
-
-		return str
-			.replace(/([a-z\d])([A-Z])/g, '$1' + sep + '$2')
-			.replace(/([A-Z]+)([A-Z][a-z\d]+)/g, '$1' + sep + '$2')
-			.toLowerCase();
-	};
-	return decamelize;
-}
-
-var decamelizeExports = requireDecamelize();
-var snakeCase = /*@__PURE__*/getDefaultExportFromCjs(decamelizeExports);
-
-var camelcase = {exports: {}};
-
-var hasRequiredCamelcase;
-
-function requireCamelcase () {
-	if (hasRequiredCamelcase) return camelcase.exports;
-	hasRequiredCamelcase = 1;
-
-	const UPPERCASE = /[\p{Lu}]/u;
-	const LOWERCASE = /[\p{Ll}]/u;
-	const LEADING_CAPITAL = /^[\p{Lu}](?![\p{Lu}])/gu;
-	const IDENTIFIER = /([\p{Alpha}\p{N}_]|$)/u;
-	const SEPARATORS = /[_.\- ]+/;
-
-	const LEADING_SEPARATORS = new RegExp('^' + SEPARATORS.source);
-	const SEPARATORS_AND_IDENTIFIER = new RegExp(SEPARATORS.source + IDENTIFIER.source, 'gu');
-	const NUMBERS_AND_IDENTIFIER = new RegExp('\\d+' + IDENTIFIER.source, 'gu');
-
-	const preserveCamelCase = (string, toLowerCase, toUpperCase) => {
-		let isLastCharLower = false;
-		let isLastCharUpper = false;
-		let isLastLastCharUpper = false;
-
-		for (let i = 0; i < string.length; i++) {
-			const character = string[i];
-
-			if (isLastCharLower && UPPERCASE.test(character)) {
-				string = string.slice(0, i) + '-' + string.slice(i);
-				isLastCharLower = false;
-				isLastLastCharUpper = isLastCharUpper;
-				isLastCharUpper = true;
-				i++;
-			} else if (isLastCharUpper && isLastLastCharUpper && LOWERCASE.test(character)) {
-				string = string.slice(0, i - 1) + '-' + string.slice(i - 1);
-				isLastLastCharUpper = isLastCharUpper;
-				isLastCharUpper = false;
-				isLastCharLower = true;
-			} else {
-				isLastCharLower = toLowerCase(character) === character && toUpperCase(character) !== character;
-				isLastLastCharUpper = isLastCharUpper;
-				isLastCharUpper = toUpperCase(character) === character && toLowerCase(character) !== character;
-			}
-		}
-
-		return string;
-	};
-
-	const preserveConsecutiveUppercase = (input, toLowerCase) => {
-		LEADING_CAPITAL.lastIndex = 0;
-
-		return input.replace(LEADING_CAPITAL, m1 => toLowerCase(m1));
-	};
-
-	const postProcess = (input, toUpperCase) => {
-		SEPARATORS_AND_IDENTIFIER.lastIndex = 0;
-		NUMBERS_AND_IDENTIFIER.lastIndex = 0;
-
-		return input.replace(SEPARATORS_AND_IDENTIFIER, (_, identifier) => toUpperCase(identifier))
-			.replace(NUMBERS_AND_IDENTIFIER, m => toUpperCase(m));
-	};
-
-	const camelCase = (input, options) => {
-		if (!(typeof input === 'string' || Array.isArray(input))) {
-			throw new TypeError('Expected the input to be `string | string[]`');
-		}
-
-		options = {
-			pascalCase: false,
-			preserveConsecutiveUppercase: false,
-			...options
-		};
-
-		if (Array.isArray(input)) {
-			input = input.map(x => x.trim())
-				.filter(x => x.length)
-				.join('-');
-		} else {
-			input = input.trim();
-		}
-
-		if (input.length === 0) {
-			return '';
-		}
-
-		const toLowerCase = options.locale === false ?
-			string => string.toLowerCase() :
-			string => string.toLocaleLowerCase(options.locale);
-		const toUpperCase = options.locale === false ?
-			string => string.toUpperCase() :
-			string => string.toLocaleUpperCase(options.locale);
-
-		if (input.length === 1) {
-			return options.pascalCase ? toUpperCase(input) : toLowerCase(input);
-		}
-
-		const hasUpperCase = input !== toLowerCase(input);
-
-		if (hasUpperCase) {
-			input = preserveCamelCase(input, toLowerCase, toUpperCase);
-		}
-
-		input = input.replace(LEADING_SEPARATORS, '');
-
-		if (options.preserveConsecutiveUppercase) {
-			input = preserveConsecutiveUppercase(input, toLowerCase);
-		} else {
-			input = toLowerCase(input);
-		}
-
-		if (options.pascalCase) {
-			input = toUpperCase(input.charAt(0)) + input.slice(1);
-		}
-
-		return postProcess(input, toUpperCase);
-	};
-
-	camelcase.exports = camelCase;
-	// TODO: Remove this for the next major release
-	camelcase.exports.default = camelCase;
-	return camelcase.exports;
-}
-
-requireCamelcase();
-
-//#region src/load/map_keys.ts
-function keyToJson(key, map) {
-	return map?.[key] || snakeCase(key);
-}
-function mapKeys(fields, mapper, map) {
-	const mapped = {};
-	for (const key in fields) if (Object.hasOwn(fields, key)) mapped[mapper(key, map)] = fields[key];
-	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";
-}
-/**
-* Create a "not_implemented" serialization result for objects that cannot be serialized.
-*/
-function createNotImplemented(obj) {
-	let id;
-	if (obj !== null && typeof obj === "object") if ("lc_id" in obj && Array.isArray(obj.lc_id)) id = obj.lc_id;
-	else id = [obj.constructor?.name ?? "Object"];
-	else id = [typeof obj];
-	return {
-		lc: 1,
-		type: "not_implemented",
-		id
-	};
-}
-/**
-* 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.
-* @param pathSet - WeakSet to track ancestor objects in the current path to detect circular references.
-*                  Objects are removed after processing to allow shared references (same object in
-*                  multiple places) while still detecting true circular references (ancestor in descendant).
-* @returns The value with any `lc`-containing objects wrapped in escape markers.
-*/
-function escapeIfNeeded(value, pathSet = /* @__PURE__ */ new WeakSet()) {
-	if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-		if (pathSet.has(value)) return createNotImplemented(value);
-		if (isSerializableLike(value)) return value;
-		pathSet.add(value);
-		const record = value;
-		if (needsEscaping(record)) {
-			pathSet.delete(value);
-			return escapeObject(record);
-		}
-		const result = {};
-		for (const [key, val] of Object.entries(record)) result[key] = escapeIfNeeded(val, pathSet);
-		pathSet.delete(value);
-		return result;
-	}
-	if (Array.isArray(value)) return value.map((item) => escapeIfNeeded(item, pathSet));
-	return value;
-}
-
-function shallowCopy(obj) {
-	return Array.isArray(obj) ? [...obj] : { ...obj };
-}
-function replaceSecrets(root, secretsMap) {
-	const result = shallowCopy(root);
-	for (const [path, secretId] of Object.entries(secretsMap)) {
-		const [last, ...partsReverse] = path.split(".").reverse();
-		let current = result;
-		for (const part of partsReverse.reverse()) {
-			if (current[part] === void 0) break;
-			current[part] = shallowCopy(current[part]);
-			current = current[part];
-		}
-		if (current[last] !== void 0) current[last] = {
-			lc: 1,
-			type: "secret",
-			id: [secretId]
-		};
-	}
-	return result;
-}
-/**
-* Get a unique name for the module, rather than parent class implementations.
-* Should not be subclassed, subclass lc_name above instead.
-*/
-function get_lc_unique_name(serializableClass) {
-	const parentClass = Object.getPrototypeOf(serializableClass);
-	if (typeof serializableClass.lc_name === "function" && (typeof parentClass.lc_name !== "function" || serializableClass.lc_name() !== parentClass.lc_name())) return serializableClass.lc_name();
-	else return serializableClass.name;
-}
-var Serializable = class Serializable {
-	lc_serializable = false;
-	lc_kwargs;
-	/**
-	* The name of the serializable. Override to provide an alias or
-	* to preserve the serialized module name in minified environments.
-	*
-	* Implemented as a static method to support loading logic.
-	*/
-	static lc_name() {
-		return this.name;
-	}
-	/**
-	* The final serialized identifier for the module.
-	*/
-	get lc_id() {
-		return [...this.lc_namespace, get_lc_unique_name(this.constructor)];
-	}
-	/**
-	* A map of secrets, which will be omitted from serialization.
-	* Keys are paths to the secret in constructor args, e.g. "foo.bar.baz".
-	* Values are the secret ids, which will be used when deserializing.
-	*/
-	get lc_secrets() {}
-	/**
-	* A map of additional attributes to merge with constructor args.
-	* Keys are the attribute names, e.g. "foo".
-	* Values are the attribute values, which will be serialized.
-	* These attributes need to be accepted by the constructor as arguments.
-	*/
-	get lc_attributes() {}
-	/**
-	* A map of aliases for constructor args.
-	* Keys are the attribute names, e.g. "foo".
-	* Values are the alias that will replace the key in serialization.
-	* This is used to eg. make argument names match Python.
-	*/
-	get lc_aliases() {}
-	/**
-	* A manual list of keys that should be serialized.
-	* If not overridden, all fields passed into the constructor will be serialized.
-	*/
-	get lc_serializable_keys() {}
-	constructor(kwargs, ..._args) {
-		if (this.lc_serializable_keys !== void 0) this.lc_kwargs = Object.fromEntries(Object.entries(kwargs || {}).filter(([key]) => this.lc_serializable_keys?.includes(key)));
-		else this.lc_kwargs = kwargs ?? {};
-	}
-	toJSON() {
-		if (!this.lc_serializable) return this.toJSONNotImplemented();
-		if (this.lc_kwargs instanceof Serializable || typeof this.lc_kwargs !== "object" || Array.isArray(this.lc_kwargs)) return this.toJSONNotImplemented();
-		const aliases = {};
-		const secrets = {};
-		const kwargs = Object.keys(this.lc_kwargs).reduce((acc, key) => {
-			acc[key] = key in this ? this[key] : this.lc_kwargs[key];
-			return acc;
-		}, {});
-		for (let current = Object.getPrototypeOf(this); current; current = Object.getPrototypeOf(current)) {
-			Object.assign(aliases, Reflect.get(current, "lc_aliases", this));
-			Object.assign(secrets, Reflect.get(current, "lc_secrets", this));
-			Object.assign(kwargs, Reflect.get(current, "lc_attributes", this));
-		}
-		Object.keys(secrets).forEach((keyPath) => {
-			let read = this;
-			let write = kwargs;
-			const [last, ...partsReverse] = keyPath.split(".").reverse();
-			for (const key of partsReverse.reverse()) {
-				if (!(key in read) || read[key] === void 0) return;
-				if (!(key in write) || write[key] === void 0) {
-					if (typeof read[key] === "object" && read[key] != null) write[key] = {};
-					else if (Array.isArray(read[key])) write[key] = [];
-				}
-				read = read[key];
-				write = write[key];
-			}
-			if (last in read && read[last] !== void 0) write[last] = write[last] || read[last];
-		});
-		const escapedKwargs = {};
-		const pathSet = /* @__PURE__ */ new WeakSet();
-		pathSet.add(this);
-		for (const [key, value] of Object.entries(kwargs)) escapedKwargs[key] = escapeIfNeeded(value, pathSet);
-		const processedKwargs = mapKeys(Object.keys(secrets).length ? replaceSecrets(escapedKwargs, secrets) : escapedKwargs, keyToJson, aliases);
-		return {
-			lc: 1,
-			type: "constructor",
-			id: this.lc_id,
-			kwargs: processedKwargs
-		};
-	}
-	toJSONNotImplemented() {
-		return {
-			lc: 1,
-			type: "not_implemented",
-			id: this.lc_id
-		};
-	}
-};
-
-const isDeno = () => typeof Deno !== "undefined";
-function getEnvironmentVariable(name) {
-	try {
-		if (typeof process !== "undefined") return process.env?.[name];
-		else if (isDeno()) return Deno?.env.get(name);
-		else return;
-	} catch {
-		return;
-	}
-}
-
-/**
-* Abstract class that provides a set of optional methods that can be
-* overridden in derived classes to handle various events during the
-* execution of a LangChain application.
-*/
-var BaseCallbackHandlerMethodsClass = class {};
-/**
-* Abstract base class for creating callback handlers in the LangChain
-* framework. It provides a set of optional methods that can be overridden
-* in derived classes to handle various events during the execution of a
-* LangChain application.
-*/
-var BaseCallbackHandler = class extends BaseCallbackHandlerMethodsClass {
-	lc_serializable = false;
-	get lc_namespace() {
-		return [
-			"langchain_core",
-			"callbacks",
-			this.name
-		];
-	}
-	get lc_secrets() {}
-	get lc_attributes() {}
-	get lc_aliases() {}
-	get lc_serializable_keys() {}
-	/**
-	* The name of the serializable. Override to provide an alias or
-	* to preserve the serialized module name in minified environments.
-	*
-	* Implemented as a static method to support loading logic.
-	*/
-	static lc_name() {
-		return this.name;
-	}
-	/**
-	* The final serialized identifier for the module.
-	*/
-	get lc_id() {
-		return [...this.lc_namespace, get_lc_unique_name(this.constructor)];
-	}
-	lc_kwargs;
-	ignoreLLM = false;
-	ignoreChain = false;
-	ignoreAgent = false;
-	ignoreRetriever = false;
-	ignoreCustomEvent = false;
-	raiseError = false;
-	awaitHandlers = getEnvironmentVariable("LANGCHAIN_CALLBACKS_BACKGROUND") === "false";
-	constructor(input) {
-		super();
-		this.lc_kwargs = input || {};
-		if (input) {
-			this.ignoreLLM = input.ignoreLLM ?? this.ignoreLLM;
-			this.ignoreChain = input.ignoreChain ?? this.ignoreChain;
-			this.ignoreAgent = input.ignoreAgent ?? this.ignoreAgent;
-			this.ignoreRetriever = input.ignoreRetriever ?? this.ignoreRetriever;
-			this.ignoreCustomEvent = input.ignoreCustomEvent ?? this.ignoreCustomEvent;
-			this.raiseError = input.raiseError ?? this.raiseError;
-			this.awaitHandlers = this.raiseError || (input._awaitHandler ?? this.awaitHandlers);
-		}
-	}
-	copy() {
-		return new this.constructor(this);
-	}
-	toJSON() {
-		return Serializable.prototype.toJSON.call(this);
-	}
-	toJSONNotImplemented() {
-		return Serializable.prototype.toJSONNotImplemented.call(this);
-	}
-	static fromMethods(methods) {
-		class Handler extends BaseCallbackHandler {
-			name = uuid.v7();
-			constructor() {
-				super();
-				Object.assign(this, methods);
-			}
-		}
-		return new Handler();
-	}
-};
-
-var version = "7.21.0";
+var version = "8.0.1";
 
 const DEFAULT_MAX_DEPTH = 3;
 const MAX_STACK_LINES = 20;