@langchain/core 1.1.32 → 1.1.33-dev-1773698445534

package/dist/load/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["coreImportMap","defaultOptionalImportEntrypoints","optionalImportEntrypoints"],"sources":["../../src/load/index.ts"],"sourcesContent":["/**\n * Load LangChain objects from JSON strings or objects.\n *\n * **WARNING: `load()` deserializes data by instantiating classes and invoking\n * constructors. Never call `load()` on untrusted or user-supplied input.**\n * Doing so can lead to insecure deserialization — including arbitrary class\n * instantiation, secret exfiltration, and server-side request forgery (SSRF).\n * Only deserialize data that originates from a trusted source you control.\n *\n * ## How it works\n *\n * Each `Serializable` LangChain object has a unique identifier (its \"class path\"),\n * which is a list of strings representing the module path and class name. For example:\n *\n * - `AIMessage` -> `[\"langchain_core\", \"messages\", \"ai\", \"AIMessage\"]`\n * - `ChatPromptTemplate` -> `[\"langchain_core\", \"prompts\", \"chat\", \"ChatPromptTemplate\"]`\n *\n * When deserializing, the class path is validated against supported namespaces.\n *\n * ## Security model\n *\n * The `secretsFromEnv` parameter controls whether secrets can be loaded from environment\n * variables:\n *\n * - `false` (default): Secrets must be provided in `secretsMap`. If a secret is not\n *   found, `null` is returned instead of loading from environment variables.\n * - `true`: If a secret is not found in `secretsMap`, it will be loaded from\n *   environment variables. Use this only in trusted environments.\n *\n * ### Hardening recommendations\n *\n * - **Never enable `secretsFromEnv`** unless the serialized data is fully trusted.\n *   A crafted payload can reference arbitrary environment variable names, leaking\n *   secrets to an attacker-controlled class constructor.\n * - **Keep `secretsMap` minimal.** Only include the specific secrets the serialized\n *   object actually needs.\n * - **Keep `importMap` / `optionalImportsMap` as small and static as possible.**\n *   Each entry widens the set of classes an attacker can instantiate. Never\n *   populate these maps from user input.\n *\n * ### Injection protection (escape-based)\n *\n * During serialization, plain objects that contain an `'lc'` key are escaped by wrapping\n * them: `{\"__lc_escaped__\": {...}}`. During deserialization, escaped objects are unwrapped\n * and returned as plain objects, NOT instantiated as LC objects.\n *\n * This is an allowlist approach: only objects explicitly produced by\n * `Serializable.toJSON()` (which are NOT escaped) are treated as LC objects;\n * everything else is user data.\n *\n * @module\n */\n\nimport {\n  Serializable,\n  SerializedConstructor,\n  SerializedNotImplemented,\n  SerializedSecret,\n  get_lc_unique_name,\n} from \"./serializable.js\";\nimport { optionalImportEntrypoints as defaultOptionalImportEntrypoints } from \"./import_constants.js\";\nimport * as coreImportMap from \"./import_map.js\";\nimport type { OptionalImportMap, SecretMap } from \"./import_type.js\";\nimport { type SerializedFields, keyFromJson, mapKeys } from \"./map_keys.js\";\nimport { getEnvironmentVariable } from \"../utils/env.js\";\nimport { isEscapedObject, unescapeValue } from \"./validation.js\";\n\n/**\n * Options for loading serialized LangChain objects.\n *\n * @remarks\n * **Security considerations:**\n *\n * Deserialization can instantiate arbitrary classes from the allowed namespaces.\n * When loading untrusted data, be aware that:\n *\n * 1. **`secretsFromEnv`**: Defaults to `false`. Setting to `true` allows the\n *    deserializer to read environment variables, which could leak secrets if\n *    the serialized data contains malicious secret references.\n *\n * 2. **`importMap` / `optionalImportsMap`**: These allow extending which classes\n *    can be instantiated. Never populate these from user input. Only include\n *    modules you explicitly trust.\n *\n * 3. **Class instantiation**: Allowed classes will have their constructors called\n *    with the deserialized kwargs. If a class performs side effects in its\n *    constructor (network calls, file I/O, etc.), those will execute.\n */\nexport interface LoadOptions {\n  /**\n   * A map of secrets to load. Keys are secret identifiers, values are the secret values.\n   *\n   * If a secret is not found in this map and `secretsFromEnv` is `false`, an error is\n   * thrown. If `secretsFromEnv` is `true`, the secret will be loaded from environment\n   * variables (if not found there either, an error is thrown).\n   */\n  secretsMap?: SecretMap;\n\n  /**\n   * Whether to load secrets from environment variables when not found in `secretsMap`.\n   *\n   * @default false\n   *\n   * @remarks\n   * **Security warning:** Setting this to `true` allows the deserializer to read\n   * environment variables, which could be a security risk if the serialized data\n   * is not trusted. Only set this to `true` when deserializing data from trusted\n   * sources (e.g., your own database, not user input).\n   */\n  secretsFromEnv?: boolean;\n\n  /**\n   * A map of optional imports. Keys are namespace paths (e.g., \"langchain_community/llms\"),\n   * values are the imported modules.\n   *\n   * @remarks\n   * **Security warning:** This extends which classes can be instantiated during\n   * deserialization. Never populate this map with values derived from user input.\n   * Only include modules that you explicitly trust and have reviewed.\n   *\n   * Classes in these modules can be instantiated with attacker-controlled kwargs\n   * if the serialized data is untrusted.\n   */\n  optionalImportsMap?: OptionalImportMap;\n\n  /**\n   * Additional optional import entrypoints to allow beyond the defaults.\n   *\n   * @remarks\n   * **Security warning:** This extends which namespace paths are considered valid\n   * for deserialization. Never populate this array with values derived from user\n   * input. Each entrypoint you add expands the attack surface for deserialization.\n   */\n  optionalImportEntrypoints?: string[];\n\n  /**\n   * Additional import map for the \"langchain\" namespace.\n   *\n   * @remarks\n   * **Security warning:** This extends which classes can be instantiated during\n   * deserialization. Never populate this map with values derived from user input.\n   * Only include modules that you explicitly trust and have reviewed.\n   *\n   * Any class exposed through this map can be instantiated with attacker-controlled\n   * kwargs if the serialized data is untrusted.\n   */\n  importMap?: Record<string, unknown>;\n\n  /**\n   * Maximum recursion depth allowed during deserialization.\n   *\n   * @default 50\n   *\n   * @remarks\n   * This limit protects against denial-of-service attacks using deeply nested\n   * JSON structures that could cause stack overflow. If your legitimate data\n   * requires deeper nesting, you can increase this limit.\n   */\n  maxDepth?: number;\n}\n\n/**\n * Default maximum recursion depth for deserialization.\n * This provides protection against DoS attacks via deeply nested structures.\n */\nconst DEFAULT_MAX_DEPTH = 50;\n\nfunction combineAliasesAndInvert(constructor: typeof Serializable) {\n  const aliases: { [key: string]: string } = {};\n  for (\n    let current = constructor;\n    current && current.prototype;\n    current = Object.getPrototypeOf(current)\n  ) {\n    Object.assign(aliases, Reflect.get(current.prototype, \"lc_aliases\"));\n  }\n  return Object.entries(aliases).reduce(\n    (acc, [key, value]) => {\n      acc[value] = key;\n      return acc;\n    },\n    {} as Record<string, string>\n  );\n}\n\ninterface ReviverContext {\n  optionalImportsMap: OptionalImportMap;\n  optionalImportEntrypoints: string[];\n  secretsMap: SecretMap;\n  secretsFromEnv: boolean;\n  importMap: Record<string, unknown>;\n  path: string[];\n  depth: number;\n  maxDepth: number;\n}\n\n/**\n * Recursively revive a value, handling escape markers and LC objects.\n *\n * This function handles:\n * 1. Escaped dicts - unwrapped and returned as plain objects\n * 2. LC secret objects - resolved from secretsMap or env\n * 3. LC constructor objects - instantiated\n * 4. Regular objects/arrays - recursed into\n */\nasync function reviver(this: ReviverContext, value: unknown): Promise<unknown> {\n  const {\n    optionalImportsMap,\n    optionalImportEntrypoints,\n    importMap,\n    secretsMap,\n    secretsFromEnv,\n    path,\n    depth,\n    maxDepth,\n  } = this;\n  const pathStr = path.join(\".\");\n\n  // Check recursion depth to prevent DoS via deeply nested structures\n  if (depth > maxDepth) {\n    throw new Error(\n      `Maximum recursion depth (${maxDepth}) exceeded during deserialization. ` +\n        `This may indicate a malicious payload or you may need to increase maxDepth.`\n    );\n  }\n\n  // If not an object, return as-is\n  if (typeof value !== \"object\" || value == null) {\n    return value;\n  }\n\n  // Handle arrays - recurse into elements\n  if (Array.isArray(value)) {\n    return Promise.all(\n      value.map((v, i) =>\n        reviver.call({ ...this, path: [...path, `${i}`], depth: depth + 1 }, v)\n      )\n    );\n  }\n\n  // It's an object - check for escape marker FIRST\n  const record = value as Record<string, unknown>;\n  if (isEscapedObject(record)) {\n    // This is an escaped user object - unwrap and return as-is (no LC processing)\n    return unescapeValue(record);\n  }\n\n  // Check for LC secret object\n  if (\n    \"lc\" in record &&\n    \"type\" in record &&\n    \"id\" in record &&\n    record.lc === 1 &&\n    record.type === \"secret\"\n  ) {\n    const serialized = record as unknown as SerializedSecret;\n    const [key] = serialized.id;\n    if (key in secretsMap) {\n      return secretsMap[key as keyof SecretMap];\n    } else if (secretsFromEnv) {\n      const secretValueInEnv = getEnvironmentVariable(key);\n      if (secretValueInEnv) {\n        return secretValueInEnv;\n      }\n    }\n    throw new Error(`Missing secret \"${key}\" at ${pathStr}`);\n  }\n\n  // Check for LC not_implemented object\n  if (\n    \"lc\" in record &&\n    \"type\" in record &&\n    \"id\" in record &&\n    record.lc === 1 &&\n    record.type === \"not_implemented\"\n  ) {\n    const serialized = record as unknown as SerializedNotImplemented;\n    const str = JSON.stringify(serialized);\n    throw new Error(\n      `Trying to load an object that doesn't implement serialization: ${pathStr} -> ${str}`\n    );\n  }\n\n  // Check for LC constructor object\n  if (\n    \"lc\" in record &&\n    \"type\" in record &&\n    \"id\" in record &&\n    \"kwargs\" in record &&\n    record.lc === 1 &&\n    record.type === \"constructor\"\n  ) {\n    const serialized = record as unknown as SerializedConstructor;\n    const str = JSON.stringify(serialized);\n    const [name, ...namespaceReverse] = serialized.id.slice().reverse();\n    const namespace = namespaceReverse.reverse();\n    const importMaps = { langchain_core: coreImportMap, langchain: importMap };\n\n    let module:\n      | (typeof importMaps)[\"langchain_core\"][keyof (typeof importMaps)[\"langchain_core\"]]\n      | (typeof importMaps)[\"langchain\"][keyof (typeof importMaps)[\"langchain\"]]\n      | OptionalImportMap[keyof OptionalImportMap]\n      | null = null;\n\n    const optionalImportNamespaceAliases = [namespace.join(\"/\")];\n    if (namespace[0] === \"langchain_community\") {\n      optionalImportNamespaceAliases.push(\n        [\"langchain\", ...namespace.slice(1)].join(\"/\")\n      );\n    }\n    const matchingNamespaceAlias = optionalImportNamespaceAliases.find(\n      (alias) => alias in optionalImportsMap\n    );\n    if (\n      defaultOptionalImportEntrypoints\n        .concat(optionalImportEntrypoints)\n        .includes(namespace.join(\"/\")) ||\n      matchingNamespaceAlias\n    ) {\n      if (matchingNamespaceAlias !== undefined) {\n        module =\n          await optionalImportsMap[\n            matchingNamespaceAlias as keyof typeof optionalImportsMap\n          ];\n      } else {\n        throw new Error(\n          `Missing key \"${namespace.join(\n            \"/\"\n          )}\" for ${pathStr} in load(optionalImportsMap={})`\n        );\n      }\n    } else {\n      let finalImportMap:\n        | (typeof importMaps)[\"langchain\"]\n        | (typeof importMaps)[\"langchain_core\"];\n      // Currently, we only support langchain and langchain_core imports.\n      if (namespace[0] === \"langchain\" || namespace[0] === \"langchain_core\") {\n        finalImportMap = importMaps[namespace[0]];\n        namespace.shift();\n      } else {\n        throw new Error(`Invalid namespace: ${pathStr} -> ${str}`);\n      }\n\n      // The root namespace \"langchain\" is not a valid import.\n      if (namespace.length === 0) {\n        throw new Error(`Invalid namespace: ${pathStr} -> ${str}`);\n      }\n\n      // Find the longest matching namespace.\n      let importMapKey: string;\n      do {\n        importMapKey = namespace.join(\"__\");\n        if (importMapKey in finalImportMap) {\n          break;\n        } else {\n          namespace.pop();\n        }\n      } while (namespace.length > 0);\n\n      // If no matching namespace is found, throw an error.\n      if (importMapKey in finalImportMap) {\n        module = finalImportMap[importMapKey as keyof typeof finalImportMap];\n      }\n    }\n\n    if (typeof module !== \"object\" || module === null) {\n      throw new Error(`Invalid namespace: ${pathStr} -> ${str}`);\n    }\n\n    // Extract the builder from the import map.\n    const builder =\n      // look for a named export with the same name as the class\n      module[name as keyof typeof module] ??\n      // look for an export with a lc_name property matching the class name\n      // this is necessary for classes that are minified\n      Object.values(module).find(\n        (v) =>\n          typeof v === \"function\" &&\n          get_lc_unique_name(v as typeof Serializable) === name\n      );\n    if (typeof builder !== \"function\") {\n      throw new Error(`Invalid identifer: ${pathStr} -> ${str}`);\n    }\n\n    // Recurse on the arguments, which may be serialized objects themselves\n    const kwargs = await reviver.call(\n      { ...this, path: [...path, \"kwargs\"], depth: depth + 1 },\n      serialized.kwargs\n    );\n\n    // Construct the object\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const instance = new (builder as any)(\n      mapKeys(\n        kwargs as SerializedFields,\n        keyFromJson,\n        combineAliasesAndInvert(builder)\n      )\n    );\n\n    // Minification in severless/edge runtimes will mange the\n    // name of classes presented in traces. As the names in import map\n    // are present as-is even with minification, use these names instead\n    Object.defineProperty(instance.constructor, \"name\", { value: name });\n\n    return instance;\n  }\n\n  // Regular object - recurse into values\n  const result: Record<string, unknown> = {};\n  for (const [key, val] of Object.entries(record)) {\n    result[key] = await reviver.call(\n      { ...this, path: [...path, key], depth: depth + 1 },\n      val\n    );\n  }\n  return result;\n}\n\n/**\n * Load a LangChain object from a JSON string.\n *\n * **WARNING — insecure deserialization risk.** This function instantiates\n * classes and invokes constructors based on the contents of `text`. If `text`\n * originates from an untrusted source, an attacker can craft a payload that\n * instantiates arbitrary allowed classes with attacker-controlled arguments,\n * potentially causing secret exfiltration, SSRF, or other side effects.\n *\n * Only call `load()` on data you have produced yourself or received from a\n * fully trusted origin (e.g., your own database). **Never deserialize\n * user-supplied or network-received JSON without independent validation.**\n *\n * @param text - The JSON string to parse and load.\n * @param options - Options for loading. See {@link LoadOptions} for security guidance.\n * @returns The loaded LangChain object.\n *\n * @example\n * ```typescript\n * import { load } from \"@langchain/core/load\";\n * import { AIMessage } from \"@langchain/core/messages\";\n *\n * // Basic usage - secrets must be provided explicitly\n * const msg = await load<AIMessage>(jsonString);\n *\n * // With secrets from a map (preferred over secretsFromEnv)\n * const msg = await load<AIMessage>(jsonString, {\n *   secretsMap: { OPENAI_API_KEY: \"sk-...\" }\n * });\n *\n * // Allow loading secrets from environment — ONLY for fully trusted data\n * const msg = await load<AIMessage>(jsonString, {\n *   secretsFromEnv: true\n * });\n * ```\n */\nexport async function load<T>(text: string, options?: LoadOptions): Promise<T> {\n  const json = JSON.parse(text);\n\n  const context: ReviverContext = {\n    optionalImportsMap: options?.optionalImportsMap ?? {},\n    optionalImportEntrypoints: options?.optionalImportEntrypoints ?? [],\n    secretsMap: options?.secretsMap ?? {},\n    secretsFromEnv: options?.secretsFromEnv ?? false,\n    importMap: options?.importMap ?? {},\n    path: [\"$\"],\n    depth: 0,\n    maxDepth: options?.maxDepth ?? DEFAULT_MAX_DEPTH,\n  };\n\n  return reviver.call(context, json) as Promise<T>;\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":["coreImportMap","defaultOptionalImportEntrypoints","optionalImportEntrypoints"],"sources":["../../src/load/index.ts"],"sourcesContent":["/**\n * Load LangChain objects from JSON strings or objects.\n *\n * **WARNING: `load()` deserializes data by instantiating classes and invoking\n * constructors. Never call `load()` on untrusted or user-supplied input.**\n * Doing so can lead to insecure deserialization — including arbitrary class\n * instantiation, secret exfiltration, and server-side request forgery (SSRF).\n * Only deserialize data that originates from a trusted source you control.\n *\n * ## How it works\n *\n * Each `Serializable` LangChain object has a unique identifier (its \"class path\"),\n * which is a list of strings representing the module path and class name. For example:\n *\n * - `AIMessage` -> `[\"langchain_core\", \"messages\", \"ai\", \"AIMessage\"]`\n * - `ChatPromptTemplate` -> `[\"langchain_core\", \"prompts\", \"chat\", \"ChatPromptTemplate\"]`\n *\n * When deserializing, the class path is validated against supported namespaces.\n *\n * ## Security model\n *\n * The `secretsFromEnv` parameter controls whether secrets can be loaded from environment\n * variables:\n *\n * - `false` (default): Secrets must be provided in `secretsMap`. If a secret is not\n *   found, `null` is returned instead of loading from environment variables.\n * - `true`: If a secret is not found in `secretsMap`, it will be loaded from\n *   environment variables. Use this only in trusted environments.\n *\n * ### Hardening recommendations\n *\n * - **Never enable `secretsFromEnv`** unless the serialized data is fully trusted.\n *   A crafted payload can reference arbitrary environment variable names, leaking\n *   secrets to an attacker-controlled class constructor.\n * - **Keep `secretsMap` minimal.** Only include the specific secrets the serialized\n *   object actually needs.\n * - **Keep `importMap` / `optionalImportsMap` as small and static as possible.**\n *   Each entry widens the set of classes an attacker can instantiate. Never\n *   populate these maps from user input.\n *\n * ### Injection protection (escape-based)\n *\n * During serialization, plain objects that contain an `'lc'` key are escaped by wrapping\n * them: `{\"__lc_escaped__\": {...}}`. During deserialization, escaped objects are unwrapped\n * and returned as plain objects, NOT instantiated as LC objects.\n *\n * This is an allowlist approach: only objects explicitly produced by\n * `Serializable.toJSON()` (which are NOT escaped) are treated as LC objects;\n * everything else is user data.\n *\n * @module\n */\n\nimport {\n  Serializable,\n  SerializedConstructor,\n  SerializedNotImplemented,\n  SerializedSecret,\n  get_lc_unique_name,\n} from \"./serializable.js\";\nimport { optionalImportEntrypoints as defaultOptionalImportEntrypoints } from \"./import_constants.js\";\nimport * as coreImportMap from \"./import_map.js\";\nimport type { OptionalImportMap, SecretMap } from \"./import_type.js\";\nimport { type SerializedFields, keyFromJson, mapKeys } from \"./map_keys.js\";\nimport { getEnvironmentVariable } from \"../utils/env.js\";\nimport { isEscapedObject, unescapeValue } from \"./validation.js\";\n\n/**\n * Options for loading serialized LangChain objects.\n *\n * @remarks\n * **Security considerations:**\n *\n * Deserialization can instantiate arbitrary classes from the allowed namespaces.\n * When loading untrusted data, be aware that:\n *\n * 1. **`secretsFromEnv`**: Defaults to `false`. Setting to `true` allows the\n *    deserializer to read environment variables, which could leak secrets if\n *    the serialized data contains malicious secret references.\n *\n * 2. **`importMap` / `optionalImportsMap`**: These allow extending which classes\n *    can be instantiated. Never populate these from user input. Only include\n *    modules you explicitly trust.\n *\n * 3. **Class instantiation**: Allowed classes will have their constructors called\n *    with the deserialized kwargs. If a class performs side effects in its\n *    constructor (network calls, file I/O, etc.), those will execute.\n */\nexport interface LoadOptions {\n  /**\n   * A map of secrets to load. Keys are secret identifiers, values are the secret values.\n   *\n   * If a secret is not found in this map and `secretsFromEnv` is `false`, an error is\n   * thrown. If `secretsFromEnv` is `true`, the secret will be loaded from environment\n   * variables (if not found there either, an error is thrown).\n   */\n  secretsMap?: SecretMap;\n\n  /**\n   * Whether to load secrets from environment variables when not found in `secretsMap`.\n   *\n   * @default false\n   *\n   * @remarks\n   * **Security warning:** Setting this to `true` allows the deserializer to read\n   * environment variables, which could be a security risk if the serialized data\n   * is not trusted. Only set this to `true` when deserializing data from trusted\n   * sources (e.g., your own database, not user input).\n   */\n  secretsFromEnv?: boolean;\n\n  /**\n   * A map of optional imports. Keys are namespace paths (e.g., \"langchain_community/llms\"),\n   * values are the imported modules.\n   *\n   * @remarks\n   * **Security warning:** This extends which classes can be instantiated during\n   * deserialization. Never populate this map with values derived from user input.\n   * Only include modules that you explicitly trust and have reviewed.\n   *\n   * Classes in these modules can be instantiated with attacker-controlled kwargs\n   * if the serialized data is untrusted.\n   */\n  optionalImportsMap?: OptionalImportMap;\n\n  /**\n   * Additional optional import entrypoints to allow beyond the defaults.\n   *\n   * @remarks\n   * **Security warning:** This extends which namespace paths are considered valid\n   * for deserialization. Never populate this array with values derived from user\n   * input. Each entrypoint you add expands the attack surface for deserialization.\n   */\n  optionalImportEntrypoints?: string[];\n\n  /**\n   * Additional import map for the \"langchain\" namespace.\n   *\n   * @remarks\n   * **Security warning:** This extends which classes can be instantiated during\n   * deserialization. Never populate this map with values derived from user input.\n   * Only include modules that you explicitly trust and have reviewed.\n   *\n   * Any class exposed through this map can be instantiated with attacker-controlled\n   * kwargs if the serialized data is untrusted.\n   */\n  importMap?: Record<string, unknown>;\n\n  /**\n   * Maximum recursion depth allowed during deserialization.\n   *\n   * @default 50\n   *\n   * @remarks\n   * This limit protects against denial-of-service attacks using deeply nested\n   * JSON structures that could cause stack overflow. If your legitimate data\n   * requires deeper nesting, you can increase this limit.\n   */\n  maxDepth?: number;\n}\n\n/**\n * Default maximum recursion depth for deserialization.\n * This provides protection against DoS attacks via deeply nested structures.\n */\nconst DEFAULT_MAX_DEPTH = 50;\n\nfunction combineAliasesAndInvert(constructor: typeof Serializable) {\n  const aliases: { [key: string]: string } = {};\n  for (\n    let current = constructor;\n    current && current.prototype;\n    current = Object.getPrototypeOf(current)\n  ) {\n    Object.assign(aliases, Reflect.get(current.prototype, \"lc_aliases\"));\n  }\n  return Object.entries(aliases).reduce(\n    (acc, [key, value]) => {\n      acc[value] = key;\n      return acc;\n    },\n    {} as Record<string, string>\n  );\n}\n\ninterface ReviverContext {\n  optionalImportsMap: OptionalImportMap;\n  optionalImportEntrypoints: string[];\n  secretsMap: SecretMap;\n  secretsFromEnv: boolean;\n  importMap: Record<string, unknown>;\n  path: string[];\n  depth: number;\n  maxDepth: number;\n}\n\n/**\n * Recursively revive a value, handling escape markers and LC objects.\n *\n * This function handles:\n * 1. Escaped dicts - unwrapped and returned as plain objects\n * 2. LC secret objects - resolved from secretsMap or env\n * 3. LC constructor objects - instantiated\n * 4. Regular objects/arrays - recursed into\n */\nasync function reviver(this: ReviverContext, value: unknown): Promise<unknown> {\n  const {\n    optionalImportsMap,\n    optionalImportEntrypoints,\n    importMap,\n    secretsMap,\n    secretsFromEnv,\n    path,\n    depth,\n    maxDepth,\n  } = this;\n  const pathStr = path.join(\".\");\n\n  // Check recursion depth to prevent DoS via deeply nested structures\n  if (depth > maxDepth) {\n    throw new Error(\n      `Maximum recursion depth (${maxDepth}) exceeded during deserialization. ` +\n        `This may indicate a malicious payload or you may need to increase maxDepth.`\n    );\n  }\n\n  // If not an object, return as-is\n  if (typeof value !== \"object\" || value == null) {\n    return value;\n  }\n\n  // Handle arrays - recurse into elements\n  if (Array.isArray(value)) {\n    return Promise.all(\n      value.map((v, i) =>\n        reviver.call({ ...this, path: [...path, `${i}`], depth: depth + 1 }, v)\n      )\n    );\n  }\n\n  // It's an object - check for escape marker FIRST\n  const record = value as Record<string, unknown>;\n  if (isEscapedObject(record)) {\n    // This is an escaped user object - unwrap and return as-is (no LC processing)\n    return unescapeValue(record);\n  }\n\n  // Check for LC secret object\n  if (\n    \"lc\" in record &&\n    \"type\" in record &&\n    \"id\" in record &&\n    record.lc === 1 &&\n    record.type === \"secret\"\n  ) {\n    const serialized = record as unknown as SerializedSecret;\n    const [key] = serialized.id;\n    if (key in secretsMap) {\n      return secretsMap[key as keyof SecretMap];\n    } else if (secretsFromEnv) {\n      const secretValueInEnv = getEnvironmentVariable(key);\n      if (secretValueInEnv) {\n        return secretValueInEnv;\n      }\n    }\n    throw new Error(`Missing secret \"${key}\" at ${pathStr}`);\n  }\n\n  // Check for LC not_implemented object\n  if (\n    \"lc\" in record &&\n    \"type\" in record &&\n    \"id\" in record &&\n    record.lc === 1 &&\n    record.type === \"not_implemented\"\n  ) {\n    const serialized = record as unknown as SerializedNotImplemented;\n    const str = JSON.stringify(serialized);\n    throw new Error(\n      `Trying to load an object that doesn't implement serialization: ${pathStr} -> ${str}`\n    );\n  }\n\n  // Check for LC constructor object\n  if (\n    \"lc\" in record &&\n    \"type\" in record &&\n    \"id\" in record &&\n    \"kwargs\" in record &&\n    record.lc === 1 &&\n    record.type === \"constructor\"\n  ) {\n    const serialized = record as unknown as SerializedConstructor;\n    const str = JSON.stringify(serialized);\n    const [name, ...namespaceReverse] = serialized.id.slice().reverse();\n    const namespace = namespaceReverse.reverse();\n    const importMaps = { langchain_core: coreImportMap, langchain: importMap };\n\n    let module:\n      | (typeof importMaps)[\"langchain_core\"][keyof (typeof importMaps)[\"langchain_core\"]]\n      | (typeof importMaps)[\"langchain\"][keyof (typeof importMaps)[\"langchain\"]]\n      | OptionalImportMap[keyof OptionalImportMap]\n      | null = null;\n\n    const optionalImportNamespaceAliases = [namespace.join(\"/\")];\n    if (namespace[0] === \"langchain_community\") {\n      optionalImportNamespaceAliases.push(\n        [\"langchain\", ...namespace.slice(1)].join(\"/\")\n      );\n    }\n    const matchingNamespaceAlias = optionalImportNamespaceAliases.find(\n      (alias) => alias in optionalImportsMap\n    );\n    if (\n      defaultOptionalImportEntrypoints\n        .concat(optionalImportEntrypoints)\n        .includes(namespace.join(\"/\")) ||\n      matchingNamespaceAlias\n    ) {\n      if (matchingNamespaceAlias !== undefined) {\n        module =\n          await optionalImportsMap[\n            matchingNamespaceAlias as keyof typeof optionalImportsMap\n          ];\n      } else {\n        throw new Error(\n          `Missing key \"${namespace.join(\n            \"/\"\n          )}\" for ${pathStr} in load(optionalImportsMap={})`\n        );\n      }\n    } else {\n      let finalImportMap:\n        | (typeof importMaps)[\"langchain\"]\n        | (typeof importMaps)[\"langchain_core\"];\n      // Currently, we only support langchain and langchain_core imports.\n      if (namespace[0] === \"langchain\" || namespace[0] === \"langchain_core\") {\n        finalImportMap = importMaps[namespace[0]];\n        namespace.shift();\n      } else {\n        throw new Error(`Invalid namespace: ${pathStr} -> ${str}`);\n      }\n\n      // The root namespace \"langchain\" is not a valid import.\n      if (namespace.length === 0) {\n        throw new Error(`Invalid namespace: ${pathStr} -> ${str}`);\n      }\n\n      // Find the longest matching namespace.\n      let importMapKey: string;\n      do {\n        importMapKey = namespace.join(\"__\");\n        if (importMapKey in finalImportMap) {\n          break;\n        } else {\n          namespace.pop();\n        }\n      } while (namespace.length > 0);\n\n      // If no matching namespace is found, throw an error.\n      if (importMapKey in finalImportMap) {\n        module = finalImportMap[importMapKey as keyof typeof finalImportMap];\n      }\n    }\n\n    if (typeof module !== \"object\" || module === null) {\n      throw new Error(`Invalid namespace: ${pathStr} -> ${str}`);\n    }\n\n    // Extract the builder from the import map.\n    const builder =\n      // look for a named export with the same name as the class\n      module[name as keyof typeof module] ??\n      // look for an export with a lc_name property matching the class name\n      // this is necessary for classes that are minified\n      Object.values(module).find(\n        (v) =>\n          typeof v === \"function\" &&\n          get_lc_unique_name(v as typeof Serializable) === name\n      );\n    if (typeof builder !== \"function\") {\n      throw new Error(`Invalid identifer: ${pathStr} -> ${str}`);\n    }\n\n    // Recurse on the arguments, which may be serialized objects themselves\n    const kwargs = await reviver.call(\n      { ...this, path: [...path, \"kwargs\"], depth: depth + 1 },\n      serialized.kwargs\n    );\n\n    // Construct the object\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const instance = new (builder as any)(\n      mapKeys(\n        kwargs as SerializedFields,\n        keyFromJson,\n        combineAliasesAndInvert(builder)\n      )\n    );\n\n    // Minification in severless/edge runtimes will mange the\n    // name of classes presented in traces. As the names in import map\n    // are present as-is even with minification, use these names instead\n    Object.defineProperty(instance.constructor, \"name\", { value: name });\n\n    return instance;\n  }\n\n  // Regular object - recurse into values\n  const result: Record<string, unknown> = {};\n  for (const [key, val] of Object.entries(record)) {\n    result[key] = await reviver.call(\n      { ...this, path: [...path, key], depth: depth + 1 },\n      val\n    );\n  }\n  return result;\n}\n\n/**\n * Load a LangChain object from a JSON string.\n *\n * **WARNING — insecure deserialization risk.** This function instantiates\n * classes and invokes constructors based on the contents of `text`. If `text`\n * originates from an untrusted source, an attacker can craft a payload that\n * instantiates arbitrary allowed classes with attacker-controlled arguments,\n * potentially causing secret exfiltration, SSRF, or other side effects.\n *\n * Only call `load()` on data you have produced yourself or received from a\n * fully trusted origin (e.g., your own database). **Never deserialize\n * user-supplied or network-received JSON without independent validation.**\n *\n * @param text - The JSON string to parse and load.\n * @param options - Options for loading. See {@link LoadOptions} for security guidance.\n * @returns The loaded LangChain object.\n *\n * @example\n * ```typescript\n * import { load } from \"@langchain/core/load\";\n * import { AIMessage } from \"@langchain/core/messages\";\n *\n * // Basic usage - secrets must be provided explicitly\n * const msg = await load<AIMessage>(jsonString);\n *\n * // With secrets from a map (preferred over secretsFromEnv)\n * const msg = await load<AIMessage>(jsonString, {\n *   secretsMap: { OPENAI_API_KEY: \"sk-...\" }\n * });\n *\n * // Allow loading secrets from environment — ONLY for fully trusted data\n * const msg = await load<AIMessage>(jsonString, {\n *   secretsFromEnv: true\n * });\n * ```\n */\nexport async function load<T>(text: string, options?: LoadOptions): Promise<T> {\n  const json = JSON.parse(text);\n\n  const context: ReviverContext = {\n    optionalImportsMap: options?.optionalImportsMap ?? {},\n    optionalImportEntrypoints: options?.optionalImportEntrypoints ?? [],\n    secretsMap: options?.secretsMap ?? {},\n    secretsFromEnv: options?.secretsFromEnv ?? false,\n    importMap: options?.importMap ?? {},\n    path: [\"$\"],\n    depth: 0,\n    maxDepth: options?.maxDepth ?? DEFAULT_MAX_DEPTH,\n  };\n\n  return reviver.call(context, json) as Promise<T>;\n}\n"],"mappings":"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"}

