langchain 1.0.0-alpha.3 → 1.0.0-alpha.5

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

@@ -0,0 +1 @@
+{"version":3,"file":"promptCaching.cjs","names":["z","middlewareOptions?: Partial<z.infer<typeof contextSchema>>","createMiddleware"],"sources":["../../../../src/agents/middlewareAgent/middlewares/promptCaching.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { createMiddleware } from \"../middleware.js\";\n\nconst contextSchema = z.object({\n  // Configuration options\n  enableCaching: z.boolean().default(true),\n  ttl: z.enum([\"5m\", \"1h\"]).default(\"5m\"),\n  minMessagesToCache: z.number().default(3),\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 messages when using Anthropic models,\n * enabling their prompt caching feature. This can significantly reduce costs and latency for\n * applications with repetitive 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 *   middlewares: [\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 *   middlewares: [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 *   middlewares: [\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 *   middlewares: [\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      const enableCaching =\n        runtime.context.enableCaching ?? middlewareOptions?.enableCaching;\n      const ttl = runtime.context.ttl ?? middlewareOptions?.ttl;\n      const 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() !== \"anthropic\") {\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      return {\n        ...options,\n        modelSettings: {\n          cache_control: {\n            type: \"ephemeral\",\n            ttl,\n          },\n        },\n      };\n    },\n  });\n}\n"],"mappings":";;;;;AAGA,MAAM,gBAAgBA,MAAE,OAAO;CAE7B,eAAeA,MAAE,SAAS,CAAC,QAAQ,KAAK;CACxC,KAAKA,MAAE,KAAK,CAAC,MAAM,IAAK,EAAC,CAAC,QAAQ,KAAK;CACvC,oBAAoBA,MAAE,QAAQ,CAAC,QAAQ,EAAE;AAC1C,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuHF,SAAgB,iCACdC,mBACA;AACA,QAAOC,oCAAiB;EACtB,MAAM;EACN;EACA,qBAAqB,CAAC,SAAS,OAAO,YAAY;GAChD,MAAM,gBACJ,QAAQ,QAAQ,iBAAiB,mBAAmB;GACtD,MAAM,MAAM,QAAQ,QAAQ,OAAO,mBAAmB;GACtD,MAAM,qBACJ,QAAQ,QAAQ,sBAChB,mBAAmB;AAGrB,OAAI,CAAC,cACH,QAAO;AAGT,OAAI,QAAQ,OAAO,SAAS,KAAK,YAC/B,OAAM,IAAI,MACR;GAIJ,MAAM,gBACJ,MAAM,SAAS,UAAU,QAAQ,gBAAgB,IAAI;AAEvD,OAAI,gBAAgB,mBAClB,QAAO;AAGT,UAAO;IACL,GAAG;IACH,eAAe,EACb,eAAe;KACb,MAAM;KACN;IACD,EACF;GACF;EACF;CACF,EAAC;AACH"}

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

