langchain 1.0.3 → 1.0.5

package/dist/agents/middleware/callLimit.d.cts

@@ -1,119 +0,0 @@
-import { AgentMiddleware } from "./types.cjs";
-import { InferInteropZodInput } from "@langchain/core/utils/types";
-import { z } from "zod/v3";
-
-//#region src/agents/middleware/callLimit.d.ts
-declare const contextSchema: z.ZodObject<{
-  /**
-   * The maximum number of model calls allowed per thread.
-   */
-  threadLimit: z.ZodOptional<z.ZodNumber>;
-  /**
-   * The maximum number of model calls allowed per run.
-   */
-  runLimit: z.ZodOptional<z.ZodNumber>;
-  /**
-   * The behavior to take when the limit is exceeded.
-   * - "throw" will throw an error and stop the agent.
-   * - "end" will end the agent.
-   * @default "end"
-   */
-  exitBehavior: z.ZodOptional<z.ZodEnum<["throw", "end"]>>;
-}, "strip", z.ZodTypeAny, {
-  threadLimit?: number | undefined;
-  runLimit?: number | undefined;
-  exitBehavior?: "end" | "throw" | undefined;
-}, {
-  threadLimit?: number | undefined;
-  runLimit?: number | undefined;
-  exitBehavior?: "end" | "throw" | undefined;
-}>;
-type ModelCallLimitMiddlewareConfig = Partial<InferInteropZodInput<typeof contextSchema>>;
-/**
- * Creates a middleware to limit the number of model calls at both thread and run levels.
- *
- * This middleware helps prevent excessive model API calls by enforcing limits on how many
- * times the model can be invoked. It supports two types of limits:
- *
- * - **Thread-level limit**: Restricts the total number of model calls across an entire conversation thread
- * - **Run-level limit**: Restricts the number of model calls within a single agent run/invocation
- *
- * ## How It Works
- *
- * The middleware intercepts model requests before they are sent and checks the current call counts
- * against the configured limits. If either limit is exceeded, it throws a `ModelCallLimitMiddlewareError`
- * to stop execution and prevent further API calls.
- *
- * ## Use Cases
- *
- * - **Cost Control**: Prevent runaway costs from excessive model calls in production
- * - **Testing**: Ensure agents don't make too many calls during development/testing
- * - **Safety**: Limit potential infinite loops or recursive agent behaviors
- * - **Rate Limiting**: Enforce organizational policies on model usage per conversation
- *
- * @param middlewareOptions - Configuration options for the call limits
- * @param middlewareOptions.threadLimit - Maximum number of model calls allowed per thread (optional)
- * @param middlewareOptions.runLimit - Maximum number of model calls allowed per run (optional)
- *
- * @returns A middleware instance that can be passed to `createAgent`
- *
- * @throws {ModelCallLimitMiddlewareError} When either the thread or run limit is exceeded
- *
- * @example
- * ```typescript
- * import { createAgent, modelCallLimitMiddleware } from "langchain";
- *
- * // Limit to 10 calls per thread and 3 calls per run
- * const agent = createAgent({
- *   model: "openai:gpt-4o-mini",
- *   tools: [myTool],
- *   middleware: [
- *     modelCallLimitMiddleware({
- *       threadLimit: 10,
- *       runLimit: 3
- *     })
- *   ]
- * });
- * ```
- *
- * @example
- * ```typescript
- * // Limits can also be configured at runtime via context
- * const result = await agent.invoke(
- *   { messages: ["Hello"] },
- *   {
- *     configurable: {
- *       threadLimit: 5  // Override the default limit for this run
- *     }
- *   }
- * );
- * ```
- */
-declare function modelCallLimitMiddleware(middlewareOptions?: ModelCallLimitMiddlewareConfig): AgentMiddleware<undefined, z.ZodObject<{
-  /**
-   * The maximum number of model calls allowed per thread.
-   */
-  threadLimit: z.ZodOptional<z.ZodNumber>;
-  /**
-   * The maximum number of model calls allowed per run.
-   */
-  runLimit: z.ZodOptional<z.ZodNumber>;
-  /**
-   * The behavior to take when the limit is exceeded.
-   * - "throw" will throw an error and stop the agent.
-   * - "end" will end the agent.
-   * @default "end"
-   */
-  exitBehavior: z.ZodOptional<z.ZodEnum<["throw", "end"]>>;
-}, "strip", z.ZodTypeAny, {
-  threadLimit?: number | undefined;
-  runLimit?: number | undefined;
-  exitBehavior?: "end" | "throw" | undefined;
-}, {
-  threadLimit?: number | undefined;
-  runLimit?: number | undefined;
-  exitBehavior?: "end" | "throw" | undefined;
-}>, any>;
-//#endregion
-export { ModelCallLimitMiddlewareConfig, modelCallLimitMiddleware };
-//# sourceMappingURL=callLimit.d.cts.map