package/dist/load/map_keys.cjs

@@ -1,9 +1,8 @@
-const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 let decamelize = require("decamelize");
 decamelize = require_runtime.__toESM(decamelize);
 let camelcase = require("camelcase");
 camelcase = require_runtime.__toESM(camelcase);
-
 //#region src/load/map_keys.ts
 function keyToJson(key, map) {
 	return map?.[key] || (0, decamelize.default)(key);
@@ -16,9 +15,9 @@ function mapKeys(fields, mapper, map) {
 	for (const key in fields) if (Object.hasOwn(fields, key)) mapped[mapper(key, map)] = fields[key];
 	return mapped;
 }
-
 //#endregion
 exports.keyFromJson = keyFromJson;
 exports.keyToJson = keyToJson;
 exports.mapKeys = mapKeys;
+
 //# sourceMappingURL=map_keys.cjs.map

package/dist/load/map_keys.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"map_keys.cjs","names":[],"sources":["../../src/load/map_keys.ts"],"sourcesContent":["import snakeCase from \"decamelize\";\nimport camelCase from \"camelcase\";\n\nexport interface SerializedFields {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  [key: string]: any;\n}\n\nexport interface SerializedKeyAlias {\n  [key: string]: string;\n}\n\nexport function keyToJson(key: string, map?: SerializedKeyAlias): string {\n  return map?.[key] || snakeCase(key);\n}\n\nexport function keyFromJson(key: string, map?: SerializedKeyAlias): string {\n  return map?.[key] || camelCase(key);\n}\n\nexport function mapKeys(\n  fields: SerializedFields,\n  mapper: typeof keyToJson,\n  map?: SerializedKeyAlias\n): SerializedFields {\n  const mapped: SerializedFields = {};\n\n  for (const key in fields) {\n    if (Object.hasOwn(fields, key)) {\n      mapped[mapper(key, map)] = fields[key];\n    }\n  }\n\n  return mapped;\n}\n"],"mappings":";;;;;;;AAYA,SAAgB,UAAU,KAAa,KAAkC;AACvE,QAAO,MAAM,gCAAkB,IAAI;;AAGrC,SAAgB,YAAY,KAAa,KAAkC;AACzE,QAAO,MAAM,+BAAkB,IAAI;;AAGrC,SAAgB,QACd,QACA,QACA,KACkB;CAClB,MAAM,SAA2B,EAAE;AAEnC,MAAK,MAAM,OAAO,OAChB,KAAI,OAAO,OAAO,QAAQ,IAAI,CAC5B,QAAO,OAAO,KAAK,IAAI,IAAI,OAAO;AAItC,QAAO"}
+{"version":3,"file":"map_keys.cjs","names":[],"sources":["../../src/load/map_keys.ts"],"sourcesContent":["import snakeCase from \"decamelize\";\nimport camelCase from \"camelcase\";\n\nexport interface SerializedFields {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  [key: string]: any;\n}\n\nexport interface SerializedKeyAlias {\n  [key: string]: string;\n}\n\nexport function keyToJson(key: string, map?: SerializedKeyAlias): string {\n  return map?.[key] || snakeCase(key);\n}\n\nexport function keyFromJson(key: string, map?: SerializedKeyAlias): string {\n  return map?.[key] || camelCase(key);\n}\n\nexport function mapKeys(\n  fields: SerializedFields,\n  mapper: typeof keyToJson,\n  map?: SerializedKeyAlias\n): SerializedFields {\n  const mapped: SerializedFields = {};\n\n  for (const key in fields) {\n    if (Object.hasOwn(fields, key)) {\n      mapped[mapper(key, map)] = fields[key];\n    }\n  }\n\n  return mapped;\n}\n"],"mappings":";;;;;;AAYA,SAAgB,UAAU,KAAa,KAAkC;AACvE,QAAO,MAAM,SAAA,GAAA,WAAA,SAAkB,IAAI;;AAGrC,SAAgB,YAAY,KAAa,KAAkC;AACzE,QAAO,MAAM,SAAA,GAAA,UAAA,SAAkB,IAAI;;AAGrC,SAAgB,QACd,QACA,QACA,KACkB;CAClB,MAAM,SAA2B,EAAE;AAEnC,MAAK,MAAM,OAAO,OAChB,KAAI,OAAO,OAAO,QAAQ,IAAI,CAC5B,QAAO,OAAO,KAAK,IAAI,IAAI,OAAO;AAItC,QAAO"}

