langchain 1.0.0-alpha.7 → 1.0.0-alpha.9

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

@@ -0,0 +1 @@
+{"version":3,"file":"piiRedaction.js","names":["text: string","rules: Record<string, RegExp>","redactionMap: RedactionMap","message: BaseMessage","config: ProcessHumanMessageConfig","options: PIIRedactionMiddlewareConfig","structuredResponse: Record<string, unknown> | undefined","structuredResponse"],"sources":["../../../src/agents/middleware/piiRedaction.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport {\n  BaseMessage,\n  AIMessage,\n  HumanMessage,\n  ToolMessage,\n  RemoveMessage,\n  SystemMessage,\n} from \"@langchain/core/messages\";\nimport type { InferInteropZodInput } from \"@langchain/core/utils/types\";\n\nimport { createMiddleware } from \"../middleware.js\";\n\n/**\n * Type for the redaction map that stores original values by ID\n */\ntype RedactionMap = Record<string, string>;\n\n/**\n * Configuration schema for the Input Guardrails middleware\n */\nconst contextSchema = z.object({\n  /**\n   * A record of PII detection rules to apply\n   * @default DEFAULT_PII_RULES (with enabled rules only)\n   */\n  rules: z\n    .record(\n      z.string(),\n      z.instanceof(RegExp).describe(\"Regular expression pattern to match PII\")\n    )\n    .optional(),\n});\n\nexport type PIIRedactionMiddlewareConfig = InferInteropZodInput<\n  typeof contextSchema\n>;\n\n/**\n * Generate a unique ID for a redaction\n */\nfunction generateRedactionId(): string {\n  return Math.random().toString(36).substring(2, 11);\n}\n\n/**\n * Apply PII detection rules to text with ID tracking\n */\nfunction applyPIIRules(\n  text: string,\n  rules: Record<string, RegExp>,\n  redactionMap: RedactionMap\n): string {\n  let processedText = text;\n\n  for (const [name, pattern] of Object.entries(rules)) {\n    const replacement = name.toUpperCase().replace(/[^a-zA-Z0-9_-]/g, \"\");\n    processedText = processedText.replace(pattern, (match) => {\n      const id = generateRedactionId();\n      redactionMap[id] = match;\n      // Create a trackable replacement like [REDACTED_SSN_abc123]\n      return `[REDACTED_${replacement}_${id}]`;\n    });\n  }\n\n  return processedText;\n}\n\ninterface ProcessHumanMessageConfig {\n  rules: Record<string, RegExp>;\n  redactionMap: RedactionMap;\n}\n\n/**\n * Process a single human message for PII detection and redaction\n */\nasync function processMessage(\n  message: BaseMessage,\n  config: ProcessHumanMessageConfig\n): Promise<BaseMessage> {\n  /**\n   * handle basic message types\n   */\n  if (\n    HumanMessage.isInstance(message) ||\n    ToolMessage.isInstance(message) ||\n    SystemMessage.isInstance(message)\n  ) {\n    const content = message.content as string;\n    const processedContent = await applyPIIRules(\n      content,\n      config.rules,\n      config.redactionMap\n    );\n\n    if (processedContent !== content) {\n      const MessageConstructor = Object.getPrototypeOf(message).constructor;\n      return new MessageConstructor({\n        ...message,\n        content: processedContent,\n      });\n    }\n\n    return message;\n  }\n\n  /**\n   * Handle AI messages\n   */\n  if (AIMessage.isInstance(message)) {\n    const content =\n      typeof message.content === \"string\"\n        ? message.content\n        : JSON.stringify(message.content);\n    const toolCalls = JSON.stringify(message.tool_calls);\n    const processedContent = await applyPIIRules(\n      content,\n      config.rules,\n      config.redactionMap\n    );\n    const processedToolCalls = await applyPIIRules(\n      toolCalls,\n      config.rules,\n      config.redactionMap\n    );\n\n    if (processedContent !== content || processedToolCalls !== toolCalls) {\n      return new AIMessage({\n        ...message,\n        content:\n          typeof message.content === \"string\"\n            ? processedContent\n            : JSON.parse(processedContent),\n        tool_calls: JSON.parse(processedToolCalls),\n      });\n    }\n\n    return message;\n  }\n\n  throw new Error(`Unsupported message type: ${message.type}`);\n}\n\n/**\n * Restore original values from redacted text using the redaction map\n */\nfunction restoreRedactedValues(\n  text: string,\n  redactionMap: RedactionMap\n): string {\n  let restoredText = text;\n\n  // Pattern to match redacted values like [REDACTED_SSN_abc123]\n  const redactionPattern = /\\[REDACTED_[A-Z_]+_(\\w+)\\]/g;\n\n  restoredText = restoredText.replace(redactionPattern, (match, id) => {\n    if (redactionMap[id]) {\n      return redactionMap[id];\n    }\n    return match; // Keep original if no mapping found\n  });\n\n  return restoredText;\n}\n\n/**\n * Restore redacted values in a message (creates a new message object)\n */\nfunction restoreMessage(\n  message: BaseMessage,\n  redactionMap: RedactionMap\n): { message: BaseMessage; changed: boolean } {\n  /**\n   * handle basic message types\n   */\n  if (\n    HumanMessage.isInstance(message) ||\n    ToolMessage.isInstance(message) ||\n    SystemMessage.isInstance(message)\n  ) {\n    const content = message.content as string;\n    const restoredContent = restoreRedactedValues(content, redactionMap);\n    if (restoredContent !== content) {\n      const MessageConstructor = Object.getPrototypeOf(message).constructor;\n      const newMessage = new MessageConstructor({\n        ...message,\n        content: restoredContent,\n      });\n      return { message: newMessage, changed: true };\n    }\n    return { message, changed: false };\n  }\n\n  /**\n   * handle AI messages\n   */\n  if (AIMessage.isInstance(message)) {\n    const content =\n      typeof message.content === \"string\"\n        ? message.content\n        : JSON.stringify(message.content);\n    const toolCalls = JSON.stringify(message.tool_calls);\n    const processedContent = restoreRedactedValues(content, redactionMap);\n    const processedToolCalls = restoreRedactedValues(toolCalls, redactionMap);\n    if (processedContent !== content || processedToolCalls !== toolCalls) {\n      return {\n        message: new AIMessage({\n          ...message,\n          content:\n            typeof message.content === \"string\"\n              ? processedContent\n              : JSON.parse(processedContent),\n          tool_calls: JSON.parse(processedToolCalls),\n        }),\n        changed: true,\n      };\n    }\n\n    return { message, changed: false };\n  }\n\n  throw new Error(`Unsupported message type: ${message.type}`);\n}\n\n/**\n * Creates a middleware that detects and redacts personally identifiable information (PII)\n * from messages before they are sent to model providers, and restores original values\n * in model responses for tool execution.\n *\n * ## Mechanism\n *\n * The middleware intercepts agent execution at two points:\n *\n * ### Request Phase (`wrapModelCall`)\n * - Applies regex-based pattern matching to all message content (HumanMessage, ToolMessage, SystemMessage, AIMessage)\n * - Processes both message text and AIMessage tool call arguments\n * - Each matched pattern generates:\n *   - Unique identifier: `generateRedactionId()` → `\"abc123\"`\n *   - Redaction marker: `[REDACTED_{RULE_NAME}_{ID}]` → `\"[REDACTED_SSN_abc123]\"`\n *   - Redaction map entry: `{ \"abc123\": \"123-45-6789\" }`\n * - Returns modified request with redacted message content\n *\n * ### Response Phase (`afterModel`)\n * - Scans AIMessage responses for redaction markers matching pattern: `/\\[REDACTED_[A-Z_]+_(\\w+)\\]/g`\n * - Replaces markers with original values from redaction map\n * - Handles both standard responses and structured output (via tool calls or JSON content)\n * - For structured output, restores values in both the tool call arguments and the `structuredResponse` state field\n * - Returns new message instances via RemoveMessage/AIMessage to update state\n *\n * ## Data Flow\n *\n * ```\n * User Input: \"My SSN is 123-45-6789\"\n *     ↓ [beforeModel]\n * Model Request: \"My SSN is [REDACTED_SSN_abc123]\"\n *     ↓ [model invocation]\n * Model Response: tool_call({ \"ssn\": \"[REDACTED_SSN_abc123]\" })\n *     ↓ [afterModel]\n * Tool Execution: tool({ \"ssn\": \"123-45-6789\" })\n * ```\n *\n * ## Limitations\n *\n * This middleware provides model provider isolation only. PII may still be present in:\n * - LangGraph state checkpoints (memory, databases)\n * - Network traffic between client and application server\n * - Application logs and trace data\n * - Tool execution arguments and responses\n * - Final agent output\n *\n * For comprehensive PII protection, implement additional controls at the application,\n * network, and storage layers.\n *\n * @param options - Configuration options\n * @param options.rules - Record of detection rules mapping rule names to regex patterns.\n *   Rule names are normalized to uppercase and used in redaction markers.\n *   Patterns must use the global flag (`/pattern/g`) to match all occurrences.\n *\n * @returns Middleware instance for use with `createAgent`\n *\n * @example Basic usage with custom rules\n * ```typescript\n * import { piiRedactionMiddleware } from \"langchain\";\n * import { createAgent } from \"langchain\";\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod/v3\";\n *\n * const PII_RULES = {\n *   ssn: /\\b\\d{3}-?\\d{2}-?\\d{4}\\b/g,\n *   email: /\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}\\b/g,\n *   phone: /\\b\\d{3}[-.]?\\d{3}[-.]?\\d{4}\\b/g,\n * };\n *\n * const lookupUser = tool(async ({ ssn }) => {\n *   // Receives original value: \"123-45-6789\"\n *   return { name: \"John Doe\", account: \"active\" };\n * }, {\n *   name: \"lookup_user\",\n *   description: \"Look up user by SSN\",\n *   schema: z.object({ ssn: z.string() })\n * });\n *\n * const agent = createAgent({\n *   model: new ChatOpenAI({ model: \"gpt-4\" }),\n *   tools: [lookupUser],\n *   middleware: [piiRedactionMiddleware({ rules: PII_RULES })]\n * });\n *\n * const result = await agent.invoke({\n *   messages: [new HumanMessage(\"Look up SSN 123-45-6789\")]\n * });\n * // Model request: \"Look up SSN [REDACTED_SSN_abc123]\"\n * // Model response: tool_call({ \"ssn\": \"[REDACTED_SSN_abc123]\" })\n * // Tool receives: { \"ssn\": \"123-45-6789\" }\n * ```\n *\n * @example Runtime rule configuration via context\n * ```typescript\n * const agent = createAgent({\n *   model: new ChatOpenAI({ model: \"gpt-4\" }),\n *   tools: [someTool],\n *   middleware: [piiRedactionMiddleware()]\n * });\n *\n * // Configure rules at runtime via middleware context\n * const result = await agent.invoke(\n *   { messages: [new HumanMessage(\"...\")] },\n *   {\n *     configurable: {\n *       PIIRedactionMiddleware: {\n *         rules: {\n *           ssn: /\\b\\d{3}-?\\d{2}-?\\d{4}\\b/g,\n *           email: /\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}\\b/g,\n *         }\n *       }\n *     }\n *   }\n * );\n * ```\n *\n * @example Custom rule patterns\n * ```typescript\n * const customRules = {\n *   employee_id: /EMP-\\d{6}/g,\n *   api_key: /sk-[a-zA-Z0-9]{32}/g,\n *   credit_card: /\\b\\d{4}[- ]?\\d{4}[- ]?\\d{4}[- ]?\\d{4}\\b/g,\n * };\n *\n * const middleware = piiRedactionMiddleware({ rules: customRules });\n * // Generates markers like: [REDACTED_EMPLOYEE_ID_xyz789]\n * ```\n *\n * @public\n */\nexport function piiRedactionMiddleware(\n  options: PIIRedactionMiddlewareConfig = {}\n): ReturnType<typeof createMiddleware> {\n  const redactionMap: RedactionMap = {};\n\n  return createMiddleware({\n    name: \"PIIRedactionMiddleware\",\n    contextSchema,\n    wrapModelCall: async (request, handler) => {\n      /**\n       * Merge options with context, following bigTool.ts pattern\n       */\n      const rules = request.runtime.context.rules ?? options.rules ?? {};\n\n      /**\n       * If no rules are provided, skip processing\n       */\n      if (Object.keys(rules).length === 0) {\n        return handler(request);\n      }\n\n      const processedMessages = await Promise.all(\n        request.state.messages.map((message: BaseMessage) =>\n          processMessage(message, {\n            rules,\n            redactionMap,\n          })\n        )\n      );\n\n      return handler({\n        ...request,\n        messages: processedMessages,\n      });\n    },\n    afterModel: async (state) => {\n      /**\n       * If no redactions were made, skip processing\n       */\n      if (Object.keys(redactionMap).length === 0) {\n        return;\n      }\n\n      const lastMessage = state.messages.at(-1);\n      if (!AIMessage.isInstance(lastMessage)) {\n        return;\n      }\n\n      /**\n       * In cases where we do structured output via tool calls, we also have to look at the second last message\n       * as we add a custom last message to the messages array.\n       */\n      const secondLastMessage = state.messages.at(-2);\n\n      const { message: restoredLastMessage, changed } = restoreMessage(\n        lastMessage,\n        redactionMap\n      );\n\n      if (!changed) {\n        return;\n      }\n\n      /**\n       * Identify if the last message is a structured response and restore the values if so\n       */\n      let structuredResponse: Record<string, unknown> | undefined;\n      if (\n        AIMessage.isInstance(lastMessage) &&\n        lastMessage?.tool_calls?.length === 0 &&\n        typeof lastMessage.content === \"string\" &&\n        lastMessage.content.startsWith(\"{\") &&\n        lastMessage.content.endsWith(\"}\")\n      ) {\n        try {\n          structuredResponse = JSON.parse(\n            restoreRedactedValues(lastMessage.content, redactionMap)\n          );\n        } catch {\n          // ignore\n        }\n      }\n\n      /**\n       * Check if the second last message is a structured response tool call\n       */\n      const isStructuredResponseToolCall =\n        AIMessage.isInstance(secondLastMessage) &&\n        secondLastMessage?.tool_calls?.length !== 0 &&\n        secondLastMessage?.tool_calls?.some((call) =>\n          call.name.startsWith(\"extract-\")\n        );\n      if (isStructuredResponseToolCall) {\n        const {\n          message: restoredSecondLastMessage,\n          changed: changedSecondLastMessage,\n        } = restoreMessage(secondLastMessage, redactionMap);\n        const structuredResponseRedacted = secondLastMessage.tool_calls?.find(\n          (call) => call.name.startsWith(\"extract-\")\n        )?.args;\n        const structuredResponse = structuredResponseRedacted\n          ? JSON.parse(\n              restoreRedactedValues(\n                JSON.stringify(structuredResponseRedacted),\n                redactionMap\n              )\n            )\n          : undefined;\n        if (changed || changedSecondLastMessage) {\n          return {\n            ...state,\n            ...(structuredResponse ? { structuredResponse } : {}),\n            messages: [\n              new RemoveMessage({ id: secondLastMessage.id as string }),\n              new RemoveMessage({ id: lastMessage.id as string }),\n              restoredSecondLastMessage,\n              restoredLastMessage,\n            ],\n          };\n        }\n      }\n\n      return {\n        ...state,\n        ...(structuredResponse ? { structuredResponse } : {}),\n        messages: [\n          new RemoveMessage({ id: lastMessage.id as string }),\n          restoredLastMessage,\n        ],\n      };\n    },\n  });\n}\n"],"mappings":"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"}

