@langchain/core 0.3.72 → 1.0.0-alpha.2

package/README.md

@@ -8,7 +8,7 @@ chat models, vectorstores, retrievers, and runnables.
 ## 💾 Quick Install
 
 ```bash
-$ yarn add @langchain/core
+$ pnpm install @langchain/core
 ```
 
 ## 🤔 What is this?
@@ -21,7 +21,7 @@ The benefit of having these abstractions is that any provider can implement the
 For example, you can install other provider-specific packages like this:
 
 ```bash
-$ yarn add @langchain/openai
+$ pnpm install @langchain/openai
 ```
 
 And use them as follows:
@@ -135,7 +135,7 @@ Because all used packages must share the same version of core, packages should n
 This recommendation will change to a caret once a major version (1.x.x) release has occurred.
 
 We suggest making all packages cross-compatible with ESM and CJS using a build step like the one in
-[@langchain/anthropic](https://github.com/langchain-ai/langchainjs/tree/main/libs/langchain-anthropic), then running `yarn build` before running `npm publish`.
+[@langchain/anthropic](https://github.com/langchain-ai/langchainjs/tree/main/libs/langchain-anthropic), then running `pnpm build` before running `npm publish`.
 
 We will be exploring how to make this process easier in the future.
 

package/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,32 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__export = __export;
+exports.__toESM = __toESM;

package/dist/_virtual/rolldown_runtime.js

@@ -0,0 +1,11 @@
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+
+//#endregion
+export { __export };

package/dist/agents.cjs

@@ -1,2 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+//#region src/agents.ts
+var agents_exports = {};
+
+//#endregion
+Object.defineProperty(exports, 'agents_exports', {
+  enumerable: true,
+  get: function () {
+    return agents_exports;
+  }
+});
+//# sourceMappingURL=agents.cjs.map

package/dist/agents.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents.cjs","names":[],"sources":["../src/agents.ts"],"sourcesContent":["export type AgentAction = {\n  tool: string;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  toolInput: string | Record<string, any>;\n  log: string;\n};\n\nexport type AgentFinish = {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  returnValues: Record<string, any>;\n  log: string;\n};\n\nexport type AgentStep = {\n  action: AgentAction;\n  observation: string;\n};\n"],"mappings":""}

package/dist/agents.d.cts

@@ -0,0 +1,19 @@
+//#region src/agents.d.ts
+type AgentAction = {
+  tool: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  toolInput: string | Record<string, any>;
+  log: string;
+};
+type AgentFinish = {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  returnValues: Record<string, any>;
+  log: string;
+};
+type AgentStep = {
+  action: AgentAction;
+  observation: string;
+};
+//#endregion
+export { AgentAction, AgentFinish, AgentStep };
+//# sourceMappingURL=agents.d.cts.map

package/dist/agents.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents.d.cts","names":["AgentAction","Record","AgentFinish","AgentStep"],"sources":["../src/agents.d.ts"],"sourcesContent":["export type AgentAction = {\n    tool: string;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    toolInput: string | Record<string, any>;\n    log: string;\n};\nexport type AgentFinish = {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    returnValues: Record<string, any>;\n    log: string;\n};\nexport type AgentStep = {\n    action: AgentAction;\n    observation: string;\n};\n"],"mappings":";KAAYA,WAAAA;EAAAA,IAAAA,EAAAA,MAAAA;EAMAE;EAKAC,SAAAA,EAAAA,MAAS,GARGF,MASZD,CAAAA,MAAW,EAAA,GAAA,CAAA;;;KANXE,WAAAA;;gBAEMD;;;KAGNE,SAAAA;UACAH"}

package/dist/agents.d.ts

@@ -1,13 +1,19 @@
-export type AgentAction = {
-    tool: string;
-    toolInput: string | Record<string, any>;
-    log: string;
+//#region src/agents.d.ts
+type AgentAction = {
+  tool: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  toolInput: string | Record<string, any>;
+  log: string;
 };
-export type AgentFinish = {
-    returnValues: Record<string, any>;
-    log: string;
+type AgentFinish = {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  returnValues: Record<string, any>;
+  log: string;
 };
-export type AgentStep = {
-    action: AgentAction;
-    observation: string;
+type AgentStep = {
+  action: AgentAction;
+  observation: string;
 };
+//#endregion
+export { AgentAction, AgentFinish, AgentStep };
+//# sourceMappingURL=agents.d.ts.map

package/dist/agents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents.d.ts","names":["AgentAction","Record","AgentFinish","AgentStep"],"sources":["../src/agents.d.ts"],"sourcesContent":["export type AgentAction = {\n    tool: string;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    toolInput: string | Record<string, any>;\n    log: string;\n};\nexport type AgentFinish = {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    returnValues: Record<string, any>;\n    log: string;\n};\nexport type AgentStep = {\n    action: AgentAction;\n    observation: string;\n};\n"],"mappings":";KAAYA,WAAAA;EAAAA,IAAAA,EAAAA,MAAAA;EAMAE;EAKAC,SAAAA,EAAAA,MAAS,GARGF,MASZD,CAAAA,MAAAA,EAAW,GAAA,CAAA;;;KANXE,WAAAA;;gBAEMD;;;KAGNE,SAAAA;UACAH"}

package/dist/agents.js

@@ -1 +1,6 @@
-export {};
+//#region src/agents.ts
+var agents_exports = {};
+
+//#endregion
+export { agents_exports };
+//# sourceMappingURL=agents.js.map

package/dist/agents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents.js","names":[],"sources":["../src/agents.ts"],"sourcesContent":["export type AgentAction = {\n  tool: string;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  toolInput: string | Record<string, any>;\n  log: string;\n};\n\nexport type AgentFinish = {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  returnValues: Record<string, any>;\n  log: string;\n};\n\nexport type AgentStep = {\n  action: AgentAction;\n  observation: string;\n};\n"],"mappings":""}

package/dist/caches/base.cjs

@@ -1,112 +1,107 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InMemoryCache = exports.BaseCache = exports.getCacheKey = void 0;
-exports.deserializeStoredGeneration = deserializeStoredGeneration;
-exports.serializeGeneration = serializeGeneration;
-const hash_js_1 = require("../utils/hash.cjs");
-const utils_js_1 = require("../messages/utils.cjs");
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_utils = require('../messages/utils.cjs');
+const require_utils_js_sha1_hash = require('../utils/js-sha1/hash.cjs');
+require('../utils/hash.cjs');
+
+//#region src/caches/base.ts
+var base_exports = {};
+require_rolldown_runtime.__export(base_exports, {
+	BaseCache: () => BaseCache,
+	InMemoryCache: () => InMemoryCache,
+	deserializeStoredGeneration: () => deserializeStoredGeneration,
+	getCacheKey: () => getCacheKey,
+	serializeGeneration: () => serializeGeneration
+});
 /**
- * This cache key should be consistent across all versions of LangChain.
- * It is currently NOT consistent across versions of LangChain.
- *
- * A huge benefit of having a remote cache (like redis) is that you can
- * access the cache from different processes/machines. The allows you to
- * separate concerns and scale horizontally.
- *
- * TODO: Make cache key consistent across versions of LangChain.
- *
- * @deprecated Use `makeDefaultKeyEncoder()` to create a custom key encoder.
- * This function will be removed in a future version.
- */
-const getCacheKey = (...strings) => (0, hash_js_1.insecureHash)(strings.join("_"));
-exports.getCacheKey = getCacheKey;
+* This cache key should be consistent across all versions of LangChain.
+* It is currently NOT consistent across versions of LangChain.
+*
+* A huge benefit of having a remote cache (like redis) is that you can
+* access the cache from different processes/machines. The allows you to
+* separate concerns and scale horizontally.
+*
+* TODO: Make cache key consistent across versions of LangChain.
+*
+* @deprecated Use `makeDefaultKeyEncoder()` to create a custom key encoder.
+* This function will be removed in a future version.
+*/
+const getCacheKey = (...strings) => require_utils_js_sha1_hash.insecureHash(strings.join("_"));
 function deserializeStoredGeneration(storedGeneration) {
-    if (storedGeneration.message !== undefined) {
-        return {
-            text: storedGeneration.text,
-            message: (0, utils_js_1.mapStoredMessageToChatMessage)(storedGeneration.message),
-        };
-    }
-    else {
-        return { text: storedGeneration.text };
-    }
+	if (storedGeneration.message !== void 0) return {
+		text: storedGeneration.text,
+		message: require_utils.mapStoredMessageToChatMessage(storedGeneration.message)
+	};
+	else return { text: storedGeneration.text };
 }
 function serializeGeneration(generation) {
-    const serializedValue = {
-        text: generation.text,
-    };
-    if (generation.message !== undefined) {
-        serializedValue.message = generation.message.toDict();
-    }
-    return serializedValue;
+	const serializedValue = { text: generation.text };
+	if (generation.message !== void 0) serializedValue.message = generation.message.toDict();
+	return serializedValue;
 }
 /**
- * Base class for all caches. All caches should extend this class.
- */
-class BaseCache {
-    constructor() {
-        // For backwards compatibility, we use a default key encoder
-        // that uses SHA-1 to hash the prompt and LLM key. This will also print a warning
-        // about the security implications of using SHA-1 as a cache key.
-        Object.defineProperty(this, "keyEncoder", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: exports.getCacheKey
-        });
-    }
-    /**
-     * Sets a custom key encoder function for the cache.
-     * This function should take a prompt and an LLM key and return a string
-     * that will be used as the cache key.
-     * @param keyEncoderFn The custom key encoder function.
-     */
-    makeDefaultKeyEncoder(keyEncoderFn) {
-        this.keyEncoder = keyEncoderFn;
-    }
-}
-exports.BaseCache = BaseCache;
-const GLOBAL_MAP = new Map();
+* Base class for all caches. All caches should extend this class.
+*/
+var BaseCache = class {
+	keyEncoder = getCacheKey;
+	/**
+	* Sets a custom key encoder function for the cache.
+	* This function should take a prompt and an LLM key and return a string
+	* that will be used as the cache key.
+	* @param keyEncoderFn The custom key encoder function.
+	*/
+	makeDefaultKeyEncoder(keyEncoderFn) {
+		this.keyEncoder = keyEncoderFn;
+	}
+};
+const GLOBAL_MAP = /* @__PURE__ */ new Map();
 /**
- * A cache for storing LLM generations that stores data in memory.
- */
-class InMemoryCache extends BaseCache {
-    constructor(map) {
-        super();
-        Object.defineProperty(this, "cache", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.cache = map ?? new Map();
-    }
-    /**
-     * Retrieves data from the cache using a prompt and an LLM key. If the
-     * data is not found, it returns null.
-     * @param prompt The prompt used to find the data.
-     * @param llmKey The LLM key used to find the data.
-     * @returns The data corresponding to the prompt and LLM key, or null if not found.
-     */
-    lookup(prompt, llmKey) {
-        return Promise.resolve(this.cache.get(this.keyEncoder(prompt, llmKey)) ?? null);
-    }
-    /**
-     * Updates the cache with new data using a prompt and an LLM key.
-     * @param prompt The prompt used to store the data.
-     * @param llmKey The LLM key used to store the data.
-     * @param value The data to be stored.
-     */
-    async update(prompt, llmKey, value) {
-        this.cache.set(this.keyEncoder(prompt, llmKey), value);
-    }
-    /**
-     * Returns a global instance of InMemoryCache using a predefined global
-     * map as the initial cache.
-     * @returns A global instance of InMemoryCache.
-     */
-    static global() {
-        return new InMemoryCache(GLOBAL_MAP);
-    }
-}
+* A cache for storing LLM generations that stores data in memory.
+*/
+var InMemoryCache = class InMemoryCache extends BaseCache {
+	cache;
+	constructor(map) {
+		super();
+		this.cache = map ?? /* @__PURE__ */ new Map();
+	}
+	/**
+	* Retrieves data from the cache using a prompt and an LLM key. If the
+	* data is not found, it returns null.
+	* @param prompt The prompt used to find the data.
+	* @param llmKey The LLM key used to find the data.
+	* @returns The data corresponding to the prompt and LLM key, or null if not found.
+	*/
+	lookup(prompt, llmKey) {
+		return Promise.resolve(this.cache.get(this.keyEncoder(prompt, llmKey)) ?? null);
+	}
+	/**
+	* Updates the cache with new data using a prompt and an LLM key.
+	* @param prompt The prompt used to store the data.
+	* @param llmKey The LLM key used to store the data.
+	* @param value The data to be stored.
+	*/
+	async update(prompt, llmKey, value) {
+		this.cache.set(this.keyEncoder(prompt, llmKey), value);
+	}
+	/**
+	* Returns a global instance of InMemoryCache using a predefined global
+	* map as the initial cache.
+	* @returns A global instance of InMemoryCache.
+	*/
+	static global() {
+		return new InMemoryCache(GLOBAL_MAP);
+	}
+};
+
+//#endregion
+exports.BaseCache = BaseCache;
 exports.InMemoryCache = InMemoryCache;
+Object.defineProperty(exports, 'base_exports', {
+  enumerable: true,
+  get: function () {
+    return base_exports;
+  }
+});
+exports.deserializeStoredGeneration = deserializeStoredGeneration;
+exports.getCacheKey = getCacheKey;
+exports.serializeGeneration = serializeGeneration;
+//# sourceMappingURL=base.cjs.map

package/dist/caches/base.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.cjs","names":["getCacheKey: HashKeyEncoder","insecureHash","storedGeneration: StoredGeneration","mapStoredMessageToChatMessage","generation: Generation","serializedValue: StoredGeneration","keyEncoderFn: HashKeyEncoder","map?: Map<string, T>","prompt: string","llmKey: string","value: T"],"sources":["../../src/caches/base.ts"],"sourcesContent":["import { insecureHash, type HashKeyEncoder } from \"../utils/hash.js\";\nimport type { Generation, ChatGeneration } from \"../outputs.js\";\nimport { mapStoredMessageToChatMessage } from \"../messages/utils.js\";\nimport { type StoredGeneration } from \"../messages/base.js\";\n\n/**\n * This cache key should be consistent across all versions of LangChain.\n * It is currently NOT consistent across versions of LangChain.\n *\n * A huge benefit of having a remote cache (like redis) is that you can\n * access the cache from different processes/machines. The allows you to\n * separate concerns and scale horizontally.\n *\n * TODO: Make cache key consistent across versions of LangChain.\n *\n * @deprecated Use `makeDefaultKeyEncoder()` to create a custom key encoder.\n * This function will be removed in a future version.\n */\nexport const getCacheKey: HashKeyEncoder = (...strings) =>\n  insecureHash(strings.join(\"_\"));\n\nexport function deserializeStoredGeneration(\n  storedGeneration: StoredGeneration\n) {\n  if (storedGeneration.message !== undefined) {\n    return {\n      text: storedGeneration.text,\n      message: mapStoredMessageToChatMessage(storedGeneration.message),\n    };\n  } else {\n    return { text: storedGeneration.text };\n  }\n}\n\nexport function serializeGeneration(generation: Generation) {\n  const serializedValue: StoredGeneration = {\n    text: generation.text,\n  };\n  if ((generation as ChatGeneration).message !== undefined) {\n    serializedValue.message = (generation as ChatGeneration).message.toDict();\n  }\n  return serializedValue;\n}\n\n/**\n * Base class for all caches. All caches should extend this class.\n */\nexport abstract class BaseCache<T = Generation[]> {\n  // For backwards compatibility, we use a default key encoder\n  // that uses SHA-1 to hash the prompt and LLM key. This will also print a warning\n  // about the security implications of using SHA-1 as a cache key.\n  protected keyEncoder: HashKeyEncoder = getCacheKey;\n\n  /**\n   * Sets a custom key encoder function for the cache.\n   * This function should take a prompt and an LLM key and return a string\n   * that will be used as the cache key.\n   * @param keyEncoderFn The custom key encoder function.\n   */\n  makeDefaultKeyEncoder(keyEncoderFn: HashKeyEncoder): void {\n    this.keyEncoder = keyEncoderFn;\n  }\n\n  abstract lookup(prompt: string, llmKey: string): Promise<T | null>;\n\n  abstract update(prompt: string, llmKey: string, value: T): Promise<void>;\n}\n\nconst GLOBAL_MAP = new Map();\n\n/**\n * A cache for storing LLM generations that stores data in memory.\n */\nexport class InMemoryCache<T = Generation[]> extends BaseCache<T> {\n  private cache: Map<string, T>;\n\n  constructor(map?: Map<string, T>) {\n    super();\n    this.cache = map ?? new Map();\n  }\n\n  /**\n   * Retrieves data from the cache using a prompt and an LLM key. If the\n   * data is not found, it returns null.\n   * @param prompt The prompt used to find the data.\n   * @param llmKey The LLM key used to find the data.\n   * @returns The data corresponding to the prompt and LLM key, or null if not found.\n   */\n  lookup(prompt: string, llmKey: string): Promise<T | null> {\n    return Promise.resolve(\n      this.cache.get(this.keyEncoder(prompt, llmKey)) ?? null\n    );\n  }\n\n  /**\n   * Updates the cache with new data using a prompt and an LLM key.\n   * @param prompt The prompt used to store the data.\n   * @param llmKey The LLM key used to store the data.\n   * @param value The data to be stored.\n   */\n  async update(prompt: string, llmKey: string, value: T): Promise<void> {\n    this.cache.set(this.keyEncoder(prompt, llmKey), value);\n  }\n\n  /**\n   * Returns a global instance of InMemoryCache using a predefined global\n   * map as the initial cache.\n   * @returns A global instance of InMemoryCache.\n   */\n  static global(): InMemoryCache {\n    return new InMemoryCache(GLOBAL_MAP);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAkBA,MAAaA,cAA8B,CAAC,GAAG,YAC7CC,wCAAa,QAAQ,KAAK,IAAI,CAAC;AAEjC,SAAgB,4BACdC,kBACA;AACA,KAAI,iBAAiB,YAAY,OAC/B,QAAO;EACL,MAAM,iBAAiB;EACvB,SAASC,4CAA8B,iBAAiB,QAAQ;CACjE;KAED,QAAO,EAAE,MAAM,iBAAiB,KAAM;AAEzC;AAED,SAAgB,oBAAoBC,YAAwB;CAC1D,MAAMC,kBAAoC,EACxC,MAAM,WAAW,KAClB;AACD,KAAK,WAA8B,YAAY,QAC7C,gBAAgB,UAAW,WAA8B,QAAQ,QAAQ;AAE3E,QAAO;AACR;;;;AAKD,IAAsB,YAAtB,MAAkD;CAIhD,AAAU,aAA6B;;;;;;;CAQvC,sBAAsBC,cAAoC;EACxD,KAAK,aAAa;CACnB;AAKF;AAED,MAAM,6BAAa,IAAI;;;;AAKvB,IAAa,gBAAb,MAAa,sBAAwC,UAAa;CAChE,AAAQ;CAER,YAAYC,KAAsB;EAChC,OAAO;EACP,KAAK,QAAQ,uBAAO,IAAI;CACzB;;;;;;;;CASD,OAAOC,QAAgBC,QAAmC;AACxD,SAAO,QAAQ,QACb,KAAK,MAAM,IAAI,KAAK,WAAW,QAAQ,OAAO,CAAC,IAAI,KACpD;CACF;;;;;;;CAQD,MAAM,OAAOD,QAAgBC,QAAgBC,OAAyB;EACpE,KAAK,MAAM,IAAI,KAAK,WAAW,QAAQ,OAAO,EAAE,MAAM;CACvD;;;;;;CAOD,OAAO,SAAwB;AAC7B,SAAO,IAAI,cAAc;CAC1B;AACF"}

package/dist/caches/base.d.cts

@@ -0,0 +1,83 @@
+import { StoredGeneration } from "../messages/base.cjs";
+import { ToolMessage } from "../messages/tool.cjs";
+import { AIMessage } from "../messages/ai.cjs";
+import { ChatMessage } from "../messages/chat.cjs";
+import { FunctionMessage } from "../messages/function.cjs";
+import { HumanMessage } from "../messages/human.cjs";
+import { SystemMessage } from "../messages/system.cjs";
+import { HashKeyEncoder } from "../utils/hash.cjs";
+import { Generation } from "../outputs.cjs";
+
+//#region src/caches/base.d.ts
+
+/**
+ * This cache key should be consistent across all versions of LangChain.
+ * It is currently NOT consistent across versions of LangChain.
+ *
+ * A huge benefit of having a remote cache (like redis) is that you can
+ * access the cache from different processes/machines. The allows you to
+ * separate concerns and scale horizontally.
+ *
+ * TODO: Make cache key consistent across versions of LangChain.
+ *
+ * @deprecated Use `makeDefaultKeyEncoder()` to create a custom key encoder.
+ * This function will be removed in a future version.
+ */
+declare const getCacheKey: HashKeyEncoder;
+declare function deserializeStoredGeneration(storedGeneration: StoredGeneration): {
+  text: string;
+  message: AIMessage | ChatMessage | FunctionMessage | HumanMessage | SystemMessage | ToolMessage;
+} | {
+  message?: undefined;
+  text: string;
+};
+declare function serializeGeneration(generation: Generation): StoredGeneration;
+/**
+ * Base class for all caches. All caches should extend this class.
+ */
+declare abstract class BaseCache<T = Generation[]> {
+  // For backwards compatibility, we use a default key encoder
+  // that uses SHA-1 to hash the prompt and LLM key. This will also print a warning
+  // about the security implications of using SHA-1 as a cache key.
+  protected keyEncoder: HashKeyEncoder;
+  /**
+   * Sets a custom key encoder function for the cache.
+   * This function should take a prompt and an LLM key and return a string
+   * that will be used as the cache key.
+   * @param keyEncoderFn The custom key encoder function.
+   */
+  makeDefaultKeyEncoder(keyEncoderFn: HashKeyEncoder): void;
+  abstract lookup(prompt: string, llmKey: string): Promise<T | null>;
+  abstract update(prompt: string, llmKey: string, value: T): Promise<void>;
+}
+/**
+ * A cache for storing LLM generations that stores data in memory.
+ */
+declare class InMemoryCache<T = Generation[]> extends BaseCache<T> {
+  private cache;
+  constructor(map?: Map<string, T>);
+  /**
+   * Retrieves data from the cache using a prompt and an LLM key. If the
+   * data is not found, it returns null.
+   * @param prompt The prompt used to find the data.
+   * @param llmKey The LLM key used to find the data.
+   * @returns The data corresponding to the prompt and LLM key, or null if not found.
+   */
+  lookup(prompt: string, llmKey: string): Promise<T | null>;
+  /**
+   * Updates the cache with new data using a prompt and an LLM key.
+   * @param prompt The prompt used to store the data.
+   * @param llmKey The LLM key used to store the data.
+   * @param value The data to be stored.
+   */
+  update(prompt: string, llmKey: string, value: T): Promise<void>;
+  /**
+   * Returns a global instance of InMemoryCache using a predefined global
+   * map as the initial cache.
+   * @returns A global instance of InMemoryCache.
+   */
+  static global(): InMemoryCache;
+}
+//#endregion
+export { BaseCache, InMemoryCache, deserializeStoredGeneration, getCacheKey, serializeGeneration };
+//# sourceMappingURL=base.d.cts.map

package/dist/caches/base.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.cts","names":["___messages_chat_js0","___messages_function_js0","___messages_human_js0","___messages_system_js0","___messages_tool_js0","HashKeyEncoder","Generation","StoredGeneration","getCacheKey","deserializeStoredGeneration","___messages_ai_js0","AIMessage","ChatMessage","FunctionMessage","HumanMessage","SystemMessage","ToolMessage","serializeGeneration","BaseCache","T","Promise","InMemoryCache","Map"],"sources":["../../src/caches/base.d.ts"],"sourcesContent":["import { type HashKeyEncoder } from \"../utils/hash.js\";\nimport type { Generation } from \"../outputs.js\";\nimport { type StoredGeneration } from \"../messages/base.js\";\n/**\n * This cache key should be consistent across all versions of LangChain.\n * It is currently NOT consistent across versions of LangChain.\n *\n * A huge benefit of having a remote cache (like redis) is that you can\n * access the cache from different processes/machines. The allows you to\n * separate concerns and scale horizontally.\n *\n * TODO: Make cache key consistent across versions of LangChain.\n *\n * @deprecated Use `makeDefaultKeyEncoder()` to create a custom key encoder.\n * This function will be removed in a future version.\n */\nexport declare const getCacheKey: HashKeyEncoder;\nexport declare function deserializeStoredGeneration(storedGeneration: StoredGeneration): {\n    text: string;\n    message: import(\"../messages/ai.js\").AIMessage | import(\"../messages/chat.js\").ChatMessage | import(\"../messages/function.js\").FunctionMessage | import(\"../messages/human.js\").HumanMessage | import(\"../messages/system.js\").SystemMessage | import(\"../messages/tool.js\").ToolMessage;\n} | {\n    message?: undefined;\n    text: string;\n};\nexport declare function serializeGeneration(generation: Generation): StoredGeneration;\n/**\n * Base class for all caches. All caches should extend this class.\n */\nexport declare abstract class BaseCache<T = Generation[]> {\n    // For backwards compatibility, we use a default key encoder\n    // that uses SHA-1 to hash the prompt and LLM key. This will also print a warning\n    // about the security implications of using SHA-1 as a cache key.\n    protected keyEncoder: HashKeyEncoder;\n    /**\n     * Sets a custom key encoder function for the cache.\n     * This function should take a prompt and an LLM key and return a string\n     * that will be used as the cache key.\n     * @param keyEncoderFn The custom key encoder function.\n     */\n    makeDefaultKeyEncoder(keyEncoderFn: HashKeyEncoder): void;\n    abstract lookup(prompt: string, llmKey: string): Promise<T | null>;\n    abstract update(prompt: string, llmKey: string, value: T): Promise<void>;\n}\n/**\n * A cache for storing LLM generations that stores data in memory.\n */\nexport declare class InMemoryCache<T = Generation[]> extends BaseCache<T> {\n    private cache;\n    constructor(map?: Map<string, T>);\n    /**\n     * Retrieves data from the cache using a prompt and an LLM key. If the\n     * data is not found, it returns null.\n     * @param prompt The prompt used to find the data.\n     * @param llmKey The LLM key used to find the data.\n     * @returns The data corresponding to the prompt and LLM key, or null if not found.\n     */\n    lookup(prompt: string, llmKey: string): Promise<T | null>;\n    /**\n     * Updates the cache with new data using a prompt and an LLM key.\n     * @param prompt The prompt used to store the data.\n     * @param llmKey The LLM key used to store the data.\n     * @param value The data to be stored.\n     */\n    update(prompt: string, llmKey: string, value: T): Promise<void>;\n    /**\n     * Returns a global instance of InMemoryCache using a predefined global\n     * map as the initial cache.\n     * @returns A global instance of InMemoryCache.\n     */\n    static global(): InMemoryCache;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAgBA;AACA;;;;AAEkD,cAH7BQ,WAG6B,EAHhBH,cAGgB;AAA4C,iBAFtEI,2BAAAA,CAEsE,gBAAA,EAFxBF,gBAEwB,CAAA,EAAA;EAAoD,IAAA,EAAA,MAAA;EAA8C,OAAA,EAF1G,SAAA,GAEpC,WAAA,GAA4C,eAAA,GAAoD,YAAA,GAA8C,aAAA,GAAgD,WAAhD;CAAgD,GAAA;EAA4C,OAAA,CAAA,EAAA,SAAA;EAKpQU,IAAAA,EAAAA,MAAAA;CAAmB;AAAaX,iBAAhCW,mBAAAA,CAAgCX,UAAAA,EAAAA,UAAAA,CAAAA,EAAaC,gBAAbD;;AAA6B;AAIrF;AAAuC,uBAATY,SAAS,CAAA,IAAKZ,UAAL,EAAA,CAAA,CAAA;EAAA;EAAe;EAId;EAOc,UACOa,UAAAA,EARnCd,cAQmCc;EAAC;;;AACQ;AAKtE;;EAAkC,qBAAKb,CAAAA,YAAAA,EAPCD,cAODC,CAAAA,EAAAA,IAAAA;EAAU,SAAsBa,MAAAA,CAAAA,MAAAA,EAAAA,MAAAA,EAAAA,MAAAA,EAAAA,MAAAA,CAAAA,EANlBC,OAMkBD,CANVA,CAMUA,GAAAA,IAAAA,CAAAA;EAAC,SAEtCA,MAAAA,CAAAA,MAAAA,EAAAA,MAAAA,EAAAA,MAAAA,EAAAA,MAAAA,EAAAA,KAAAA,EAPyBA,CAOzBA,CAAAA,EAP6BC,OAO7BD,CAAAA,IAAAA,CAAAA;;;;;AAeoBC,cAjBjCC,aAiBiCD,CAAAA,IAjBfd,UAiBec,EAAAA,CAAAA,SAjBOF,SAiBPE,CAjBiBD,CAiBjBC,CAAAA,CAAAA;EAAO,QAMxCC,KAAAA;EAAa,WAvB2BH,CAAAA,GAAAA,CAAAA,EAEvCI,GAFuCJ,CAAAA,MAAAA,EAE3BC,CAF2BD,CAAAA;EAAS;;;;;;;0CAU1BE,QAAQD;;;;;;;gDAOFA,IAAIC;;;;;;mBAMjCC"}

package/dist/caches/base.d.ts

@@ -1,6 +1,15 @@
-import { type HashKeyEncoder } from "../utils/hash.js";
-import type { Generation } from "../outputs.js";
-import { type StoredGeneration } from "../messages/base.js";
+import { StoredGeneration } from "../messages/base.js";
+import { ToolMessage } from "../messages/tool.js";
+import { AIMessage } from "../messages/ai.js";
+import { ChatMessage } from "../messages/chat.js";
+import { FunctionMessage } from "../messages/function.js";
+import { HumanMessage } from "../messages/human.js";
+import { SystemMessage } from "../messages/system.js";
+import { HashKeyEncoder } from "../utils/hash.js";
+import { Generation } from "../outputs.js";
+
+//#region src/caches/base.d.ts
+
 /**
  * This cache key should be consistent across all versions of LangChain.
  * It is currently NOT consistent across versions of LangChain.
@@ -14,55 +23,61 @@ import { type StoredGeneration } from "../messages/base.js";
  * @deprecated Use `makeDefaultKeyEncoder()` to create a custom key encoder.
  * This function will be removed in a future version.
  */
-export declare const getCacheKey: HashKeyEncoder;
-export declare function deserializeStoredGeneration(storedGeneration: StoredGeneration): {
-    text: string;
-    message: import("../messages/tool.js").ToolMessage | import("../messages/ai.js").AIMessage | import("../messages/chat.js").ChatMessage | import("../messages/function.js").FunctionMessage | import("../messages/human.js").HumanMessage | import("../messages/system.js").SystemMessage;
+declare const getCacheKey: HashKeyEncoder;
+declare function deserializeStoredGeneration(storedGeneration: StoredGeneration): {
+  text: string;
+  message: AIMessage | ChatMessage | FunctionMessage | HumanMessage | SystemMessage | ToolMessage;
 } | {
-    text: string;
-    message?: undefined;
+  message?: undefined;
+  text: string;
 };
-export declare function serializeGeneration(generation: Generation): StoredGeneration;
+declare function serializeGeneration(generation: Generation): StoredGeneration;
 /**
  * Base class for all caches. All caches should extend this class.
  */
-export declare abstract class BaseCache<T = Generation[]> {
-    protected keyEncoder: HashKeyEncoder;
-    /**
-     * Sets a custom key encoder function for the cache.
-     * This function should take a prompt and an LLM key and return a string
-     * that will be used as the cache key.
-     * @param keyEncoderFn The custom key encoder function.
-     */
-    makeDefaultKeyEncoder(keyEncoderFn: HashKeyEncoder): void;
-    abstract lookup(prompt: string, llmKey: string): Promise<T | null>;
-    abstract update(prompt: string, llmKey: string, value: T): Promise<void>;
+declare abstract class BaseCache<T = Generation[]> {
+  // For backwards compatibility, we use a default key encoder
+  // that uses SHA-1 to hash the prompt and LLM key. This will also print a warning
+  // about the security implications of using SHA-1 as a cache key.
+  protected keyEncoder: HashKeyEncoder;
+  /**
+   * Sets a custom key encoder function for the cache.
+   * This function should take a prompt and an LLM key and return a string
+   * that will be used as the cache key.
+   * @param keyEncoderFn The custom key encoder function.
+   */
+  makeDefaultKeyEncoder(keyEncoderFn: HashKeyEncoder): void;
+  abstract lookup(prompt: string, llmKey: string): Promise<T | null>;
+  abstract update(prompt: string, llmKey: string, value: T): Promise<void>;
 }
 /**
  * A cache for storing LLM generations that stores data in memory.
  */
-export declare class InMemoryCache<T = Generation[]> extends BaseCache<T> {
-    private cache;
-    constructor(map?: Map<string, T>);
-    /**
-     * Retrieves data from the cache using a prompt and an LLM key. If the
-     * data is not found, it returns null.
-     * @param prompt The prompt used to find the data.
-     * @param llmKey The LLM key used to find the data.
-     * @returns The data corresponding to the prompt and LLM key, or null if not found.
-     */
-    lookup(prompt: string, llmKey: string): Promise<T | null>;
-    /**
-     * Updates the cache with new data using a prompt and an LLM key.
-     * @param prompt The prompt used to store the data.
-     * @param llmKey The LLM key used to store the data.
-     * @param value The data to be stored.
-     */
-    update(prompt: string, llmKey: string, value: T): Promise<void>;
-    /**
-     * Returns a global instance of InMemoryCache using a predefined global
-     * map as the initial cache.
-     * @returns A global instance of InMemoryCache.
-     */
-    static global(): InMemoryCache;
+declare class InMemoryCache<T = Generation[]> extends BaseCache<T> {
+  private cache;
+  constructor(map?: Map<string, T>);
+  /**
+   * Retrieves data from the cache using a prompt and an LLM key. If the
+   * data is not found, it returns null.
+   * @param prompt The prompt used to find the data.
+   * @param llmKey The LLM key used to find the data.
+   * @returns The data corresponding to the prompt and LLM key, or null if not found.
+   */
+  lookup(prompt: string, llmKey: string): Promise<T | null>;
+  /**
+   * Updates the cache with new data using a prompt and an LLM key.
+   * @param prompt The prompt used to store the data.
+   * @param llmKey The LLM key used to store the data.
+   * @param value The data to be stored.
+   */
+  update(prompt: string, llmKey: string, value: T): Promise<void>;
+  /**
+   * Returns a global instance of InMemoryCache using a predefined global
+   * map as the initial cache.
+   * @returns A global instance of InMemoryCache.
+   */
+  static global(): InMemoryCache;
 }
+//#endregion
+export { BaseCache, InMemoryCache, deserializeStoredGeneration, getCacheKey, serializeGeneration };
+//# sourceMappingURL=base.d.ts.map

package/dist/caches/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","names":["___messages_chat_js0","___messages_function_js0","___messages_human_js0","___messages_system_js0","___messages_tool_js0","HashKeyEncoder","Generation","StoredGeneration","getCacheKey","deserializeStoredGeneration","___messages_ai_js0","AIMessage","ChatMessage","FunctionMessage","HumanMessage","SystemMessage","ToolMessage","serializeGeneration","BaseCache","T","Promise","InMemoryCache","Map"],"sources":["../../src/caches/base.d.ts"],"sourcesContent":["import { type HashKeyEncoder } from \"../utils/hash.js\";\nimport type { Generation } from \"../outputs.js\";\nimport { type StoredGeneration } from \"../messages/base.js\";\n/**\n * This cache key should be consistent across all versions of LangChain.\n * It is currently NOT consistent across versions of LangChain.\n *\n * A huge benefit of having a remote cache (like redis) is that you can\n * access the cache from different processes/machines. The allows you to\n * separate concerns and scale horizontally.\n *\n * TODO: Make cache key consistent across versions of LangChain.\n *\n * @deprecated Use `makeDefaultKeyEncoder()` to create a custom key encoder.\n * This function will be removed in a future version.\n */\nexport declare const getCacheKey: HashKeyEncoder;\nexport declare function deserializeStoredGeneration(storedGeneration: StoredGeneration): {\n    text: string;\n    message: import(\"../messages/ai.js\").AIMessage | import(\"../messages/chat.js\").ChatMessage | import(\"../messages/function.js\").FunctionMessage | import(\"../messages/human.js\").HumanMessage | import(\"../messages/system.js\").SystemMessage | import(\"../messages/tool.js\").ToolMessage;\n} | {\n    message?: undefined;\n    text: string;\n};\nexport declare function serializeGeneration(generation: Generation): StoredGeneration;\n/**\n * Base class for all caches. All caches should extend this class.\n */\nexport declare abstract class BaseCache<T = Generation[]> {\n    // For backwards compatibility, we use a default key encoder\n    // that uses SHA-1 to hash the prompt and LLM key. This will also print a warning\n    // about the security implications of using SHA-1 as a cache key.\n    protected keyEncoder: HashKeyEncoder;\n    /**\n     * Sets a custom key encoder function for the cache.\n     * This function should take a prompt and an LLM key and return a string\n     * that will be used as the cache key.\n     * @param keyEncoderFn The custom key encoder function.\n     */\n    makeDefaultKeyEncoder(keyEncoderFn: HashKeyEncoder): void;\n    abstract lookup(prompt: string, llmKey: string): Promise<T | null>;\n    abstract update(prompt: string, llmKey: string, value: T): Promise<void>;\n}\n/**\n * A cache for storing LLM generations that stores data in memory.\n */\nexport declare class InMemoryCache<T = Generation[]> extends BaseCache<T> {\n    private cache;\n    constructor(map?: Map<string, T>);\n    /**\n     * Retrieves data from the cache using a prompt and an LLM key. If the\n     * data is not found, it returns null.\n     * @param prompt The prompt used to find the data.\n     * @param llmKey The LLM key used to find the data.\n     * @returns The data corresponding to the prompt and LLM key, or null if not found.\n     */\n    lookup(prompt: string, llmKey: string): Promise<T | null>;\n    /**\n     * Updates the cache with new data using a prompt and an LLM key.\n     * @param prompt The prompt used to store the data.\n     * @param llmKey The LLM key used to store the data.\n     * @param value The data to be stored.\n     */\n    update(prompt: string, llmKey: string, value: T): Promise<void>;\n    /**\n     * Returns a global instance of InMemoryCache using a predefined global\n     * map as the initial cache.\n     * @returns A global instance of InMemoryCache.\n     */\n    static global(): InMemoryCache;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAgBA;AACA;;;;AAEkD,cAH7BQ,WAG6B,EAHhBH,cAGgB;AAA4C,iBAFtEI,2BAAAA,CAEsE,gBAAA,EAFxBF,gBAEwB,CAAA,EAAA;EAAoD,IAAA,EAAA,MAAA;EAA8C,OAAA,EAF1G,SAAA,GAEpC,WAAA,GAA4C,eAAA,GAAoD,YAAA,GAA8C,aAAA,GAAgD,WAAhD;CAAgD,GAAA;EAA4C,OAAA,CAAA,EAAA,SAAA;EAKpQU,IAAAA,EAAAA,MAAAA;CAAmB;AAAaX,iBAAhCW,mBAAAA,CAAgCX,UAAAA,EAAAA,UAAAA,CAAAA,EAAaC,gBAAbD;;AAA6B;AAIrF;AAAuC,uBAATY,SAAS,CAAA,IAAKZ,UAAL,EAAA,CAAA,CAAA;EAAA;EAAe;EAId;EAOc,UACOa,UAAAA,EARnCd,cAQmCc;EAAC;;;AACQ;AAKtE;;EAAkC,qBAAKb,CAAAA,YAAAA,EAPCD,cAODC,CAAAA,EAAAA,IAAAA;EAAU,SAAsBa,MAAAA,CAAAA,MAAAA,EAAAA,MAAAA,EAAAA,MAAAA,EAAAA,MAAAA,CAAAA,EANlBC,OAMkBD,CANVA,CAMUA,GAAAA,IAAAA,CAAAA;EAAC,SAEtCA,MAAAA,CAAAA,MAAAA,EAAAA,MAAAA,EAAAA,MAAAA,EAAAA,MAAAA,EAAAA,KAAAA,EAPyBA,CAOzBA,CAAAA,EAP6BC,OAO7BD,CAAAA,IAAAA,CAAAA;;;;;AAeoBC,cAjBjCC,aAiBiCD,CAAAA,IAjBfd,UAiBec,EAAAA,CAAAA,SAjBOF,SAiBPE,CAjBiBD,CAiBjBC,CAAAA,CAAAA;EAAO,QAMxCC,KAAAA;EAAa,WAvB2BH,CAAAA,GAAAA,CAAAA,EAEvCI,GAFuCJ,CAAAA,MAAAA,EAE3BC,CAF2BD,CAAAA;EAAS;;;;;;;0CAU1BE,QAAQD;;;;;;;gDAOFA,IAAIC;;;;;;mBAMjCC"}