package/dist/load/map_keys.js

@@ -1,6 +1,5 @@
 import snakeCase from "decamelize";
 import camelCase from "camelcase";
-
 //#region src/load/map_keys.ts
 function keyToJson(key, map) {
 	return map?.[key] || snakeCase(key);
@@ -13,7 +12,7 @@ function mapKeys(fields, mapper, map) {
 	for (const key in fields) if (Object.hasOwn(fields, key)) mapped[mapper(key, map)] = fields[key];
 	return mapped;
 }
-
 //#endregion
 export { keyFromJson, keyToJson, mapKeys };
+
 //# sourceMappingURL=map_keys.js.map

package/dist/load/map_keys.js.map

@@ -1 +1 @@
-{"version":3,"file":"map_keys.js","names":[],"sources":["../../src/load/map_keys.ts"],"sourcesContent":["import snakeCase from \"decamelize\";\nimport camelCase from \"camelcase\";\n\nexport interface SerializedFields {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  [key: string]: any;\n}\n\nexport interface SerializedKeyAlias {\n  [key: string]: string;\n}\n\nexport function keyToJson(key: string, map?: SerializedKeyAlias): string {\n  return map?.[key] || snakeCase(key);\n}\n\nexport function keyFromJson(key: string, map?: SerializedKeyAlias): string {\n  return map?.[key] || camelCase(key);\n}\n\nexport function mapKeys(\n  fields: SerializedFields,\n  mapper: typeof keyToJson,\n  map?: SerializedKeyAlias\n): SerializedFields {\n  const mapped: SerializedFields = {};\n\n  for (const key in fields) {\n    if (Object.hasOwn(fields, key)) {\n      mapped[mapper(key, map)] = fields[key];\n    }\n  }\n\n  return mapped;\n}\n"],"mappings":";;;;AAYA,SAAgB,UAAU,KAAa,KAAkC;AACvE,QAAO,MAAM,QAAQ,UAAU,IAAI;;AAGrC,SAAgB,YAAY,KAAa,KAAkC;AACzE,QAAO,MAAM,QAAQ,UAAU,IAAI;;AAGrC,SAAgB,QACd,QACA,QACA,KACkB;CAClB,MAAM,SAA2B,EAAE;AAEnC,MAAK,MAAM,OAAO,OAChB,KAAI,OAAO,OAAO,QAAQ,IAAI,CAC5B,QAAO,OAAO,KAAK,IAAI,IAAI,OAAO;AAItC,QAAO"}
+{"version":3,"file":"map_keys.js","names":[],"sources":["../../src/load/map_keys.ts"],"sourcesContent":["import snakeCase from \"decamelize\";\nimport camelCase from \"camelcase\";\n\nexport interface SerializedFields {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  [key: string]: any;\n}\n\nexport interface SerializedKeyAlias {\n  [key: string]: string;\n}\n\nexport function keyToJson(key: string, map?: SerializedKeyAlias): string {\n  return map?.[key] || snakeCase(key);\n}\n\nexport function keyFromJson(key: string, map?: SerializedKeyAlias): string {\n  return map?.[key] || camelCase(key);\n}\n\nexport function mapKeys(\n  fields: SerializedFields,\n  mapper: typeof keyToJson,\n  map?: SerializedKeyAlias\n): SerializedFields {\n  const mapped: SerializedFields = {};\n\n  for (const key in fields) {\n    if (Object.hasOwn(fields, key)) {\n      mapped[mapper(key, map)] = fields[key];\n    }\n  }\n\n  return mapped;\n}\n"],"mappings":";;;AAYA,SAAgB,UAAU,KAAa,KAAkC;AACvE,QAAO,MAAM,QAAQ,UAAU,IAAI;;AAGrC,SAAgB,YAAY,KAAa,KAAkC;AACzE,QAAO,MAAM,QAAQ,UAAU,IAAI;;AAGrC,SAAgB,QACd,QACA,QACA,KACkB;CAClB,MAAM,SAA2B,EAAE;AAEnC,MAAK,MAAM,OAAO,OAChB,KAAI,OAAO,OAAO,QAAQ,IAAI,CAC5B,QAAO,OAAO,KAAK,IAAI,IAAI,OAAO;AAItC,QAAO"}

package/dist/load/serializable.cjs

@@ -1,8 +1,7 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
-const require_map_keys = require('./map_keys.cjs');
-const require_validation = require('./validation.cjs');
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_map_keys = require("./map_keys.cjs");
+const require_validation = require("./validation.cjs");
 //#region src/load/serializable.ts
 var serializable_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	Serializable: () => Serializable,
@@ -134,14 +133,14 @@ var Serializable = class Serializable {
 		};
 	}
 };
-
 //#endregion
 exports.Serializable = Serializable;
 exports.get_lc_unique_name = get_lc_unique_name;