package/dist/agents/middleware/callLimit.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"callLimit.d.cts","names":["z","InferInteropZodInput","contextSchema","ZodNumber","ZodOptional","ZodEnum","ZodTypeAny","ZodObject","ModelCallLimitMiddlewareConfig","Partial","modelCallLimitMiddleware","__types_js10","AgentMiddleware"],"sources":["../../../src/agents/middleware/callLimit.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\ndeclare const contextSchema: z.ZodObject<{\n    /**\n     * The maximum number of model calls allowed per thread.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The maximum number of model calls allowed per run.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The behavior to take when the limit is exceeded.\n     * - \"throw\" will throw an error and stop the agent.\n     * - \"end\" will end the agent.\n     * @default \"end\"\n     */\n    exitBehavior: z.ZodOptional<z.ZodEnum<[\"throw\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}>;\nexport type ModelCallLimitMiddlewareConfig = Partial<InferInteropZodInput<typeof contextSchema>>;\n/**\n * Creates a middleware to limit the number of model calls at both thread and run levels.\n *\n * This middleware helps prevent excessive model API calls by enforcing limits on how many\n * times the model can be invoked. It supports two types of limits:\n *\n * - **Thread-level limit**: Restricts the total number of model calls across an entire conversation thread\n * - **Run-level limit**: Restricts the number of model calls within a single agent run/invocation\n *\n * ## How It Works\n *\n * The middleware intercepts model requests before they are sent and checks the current call counts\n * against the configured limits. If either limit is exceeded, it throws a `ModelCallLimitMiddlewareError`\n * to stop execution and prevent further API calls.\n *\n * ## Use Cases\n *\n * - **Cost Control**: Prevent runaway costs from excessive model calls in production\n * - **Testing**: Ensure agents don't make too many calls during development/testing\n * - **Safety**: Limit potential infinite loops or recursive agent behaviors\n * - **Rate Limiting**: Enforce organizational policies on model usage per conversation\n *\n * @param middlewareOptions - Configuration options for the call limits\n * @param middlewareOptions.threadLimit - Maximum number of model calls allowed per thread (optional)\n * @param middlewareOptions.runLimit - Maximum number of model calls allowed per run (optional)\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @throws {ModelCallLimitMiddlewareError} When either the thread or run limit is exceeded\n *\n * @example\n * ```typescript\n * import { createAgent, modelCallLimitMiddleware } from \"langchain\";\n *\n * // Limit to 10 calls per thread and 3 calls per run\n * const agent = createAgent({\n *   model: \"openai:gpt-4o-mini\",\n *   tools: [myTool],\n *   middleware: [\n *     modelCallLimitMiddleware({\n *       threadLimit: 10,\n *       runLimit: 3\n *     })\n *   ]\n * });\n * ```\n *\n * @example\n * ```typescript\n * // Limits can also be configured at runtime via context\n * const result = await agent.invoke(\n *   { messages: [\"Hello\"] },\n *   {\n *     configurable: {\n *       threadLimit: 5  // Override the default limit for this run\n *     }\n *   }\n * );\n * ```\n */\nexport declare function modelCallLimitMiddleware(middlewareOptions?: ModelCallLimitMiddlewareConfig): import(\"./types.js\").AgentMiddleware<undefined, z.ZodObject<{\n    /**\n     * The maximum number of model calls allowed per thread.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The maximum number of model calls allowed per run.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The behavior to take when the limit is exceeded.\n     * - \"throw\" will throw an error and stop the agent.\n     * - \"end\" will end the agent.\n     * @default \"end\"\n     */\n    exitBehavior: z.ZodOptional<z.ZodEnum<[\"throw\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}>, any>;\nexport {};\n"],"mappings":";;;;;cAEcE,eAAeF,CAAAA,CAAEO;;;AADoC;EAyBjE,WAAA,EApBeP,CAAAA,CAAEI,WAoBjB,CApB6BJ,CAAAA,CAAEG,SAoB/B,CAAA;EAAA;;;EAhBqC,QAAvBC,EAAFJ,CAAAA,CAAEI,WAAAA,CAAYJ,CAAAA,CAAEG,SAAdC,CAAAA;EAAW;;;;AARa;AAyBxC;EAA0C,YAAA,EAVxBJ,CAAAA,CAAEI,WAUsB,CAVVJ,CAAAA,CAAEK,OAUQ,CAAA,CAAA,OAAA,EAAA,KAAA,CAAA,CAAA,CAAA;CAAA,EAAA,OAAuCH,EATrEF,CAAAA,CAAEM,UASmEJ,EAAAA;EAAa,WAAzCD,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAoB,QAA5BQ,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAO,YAAA,CAAA,EAAA,KAAA,GAAA,OAAA,GAAA,SAAA;AA6DpD,CAAA,EAAA;EAAgD,WAAA,CAAA,EAAA,MAAA,GAAA,SAAA;EAAA,QAAqBD,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAA8B,YAIlEL,CAAAA,EAAAA,KAAAA,GAAAA,OAAAA,GAAAA,SAAAA;CAAS,CAAA;AAIdH,KArEhBQ,8BAAAA,GAAiCC,OAqEfN,CArEuBF,oBAqEvBE,CAAAA,OArEmDD,aAqEnDC,CAAAA,CAAAA;;;;;;;AAR4G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAlHO,wBAAAA,qBAA6CF,iCAA4F,2BAAXR,CAAAA,CAAEO;;;;eAIvIP,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;;;;YAInBH,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;;;;;;;gBAOZH,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEK;YACtBL,CAAAA,CAAEM"}

package/dist/agents/middleware/callLimit.d.ts

@@ -1,119 +0,0 @@
-import { AgentMiddleware } from "./types.js";
-import { z } from "zod/v3";
-import { InferInteropZodInput } from "@langchain/core/utils/types";
-
-//#region src/agents/middleware/callLimit.d.ts
-declare const contextSchema: z.ZodObject<{
-  /**
-   * The maximum number of model calls allowed per thread.
-   */
-  threadLimit: z.ZodOptional<z.ZodNumber>;
-  /**
-   * The maximum number of model calls allowed per run.
-   */
-  runLimit: z.ZodOptional<z.ZodNumber>;
-  /**
-   * The behavior to take when the limit is exceeded.
-   * - "throw" will throw an error and stop the agent.
-   * - "end" will end the agent.
-   * @default "end"
-   */
-  exitBehavior: z.ZodOptional<z.ZodEnum<["throw", "end"]>>;
-}, "strip", z.ZodTypeAny, {
-  threadLimit?: number | undefined;
-  runLimit?: number | undefined;
-  exitBehavior?: "end" | "throw" | undefined;
-}, {
-  threadLimit?: number | undefined;
-  runLimit?: number | undefined;
-  exitBehavior?: "end" | "throw" | undefined;
-}>;
-type ModelCallLimitMiddlewareConfig = Partial<InferInteropZodInput<typeof contextSchema>>;
-/**
- * Creates a middleware to limit the number of model calls at both thread and run levels.
- *
- * This middleware helps prevent excessive model API calls by enforcing limits on how many
- * times the model can be invoked. It supports two types of limits:
- *
- * - **Thread-level limit**: Restricts the total number of model calls across an entire conversation thread
- * - **Run-level limit**: Restricts the number of model calls within a single agent run/invocation
- *
- * ## How It Works
- *
- * The middleware intercepts model requests before they are sent and checks the current call counts
- * against the configured limits. If either limit is exceeded, it throws a `ModelCallLimitMiddlewareError`
- * to stop execution and prevent further API calls.
- *
- * ## Use Cases
- *
- * - **Cost Control**: Prevent runaway costs from excessive model calls in production
- * - **Testing**: Ensure agents don't make too many calls during development/testing
- * - **Safety**: Limit potential infinite loops or recursive agent behaviors
- * - **Rate Limiting**: Enforce organizational policies on model usage per conversation
- *
- * @param middlewareOptions - Configuration options for the call limits
- * @param middlewareOptions.threadLimit - Maximum number of model calls allowed per thread (optional)
- * @param middlewareOptions.runLimit - Maximum number of model calls allowed per run (optional)
- *
- * @returns A middleware instance that can be passed to `createAgent`
- *
- * @throws {ModelCallLimitMiddlewareError} When either the thread or run limit is exceeded
- *
- * @example
- * ```typescript
- * import { createAgent, modelCallLimitMiddleware } from "langchain";
- *
- * // Limit to 10 calls per thread and 3 calls per run
- * const agent = createAgent({
- *   model: "openai:gpt-4o-mini",
- *   tools: [myTool],
- *   middleware: [
- *     modelCallLimitMiddleware({
- *       threadLimit: 10,
- *       runLimit: 3
- *     })
- *   ]
- * });
- * ```
- *
- * @example
- * ```typescript
- * // Limits can also be configured at runtime via context
- * const result = await agent.invoke(
- *   { messages: ["Hello"] },
- *   {
- *     configurable: {
- *       threadLimit: 5  // Override the default limit for this run
- *     }
- *   }
- * );
- * ```
- */
-declare function modelCallLimitMiddleware(middlewareOptions?: ModelCallLimitMiddlewareConfig): AgentMiddleware<undefined, z.ZodObject<{
-  /**
-   * The maximum number of model calls allowed per thread.
-   */
-  threadLimit: z.ZodOptional<z.ZodNumber>;
-  /**
-   * The maximum number of model calls allowed per run.
-   */
-  runLimit: z.ZodOptional<z.ZodNumber>;
-  /**
-   * The behavior to take when the limit is exceeded.
-   * - "throw" will throw an error and stop the agent.
-   * - "end" will end the agent.
-   * @default "end"
-   */
-  exitBehavior: z.ZodOptional<z.ZodEnum<["throw", "end"]>>;
-}, "strip", z.ZodTypeAny, {
-  threadLimit?: number | undefined;
-  runLimit?: number | undefined;
-  exitBehavior?: "end" | "throw" | undefined;
-}, {
-  threadLimit?: number | undefined;
-  runLimit?: number | undefined;
-  exitBehavior?: "end" | "throw" | undefined;
-}>, any>;
-//#endregion
-export { ModelCallLimitMiddlewareConfig, modelCallLimitMiddleware };
-//# sourceMappingURL=callLimit.d.ts.map

