langchain 0.0.194 → 0.0.196

package/dist/load/index.js

@@ -1,152 +1,11 @@
-import { get_lc_unique_name, } from "./serializable.js";
+import { load as coreLoad } from "langchain-core/load";
 import { optionalImportEntrypoints } from "./import_constants.js";
 import * as importMap from "./import_map.js";
-import { keyFromJson, mapKeys } from "./map_keys.js";
-import { getEnvironmentVariable } from "../util/env.js";
-function combineAliasesAndInvert(constructor) {
-    const aliases = {};
-    for (
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    let current = constructor; current && current.prototype; current = Object.getPrototypeOf(current)) {
-        Object.assign(aliases, Reflect.get(current.prototype, "lc_aliases"));
-    }
-    return Object.entries(aliases).reduce((acc, [key, value]) => {
-        acc[value] = key;
-        return acc;
-    }, {});
-}
-async function reviver(value) {
-    const { optionalImportsMap, secretsMap, path = ["$"] } = this;
-    const pathStr = path.join(".");
-    if (typeof value === "object" &&
-        value !== null &&
-        !Array.isArray(value) &&
-        "lc" in value &&
-        "type" in value &&
-        "id" in value &&
-        value.lc === 1 &&
-        value.type === "secret") {
-        const serialized = value;
-        const [key] = serialized.id;
-        if (key in secretsMap) {
-            return secretsMap[key];
-        }
-        else {
-            const secretValueInEnv = getEnvironmentVariable(key);
-            if (secretValueInEnv) {
-                return secretValueInEnv;
-            }
-            else {
-                throw new Error(`Missing key "${key}" for ${pathStr} in load(secretsMap={})`);
-            }
-        }
-    }
-    else if (typeof value === "object" &&
-        value !== null &&
-        !Array.isArray(value) &&
-        "lc" in value &&
-        "type" in value &&
-        "id" in value &&
-        value.lc === 1 &&
-        value.type === "not_implemented") {
-        const serialized = value;
-        const str = JSON.stringify(serialized);
-        throw new Error(`Trying to load an object that doesn't implement serialization: ${pathStr} -> ${str}`);
-    }
-    else if (typeof value === "object" &&
-        value !== null &&
-        !Array.isArray(value) &&
-        "lc" in value &&
-        "type" in value &&
-        "id" in value &&
-        "kwargs" in value &&
-        value.lc === 1) {
-        const serialized = value;
-        const str = JSON.stringify(serialized);
-        const [name, ...namespaceReverse] = serialized.id.slice().reverse();
-        const namespace = namespaceReverse.reverse();
-        let module;
-        if (optionalImportEntrypoints.includes(namespace.join("/")) ||
-            namespace.join("/") in optionalImportsMap) {
-            if (namespace.join("/") in optionalImportsMap) {
-                module = await optionalImportsMap[namespace.join("/")];
-            }
-            else {
-                throw new Error(`Missing key "${namespace.join("/")}" for ${pathStr} in load(optionalImportsMap={})`);
-            }
-        }
-        else {
-            // Currently, we only support langchain imports.
-            if (namespace[0] === "langchain") {
-                namespace.shift();
-            }
-            else {
-                throw new Error(`Invalid namespace: ${pathStr} -> ${str}`);
-            }
-            // The root namespace "langchain" is not a valid import.
-            if (namespace.length === 0) {
-                throw new Error(`Invalid namespace: ${pathStr} -> ${str}`);
-            }
-            // Find the longest matching namespace.
-            let importMapKey;
-            do {
-                importMapKey = namespace.join("__");
-                if (importMapKey in importMap) {
-                    break;
-                }
-                else {
-                    namespace.pop();
-                }
-            } while (namespace.length > 0);
-            // If no matching namespace is found, throw an error.
-            if (importMapKey in importMap) {
-                module = importMap[importMapKey];
-            }
-        }
-        if (typeof module !== "object" || module === null) {
-            throw new Error(`Invalid namespace: ${pathStr} -> ${str}`);
-        }
-        // Extract the builder from the import map.
-        const builder = 
-        // look for a named export with the same name as the class
-        module[name] ??
-            // look for an export with a lc_name property matching the class name
-            // this is necessary for classes that are minified
-            Object.values(module).find((v) => typeof v === "function" &&
-                get_lc_unique_name(v) === name);
-        if (typeof builder !== "function") {
-            throw new Error(`Invalid identifer: ${pathStr} -> ${str}`);
-        }
-        // Recurse on the arguments, which may be serialized objects themselves
-        const kwargs = await reviver.call({ ...this, path: [...path, "kwargs"] }, serialized.kwargs);
-        // Construct the object
-        if (serialized.type === "constructor") {
-            // eslint-disable-next-line new-cap, @typescript-eslint/no-explicit-any
-            const instance = new builder(mapKeys(kwargs, keyFromJson, combineAliasesAndInvert(builder)));
-            // Minification in severless/edge runtimes will mange the
-            // name of classes presented in traces. As the names in import map
-            // are present as-is even with minification, use these names instead
-            Object.defineProperty(instance.constructor, "name", { value: name });
-            return instance;
-        }
-        else {
-            throw new Error(`Invalid type: ${pathStr} -> ${str}`);
-        }
-    }
-    else if (typeof value === "object" && value !== null) {
-        if (Array.isArray(value)) {
-            return Promise.all(value.map((v, i) => reviver.call({ ...this, path: [...path, `${i}`] }, v)));
-        }
-        else {
-            return Object.fromEntries(await Promise.all(Object.entries(value).map(async ([key, value]) => [
-                key,
-                await reviver.call({ ...this, path: [...path, key] }, value),
-            ])));
-        }
-    }
-    return value;
-}
 export async function load(text, secretsMap = {}, optionalImportsMap = {}) {
-    const json = JSON.parse(text);
-    return reviver.call({ secretsMap, optionalImportsMap }, json);
+    return coreLoad(text, {
+        secretsMap,
+        optionalImportsMap,
+        optionalImportEntrypoints,
+        importMap,
+    });
 }