@@ -0,0 +1,152 @@
+import { AgentMiddleware } from "../types.cjs";
+import { z } from "zod";
+
+//#region src/agents/middlewareAgent/middlewares/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>;
+}, "strip", z.ZodTypeAny, {
+  enableCaching: boolean;
+  ttl: "1h" | "5m";
+  minMessagesToCache: number;
+}, {
+  enableCaching?: boolean | undefined;
+  ttl?: "1h" | "5m" | undefined;
+  minMessagesToCache?: number | undefined;
+}>;
+/**
+ * Creates a prompt caching middleware for Anthropic models to optimize API usage.
+ *
+ * This middleware automatically adds cache control headers to messages when using Anthropic models,
+ * enabling their prompt caching feature. This can significantly reduce costs and latency for
+ * applications with repetitive prompts, long system messages, or extensive conversation histories.
+ *
+ * ## How It Works
+ *
+ * The middleware intercepts model requests and adds cache control metadata that tells Anthropic's
+ * API to cache processed prompt prefixes. On subsequent requests with matching prefixes, the
+ * cached representations are reused, skipping redundant token processing.
+ *
+ * ## Benefits
+ *
+ * - **Cost Reduction**: Avoid reprocessing the same tokens repeatedly (up to 90% savings on cached portions)
+ * - **Lower Latency**: Cached prompts are processed faster as embeddings are pre-computed
+ * - **Better Scalability**: Reduced computational load enables handling more requests
+ * - **Consistent Performance**: Stable response times for repetitive queries
+ *
+ * @param middlewareOptions - Configuration options for the caching behavior
+ * @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`)
+ *
+ * @returns A middleware instance that can be passed to `createAgent`
+ *
+ * @throws {Error} If used with non-Anthropic models
+ *
+ * @example
+ * Basic usage with default settings
+ * ```typescript
+ * import { createAgent } from "langchain";
+ * import { anthropicPromptCachingMiddleware } from "langchain/middleware";
+ *
+ * const agent = createAgent({
+ *   model: "anthropic:claude-3-5-sonnet",
+ *   middlewares: [
+ *     anthropicPromptCachingMiddleware()
+ *   ]
+ * });
+ * ```
+ *
+ * @example
+ * Custom configuration for longer conversations
+ * ```typescript
+ * const cachingMiddleware = anthropicPromptCachingMiddleware({
+ *   ttl: "1h",  // Cache for 1 hour instead of default 5 minutes
+ *   minMessagesToCache: 5  // Only cache after 5 messages
+ * });
+ *
+ * const agent = createAgent({
+ *   model: "anthropic:claude-3-5-sonnet",
+ *   systemMessage: "You are a helpful assistant with deep knowledge of...", // Long system prompt
+ *   middlewares: [cachingMiddleware]
+ * });
+ * ```
+ *
+ * @example
+ * Conditional caching based on runtime context
+ * ```typescript
+ * const agent = createAgent({
+ *   model: "anthropic:claude-3-5-sonnet",
+ *   middlewares: [
+ *     anthropicPromptCachingMiddleware({
+ *       enableCaching: true,
+ *       ttl: "5m"
+ *     })
+ *   ]
+ * });
+ *
+ * // Disable caching for specific requests
+ * await agent.invoke(
+ *   { messages: [new HumanMessage("Process this without caching")] },
+ *   {
+ *     configurable: {
+ *       middleware_context: { enableCaching: false }
+ *     }
+ *   }
+ * );
+ * ```
+ *
+ * @example
+ * Optimal setup for customer support chatbot
+ * ```typescript
+ * const supportAgent = createAgent({
+ *   model: "anthropic:claude-3-5-sonnet",
+ *   systemMessage: `You are a customer support agent for ACME Corp.
+ *
+ *     Company policies:
+ *     - Always be polite and professional
+ *     - Refer to knowledge base for product information
+ *     - Escalate billing issues to human agents
+ *     ... (extensive policies and guidelines)
+ *   `,
+ *   tools: [searchKnowledgeBase, createTicket, checkOrderStatus],
+ *   middlewares: [
+ *     anthropicPromptCachingMiddleware({
+ *       ttl: "1h",  // Long TTL for stable system prompt
+ *       minMessagesToCache: 1  // Cache immediately due to large system prompt
+ *     })
+ *   ]
+ * });
+ * ```
+ *
+ * @remarks
+ * - **Anthropic Only**: This middleware only works with Anthropic models and will throw an error if used with other providers
+ * - **Automatic Application**: Caching is applied automatically when message count exceeds `minMessagesToCache`
+ * - **Cache Scope**: Caches are isolated per API key and cannot be shared across different keys
+ * - **TTL Options**: Only supports "5m" (5 minutes) and "1h" (1 hour) as TTL values per Anthropic's API
+ * - **Best Use Cases**: Long system prompts, multi-turn conversations, repetitive queries, RAG applications
+ * - **Cost Impact**: Cached tokens are billed at 10% of the base input token price, cache writes are billed at 25% of the base
+ *
+ * @see {@link createAgent} for agent creation
+ * @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>;
+}, "strip", z.ZodTypeAny, {
+  enableCaching: boolean;
+  ttl: "1h" | "5m";
+  minMessagesToCache: number;
+}, {
+  enableCaching?: boolean | undefined;
+  ttl?: "1h" | "5m" | undefined;
+  minMessagesToCache?: number | undefined;
+}>, any>;
+//#endregion
+export { anthropicPromptCachingMiddleware };
+//# sourceMappingURL=promptCaching.d.cts.map

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

@@ -0,0 +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/middlewares/promptCaching.d.ts"],"sourcesContent":["import { z } from \"zod\";\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 messages when using Anthropic models,\n * enabling their prompt caching feature. This can significantly reduce costs and latency for\n * applications with repetitive 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 *   middlewares: [\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 *   middlewares: [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 *   middlewares: [\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 *   middlewares: [\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"}

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

@@ -0,0 +1,152 @@
+import { AgentMiddleware } from "../types.js";
+import { z } from "zod";
+
+//#region src/agents/middlewareAgent/middlewares/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>;
+}, "strip", z.ZodTypeAny, {
+  enableCaching: boolean;
+  ttl: "1h" | "5m";
+  minMessagesToCache: number;
+}, {
+  enableCaching?: boolean | undefined;
+  ttl?: "1h" | "5m" | undefined;
+  minMessagesToCache?: number | undefined;
+}>;
+/**
+ * Creates a prompt caching middleware for Anthropic models to optimize API usage.
+ *
+ * This middleware automatically adds cache control headers to messages when using Anthropic models,
+ * enabling their prompt caching feature. This can significantly reduce costs and latency for
+ * applications with repetitive prompts, long system messages, or extensive conversation histories.
+ *
+ * ## How It Works
+ *
+ * The middleware intercepts model requests and adds cache control metadata that tells Anthropic's
+ * API to cache processed prompt prefixes. On subsequent requests with matching prefixes, the
+ * cached representations are reused, skipping redundant token processing.
+ *
+ * ## Benefits
+ *
+ * - **Cost Reduction**: Avoid reprocessing the same tokens repeatedly (up to 90% savings on cached portions)
+ * - **Lower Latency**: Cached prompts are processed faster as embeddings are pre-computed
+ * - **Better Scalability**: Reduced computational load enables handling more requests
+ * - **Consistent Performance**: Stable response times for repetitive queries
+ *
+ * @param middlewareOptions - Configuration options for the caching behavior
+ * @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`)
+ *
+ * @returns A middleware instance that can be passed to `createAgent`
+ *
+ * @throws {Error} If used with non-Anthropic models
+ *
+ * @example
+ * Basic usage with default settings
+ * ```typescript
+ * import { createAgent } from "langchain";
+ * import { anthropicPromptCachingMiddleware } from "langchain/middleware";
+ *
+ * const agent = createAgent({
+ *   model: "anthropic:claude-3-5-sonnet",
+ *   middlewares: [
+ *     anthropicPromptCachingMiddleware()
+ *   ]
+ * });
+ * ```
+ *
+ * @example
+ * Custom configuration for longer conversations
+ * ```typescript
+ * const cachingMiddleware = anthropicPromptCachingMiddleware({
+ *   ttl: "1h",  // Cache for 1 hour instead of default 5 minutes
+ *   minMessagesToCache: 5  // Only cache after 5 messages
+ * });
+ *
+ * const agent = createAgent({
+ *   model: "anthropic:claude-3-5-sonnet",
+ *   systemMessage: "You are a helpful assistant with deep knowledge of...", // Long system prompt
+ *   middlewares: [cachingMiddleware]
+ * });
+ * ```
+ *
+ * @example
+ * Conditional caching based on runtime context
+ * ```typescript
+ * const agent = createAgent({
+ *   model: "anthropic:claude-3-5-sonnet",
+ *   middlewares: [
+ *     anthropicPromptCachingMiddleware({
+ *       enableCaching: true,
+ *       ttl: "5m"
+ *     })
+ *   ]
+ * });
+ *
+ * // Disable caching for specific requests
+ * await agent.invoke(
+ *   { messages: [new HumanMessage("Process this without caching")] },
+ *   {
+ *     configurable: {
+ *       middleware_context: { enableCaching: false }
+ *     }
+ *   }
+ * );
+ * ```
+ *
+ * @example
+ * Optimal setup for customer support chatbot
+ * ```typescript
+ * const supportAgent = createAgent({
+ *   model: "anthropic:claude-3-5-sonnet",
+ *   systemMessage: `You are a customer support agent for ACME Corp.
+ *
+ *     Company policies:
+ *     - Always be polite and professional
+ *     - Refer to knowledge base for product information
+ *     - Escalate billing issues to human agents
+ *     ... (extensive policies and guidelines)
+ *   `,
+ *   tools: [searchKnowledgeBase, createTicket, checkOrderStatus],
+ *   middlewares: [
+ *     anthropicPromptCachingMiddleware({
+ *       ttl: "1h",  // Long TTL for stable system prompt
+ *       minMessagesToCache: 1  // Cache immediately due to large system prompt
+ *     })
+ *   ]
+ * });
+ * ```
+ *
+ * @remarks
+ * - **Anthropic Only**: This middleware only works with Anthropic models and will throw an error if used with other providers
+ * - **Automatic Application**: Caching is applied automatically when message count exceeds `minMessagesToCache`
+ * - **Cache Scope**: Caches are isolated per API key and cannot be shared across different keys
+ * - **TTL Options**: Only supports "5m" (5 minutes) and "1h" (1 hour) as TTL values per Anthropic's API
+ * - **Best Use Cases**: Long system prompts, multi-turn conversations, repetitive queries, RAG applications
+ * - **Cost Impact**: Cached tokens are billed at 10% of the base input token price, cache writes are billed at 25% of the base
+ *
+ * @see {@link createAgent} for agent creation
+ * @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>;
+}, "strip", z.ZodTypeAny, {
+  enableCaching: boolean;
+  ttl: "1h" | "5m";
+  minMessagesToCache: number;
+}, {
+  enableCaching?: boolean | undefined;
+  ttl?: "1h" | "5m" | undefined;
+  minMessagesToCache?: number | undefined;
+}>, any>;
+//#endregion
+export { anthropicPromptCachingMiddleware };
+//# sourceMappingURL=promptCaching.d.ts.map

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

@@ -0,0 +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/middlewares/promptCaching.d.ts"],"sourcesContent":["import { z } from \"zod\";\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 messages when using Anthropic models,\n * enabling their prompt caching feature. This can significantly reduce costs and latency for\n * applications with repetitive 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 *   middlewares: [\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 *   middlewares: [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 *   middlewares: [\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 *   middlewares: [\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"}

package/dist/agents/middlewareAgent/middlewares/promptCaching.js

@@ -0,0 +1,152 @@
+import { createMiddleware } from "../middleware.js";
+import { z } from "zod";
+
+//#region src/agents/middlewareAgent/middlewares/promptCaching.ts
+const contextSchema = z.object({
+	enableCaching: z.boolean().default(true),
+	ttl: z.enum(["5m", "1h"]).default("5m"),
+	minMessagesToCache: z.number().default(3)
+});
+/**
+* Creates a prompt caching middleware for Anthropic models to optimize API usage.
+*
+* This middleware automatically adds cache control headers to messages when using Anthropic models,
+* enabling their prompt caching feature. This can significantly reduce costs and latency for
+* applications with repetitive prompts, long system messages, or extensive conversation histories.
+*
+* ## How It Works
+*
+* The middleware intercepts model requests and adds cache control metadata that tells Anthropic's
+* API to cache processed prompt prefixes. On subsequent requests with matching prefixes, the
+* cached representations are reused, skipping redundant token processing.
+*
+* ## Benefits
+*
+* - **Cost Reduction**: Avoid reprocessing the same tokens repeatedly (up to 90% savings on cached portions)
+* - **Lower Latency**: Cached prompts are processed faster as embeddings are pre-computed
+* - **Better Scalability**: Reduced computational load enables handling more requests
+* - **Consistent Performance**: Stable response times for repetitive queries
+*
+* @param middlewareOptions - Configuration options for the caching behavior
+* @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`)
+*
+* @returns A middleware instance that can be passed to `createAgent`
+*
+* @throws {Error} If used with non-Anthropic models
+*
+* @example
+* Basic usage with default settings
+* ```typescript
+* import { createAgent } from "langchain";
+* import { anthropicPromptCachingMiddleware } from "langchain/middleware";
+*
+* const agent = createAgent({
+*   model: "anthropic:claude-3-5-sonnet",
+*   middlewares: [
+*     anthropicPromptCachingMiddleware()
+*   ]
+* });
+* ```
+*
+* @example
+* Custom configuration for longer conversations
+* ```typescript
+* const cachingMiddleware = anthropicPromptCachingMiddleware({
+*   ttl: "1h",  // Cache for 1 hour instead of default 5 minutes
+*   minMessagesToCache: 5  // Only cache after 5 messages
+* });
+*
+* const agent = createAgent({
+*   model: "anthropic:claude-3-5-sonnet",
+*   systemMessage: "You are a helpful assistant with deep knowledge of...", // Long system prompt
+*   middlewares: [cachingMiddleware]
+* });
+* ```
+*
+* @example
+* Conditional caching based on runtime context
+* ```typescript
+* const agent = createAgent({
+*   model: "anthropic:claude-3-5-sonnet",
+*   middlewares: [
+*     anthropicPromptCachingMiddleware({
+*       enableCaching: true,
+*       ttl: "5m"
+*     })
+*   ]
+* });
+*
+* // Disable caching for specific requests
+* await agent.invoke(
+*   { messages: [new HumanMessage("Process this without caching")] },
+*   {
+*     configurable: {
+*       middleware_context: { enableCaching: false }
+*     }
+*   }
+* );
+* ```
+*
+* @example
+* Optimal setup for customer support chatbot
+* ```typescript
+* const supportAgent = createAgent({
+*   model: "anthropic:claude-3-5-sonnet",
+*   systemMessage: `You are a customer support agent for ACME Corp.
+*
+*     Company policies:
+*     - Always be polite and professional
+*     - Refer to knowledge base for product information
+*     - Escalate billing issues to human agents
+*     ... (extensive policies and guidelines)
+*   `,
+*   tools: [searchKnowledgeBase, createTicket, checkOrderStatus],
+*   middlewares: [
+*     anthropicPromptCachingMiddleware({
+*       ttl: "1h",  // Long TTL for stable system prompt
+*       minMessagesToCache: 1  // Cache immediately due to large system prompt
+*     })
+*   ]
+* });
+* ```
+*
+* @remarks
+* - **Anthropic Only**: This middleware only works with Anthropic models and will throw an error if used with other providers
+* - **Automatic Application**: Caching is applied automatically when message count exceeds `minMessagesToCache`
+* - **Cache Scope**: Caches are isolated per API key and cannot be shared across different keys
+* - **TTL Options**: Only supports "5m" (5 minutes) and "1h" (1 hour) as TTL values per Anthropic's API
+* - **Best Use Cases**: Long system prompts, multi-turn conversations, repetitive queries, RAG applications
+* - **Cost Impact**: Cached tokens are billed at 10% of the base input token price, cache writes are billed at 25% of the base
+*
+* @see {@link createAgent} for agent creation
+* @see {@link https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching} Anthropic's prompt caching documentation
+* @public
+*/
+function anthropicPromptCachingMiddleware(middlewareOptions) {
+	return createMiddleware({
+		name: "PromptCachingMiddleware",
+		contextSchema,
+		prepareModelRequest: (options, state, runtime) => {
+			const enableCaching = runtime.context.enableCaching ?? middlewareOptions?.enableCaching;
+			const ttl = runtime.context.ttl ?? middlewareOptions?.ttl;
+			const minMessagesToCache = runtime.context.minMessagesToCache ?? middlewareOptions?.minMessagesToCache;
+			if (!enableCaching) return void 0;
+			if (options.model?.getName() !== "anthropic") 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;
+			return {
+				...options,
+				modelSettings: { cache_control: {
+					type: "ephemeral",
+					ttl
+				} }
+			};
+		}
+	});
+}
+
+//#endregion
+export { anthropicPromptCachingMiddleware };
+//# sourceMappingURL=promptCaching.js.map