package/dist/agents/middleware/promptCaching.cjs

@@ -0,0 +1,213 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_middleware = require('../middleware.cjs');
+const zod_v3 = require_rolldown_runtime.__toESM(require("zod/v3"));
+
+//#region src/agents/middleware/promptCaching.ts
+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().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) {
+		super(message);
+		this.name = "PromptCachingMiddlewareError";
+	}
+};
+/**
+* Creates a prompt caching middleware for Anthropic models to optimize API usage.
+*
+* This middleware automatically adds cache control headers to the last messages when using Anthropic models,
+* enabling their prompt caching feature. This can significantly reduce costs 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`)
+* @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`
+*
+* @throws {Error} If used with non-Anthropic models
+*
+* @example
+* Basic usage with default settings
+* ```typescript
+* import { createAgent } from "langchain";
+* import { anthropicPromptCachingMiddleware } from "langchain";
+*
+* const agent = createAgent({
+*   model: "anthropic:claude-3-5-sonnet",
+*   middleware: [
+*     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",
+*   systemPrompt: "You are a helpful assistant with deep knowledge of...", // Long system prompt
+*   middleware: [cachingMiddleware]
+* });
+* ```
+*
+* @example
+* Conditional caching based on runtime context
+* ```typescript
+* const agent = createAgent({
+*   model: "anthropic:claude-3-5-sonnet",
+*   middleware: [
+*     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",
+*   systemPrompt: `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],
+*   middleware: [
+*     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 require_middleware.createMiddleware({
+		name: "PromptCachingMiddleware",
+		contextSchema,
+		wrapModelCall: (request, handler) => {
+			/**
+			* Prefer runtime context values over middleware options values over defaults
+			*/
+			const enableCaching = request.runtime.context.enableCaching ?? middlewareOptions?.enableCaching ?? DEFAULT_ENABLE_CACHING;
+			const ttl = request.runtime.context.ttl ?? middlewareOptions?.ttl ?? DEFAULT_TTL;
+			const minMessagesToCache = request.runtime.context.minMessagesToCache ?? middlewareOptions?.minMessagesToCache ?? DEFAULT_MIN_MESSAGES_TO_CACHE;
+			const unsupportedModelBehavior = request.runtime.context.unsupportedModelBehavior ?? middlewareOptions?.unsupportedModelBehavior ?? DEFAULT_UNSUPPORTED_MODEL_BEHAVIOR;
+			if (!enableCaching || !request.model) return handler(request);
+			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 handler(request);
+			}
+			const messagesCount = request.state.messages.length + (request.systemPrompt ? 1 : 0);
+			if (messagesCount < minMessagesToCache) return handler(request);
+			/**
+			* Add cache_control to the last message
+			*/
+			const lastMessage = request.messages.at(-1);
+			if (!lastMessage) return handler(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 handler({
+					...request,
+					messages: [...request.messages.slice(0, -1), newMessage]
+				});
+			} else if (typeof lastMessage.content === "string") {
+				const newMessage = new NewMessageConstructor({
+					...lastMessage,
+					content: [{
+						type: "text",
+						text: lastMessage.content,
+						cache_control: {
+							type: "ephemeral",
+							ttl
+						}
+					}]
+				});
+				return handler({
+					...request,
+					messages: [...request.messages.slice(0, -1), newMessage]
+				});
+			}
+			throw new PromptCachingMiddlewareError("Last message content is not a string or array");
+		}
+	});
+}
+
+//#endregion
+exports.anthropicPromptCachingMiddleware = anthropicPromptCachingMiddleware;
+//# sourceMappingURL=promptCaching.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"promptCaching.cjs","names":["z","message: string","middlewareOptions?: PromptCachingMiddlewareConfig","createMiddleware"],"sources":["../../../src/agents/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    wrapModelCall: (request, handler) => {\n      /**\n       * Prefer runtime context values over middleware options values over defaults\n       */\n      const enableCaching =\n        request.runtime.context.enableCaching ??\n        middlewareOptions?.enableCaching ??\n        DEFAULT_ENABLE_CACHING;\n      const ttl =\n        request.runtime.context.ttl ?? middlewareOptions?.ttl ?? DEFAULT_TTL;\n      const minMessagesToCache =\n        request.runtime.context.minMessagesToCache ??\n        middlewareOptions?.minMessagesToCache ??\n        DEFAULT_MIN_MESSAGES_TO_CACHE;\n      const unsupportedModelBehavior =\n        request.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 handler(request);\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 handler(request);\n      }\n\n      const messagesCount =\n        request.state.messages.length + (request.systemPrompt ? 1 : 0);\n\n      if (messagesCount < minMessagesToCache) {\n        return handler(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 handler(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 handler({\n          ...request,\n          messages: [...request.messages.slice(0, -1), newMessage],\n        });\n      } else if (typeof lastMessage.content === \"string\") {\n        const newMessage = new NewMessageConstructor({\n          ...lastMessage,\n          content: [\n            {\n              type: \"text\",\n              text: lastMessage.content,\n              cache_control: {\n                type: \"ephemeral\",\n                ttl,\n              },\n            },\n          ],\n        });\n        return handler({\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":"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"}

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