package/dist/load/map_keys.cjs

@@ -1,26 +1,2 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapKeys = exports.keyFromJson = exports.keyToJson = void 0;
-const decamelize_1 = __importDefault(require("decamelize"));
-const camelcase_1 = __importDefault(require("camelcase"));
-function keyToJson(key, map) {
-    return map?.[key] || (0, decamelize_1.default)(key);
-}
-exports.keyToJson = keyToJson;
-function keyFromJson(key, map) {
-    return map?.[key] || (0, camelcase_1.default)(key);
-}
-exports.keyFromJson = keyFromJson;
-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;
-}
-exports.mapKeys = mapKeys;

package/dist/load/map_keys.d.ts

@@ -1,9 +1,3 @@
 export interface SerializedFields {
     [key: string]: any;
 }
-export interface SerializedKeyAlias {
-    [key: string]: string;
-}
-export declare function keyToJson(key: string, map?: SerializedKeyAlias): string;
-export declare function keyFromJson(key: string, map?: SerializedKeyAlias): string;
-export declare function mapKeys(fields: SerializedFields, mapper: typeof keyToJson, map?: SerializedKeyAlias): SerializedFields;

package/dist/load/map_keys.js

@@ -1,17 +1 @@
-import snakeCase from "decamelize";
-import camelCase from "camelcase";
-export function keyToJson(key, map) {
-    return map?.[key] || snakeCase(key);
-}
-export function keyFromJson(key, map) {
-    return map?.[key] || camelCase(key);
-}
-export 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;
-}
+export {};

package/dist/load/serializable.cjs