package/dist/agents/middleware/callLimit.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"callLimit.d.ts","names":["z","InferInteropZodInput","contextSchema","ZodNumber","ZodOptional","ZodEnum","ZodTypeAny","ZodObject","ModelCallLimitMiddlewareConfig","Partial","modelCallLimitMiddleware","__types_js10","AgentMiddleware"],"sources":["../../../src/agents/middleware/callLimit.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\ndeclare const contextSchema: z.ZodObject<{\n    /**\n     * The maximum number of model calls allowed per thread.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The maximum number of model calls allowed per run.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The behavior to take when the limit is exceeded.\n     * - \"throw\" will throw an error and stop the agent.\n     * - \"end\" will end the agent.\n     * @default \"end\"\n     */\n    exitBehavior: z.ZodOptional<z.ZodEnum<[\"throw\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}>;\nexport type ModelCallLimitMiddlewareConfig = Partial<InferInteropZodInput<typeof contextSchema>>;\n/**\n * Creates a middleware to limit the number of model calls at both thread and run levels.\n *\n * This middleware helps prevent excessive model API calls by enforcing limits on how many\n * times the model can be invoked. It supports two types of limits:\n *\n * - **Thread-level limit**: Restricts the total number of model calls across an entire conversation thread\n * - **Run-level limit**: Restricts the number of model calls within a single agent run/invocation\n *\n * ## How It Works\n *\n * The middleware intercepts model requests before they are sent and checks the current call counts\n * against the configured limits. If either limit is exceeded, it throws a `ModelCallLimitMiddlewareError`\n * to stop execution and prevent further API calls.\n *\n * ## Use Cases\n *\n * - **Cost Control**: Prevent runaway costs from excessive model calls in production\n * - **Testing**: Ensure agents don't make too many calls during development/testing\n * - **Safety**: Limit potential infinite loops or recursive agent behaviors\n * - **Rate Limiting**: Enforce organizational policies on model usage per conversation\n *\n * @param middlewareOptions - Configuration options for the call limits\n * @param middlewareOptions.threadLimit - Maximum number of model calls allowed per thread (optional)\n * @param middlewareOptions.runLimit - Maximum number of model calls allowed per run (optional)\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @throws {ModelCallLimitMiddlewareError} When either the thread or run limit is exceeded\n *\n * @example\n * ```typescript\n * import { createAgent, modelCallLimitMiddleware } from \"langchain\";\n *\n * // Limit to 10 calls per thread and 3 calls per run\n * const agent = createAgent({\n *   model: \"openai:gpt-4o-mini\",\n *   tools: [myTool],\n *   middleware: [\n *     modelCallLimitMiddleware({\n *       threadLimit: 10,\n *       runLimit: 3\n *     })\n *   ]\n * });\n * ```\n *\n * @example\n * ```typescript\n * // Limits can also be configured at runtime via context\n * const result = await agent.invoke(\n *   { messages: [\"Hello\"] },\n *   {\n *     configurable: {\n *       threadLimit: 5  // Override the default limit for this run\n *     }\n *   }\n * );\n * ```\n */\nexport declare function modelCallLimitMiddleware(middlewareOptions?: ModelCallLimitMiddlewareConfig): import(\"./types.js\").AgentMiddleware<undefined, z.ZodObject<{\n    /**\n     * The maximum number of model calls allowed per thread.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The maximum number of model calls allowed per run.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The behavior to take when the limit is exceeded.\n     * - \"throw\" will throw an error and stop the agent.\n     * - \"end\" will end the agent.\n     * @default \"end\"\n     */\n    exitBehavior: z.ZodOptional<z.ZodEnum<[\"throw\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}>, any>;\nexport {};\n"],"mappings":";;;;;cAEcE,eAAeF,CAAAA,CAAEO;;;AADoC;EAyBjE,WAAA,EApBeP,CAAAA,CAAEI,WAoBjB,CApB6BJ,CAAAA,CAAEG,SAoB/B,CAAA;EAAA;;;EAhBqC,QAAvBC,EAAFJ,CAAAA,CAAEI,WAAAA,CAAYJ,CAAAA,CAAEG,SAAdC,CAAAA;EAAW;;;;AARa;AAyBxC;EAA0C,YAAA,EAVxBJ,CAAAA,CAAEI,WAUsB,CAVVJ,CAAAA,CAAEK,OAUQ,CAAA,CAAA,OAAA,EAAA,KAAA,CAAA,CAAA,CAAA;CAAA,EAAA,OAAuCH,EATrEF,CAAAA,CAAEM,UASmEJ,EAAAA;EAAa,WAAzCD,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAoB,QAA5BQ,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAO,YAAA,CAAA,EAAA,KAAA,GAAA,OAAA,GAAA,SAAA;AA6DpD,CAAA,EAAA;EAAgD,WAAA,CAAA,EAAA,MAAA,GAAA,SAAA;EAAA,QAAqBD,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAA8B,YAIlEL,CAAAA,EAAAA,KAAAA,GAAAA,OAAAA,GAAAA,SAAAA;CAAS,CAAA;AAIdH,KArEhBQ,8BAAAA,GAAiCC,OAqEfN,CArEuBF,oBAqEvBE,CAAAA,OArEmDD,aAqEnDC,CAAAA,CAAAA;;;;;;;AAR4G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAlHO,wBAAAA,qBAA6CF,iCAA4F,2BAAXR,CAAAA,CAAEO;;;;eAIvIP,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;;;;YAInBH,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;;;;;;;gBAOZH,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEK;YACtBL,CAAAA,CAAEM"}

package/dist/agents/middleware/callLimit.js