@@ -0,0 +1,197 @@
+import { AgentMiddleware } from "./types.cjs";
+import { InferInteropZodInput } from "@langchain/core/utils/types";
+import { z } from "zod/v3";
+
+//#region src/agents/middleware/promptCaching.d.ts
+declare const contextSchema: 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 | 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.
+ *
+ * This middleware automatically adds cache control headers to the last messages when using Anthropic models,
+ * enabling their prompt caching feature. This can significantly reduce costs 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`)
+ * @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`
+ *
+ * @throws {Error} If used with non-Anthropic models
+ *
+ * @example
+ * Basic usage with default settings
+ * ```typescript
+ * import { createAgent } from "langchain";
+ * import { anthropicPromptCachingMiddleware } from "langchain";
+ *
+ * const agent = createAgent({
+ *   model: "anthropic:claude-3-5-sonnet",
+ *   middleware: [
+ *     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",
+ *   systemPrompt: "You are a helpful assistant with deep knowledge of...", // Long system prompt
+ *   middleware: [cachingMiddleware]
+ * });
+ * ```
+ *
+ * @example
+ * Conditional caching based on runtime context
+ * ```typescript
+ * const agent = createAgent({
+ *   model: "anthropic:claude-3-5-sonnet",
+ *   middleware: [
+ *     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",
+ *   systemPrompt: `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],
+ *   middleware: [
+ *     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?: 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 | 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 { PromptCachingMiddlewareConfig, anthropicPromptCachingMiddleware };
+//# sourceMappingURL=promptCaching.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"promptCaching.d.cts","names":["z","InferInteropZodInput","contextSchema","ZodBoolean","ZodOptional","ZodEnum","ZodNumber","ZodTypeAny","ZodObject","PromptCachingMiddlewareConfig","Partial","anthropicPromptCachingMiddleware","__types_js4","AgentMiddleware"],"sources":["../../../src/agents/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(\"./types.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"}