-Object.defineProperty(exports, 'serializable_exports', {
-  enumerable: true,
-  get: function () {
-    return serializable_exports;
-  }
+Object.defineProperty(exports, "serializable_exports", {
+	enumerable: true,
+	get: function() {
+		return serializable_exports;
+	}
 });
+
 //# sourceMappingURL=serializable.cjs.map

package/dist/load/serializable.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"serializable.cjs","names":["escapeIfNeeded","mapKeys","keyToJson"],"sources":["../../src/load/serializable.ts"],"sourcesContent":["import { type SerializedFields, keyToJson, mapKeys } from \"./map_keys.js\";\nimport { escapeIfNeeded } from \"./validation.js\";\n\nexport interface BaseSerialized<T extends string> {\n  lc: number;\n  type: T;\n  id: string[];\n  name?: string;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  graph?: Record<string, any>;\n}\n\nexport interface SerializedConstructor extends BaseSerialized<\"constructor\"> {\n  kwargs: SerializedFields;\n}\n\nexport interface SerializedSecret extends BaseSerialized<\"secret\"> {}\n\nexport interface SerializedNotImplemented extends BaseSerialized<\"not_implemented\"> {}\n\nexport type Serialized =\n  | SerializedConstructor\n  | SerializedSecret\n  | SerializedNotImplemented;\n\nfunction shallowCopy<T extends object>(obj: T): T {\n  return Array.isArray(obj) ? ([...obj] as T) : ({ ...obj } as T);\n}\n\nfunction replaceSecrets(\n  root: SerializedFields,\n  secretsMap: { [key: string]: string }\n): SerializedFields {\n  const result = shallowCopy(root);\n  for (const [path, secretId] of Object.entries(secretsMap)) {\n    const [last, ...partsReverse] = path.split(\".\").reverse();\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    let current: any = result;\n    for (const part of partsReverse.reverse()) {\n      if (current[part] === undefined) {\n        break;\n      }\n      current[part] = shallowCopy(current[part]);\n      current = current[part];\n    }\n    if (current[last] !== undefined) {\n      current[last] = {\n        lc: 1,\n        type: \"secret\",\n        id: [secretId],\n      };\n    }\n  }\n  return result;\n}\n\n/**\n * Get a unique name for the module, rather than parent class implementations.\n * Should not be subclassed, subclass lc_name above instead.\n */\nexport function get_lc_unique_name(\n  serializableClass: typeof Serializable\n): string {\n  // \"super\" here would refer to the parent class of Serializable,\n  // when we want the parent class of the module actually calling this method.\n  const parentClass = Object.getPrototypeOf(serializableClass);\n  const lcNameIsSubclassed =\n    typeof serializableClass.lc_name === \"function\" &&\n    (typeof parentClass.lc_name !== \"function\" ||\n      serializableClass.lc_name() !== parentClass.lc_name());\n  if (lcNameIsSubclassed) {\n    return serializableClass.lc_name();\n  } else {\n    return serializableClass.name;\n  }\n}\n\n/**\n * Interface for objects that can be serialized.\n * This is a duck-typed interface to avoid circular imports.\n */\nexport interface SerializableLike {\n  lc_serializable: boolean;\n  lc_secrets?: Record<string, string>;\n  toJSON(): {\n    lc: number;\n    type: string;\n    id: string[];\n    kwargs?: Record<string, unknown>;\n  };\n}\n\nexport interface SerializableInterface {\n  get lc_id(): string[];\n}\n\nexport abstract class Serializable implements SerializableInterface {\n  lc_serializable = false;\n\n  lc_kwargs: SerializedFields;\n\n  /**\n   * A path to the module that contains the class, eg. [\"langchain\", \"llms\"]\n   * Usually should be the same as the entrypoint the class is exported from.\n   */\n  abstract lc_namespace: string[];\n\n  /**\n   * The name of the serializable. Override to provide an alias or\n   * to preserve the serialized module name in minified environments.\n   *\n   * Implemented as a static method to support loading logic.\n   */\n  static lc_name(): string {\n    return this.name;\n  }\n\n  /**\n   * The final serialized identifier for the module.\n   */\n  get lc_id(): string[] {\n    return [\n      ...this.lc_namespace,\n      get_lc_unique_name(this.constructor as typeof Serializable),\n    ];\n  }\n\n  /**\n   * A map of secrets, which will be omitted from serialization.\n   * Keys are paths to the secret in constructor args, e.g. \"foo.bar.baz\".\n   * Values are the secret ids, which will be used when deserializing.\n   */\n  get lc_secrets(): { [key: string]: string } | undefined {\n    return undefined;\n  }\n\n  /**\n   * A map of additional attributes to merge with constructor args.\n   * Keys are the attribute names, e.g. \"foo\".\n   * Values are the attribute values, which will be serialized.\n   * These attributes need to be accepted by the constructor as arguments.\n   */\n  get lc_attributes(): SerializedFields | undefined {\n    return undefined;\n  }\n\n  /**\n   * A map of aliases for constructor args.\n   * Keys are the attribute names, e.g. \"foo\".\n   * Values are the alias that will replace the key in serialization.\n   * This is used to eg. make argument names match Python.\n   */\n  get lc_aliases(): { [key: string]: string } | undefined {\n    return undefined;\n  }\n\n  /**\n   * A manual list of keys that should be serialized.\n   * If not overridden, all fields passed into the constructor will be serialized.\n   */\n  get lc_serializable_keys(): string[] | undefined {\n    return undefined;\n  }\n\n  constructor(kwargs?: SerializedFields, ..._args: never[]) {\n    if (this.lc_serializable_keys !== undefined) {\n      this.lc_kwargs = Object.fromEntries(\n        Object.entries(kwargs || {}).filter(([key]) =>\n          this.lc_serializable_keys?.includes(key)\n        )\n      );\n    } else {\n      this.lc_kwargs = kwargs ?? {};\n    }\n  }\n\n  toJSON(): Serialized {\n    if (!this.lc_serializable) {\n      return this.toJSONNotImplemented();\n    }\n    if (\n      // eslint-disable-next-line no-instanceof/no-instanceof\n      this.lc_kwargs instanceof Serializable ||\n      typeof this.lc_kwargs !== \"object\" ||\n      Array.isArray(this.lc_kwargs)\n    ) {\n      // We do not support serialization of classes with arg not a POJO\n      // I'm aware the check above isn't as strict as it could be\n      return this.toJSONNotImplemented();\n    }\n\n    const aliases: { [key: string]: string } = {};\n    const secrets: { [key: string]: string } = {};\n    const kwargs = Object.keys(this.lc_kwargs).reduce((acc, key) => {\n      acc[key] = key in this ? this[key as keyof this] : this.lc_kwargs[key];\n      return acc;\n    }, {} as SerializedFields);\n    // get secrets, attributes and aliases from all superclasses\n    for (\n      let current = Object.getPrototypeOf(this);\n      current;\n      current = Object.getPrototypeOf(current)\n    ) {\n      Object.assign(aliases, Reflect.get(current, \"lc_aliases\", this));\n      Object.assign(secrets, Reflect.get(current, \"lc_secrets\", this));\n      Object.assign(kwargs, Reflect.get(current, \"lc_attributes\", this));\n    }\n\n    // include all secrets used, even if not in kwargs,\n    // will be replaced with sentinel value in replaceSecrets\n    Object.keys(secrets).forEach((keyPath) => {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      let read: any = this;\n\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      let write: any = kwargs;\n\n      const [last, ...partsReverse] = keyPath.split(\".\").reverse();\n      for (const key of partsReverse.reverse()) {\n        if (!(key in read) || read[key] === undefined) return;\n        if (!(key in write) || write[key] === undefined) {\n          if (typeof read[key] === \"object\" && read[key] != null) {\n            write[key] = {};\n          } else if (Array.isArray(read[key])) {\n            write[key] = [];\n          }\n        }\n\n        read = read[key];\n        write = write[key];\n      }\n\n      if (last in read && read[last] !== undefined) {\n        write[last] = write[last] || read[last];\n      }\n    });\n\n    const escapedKwargs: SerializedFields = {};\n    // Track current path to detect circular references (but not shared references)\n    // The Serializable object itself stays in the path to detect self-references in kwargs\n    const pathSet = new WeakSet<object>();\n    pathSet.add(this);\n    for (const [key, value] of Object.entries(kwargs)) {\n      escapedKwargs[key] = escapeIfNeeded(value, pathSet);\n    }\n\n    // Now add secret markers - these are added AFTER escaping so they won't be escaped\n    const kwargsWithSecrets = Object.keys(secrets).length\n      ? replaceSecrets(escapedKwargs, secrets)\n      : escapedKwargs;\n\n    // Finally transform keys to JSON format\n    const processedKwargs = mapKeys(kwargsWithSecrets, keyToJson, aliases);\n\n    return {\n      lc: 1,\n      type: \"constructor\",\n      id: this.lc_id,\n      kwargs: processedKwargs,\n    };\n  }\n\n  toJSONNotImplemented(): SerializedNotImplemented {\n    return {\n      lc: 1,\n      type: \"not_implemented\",\n      id: this.lc_id,\n    };\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"serializable.cjs","names":["escapeIfNeeded","mapKeys","keyToJson"],"sources":["../../src/load/serializable.ts"],"sourcesContent":["import { type SerializedFields, keyToJson, mapKeys } from \"./map_keys.js\";\nimport { escapeIfNeeded } from \"./validation.js\";\n\nexport interface BaseSerialized<T extends string> {\n  lc: number;\n  type: T;\n  id: string[];\n  name?: string;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  graph?: Record<string, any>;\n}\n\nexport interface SerializedConstructor extends BaseSerialized<\"constructor\"> {\n  kwargs: SerializedFields;\n}\n\nexport interface SerializedSecret extends BaseSerialized<\"secret\"> {}\n\nexport interface SerializedNotImplemented extends BaseSerialized<\"not_implemented\"> {}\n\nexport type Serialized =\n  | SerializedConstructor\n  | SerializedSecret\n  | SerializedNotImplemented;\n\nfunction shallowCopy<T extends object>(obj: T): T {\n  return Array.isArray(obj) ? ([...obj] as T) : ({ ...obj } as T);\n}\n\nfunction replaceSecrets(\n  root: SerializedFields,\n  secretsMap: { [key: string]: string }\n): SerializedFields {\n  const result = shallowCopy(root);\n  for (const [path, secretId] of Object.entries(secretsMap)) {\n    const [last, ...partsReverse] = path.split(\".\").reverse();\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    let current: any = result;\n    for (const part of partsReverse.reverse()) {\n      if (current[part] === undefined) {\n        break;\n      }\n      current[part] = shallowCopy(current[part]);\n      current = current[part];\n    }\n    if (current[last] !== undefined) {\n      current[last] = {\n        lc: 1,\n        type: \"secret\",\n        id: [secretId],\n      };\n    }\n  }\n  return result;\n}\n\n/**\n * Get a unique name for the module, rather than parent class implementations.\n * Should not be subclassed, subclass lc_name above instead.\n */\nexport function get_lc_unique_name(\n  serializableClass: typeof Serializable\n): string {\n  // \"super\" here would refer to the parent class of Serializable,\n  // when we want the parent class of the module actually calling this method.\n  const parentClass = Object.getPrototypeOf(serializableClass);\n  const lcNameIsSubclassed =\n    typeof serializableClass.lc_name === \"function\" &&\n    (typeof parentClass.lc_name !== \"function\" ||\n      serializableClass.lc_name() !== parentClass.lc_name());\n  if (lcNameIsSubclassed) {\n    return serializableClass.lc_name();\n  } else {\n    return serializableClass.name;\n  }\n}\n\n/**\n * Interface for objects that can be serialized.\n * This is a duck-typed interface to avoid circular imports.\n */\nexport interface SerializableLike {\n  lc_serializable: boolean;\n  lc_secrets?: Record<string, string>;\n  toJSON(): {\n    lc: number;\n    type: string;\n    id: string[];\n    kwargs?: Record<string, unknown>;\n  };\n}\n\nexport interface SerializableInterface {\n  get lc_id(): string[];\n}\n\nexport abstract class Serializable implements SerializableInterface {\n  lc_serializable = false;\n\n  lc_kwargs: SerializedFields;\n\n  /**\n   * A path to the module that contains the class, eg. [\"langchain\", \"llms\"]\n   * Usually should be the same as the entrypoint the class is exported from.\n   */\n  abstract lc_namespace: string[];\n\n  /**\n   * The name of the serializable. Override to provide an alias or\n   * to preserve the serialized module name in minified environments.\n   *\n   * Implemented as a static method to support loading logic.\n   */\n  static lc_name(): string {\n    return this.name;\n  }\n\n  /**\n   * The final serialized identifier for the module.\n   */\n  get lc_id(): string[] {\n    return [\n      ...this.lc_namespace,\n      get_lc_unique_name(this.constructor as typeof Serializable),\n    ];\n  }\n\n  /**\n   * A map of secrets, which will be omitted from serialization.\n   * Keys are paths to the secret in constructor args, e.g. \"foo.bar.baz\".\n   * Values are the secret ids, which will be used when deserializing.\n   */\n  get lc_secrets(): { [key: string]: string } | undefined {\n    return undefined;\n  }\n\n  /**\n   * A map of additional attributes to merge with constructor args.\n   * Keys are the attribute names, e.g. \"foo\".\n   * Values are the attribute values, which will be serialized.\n   * These attributes need to be accepted by the constructor as arguments.\n   */\n  get lc_attributes(): SerializedFields | undefined {\n    return undefined;\n  }\n\n  /**\n   * A map of aliases for constructor args.\n   * Keys are the attribute names, e.g. \"foo\".\n   * Values are the alias that will replace the key in serialization.\n   * This is used to eg. make argument names match Python.\n   */\n  get lc_aliases(): { [key: string]: string } | undefined {\n    return undefined;\n  }\n\n  /**\n   * A manual list of keys that should be serialized.\n   * If not overridden, all fields passed into the constructor will be serialized.\n   */\n  get lc_serializable_keys(): string[] | undefined {\n    return undefined;\n  }\n\n  constructor(kwargs?: SerializedFields, ..._args: never[]) {\n    if (this.lc_serializable_keys !== undefined) {\n      this.lc_kwargs = Object.fromEntries(\n        Object.entries(kwargs || {}).filter(([key]) =>\n          this.lc_serializable_keys?.includes(key)\n        )\n      );\n    } else {\n      this.lc_kwargs = kwargs ?? {};\n    }\n  }\n\n  toJSON(): Serialized {\n    if (!this.lc_serializable) {\n      return this.toJSONNotImplemented();\n    }\n    if (\n      // eslint-disable-next-line no-instanceof/no-instanceof\n      this.lc_kwargs instanceof Serializable ||\n      typeof this.lc_kwargs !== \"object\" ||\n      Array.isArray(this.lc_kwargs)\n    ) {\n      // We do not support serialization of classes with arg not a POJO\n      // I'm aware the check above isn't as strict as it could be\n      return this.toJSONNotImplemented();\n    }\n\n    const aliases: { [key: string]: string } = {};\n    const secrets: { [key: string]: string } = {};\n    const kwargs = Object.keys(this.lc_kwargs).reduce((acc, key) => {\n      acc[key] = key in this ? this[key as keyof this] : this.lc_kwargs[key];\n      return acc;\n    }, {} as SerializedFields);\n    // get secrets, attributes and aliases from all superclasses\n    for (\n      let current = Object.getPrototypeOf(this);\n      current;\n      current = Object.getPrototypeOf(current)\n    ) {\n      Object.assign(aliases, Reflect.get(current, \"lc_aliases\", this));\n      Object.assign(secrets, Reflect.get(current, \"lc_secrets\", this));\n      Object.assign(kwargs, Reflect.get(current, \"lc_attributes\", this));\n    }\n\n    // include all secrets used, even if not in kwargs,\n    // will be replaced with sentinel value in replaceSecrets\n    Object.keys(secrets).forEach((keyPath) => {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      let read: any = this;\n\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      let write: any = kwargs;\n\n      const [last, ...partsReverse] = keyPath.split(\".\").reverse();\n      for (const key of partsReverse.reverse()) {\n        if (!(key in read) || read[key] === undefined) return;\n        if (!(key in write) || write[key] === undefined) {\n          if (typeof read[key] === \"object\" && read[key] != null) {\n            write[key] = {};\n          } else if (Array.isArray(read[key])) {\n            write[key] = [];\n          }\n        }\n\n        read = read[key];\n        write = write[key];\n      }\n\n      if (last in read && read[last] !== undefined) {\n        write[last] = write[last] || read[last];\n      }\n    });\n\n    const escapedKwargs: SerializedFields = {};\n    // Track current path to detect circular references (but not shared references)\n    // The Serializable object itself stays in the path to detect self-references in kwargs\n    const pathSet = new WeakSet<object>();\n    pathSet.add(this);\n    for (const [key, value] of Object.entries(kwargs)) {\n      escapedKwargs[key] = escapeIfNeeded(value, pathSet);\n    }\n\n    // Now add secret markers - these are added AFTER escaping so they won't be escaped\n    const kwargsWithSecrets = Object.keys(secrets).length\n      ? replaceSecrets(escapedKwargs, secrets)\n      : escapedKwargs;\n\n    // Finally transform keys to JSON format\n    const processedKwargs = mapKeys(kwargsWithSecrets, keyToJson, aliases);\n\n    return {\n      lc: 1,\n      type: \"constructor\",\n      id: this.lc_id,\n      kwargs: processedKwargs,\n    };\n  }\n\n  toJSONNotImplemented(): SerializedNotImplemented {\n    return {\n      lc: 1,\n      type: \"not_implemented\",\n      id: this.lc_id,\n    };\n  }\n}\n"],"mappings":"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"}

package/dist/load/serializable.js

@@ -1,7 +1,6 @@
 import { __exportAll } from "../_virtual/_rolldown/runtime.js";
 import { keyToJson, mapKeys } from "./map_keys.js";
 import { escapeIfNeeded } from "./validation.js";
-
 //#region src/load/serializable.ts
 var serializable_exports = /* @__PURE__ */ __exportAll({
 	Serializable: () => Serializable,
@@ -133,7 +132,7 @@ var Serializable = class Serializable {
 		};
 	}
 };
-
 //#endregion
 export { Serializable, get_lc_unique_name, serializable_exports };
+
 //# sourceMappingURL=serializable.js.map

package/dist/load/serializable.js.map

@@ -1 +1 @@
-{"version":3,"file":"serializable.js","names":[],"sources":["../../src/load/serializable.ts"],"sourcesContent":["import { type SerializedFields, keyToJson, mapKeys } from \"./map_keys.js\";\nimport { escapeIfNeeded } from \"./validation.js\";\n\nexport interface BaseSerialized<T extends string> {\n  lc: number;\n  type: T;\n  id: string[];\n  name?: string;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  graph?: Record<string, any>;\n}\n\nexport interface SerializedConstructor extends BaseSerialized<\"constructor\"> {\n  kwargs: SerializedFields;\n}\n\nexport interface SerializedSecret extends BaseSerialized<\"secret\"> {}\n\nexport interface SerializedNotImplemented extends BaseSerialized<\"not_implemented\"> {}\n\nexport type Serialized =\n  | SerializedConstructor\n  | SerializedSecret\n  | SerializedNotImplemented;\n\nfunction shallowCopy<T extends object>(obj: T): T {\n  return Array.isArray(obj) ? ([...obj] as T) : ({ ...obj } as T);\n}\n\nfunction replaceSecrets(\n  root: SerializedFields,\n  secretsMap: { [key: string]: string }\n): SerializedFields {\n  const result = shallowCopy(root);\n  for (const [path, secretId] of Object.entries(secretsMap)) {\n    const [last, ...partsReverse] = path.split(\".\").reverse();\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    let current: any = result;\n    for (const part of partsReverse.reverse()) {\n      if (current[part] === undefined) {\n        break;\n      }\n      current[part] = shallowCopy(current[part]);\n      current = current[part];\n    }\n    if (current[last] !== undefined) {\n      current[last] = {\n        lc: 1,\n        type: \"secret\",\n        id: [secretId],\n      };\n    }\n  }\n  return result;\n}\n\n/**\n * Get a unique name for the module, rather than parent class implementations.\n * Should not be subclassed, subclass lc_name above instead.\n */\nexport function get_lc_unique_name(\n  serializableClass: typeof Serializable\n): string {\n  // \"super\" here would refer to the parent class of Serializable,\n  // when we want the parent class of the module actually calling this method.\n  const parentClass = Object.getPrototypeOf(serializableClass);\n  const lcNameIsSubclassed =\n    typeof serializableClass.lc_name === \"function\" &&\n    (typeof parentClass.lc_name !== \"function\" ||\n      serializableClass.lc_name() !== parentClass.lc_name());\n  if (lcNameIsSubclassed) {\n    return serializableClass.lc_name();\n  } else {\n    return serializableClass.name;\n  }\n}\n\n/**\n * Interface for objects that can be serialized.\n * This is a duck-typed interface to avoid circular imports.\n */\nexport interface SerializableLike {\n  lc_serializable: boolean;\n  lc_secrets?: Record<string, string>;\n  toJSON(): {\n    lc: number;\n    type: string;\n    id: string[];\n    kwargs?: Record<string, unknown>;\n  };\n}\n\nexport interface SerializableInterface {\n  get lc_id(): string[];\n}\n\nexport abstract class Serializable implements SerializableInterface {\n  lc_serializable = false;\n\n  lc_kwargs: SerializedFields;\n\n  /**\n   * A path to the module that contains the class, eg. [\"langchain\", \"llms\"]\n   * Usually should be the same as the entrypoint the class is exported from.\n   */\n  abstract lc_namespace: string[];\n\n  /**\n   * The name of the serializable. Override to provide an alias or\n   * to preserve the serialized module name in minified environments.\n   *\n   * Implemented as a static method to support loading logic.\n   */\n  static lc_name(): string {\n    return this.name;\n  }\n\n  /**\n   * The final serialized identifier for the module.\n   */\n  get lc_id(): string[] {\n    return [\n      ...this.lc_namespace,\n      get_lc_unique_name(this.constructor as typeof Serializable),\n    ];\n  }\n\n  /**\n   * A map of secrets, which will be omitted from serialization.\n   * Keys are paths to the secret in constructor args, e.g. \"foo.bar.baz\".\n   * Values are the secret ids, which will be used when deserializing.\n   */\n  get lc_secrets(): { [key: string]: string } | undefined {\n    return undefined;\n  }\n\n  /**\n   * A map of additional attributes to merge with constructor args.\n   * Keys are the attribute names, e.g. \"foo\".\n   * Values are the attribute values, which will be serialized.\n   * These attributes need to be accepted by the constructor as arguments.\n   */\n  get lc_attributes(): SerializedFields | undefined {\n    return undefined;\n  }\n\n  /**\n   * A map of aliases for constructor args.\n   * Keys are the attribute names, e.g. \"foo\".\n   * Values are the alias that will replace the key in serialization.\n   * This is used to eg. make argument names match Python.\n   */\n  get lc_aliases(): { [key: string]: string } | undefined {\n    return undefined;\n  }\n\n  /**\n   * A manual list of keys that should be serialized.\n   * If not overridden, all fields passed into the constructor will be serialized.\n   */\n  get lc_serializable_keys(): string[] | undefined {\n    return undefined;\n  }\n\n  constructor(kwargs?: SerializedFields, ..._args: never[]) {\n    if (this.lc_serializable_keys !== undefined) {\n      this.lc_kwargs = Object.fromEntries(\n        Object.entries(kwargs || {}).filter(([key]) =>\n          this.lc_serializable_keys?.includes(key)\n        )\n      );\n    } else {\n      this.lc_kwargs = kwargs ?? {};\n    }\n  }\n\n  toJSON(): Serialized {\n    if (!this.lc_serializable) {\n      return this.toJSONNotImplemented();\n    }\n    if (\n      // eslint-disable-next-line no-instanceof/no-instanceof\n      this.lc_kwargs instanceof Serializable ||\n      typeof this.lc_kwargs !== \"object\" ||\n      Array.isArray(this.lc_kwargs)\n    ) {\n      // We do not support serialization of classes with arg not a POJO\n      // I'm aware the check above isn't as strict as it could be\n      return this.toJSONNotImplemented();\n    }\n\n    const aliases: { [key: string]: string } = {};\n    const secrets: { [key: string]: string } = {};\n    const kwargs = Object.keys(this.lc_kwargs).reduce((acc, key) => {\n      acc[key] = key in this ? this[key as keyof this] : this.lc_kwargs[key];\n      return acc;\n    }, {} as SerializedFields);\n    // get secrets, attributes and aliases from all superclasses\n    for (\n      let current = Object.getPrototypeOf(this);\n      current;\n      current = Object.getPrototypeOf(current)\n    ) {\n      Object.assign(aliases, Reflect.get(current, \"lc_aliases\", this));\n      Object.assign(secrets, Reflect.get(current, \"lc_secrets\", this));\n      Object.assign(kwargs, Reflect.get(current, \"lc_attributes\", this));\n    }\n\n    // include all secrets used, even if not in kwargs,\n    // will be replaced with sentinel value in replaceSecrets\n    Object.keys(secrets).forEach((keyPath) => {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      let read: any = this;\n\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      let write: any = kwargs;\n\n      const [last, ...partsReverse] = keyPath.split(\".\").reverse();\n      for (const key of partsReverse.reverse()) {\n        if (!(key in read) || read[key] === undefined) return;\n        if (!(key in write) || write[key] === undefined) {\n          if (typeof read[key] === \"object\" && read[key] != null) {\n            write[key] = {};\n          } else if (Array.isArray(read[key])) {\n            write[key] = [];\n          }\n        }\n\n        read = read[key];\n        write = write[key];\n      }\n\n      if (last in read && read[last] !== undefined) {\n        write[last] = write[last] || read[last];\n      }\n    });\n\n    const escapedKwargs: SerializedFields = {};\n    // Track current path to detect circular references (but not shared references)\n    // The Serializable object itself stays in the path to detect self-references in kwargs\n    const pathSet = new WeakSet<object>();\n    pathSet.add(this);\n    for (const [key, value] of Object.entries(kwargs)) {\n      escapedKwargs[key] = escapeIfNeeded(value, pathSet);\n    }\n\n    // Now add secret markers - these are added AFTER escaping so they won't be escaped\n    const kwargsWithSecrets = Object.keys(secrets).length\n      ? replaceSecrets(escapedKwargs, secrets)\n      : escapedKwargs;\n\n    // Finally transform keys to JSON format\n    const processedKwargs = mapKeys(kwargsWithSecrets, keyToJson, aliases);\n\n    return {\n      lc: 1,\n      type: \"constructor\",\n      id: this.lc_id,\n      kwargs: processedKwargs,\n    };\n  }\n\n  toJSONNotImplemented(): SerializedNotImplemented {\n    return {\n      lc: 1,\n      type: \"not_implemented\",\n      id: this.lc_id,\n    };\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"serializable.js","names":[],"sources":["../../src/load/serializable.ts"],"sourcesContent":["import { type SerializedFields, keyToJson, mapKeys } from \"./map_keys.js\";\nimport { escapeIfNeeded } from \"./validation.js\";\n\nexport interface BaseSerialized<T extends string> {\n  lc: number;\n  type: T;\n  id: string[];\n  name?: string;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  graph?: Record<string, any>;\n}\n\nexport interface SerializedConstructor extends BaseSerialized<\"constructor\"> {\n  kwargs: SerializedFields;\n}\n\nexport interface SerializedSecret extends BaseSerialized<\"secret\"> {}\n\nexport interface SerializedNotImplemented extends BaseSerialized<\"not_implemented\"> {}\n\nexport type Serialized =\n  | SerializedConstructor\n  | SerializedSecret\n  | SerializedNotImplemented;\n\nfunction shallowCopy<T extends object>(obj: T): T {\n  return Array.isArray(obj) ? ([...obj] as T) : ({ ...obj } as T);\n}\n\nfunction replaceSecrets(\n  root: SerializedFields,\n  secretsMap: { [key: string]: string }\n): SerializedFields {\n  const result = shallowCopy(root);\n  for (const [path, secretId] of Object.entries(secretsMap)) {\n    const [last, ...partsReverse] = path.split(\".\").reverse();\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    let current: any = result;\n    for (const part of partsReverse.reverse()) {\n      if (current[part] === undefined) {\n        break;\n      }\n      current[part] = shallowCopy(current[part]);\n      current = current[part];\n    }\n    if (current[last] !== undefined) {\n      current[last] = {\n        lc: 1,\n        type: \"secret\",\n        id: [secretId],\n      };\n    }\n  }\n  return result;\n}\n\n/**\n * Get a unique name for the module, rather than parent class implementations.\n * Should not be subclassed, subclass lc_name above instead.\n */\nexport function get_lc_unique_name(\n  serializableClass: typeof Serializable\n): string {\n  // \"super\" here would refer to the parent class of Serializable,\n  // when we want the parent class of the module actually calling this method.\n  const parentClass = Object.getPrototypeOf(serializableClass);\n  const lcNameIsSubclassed =\n    typeof serializableClass.lc_name === \"function\" &&\n    (typeof parentClass.lc_name !== \"function\" ||\n      serializableClass.lc_name() !== parentClass.lc_name());\n  if (lcNameIsSubclassed) {\n    return serializableClass.lc_name();\n  } else {\n    return serializableClass.name;\n  }\n}\n\n/**\n * Interface for objects that can be serialized.\n * This is a duck-typed interface to avoid circular imports.\n */\nexport interface SerializableLike {\n  lc_serializable: boolean;\n  lc_secrets?: Record<string, string>;\n  toJSON(): {\n    lc: number;\n    type: string;\n    id: string[];\n    kwargs?: Record<string, unknown>;\n  };\n}\n\nexport interface SerializableInterface {\n  get lc_id(): string[];\n}\n\nexport abstract class Serializable implements SerializableInterface {\n  lc_serializable = false;\n\n  lc_kwargs: SerializedFields;\n\n  /**\n   * A path to the module that contains the class, eg. [\"langchain\", \"llms\"]\n   * Usually should be the same as the entrypoint the class is exported from.\n   */\n  abstract lc_namespace: string[];\n\n  /**\n   * The name of the serializable. Override to provide an alias or\n   * to preserve the serialized module name in minified environments.\n   *\n   * Implemented as a static method to support loading logic.\n   */\n  static lc_name(): string {\n    return this.name;\n  }\n\n  /**\n   * The final serialized identifier for the module.\n   */\n  get lc_id(): string[] {\n    return [\n      ...this.lc_namespace,\n      get_lc_unique_name(this.constructor as typeof Serializable),\n    ];\n  }\n\n  /**\n   * A map of secrets, which will be omitted from serialization.\n   * Keys are paths to the secret in constructor args, e.g. \"foo.bar.baz\".\n   * Values are the secret ids, which will be used when deserializing.\n   */\n  get lc_secrets(): { [key: string]: string } | undefined {\n    return undefined;\n  }\n\n  /**\n   * A map of additional attributes to merge with constructor args.\n   * Keys are the attribute names, e.g. \"foo\".\n   * Values are the attribute values, which will be serialized.\n   * These attributes need to be accepted by the constructor as arguments.\n   */\n  get lc_attributes(): SerializedFields | undefined {\n    return undefined;\n  }\n\n  /**\n   * A map of aliases for constructor args.\n   * Keys are the attribute names, e.g. \"foo\".\n   * Values are the alias that will replace the key in serialization.\n   * This is used to eg. make argument names match Python.\n   */\n  get lc_aliases(): { [key: string]: string } | undefined {\n    return undefined;\n  }\n\n  /**\n   * A manual list of keys that should be serialized.\n   * If not overridden, all fields passed into the constructor will be serialized.\n   */\n  get lc_serializable_keys(): string[] | undefined {\n    return undefined;\n  }\n\n  constructor(kwargs?: SerializedFields, ..._args: never[]) {\n    if (this.lc_serializable_keys !== undefined) {\n      this.lc_kwargs = Object.fromEntries(\n        Object.entries(kwargs || {}).filter(([key]) =>\n          this.lc_serializable_keys?.includes(key)\n        )\n      );\n    } else {\n      this.lc_kwargs = kwargs ?? {};\n    }\n  }\n\n  toJSON(): Serialized {\n    if (!this.lc_serializable) {\n      return this.toJSONNotImplemented();\n    }\n    if (\n      // eslint-disable-next-line no-instanceof/no-instanceof\n      this.lc_kwargs instanceof Serializable ||\n      typeof this.lc_kwargs !== \"object\" ||\n      Array.isArray(this.lc_kwargs)\n    ) {\n      // We do not support serialization of classes with arg not a POJO\n      // I'm aware the check above isn't as strict as it could be\n      return this.toJSONNotImplemented();\n    }\n\n    const aliases: { [key: string]: string } = {};\n    const secrets: { [key: string]: string } = {};\n    const kwargs = Object.keys(this.lc_kwargs).reduce((acc, key) => {\n      acc[key] = key in this ? this[key as keyof this] : this.lc_kwargs[key];\n      return acc;\n    }, {} as SerializedFields);\n    // get secrets, attributes and aliases from all superclasses\n    for (\n      let current = Object.getPrototypeOf(this);\n      current;\n      current = Object.getPrototypeOf(current)\n    ) {\n      Object.assign(aliases, Reflect.get(current, \"lc_aliases\", this));\n      Object.assign(secrets, Reflect.get(current, \"lc_secrets\", this));\n      Object.assign(kwargs, Reflect.get(current, \"lc_attributes\", this));\n    }\n\n    // include all secrets used, even if not in kwargs,\n    // will be replaced with sentinel value in replaceSecrets\n    Object.keys(secrets).forEach((keyPath) => {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      let read: any = this;\n\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      let write: any = kwargs;\n\n      const [last, ...partsReverse] = keyPath.split(\".\").reverse();\n      for (const key of partsReverse.reverse()) {\n        if (!(key in read) || read[key] === undefined) return;\n        if (!(key in write) || write[key] === undefined) {\n          if (typeof read[key] === \"object\" && read[key] != null) {\n            write[key] = {};\n          } else if (Array.isArray(read[key])) {\n            write[key] = [];\n          }\n        }\n\n        read = read[key];\n        write = write[key];\n      }\n\n      if (last in read && read[last] !== undefined) {\n        write[last] = write[last] || read[last];\n      }\n    });\n\n    const escapedKwargs: SerializedFields = {};\n    // Track current path to detect circular references (but not shared references)\n    // The Serializable object itself stays in the path to detect self-references in kwargs\n    const pathSet = new WeakSet<object>();\n    pathSet.add(this);\n    for (const [key, value] of Object.entries(kwargs)) {\n      escapedKwargs[key] = escapeIfNeeded(value, pathSet);\n    }\n\n    // Now add secret markers - these are added AFTER escaping so they won't be escaped\n    const kwargsWithSecrets = Object.keys(secrets).length\n      ? replaceSecrets(escapedKwargs, secrets)\n      : escapedKwargs;\n\n    // Finally transform keys to JSON format\n    const processedKwargs = mapKeys(kwargsWithSecrets, keyToJson, aliases);\n\n    return {\n      lc: 1,\n      type: \"constructor\",\n      id: this.lc_id,\n      kwargs: processedKwargs,\n    };\n  }\n\n  toJSONNotImplemented(): SerializedNotImplemented {\n    return {\n      lc: 1,\n      type: \"not_implemented\",\n      id: this.lc_id,\n    };\n  }\n}\n"],"mappings":"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"}

package/dist/load/validation.cjs

@@ -1,4 +1,3 @@
-
 //#region src/load/validation.ts
 /**
 * Sentinel key used to mark escaped user objects during serialization.
@@ -15,7 +14,7 @@ const LC_ESCAPED_KEY = "__lc_escaped__";
 * 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;
+	return "lc" in obj || Object.keys(obj).length === 1 && "__lc_escaped__" in obj;
 }
 /**
 * Wrap an object in the escape marker.
@@ -37,7 +36,7 @@ function escapeObject(obj) {
 * ```
 */
 function isEscapedObject(obj) {
-	return Object.keys(obj).length === 1 && LC_ESCAPED_KEY in obj;
+	return Object.keys(obj).length === 1 && "__lc_escaped__" in obj;
 }
 /**
 * Check if an object looks like a Serializable instance (duck typing).
@@ -113,9 +112,9 @@ function unescapeValue(obj) {
 	if (Array.isArray(obj)) return obj.map((item) => unescapeValue(item));
 	return obj;
 }
-
 //#endregion
 exports.escapeIfNeeded = escapeIfNeeded;
 exports.isEscapedObject = isEscapedObject;
 exports.unescapeValue = unescapeValue;
+
 //# sourceMappingURL=validation.cjs.map

package/dist/load/validation.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"validation.cjs","names":[],"sources":["../../src/load/validation.ts"],"sourcesContent":["/**\n * Sentinel key used to mark escaped user objects during serialization.\n *\n * When a plain object contains 'lc' key (which could be confused with LC objects),\n * we wrap it as `{\"__lc_escaped__\": {...original...}}`.\n */\nexport const LC_ESCAPED_KEY = \"__lc_escaped__\";\n\n/**\n * Check if an object needs escaping to prevent confusion with LC objects.\n *\n * An object needs escaping if:\n * 1. It has an `'lc'` key (could be confused with LC serialization format)\n * 2. It has only the escape key (would be mistaken for an escaped object)\n */\nexport function needsEscaping(obj: Record<string, unknown>): boolean {\n  return (\n    \"lc\" in obj || (Object.keys(obj).length === 1 && LC_ESCAPED_KEY in obj)\n  );\n}\n\n/**\n * Wrap an object in the escape marker.\n *\n * @example\n * ```typescript\n * {\"key\": \"value\"}  // becomes {\"__lc_escaped__\": {\"key\": \"value\"}}\n * ```\n */\nexport function escapeObject(\n  obj: Record<string, unknown>\n): Record<string, unknown> {\n  return { [LC_ESCAPED_KEY]: obj };\n}\n\n/**\n * Check if an object is an escaped user object.\n *\n * @example\n * ```typescript\n * {\"__lc_escaped__\": {...}}  // is an escaped object\n * ```\n */\nexport function isEscapedObject(obj: Record<string, unknown>): boolean {\n  return Object.keys(obj).length === 1 && LC_ESCAPED_KEY in obj;\n}\n\n/**\n * Interface for objects that can be serialized.\n * This is a duck-typed interface to avoid circular imports.\n */\ninterface SerializableLike {\n  lc_serializable: boolean;\n  lc_secrets?: Record<string, string>;\n  toJSON(): {\n    lc: number;\n    type: string;\n    id: string[];\n    kwargs?: Record<string, unknown>;\n  };\n}\n\n/**\n * Check if an object looks like a Serializable instance (duck typing).\n */\nfunction isSerializableLike(obj: unknown): obj is SerializableLike {\n  return (\n    obj !== null &&\n    typeof obj === \"object\" &&\n    \"lc_serializable\" in obj &&\n    typeof (obj as SerializableLike).toJSON === \"function\"\n  );\n}\n\n/**\n * Create a \"not_implemented\" serialization result for objects that cannot be serialized.\n */\nfunction createNotImplemented(obj: unknown): {\n  lc: 1;\n  type: \"not_implemented\";\n  id: string[];\n} {\n  let id: string[];\n  if (obj !== null && typeof obj === \"object\") {\n    if (\"lc_id\" in obj && Array.isArray(obj.lc_id)) {\n      id = obj.lc_id as string[];\n    } else {\n      id = [obj.constructor?.name ?? \"Object\"];\n    }\n  } else {\n    id = [typeof obj];\n  }\n  return {\n    lc: 1,\n    type: \"not_implemented\",\n    id,\n  };\n}\n\n/**\n * Serialize a value with escaping of user objects.\n *\n * Called recursively on kwarg values to escape any plain objects that could be\n * confused with LC objects.\n *\n * @param obj - The value to serialize.\n * @param pathSet - WeakSet to track ancestor objects in the current path to detect circular references.\n *                  Objects are removed after processing to allow shared references (same object in\n *                  multiple places) while still detecting true circular references (ancestor in descendant).\n * @returns The serialized value with user objects escaped as needed.\n */\nexport function serializeValue(\n  obj: unknown,\n  pathSet: WeakSet<object> = new WeakSet()\n): unknown {\n  if (obj !== null && typeof obj === \"object\" && !Array.isArray(obj)) {\n    // Check for circular reference - only if this object is an ancestor in the current path\n    if (pathSet.has(obj)) {\n      return createNotImplemented(obj);\n    }\n\n    if (isSerializableLike(obj)) {\n      // This is an LC object - serialize it properly (not escaped)\n      return serializeLcObject(obj, pathSet);\n    }\n\n    // Add to path before processing children\n    pathSet.add(obj);\n\n    const record = obj as Record<string, unknown>;\n    // Check if object needs escaping BEFORE recursing into values.\n    // If it needs escaping, wrap it as-is - the contents are user data that\n    // will be returned as-is during deserialization (no instantiation).\n    // This prevents re-escaping of already-escaped nested content.\n    if (needsEscaping(record)) {\n      // Remove from path before returning (to allow shared references)\n      pathSet.delete(obj);\n      return escapeObject(record);\n    }\n    // Safe object (no 'lc' key) - recurse into values\n    const result: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(record)) {\n      result[key] = serializeValue(value, pathSet);\n    }\n    // Remove from path after processing (to allow shared references in other branches)\n    pathSet.delete(obj);\n    return result;\n  }\n\n  if (Array.isArray(obj)) {\n    // Arrays don't need circular reference tracking since they're handled by object tracking\n    return obj.map((item) => serializeValue(item, pathSet));\n  }\n\n  if (\n    typeof obj === \"string\" ||\n    typeof obj === \"number\" ||\n    typeof obj === \"boolean\" ||\n    obj === null\n  ) {\n    return obj;\n  }\n\n  // Non-JSON-serializable object (Date, custom objects, etc.)\n  return createNotImplemented(obj);\n}\n\n/**\n * Serialize a `Serializable` object with escaping of user data in kwargs.\n *\n * @param obj - The `Serializable` object to serialize.\n * @param pathSet - WeakSet to track ancestor objects in the current path to detect circular references.\n *                  The Serializable object is kept in the path set to detect if it appears in its own kwargs.\n * @returns The serialized object with user data in kwargs escaped as needed.\n *\n * @remarks\n * Kwargs values are processed with `serializeValue` to escape user data (like\n * metadata) that contains `'lc'` keys. Secret fields (from `lc_secrets`) are\n * skipped because `toJSON()` replaces their values with secret markers.\n */\nexport function serializeLcObject(\n  obj: SerializableLike,\n  pathSet: WeakSet<object> = new WeakSet()\n): {\n  lc: number;\n  type: string;\n  id: string[];\n  kwargs?: Record<string, unknown>;\n} {\n  // Add object to path set to detect if it appears in its own kwargs (circular reference)\n  // Note: We intentionally don't remove this after processing because a Serializable\n  // appearing in its own kwargs is always a circular reference that should be detected.\n  pathSet.add(obj);\n\n  // Secret fields are handled by toJSON() - it replaces values with secret markers\n  const secretFields = new Set(Object.keys(obj.lc_secrets ?? {}));\n\n  const serialized = { ...obj.toJSON() };\n\n  // Process kwargs to escape user data that could be confused with LC objects\n  // Skip secret fields - toJSON() already converted them to secret markers\n  if (serialized.type === \"constructor\" && serialized.kwargs) {\n    const newKwargs: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(serialized.kwargs)) {\n      if (secretFields.has(key)) {\n        newKwargs[key] = value;\n      } else {\n        newKwargs[key] = serializeValue(value, pathSet);\n      }\n    }\n    serialized.kwargs = newKwargs;\n  }\n\n  return serialized;\n}\n\n/**\n * Escape a value if it needs escaping (contains `lc` key).\n *\n * This is a simpler version of `serializeValue` that doesn't handle Serializable\n * objects - it's meant to be called on kwargs values that have already been\n * processed by `toJSON()`.\n *\n * @param value - The value to potentially escape.\n * @param pathSet - WeakSet to track ancestor objects in the current path to detect circular references.\n *                  Objects are removed after processing to allow shared references (same object in\n *                  multiple places) while still detecting true circular references (ancestor in descendant).\n * @returns The value with any `lc`-containing objects wrapped in escape markers.\n */\nexport function escapeIfNeeded(\n  value: unknown,\n  pathSet: WeakSet<object> = new WeakSet()\n): unknown {\n  if (value !== null && typeof value === \"object\" && !Array.isArray(value)) {\n    // Check for circular reference - only if this object is an ancestor in the current path\n    if (pathSet.has(value)) {\n      // Replace circular reference with a not_implemented marker\n      return createNotImplemented(value);\n    }\n\n    // Preserve Serializable objects - they have their own toJSON() that will be\n    // called by JSON.stringify. We don't want to convert them to plain objects.\n    if (isSerializableLike(value)) {\n      return value;\n    }\n\n    // Add to path before processing children\n    pathSet.add(value);\n\n    const record = value as Record<string, unknown>;\n    // Check if object needs escaping BEFORE recursing into values.\n    // If it needs escaping, wrap it as-is - the contents are user data that\n    // will be returned as-is during deserialization (no instantiation).\n    if (needsEscaping(record)) {\n      // Remove from path before returning (to allow shared references)\n      pathSet.delete(value);\n      return escapeObject(record);\n    }\n    // Safe object (no 'lc' key) - recurse into values\n    const result: Record<string, unknown> = {};\n    for (const [key, val] of Object.entries(record)) {\n      result[key] = escapeIfNeeded(val, pathSet);\n    }\n    // Remove from path after processing (to allow shared references in other branches)\n    pathSet.delete(value);\n    return result;\n  }\n\n  if (Array.isArray(value)) {\n    return value.map((item) => escapeIfNeeded(item, pathSet));\n  }\n\n  return value;\n}\n\n/**\n * Unescape a value, processing escape markers in object values and arrays.\n *\n * When an escaped object is encountered (`{\"__lc_escaped__\": ...}`), it's\n * unwrapped and the contents are returned AS-IS (no further processing).\n * The contents represent user data that should not be modified.\n *\n * For regular objects and arrays, we recurse to find any nested escape markers.\n *\n * @param obj - The value to unescape.\n * @returns The unescaped value.\n */\nexport function unescapeValue(obj: unknown): unknown {\n  if (obj !== null && typeof obj === \"object\" && !Array.isArray(obj)) {\n    const record = obj as Record<string, unknown>;\n    if (isEscapedObject(record)) {\n      // Unwrap and return the user data as-is (no further unescaping).\n      // The contents are user data that may contain more escape keys,\n      // but those are part of the user's actual data.\n      return record[LC_ESCAPED_KEY];\n    }\n\n    // Regular object - recurse into values to find nested escape markers\n    const result: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(record)) {\n      result[key] = unescapeValue(value);\n    }\n    return result;\n  }\n\n  if (Array.isArray(obj)) {\n    return obj.map((item) => unescapeValue(item));\n  }\n\n  return obj;\n}\n"],"mappings":";;;;;;;;AAMA,MAAa,iBAAiB;;;;;;;;AAS9B,SAAgB,cAAc,KAAuC;AACnE,QACE,QAAQ,OAAQ,OAAO,KAAK,IAAI,CAAC,WAAW,KAAK,kBAAkB;;;;;;;;;;AAYvE,SAAgB,aACd,KACyB;AACzB,QAAO,GAAG,iBAAiB,KAAK;;;;;;;;;;AAWlC,SAAgB,gBAAgB,KAAuC;AACrE,QAAO,OAAO,KAAK,IAAI,CAAC,WAAW,KAAK,kBAAkB;;;;;AAqB5D,SAAS,mBAAmB,KAAuC;AACjE,QACE,QAAQ,QACR,OAAO,QAAQ,YACf,qBAAqB,OACrB,OAAQ,IAAyB,WAAW;;;;;AAOhD,SAAS,qBAAqB,KAI5B;CACA,IAAI;AACJ,KAAI,QAAQ,QAAQ,OAAO,QAAQ,SACjC,KAAI,WAAW,OAAO,MAAM,QAAQ,IAAI,MAAM,CAC5C,MAAK,IAAI;KAET,MAAK,CAAC,IAAI,aAAa,QAAQ,SAAS;KAG1C,MAAK,CAAC,OAAO,IAAI;AAEnB,QAAO;EACL,IAAI;EACJ,MAAM;EACN;EACD;;;;;;;;;;;;;;;AAqIH,SAAgB,eACd,OACA,0BAA2B,IAAI,SAAS,EAC/B;AACT,KAAI,UAAU,QAAQ,OAAO,UAAU,YAAY,CAAC,MAAM,QAAQ,MAAM,EAAE;AAExE,MAAI,QAAQ,IAAI,MAAM,CAEpB,QAAO,qBAAqB,MAAM;AAKpC,MAAI,mBAAmB,MAAM,CAC3B,QAAO;AAIT,UAAQ,IAAI,MAAM;EAElB,MAAM,SAAS;AAIf,MAAI,cAAc,OAAO,EAAE;AAEzB,WAAQ,OAAO,MAAM;AACrB,UAAO,aAAa,OAAO;;EAG7B,MAAM,SAAkC,EAAE;AAC1C,OAAK,MAAM,CAAC,KAAK,QAAQ,OAAO,QAAQ,OAAO,CAC7C,QAAO,OAAO,eAAe,KAAK,QAAQ;AAG5C,UAAQ,OAAO,MAAM;AACrB,SAAO;;AAGT,KAAI,MAAM,QAAQ,MAAM,CACtB,QAAO,MAAM,KAAK,SAAS,eAAe,MAAM,QAAQ,CAAC;AAG3D,QAAO;;;;;;;;;;;;;;AAeT,SAAgB,cAAc,KAAuB;AACnD,KAAI,QAAQ,QAAQ,OAAO,QAAQ,YAAY,CAAC,MAAM,QAAQ,IAAI,EAAE;EAClE,MAAM,SAAS;AACf,MAAI,gBAAgB,OAAO,CAIzB,QAAO,OAAO;EAIhB,MAAM,SAAkC,EAAE;AAC1C,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,CAC/C,QAAO,OAAO,cAAc,MAAM;AAEpC,SAAO;;AAGT,KAAI,MAAM,QAAQ,IAAI,CACpB,QAAO,IAAI,KAAK,SAAS,cAAc,KAAK,CAAC;AAG/C,QAAO"}
+{"version":3,"file":"validation.cjs","names":[],"sources":["../../src/load/validation.ts"],"sourcesContent":["/**\n * Sentinel key used to mark escaped user objects during serialization.\n *\n * When a plain object contains 'lc' key (which could be confused with LC objects),\n * we wrap it as `{\"__lc_escaped__\": {...original...}}`.\n */\nexport const LC_ESCAPED_KEY = \"__lc_escaped__\";\n\n/**\n * Check if an object needs escaping to prevent confusion with LC objects.\n *\n * An object needs escaping if:\n * 1. It has an `'lc'` key (could be confused with LC serialization format)\n * 2. It has only the escape key (would be mistaken for an escaped object)\n */\nexport function needsEscaping(obj: Record<string, unknown>): boolean {\n  return (\n    \"lc\" in obj || (Object.keys(obj).length === 1 && LC_ESCAPED_KEY in obj)\n  );\n}\n\n/**\n * Wrap an object in the escape marker.\n *\n * @example\n * ```typescript\n * {\"key\": \"value\"}  // becomes {\"__lc_escaped__\": {\"key\": \"value\"}}\n * ```\n */\nexport function escapeObject(\n  obj: Record<string, unknown>\n): Record<string, unknown> {\n  return { [LC_ESCAPED_KEY]: obj };\n}\n\n/**\n * Check if an object is an escaped user object.\n *\n * @example\n * ```typescript\n * {\"__lc_escaped__\": {...}}  // is an escaped object\n * ```\n */\nexport function isEscapedObject(obj: Record<string, unknown>): boolean {\n  return Object.keys(obj).length === 1 && LC_ESCAPED_KEY in obj;\n}\n\n/**\n * Interface for objects that can be serialized.\n * This is a duck-typed interface to avoid circular imports.\n */\ninterface SerializableLike {\n  lc_serializable: boolean;\n  lc_secrets?: Record<string, string>;\n  toJSON(): {\n    lc: number;\n    type: string;\n    id: string[];\n    kwargs?: Record<string, unknown>;\n  };\n}\n\n/**\n * Check if an object looks like a Serializable instance (duck typing).\n */\nfunction isSerializableLike(obj: unknown): obj is SerializableLike {\n  return (\n    obj !== null &&\n    typeof obj === \"object\" &&\n    \"lc_serializable\" in obj &&\n    typeof (obj as SerializableLike).toJSON === \"function\"\n  );\n}\n\n/**\n * Create a \"not_implemented\" serialization result for objects that cannot be serialized.\n */\nfunction createNotImplemented(obj: unknown): {\n  lc: 1;\n  type: \"not_implemented\";\n  id: string[];\n} {\n  let id: string[];\n  if (obj !== null && typeof obj === \"object\") {\n    if (\"lc_id\" in obj && Array.isArray(obj.lc_id)) {\n      id = obj.lc_id as string[];\n    } else {\n      id = [obj.constructor?.name ?? \"Object\"];\n    }\n  } else {\n    id = [typeof obj];\n  }\n  return {\n    lc: 1,\n    type: \"not_implemented\",\n    id,\n  };\n}\n\n/**\n * Serialize a value with escaping of user objects.\n *\n * Called recursively on kwarg values to escape any plain objects that could be\n * confused with LC objects.\n *\n * @param obj - The value to serialize.\n * @param pathSet - WeakSet to track ancestor objects in the current path to detect circular references.\n *                  Objects are removed after processing to allow shared references (same object in\n *                  multiple places) while still detecting true circular references (ancestor in descendant).\n * @returns The serialized value with user objects escaped as needed.\n */\nexport function serializeValue(\n  obj: unknown,\n  pathSet: WeakSet<object> = new WeakSet()\n): unknown {\n  if (obj !== null && typeof obj === \"object\" && !Array.isArray(obj)) {\n    // Check for circular reference - only if this object is an ancestor in the current path\n    if (pathSet.has(obj)) {\n      return createNotImplemented(obj);\n    }\n\n    if (isSerializableLike(obj)) {\n      // This is an LC object - serialize it properly (not escaped)\n      return serializeLcObject(obj, pathSet);\n    }\n\n    // Add to path before processing children\n    pathSet.add(obj);\n\n    const record = obj as Record<string, unknown>;\n    // Check if object needs escaping BEFORE recursing into values.\n    // If it needs escaping, wrap it as-is - the contents are user data that\n    // will be returned as-is during deserialization (no instantiation).\n    // This prevents re-escaping of already-escaped nested content.\n    if (needsEscaping(record)) {\n      // Remove from path before returning (to allow shared references)\n      pathSet.delete(obj);\n      return escapeObject(record);\n    }\n    // Safe object (no 'lc' key) - recurse into values\n    const result: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(record)) {\n      result[key] = serializeValue(value, pathSet);\n    }\n    // Remove from path after processing (to allow shared references in other branches)\n    pathSet.delete(obj);\n    return result;\n  }\n\n  if (Array.isArray(obj)) {\n    // Arrays don't need circular reference tracking since they're handled by object tracking\n    return obj.map((item) => serializeValue(item, pathSet));\n  }\n\n  if (\n    typeof obj === \"string\" ||\n    typeof obj === \"number\" ||\n    typeof obj === \"boolean\" ||\n    obj === null\n  ) {\n    return obj;\n  }\n\n  // Non-JSON-serializable object (Date, custom objects, etc.)\n  return createNotImplemented(obj);\n}\n\n/**\n * Serialize a `Serializable` object with escaping of user data in kwargs.\n *\n * @param obj - The `Serializable` object to serialize.\n * @param pathSet - WeakSet to track ancestor objects in the current path to detect circular references.\n *                  The Serializable object is kept in the path set to detect if it appears in its own kwargs.\n * @returns The serialized object with user data in kwargs escaped as needed.\n *\n * @remarks\n * Kwargs values are processed with `serializeValue` to escape user data (like\n * metadata) that contains `'lc'` keys. Secret fields (from `lc_secrets`) are\n * skipped because `toJSON()` replaces their values with secret markers.\n */\nexport function serializeLcObject(\n  obj: SerializableLike,\n  pathSet: WeakSet<object> = new WeakSet()\n): {\n  lc: number;\n  type: string;\n  id: string[];\n  kwargs?: Record<string, unknown>;\n} {\n  // Add object to path set to detect if it appears in its own kwargs (circular reference)\n  // Note: We intentionally don't remove this after processing because a Serializable\n  // appearing in its own kwargs is always a circular reference that should be detected.\n  pathSet.add(obj);\n\n  // Secret fields are handled by toJSON() - it replaces values with secret markers\n  const secretFields = new Set(Object.keys(obj.lc_secrets ?? {}));\n\n  const serialized = { ...obj.toJSON() };\n\n  // Process kwargs to escape user data that could be confused with LC objects\n  // Skip secret fields - toJSON() already converted them to secret markers\n  if (serialized.type === \"constructor\" && serialized.kwargs) {\n    const newKwargs: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(serialized.kwargs)) {\n      if (secretFields.has(key)) {\n        newKwargs[key] = value;\n      } else {\n        newKwargs[key] = serializeValue(value, pathSet);\n      }\n    }\n    serialized.kwargs = newKwargs;\n  }\n\n  return serialized;\n}\n\n/**\n * Escape a value if it needs escaping (contains `lc` key).\n *\n * This is a simpler version of `serializeValue` that doesn't handle Serializable\n * objects - it's meant to be called on kwargs values that have already been\n * processed by `toJSON()`.\n *\n * @param value - The value to potentially escape.\n * @param pathSet - WeakSet to track ancestor objects in the current path to detect circular references.\n *                  Objects are removed after processing to allow shared references (same object in\n *                  multiple places) while still detecting true circular references (ancestor in descendant).\n * @returns The value with any `lc`-containing objects wrapped in escape markers.\n */\nexport function escapeIfNeeded(\n  value: unknown,\n  pathSet: WeakSet<object> = new WeakSet()\n): unknown {\n  if (value !== null && typeof value === \"object\" && !Array.isArray(value)) {\n    // Check for circular reference - only if this object is an ancestor in the current path\n    if (pathSet.has(value)) {\n      // Replace circular reference with a not_implemented marker\n      return createNotImplemented(value);\n    }\n\n    // Preserve Serializable objects - they have their own toJSON() that will be\n    // called by JSON.stringify. We don't want to convert them to plain objects.\n    if (isSerializableLike(value)) {\n      return value;\n    }\n\n    // Add to path before processing children\n    pathSet.add(value);\n\n    const record = value as Record<string, unknown>;\n    // Check if object needs escaping BEFORE recursing into values.\n    // If it needs escaping, wrap it as-is - the contents are user data that\n    // will be returned as-is during deserialization (no instantiation).\n    if (needsEscaping(record)) {\n      // Remove from path before returning (to allow shared references)\n      pathSet.delete(value);\n      return escapeObject(record);\n    }\n    // Safe object (no 'lc' key) - recurse into values\n    const result: Record<string, unknown> = {};\n    for (const [key, val] of Object.entries(record)) {\n      result[key] = escapeIfNeeded(val, pathSet);\n    }\n    // Remove from path after processing (to allow shared references in other branches)\n    pathSet.delete(value);\n    return result;\n  }\n\n  if (Array.isArray(value)) {\n    return value.map((item) => escapeIfNeeded(item, pathSet));\n  }\n\n  return value;\n}\n\n/**\n * Unescape a value, processing escape markers in object values and arrays.\n *\n * When an escaped object is encountered (`{\"__lc_escaped__\": ...}`), it's\n * unwrapped and the contents are returned AS-IS (no further processing).\n * The contents represent user data that should not be modified.\n *\n * For regular objects and arrays, we recurse to find any nested escape markers.\n *\n * @param obj - The value to unescape.\n * @returns The unescaped value.\n */\nexport function unescapeValue(obj: unknown): unknown {\n  if (obj !== null && typeof obj === \"object\" && !Array.isArray(obj)) {\n    const record = obj as Record<string, unknown>;\n    if (isEscapedObject(record)) {\n      // Unwrap and return the user data as-is (no further unescaping).\n      // The contents are user data that may contain more escape keys,\n      // but those are part of the user's actual data.\n      return record[LC_ESCAPED_KEY];\n    }\n\n    // Regular object - recurse into values to find nested escape markers\n    const result: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(record)) {\n      result[key] = unescapeValue(value);\n    }\n    return result;\n  }\n\n  if (Array.isArray(obj)) {\n    return obj.map((item) => unescapeValue(item));\n  }\n\n  return obj;\n}\n"],"mappings":";;;;;;;AAMA,MAAa,iBAAiB;;;;;;;;AAS9B,SAAgB,cAAc,KAAuC;AACnE,QACE,QAAQ,OAAQ,OAAO,KAAK,IAAI,CAAC,WAAW,KAAA,oBAAuB;;;;;;;;;;AAYvE,SAAgB,aACd,KACyB;AACzB,QAAO,GAAG,iBAAiB,KAAK;;;;;;;;;;AAWlC,SAAgB,gBAAgB,KAAuC;AACrE,QAAO,OAAO,KAAK,IAAI,CAAC,WAAW,KAAA,oBAAuB;;;;;AAqB5D,SAAS,mBAAmB,KAAuC;AACjE,QACE,QAAQ,QACR,OAAO,QAAQ,YACf,qBAAqB,OACrB,OAAQ,IAAyB,WAAW;;;;;AAOhD,SAAS,qBAAqB,KAI5B;CACA,IAAI;AACJ,KAAI,QAAQ,QAAQ,OAAO,QAAQ,SACjC,KAAI,WAAW,OAAO,MAAM,QAAQ,IAAI,MAAM,CAC5C,MAAK,IAAI;KAET,MAAK,CAAC,IAAI,aAAa,QAAQ,SAAS;KAG1C,MAAK,CAAC,OAAO,IAAI;AAEnB,QAAO;EACL,IAAI;EACJ,MAAM;EACN;EACD;;;;;;;;;;;;;;;AAqIH,SAAgB,eACd,OACA,0BAA2B,IAAI,SAAS,EAC/B;AACT,KAAI,UAAU,QAAQ,OAAO,UAAU,YAAY,CAAC,MAAM,QAAQ,MAAM,EAAE;AAExE,MAAI,QAAQ,IAAI,MAAM,CAEpB,QAAO,qBAAqB,MAAM;AAKpC,MAAI,mBAAmB,MAAM,CAC3B,QAAO;AAIT,UAAQ,IAAI,MAAM;EAElB,MAAM,SAAS;AAIf,MAAI,cAAc,OAAO,EAAE;AAEzB,WAAQ,OAAO,MAAM;AACrB,UAAO,aAAa,OAAO;;EAG7B,MAAM,SAAkC,EAAE;AAC1C,OAAK,MAAM,CAAC,KAAK,QAAQ,OAAO,QAAQ,OAAO,CAC7C,QAAO,OAAO,eAAe,KAAK,QAAQ;AAG5C,UAAQ,OAAO,MAAM;AACrB,SAAO;;AAGT,KAAI,MAAM,QAAQ,MAAM,CACtB,QAAO,MAAM,KAAK,SAAS,eAAe,MAAM,QAAQ,CAAC;AAG3D,QAAO;;;;;;;;;;;;;;AAeT,SAAgB,cAAc,KAAuB;AACnD,KAAI,QAAQ,QAAQ,OAAO,QAAQ,YAAY,CAAC,MAAM,QAAQ,IAAI,EAAE;EAClE,MAAM,SAAS;AACf,MAAI,gBAAgB,OAAO,CAIzB,QAAO,OAAO;EAIhB,MAAM,SAAkC,EAAE;AAC1C,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,CAC/C,QAAO,OAAO,cAAc,MAAM;AAEpC,SAAO;;AAGT,KAAI,MAAM,QAAQ,IAAI,CACpB,QAAO,IAAI,KAAK,SAAS,cAAc,KAAK,CAAC;AAG/C,QAAO"}