@@ -1,129 +0,0 @@
-import { createMiddleware } from "../middleware.js";
-import { AIMessage } from "@langchain/core/messages";
-import { z } from "zod/v3";
-
-//#region src/agents/middleware/callLimit.ts
-const DEFAULT_EXIT_BEHAVIOR = "end";
-const contextSchema = z.object({
-	threadLimit: z.number().optional(),
-	runLimit: z.number().optional(),
-	exitBehavior: z.enum(["throw", "end"]).optional()
-});
-/**
-* Error thrown when the model call limit is exceeded.
-*
-* @param threadLimit - The maximum number of model calls allowed per thread.
-* @param runLimit - The maximum number of model calls allowed per run.
-* @param threadCount - The number of model calls made at the thread level.
-* @param runCount - The number of model calls made at the run level.
-*/
-var ModelCallLimitMiddlewareError = class extends Error {
-	constructor({ threadLimit, runLimit, threadCount, runCount }) {
-		const exceededHint = [];
-		if (typeof threadLimit === "number" && typeof threadCount === "number") exceededHint.push(`thread level call limit reached with ${threadCount} model calls`);
-		if (typeof runLimit === "number" && typeof runCount === "number") exceededHint.push(`run level call limit reached with ${runCount} model calls`);
-		super(`Model call limits exceeded${exceededHint.length > 0 ? `: ${exceededHint.join(", ")}` : ""}`);
-		this.name = "ModelCallLimitMiddlewareError";
-	}
-};
-/**
-* Creates a middleware to limit the number of model calls at both thread and run levels.
-*
-* This middleware helps prevent excessive model API calls by enforcing limits on how many
-* times the model can be invoked. It supports two types of limits:
-*
-* - **Thread-level limit**: Restricts the total number of model calls across an entire conversation thread
-* - **Run-level limit**: Restricts the number of model calls within a single agent run/invocation
-*
-* ## How It Works
-*
-* The middleware intercepts model requests before they are sent and checks the current call counts
-* against the configured limits. If either limit is exceeded, it throws a `ModelCallLimitMiddlewareError`
-* to stop execution and prevent further API calls.
-*
-* ## Use Cases
-*
-* - **Cost Control**: Prevent runaway costs from excessive model calls in production
-* - **Testing**: Ensure agents don't make too many calls during development/testing
-* - **Safety**: Limit potential infinite loops or recursive agent behaviors
-* - **Rate Limiting**: Enforce organizational policies on model usage per conversation
-*
-* @param middlewareOptions - Configuration options for the call limits
-* @param middlewareOptions.threadLimit - Maximum number of model calls allowed per thread (optional)
-* @param middlewareOptions.runLimit - Maximum number of model calls allowed per run (optional)
-*
-* @returns A middleware instance that can be passed to `createAgent`
-*
-* @throws {ModelCallLimitMiddlewareError} When either the thread or run limit is exceeded
-*
-* @example
-* ```typescript
-* import { createAgent, modelCallLimitMiddleware } from "langchain";
-*
-* // Limit to 10 calls per thread and 3 calls per run
-* const agent = createAgent({
-*   model: "openai:gpt-4o-mini",
-*   tools: [myTool],
-*   middleware: [
-*     modelCallLimitMiddleware({
-*       threadLimit: 10,
-*       runLimit: 3
-*     })
-*   ]
-* });
-* ```
-*
-* @example
-* ```typescript
-* // Limits can also be configured at runtime via context
-* const result = await agent.invoke(
-*   { messages: ["Hello"] },
-*   {
-*     configurable: {
-*       threadLimit: 5  // Override the default limit for this run
-*     }
-*   }
-* );
-* ```
-*/
-function modelCallLimitMiddleware(middlewareOptions) {
-	return createMiddleware({
-		name: "ModelCallLimitMiddleware",
-		contextSchema,
-		beforeModel: {
-			canJumpTo: ["end"],
-			hook: (state, runtime) => {
-				const exitBehavior = runtime.context.exitBehavior ?? middlewareOptions?.exitBehavior ?? DEFAULT_EXIT_BEHAVIOR;
-				const threadLimit = runtime.context.threadLimit ?? middlewareOptions?.threadLimit;
-				const runLimit = runtime.context.runLimit ?? middlewareOptions?.runLimit;
-				if (typeof threadLimit === "number" && threadLimit <= runtime.threadLevelCallCount) {
-					const error = new ModelCallLimitMiddlewareError({
-						threadLimit,
-						threadCount: runtime.threadLevelCallCount
-					});
-					if (exitBehavior === "end") return {
-						jumpTo: "end",
-						messages: [new AIMessage(error.message)]
-					};
-					throw error;
-				}
-				if (typeof runLimit === "number" && runLimit <= runtime.runModelCallCount) {
-					const error = new ModelCallLimitMiddlewareError({
-						runLimit,
-						runCount: runtime.runModelCallCount
-					});
-					if (exitBehavior === "end") return {
-						jumpTo: "end",
-						messages: [new AIMessage(error.message)]
-					};
-					throw error;
-				}
-				return state;
-			}
-		}
-	});
-}
-
-//#endregion
-export { modelCallLimitMiddleware };
-//# sourceMappingURL=callLimit.js.map