package/dist/agents/middlewareAgent/middlewares/promptCaching.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"promptCaching.js","names":["middlewareOptions?: Partial<z.infer<typeof contextSchema>>"],"sources":["../../../../src/agents/middlewareAgent/middlewares/promptCaching.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { createMiddleware } from \"../middleware.js\";\n\nconst contextSchema = z.object({\n  // Configuration options\n  enableCaching: z.boolean().default(true),\n  ttl: z.enum([\"5m\", \"1h\"]).default(\"5m\"),\n  minMessagesToCache: z.number().default(3),\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 messages when using Anthropic models,\n * enabling their prompt caching feature. This can significantly reduce costs and latency for\n * applications with repetitive 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 *   middlewares: [\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 *   middlewares: [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 *   middlewares: [\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 *   middlewares: [\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      const enableCaching =\n        runtime.context.enableCaching ?? middlewareOptions?.enableCaching;\n      const ttl = runtime.context.ttl ?? middlewareOptions?.ttl;\n      const 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() !== \"anthropic\") {\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      return {\n        ...options,\n        modelSettings: {\n          cache_control: {\n            type: \"ephemeral\",\n            ttl,\n          },\n        },\n      };\n    },\n  });\n}\n"],"mappings":";;;;AAGA,MAAM,gBAAgB,EAAE,OAAO;CAE7B,eAAe,EAAE,SAAS,CAAC,QAAQ,KAAK;CACxC,KAAK,EAAE,KAAK,CAAC,MAAM,IAAK,EAAC,CAAC,QAAQ,KAAK;CACvC,oBAAoB,EAAE,QAAQ,CAAC,QAAQ,EAAE;AAC1C,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuHF,SAAgB,iCACdA,mBACA;AACA,QAAO,iBAAiB;EACtB,MAAM;EACN;EACA,qBAAqB,CAAC,SAAS,OAAO,YAAY;GAChD,MAAM,gBACJ,QAAQ,QAAQ,iBAAiB,mBAAmB;GACtD,MAAM,MAAM,QAAQ,QAAQ,OAAO,mBAAmB;GACtD,MAAM,qBACJ,QAAQ,QAAQ,sBAChB,mBAAmB;AAGrB,OAAI,CAAC,cACH,QAAO;AAGT,OAAI,QAAQ,OAAO,SAAS,KAAK,YAC/B,OAAM,IAAI,MACR;GAIJ,MAAM,gBACJ,MAAM,SAAS,UAAU,QAAQ,gBAAgB,IAAI;AAEvD,OAAI,gBAAgB,mBAClB,QAAO;AAGT,UAAO;IACL,GAAG;IACH,eAAe,EACb,eAAe;KACb,MAAM;KACN;IACD,EACF;GACF;EACF;CACF,EAAC;AACH"}