package/dist/load/validation.js

@@ -14,7 +14,7 @@ const LC_ESCAPED_KEY = "__lc_escaped__";
 * 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;
+	return "lc" in obj || Object.keys(obj).length === 1 && "__lc_escaped__" in obj;
 }
 /**
 * Wrap an object in the escape marker.
@@ -36,7 +36,7 @@ function escapeObject(obj) {
 * ```
 */
 function isEscapedObject(obj) {
-	return Object.keys(obj).length === 1 && LC_ESCAPED_KEY in obj;
+	return Object.keys(obj).length === 1 && "__lc_escaped__" in obj;
 }
 /**
 * Check if an object looks like a Serializable instance (duck typing).
@@ -112,7 +112,7 @@ function unescapeValue(obj) {
 	if (Array.isArray(obj)) return obj.map((item) => unescapeValue(item));
 	return obj;
 }
-
 //#endregion
 export { escapeIfNeeded, isEscapedObject, unescapeValue };
+
 //# sourceMappingURL=validation.js.map

package/dist/load/validation.js.map

@@ -1 +1 @@
-{"version":3,"file":"validation.js","names":[],"sources":["../../src/load/validation.ts"],"sourcesContent":["/**\n * Sentinel key used to mark escaped user objects during serialization.\n *\n * When a plain object contains 'lc' key (which could be confused with LC objects),\n * we wrap it as `{\"__lc_escaped__\": {...original...}}`.\n */\nexport const LC_ESCAPED_KEY = \"__lc_escaped__\";\n\n/**\n * Check if an object needs escaping to prevent confusion with LC objects.\n *\n * An object needs escaping if:\n * 1. It has an `'lc'` key (could be confused with LC serialization format)\n * 2. It has only the escape key (would be mistaken for an escaped object)\n */\nexport function needsEscaping(obj: Record<string, unknown>): boolean {\n  return (\n    \"lc\" in obj || (Object.keys(obj).length === 1 && LC_ESCAPED_KEY in obj)\n  );\n}\n\n/**\n * Wrap an object in the escape marker.\n *\n * @example\n * ```typescript\n * {\"key\": \"value\"}  // becomes {\"__lc_escaped__\": {\"key\": \"value\"}}\n * ```\n */\nexport function escapeObject(\n  obj: Record<string, unknown>\n): Record<string, unknown> {\n  return { [LC_ESCAPED_KEY]: obj };\n}\n\n/**\n * Check if an object is an escaped user object.\n *\n * @example\n * ```typescript\n * {\"__lc_escaped__\": {...}}  // is an escaped object\n * ```\n */\nexport function isEscapedObject(obj: Record<string, unknown>): boolean {\n  return Object.keys(obj).length === 1 && LC_ESCAPED_KEY in obj;\n}\n\n/**\n * Interface for objects that can be serialized.\n * This is a duck-typed interface to avoid circular imports.\n */\ninterface SerializableLike {\n  lc_serializable: boolean;\n  lc_secrets?: Record<string, string>;\n  toJSON(): {\n    lc: number;\n    type: string;\n    id: string[];\n    kwargs?: Record<string, unknown>;\n  };\n}\n\n/**\n * Check if an object looks like a Serializable instance (duck typing).\n */\nfunction isSerializableLike(obj: unknown): obj is SerializableLike {\n  return (\n    obj !== null &&\n    typeof obj === \"object\" &&\n    \"lc_serializable\" in obj &&\n    typeof (obj as SerializableLike).toJSON === \"function\"\n  );\n}\n\n/**\n * Create a \"not_implemented\" serialization result for objects that cannot be serialized.\n */\nfunction createNotImplemented(obj: unknown): {\n  lc: 1;\n  type: \"not_implemented\";\n  id: string[];\n} {\n  let id: string[];\n  if (obj !== null && typeof obj === \"object\") {\n    if (\"lc_id\" in obj && Array.isArray(obj.lc_id)) {\n      id = obj.lc_id as string[];\n    } else {\n      id = [obj.constructor?.name ?? \"Object\"];\n    }\n  } else {\n    id = [typeof obj];\n  }\n  return {\n    lc: 1,\n    type: \"not_implemented\",\n    id,\n  };\n}\n\n/**\n * Serialize a value with escaping of user objects.\n *\n * Called recursively on kwarg values to escape any plain objects that could be\n * confused with LC objects.\n *\n * @param obj - The value to serialize.\n * @param pathSet - WeakSet to track ancestor objects in the current path to detect circular references.\n *                  Objects are removed after processing to allow shared references (same object in\n *                  multiple places) while still detecting true circular references (ancestor in descendant).\n * @returns The serialized value with user objects escaped as needed.\n */\nexport function serializeValue(\n  obj: unknown,\n  pathSet: WeakSet<object> = new WeakSet()\n): unknown {\n  if (obj !== null && typeof obj === \"object\" && !Array.isArray(obj)) {\n    // Check for circular reference - only if this object is an ancestor in the current path\n    if (pathSet.has(obj)) {\n      return createNotImplemented(obj);\n    }\n\n    if (isSerializableLike(obj)) {\n      // This is an LC object - serialize it properly (not escaped)\n      return serializeLcObject(obj, pathSet);\n    }\n\n    // Add to path before processing children\n    pathSet.add(obj);\n\n    const record = obj as Record<string, unknown>;\n    // Check if object needs escaping BEFORE recursing into values.\n    // If it needs escaping, wrap it as-is - the contents are user data that\n    // will be returned as-is during deserialization (no instantiation).\n    // This prevents re-escaping of already-escaped nested content.\n    if (needsEscaping(record)) {\n      // Remove from path before returning (to allow shared references)\n      pathSet.delete(obj);\n      return escapeObject(record);\n    }\n    // Safe object (no 'lc' key) - recurse into values\n    const result: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(record)) {\n      result[key] = serializeValue(value, pathSet);\n    }\n    // Remove from path after processing (to allow shared references in other branches)\n    pathSet.delete(obj);\n    return result;\n  }\n\n  if (Array.isArray(obj)) {\n    // Arrays don't need circular reference tracking since they're handled by object tracking\n    return obj.map((item) => serializeValue(item, pathSet));\n  }\n\n  if (\n    typeof obj === \"string\" ||\n    typeof obj === \"number\" ||\n    typeof obj === \"boolean\" ||\n    obj === null\n  ) {\n    return obj;\n  }\n\n  // Non-JSON-serializable object (Date, custom objects, etc.)\n  return createNotImplemented(obj);\n}\n\n/**\n * Serialize a `Serializable` object with escaping of user data in kwargs.\n *\n * @param obj - The `Serializable` object to serialize.\n * @param pathSet - WeakSet to track ancestor objects in the current path to detect circular references.\n *                  The Serializable object is kept in the path set to detect if it appears in its own kwargs.\n * @returns The serialized object with user data in kwargs escaped as needed.\n *\n * @remarks\n * Kwargs values are processed with `serializeValue` to escape user data (like\n * metadata) that contains `'lc'` keys. Secret fields (from `lc_secrets`) are\n * skipped because `toJSON()` replaces their values with secret markers.\n */\nexport function serializeLcObject(\n  obj: SerializableLike,\n  pathSet: WeakSet<object> = new WeakSet()\n): {\n  lc: number;\n  type: string;\n  id: string[];\n  kwargs?: Record<string, unknown>;\n} {\n  // Add object to path set to detect if it appears in its own kwargs (circular reference)\n  // Note: We intentionally don't remove this after processing because a Serializable\n  // appearing in its own kwargs is always a circular reference that should be detected.\n  pathSet.add(obj);\n\n  // Secret fields are handled by toJSON() - it replaces values with secret markers\n  const secretFields = new Set(Object.keys(obj.lc_secrets ?? {}));\n\n  const serialized = { ...obj.toJSON() };\n\n  // Process kwargs to escape user data that could be confused with LC objects\n  // Skip secret fields - toJSON() already converted them to secret markers\n  if (serialized.type === \"constructor\" && serialized.kwargs) {\n    const newKwargs: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(serialized.kwargs)) {\n      if (secretFields.has(key)) {\n        newKwargs[key] = value;\n      } else {\n        newKwargs[key] = serializeValue(value, pathSet);\n      }\n    }\n    serialized.kwargs = newKwargs;\n  }\n\n  return serialized;\n}\n\n/**\n * Escape a value if it needs escaping (contains `lc` key).\n *\n * This is a simpler version of `serializeValue` that doesn't handle Serializable\n * objects - it's meant to be called on kwargs values that have already been\n * processed by `toJSON()`.\n *\n * @param value - The value to potentially escape.\n * @param pathSet - WeakSet to track ancestor objects in the current path to detect circular references.\n *                  Objects are removed after processing to allow shared references (same object in\n *                  multiple places) while still detecting true circular references (ancestor in descendant).\n * @returns The value with any `lc`-containing objects wrapped in escape markers.\n */\nexport function escapeIfNeeded(\n  value: unknown,\n  pathSet: WeakSet<object> = new WeakSet()\n): unknown {\n  if (value !== null && typeof value === \"object\" && !Array.isArray(value)) {\n    // Check for circular reference - only if this object is an ancestor in the current path\n    if (pathSet.has(value)) {\n      // Replace circular reference with a not_implemented marker\n      return createNotImplemented(value);\n    }\n\n    // Preserve Serializable objects - they have their own toJSON() that will be\n    // called by JSON.stringify. We don't want to convert them to plain objects.\n    if (isSerializableLike(value)) {\n      return value;\n    }\n\n    // Add to path before processing children\n    pathSet.add(value);\n\n    const record = value as Record<string, unknown>;\n    // Check if object needs escaping BEFORE recursing into values.\n    // If it needs escaping, wrap it as-is - the contents are user data that\n    // will be returned as-is during deserialization (no instantiation).\n    if (needsEscaping(record)) {\n      // Remove from path before returning (to allow shared references)\n      pathSet.delete(value);\n      return escapeObject(record);\n    }\n    // Safe object (no 'lc' key) - recurse into values\n    const result: Record<string, unknown> = {};\n    for (const [key, val] of Object.entries(record)) {\n      result[key] = escapeIfNeeded(val, pathSet);\n    }\n    // Remove from path after processing (to allow shared references in other branches)\n    pathSet.delete(value);\n    return result;\n  }\n\n  if (Array.isArray(value)) {\n    return value.map((item) => escapeIfNeeded(item, pathSet));\n  }\n\n  return value;\n}\n\n/**\n * Unescape a value, processing escape markers in object values and arrays.\n *\n * When an escaped object is encountered (`{\"__lc_escaped__\": ...}`), it's\n * unwrapped and the contents are returned AS-IS (no further processing).\n * The contents represent user data that should not be modified.\n *\n * For regular objects and arrays, we recurse to find any nested escape markers.\n *\n * @param obj - The value to unescape.\n * @returns The unescaped value.\n */\nexport function unescapeValue(obj: unknown): unknown {\n  if (obj !== null && typeof obj === \"object\" && !Array.isArray(obj)) {\n    const record = obj as Record<string, unknown>;\n    if (isEscapedObject(record)) {\n      // Unwrap and return the user data as-is (no further unescaping).\n      // The contents are user data that may contain more escape keys,\n      // but those are part of the user's actual data.\n      return record[LC_ESCAPED_KEY];\n    }\n\n    // Regular object - recurse into values to find nested escape markers\n    const result: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(record)) {\n      result[key] = unescapeValue(value);\n    }\n    return result;\n  }\n\n  if (Array.isArray(obj)) {\n    return obj.map((item) => unescapeValue(item));\n  }\n\n  return obj;\n}\n"],"mappings":";;;;;;;AAMA,MAAa,iBAAiB;;;;;;;;AAS9B,SAAgB,cAAc,KAAuC;AACnE,QACE,QAAQ,OAAQ,OAAO,KAAK,IAAI,CAAC,WAAW,KAAK,kBAAkB;;;;;;;;;;AAYvE,SAAgB,aACd,KACyB;AACzB,QAAO,GAAG,iBAAiB,KAAK;;;;;;;;;;AAWlC,SAAgB,gBAAgB,KAAuC;AACrE,QAAO,OAAO,KAAK,IAAI,CAAC,WAAW,KAAK,kBAAkB;;;;;AAqB5D,SAAS,mBAAmB,KAAuC;AACjE,QACE,QAAQ,QACR,OAAO,QAAQ,YACf,qBAAqB,OACrB,OAAQ,IAAyB,WAAW;;;;;AAOhD,SAAS,qBAAqB,KAI5B;CACA,IAAI;AACJ,KAAI,QAAQ,QAAQ,OAAO,QAAQ,SACjC,KAAI,WAAW,OAAO,MAAM,QAAQ,IAAI,MAAM,CAC5C,MAAK,IAAI;KAET,MAAK,CAAC,IAAI,aAAa,QAAQ,SAAS;KAG1C,MAAK,CAAC,OAAO,IAAI;AAEnB,QAAO;EACL,IAAI;EACJ,MAAM;EACN;EACD;;;;;;;;;;;;;;;AAqIH,SAAgB,eACd,OACA,0BAA2B,IAAI,SAAS,EAC/B;AACT,KAAI,UAAU,QAAQ,OAAO,UAAU,YAAY,CAAC,MAAM,QAAQ,MAAM,EAAE;AAExE,MAAI,QAAQ,IAAI,MAAM,CAEpB,QAAO,qBAAqB,MAAM;AAKpC,MAAI,mBAAmB,MAAM,CAC3B,QAAO;AAIT,UAAQ,IAAI,MAAM;EAElB,MAAM,SAAS;AAIf,MAAI,cAAc,OAAO,EAAE;AAEzB,WAAQ,OAAO,MAAM;AACrB,UAAO,aAAa,OAAO;;EAG7B,MAAM,SAAkC,EAAE;AAC1C,OAAK,MAAM,CAAC,KAAK,QAAQ,OAAO,QAAQ,OAAO,CAC7C,QAAO,OAAO,eAAe,KAAK,QAAQ;AAG5C,UAAQ,OAAO,MAAM;AACrB,SAAO;;AAGT,KAAI,MAAM,QAAQ,MAAM,CACtB,QAAO,MAAM,KAAK,SAAS,eAAe,MAAM,QAAQ,CAAC;AAG3D,QAAO;;;;;;;;;;;;;;AAeT,SAAgB,cAAc,KAAuB;AACnD,KAAI,QAAQ,QAAQ,OAAO,QAAQ,YAAY,CAAC,MAAM,QAAQ,IAAI,EAAE;EAClE,MAAM,SAAS;AACf,MAAI,gBAAgB,OAAO,CAIzB,QAAO,OAAO;EAIhB,MAAM,SAAkC,EAAE;AAC1C,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,CAC/C,QAAO,OAAO,cAAc,MAAM;AAEpC,SAAO;;AAGT,KAAI,MAAM,QAAQ,IAAI,CACpB,QAAO,IAAI,KAAK,SAAS,cAAc,KAAK,CAAC;AAG/C,QAAO"}
+{"version":3,"file":"validation.js","names":[],"sources":["../../src/load/validation.ts"],"sourcesContent":["/**\n * Sentinel key used to mark escaped user objects during serialization.\n *\n * When a plain object contains 'lc' key (which could be confused with LC objects),\n * we wrap it as `{\"__lc_escaped__\": {...original...}}`.\n */\nexport const LC_ESCAPED_KEY = \"__lc_escaped__\";\n\n/**\n * Check if an object needs escaping to prevent confusion with LC objects.\n *\n * An object needs escaping if:\n * 1. It has an `'lc'` key (could be confused with LC serialization format)\n * 2. It has only the escape key (would be mistaken for an escaped object)\n */\nexport function needsEscaping(obj: Record<string, unknown>): boolean {\n  return (\n    \"lc\" in obj || (Object.keys(obj).length === 1 && LC_ESCAPED_KEY in obj)\n  );\n}\n\n/**\n * Wrap an object in the escape marker.\n *\n * @example\n * ```typescript\n * {\"key\": \"value\"}  // becomes {\"__lc_escaped__\": {\"key\": \"value\"}}\n * ```\n */\nexport function escapeObject(\n  obj: Record<string, unknown>\n): Record<string, unknown> {\n  return { [LC_ESCAPED_KEY]: obj };\n}\n\n/**\n * Check if an object is an escaped user object.\n *\n * @example\n * ```typescript\n * {\"__lc_escaped__\": {...}}  // is an escaped object\n * ```\n */\nexport function isEscapedObject(obj: Record<string, unknown>): boolean {\n  return Object.keys(obj).length === 1 && LC_ESCAPED_KEY in obj;\n}\n\n/**\n * Interface for objects that can be serialized.\n * This is a duck-typed interface to avoid circular imports.\n */\ninterface SerializableLike {\n  lc_serializable: boolean;\n  lc_secrets?: Record<string, string>;\n  toJSON(): {\n    lc: number;\n    type: string;\n    id: string[];\n    kwargs?: Record<string, unknown>;\n  };\n}\n\n/**\n * Check if an object looks like a Serializable instance (duck typing).\n */\nfunction isSerializableLike(obj: unknown): obj is SerializableLike {\n  return (\n    obj !== null &&\n    typeof obj === \"object\" &&\n    \"lc_serializable\" in obj &&\n    typeof (obj as SerializableLike).toJSON === \"function\"\n  );\n}\n\n/**\n * Create a \"not_implemented\" serialization result for objects that cannot be serialized.\n */\nfunction createNotImplemented(obj: unknown): {\n  lc: 1;\n  type: \"not_implemented\";\n  id: string[];\n} {\n  let id: string[];\n  if (obj !== null && typeof obj === \"object\") {\n    if (\"lc_id\" in obj && Array.isArray(obj.lc_id)) {\n      id = obj.lc_id as string[];\n    } else {\n      id = [obj.constructor?.name ?? \"Object\"];\n    }\n  } else {\n    id = [typeof obj];\n  }\n  return {\n    lc: 1,\n    type: \"not_implemented\",\n    id,\n  };\n}\n\n/**\n * Serialize a value with escaping of user objects.\n *\n * Called recursively on kwarg values to escape any plain objects that could be\n * confused with LC objects.\n *\n * @param obj - The value to serialize.\n * @param pathSet - WeakSet to track ancestor objects in the current path to detect circular references.\n *                  Objects are removed after processing to allow shared references (same object in\n *                  multiple places) while still detecting true circular references (ancestor in descendant).\n * @returns The serialized value with user objects escaped as needed.\n */\nexport function serializeValue(\n  obj: unknown,\n  pathSet: WeakSet<object> = new WeakSet()\n): unknown {\n  if (obj !== null && typeof obj === \"object\" && !Array.isArray(obj)) {\n    // Check for circular reference - only if this object is an ancestor in the current path\n    if (pathSet.has(obj)) {\n      return createNotImplemented(obj);\n    }\n\n    if (isSerializableLike(obj)) {\n      // This is an LC object - serialize it properly (not escaped)\n      return serializeLcObject(obj, pathSet);\n    }\n\n    // Add to path before processing children\n    pathSet.add(obj);\n\n    const record = obj as Record<string, unknown>;\n    // Check if object needs escaping BEFORE recursing into values.\n    // If it needs escaping, wrap it as-is - the contents are user data that\n    // will be returned as-is during deserialization (no instantiation).\n    // This prevents re-escaping of already-escaped nested content.\n    if (needsEscaping(record)) {\n      // Remove from path before returning (to allow shared references)\n      pathSet.delete(obj);\n      return escapeObject(record);\n    }\n    // Safe object (no 'lc' key) - recurse into values\n    const result: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(record)) {\n      result[key] = serializeValue(value, pathSet);\n    }\n    // Remove from path after processing (to allow shared references in other branches)\n    pathSet.delete(obj);\n    return result;\n  }\n\n  if (Array.isArray(obj)) {\n    // Arrays don't need circular reference tracking since they're handled by object tracking\n    return obj.map((item) => serializeValue(item, pathSet));\n  }\n\n  if (\n    typeof obj === \"string\" ||\n    typeof obj === \"number\" ||\n    typeof obj === \"boolean\" ||\n    obj === null\n  ) {\n    return obj;\n  }\n\n  // Non-JSON-serializable object (Date, custom objects, etc.)\n  return createNotImplemented(obj);\n}\n\n/**\n * Serialize a `Serializable` object with escaping of user data in kwargs.\n *\n * @param obj - The `Serializable` object to serialize.\n * @param pathSet - WeakSet to track ancestor objects in the current path to detect circular references.\n *                  The Serializable object is kept in the path set to detect if it appears in its own kwargs.\n * @returns The serialized object with user data in kwargs escaped as needed.\n *\n * @remarks\n * Kwargs values are processed with `serializeValue` to escape user data (like\n * metadata) that contains `'lc'` keys. Secret fields (from `lc_secrets`) are\n * skipped because `toJSON()` replaces their values with secret markers.\n */\nexport function serializeLcObject(\n  obj: SerializableLike,\n  pathSet: WeakSet<object> = new WeakSet()\n): {\n  lc: number;\n  type: string;\n  id: string[];\n  kwargs?: Record<string, unknown>;\n} {\n  // Add object to path set to detect if it appears in its own kwargs (circular reference)\n  // Note: We intentionally don't remove this after processing because a Serializable\n  // appearing in its own kwargs is always a circular reference that should be detected.\n  pathSet.add(obj);\n\n  // Secret fields are handled by toJSON() - it replaces values with secret markers\n  const secretFields = new Set(Object.keys(obj.lc_secrets ?? {}));\n\n  const serialized = { ...obj.toJSON() };\n\n  // Process kwargs to escape user data that could be confused with LC objects\n  // Skip secret fields - toJSON() already converted them to secret markers\n  if (serialized.type === \"constructor\" && serialized.kwargs) {\n    const newKwargs: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(serialized.kwargs)) {\n      if (secretFields.has(key)) {\n        newKwargs[key] = value;\n      } else {\n        newKwargs[key] = serializeValue(value, pathSet);\n      }\n    }\n    serialized.kwargs = newKwargs;\n  }\n\n  return serialized;\n}\n\n/**\n * Escape a value if it needs escaping (contains `lc` key).\n *\n * This is a simpler version of `serializeValue` that doesn't handle Serializable\n * objects - it's meant to be called on kwargs values that have already been\n * processed by `toJSON()`.\n *\n * @param value - The value to potentially escape.\n * @param pathSet - WeakSet to track ancestor objects in the current path to detect circular references.\n *                  Objects are removed after processing to allow shared references (same object in\n *                  multiple places) while still detecting true circular references (ancestor in descendant).\n * @returns The value with any `lc`-containing objects wrapped in escape markers.\n */\nexport function escapeIfNeeded(\n  value: unknown,\n  pathSet: WeakSet<object> = new WeakSet()\n): unknown {\n  if (value !== null && typeof value === \"object\" && !Array.isArray(value)) {\n    // Check for circular reference - only if this object is an ancestor in the current path\n    if (pathSet.has(value)) {\n      // Replace circular reference with a not_implemented marker\n      return createNotImplemented(value);\n    }\n\n    // Preserve Serializable objects - they have their own toJSON() that will be\n    // called by JSON.stringify. We don't want to convert them to plain objects.\n    if (isSerializableLike(value)) {\n      return value;\n    }\n\n    // Add to path before processing children\n    pathSet.add(value);\n\n    const record = value as Record<string, unknown>;\n    // Check if object needs escaping BEFORE recursing into values.\n    // If it needs escaping, wrap it as-is - the contents are user data that\n    // will be returned as-is during deserialization (no instantiation).\n    if (needsEscaping(record)) {\n      // Remove from path before returning (to allow shared references)\n      pathSet.delete(value);\n      return escapeObject(record);\n    }\n    // Safe object (no 'lc' key) - recurse into values\n    const result: Record<string, unknown> = {};\n    for (const [key, val] of Object.entries(record)) {\n      result[key] = escapeIfNeeded(val, pathSet);\n    }\n    // Remove from path after processing (to allow shared references in other branches)\n    pathSet.delete(value);\n    return result;\n  }\n\n  if (Array.isArray(value)) {\n    return value.map((item) => escapeIfNeeded(item, pathSet));\n  }\n\n  return value;\n}\n\n/**\n * Unescape a value, processing escape markers in object values and arrays.\n *\n * When an escaped object is encountered (`{\"__lc_escaped__\": ...}`), it's\n * unwrapped and the contents are returned AS-IS (no further processing).\n * The contents represent user data that should not be modified.\n *\n * For regular objects and arrays, we recurse to find any nested escape markers.\n *\n * @param obj - The value to unescape.\n * @returns The unescaped value.\n */\nexport function unescapeValue(obj: unknown): unknown {\n  if (obj !== null && typeof obj === \"object\" && !Array.isArray(obj)) {\n    const record = obj as Record<string, unknown>;\n    if (isEscapedObject(record)) {\n      // Unwrap and return the user data as-is (no further unescaping).\n      // The contents are user data that may contain more escape keys,\n      // but those are part of the user's actual data.\n      return record[LC_ESCAPED_KEY];\n    }\n\n    // Regular object - recurse into values to find nested escape markers\n    const result: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(record)) {\n      result[key] = unescapeValue(value);\n    }\n    return result;\n  }\n\n  if (Array.isArray(obj)) {\n    return obj.map((item) => unescapeValue(item));\n  }\n\n  return obj;\n}\n"],"mappings":";;;;;;;AAMA,MAAa,iBAAiB;;;;;;;;AAS9B,SAAgB,cAAc,KAAuC;AACnE,QACE,QAAQ,OAAQ,OAAO,KAAK,IAAI,CAAC,WAAW,KAAA,oBAAuB;;;;;;;;;;AAYvE,SAAgB,aACd,KACyB;AACzB,QAAO,GAAG,iBAAiB,KAAK;;;;;;;;;;AAWlC,SAAgB,gBAAgB,KAAuC;AACrE,QAAO,OAAO,KAAK,IAAI,CAAC,WAAW,KAAA,oBAAuB;;;;;AAqB5D,SAAS,mBAAmB,KAAuC;AACjE,QACE,QAAQ,QACR,OAAO,QAAQ,YACf,qBAAqB,OACrB,OAAQ,IAAyB,WAAW;;;;;AAOhD,SAAS,qBAAqB,KAI5B;CACA,IAAI;AACJ,KAAI,QAAQ,QAAQ,OAAO,QAAQ,SACjC,KAAI,WAAW,OAAO,MAAM,QAAQ,IAAI,MAAM,CAC5C,MAAK,IAAI;KAET,MAAK,CAAC,IAAI,aAAa,QAAQ,SAAS;KAG1C,MAAK,CAAC,OAAO,IAAI;AAEnB,QAAO;EACL,IAAI;EACJ,MAAM;EACN;EACD;;;;;;;;;;;;;;;AAqIH,SAAgB,eACd,OACA,0BAA2B,IAAI,SAAS,EAC/B;AACT,KAAI,UAAU,QAAQ,OAAO,UAAU,YAAY,CAAC,MAAM,QAAQ,MAAM,EAAE;AAExE,MAAI,QAAQ,IAAI,MAAM,CAEpB,QAAO,qBAAqB,MAAM;AAKpC,MAAI,mBAAmB,MAAM,CAC3B,QAAO;AAIT,UAAQ,IAAI,MAAM;EAElB,MAAM,SAAS;AAIf,MAAI,cAAc,OAAO,EAAE;AAEzB,WAAQ,OAAO,MAAM;AACrB,UAAO,aAAa,OAAO;;EAG7B,MAAM,SAAkC,EAAE;AAC1C,OAAK,MAAM,CAAC,KAAK,QAAQ,OAAO,QAAQ,OAAO,CAC7C,QAAO,OAAO,eAAe,KAAK,QAAQ;AAG5C,UAAQ,OAAO,MAAM;AACrB,SAAO;;AAGT,KAAI,MAAM,QAAQ,MAAM,CACtB,QAAO,MAAM,KAAK,SAAS,eAAe,MAAM,QAAQ,CAAC;AAG3D,QAAO;;;;;;;;;;;;;;AAeT,SAAgB,cAAc,KAAuB;AACnD,KAAI,QAAQ,QAAQ,OAAO,QAAQ,YAAY,CAAC,MAAM,QAAQ,IAAI,EAAE;EAClE,MAAM,SAAS;AACf,MAAI,gBAAgB,OAAO,CAIzB,QAAO,OAAO;EAIhB,MAAM,SAAkC,EAAE;AAC1C,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,CAC/C,QAAO,OAAO,cAAc,MAAM;AAEpC,SAAO;;AAGT,KAAI,MAAM,QAAQ,IAAI,CACpB,QAAO,IAAI,KAAK,SAAS,cAAc,KAAK,CAAC;AAG/C,QAAO"}