package/dist/agents/middleware/callLimit.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"callLimit.js","names":["exceededHint: string[]","middlewareOptions?: ModelCallLimitMiddlewareConfig"],"sources":["../../../src/agents/middleware/callLimit.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { AIMessage } from \"@langchain/core/messages\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\n\nimport { createMiddleware } from \"../middleware.js\";\n\nconst DEFAULT_EXIT_BEHAVIOR = \"end\";\n\nconst contextSchema = z.object({\n  /**\n   * The maximum number of model calls allowed per thread.\n   */\n  threadLimit: z.number().optional(),\n  /**\n   * The maximum number of model calls allowed per run.\n   */\n  runLimit: z.number().optional(),\n  /**\n   * The behavior to take when the limit is exceeded.\n   * - \"throw\" will throw an error and stop the agent.\n   * - \"end\" will end the agent.\n   * @default \"end\"\n   */\n  exitBehavior: z.enum([\"throw\", \"end\"]).optional(),\n});\nexport type ModelCallLimitMiddlewareConfig = Partial<\n  InferInteropZodInput<typeof contextSchema>\n>;\n\n/**\n * Error thrown when the model call limit is exceeded.\n *\n * @param threadLimit - The maximum number of model calls allowed per thread.\n * @param runLimit - The maximum number of model calls allowed per run.\n * @param threadCount - The number of model calls made at the thread level.\n * @param runCount - The number of model calls made at the run level.\n */\nclass ModelCallLimitMiddlewareError extends Error {\n  constructor({\n    threadLimit,\n    runLimit,\n    threadCount,\n    runCount,\n  }: {\n    threadLimit?: number;\n    runLimit?: number;\n    threadCount?: number;\n    runCount?: number;\n  }) {\n    const exceededHint: string[] = [];\n    if (typeof threadLimit === \"number\" && typeof threadCount === \"number\") {\n      exceededHint.push(\n        `thread level call limit reached with ${threadCount} model calls`\n      );\n    }\n    if (typeof runLimit === \"number\" && typeof runCount === \"number\") {\n      exceededHint.push(\n        `run level call limit reached with ${runCount} model calls`\n      );\n    }\n    super(\n      `Model call limits exceeded${\n        exceededHint.length > 0 ? `: ${exceededHint.join(\", \")}` : \"\"\n      }`\n    );\n    this.name = \"ModelCallLimitMiddlewareError\";\n  }\n}\n\n/**\n * Creates a middleware to limit the number of model calls at both thread and run levels.\n *\n * This middleware helps prevent excessive model API calls by enforcing limits on how many\n * times the model can be invoked. It supports two types of limits:\n *\n * - **Thread-level limit**: Restricts the total number of model calls across an entire conversation thread\n * - **Run-level limit**: Restricts the number of model calls within a single agent run/invocation\n *\n * ## How It Works\n *\n * The middleware intercepts model requests before they are sent and checks the current call counts\n * against the configured limits. If either limit is exceeded, it throws a `ModelCallLimitMiddlewareError`\n * to stop execution and prevent further API calls.\n *\n * ## Use Cases\n *\n * - **Cost Control**: Prevent runaway costs from excessive model calls in production\n * - **Testing**: Ensure agents don't make too many calls during development/testing\n * - **Safety**: Limit potential infinite loops or recursive agent behaviors\n * - **Rate Limiting**: Enforce organizational policies on model usage per conversation\n *\n * @param middlewareOptions - Configuration options for the call limits\n * @param middlewareOptions.threadLimit - Maximum number of model calls allowed per thread (optional)\n * @param middlewareOptions.runLimit - Maximum number of model calls allowed per run (optional)\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @throws {ModelCallLimitMiddlewareError} When either the thread or run limit is exceeded\n *\n * @example\n * ```typescript\n * import { createAgent, modelCallLimitMiddleware } from \"langchain\";\n *\n * // Limit to 10 calls per thread and 3 calls per run\n * const agent = createAgent({\n *   model: \"openai:gpt-4o-mini\",\n *   tools: [myTool],\n *   middleware: [\n *     modelCallLimitMiddleware({\n *       threadLimit: 10,\n *       runLimit: 3\n *     })\n *   ]\n * });\n * ```\n *\n * @example\n * ```typescript\n * // Limits can also be configured at runtime via context\n * const result = await agent.invoke(\n *   { messages: [\"Hello\"] },\n *   {\n *     configurable: {\n *       threadLimit: 5  // Override the default limit for this run\n *     }\n *   }\n * );\n * ```\n */\nexport function modelCallLimitMiddleware(\n  middlewareOptions?: ModelCallLimitMiddlewareConfig\n) {\n  return createMiddleware({\n    name: \"ModelCallLimitMiddleware\",\n    contextSchema,\n    beforeModel: {\n      canJumpTo: [\"end\"],\n      hook: (state, runtime) => {\n        const exitBehavior =\n          runtime.context.exitBehavior ??\n          middlewareOptions?.exitBehavior ??\n          DEFAULT_EXIT_BEHAVIOR;\n        const threadLimit =\n          runtime.context.threadLimit ?? middlewareOptions?.threadLimit;\n        const runLimit =\n          runtime.context.runLimit ?? middlewareOptions?.runLimit;\n\n        if (\n          typeof threadLimit === \"number\" &&\n          threadLimit <= runtime.threadLevelCallCount\n        ) {\n          const error = new ModelCallLimitMiddlewareError({\n            threadLimit,\n            threadCount: runtime.threadLevelCallCount,\n          });\n          if (exitBehavior === \"end\") {\n            return {\n              jumpTo: \"end\",\n              messages: [new AIMessage(error.message)],\n            };\n          }\n\n          throw error;\n        }\n        if (\n          typeof runLimit === \"number\" &&\n          runLimit <= runtime.runModelCallCount\n        ) {\n          const error = new ModelCallLimitMiddlewareError({\n            runLimit,\n            runCount: runtime.runModelCallCount,\n          });\n          if (exitBehavior === \"end\") {\n            return {\n              jumpTo: \"end\",\n              messages: [new AIMessage(error.message)],\n            };\n          }\n\n          throw error;\n        }\n\n        return state;\n      },\n    },\n  });\n}\n"],"mappings":";;;;;AAMA,MAAM,wBAAwB;AAE9B,MAAM,gBAAgB,EAAE,OAAO;CAI7B,aAAa,EAAE,QAAQ,CAAC,UAAU;CAIlC,UAAU,EAAE,QAAQ,CAAC,UAAU;CAO/B,cAAc,EAAE,KAAK,CAAC,SAAS,KAAM,EAAC,CAAC,UAAU;AAClD,EAAC;;;;;;;;;AAaF,IAAM,gCAAN,cAA4C,MAAM;CAChD,YAAY,EACV,aACA,UACA,aACA,UAMD,EAAE;EACD,MAAMA,eAAyB,CAAE;AACjC,MAAI,OAAO,gBAAgB,YAAY,OAAO,gBAAgB,UAC5D,aAAa,KACX,CAAC,qCAAqC,EAAE,YAAY,YAAY,CAAC,CAClE;AAEH,MAAI,OAAO,aAAa,YAAY,OAAO,aAAa,UACtD,aAAa,KACX,CAAC,kCAAkC,EAAE,SAAS,YAAY,CAAC,CAC5D;EAEH,MACE,CAAC,0BAA0B,EACzB,aAAa,SAAS,IAAI,CAAC,EAAE,EAAE,aAAa,KAAK,KAAK,EAAE,GAAG,IAC3D,CACH;EACD,KAAK,OAAO;CACb;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8DD,SAAgB,yBACdC,mBACA;AACA,QAAO,iBAAiB;EACtB,MAAM;EACN;EACA,aAAa;GACX,WAAW,CAAC,KAAM;GAClB,MAAM,CAAC,OAAO,YAAY;IACxB,MAAM,eACJ,QAAQ,QAAQ,gBAChB,mBAAmB,gBACnB;IACF,MAAM,cACJ,QAAQ,QAAQ,eAAe,mBAAmB;IACpD,MAAM,WACJ,QAAQ,QAAQ,YAAY,mBAAmB;AAEjD,QACE,OAAO,gBAAgB,YACvB,eAAe,QAAQ,sBACvB;KACA,MAAM,QAAQ,IAAI,8BAA8B;MAC9C;MACA,aAAa,QAAQ;KACtB;AACD,SAAI,iBAAiB,MACnB,QAAO;MACL,QAAQ;MACR,UAAU,CAAC,IAAI,UAAU,MAAM,QAAS;KACzC;AAGH,WAAM;IACP;AACD,QACE,OAAO,aAAa,YACpB,YAAY,QAAQ,mBACpB;KACA,MAAM,QAAQ,IAAI,8BAA8B;MAC9C;MACA,UAAU,QAAQ;KACnB;AACD,SAAI,iBAAiB,MACnB,QAAO;MACL,QAAQ;MACR,UAAU,CAAC,IAAI,UAAU,MAAM,QAAS;KACzC;AAGH,WAAM;IACP;AAED,WAAO;GACR;EACF;CACF,EAAC;AACH"}