@@ -1,180 +1,17 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Serializable = exports.get_lc_unique_name = void 0;
-const map_keys_js_1 = require("./map_keys.cjs");
-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();
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let current = result;
-        for (const part of partsReverse.reverse()) {
-            if (current[part] === undefined) {
-                break;
-            }
-            current[part] = shallowCopy(current[part]);
-            current = current[part];
-        }
-        if (current[last] !== undefined) {
-            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(
-// eslint-disable-next-line @typescript-eslint/no-use-before-define
-serializableClass) {
-    // "super" here would refer to the parent class of Serializable,
-    // when we want the parent class of the module actually calling this method.
-    const parentClass = Object.getPrototypeOf(serializableClass);
-    const lcNameIsSubclassed = typeof serializableClass.lc_name === "function" &&
-        (typeof parentClass.lc_name !== "function" ||
-            serializableClass.lc_name() !== parentClass.lc_name());
-    if (lcNameIsSubclassed) {
-        return serializableClass.lc_name();
-    }
-    else {
-        return serializableClass.name;
-    }
-}
-exports.get_lc_unique_name = get_lc_unique_name;
-class Serializable {
-    /**
-     * 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() {
-        return undefined;
-    }
-    /**
-     * 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() {
-        return undefined;
-    }
-    /**
-     * 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() {
-        return undefined;
-    }
-    constructor(kwargs, ..._args) {
-        Object.defineProperty(this, "lc_serializable", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "lc_kwargs", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.lc_kwargs = kwargs || {};
-    }
-    toJSON() {
-        if (!this.lc_serializable) {
-            return this.toJSONNotImplemented();
-        }
-        if (
-        // eslint-disable-next-line no-instanceof/no-instanceof
-        this.lc_kwargs instanceof Serializable ||
-            typeof this.lc_kwargs !== "object" ||
-            Array.isArray(this.lc_kwargs)) {
-            // We do not support serialization of classes with arg not a POJO
-            // I'm aware the check above isn't as strict as it could be
-            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;
-        }, {});
-        // get secrets, attributes and aliases from all superclasses
-        for (
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        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));
-        }
-        // include all secrets used, even if not in kwargs,
-        // will be replaced with sentinel value in replaceSecrets
-        Object.keys(secrets).forEach((keyPath) => {
-            // eslint-disable-next-line @typescript-eslint/no-this-alias, @typescript-eslint/no-explicit-any
-            let read = this;
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            let write = kwargs;
-            const [last, ...partsReverse] = keyPath.split(".").reverse();
-            for (const key of partsReverse.reverse()) {
-                if (!(key in read) || read[key] === undefined)
-                    return;
-                if (!(key in write) || write[key] === undefined) {
-                    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] !== undefined) {
-                write[last] = write[last] || read[last];
-            }
-        });
-        return {
-            lc: 1,
-            type: "constructor",
-            id: this.lc_id,
-            kwargs: (0, map_keys_js_1.mapKeys)(Object.keys(secrets).length ? replaceSecrets(kwargs, secrets) : kwargs, map_keys_js_1.keyToJson, aliases),
-        };
-    }
-    toJSONNotImplemented() {
-        return {
-            lc: 1,
-            type: "not_implemented",
-            id: this.lc_id,
-        };
-    }
-}
-exports.Serializable = Serializable;
+__exportStar(require("langchain-core/load/serializable"), exports);

package/dist/load/serializable.d.ts

@@ -1,66 +1 @@
-import { SerializedFields } from "./map_keys.js";
-export interface BaseSerialized<T extends string> {
-    lc: number;
-    type: T;
-    id: string[];
-}
-export interface SerializedConstructor extends BaseSerialized<"constructor"> {
-    kwargs: SerializedFields;
-}
-export interface SerializedSecret extends BaseSerialized<"secret"> {
-}
-export interface SerializedNotImplemented extends BaseSerialized<"not_implemented"> {
-}
-export type Serialized = SerializedConstructor | SerializedSecret | SerializedNotImplemented;
-/**
- * Get a unique name for the module, rather than parent class implementations.
- * Should not be subclassed, subclass lc_name above instead.
- */
-export declare function get_lc_unique_name(serializableClass: typeof Serializable): string;
-export declare abstract class Serializable {
-    lc_serializable: boolean;
-    lc_kwargs: SerializedFields;
-    /**
-     * A path to the module that contains the class, eg. ["langchain", "llms"]
-     * Usually should be the same as the entrypoint the class is exported from.
-     */
-    abstract lc_namespace: string[];
-    /**
-     * 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(): string;
-    /**
-     * The final serialized identifier for the module.
-     */
-    get lc_id(): string[];
-    /**
-     * 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(): {
-        [key: string]: string;
-    } | undefined;
-    /**
-     * 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(): SerializedFields | undefined;
-    /**
-     * 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(): {
-        [key: string]: string;
-    } | undefined;
-    constructor(kwargs?: SerializedFields, ..._args: never[]);
-    toJSON(): Serialized;
-    toJSONNotImplemented(): SerializedNotImplemented;
-}
+export * from "langchain-core/load/serializable";

package/dist/load/serializable.js

@@ -1,175 +1 @@
-import { keyToJson, mapKeys } from "./map_keys.js";
-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();
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let current = result;
-        for (const part of partsReverse.reverse()) {
-            if (current[part] === undefined) {
-                break;
-            }
-            current[part] = shallowCopy(current[part]);
-            current = current[part];
-        }
-        if (current[last] !== undefined) {
-            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.
- */
-export function get_lc_unique_name(
-// eslint-disable-next-line @typescript-eslint/no-use-before-define
-serializableClass) {
-    // "super" here would refer to the parent class of Serializable,
-    // when we want the parent class of the module actually calling this method.
-    const parentClass = Object.getPrototypeOf(serializableClass);
-    const lcNameIsSubclassed = typeof serializableClass.lc_name === "function" &&
-        (typeof parentClass.lc_name !== "function" ||
-            serializableClass.lc_name() !== parentClass.lc_name());
-    if (lcNameIsSubclassed) {
-        return serializableClass.lc_name();
-    }
-    else {
-        return serializableClass.name;
-    }
-}
-export class Serializable {
-    /**
-     * 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() {
-        return undefined;
-    }
-    /**
-     * 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() {
-        return undefined;
-    }
-    /**
-     * 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() {
-        return undefined;
-    }
-    constructor(kwargs, ..._args) {
-        Object.defineProperty(this, "lc_serializable", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "lc_kwargs", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.lc_kwargs = kwargs || {};
-    }
-    toJSON() {
-        if (!this.lc_serializable) {
-            return this.toJSONNotImplemented();
-        }
-        if (
-        // eslint-disable-next-line no-instanceof/no-instanceof
-        this.lc_kwargs instanceof Serializable ||
-            typeof this.lc_kwargs !== "object" ||
-            Array.isArray(this.lc_kwargs)) {
-            // We do not support serialization of classes with arg not a POJO
-            // I'm aware the check above isn't as strict as it could be
-            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;
-        }, {});
-        // get secrets, attributes and aliases from all superclasses
-        for (
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        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));
-        }
-        // include all secrets used, even if not in kwargs,
-        // will be replaced with sentinel value in replaceSecrets
-        Object.keys(secrets).forEach((keyPath) => {
-            // eslint-disable-next-line @typescript-eslint/no-this-alias, @typescript-eslint/no-explicit-any
-            let read = this;
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            let write = kwargs;
-            const [last, ...partsReverse] = keyPath.split(".").reverse();
-            for (const key of partsReverse.reverse()) {
-                if (!(key in read) || read[key] === undefined)
-                    return;
-                if (!(key in write) || write[key] === undefined) {
-                    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] !== undefined) {
-                write[last] = write[last] || read[last];
-            }
-        });
-        return {
-            lc: 1,
-            type: "constructor",
-            id: this.lc_id,
-            kwargs: mapKeys(Object.keys(secrets).length ? replaceSecrets(kwargs, secrets) : kwargs, keyToJson, aliases),
-        };
-    }
-    toJSONNotImplemented() {
-        return {
-            lc: 1,
-            type: "not_implemented",
-            id: this.lc_id,
-        };
-    }
-}
+export * from "langchain-core/load/serializable";