package/dist/memory.cjs

@@ -1,8 +1,6 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/memory.ts
-var memory_exports = /* @__PURE__ */ require_runtime.__exportAll({
+var memory_exports = /* @__PURE__ */ require("./_virtual/_rolldown/runtime.cjs").__exportAll({
 	BaseMemory: () => BaseMemory,
 	getInputValue: () => getInputValue,
 	getOutputValue: () => getOutputValue,
@@ -57,16 +55,16 @@ function getPromptInputKey(inputs, memoryVariables) {
 	if (promptInputKeys.length !== 1) throw new Error(`One input key expected, but got ${promptInputKeys.length}`);
 	return promptInputKeys[0];
 }
-
 //#endregion
 exports.BaseMemory = BaseMemory;
 exports.getInputValue = getInputValue;
 exports.getOutputValue = getOutputValue;
 exports.getPromptInputKey = getPromptInputKey;
-Object.defineProperty(exports, 'memory_exports', {
-  enumerable: true,
-  get: function () {
-    return memory_exports;
-  }
+Object.defineProperty(exports, "memory_exports", {
+	enumerable: true,
+	get: function() {
+		return memory_exports;
+	}
 });
+
 //# sourceMappingURL=memory.cjs.map

package/dist/memory.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"memory.cjs","names":[],"sources":["../src/memory.ts"],"sourcesContent":["/**\n * Type alias for a record where the keys are strings and the values can\n * be any type. This is used to represent the input values for a Chain.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type InputValues = Record<string, any>;\n\n/**\n * Type alias for a record where the keys are strings and the values can\n * be any type. This is used to represent the output values from a Chain.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type OutputValues = Record<string, any>;\n\n/**\n * Type alias for a record where the keys are strings and the values can\n * be any type. This is used to represent the memory variables in a Chain.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type MemoryVariables = Record<string, any>;\n\n/**\n * Abstract base class for memory in LangChain's Chains. Memory refers to\n * the state in Chains. It can be used to store information about past\n * executions of a Chain and inject that information into the inputs of\n * future executions of the Chain.\n */\nexport abstract class BaseMemory {\n  abstract get memoryKeys(): string[];\n\n  /**\n   * Abstract method that should take an object of input values and return a\n   * Promise that resolves with an object of memory variables. The\n   * implementation of this method should load the memory variables from the\n   * provided input values.\n   * @param values An object of input values.\n   * @returns Promise that resolves with an object of memory variables.\n   */\n  abstract loadMemoryVariables(values: InputValues): Promise<MemoryVariables>;\n\n  /**\n   * Abstract method that should take two objects, one of input values and\n   * one of output values, and return a Promise that resolves when the\n   * context has been saved. The implementation of this method should save\n   * the context based on the provided input and output values.\n   * @param inputValues An object of input values.\n   * @param outputValues An object of output values.\n   * @returns Promise that resolves when the context has been saved.\n   */\n  abstract saveContext(\n    inputValues: InputValues,\n    outputValues: OutputValues\n  ): Promise<void>;\n}\n\nconst getValue = (values: InputValues | OutputValues, key?: string) => {\n  if (key !== undefined) {\n    return values[key];\n  }\n  const keys = Object.keys(values);\n  if (keys.length === 1) {\n    return values[keys[0]];\n  }\n};\n\n/**\n * This function is used by memory classes to select the input value\n * to use for the memory. If there is only one input value, it is used.\n * If there are multiple input values, the inputKey must be specified.\n */\nexport const getInputValue = (inputValues: InputValues, inputKey?: string) => {\n  const value = getValue(inputValues, inputKey);\n  if (!value) {\n    const keys = Object.keys(inputValues);\n    throw new Error(\n      `input values have ${keys.length} keys, you must specify an input key or pass only 1 key as input`\n    );\n  }\n  return value;\n};\n\n/**\n * This function is used by memory classes to select the output value\n * to use for the memory. If there is only one output value, it is used.\n * If there are multiple output values, the outputKey must be specified.\n * If no outputKey is specified, an error is thrown.\n */\nexport const getOutputValue = (\n  outputValues: OutputValues,\n  outputKey?: string\n) => {\n  const value = getValue(outputValues, outputKey);\n  if (!value && value !== \"\") {\n    const keys = Object.keys(outputValues);\n    throw new Error(\n      `output values have ${keys.length} keys, you must specify an output key or pass only 1 key as output`\n    );\n  }\n  return value;\n};\n\n/**\n * Function used by memory classes to get the key of the prompt input,\n * excluding any keys that are memory variables or the \"stop\" key. If\n * there is not exactly one prompt input key, an error is thrown.\n */\nexport function getPromptInputKey(\n  inputs: Record<string, unknown>,\n  memoryVariables: string[]\n): string {\n  const promptInputKeys = Object.keys(inputs).filter(\n    (key) => !memoryVariables.includes(key) && key !== \"stop\"\n  );\n  if (promptInputKeys.length !== 1) {\n    throw new Error(\n      `One input key expected, but got ${promptInputKeys.length}`\n    );\n  }\n  return promptInputKeys[0];\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA2BA,IAAsB,aAAtB,MAAiC;AA4BjC,MAAM,YAAY,QAAoC,QAAiB;AACrE,KAAI,QAAQ,OACV,QAAO,OAAO;CAEhB,MAAM,OAAO,OAAO,KAAK,OAAO;AAChC,KAAI,KAAK,WAAW,EAClB,QAAO,OAAO,KAAK;;;;;;;AASvB,MAAa,iBAAiB,aAA0B,aAAsB;CAC5E,MAAM,QAAQ,SAAS,aAAa,SAAS;AAC7C,KAAI,CAAC,OAAO;EACV,MAAM,OAAO,OAAO,KAAK,YAAY;AACrC,QAAM,IAAI,MACR,qBAAqB,KAAK,OAAO,kEAClC;;AAEH,QAAO;;;;;;;;AAST,MAAa,kBACX,cACA,cACG;CACH,MAAM,QAAQ,SAAS,cAAc,UAAU;AAC/C,KAAI,CAAC,SAAS,UAAU,IAAI;EAC1B,MAAM,OAAO,OAAO,KAAK,aAAa;AACtC,QAAM,IAAI,MACR,sBAAsB,KAAK,OAAO,oEACnC;;AAEH,QAAO;;;;;;;AAQT,SAAgB,kBACd,QACA,iBACQ;CACR,MAAM,kBAAkB,OAAO,KAAK,OAAO,CAAC,QACzC,QAAQ,CAAC,gBAAgB,SAAS,IAAI,IAAI,QAAQ,OACpD;AACD,KAAI,gBAAgB,WAAW,EAC7B,OAAM,IAAI,MACR,mCAAmC,gBAAgB,SACpD;AAEH,QAAO,gBAAgB"}
+{"version":3,"file":"memory.cjs","names":[],"sources":["../src/memory.ts"],"sourcesContent":["/**\n * Type alias for a record where the keys are strings and the values can\n * be any type. This is used to represent the input values for a Chain.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type InputValues = Record<string, any>;\n\n/**\n * Type alias for a record where the keys are strings and the values can\n * be any type. This is used to represent the output values from a Chain.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type OutputValues = Record<string, any>;\n\n/**\n * Type alias for a record where the keys are strings and the values can\n * be any type. This is used to represent the memory variables in a Chain.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type MemoryVariables = Record<string, any>;\n\n/**\n * Abstract base class for memory in LangChain's Chains. Memory refers to\n * the state in Chains. It can be used to store information about past\n * executions of a Chain and inject that information into the inputs of\n * future executions of the Chain.\n */\nexport abstract class BaseMemory {\n  abstract get memoryKeys(): string[];\n\n  /**\n   * Abstract method that should take an object of input values and return a\n   * Promise that resolves with an object of memory variables. The\n   * implementation of this method should load the memory variables from the\n   * provided input values.\n   * @param values An object of input values.\n   * @returns Promise that resolves with an object of memory variables.\n   */\n  abstract loadMemoryVariables(values: InputValues): Promise<MemoryVariables>;\n\n  /**\n   * Abstract method that should take two objects, one of input values and\n   * one of output values, and return a Promise that resolves when the\n   * context has been saved. The implementation of this method should save\n   * the context based on the provided input and output values.\n   * @param inputValues An object of input values.\n   * @param outputValues An object of output values.\n   * @returns Promise that resolves when the context has been saved.\n   */\n  abstract saveContext(\n    inputValues: InputValues,\n    outputValues: OutputValues\n  ): Promise<void>;\n}\n\nconst getValue = (values: InputValues | OutputValues, key?: string) => {\n  if (key !== undefined) {\n    return values[key];\n  }\n  const keys = Object.keys(values);\n  if (keys.length === 1) {\n    return values[keys[0]];\n  }\n};\n\n/**\n * This function is used by memory classes to select the input value\n * to use for the memory. If there is only one input value, it is used.\n * If there are multiple input values, the inputKey must be specified.\n */\nexport const getInputValue = (inputValues: InputValues, inputKey?: string) => {\n  const value = getValue(inputValues, inputKey);\n  if (!value) {\n    const keys = Object.keys(inputValues);\n    throw new Error(\n      `input values have ${keys.length} keys, you must specify an input key or pass only 1 key as input`\n    );\n  }\n  return value;\n};\n\n/**\n * This function is used by memory classes to select the output value\n * to use for the memory. If there is only one output value, it is used.\n * If there are multiple output values, the outputKey must be specified.\n * If no outputKey is specified, an error is thrown.\n */\nexport const getOutputValue = (\n  outputValues: OutputValues,\n  outputKey?: string\n) => {\n  const value = getValue(outputValues, outputKey);\n  if (!value && value !== \"\") {\n    const keys = Object.keys(outputValues);\n    throw new Error(\n      `output values have ${keys.length} keys, you must specify an output key or pass only 1 key as output`\n    );\n  }\n  return value;\n};\n\n/**\n * Function used by memory classes to get the key of the prompt input,\n * excluding any keys that are memory variables or the \"stop\" key. If\n * there is not exactly one prompt input key, an error is thrown.\n */\nexport function getPromptInputKey(\n  inputs: Record<string, unknown>,\n  memoryVariables: string[]\n): string {\n  const promptInputKeys = Object.keys(inputs).filter(\n    (key) => !memoryVariables.includes(key) && key !== \"stop\"\n  );\n  if (promptInputKeys.length !== 1) {\n    throw new Error(\n      `One input key expected, but got ${promptInputKeys.length}`\n    );\n  }\n  return promptInputKeys[0];\n}\n"],"mappings":";;;;;;;;;;;;;;AA2BA,IAAsB,aAAtB,MAAiC;AA4BjC,MAAM,YAAY,QAAoC,QAAiB;AACrE,KAAI,QAAQ,KAAA,EACV,QAAO,OAAO;CAEhB,MAAM,OAAO,OAAO,KAAK,OAAO;AAChC,KAAI,KAAK,WAAW,EAClB,QAAO,OAAO,KAAK;;;;;;;AASvB,MAAa,iBAAiB,aAA0B,aAAsB;CAC5E,MAAM,QAAQ,SAAS,aAAa,SAAS;AAC7C,KAAI,CAAC,OAAO;EACV,MAAM,OAAO,OAAO,KAAK,YAAY;AACrC,QAAM,IAAI,MACR,qBAAqB,KAAK,OAAO,kEAClC;;AAEH,QAAO;;;;;;;;AAST,MAAa,kBACX,cACA,cACG;CACH,MAAM,QAAQ,SAAS,cAAc,UAAU;AAC/C,KAAI,CAAC,SAAS,UAAU,IAAI;EAC1B,MAAM,OAAO,OAAO,KAAK,aAAa;AACtC,QAAM,IAAI,MACR,sBAAsB,KAAK,OAAO,oEACnC;;AAEH,QAAO;;;;;;;AAQT,SAAgB,kBACd,QACA,iBACQ;CACR,MAAM,kBAAkB,OAAO,KAAK,OAAO,CAAC,QACzC,QAAQ,CAAC,gBAAgB,SAAS,IAAI,IAAI,QAAQ,OACpD;AACD,KAAI,gBAAgB,WAAW,EAC7B,OAAM,IAAI,MACR,mCAAmC,gBAAgB,SACpD;AAEH,QAAO,gBAAgB"}

package/dist/memory.js

@@ -1,5 +1,4 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-
 //#region src/memory.ts
 var memory_exports = /* @__PURE__ */ __exportAll({
 	BaseMemory: () => BaseMemory,
@@ -56,7 +55,7 @@ function getPromptInputKey(inputs, memoryVariables) {
 	if (promptInputKeys.length !== 1) throw new Error(`One input key expected, but got ${promptInputKeys.length}`);
 	return promptInputKeys[0];
 }
-
 //#endregion
 export { BaseMemory, getInputValue, getOutputValue, getPromptInputKey, memory_exports };
+
 //# sourceMappingURL=memory.js.map