package/dist/agents/middleware/index.d.cts

@@ -1,15 +0,0 @@
-import { AgentMiddleware } from "./types.cjs";
-import { SummarizationMiddlewareConfig, summarizationMiddleware } from "./summarization.cjs";
-import { Action, ActionRequest, ApproveDecision, Decision, DecisionType, DescriptionFactory, EditDecision, HITLRequest, HITLResponse, HumanInTheLoopMiddlewareConfig, InterruptOnConfig, RejectDecision, ReviewConfig, humanInTheLoopMiddleware } from "./hitl.cjs";
-import { PromptCachingMiddlewareConfig, anthropicPromptCachingMiddleware } from "./promptCaching.cjs";
-import { DynamicSystemPromptMiddlewareConfig, dynamicSystemPromptMiddleware } from "./dynamicSystemPrompt.cjs";
-import { LLMToolSelectorConfig, llmToolSelectorMiddleware } from "./llmToolSelector.cjs";
-import { PIIRedactionMiddlewareConfig, piiRedactionMiddleware } from "./piiRedaction.cjs";
-import { ClearToolUsesEdit, ClearToolUsesEditConfig, ContextEdit, ContextEditingMiddlewareConfig, TokenCounter, contextEditingMiddleware } from "./contextEditing.cjs";
-import { ToolCallLimitConfig, ToolCallLimitExceededError, toolCallLimitMiddleware } from "./toolCallLimit.cjs";
-import { TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT, TodoListMiddlewareOptions, todoListMiddleware } from "./todoListMiddleware.cjs";
-import { modelFallbackMiddleware } from "./modelFallback.cjs";
-import { ToolRetryMiddlewareConfig, toolRetryMiddleware } from "./toolRetry.cjs";
-import { countTokensApproximately } from "./utils.cjs";
-import { ModelCallLimitMiddlewareConfig, modelCallLimitMiddleware } from "./modelCallLimit.js";
-export { type ModelCallLimitMiddlewareConfig, modelCallLimitMiddleware };

package/dist/agents/middleware/index.d.ts

@@ -1,14 +0,0 @@
-import { AgentMiddleware } from "./types.js";
-import { SummarizationMiddlewareConfig, summarizationMiddleware } from "./summarization.js";
-import { Action, ActionRequest, ApproveDecision, Decision, DecisionType, DescriptionFactory, EditDecision, HITLRequest, HITLResponse, HumanInTheLoopMiddlewareConfig, InterruptOnConfig, RejectDecision, ReviewConfig, humanInTheLoopMiddleware } from "./hitl.js";
-import { PromptCachingMiddlewareConfig, anthropicPromptCachingMiddleware } from "./promptCaching.js";
-import { DynamicSystemPromptMiddlewareConfig, dynamicSystemPromptMiddleware } from "./dynamicSystemPrompt.js";
-import { LLMToolSelectorConfig, llmToolSelectorMiddleware } from "./llmToolSelector.js";
-import { PIIRedactionMiddlewareConfig, piiRedactionMiddleware } from "./piiRedaction.js";
-import { ClearToolUsesEdit, ClearToolUsesEditConfig, ContextEdit, ContextEditingMiddlewareConfig, TokenCounter, contextEditingMiddleware } from "./contextEditing.js";
-import { ToolCallLimitConfig, ToolCallLimitExceededError, toolCallLimitMiddleware } from "./toolCallLimit.js";
-import { TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT, TodoListMiddlewareOptions, todoListMiddleware } from "./todoListMiddleware.js";
-import { ModelCallLimitMiddlewareConfig, modelCallLimitMiddleware } from "./modelCallLimit.js";
-import { modelFallbackMiddleware } from "./modelFallback.js";
-import { ToolRetryMiddlewareConfig, toolRetryMiddleware } from "./toolRetry.js";
-import { countTokensApproximately } from "./utils.js";

package/dist/agents/tools.d.cts

@@ -1,9 +0,0 @@
-import { RunnableToolLike } from "@langchain/core/runnables";
-import { DynamicTool, StructuredToolInterface } from "@langchain/core/tools";
-
-//#region src/agents/tools.d.ts
-type ServerTool = Record<string, unknown>;
-type ClientTool = StructuredToolInterface | DynamicTool | RunnableToolLike;
-//#endregion
-export { ClientTool, ServerTool };
-//# sourceMappingURL=tools.d.cts.map

package/dist/agents/tools.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tools.d.cts","names":["StructuredToolInterface","DynamicTool","RunnableToolLike","ServerTool","Record","ClientTool"],"sources":["../../src/agents/tools.d.ts"],"sourcesContent":["import type { StructuredToolInterface, DynamicTool } from \"@langchain/core/tools\";\nimport type { RunnableToolLike } from \"@langchain/core/runnables\";\nexport type ServerTool = Record<string, unknown>;\nexport type ClientTool = StructuredToolInterface | DynamicTool | RunnableToolLike;\n"],"mappings":";;;;KAEYG,UAAAA,GAAaC;KACbC,UAAAA,GAAaL,0BAA0BC,cAAcC"}

package/dist/agents/tools.d.ts

@@ -1,9 +0,0 @@
-import { RunnableToolLike } from "@langchain/core/runnables";
-import { DynamicTool, StructuredToolInterface } from "@langchain/core/tools";
-
-//#region src/agents/tools.d.ts
-type ServerTool = Record<string, unknown>;
-type ClientTool = StructuredToolInterface | DynamicTool | RunnableToolLike;
-//#endregion
-export { ClientTool, ServerTool };
-//# sourceMappingURL=tools.d.ts.map

package/dist/agents/tools.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tools.d.ts","names":["StructuredToolInterface","DynamicTool","RunnableToolLike","ServerTool","Record","ClientTool"],"sources":["../../src/agents/tools.d.ts"],"sourcesContent":["import type { StructuredToolInterface, DynamicTool } from \"@langchain/core/tools\";\nimport type { RunnableToolLike } from \"@langchain/core/runnables\";\nexport type ServerTool = Record<string, unknown>;\nexport type ClientTool = StructuredToolInterface | DynamicTool | RunnableToolLike;\n"],"mappings":";;;;KAEYG,UAAAA,GAAaC;KACbC,UAAAA,GAAaL,0BAA0BC,cAAcC"}

package/dist/embeddings/cache_backed.cjs

