langchain 1.0.0-alpha.6 → 1.0.0-alpha.8

package/dist/agents/middlewareAgent/middleware/promptCaching.cjs

@@ -6,10 +6,16 @@ const zod_v3 = require_rolldown_runtime.__toESM(require("zod/v3"));
 const DEFAULT_ENABLE_CACHING = true;
 const DEFAULT_TTL = "5m";
 const DEFAULT_MIN_MESSAGES_TO_CACHE = 3;
+const DEFAULT_UNSUPPORTED_MODEL_BEHAVIOR = "warn";
 const contextSchema = zod_v3.z.object({
-	enableCaching: zod_v3.z.boolean().default(DEFAULT_ENABLE_CACHING),
-	ttl: zod_v3.z.enum(["5m", "1h"]).default(DEFAULT_TTL),
-	minMessagesToCache: zod_v3.z.number().default(DEFAULT_MIN_MESSAGES_TO_CACHE)
+	enableCaching: zod_v3.z.boolean().optional(),
+	ttl: zod_v3.z.enum(["5m", "1h"]).optional(),
+	minMessagesToCache: zod_v3.z.number().optional(),
+	unsupportedModelBehavior: zod_v3.z.enum([
+		"ignore",
+		"warn",
+		"raise"
+	]).optional()
 });
 var PromptCachingMiddlewareError = class extends Error {
 	constructor(message) {
@@ -41,6 +47,7 @@ var PromptCachingMiddlewareError = class extends Error {
 * @param middlewareOptions.enableCaching - Whether to enable prompt caching (default: `true`)
 * @param middlewareOptions.ttl - Cache time-to-live: `"5m"` for 5 minutes or `"1h"` for 1 hour (default: `"5m"`)
 * @param middlewareOptions.minMessagesToCache - Minimum number of messages required before caching is applied (default: `3`)
+* @param middlewareOptions.unsupportedModelBehavior - The behavior to take when an unsupported model is used (default: `"warn"`)
 *
 * @returns A middleware instance that can be passed to `createAgent`
 *
@@ -50,7 +57,7 @@ var PromptCachingMiddlewareError = class extends Error {
 * Basic usage with default settings
 * ```typescript
 * import { createAgent } from "langchain";
-* import { anthropicPromptCachingMiddleware } from "langchain/middleware";
+* import { anthropicPromptCachingMiddleware } from "langchain";
 *
 * const agent = createAgent({
 *   model: "anthropic:claude-3-5-sonnet",
@@ -70,7 +77,7 @@ var PromptCachingMiddlewareError = class extends Error {
 *
 * const agent = createAgent({
 *   model: "anthropic:claude-3-5-sonnet",
-*   systemMessage: "You are a helpful assistant with deep knowledge of...", // Long system prompt
+*   systemPrompt: "You are a helpful assistant with deep knowledge of...", // Long system prompt
 *   middleware: [cachingMiddleware]
 * });
 * ```
@@ -104,7 +111,7 @@ var PromptCachingMiddlewareError = class extends Error {
 * ```typescript
 * const supportAgent = createAgent({
 *   model: "anthropic:claude-3-5-sonnet",
-*   systemMessage: `You are a customer support agent for ACME Corp.
+*   systemPrompt: `You are a customer support agent for ACME Corp.
 *
 *     Company policies:
 *     - Always be polite and professional
@@ -138,41 +145,62 @@ function anthropicPromptCachingMiddleware(middlewareOptions) {
 	return require_middleware.createMiddleware({
 		name: "PromptCachingMiddleware",
 		contextSchema,
-		prepareModelRequest: (options, state, runtime) => {
+		modifyModelRequest: (request, state, runtime) => {
 			/**
-			* If the runtime values match the schema default values, use the middleware option
-			* values otherwise use the runtime values. This allows to apply general configurations
-			* for all invocations, and override them for specific invocations.
+			* Prefer runtime context values over middleware options values over defaults
 			*/
-			const enableCaching = runtime.context.enableCaching === DEFAULT_ENABLE_CACHING ? middlewareOptions?.enableCaching ?? runtime.context.enableCaching : runtime.context.enableCaching ?? middlewareOptions?.enableCaching;
-			const ttl = runtime.context.ttl === DEFAULT_TTL ? middlewareOptions?.ttl ?? runtime.context.ttl : runtime.context.ttl ?? middlewareOptions?.ttl;
-			const minMessagesToCache = runtime.context.minMessagesToCache === DEFAULT_MIN_MESSAGES_TO_CACHE ? middlewareOptions?.minMessagesToCache ?? runtime.context.minMessagesToCache : runtime.context.minMessagesToCache ?? middlewareOptions?.minMessagesToCache;
-			if (!enableCaching) return void 0;
-			if (options.model?.getName() !== "ChatAnthropic") throw new Error("Prompt caching is only supported for Anthropic models");
-			const messagesCount = state.messages.length + (options.systemMessage ? 1 : 0);
-			if (messagesCount < minMessagesToCache) return options;
+			const enableCaching = runtime.context.enableCaching ?? middlewareOptions?.enableCaching ?? DEFAULT_ENABLE_CACHING;
+			const ttl = runtime.context.ttl ?? middlewareOptions?.ttl ?? DEFAULT_TTL;
+			const minMessagesToCache = runtime.context.minMessagesToCache ?? middlewareOptions?.minMessagesToCache ?? DEFAULT_MIN_MESSAGES_TO_CACHE;
+			const unsupportedModelBehavior = runtime.context.unsupportedModelBehavior ?? middlewareOptions?.unsupportedModelBehavior ?? DEFAULT_UNSUPPORTED_MODEL_BEHAVIOR;
+			if (!enableCaching || !request.model) return void 0;
+			const isAnthropicModel = request.model.getName() === "ChatAnthropic" || request.model.getName() === "ConfigurableModel" && request.model._defaultConfig?.modelProvider === "anthropic";
+			if (!isAnthropicModel) {
+				const modelName = request.model.getName();
+				const modelInfo = request.model.getName() === "ConfigurableModel" ? `${modelName} (${request.model._defaultConfig?.modelProvider})` : modelName;
+				const baseMessage = `Unsupported model '${modelInfo}'. Prompt caching requires an Anthropic model`;
+				if (unsupportedModelBehavior === "raise") throw new PromptCachingMiddlewareError(`${baseMessage} (e.g., 'anthropic:claude-4-0-sonnet').`);
+				else if (unsupportedModelBehavior === "warn") console.warn(`PromptCachingMiddleware: Skipping caching for ${modelName}. Consider switching to an Anthropic model for caching benefits.`);
+				return void 0;
+			}
+			const messagesCount = state.messages.length + (request.systemPrompt ? 1 : 0);
+			if (messagesCount < minMessagesToCache) return request;
 			/**
 			* Add cache_control to the last message
 			*/
-			const lastMessage = options.messages.at(-1);
-			if (!lastMessage) return options;
-			if (Array.isArray(lastMessage.content)) lastMessage.content = [...lastMessage.content.slice(0, -1), {
-				...lastMessage.content.at(-1),
-				cache_control: {
-					type: "ephemeral",
-					ttl
-				}
-			}];
-			else if (typeof lastMessage.content === "string") lastMessage.content = [{
-				type: "text",
-				text: lastMessage.content,
-				cache_control: {
-					type: "ephemeral",
-					ttl
-				}
-			}];
-			else throw new PromptCachingMiddlewareError("Last message content is not a string or array");
-			return options;
+			const lastMessage = request.messages.at(-1);
+			if (!lastMessage) return request;
+			const NewMessageConstructor = Object.getPrototypeOf(lastMessage).constructor;
+			if (Array.isArray(lastMessage.content)) {
+				const newMessage = new NewMessageConstructor({
+					...lastMessage,
+					content: [...lastMessage.content.slice(0, -1), {
+						...lastMessage.content.at(-1),
+						cache_control: {
+							type: "ephemeral",
+							ttl
+						}
+					}]
+				});
+				return {
+					...request,
+					messages: [...request.messages.slice(0, -1), newMessage]
+				};
+			} else if (typeof lastMessage.content === "string") {
+				const newMessage = new NewMessageConstructor({ content: [{
+					type: "text",
+					text: lastMessage.content,
+					cache_control: {
+						type: "ephemeral",
+						ttl
+					}
+				}] });
+				return {
+					...request,
+					messages: [...request.messages.slice(0, -1), newMessage]
+				};
+			}
+			throw new PromptCachingMiddlewareError("Last message content is not a string or array");
 		}
 	});
 }

package/dist/agents/middlewareAgent/middleware/promptCaching.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"promptCaching.cjs","names":["z","message: string","middlewareOptions?: Partial<z.infer<typeof contextSchema>>","createMiddleware"],"sources":["../../../../src/agents/middlewareAgent/middleware/promptCaching.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { ContentBlock } from \"@langchain/core/messages\";\nimport { createMiddleware } from \"../middleware.js\";\n\nconst DEFAULT_ENABLE_CACHING = true;\nconst DEFAULT_TTL = \"5m\";\nconst DEFAULT_MIN_MESSAGES_TO_CACHE = 3;\n\nconst contextSchema = z.object({\n  // Configuration options\n  enableCaching: z.boolean().default(DEFAULT_ENABLE_CACHING),\n  ttl: z.enum([\"5m\", \"1h\"]).default(DEFAULT_TTL),\n  minMessagesToCache: z.number().default(DEFAULT_MIN_MESSAGES_TO_CACHE),\n});\n\nclass PromptCachingMiddlewareError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"PromptCachingMiddlewareError\";\n  }\n}\n\n/**\n * Creates a prompt caching middleware for Anthropic models to optimize API usage.\n *\n * This middleware automatically adds cache control headers to the last messages when using Anthropic models,\n * enabling their prompt caching feature. This can significantly reduce costs for applications with repetitive\n * prompts, long system messages, or extensive conversation histories.\n *\n * ## How It Works\n *\n * The middleware intercepts model requests and adds cache control metadata that tells Anthropic's\n * API to cache processed prompt prefixes. On subsequent requests with matching prefixes, the\n * cached representations are reused, skipping redundant token processing.\n *\n * ## Benefits\n *\n * - **Cost Reduction**: Avoid reprocessing the same tokens repeatedly (up to 90% savings on cached portions)\n * - **Lower Latency**: Cached prompts are processed faster as embeddings are pre-computed\n * - **Better Scalability**: Reduced computational load enables handling more requests\n * - **Consistent Performance**: Stable response times for repetitive queries\n *\n * @param middlewareOptions - Configuration options for the caching behavior\n * @param middlewareOptions.enableCaching - Whether to enable prompt caching (default: `true`)\n * @param middlewareOptions.ttl - Cache time-to-live: `\"5m\"` for 5 minutes or `\"1h\"` for 1 hour (default: `\"5m\"`)\n * @param middlewareOptions.minMessagesToCache - Minimum number of messages required before caching is applied (default: `3`)\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @throws {Error} If used with non-Anthropic models\n *\n * @example\n * Basic usage with default settings\n * ```typescript\n * import { createAgent } from \"langchain\";\n * import { anthropicPromptCachingMiddleware } from \"langchain/middleware\";\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   middleware: [\n *     anthropicPromptCachingMiddleware()\n *   ]\n * });\n * ```\n *\n * @example\n * Custom configuration for longer conversations\n * ```typescript\n * const cachingMiddleware = anthropicPromptCachingMiddleware({\n *   ttl: \"1h\",  // Cache for 1 hour instead of default 5 minutes\n *   minMessagesToCache: 5  // Only cache after 5 messages\n * });\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   systemMessage: \"You are a helpful assistant with deep knowledge of...\", // Long system prompt\n *   middleware: [cachingMiddleware]\n * });\n * ```\n *\n * @example\n * Conditional caching based on runtime context\n * ```typescript\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   middleware: [\n *     anthropicPromptCachingMiddleware({\n *       enableCaching: true,\n *       ttl: \"5m\"\n *     })\n *   ]\n * });\n *\n * // Disable caching for specific requests\n * await agent.invoke(\n *   { messages: [new HumanMessage(\"Process this without caching\")] },\n *   {\n *     configurable: {\n *       middleware_context: { enableCaching: false }\n *     }\n *   }\n * );\n * ```\n *\n * @example\n * Optimal setup for customer support chatbot\n * ```typescript\n * const supportAgent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   systemMessage: `You are a customer support agent for ACME Corp.\n *\n *     Company policies:\n *     - Always be polite and professional\n *     - Refer to knowledge base for product information\n *     - Escalate billing issues to human agents\n *     ... (extensive policies and guidelines)\n *   `,\n *   tools: [searchKnowledgeBase, createTicket, checkOrderStatus],\n *   middleware: [\n *     anthropicPromptCachingMiddleware({\n *       ttl: \"1h\",  // Long TTL for stable system prompt\n *       minMessagesToCache: 1  // Cache immediately due to large system prompt\n *     })\n *   ]\n * });\n * ```\n *\n * @remarks\n * - **Anthropic Only**: This middleware only works with Anthropic models and will throw an error if used with other providers\n * - **Automatic Application**: Caching is applied automatically when message count exceeds `minMessagesToCache`\n * - **Cache Scope**: Caches are isolated per API key and cannot be shared across different keys\n * - **TTL Options**: Only supports \"5m\" (5 minutes) and \"1h\" (1 hour) as TTL values per Anthropic's API\n * - **Best Use Cases**: Long system prompts, multi-turn conversations, repetitive queries, RAG applications\n * - **Cost Impact**: Cached tokens are billed at 10% of the base input token price, cache writes are billed at 25% of the base\n *\n * @see {@link createAgent} for agent creation\n * @see {@link https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching} Anthropic's prompt caching documentation\n * @public\n */\nexport function anthropicPromptCachingMiddleware(\n  middlewareOptions?: Partial<z.infer<typeof contextSchema>>\n) {\n  return createMiddleware({\n    name: \"PromptCachingMiddleware\",\n    contextSchema,\n    prepareModelRequest: (options, state, runtime) => {\n      /**\n       * If the runtime values match the schema default values, use the middleware option\n       * values otherwise use the runtime values. This allows to apply general configurations\n       * for all invocations, and override them for specific invocations.\n       */\n      const enableCaching =\n        runtime.context.enableCaching === DEFAULT_ENABLE_CACHING\n          ? middlewareOptions?.enableCaching ?? runtime.context.enableCaching\n          : runtime.context.enableCaching ?? middlewareOptions?.enableCaching;\n      const ttl =\n        runtime.context.ttl === DEFAULT_TTL\n          ? middlewareOptions?.ttl ?? runtime.context.ttl\n          : runtime.context.ttl ?? middlewareOptions?.ttl;\n      const minMessagesToCache =\n        runtime.context.minMessagesToCache === DEFAULT_MIN_MESSAGES_TO_CACHE\n          ? middlewareOptions?.minMessagesToCache ??\n            runtime.context.minMessagesToCache\n          : runtime.context.minMessagesToCache ??\n            middlewareOptions?.minMessagesToCache;\n\n      // Skip if caching is disabled\n      if (!enableCaching) {\n        return undefined;\n      }\n\n      if (options.model?.getName() !== \"ChatAnthropic\") {\n        throw new Error(\n          \"Prompt caching is only supported for Anthropic models\"\n        );\n      }\n\n      const messagesCount =\n        state.messages.length + (options.systemMessage ? 1 : 0);\n\n      if (messagesCount < minMessagesToCache) {\n        return options;\n      }\n\n      /**\n       * Add cache_control to the last message\n       */\n      const lastMessage = options.messages.at(-1);\n      if (!lastMessage) {\n        return options;\n      }\n\n      if (Array.isArray(lastMessage.content)) {\n        lastMessage.content = [\n          ...lastMessage.content.slice(0, -1),\n          {\n            ...lastMessage.content.at(-1),\n            cache_control: {\n              type: \"ephemeral\",\n              ttl,\n            },\n          } as ContentBlock,\n        ];\n      } else if (typeof lastMessage.content === \"string\") {\n        lastMessage.content = [\n          {\n            type: \"text\",\n            text: lastMessage.content,\n            cache_control: {\n              type: \"ephemeral\",\n              ttl,\n            },\n          },\n        ];\n      } else {\n        throw new PromptCachingMiddlewareError(\n          \"Last message content is not a string or array\"\n        );\n      }\n\n      return options;\n    },\n  });\n}\n"],"mappings":";;;;;AAIA,MAAM,yBAAyB;AAC/B,MAAM,cAAc;AACpB,MAAM,gCAAgC;AAEtC,MAAM,gBAAgBA,SAAE,OAAO;CAE7B,eAAeA,SAAE,SAAS,CAAC,QAAQ,uBAAuB;CAC1D,KAAKA,SAAE,KAAK,CAAC,MAAM,IAAK,EAAC,CAAC,QAAQ,YAAY;CAC9C,oBAAoBA,SAAE,QAAQ,CAAC,QAAQ,8BAA8B;AACtE,EAAC;AAEF,IAAM,+BAAN,cAA2C,MAAM;CAC/C,YAAYC,SAAiB;EAC3B,MAAM,QAAQ;EACd,KAAK,OAAO;CACb;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuHD,SAAgB,iCACdC,mBACA;AACA,QAAOC,oCAAiB;EACtB,MAAM;EACN;EACA,qBAAqB,CAAC,SAAS,OAAO,YAAY;;;;;;GAMhD,MAAM,gBACJ,QAAQ,QAAQ,kBAAkB,yBAC9B,mBAAmB,iBAAiB,QAAQ,QAAQ,gBACpD,QAAQ,QAAQ,iBAAiB,mBAAmB;GAC1D,MAAM,MACJ,QAAQ,QAAQ,QAAQ,cACpB,mBAAmB,OAAO,QAAQ,QAAQ,MAC1C,QAAQ,QAAQ,OAAO,mBAAmB;GAChD,MAAM,qBACJ,QAAQ,QAAQ,uBAAuB,gCACnC,mBAAmB,sBACnB,QAAQ,QAAQ,qBAChB,QAAQ,QAAQ,sBAChB,mBAAmB;AAGzB,OAAI,CAAC,cACH,QAAO;AAGT,OAAI,QAAQ,OAAO,SAAS,KAAK,gBAC/B,OAAM,IAAI,MACR;GAIJ,MAAM,gBACJ,MAAM,SAAS,UAAU,QAAQ,gBAAgB,IAAI;AAEvD,OAAI,gBAAgB,mBAClB,QAAO;;;;GAMT,MAAM,cAAc,QAAQ,SAAS,GAAG,GAAG;AAC3C,OAAI,CAAC,YACH,QAAO;AAGT,OAAI,MAAM,QAAQ,YAAY,QAAQ,EACpC,YAAY,UAAU,CACpB,GAAG,YAAY,QAAQ,MAAM,GAAG,GAAG,EACnC;IACE,GAAG,YAAY,QAAQ,GAAG,GAAG;IAC7B,eAAe;KACb,MAAM;KACN;IACD;GACF,CACF;YACQ,OAAO,YAAY,YAAY,UACxC,YAAY,UAAU,CACpB;IACE,MAAM;IACN,MAAM,YAAY;IAClB,eAAe;KACb,MAAM;KACN;IACD;GACF,CACF;OAED,OAAM,IAAI,6BACR;AAIJ,UAAO;EACR;CACF,EAAC;AACH"}
+{"version":3,"file":"promptCaching.cjs","names":["z","message: string","middlewareOptions?: PromptCachingMiddlewareConfig","createMiddleware"],"sources":["../../../../src/agents/middlewareAgent/middleware/promptCaching.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { ContentBlock } from \"@langchain/core/messages\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\n\nimport { ConfigurableModel } from \"../../../chat_models/universal.js\";\nimport { createMiddleware } from \"../middleware.js\";\n\nconst DEFAULT_ENABLE_CACHING = true;\nconst DEFAULT_TTL = \"5m\";\nconst DEFAULT_MIN_MESSAGES_TO_CACHE = 3;\nconst DEFAULT_UNSUPPORTED_MODEL_BEHAVIOR = \"warn\";\n\nconst contextSchema = z.object({\n  /**\n   * Whether to enable prompt caching.\n   * @default true\n   */\n  enableCaching: z.boolean().optional(),\n  /**\n   * The time-to-live for the cached prompt.\n   * @default \"5m\"\n   */\n  ttl: z.enum([\"5m\", \"1h\"]).optional(),\n  /**\n   * The minimum number of messages required before caching is applied.\n   * @default 3\n   */\n  minMessagesToCache: z.number().optional(),\n  /**\n   * The behavior to take when an unsupported model is used.\n   * - \"ignore\" will ignore the unsupported model and continue without caching.\n   * - \"warn\" will warn the user and continue without caching.\n   * - \"raise\" will raise an error and stop the agent.\n   * @default \"warn\"\n   */\n  unsupportedModelBehavior: z.enum([\"ignore\", \"warn\", \"raise\"]).optional(),\n});\nexport type PromptCachingMiddlewareConfig = Partial<\n  InferInteropZodInput<typeof contextSchema>\n>;\n\nclass PromptCachingMiddlewareError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"PromptCachingMiddlewareError\";\n  }\n}\n\n/**\n * Creates a prompt caching middleware for Anthropic models to optimize API usage.\n *\n * This middleware automatically adds cache control headers to the last messages when using Anthropic models,\n * enabling their prompt caching feature. This can significantly reduce costs for applications with repetitive\n * prompts, long system messages, or extensive conversation histories.\n *\n * ## How It Works\n *\n * The middleware intercepts model requests and adds cache control metadata that tells Anthropic's\n * API to cache processed prompt prefixes. On subsequent requests with matching prefixes, the\n * cached representations are reused, skipping redundant token processing.\n *\n * ## Benefits\n *\n * - **Cost Reduction**: Avoid reprocessing the same tokens repeatedly (up to 90% savings on cached portions)\n * - **Lower Latency**: Cached prompts are processed faster as embeddings are pre-computed\n * - **Better Scalability**: Reduced computational load enables handling more requests\n * - **Consistent Performance**: Stable response times for repetitive queries\n *\n * @param middlewareOptions - Configuration options for the caching behavior\n * @param middlewareOptions.enableCaching - Whether to enable prompt caching (default: `true`)\n * @param middlewareOptions.ttl - Cache time-to-live: `\"5m\"` for 5 minutes or `\"1h\"` for 1 hour (default: `\"5m\"`)\n * @param middlewareOptions.minMessagesToCache - Minimum number of messages required before caching is applied (default: `3`)\n * @param middlewareOptions.unsupportedModelBehavior - The behavior to take when an unsupported model is used (default: `\"warn\"`)\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @throws {Error} If used with non-Anthropic models\n *\n * @example\n * Basic usage with default settings\n * ```typescript\n * import { createAgent } from \"langchain\";\n * import { anthropicPromptCachingMiddleware } from \"langchain\";\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   middleware: [\n *     anthropicPromptCachingMiddleware()\n *   ]\n * });\n * ```\n *\n * @example\n * Custom configuration for longer conversations\n * ```typescript\n * const cachingMiddleware = anthropicPromptCachingMiddleware({\n *   ttl: \"1h\",  // Cache for 1 hour instead of default 5 minutes\n *   minMessagesToCache: 5  // Only cache after 5 messages\n * });\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   systemPrompt: \"You are a helpful assistant with deep knowledge of...\", // Long system prompt\n *   middleware: [cachingMiddleware]\n * });\n * ```\n *\n * @example\n * Conditional caching based on runtime context\n * ```typescript\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   middleware: [\n *     anthropicPromptCachingMiddleware({\n *       enableCaching: true,\n *       ttl: \"5m\"\n *     })\n *   ]\n * });\n *\n * // Disable caching for specific requests\n * await agent.invoke(\n *   { messages: [new HumanMessage(\"Process this without caching\")] },\n *   {\n *     configurable: {\n *       middleware_context: { enableCaching: false }\n *     }\n *   }\n * );\n * ```\n *\n * @example\n * Optimal setup for customer support chatbot\n * ```typescript\n * const supportAgent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   systemPrompt: `You are a customer support agent for ACME Corp.\n *\n *     Company policies:\n *     - Always be polite and professional\n *     - Refer to knowledge base for product information\n *     - Escalate billing issues to human agents\n *     ... (extensive policies and guidelines)\n *   `,\n *   tools: [searchKnowledgeBase, createTicket, checkOrderStatus],\n *   middleware: [\n *     anthropicPromptCachingMiddleware({\n *       ttl: \"1h\",  // Long TTL for stable system prompt\n *       minMessagesToCache: 1  // Cache immediately due to large system prompt\n *     })\n *   ]\n * });\n * ```\n *\n * @remarks\n * - **Anthropic Only**: This middleware only works with Anthropic models and will throw an error if used with other providers\n * - **Automatic Application**: Caching is applied automatically when message count exceeds `minMessagesToCache`\n * - **Cache Scope**: Caches are isolated per API key and cannot be shared across different keys\n * - **TTL Options**: Only supports \"5m\" (5 minutes) and \"1h\" (1 hour) as TTL values per Anthropic's API\n * - **Best Use Cases**: Long system prompts, multi-turn conversations, repetitive queries, RAG applications\n * - **Cost Impact**: Cached tokens are billed at 10% of the base input token price, cache writes are billed at 25% of the base\n *\n * @see {@link createAgent} for agent creation\n * @see {@link https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching} Anthropic's prompt caching documentation\n * @public\n */\nexport function anthropicPromptCachingMiddleware(\n  middlewareOptions?: PromptCachingMiddlewareConfig\n) {\n  return createMiddleware({\n    name: \"PromptCachingMiddleware\",\n    contextSchema,\n    modifyModelRequest: (request, state, runtime) => {\n      /**\n       * Prefer runtime context values over middleware options values over defaults\n       */\n      const enableCaching =\n        runtime.context.enableCaching ??\n        middlewareOptions?.enableCaching ??\n        DEFAULT_ENABLE_CACHING;\n      const ttl = runtime.context.ttl ?? middlewareOptions?.ttl ?? DEFAULT_TTL;\n      const minMessagesToCache =\n        runtime.context.minMessagesToCache ??\n        middlewareOptions?.minMessagesToCache ??\n        DEFAULT_MIN_MESSAGES_TO_CACHE;\n      const unsupportedModelBehavior =\n        runtime.context.unsupportedModelBehavior ??\n        middlewareOptions?.unsupportedModelBehavior ??\n        DEFAULT_UNSUPPORTED_MODEL_BEHAVIOR;\n\n      // Skip if caching is disabled\n      if (!enableCaching || !request.model) {\n        return undefined;\n      }\n\n      const isAnthropicModel =\n        request.model.getName() === \"ChatAnthropic\" ||\n        (request.model.getName() === \"ConfigurableModel\" &&\n          (request.model as ConfigurableModel)._defaultConfig?.modelProvider ===\n            \"anthropic\");\n      if (!isAnthropicModel) {\n        // Get model name for better error context\n        const modelName = request.model.getName();\n        const modelInfo =\n          request.model.getName() === \"ConfigurableModel\"\n            ? `${modelName} (${\n                (request.model as ConfigurableModel)._defaultConfig\n                  ?.modelProvider\n              })`\n            : modelName;\n\n        const baseMessage = `Unsupported model '${modelInfo}'. Prompt caching requires an Anthropic model`;\n\n        if (unsupportedModelBehavior === \"raise\") {\n          throw new PromptCachingMiddlewareError(\n            `${baseMessage} (e.g., 'anthropic:claude-4-0-sonnet').`\n          );\n        } else if (unsupportedModelBehavior === \"warn\") {\n          console.warn(\n            `PromptCachingMiddleware: Skipping caching for ${modelName}. Consider switching to an Anthropic model for caching benefits.`\n          );\n        }\n        return undefined;\n      }\n\n      const messagesCount =\n        state.messages.length + (request.systemPrompt ? 1 : 0);\n\n      if (messagesCount < minMessagesToCache) {\n        return request;\n      }\n\n      /**\n       * Add cache_control to the last message\n       */\n      const lastMessage = request.messages.at(-1);\n      if (!lastMessage) {\n        return request;\n      }\n\n      const NewMessageConstructor =\n        Object.getPrototypeOf(lastMessage).constructor;\n      if (Array.isArray(lastMessage.content)) {\n        const newMessage = new NewMessageConstructor({\n          ...lastMessage,\n          content: [\n            ...lastMessage.content.slice(0, -1),\n            {\n              ...lastMessage.content.at(-1),\n              cache_control: {\n                type: \"ephemeral\",\n                ttl,\n              },\n            } as ContentBlock,\n          ],\n        });\n        return {\n          ...request,\n          messages: [...request.messages.slice(0, -1), newMessage],\n        };\n      } else if (typeof lastMessage.content === \"string\") {\n        const newMessage = new NewMessageConstructor({\n          content: [\n            {\n              type: \"text\",\n              text: lastMessage.content,\n              cache_control: {\n                type: \"ephemeral\",\n                ttl,\n              },\n            },\n          ],\n        });\n        return {\n          ...request,\n          messages: [...request.messages.slice(0, -1), newMessage],\n        };\n      }\n\n      throw new PromptCachingMiddlewareError(\n        \"Last message content is not a string or array\"\n      );\n    },\n  });\n}\n"],"mappings":";;;;;AAOA,MAAM,yBAAyB;AAC/B,MAAM,cAAc;AACpB,MAAM,gCAAgC;AACtC,MAAM,qCAAqC;AAE3C,MAAM,gBAAgBA,SAAE,OAAO;CAK7B,eAAeA,SAAE,SAAS,CAAC,UAAU;CAKrC,KAAKA,SAAE,KAAK,CAAC,MAAM,IAAK,EAAC,CAAC,UAAU;CAKpC,oBAAoBA,SAAE,QAAQ,CAAC,UAAU;CAQzC,0BAA0BA,SAAE,KAAK;EAAC;EAAU;EAAQ;CAAQ,EAAC,CAAC,UAAU;AACzE,EAAC;AAKF,IAAM,+BAAN,cAA2C,MAAM;CAC/C,YAAYC,SAAiB;EAC3B,MAAM,QAAQ;EACd,KAAK,OAAO;CACb;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwHD,SAAgB,iCACdC,mBACA;AACA,QAAOC,oCAAiB;EACtB,MAAM;EACN;EACA,oBAAoB,CAAC,SAAS,OAAO,YAAY;;;;GAI/C,MAAM,gBACJ,QAAQ,QAAQ,iBAChB,mBAAmB,iBACnB;GACF,MAAM,MAAM,QAAQ,QAAQ,OAAO,mBAAmB,OAAO;GAC7D,MAAM,qBACJ,QAAQ,QAAQ,sBAChB,mBAAmB,sBACnB;GACF,MAAM,2BACJ,QAAQ,QAAQ,4BAChB,mBAAmB,4BACnB;AAGF,OAAI,CAAC,iBAAiB,CAAC,QAAQ,MAC7B,QAAO;GAGT,MAAM,mBACJ,QAAQ,MAAM,SAAS,KAAK,mBAC3B,QAAQ,MAAM,SAAS,KAAK,uBAC1B,QAAQ,MAA4B,gBAAgB,kBACnD;AACN,OAAI,CAAC,kBAAkB;IAErB,MAAM,YAAY,QAAQ,MAAM,SAAS;IACzC,MAAM,YACJ,QAAQ,MAAM,SAAS,KAAK,sBACxB,GAAG,UAAU,EAAE,EACZ,QAAQ,MAA4B,gBACjC,cACL,CAAC,CAAC,GACH;IAEN,MAAM,cAAc,CAAC,mBAAmB,EAAE,UAAU,6CAA6C,CAAC;AAElG,QAAI,6BAA6B,QAC/B,OAAM,IAAI,6BACR,GAAG,YAAY,uCAAuC,CAAC;aAEhD,6BAA6B,QACtC,QAAQ,KACN,CAAC,8CAA8C,EAAE,UAAU,gEAAgE,CAAC,CAC7H;AAEH,WAAO;GACR;GAED,MAAM,gBACJ,MAAM,SAAS,UAAU,QAAQ,eAAe,IAAI;AAEtD,OAAI,gBAAgB,mBAClB,QAAO;;;;GAMT,MAAM,cAAc,QAAQ,SAAS,GAAG,GAAG;AAC3C,OAAI,CAAC,YACH,QAAO;GAGT,MAAM,wBACJ,OAAO,eAAe,YAAY,CAAC;AACrC,OAAI,MAAM,QAAQ,YAAY,QAAQ,EAAE;IACtC,MAAM,aAAa,IAAI,sBAAsB;KAC3C,GAAG;KACH,SAAS,CACP,GAAG,YAAY,QAAQ,MAAM,GAAG,GAAG,EACnC;MACE,GAAG,YAAY,QAAQ,GAAG,GAAG;MAC7B,eAAe;OACb,MAAM;OACN;MACD;KACF,CACF;IACF;AACD,WAAO;KACL,GAAG;KACH,UAAU,CAAC,GAAG,QAAQ,SAAS,MAAM,GAAG,GAAG,EAAE,UAAW;IACzD;GACF,WAAU,OAAO,YAAY,YAAY,UAAU;IAClD,MAAM,aAAa,IAAI,sBAAsB,EAC3C,SAAS,CACP;KACE,MAAM;KACN,MAAM,YAAY;KAClB,eAAe;MACb,MAAM;MACN;KACD;IACF,CACF,EACF;AACD,WAAO;KACL,GAAG;KACH,UAAU,CAAC,GAAG,QAAQ,SAAS,MAAM,GAAG,GAAG,EAAE,UAAW;IACzD;GACF;AAED,SAAM,IAAI,6BACR;EAEH;CACF,EAAC;AACH"}

package/dist/agents/middlewareAgent/middleware/promptCaching.d.cts

@@ -1,21 +1,44 @@
 import { AgentMiddleware } from "../types.cjs";
 import { z } from "zod/v3";
+import { InferInteropZodInput } from "@langchain/core/utils/types";
 
 //#region src/agents/middlewareAgent/middleware/promptCaching.d.ts
 declare const contextSchema: z.ZodObject<{
-  // Configuration options
-  enableCaching: z.ZodDefault<z.ZodBoolean>;
-  ttl: z.ZodDefault<z.ZodEnum<["5m", "1h"]>>;
-  minMessagesToCache: z.ZodDefault<z.ZodNumber>;
+  /**
+   * Whether to enable prompt caching.
+   * @default true
+   */
+  enableCaching: z.ZodOptional<z.ZodBoolean>;
+  /**
+   * The time-to-live for the cached prompt.
+   * @default "5m"
+   */
+  ttl: z.ZodOptional<z.ZodEnum<["5m", "1h"]>>;
+  /**
+   * The minimum number of messages required before caching is applied.
+   * @default 3
+   */
+  minMessagesToCache: z.ZodOptional<z.ZodNumber>;
+  /**
+   * The behavior to take when an unsupported model is used.
+   * - "ignore" will ignore the unsupported model and continue without caching.
+   * - "warn" will warn the user and continue without caching.
+   * - "raise" will raise an error and stop the agent.
+   * @default "warn"
+   */
+  unsupportedModelBehavior: z.ZodOptional<z.ZodEnum<["ignore", "warn", "raise"]>>;
 }, "strip", z.ZodTypeAny, {
-  enableCaching: boolean;
-  ttl: "1h" | "5m";
-  minMessagesToCache: number;
+  enableCaching?: boolean | undefined;
+  ttl?: "1h" | "5m" | undefined;
+  minMessagesToCache?: number | undefined;
+  unsupportedModelBehavior?: "ignore" | "raise" | "warn" | undefined;
 }, {
   enableCaching?: boolean | undefined;
   ttl?: "1h" | "5m" | undefined;
   minMessagesToCache?: number | undefined;
+  unsupportedModelBehavior?: "ignore" | "raise" | "warn" | undefined;
 }>;
+type PromptCachingMiddlewareConfig = Partial<InferInteropZodInput<typeof contextSchema>>;
 /**
  * Creates a prompt caching middleware for Anthropic models to optimize API usage.
  *
@@ -40,6 +63,7 @@ declare const contextSchema: z.ZodObject<{
  * @param middlewareOptions.enableCaching - Whether to enable prompt caching (default: `true`)
  * @param middlewareOptions.ttl - Cache time-to-live: `"5m"` for 5 minutes or `"1h"` for 1 hour (default: `"5m"`)
  * @param middlewareOptions.minMessagesToCache - Minimum number of messages required before caching is applied (default: `3`)
+ * @param middlewareOptions.unsupportedModelBehavior - The behavior to take when an unsupported model is used (default: `"warn"`)
  *
  * @returns A middleware instance that can be passed to `createAgent`
  *
@@ -49,7 +73,7 @@ declare const contextSchema: z.ZodObject<{
  * Basic usage with default settings
  * ```typescript
  * import { createAgent } from "langchain";
- * import { anthropicPromptCachingMiddleware } from "langchain/middleware";
+ * import { anthropicPromptCachingMiddleware } from "langchain";
  *
  * const agent = createAgent({
  *   model: "anthropic:claude-3-5-sonnet",
@@ -69,7 +93,7 @@ declare const contextSchema: z.ZodObject<{
  *
  * const agent = createAgent({
  *   model: "anthropic:claude-3-5-sonnet",
- *   systemMessage: "You are a helpful assistant with deep knowledge of...", // Long system prompt
+ *   systemPrompt: "You are a helpful assistant with deep knowledge of...", // Long system prompt
  *   middleware: [cachingMiddleware]
  * });
  * ```
@@ -103,7 +127,7 @@ declare const contextSchema: z.ZodObject<{
  * ```typescript
  * const supportAgent = createAgent({
  *   model: "anthropic:claude-3-5-sonnet",
- *   systemMessage: `You are a customer support agent for ACME Corp.
+ *   systemPrompt: `You are a customer support agent for ACME Corp.
  *
  *     Company policies:
  *     - Always be polite and professional
@@ -133,20 +157,41 @@ declare const contextSchema: z.ZodObject<{
  * @see {@link https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching} Anthropic's prompt caching documentation
  * @public
  */
-declare function anthropicPromptCachingMiddleware(middlewareOptions?: Partial<z.infer<typeof contextSchema>>): AgentMiddleware<undefined, z.ZodObject<{
-  // Configuration options
-  enableCaching: z.ZodDefault<z.ZodBoolean>;
-  ttl: z.ZodDefault<z.ZodEnum<["5m", "1h"]>>;
-  minMessagesToCache: z.ZodDefault<z.ZodNumber>;
+declare function anthropicPromptCachingMiddleware(middlewareOptions?: PromptCachingMiddlewareConfig): AgentMiddleware<undefined, z.ZodObject<{
+  /**
+   * Whether to enable prompt caching.
+   * @default true
+   */
+  enableCaching: z.ZodOptional<z.ZodBoolean>;
+  /**
+   * The time-to-live for the cached prompt.
+   * @default "5m"
+   */
+  ttl: z.ZodOptional<z.ZodEnum<["5m", "1h"]>>;
+  /**
+   * The minimum number of messages required before caching is applied.
+   * @default 3
+   */
+  minMessagesToCache: z.ZodOptional<z.ZodNumber>;
+  /**
+   * The behavior to take when an unsupported model is used.
+   * - "ignore" will ignore the unsupported model and continue without caching.
+   * - "warn" will warn the user and continue without caching.
+   * - "raise" will raise an error and stop the agent.
+   * @default "warn"
+   */
+  unsupportedModelBehavior: z.ZodOptional<z.ZodEnum<["ignore", "warn", "raise"]>>;
 }, "strip", z.ZodTypeAny, {
-  enableCaching: boolean;
-  ttl: "1h" | "5m";
-  minMessagesToCache: number;
+  enableCaching?: boolean | undefined;
+  ttl?: "1h" | "5m" | undefined;
+  minMessagesToCache?: number | undefined;
+  unsupportedModelBehavior?: "ignore" | "raise" | "warn" | undefined;
 }, {
   enableCaching?: boolean | undefined;
   ttl?: "1h" | "5m" | undefined;
   minMessagesToCache?: number | undefined;
+  unsupportedModelBehavior?: "ignore" | "raise" | "warn" | undefined;
 }>, any>;
 //#endregion
-export { anthropicPromptCachingMiddleware };
+export { PromptCachingMiddlewareConfig, anthropicPromptCachingMiddleware };
 //# sourceMappingURL=promptCaching.d.cts.map

package/dist/agents/middlewareAgent/middleware/promptCaching.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"promptCaching.d.cts","names":["z","contextSchema","ZodBoolean","ZodDefault","ZodEnum","ZodNumber","ZodTypeAny","ZodObject","anthropicPromptCachingMiddleware","infer","Partial","___types_js0","AgentMiddleware"],"sources":["../../../../src/agents/middlewareAgent/middleware/promptCaching.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\ndeclare const contextSchema: z.ZodObject<{\n    // Configuration options\n    enableCaching: z.ZodDefault<z.ZodBoolean>;\n    ttl: z.ZodDefault<z.ZodEnum<[\"5m\", \"1h\"]>>;\n    minMessagesToCache: z.ZodDefault<z.ZodNumber>;\n}, \"strip\", z.ZodTypeAny, {\n    enableCaching: boolean;\n    ttl: \"1h\" | \"5m\";\n    minMessagesToCache: number;\n}, {\n    enableCaching?: boolean | undefined;\n    ttl?: \"1h\" | \"5m\" | undefined;\n    minMessagesToCache?: number | undefined;\n}>;\n/**\n * Creates a prompt caching middleware for Anthropic models to optimize API usage.\n *\n * This middleware automatically adds cache control headers to the last messages when using Anthropic models,\n * enabling their prompt caching feature. This can significantly reduce costs for applications with repetitive\n * prompts, long system messages, or extensive conversation histories.\n *\n * ## How It Works\n *\n * The middleware intercepts model requests and adds cache control metadata that tells Anthropic's\n * API to cache processed prompt prefixes. On subsequent requests with matching prefixes, the\n * cached representations are reused, skipping redundant token processing.\n *\n * ## Benefits\n *\n * - **Cost Reduction**: Avoid reprocessing the same tokens repeatedly (up to 90% savings on cached portions)\n * - **Lower Latency**: Cached prompts are processed faster as embeddings are pre-computed\n * - **Better Scalability**: Reduced computational load enables handling more requests\n * - **Consistent Performance**: Stable response times for repetitive queries\n *\n * @param middlewareOptions - Configuration options for the caching behavior\n * @param middlewareOptions.enableCaching - Whether to enable prompt caching (default: `true`)\n * @param middlewareOptions.ttl - Cache time-to-live: `\"5m\"` for 5 minutes or `\"1h\"` for 1 hour (default: `\"5m\"`)\n * @param middlewareOptions.minMessagesToCache - Minimum number of messages required before caching is applied (default: `3`)\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @throws {Error} If used with non-Anthropic models\n *\n * @example\n * Basic usage with default settings\n * ```typescript\n * import { createAgent } from \"langchain\";\n * import { anthropicPromptCachingMiddleware } from \"langchain/middleware\";\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   middleware: [\n *     anthropicPromptCachingMiddleware()\n *   ]\n * });\n * ```\n *\n * @example\n * Custom configuration for longer conversations\n * ```typescript\n * const cachingMiddleware = anthropicPromptCachingMiddleware({\n *   ttl: \"1h\",  // Cache for 1 hour instead of default 5 minutes\n *   minMessagesToCache: 5  // Only cache after 5 messages\n * });\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   systemMessage: \"You are a helpful assistant with deep knowledge of...\", // Long system prompt\n *   middleware: [cachingMiddleware]\n * });\n * ```\n *\n * @example\n * Conditional caching based on runtime context\n * ```typescript\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   middleware: [\n *     anthropicPromptCachingMiddleware({\n *       enableCaching: true,\n *       ttl: \"5m\"\n *     })\n *   ]\n * });\n *\n * // Disable caching for specific requests\n * await agent.invoke(\n *   { messages: [new HumanMessage(\"Process this without caching\")] },\n *   {\n *     configurable: {\n *       middleware_context: { enableCaching: false }\n *     }\n *   }\n * );\n * ```\n *\n * @example\n * Optimal setup for customer support chatbot\n * ```typescript\n * const supportAgent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   systemMessage: `You are a customer support agent for ACME Corp.\n *\n *     Company policies:\n *     - Always be polite and professional\n *     - Refer to knowledge base for product information\n *     - Escalate billing issues to human agents\n *     ... (extensive policies and guidelines)\n *   `,\n *   tools: [searchKnowledgeBase, createTicket, checkOrderStatus],\n *   middleware: [\n *     anthropicPromptCachingMiddleware({\n *       ttl: \"1h\",  // Long TTL for stable system prompt\n *       minMessagesToCache: 1  // Cache immediately due to large system prompt\n *     })\n *   ]\n * });\n * ```\n *\n * @remarks\n * - **Anthropic Only**: This middleware only works with Anthropic models and will throw an error if used with other providers\n * - **Automatic Application**: Caching is applied automatically when message count exceeds `minMessagesToCache`\n * - **Cache Scope**: Caches are isolated per API key and cannot be shared across different keys\n * - **TTL Options**: Only supports \"5m\" (5 minutes) and \"1h\" (1 hour) as TTL values per Anthropic's API\n * - **Best Use Cases**: Long system prompts, multi-turn conversations, repetitive queries, RAG applications\n * - **Cost Impact**: Cached tokens are billed at 10% of the base input token price, cache writes are billed at 25% of the base\n *\n * @see {@link createAgent} for agent creation\n * @see {@link https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching} Anthropic's prompt caching documentation\n * @public\n */\nexport declare function anthropicPromptCachingMiddleware(middlewareOptions?: Partial<z.infer<typeof contextSchema>>): import(\"../types.js\").AgentMiddleware<undefined, z.ZodObject<{\n    // Configuration options\n    enableCaching: z.ZodDefault<z.ZodBoolean>;\n    ttl: z.ZodDefault<z.ZodEnum<[\"5m\", \"1h\"]>>;\n    minMessagesToCache: z.ZodDefault<z.ZodNumber>;\n}, \"strip\", z.ZodTypeAny, {\n    enableCaching: boolean;\n    ttl: \"1h\" | \"5m\";\n    minMessagesToCache: number;\n}, {\n    enableCaching?: boolean | undefined;\n    ttl?: \"1h\" | \"5m\" | undefined;\n    minMessagesToCache?: number | undefined;\n}>, any>;\nexport {};\n"],"mappings":";;;;cACcC,eAAeD,CAAAA,CAAEO;;iBAEZP,CAAAA,CAAEG,WAAWH,CAAAA,CAAEE;EAFpBD,GAAAA,EAGLD,CAAAA,CAAEG,UAUT,CAVoBH,CAAAA,CAAEI,OAUtB,CAAA,CAAA,IAAA,EAAA,IAAA,CAAA,CAAA,CAAA;EAAA,kBAAA,EATsBJ,CAAAA,CAAEG,UASxB,CATmCH,CAAAA,CAAEK,SASrC,CAAA;CAAA,EAAA,OAXgCH,EAGtBF,CAAAA,CAAEM,UAHoBJ,EAAAA;EAAU,aAAvBC,EAAAA,OAAAA;EAAU,GACTH,EAAEI,IAAAA,GAAAA,IAAAA;EAAO,kBAApBD,EAAAA,MAAAA;CAAU,EAAA;EAC2B,aAAtBA,CAAAA,EAAAA,OAAAA,GAAAA,SAAAA;EAAU,GACxBH,CAAAA,EAAEM,IAAAA,GAAAA,IAAAA,GAAAA,SAAAA;EAAU,kBALOC,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;AAAS,CAAA,CAAA;AAmIxC;;;;;;;;;;;;;;AAA2J;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAnIC,gCAAAA,qBAAqDE,QAAQV,CAAAA,CAAES,aAAaR,kBAA8E,2BAAXD,CAAAA,CAAEO;;iBAEtJP,CAAAA,CAAEG,WAAWH,CAAAA,CAAEE;OACzBF,CAAAA,CAAEG,WAAWH,CAAAA,CAAEI;sBACAJ,CAAAA,CAAEG,WAAWH,CAAAA,CAAEK;YAC3BL,CAAAA,CAAEM"}
+{"version":3,"file":"promptCaching.d.cts","names":["z","InferInteropZodInput","contextSchema","ZodBoolean","ZodOptional","ZodEnum","ZodNumber","ZodTypeAny","ZodObject","PromptCachingMiddlewareConfig","Partial","anthropicPromptCachingMiddleware","__index_js1","AgentMiddleware"],"sources":["../../../../src/agents/middlewareAgent/middleware/promptCaching.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\ndeclare const contextSchema: z.ZodObject<{\n    /**\n     * Whether to enable prompt caching.\n     * @default true\n     */\n    enableCaching: z.ZodOptional<z.ZodBoolean>;\n    /**\n     * The time-to-live for the cached prompt.\n     * @default \"5m\"\n     */\n    ttl: z.ZodOptional<z.ZodEnum<[\"5m\", \"1h\"]>>;\n    /**\n     * The minimum number of messages required before caching is applied.\n     * @default 3\n     */\n    minMessagesToCache: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The behavior to take when an unsupported model is used.\n     * - \"ignore\" will ignore the unsupported model and continue without caching.\n     * - \"warn\" will warn the user and continue without caching.\n     * - \"raise\" will raise an error and stop the agent.\n     * @default \"warn\"\n     */\n    unsupportedModelBehavior: z.ZodOptional<z.ZodEnum<[\"ignore\", \"warn\", \"raise\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    enableCaching?: boolean | undefined;\n    ttl?: \"1h\" | \"5m\" | undefined;\n    minMessagesToCache?: number | undefined;\n    unsupportedModelBehavior?: \"ignore\" | \"raise\" | \"warn\" | undefined;\n}, {\n    enableCaching?: boolean | undefined;\n    ttl?: \"1h\" | \"5m\" | undefined;\n    minMessagesToCache?: number | undefined;\n    unsupportedModelBehavior?: \"ignore\" | \"raise\" | \"warn\" | undefined;\n}>;\nexport type PromptCachingMiddlewareConfig = Partial<InferInteropZodInput<typeof contextSchema>>;\n/**\n * Creates a prompt caching middleware for Anthropic models to optimize API usage.\n *\n * This middleware automatically adds cache control headers to the last messages when using Anthropic models,\n * enabling their prompt caching feature. This can significantly reduce costs for applications with repetitive\n * prompts, long system messages, or extensive conversation histories.\n *\n * ## How It Works\n *\n * The middleware intercepts model requests and adds cache control metadata that tells Anthropic's\n * API to cache processed prompt prefixes. On subsequent requests with matching prefixes, the\n * cached representations are reused, skipping redundant token processing.\n *\n * ## Benefits\n *\n * - **Cost Reduction**: Avoid reprocessing the same tokens repeatedly (up to 90% savings on cached portions)\n * - **Lower Latency**: Cached prompts are processed faster as embeddings are pre-computed\n * - **Better Scalability**: Reduced computational load enables handling more requests\n * - **Consistent Performance**: Stable response times for repetitive queries\n *\n * @param middlewareOptions - Configuration options for the caching behavior\n * @param middlewareOptions.enableCaching - Whether to enable prompt caching (default: `true`)\n * @param middlewareOptions.ttl - Cache time-to-live: `\"5m\"` for 5 minutes or `\"1h\"` for 1 hour (default: `\"5m\"`)\n * @param middlewareOptions.minMessagesToCache - Minimum number of messages required before caching is applied (default: `3`)\n * @param middlewareOptions.unsupportedModelBehavior - The behavior to take when an unsupported model is used (default: `\"warn\"`)\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @throws {Error} If used with non-Anthropic models\n *\n * @example\n * Basic usage with default settings\n * ```typescript\n * import { createAgent } from \"langchain\";\n * import { anthropicPromptCachingMiddleware } from \"langchain\";\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   middleware: [\n *     anthropicPromptCachingMiddleware()\n *   ]\n * });\n * ```\n *\n * @example\n * Custom configuration for longer conversations\n * ```typescript\n * const cachingMiddleware = anthropicPromptCachingMiddleware({\n *   ttl: \"1h\",  // Cache for 1 hour instead of default 5 minutes\n *   minMessagesToCache: 5  // Only cache after 5 messages\n * });\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   systemPrompt: \"You are a helpful assistant with deep knowledge of...\", // Long system prompt\n *   middleware: [cachingMiddleware]\n * });\n * ```\n *\n * @example\n * Conditional caching based on runtime context\n * ```typescript\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   middleware: [\n *     anthropicPromptCachingMiddleware({\n *       enableCaching: true,\n *       ttl: \"5m\"\n *     })\n *   ]\n * });\n *\n * // Disable caching for specific requests\n * await agent.invoke(\n *   { messages: [new HumanMessage(\"Process this without caching\")] },\n *   {\n *     configurable: {\n *       middleware_context: { enableCaching: false }\n *     }\n *   }\n * );\n * ```\n *\n * @example\n * Optimal setup for customer support chatbot\n * ```typescript\n * const supportAgent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   systemPrompt: `You are a customer support agent for ACME Corp.\n *\n *     Company policies:\n *     - Always be polite and professional\n *     - Refer to knowledge base for product information\n *     - Escalate billing issues to human agents\n *     ... (extensive policies and guidelines)\n *   `,\n *   tools: [searchKnowledgeBase, createTicket, checkOrderStatus],\n *   middleware: [\n *     anthropicPromptCachingMiddleware({\n *       ttl: \"1h\",  // Long TTL for stable system prompt\n *       minMessagesToCache: 1  // Cache immediately due to large system prompt\n *     })\n *   ]\n * });\n * ```\n *\n * @remarks\n * - **Anthropic Only**: This middleware only works with Anthropic models and will throw an error if used with other providers\n * - **Automatic Application**: Caching is applied automatically when message count exceeds `minMessagesToCache`\n * - **Cache Scope**: Caches are isolated per API key and cannot be shared across different keys\n * - **TTL Options**: Only supports \"5m\" (5 minutes) and \"1h\" (1 hour) as TTL values per Anthropic's API\n * - **Best Use Cases**: Long system prompts, multi-turn conversations, repetitive queries, RAG applications\n * - **Cost Impact**: Cached tokens are billed at 10% of the base input token price, cache writes are billed at 25% of the base\n *\n * @see {@link createAgent} for agent creation\n * @see {@link https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching} Anthropic's prompt caching documentation\n * @public\n */\nexport declare function anthropicPromptCachingMiddleware(middlewareOptions?: PromptCachingMiddlewareConfig): import(\"./index.js\").AgentMiddleware<undefined, z.ZodObject<{\n    /**\n     * Whether to enable prompt caching.\n     * @default true\n     */\n    enableCaching: z.ZodOptional<z.ZodBoolean>;\n    /**\n     * The time-to-live for the cached prompt.\n     * @default \"5m\"\n     */\n    ttl: z.ZodOptional<z.ZodEnum<[\"5m\", \"1h\"]>>;\n    /**\n     * The minimum number of messages required before caching is applied.\n     * @default 3\n     */\n    minMessagesToCache: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The behavior to take when an unsupported model is used.\n     * - \"ignore\" will ignore the unsupported model and continue without caching.\n     * - \"warn\" will warn the user and continue without caching.\n     * - \"raise\" will raise an error and stop the agent.\n     * @default \"warn\"\n     */\n    unsupportedModelBehavior: z.ZodOptional<z.ZodEnum<[\"ignore\", \"warn\", \"raise\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    enableCaching?: boolean | undefined;\n    ttl?: \"1h\" | \"5m\" | undefined;\n    minMessagesToCache?: number | undefined;\n    unsupportedModelBehavior?: \"ignore\" | \"raise\" | \"warn\" | undefined;\n}, {\n    enableCaching?: boolean | undefined;\n    ttl?: \"1h\" | \"5m\" | undefined;\n    minMessagesToCache?: number | undefined;\n    unsupportedModelBehavior?: \"ignore\" | \"raise\" | \"warn\" | undefined;\n}>, any>;\nexport {};\n"],"mappings":";;;;;cAEcE,eAAeF,CAAAA,CAAEQ;;;AADoC;;EAmCjE,aA7BiCL,EAAhBH,CAAAA,CAAEI,WAAcD,CAAFH,CAAAA,CAAEG,UAAAA,CAAAA;EAAU;;;;EAUI,GAAzBH,EALfA,CAAAA,CAAEI,WAKeA,CALHJ,CAAAA,CAAEK,OAKCD,CAAAA,CAAAA,IAAAA,EAAAA,IAAAA,CAAAA,CAAAA,CAAAA;EAAW;;;;EAfG,kBAAA,EAehBJ,CAAAA,CAAEI,WAfc,CAeFJ,CAAAA,CAAEM,SAfA,CAAA;EAmC5BG;;;;;AAAuC;AAuHnD;EAAwD,wBAAA,EAnI1BT,CAAAA,CAAEI,WAmIwB,CAnIZJ,CAAAA,CAAEK,OAmIU,CAAA,CAAA,QAAA,EAAA,MAAA,EAAA,OAAA,CAAA,CAAA,CAAA;CAAA,EAAA,OAAqBI,EAlIjET,CAAAA,CAAEO,UAkI+DE,EAAAA;EAA6B,aAKvEN,CAAAA,EAAAA,OAAAA,GAAAA,SAAAA;EAAU,GAA1BH,CAAAA,EAAEI,IAAAA,GAAAA,IAAAA,GAAAA,SAAAA;EAAW,kBAKPC,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAO,wBAArBD,CAAAA,EAAAA,QAAAA,GAAAA,OAAAA,GAAAA,MAAAA,GAAAA,SAAAA;CAAW,EAAA;EAK2B,aAAvBA,CAAAA,EAAAA,OAAAA,GAAAA,SAAAA;EAAW,GAQOJ,CAAAA,EAAEK,IAAAA,GAAAA,IAAAA,GAAAA,SAAAA;EAAO,kBAArBD,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAW,wBAC7BG,CAAAA,EAAAA,QAAAA,GAAAA,OAAAA,GAAAA,MAAAA,GAAAA,SAAAA;CAAU,CAAA;AAxBgJ,KAvH5JE,6BAAAA,GAAgCC,OAuH4H,CAvHpHT,oBAuHoH,CAAA,OAvHxFC,aAuHwF,CAAA,CAAA;AAAvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAzHS,gCAAAA,qBAAqDF,gCAA2F,2BAAXT,CAAAA,CAAEQ;;;;;iBAK5IR,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;;;;;OAK1BH,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEK;;;;;sBAKDL,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEM;;;;;;;;4BAQVN,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEK;YAClCL,CAAAA,CAAEO"}

package/dist/agents/middlewareAgent/middleware/promptCaching.d.ts

@@ -1,21 +1,44 @@
 import { AgentMiddleware } from "../types.js";
+import { InferInteropZodInput } from "@langchain/core/utils/types";
 import { z } from "zod/v3";
 
 //#region src/agents/middlewareAgent/middleware/promptCaching.d.ts
 declare const contextSchema: z.ZodObject<{
-  // Configuration options
-  enableCaching: z.ZodDefault<z.ZodBoolean>;
-  ttl: z.ZodDefault<z.ZodEnum<["5m", "1h"]>>;
-  minMessagesToCache: z.ZodDefault<z.ZodNumber>;
+  /**
+   * Whether to enable prompt caching.
+   * @default true
+   */
+  enableCaching: z.ZodOptional<z.ZodBoolean>;
+  /**
+   * The time-to-live for the cached prompt.
+   * @default "5m"
+   */
+  ttl: z.ZodOptional<z.ZodEnum<["5m", "1h"]>>;
+  /**
+   * The minimum number of messages required before caching is applied.
+   * @default 3
+   */
+  minMessagesToCache: z.ZodOptional<z.ZodNumber>;
+  /**
+   * The behavior to take when an unsupported model is used.
+   * - "ignore" will ignore the unsupported model and continue without caching.
+   * - "warn" will warn the user and continue without caching.
+   * - "raise" will raise an error and stop the agent.
+   * @default "warn"
+   */
+  unsupportedModelBehavior: z.ZodOptional<z.ZodEnum<["ignore", "warn", "raise"]>>;
 }, "strip", z.ZodTypeAny, {
-  enableCaching: boolean;
-  ttl: "1h" | "5m";
-  minMessagesToCache: number;
+  enableCaching?: boolean | undefined;
+  ttl?: "1h" | "5m" | undefined;
+  minMessagesToCache?: number | undefined;
+  unsupportedModelBehavior?: "ignore" | "raise" | "warn" | undefined;
 }, {
   enableCaching?: boolean | undefined;
   ttl?: "1h" | "5m" | undefined;
   minMessagesToCache?: number | undefined;
+  unsupportedModelBehavior?: "ignore" | "raise" | "warn" | undefined;
 }>;
+type PromptCachingMiddlewareConfig = Partial<InferInteropZodInput<typeof contextSchema>>;
 /**
  * Creates a prompt caching middleware for Anthropic models to optimize API usage.
  *
@@ -40,6 +63,7 @@ declare const contextSchema: z.ZodObject<{
  * @param middlewareOptions.enableCaching - Whether to enable prompt caching (default: `true`)
  * @param middlewareOptions.ttl - Cache time-to-live: `"5m"` for 5 minutes or `"1h"` for 1 hour (default: `"5m"`)
  * @param middlewareOptions.minMessagesToCache - Minimum number of messages required before caching is applied (default: `3`)
+ * @param middlewareOptions.unsupportedModelBehavior - The behavior to take when an unsupported model is used (default: `"warn"`)
  *
  * @returns A middleware instance that can be passed to `createAgent`
  *
@@ -49,7 +73,7 @@ declare const contextSchema: z.ZodObject<{
  * Basic usage with default settings
  * ```typescript
  * import { createAgent } from "langchain";
- * import { anthropicPromptCachingMiddleware } from "langchain/middleware";
+ * import { anthropicPromptCachingMiddleware } from "langchain";
  *
  * const agent = createAgent({
  *   model: "anthropic:claude-3-5-sonnet",
@@ -69,7 +93,7 @@ declare const contextSchema: z.ZodObject<{
  *
  * const agent = createAgent({
  *   model: "anthropic:claude-3-5-sonnet",
- *   systemMessage: "You are a helpful assistant with deep knowledge of...", // Long system prompt
+ *   systemPrompt: "You are a helpful assistant with deep knowledge of...", // Long system prompt
  *   middleware: [cachingMiddleware]
  * });
  * ```
@@ -103,7 +127,7 @@ declare const contextSchema: z.ZodObject<{
  * ```typescript
  * const supportAgent = createAgent({
  *   model: "anthropic:claude-3-5-sonnet",
- *   systemMessage: `You are a customer support agent for ACME Corp.
+ *   systemPrompt: `You are a customer support agent for ACME Corp.
  *
  *     Company policies:
  *     - Always be polite and professional
@@ -133,20 +157,41 @@ declare const contextSchema: z.ZodObject<{
  * @see {@link https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching} Anthropic's prompt caching documentation
  * @public
  */
-declare function anthropicPromptCachingMiddleware(middlewareOptions?: Partial<z.infer<typeof contextSchema>>): AgentMiddleware<undefined, z.ZodObject<{
-  // Configuration options
-  enableCaching: z.ZodDefault<z.ZodBoolean>;
-  ttl: z.ZodDefault<z.ZodEnum<["5m", "1h"]>>;
-  minMessagesToCache: z.ZodDefault<z.ZodNumber>;
+declare function anthropicPromptCachingMiddleware(middlewareOptions?: PromptCachingMiddlewareConfig): AgentMiddleware<undefined, z.ZodObject<{
+  /**
+   * Whether to enable prompt caching.
+   * @default true
+   */
+  enableCaching: z.ZodOptional<z.ZodBoolean>;
+  /**
+   * The time-to-live for the cached prompt.
+   * @default "5m"
+   */
+  ttl: z.ZodOptional<z.ZodEnum<["5m", "1h"]>>;
+  /**
+   * The minimum number of messages required before caching is applied.
+   * @default 3
+   */
+  minMessagesToCache: z.ZodOptional<z.ZodNumber>;
+  /**
+   * The behavior to take when an unsupported model is used.
+   * - "ignore" will ignore the unsupported model and continue without caching.
+   * - "warn" will warn the user and continue without caching.
+   * - "raise" will raise an error and stop the agent.
+   * @default "warn"
+   */
+  unsupportedModelBehavior: z.ZodOptional<z.ZodEnum<["ignore", "warn", "raise"]>>;
 }, "strip", z.ZodTypeAny, {
-  enableCaching: boolean;
-  ttl: "1h" | "5m";
-  minMessagesToCache: number;
+  enableCaching?: boolean | undefined;
+  ttl?: "1h" | "5m" | undefined;
+  minMessagesToCache?: number | undefined;
+  unsupportedModelBehavior?: "ignore" | "raise" | "warn" | undefined;
 }, {
   enableCaching?: boolean | undefined;
   ttl?: "1h" | "5m" | undefined;
   minMessagesToCache?: number | undefined;
+  unsupportedModelBehavior?: "ignore" | "raise" | "warn" | undefined;
 }>, any>;
 //#endregion
-export { anthropicPromptCachingMiddleware };
+export { PromptCachingMiddlewareConfig, anthropicPromptCachingMiddleware };
 //# sourceMappingURL=promptCaching.d.ts.map

package/dist/agents/middlewareAgent/middleware/promptCaching.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"promptCaching.d.ts","names":["z","contextSchema","ZodBoolean","ZodDefault","ZodEnum","ZodNumber","ZodTypeAny","ZodObject","anthropicPromptCachingMiddleware","infer","Partial","___types_js0","AgentMiddleware"],"sources":["../../../../src/agents/middlewareAgent/middleware/promptCaching.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\ndeclare const contextSchema: z.ZodObject<{\n    // Configuration options\n    enableCaching: z.ZodDefault<z.ZodBoolean>;\n    ttl: z.ZodDefault<z.ZodEnum<[\"5m\", \"1h\"]>>;\n    minMessagesToCache: z.ZodDefault<z.ZodNumber>;\n}, \"strip\", z.ZodTypeAny, {\n    enableCaching: boolean;\n    ttl: \"1h\" | \"5m\";\n    minMessagesToCache: number;\n}, {\n    enableCaching?: boolean | undefined;\n    ttl?: \"1h\" | \"5m\" | undefined;\n    minMessagesToCache?: number | undefined;\n}>;\n/**\n * Creates a prompt caching middleware for Anthropic models to optimize API usage.\n *\n * This middleware automatically adds cache control headers to the last messages when using Anthropic models,\n * enabling their prompt caching feature. This can significantly reduce costs for applications with repetitive\n * prompts, long system messages, or extensive conversation histories.\n *\n * ## How It Works\n *\n * The middleware intercepts model requests and adds cache control metadata that tells Anthropic's\n * API to cache processed prompt prefixes. On subsequent requests with matching prefixes, the\n * cached representations are reused, skipping redundant token processing.\n *\n * ## Benefits\n *\n * - **Cost Reduction**: Avoid reprocessing the same tokens repeatedly (up to 90% savings on cached portions)\n * - **Lower Latency**: Cached prompts are processed faster as embeddings are pre-computed\n * - **Better Scalability**: Reduced computational load enables handling more requests\n * - **Consistent Performance**: Stable response times for repetitive queries\n *\n * @param middlewareOptions - Configuration options for the caching behavior\n * @param middlewareOptions.enableCaching - Whether to enable prompt caching (default: `true`)\n * @param middlewareOptions.ttl - Cache time-to-live: `\"5m\"` for 5 minutes or `\"1h\"` for 1 hour (default: `\"5m\"`)\n * @param middlewareOptions.minMessagesToCache - Minimum number of messages required before caching is applied (default: `3`)\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @throws {Error} If used with non-Anthropic models\n *\n * @example\n * Basic usage with default settings\n * ```typescript\n * import { createAgent } from \"langchain\";\n * import { anthropicPromptCachingMiddleware } from \"langchain/middleware\";\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   middleware: [\n *     anthropicPromptCachingMiddleware()\n *   ]\n * });\n * ```\n *\n * @example\n * Custom configuration for longer conversations\n * ```typescript\n * const cachingMiddleware = anthropicPromptCachingMiddleware({\n *   ttl: \"1h\",  // Cache for 1 hour instead of default 5 minutes\n *   minMessagesToCache: 5  // Only cache after 5 messages\n * });\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   systemMessage: \"You are a helpful assistant with deep knowledge of...\", // Long system prompt\n *   middleware: [cachingMiddleware]\n * });\n * ```\n *\n * @example\n * Conditional caching based on runtime context\n * ```typescript\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   middleware: [\n *     anthropicPromptCachingMiddleware({\n *       enableCaching: true,\n *       ttl: \"5m\"\n *     })\n *   ]\n * });\n *\n * // Disable caching for specific requests\n * await agent.invoke(\n *   { messages: [new HumanMessage(\"Process this without caching\")] },\n *   {\n *     configurable: {\n *       middleware_context: { enableCaching: false }\n *     }\n *   }\n * );\n * ```\n *\n * @example\n * Optimal setup for customer support chatbot\n * ```typescript\n * const supportAgent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   systemMessage: `You are a customer support agent for ACME Corp.\n *\n *     Company policies:\n *     - Always be polite and professional\n *     - Refer to knowledge base for product information\n *     - Escalate billing issues to human agents\n *     ... (extensive policies and guidelines)\n *   `,\n *   tools: [searchKnowledgeBase, createTicket, checkOrderStatus],\n *   middleware: [\n *     anthropicPromptCachingMiddleware({\n *       ttl: \"1h\",  // Long TTL for stable system prompt\n *       minMessagesToCache: 1  // Cache immediately due to large system prompt\n *     })\n *   ]\n * });\n * ```\n *\n * @remarks\n * - **Anthropic Only**: This middleware only works with Anthropic models and will throw an error if used with other providers\n * - **Automatic Application**: Caching is applied automatically when message count exceeds `minMessagesToCache`\n * - **Cache Scope**: Caches are isolated per API key and cannot be shared across different keys\n * - **TTL Options**: Only supports \"5m\" (5 minutes) and \"1h\" (1 hour) as TTL values per Anthropic's API\n * - **Best Use Cases**: Long system prompts, multi-turn conversations, repetitive queries, RAG applications\n * - **Cost Impact**: Cached tokens are billed at 10% of the base input token price, cache writes are billed at 25% of the base\n *\n * @see {@link createAgent} for agent creation\n * @see {@link https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching} Anthropic's prompt caching documentation\n * @public\n */\nexport declare function anthropicPromptCachingMiddleware(middlewareOptions?: Partial<z.infer<typeof contextSchema>>): import(\"../types.js\").AgentMiddleware<undefined, z.ZodObject<{\n    // Configuration options\n    enableCaching: z.ZodDefault<z.ZodBoolean>;\n    ttl: z.ZodDefault<z.ZodEnum<[\"5m\", \"1h\"]>>;\n    minMessagesToCache: z.ZodDefault<z.ZodNumber>;\n}, \"strip\", z.ZodTypeAny, {\n    enableCaching: boolean;\n    ttl: \"1h\" | \"5m\";\n    minMessagesToCache: number;\n}, {\n    enableCaching?: boolean | undefined;\n    ttl?: \"1h\" | \"5m\" | undefined;\n    minMessagesToCache?: number | undefined;\n}>, any>;\nexport {};\n"],"mappings":";;;;cACcC,eAAeD,CAAAA,CAAEO;;iBAEZP,CAAAA,CAAEG,WAAWH,CAAAA,CAAEE;EAFpBD,GAAAA,EAGLD,CAAAA,CAAEG,UAUT,CAVoBH,CAAAA,CAAEI,OAUtB,CAAA,CAAA,IAAA,EAAA,IAAA,CAAA,CAAA,CAAA;EAAA,kBAAA,EATsBJ,CAAAA,CAAEG,UASxB,CATmCH,CAAAA,CAAEK,SASrC,CAAA;CAAA,EAAA,OAXgCH,EAGtBF,CAAAA,CAAEM,UAHoBJ,EAAAA;EAAU,aAAvBC,EAAAA,OAAAA;EAAU,GACTH,EAAEI,IAAAA,GAAAA,IAAAA;EAAO,kBAApBD,EAAAA,MAAAA;CAAU,EAAA;EAC2B,aAAtBA,CAAAA,EAAAA,OAAAA,GAAAA,SAAAA;EAAU,GACxBH,CAAAA,EAAEM,IAAAA,GAAAA,IAAAA,GAAAA,SAAAA;EAAU,kBALOC,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;AAAS,CAAA,CAAA;AAmIxC;;;;;;;;;;;;;;AAA2J;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAnIC,gCAAAA,qBAAqDE,QAAQV,CAAAA,CAAES,aAAaR,kBAA8E,2BAAXD,CAAAA,CAAEO;;iBAEtJP,CAAAA,CAAEG,WAAWH,CAAAA,CAAEE;OACzBF,CAAAA,CAAEG,WAAWH,CAAAA,CAAEI;sBACAJ,CAAAA,CAAEG,WAAWH,CAAAA,CAAEK;YAC3BL,CAAAA,CAAEM"}
+{"version":3,"file":"promptCaching.d.ts","names":["z","InferInteropZodInput","contextSchema","ZodBoolean","ZodOptional","ZodEnum","ZodNumber","ZodTypeAny","ZodObject","PromptCachingMiddlewareConfig","Partial","anthropicPromptCachingMiddleware","__index_js1","AgentMiddleware"],"sources":["../../../../src/agents/middlewareAgent/middleware/promptCaching.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\ndeclare const contextSchema: z.ZodObject<{\n    /**\n     * Whether to enable prompt caching.\n     * @default true\n     */\n    enableCaching: z.ZodOptional<z.ZodBoolean>;\n    /**\n     * The time-to-live for the cached prompt.\n     * @default \"5m\"\n     */\n    ttl: z.ZodOptional<z.ZodEnum<[\"5m\", \"1h\"]>>;\n    /**\n     * The minimum number of messages required before caching is applied.\n     * @default 3\n     */\n    minMessagesToCache: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The behavior to take when an unsupported model is used.\n     * - \"ignore\" will ignore the unsupported model and continue without caching.\n     * - \"warn\" will warn the user and continue without caching.\n     * - \"raise\" will raise an error and stop the agent.\n     * @default \"warn\"\n     */\n    unsupportedModelBehavior: z.ZodOptional<z.ZodEnum<[\"ignore\", \"warn\", \"raise\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    enableCaching?: boolean | undefined;\n    ttl?: \"1h\" | \"5m\" | undefined;\n    minMessagesToCache?: number | undefined;\n    unsupportedModelBehavior?: \"ignore\" | \"raise\" | \"warn\" | undefined;\n}, {\n    enableCaching?: boolean | undefined;\n    ttl?: \"1h\" | \"5m\" | undefined;\n    minMessagesToCache?: number | undefined;\n    unsupportedModelBehavior?: \"ignore\" | \"raise\" | \"warn\" | undefined;\n}>;\nexport type PromptCachingMiddlewareConfig = Partial<InferInteropZodInput<typeof contextSchema>>;\n/**\n * Creates a prompt caching middleware for Anthropic models to optimize API usage.\n *\n * This middleware automatically adds cache control headers to the last messages when using Anthropic models,\n * enabling their prompt caching feature. This can significantly reduce costs for applications with repetitive\n * prompts, long system messages, or extensive conversation histories.\n *\n * ## How It Works\n *\n * The middleware intercepts model requests and adds cache control metadata that tells Anthropic's\n * API to cache processed prompt prefixes. On subsequent requests with matching prefixes, the\n * cached representations are reused, skipping redundant token processing.\n *\n * ## Benefits\n *\n * - **Cost Reduction**: Avoid reprocessing the same tokens repeatedly (up to 90% savings on cached portions)\n * - **Lower Latency**: Cached prompts are processed faster as embeddings are pre-computed\n * - **Better Scalability**: Reduced computational load enables handling more requests\n * - **Consistent Performance**: Stable response times for repetitive queries\n *\n * @param middlewareOptions - Configuration options for the caching behavior\n * @param middlewareOptions.enableCaching - Whether to enable prompt caching (default: `true`)\n * @param middlewareOptions.ttl - Cache time-to-live: `\"5m\"` for 5 minutes or `\"1h\"` for 1 hour (default: `\"5m\"`)\n * @param middlewareOptions.minMessagesToCache - Minimum number of messages required before caching is applied (default: `3`)\n * @param middlewareOptions.unsupportedModelBehavior - The behavior to take when an unsupported model is used (default: `\"warn\"`)\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @throws {Error} If used with non-Anthropic models\n *\n * @example\n * Basic usage with default settings\n * ```typescript\n * import { createAgent } from \"langchain\";\n * import { anthropicPromptCachingMiddleware } from \"langchain\";\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   middleware: [\n *     anthropicPromptCachingMiddleware()\n *   ]\n * });\n * ```\n *\n * @example\n * Custom configuration for longer conversations\n * ```typescript\n * const cachingMiddleware = anthropicPromptCachingMiddleware({\n *   ttl: \"1h\",  // Cache for 1 hour instead of default 5 minutes\n *   minMessagesToCache: 5  // Only cache after 5 messages\n * });\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   systemPrompt: \"You are a helpful assistant with deep knowledge of...\", // Long system prompt\n *   middleware: [cachingMiddleware]\n * });\n * ```\n *\n * @example\n * Conditional caching based on runtime context\n * ```typescript\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   middleware: [\n *     anthropicPromptCachingMiddleware({\n *       enableCaching: true,\n *       ttl: \"5m\"\n *     })\n *   ]\n * });\n *\n * // Disable caching for specific requests\n * await agent.invoke(\n *   { messages: [new HumanMessage(\"Process this without caching\")] },\n *   {\n *     configurable: {\n *       middleware_context: { enableCaching: false }\n *     }\n *   }\n * );\n * ```\n *\n * @example\n * Optimal setup for customer support chatbot\n * ```typescript\n * const supportAgent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   systemPrompt: `You are a customer support agent for ACME Corp.\n *\n *     Company policies:\n *     - Always be polite and professional\n *     - Refer to knowledge base for product information\n *     - Escalate billing issues to human agents\n *     ... (extensive policies and guidelines)\n *   `,\n *   tools: [searchKnowledgeBase, createTicket, checkOrderStatus],\n *   middleware: [\n *     anthropicPromptCachingMiddleware({\n *       ttl: \"1h\",  // Long TTL for stable system prompt\n *       minMessagesToCache: 1  // Cache immediately due to large system prompt\n *     })\n *   ]\n * });\n * ```\n *\n * @remarks\n * - **Anthropic Only**: This middleware only works with Anthropic models and will throw an error if used with other providers\n * - **Automatic Application**: Caching is applied automatically when message count exceeds `minMessagesToCache`\n * - **Cache Scope**: Caches are isolated per API key and cannot be shared across different keys\n * - **TTL Options**: Only supports \"5m\" (5 minutes) and \"1h\" (1 hour) as TTL values per Anthropic's API\n * - **Best Use Cases**: Long system prompts, multi-turn conversations, repetitive queries, RAG applications\n * - **Cost Impact**: Cached tokens are billed at 10% of the base input token price, cache writes are billed at 25% of the base\n *\n * @see {@link createAgent} for agent creation\n * @see {@link https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching} Anthropic's prompt caching documentation\n * @public\n */\nexport declare function anthropicPromptCachingMiddleware(middlewareOptions?: PromptCachingMiddlewareConfig): import(\"./index.js\").AgentMiddleware<undefined, z.ZodObject<{\n    /**\n     * Whether to enable prompt caching.\n     * @default true\n     */\n    enableCaching: z.ZodOptional<z.ZodBoolean>;\n    /**\n     * The time-to-live for the cached prompt.\n     * @default \"5m\"\n     */\n    ttl: z.ZodOptional<z.ZodEnum<[\"5m\", \"1h\"]>>;\n    /**\n     * The minimum number of messages required before caching is applied.\n     * @default 3\n     */\n    minMessagesToCache: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The behavior to take when an unsupported model is used.\n     * - \"ignore\" will ignore the unsupported model and continue without caching.\n     * - \"warn\" will warn the user and continue without caching.\n     * - \"raise\" will raise an error and stop the agent.\n     * @default \"warn\"\n     */\n    unsupportedModelBehavior: z.ZodOptional<z.ZodEnum<[\"ignore\", \"warn\", \"raise\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    enableCaching?: boolean | undefined;\n    ttl?: \"1h\" | \"5m\" | undefined;\n    minMessagesToCache?: number | undefined;\n    unsupportedModelBehavior?: \"ignore\" | \"raise\" | \"warn\" | undefined;\n}, {\n    enableCaching?: boolean | undefined;\n    ttl?: \"1h\" | \"5m\" | undefined;\n    minMessagesToCache?: number | undefined;\n    unsupportedModelBehavior?: \"ignore\" | \"raise\" | \"warn\" | undefined;\n}>, any>;\nexport {};\n"],"mappings":";;;;;cAEcE,eAAeF,CAAAA,CAAEQ;;;AADoC;;EAmCjE,aA7BiCL,EAAhBH,CAAAA,CAAEI,WAAcD,CAAFH,CAAAA,CAAEG,UAAAA,CAAAA;EAAU;;;;EAUI,GAAzBH,EALfA,CAAAA,CAAEI,WAKeA,CALHJ,CAAAA,CAAEK,OAKCD,CAAAA,CAAAA,IAAAA,EAAAA,IAAAA,CAAAA,CAAAA,CAAAA;EAAW;;;;EAfG,kBAAA,EAehBJ,CAAAA,CAAEI,WAfc,CAeFJ,CAAAA,CAAEM,SAfA,CAAA;EAmC5BG;;;;;AAAuC;AAuHnD;EAAwD,wBAAA,EAnI1BT,CAAAA,CAAEI,WAmIwB,CAnIZJ,CAAAA,CAAEK,OAmIU,CAAA,CAAA,QAAA,EAAA,MAAA,EAAA,OAAA,CAAA,CAAA,CAAA;CAAA,EAAA,OAAqBI,EAlIjET,CAAAA,CAAEO,UAkI+DE,EAAAA;EAA6B,aAKvEN,CAAAA,EAAAA,OAAAA,GAAAA,SAAAA;EAAU,GAA1BH,CAAAA,EAAEI,IAAAA,GAAAA,IAAAA,GAAAA,SAAAA;EAAW,kBAKPC,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAO,wBAArBD,CAAAA,EAAAA,QAAAA,GAAAA,OAAAA,GAAAA,MAAAA,GAAAA,SAAAA;CAAW,EAAA;EAK2B,aAAvBA,CAAAA,EAAAA,OAAAA,GAAAA,SAAAA;EAAW,GAQOJ,CAAAA,EAAEK,IAAAA,GAAAA,IAAAA,GAAAA,SAAAA;EAAO,kBAArBD,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAW,wBAC7BG,CAAAA,EAAAA,QAAAA,GAAAA,OAAAA,GAAAA,MAAAA,GAAAA,SAAAA;CAAU,CAAA;AAxBgJ,KAvH5JE,6BAAAA,GAAgCC,OAuH4H,CAvHpHT,oBAuHoH,CAAA,OAvHxFC,aAuHwF,CAAA,CAAA;AAAvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAzHS,gCAAAA,qBAAqDF,gCAA2F,2BAAXT,CAAAA,CAAEQ;;;;;iBAK5IR,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;;;;;OAK1BH,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEK;;;;;sBAKDL,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEM;;;;;;;;4BAQVN,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEK;YAClCL,CAAAA,CAAEO"}