@@ -1,140 +0,0 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
-const require_storage_encoder_backed = require('../storage/encoder_backed.cjs');
-const __langchain_core_utils_hash = require_rolldown_runtime.__toESM(require("@langchain/core/utils/hash"));
-const __langchain_core_embeddings = require_rolldown_runtime.__toESM(require("@langchain/core/embeddings"));
-
-//#region src/embeddings/cache_backed.ts
-var cache_backed_exports = {};
-require_rolldown_runtime.__export(cache_backed_exports, { CacheBackedEmbeddings: () => CacheBackedEmbeddings });
-/**
-* Interface for caching results from embedding models.
-*
-* The interface allows works with any store that implements
-* the abstract store interface accepting keys of type str and values of list of
-* floats.
-*
-* If need be, the interface can be extended to accept other implementations
-* of the value serializer and deserializer, as well as the key encoder.
-* @example
-* ```typescript
-* const underlyingEmbeddings = new OpenAIEmbeddings();
-*
-* const cacheBackedEmbeddings = CacheBackedEmbeddings.fromBytesStore(
-*   underlyingEmbeddings,
-*   new ConvexKVStore({ ctx }),
-*   {
-*     namespace: underlyingEmbeddings.modelName,
-*   },
-* );
-*
-* const loader = new TextLoader("./state_of_the_union.txt");
-* const rawDocuments = await loader.load();
-* const splitter = new RecursiveCharacterTextSplitter({
-*   chunkSize: 1000,
-*   chunkOverlap: 0,
-* });
-* const documents = await splitter.splitDocuments(rawDocuments);
-*
-* let time = Date.now();
-* const vectorstore = await ConvexVectorStore.fromDocuments(
-*   documents,
-*   cacheBackedEmbeddings,
-*   { ctx },
-* );
-* console.log(`Initial creation time: ${Date.now() - time}ms`);
-*
-* time = Date.now();
-* const vectorstore2 = await ConvexVectorStore.fromDocuments(
-*   documents,
-*   cacheBackedEmbeddings,
-*   { ctx },
-* );
-* console.log(`Cached creation time: ${Date.now() - time}ms`);
-*
-* ```
-*/
-var CacheBackedEmbeddings = class extends __langchain_core_embeddings.Embeddings {
-	underlyingEmbeddings;
-	documentEmbeddingStore;
-	constructor(fields) {
-		super(fields);
-		this.underlyingEmbeddings = fields.underlyingEmbeddings;
-		this.documentEmbeddingStore = fields.documentEmbeddingStore;
-	}
-	/**
-	* Embed query text.
-	*
-	* This method does not support caching at the moment.
-	*
-	* Support for caching queries is easy to implement, but might make
-	* sense to hold off to see the most common patterns.
-	*
-	* If the cache has an eviction policy, we may need to be a bit more careful
-	* about sharing the cache between documents and queries. Generally,
-	* one is OK evicting query caches, but document caches should be kept.
-	*
-	* @param document The text to embed.
-	* @returns The embedding for the given text.
-	*/
-	async embedQuery(document) {
-		return this.underlyingEmbeddings.embedQuery(document);
-	}
-	/**
-	* Embed a list of texts.
-	*
-	* The method first checks the cache for the embeddings.
-	* If the embeddings are not found, the method uses the underlying embedder
-	* to embed the documents and stores the results in the cache.
-	*
-	* @param documents
-	* @returns A list of embeddings for the given texts.
-	*/
-	async embedDocuments(documents) {
-		const vectors = await this.documentEmbeddingStore.mget(documents);
-		const missingIndicies = [];
-		const missingDocuments = [];
-		for (let i = 0; i < vectors.length; i += 1) if (vectors[i] === void 0) {
-			missingIndicies.push(i);
-			missingDocuments.push(documents[i]);
-		}
-		if (missingDocuments.length) {
-			const missingVectors = await this.underlyingEmbeddings.embedDocuments(missingDocuments);
-			const keyValuePairs = missingDocuments.map((document, i) => [document, missingVectors[i]]);
-			await this.documentEmbeddingStore.mset(keyValuePairs);
-			for (let i = 0; i < missingIndicies.length; i += 1) vectors[missingIndicies[i]] = missingVectors[i];
-		}
-		return vectors;
-	}
-	/**
-	* Create a new CacheBackedEmbeddings instance from another embeddings instance
-	* and a storage instance.
-	* @param underlyingEmbeddings Embeddings used to populate the cache for new documents.
-	* @param documentEmbeddingStore Stores raw document embedding values. Keys are hashes of the document content.
-	* @param options.namespace Optional namespace for store keys.
-	* @returns A new CacheBackedEmbeddings instance.
-	*/
-	static fromBytesStore(underlyingEmbeddings, documentEmbeddingStore, options) {
-		const encoder = new TextEncoder();
-		const decoder = new TextDecoder();
-		const encoderBackedStore = new require_storage_encoder_backed.EncoderBackedStore({
-			store: documentEmbeddingStore,
-			keyEncoder: (key) => (options?.namespace ?? "") + (0, __langchain_core_utils_hash.sha256)(key),
-			valueSerializer: (value) => encoder.encode(JSON.stringify(value)),
-			valueDeserializer: (serializedValue) => JSON.parse(decoder.decode(serializedValue))
-		});
-		return new this({
-			underlyingEmbeddings,
-			documentEmbeddingStore: encoderBackedStore
-		});
-	}
-};
-
-//#endregion
-exports.CacheBackedEmbeddings = CacheBackedEmbeddings;
-Object.defineProperty(exports, 'cache_backed_exports', {
-  enumerable: true,
-  get: function () {
-    return cache_backed_exports;
-  }
-});
-//# sourceMappingURL=cache_backed.cjs.map

package/dist/embeddings/cache_backed.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache_backed.cjs","names":["Embeddings","fields: CacheBackedEmbeddingsFields","document: string","documents: string[]","keyValuePairs: [string, number[]][]","underlyingEmbeddings: EmbeddingsInterface","documentEmbeddingStore: BaseStore<string, Uint8Array>","options?: {\n      namespace?: string;\n    }","EncoderBackedStore"],"sources":["../../src/embeddings/cache_backed.ts"],"sourcesContent":["import { sha256 } from \"@langchain/core/utils/hash\";\nimport {\n  type EmbeddingsInterface,\n  Embeddings,\n} from \"@langchain/core/embeddings\";\nimport { BaseStore } from \"@langchain/core/stores\";\n\nimport { AsyncCallerParams } from \"@langchain/core/utils/async_caller\";\nimport { EncoderBackedStore } from \"../storage/encoder_backed.js\";\n\n/**\n * Interface for the fields required to initialize an instance of the\n * CacheBackedEmbeddings class.\n */\nexport interface CacheBackedEmbeddingsFields extends AsyncCallerParams {\n  underlyingEmbeddings: EmbeddingsInterface;\n  documentEmbeddingStore: BaseStore<string, number[]>;\n}\n\n/**\n * Interface for caching results from embedding models.\n *\n * The interface allows works with any store that implements\n * the abstract store interface accepting keys of type str and values of list of\n * floats.\n *\n * If need be, the interface can be extended to accept other implementations\n * of the value serializer and deserializer, as well as the key encoder.\n * @example\n * ```typescript\n * const underlyingEmbeddings = new OpenAIEmbeddings();\n *\n * const cacheBackedEmbeddings = CacheBackedEmbeddings.fromBytesStore(\n *   underlyingEmbeddings,\n *   new ConvexKVStore({ ctx }),\n *   {\n *     namespace: underlyingEmbeddings.modelName,\n *   },\n * );\n *\n * const loader = new TextLoader(\"./state_of_the_union.txt\");\n * const rawDocuments = await loader.load();\n * const splitter = new RecursiveCharacterTextSplitter({\n *   chunkSize: 1000,\n *   chunkOverlap: 0,\n * });\n * const documents = await splitter.splitDocuments(rawDocuments);\n *\n * let time = Date.now();\n * const vectorstore = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Initial creation time: ${Date.now() - time}ms`);\n *\n * time = Date.now();\n * const vectorstore2 = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Cached creation time: ${Date.now() - time}ms`);\n *\n * ```\n */\nexport class CacheBackedEmbeddings extends Embeddings {\n  protected underlyingEmbeddings: EmbeddingsInterface;\n\n  protected documentEmbeddingStore: BaseStore<string, number[]>;\n\n  constructor(fields: CacheBackedEmbeddingsFields) {\n    super(fields);\n    this.underlyingEmbeddings = fields.underlyingEmbeddings;\n    this.documentEmbeddingStore = fields.documentEmbeddingStore;\n  }\n\n  /**\n   * Embed query text.\n   *\n   * This method does not support caching at the moment.\n   *\n   * Support for caching queries is easy to implement, but might make\n   * sense to hold off to see the most common patterns.\n   *\n   * If the cache has an eviction policy, we may need to be a bit more careful\n   * about sharing the cache between documents and queries. Generally,\n   * one is OK evicting query caches, but document caches should be kept.\n   *\n   * @param document The text to embed.\n   * @returns The embedding for the given text.\n   */\n  async embedQuery(document: string): Promise<number[]> {\n    return this.underlyingEmbeddings.embedQuery(document);\n  }\n\n  /**\n   * Embed a list of texts.\n   *\n   * The method first checks the cache for the embeddings.\n   * If the embeddings are not found, the method uses the underlying embedder\n   * to embed the documents and stores the results in the cache.\n   *\n   * @param documents\n   * @returns A list of embeddings for the given texts.\n   */\n  async embedDocuments(documents: string[]): Promise<number[][]> {\n    const vectors = await this.documentEmbeddingStore.mget(documents);\n    const missingIndicies = [];\n    const missingDocuments = [];\n    for (let i = 0; i < vectors.length; i += 1) {\n      if (vectors[i] === undefined) {\n        missingIndicies.push(i);\n        missingDocuments.push(documents[i]);\n      }\n    }\n    if (missingDocuments.length) {\n      const missingVectors = await this.underlyingEmbeddings.embedDocuments(\n        missingDocuments\n      );\n      const keyValuePairs: [string, number[]][] = missingDocuments.map(\n        (document, i) => [document, missingVectors[i]]\n      );\n      await this.documentEmbeddingStore.mset(keyValuePairs);\n      for (let i = 0; i < missingIndicies.length; i += 1) {\n        vectors[missingIndicies[i]] = missingVectors[i];\n      }\n    }\n    return vectors as number[][];\n  }\n\n  /**\n   * Create a new CacheBackedEmbeddings instance from another embeddings instance\n   * and a storage instance.\n   * @param underlyingEmbeddings Embeddings used to populate the cache for new documents.\n   * @param documentEmbeddingStore Stores raw document embedding values. Keys are hashes of the document content.\n   * @param options.namespace Optional namespace for store keys.\n   * @returns A new CacheBackedEmbeddings instance.\n   */\n  static fromBytesStore(\n    underlyingEmbeddings: EmbeddingsInterface,\n    documentEmbeddingStore: BaseStore<string, Uint8Array>,\n    options?: {\n      namespace?: string;\n    }\n  ) {\n    const encoder = new TextEncoder();\n    const decoder = new TextDecoder();\n    const encoderBackedStore = new EncoderBackedStore<\n      string,\n      number[],\n      Uint8Array\n    >({\n      store: documentEmbeddingStore,\n      keyEncoder: (key) => (options?.namespace ?? \"\") + sha256(key),\n      valueSerializer: (value) => encoder.encode(JSON.stringify(value)),\n      valueDeserializer: (serializedValue) =>\n        JSON.parse(decoder.decode(serializedValue)),\n    });\n    return new this({\n      underlyingEmbeddings,\n      documentEmbeddingStore: encoderBackedStore,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkEA,IAAa,wBAAb,cAA2CA,uCAAW;CACpD,AAAU;CAEV,AAAU;CAEV,YAAYC,QAAqC;EAC/C,MAAM,OAAO;EACb,KAAK,uBAAuB,OAAO;EACnC,KAAK,yBAAyB,OAAO;CACtC;;;;;;;;;;;;;;;;CAiBD,MAAM,WAAWC,UAAqC;AACpD,SAAO,KAAK,qBAAqB,WAAW,SAAS;CACtD;;;;;;;;;;;CAYD,MAAM,eAAeC,WAA0C;EAC7D,MAAM,UAAU,MAAM,KAAK,uBAAuB,KAAK,UAAU;EACjE,MAAM,kBAAkB,CAAE;EAC1B,MAAM,mBAAmB,CAAE;AAC3B,OAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK,EACvC,KAAI,QAAQ,OAAO,QAAW;GAC5B,gBAAgB,KAAK,EAAE;GACvB,iBAAiB,KAAK,UAAU,GAAG;EACpC;AAEH,MAAI,iBAAiB,QAAQ;GAC3B,MAAM,iBAAiB,MAAM,KAAK,qBAAqB,eACrD,iBACD;GACD,MAAMC,gBAAsC,iBAAiB,IAC3D,CAAC,UAAU,MAAM,CAAC,UAAU,eAAe,EAAG,EAC/C;GACD,MAAM,KAAK,uBAAuB,KAAK,cAAc;AACrD,QAAK,IAAI,IAAI,GAAG,IAAI,gBAAgB,QAAQ,KAAK,GAC/C,QAAQ,gBAAgB,MAAM,eAAe;EAEhD;AACD,SAAO;CACR;;;;;;;;;CAUD,OAAO,eACLC,sBACAC,wBACAC,SAGA;EACA,MAAM,UAAU,IAAI;EACpB,MAAM,UAAU,IAAI;EACpB,MAAM,qBAAqB,IAAIC,kDAI7B;GACA,OAAO;GACP,YAAY,CAAC,SAAS,SAAS,aAAa,8CAAa,IAAI;GAC7D,iBAAiB,CAAC,UAAU,QAAQ,OAAO,KAAK,UAAU,MAAM,CAAC;GACjE,mBAAmB,CAAC,oBAClB,KAAK,MAAM,QAAQ,OAAO,gBAAgB,CAAC;EAC9C;AACD,SAAO,IAAI,KAAK;GACd;GACA,wBAAwB;EACzB;CACF;AACF"}