langchain 1.0.0-alpha.5 → 1.0.0-alpha.7

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

@@ -1 +0,0 @@
-{"version":3,"file":"hitl.d.ts","names":["z","contextSchema","ZodString","ZodBoolean","ZodOptional","ZodTypeAny","ZodObject","ZodRecord","ZodDefault","Record","humanInTheLoopMiddleware","input","___types_js1","AgentMiddleware"],"sources":["../../../../src/agents/middlewareAgent/middlewares/hitl.d.ts"],"sourcesContent":["import { z } from \"zod\";\ndeclare const contextSchema: z.ZodObject<{\n    toolConfigs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{\n        requireApproval: z.ZodOptional<z.ZodBoolean>;\n        description: z.ZodOptional<z.ZodString>;\n    }, \"strip\", z.ZodTypeAny, {\n        requireApproval?: boolean | undefined;\n        description?: string | undefined;\n    }, {\n        requireApproval?: boolean | undefined;\n        description?: string | undefined;\n    }>>>;\n    messagePrefix: z.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    toolConfigs: Record<string, {\n        requireApproval?: boolean | undefined;\n        description?: string | undefined;\n    }>;\n    messagePrefix: string;\n}, {\n    toolConfigs?: Record<string, {\n        requireApproval?: boolean | undefined;\n        description?: string | undefined;\n    }> | undefined;\n    messagePrefix?: string | undefined;\n}>;\n/**\n * Creates a Human-in-the-Loop (HITL) middleware for tool approval and oversight.\n *\n * This middleware intercepts tool calls made by an AI agent and provides human oversight\n * capabilities before execution. It enables selective approval workflows where certain tools\n * require human intervention while others can execute automatically.\n *\n * ## Features\n *\n * - **Selective Tool Approval**: Configure which tools require human approval\n * - **Multiple Response Types**: Accept, edit, ignore, or manually respond to tool calls\n * - **Asynchronous Workflow**: Uses LangGraph's interrupt mechanism for non-blocking approval\n * - **Custom Approval Messages**: Provide context-specific descriptions for approval requests\n *\n * ## Response Types\n *\n * When a tool requires approval, the human operator can respond with:\n * - `accept`: Execute the tool with original arguments\n * - `edit`: Modify the tool arguments before execution\n * - `ignore`: Skip the tool and terminate the agent\n * - `response`: Provide a manual response instead of executing the tool\n *\n * @param options - Configuration options for the middleware\n * @param options.toolConfigs - Per-tool configuration mapping tool names to their settings\n * @param options.toolConfigs[toolName].requireApproval - Whether the tool requires human approval\n * @param options.toolConfigs[toolName].description - Custom approval message for the tool\n * @param options.messagePrefix - Default prefix for approval messages (default: \"Tool execution requires approval\")\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @example\n * Basic usage with selective tool approval\n * ```typescript\n * import { humanInTheLoopMiddleware } from \"langchain/middleware\";\n * import { createAgent } from \"langchain\";\n *\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   toolConfigs: {\n *     \"write_file\": {\n *       requireApproval: true,\n *       description: \"⚠️ File write operation requires approval\"\n *     },\n *     \"read_file\": {\n *       requireApproval: false  // Safe operation, no approval needed\n *     }\n *   }\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4\",\n *   tools: [writeFileTool, readFileTool],\n *   middlewares: [hitlMiddleware]\n * });\n * ```\n *\n * @example\n * Handling approval requests\n * ```typescript\n * import { Command } from \"@langchain/langgraph\";\n *\n * // Initial agent invocation\n * const result = await agent.invoke({\n *   messages: [new HumanMessage(\"Write 'Hello' to output.txt\")]\n * }, config);\n *\n * // Check if agent is paused for approval\n * const state = await agent.graph.getState(config);\n * if (state.next?.length > 0) {\n *   // Get interrupt details\n *   const task = state.tasks?.[0];\n *   const requests = task?.interrupts?.[0]?.value;\n *\n *   // Show tool call details to user\n *   console.log(\"Tool:\", requests[0].action);\n *   console.log(\"Args:\", requests[0].args);\n *\n *   // Resume with approval\n *   await agent.invoke(\n *     new Command({ resume: [{ type: \"accept\" }] }),\n *     config\n *   );\n * }\n * ```\n *\n * @example\n * Different response types\n * ```typescript\n * // Accept the tool call as-is\n * new Command({ resume: [{ type: \"accept\" }] })\n *\n * // Edit the tool arguments\n * new Command({\n *   resume: [{\n *     type: \"edit\",\n *     args: { action: \"write_file\", args: { filename: \"safe.txt\", content: \"Modified\" } }\n *   }]\n * })\n *\n * // Skip tool and terminate agent\n * new Command({ resume: [{ type: \"ignore\" }] })\n *\n * // Provide manual response\n * new Command({\n *   resume: [{\n *     type: \"response\",\n *     args: \"File operation not allowed in demo mode\"\n *   }]\n * })\n * ```\n *\n * @example\n * Production use case with database operations\n * ```typescript\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   toolConfigs: {\n *     \"execute_sql\": {\n *       requireApproval: true,\n *       description: \"🚨 SQL query requires DBA approval\\nPlease review for safety and performance\"\n *     },\n *     \"read_schema\": {\n *       requireApproval: false  // Reading metadata is safe\n *     },\n *     \"delete_records\": {\n *       requireApproval: true,\n *       description: \"⛔ DESTRUCTIVE OPERATION - Requires manager approval\"\n *     }\n *   },\n *   messagePrefix: \"Database operation pending approval\"\n * });\n * ```\n *\n * @remarks\n * - Tool calls are processed in the order they appear in the AI message\n * - Auto-approved tools execute immediately without interruption\n * - Multiple tools requiring approval are bundled into a single interrupt\n * - The middleware operates in the `afterModel` phase, intercepting before tool execution\n * - Requires a checkpointer to maintain state across interruptions\n *\n * @see {@link createAgent} for agent creation\n * @see {@link Command} for resuming interrupted execution\n * @public\n */\nexport declare function humanInTheLoopMiddleware(options?: z.input<typeof contextSchema>): import(\"../types.js\").AgentMiddleware<undefined, z.ZodObject<{\n    toolConfigs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{\n        requireApproval: z.ZodOptional<z.ZodBoolean>;\n        description: z.ZodOptional<z.ZodString>;\n    }, \"strip\", z.ZodTypeAny, {\n        requireApproval?: boolean | undefined;\n        description?: string | undefined;\n    }, {\n        requireApproval?: boolean | undefined;\n        description?: string | undefined;\n    }>>>;\n    messagePrefix: z.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    toolConfigs: Record<string, {\n        requireApproval?: boolean | undefined;\n        description?: string | undefined;\n    }>;\n    messagePrefix: string;\n}, {\n    toolConfigs?: Record<string, {\n        requireApproval?: boolean | undefined;\n        description?: string | undefined;\n    }> | undefined;\n    messagePrefix?: string | undefined;\n}>, any>;\nexport {};\n"],"mappings":";;;;cACcC,eAAeD,CAAAA,CAAEM;eACdN,CAAAA,CAAEQ,WAAWR,CAAAA,CAAEO,UAAUP,CAAAA,CAAEE,WAAWF,CAAAA,CAAEM;qBAChCN,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;IAF3BF,WAAAA,EAGOD,CAAAA,CAAEI,WAqBrB,CArBiCJ,CAAAA,CAAEE,SAqBnC,CAAA;EAAA,CAAA,EAAA,OAAA,EApBcF,CAAAA,CAAEK,UAoBhB,EAAA;IAvBwCL,eAAEE,CAAAA,EAAAA,OAAAA,GAAAA,SAAAA;IACLF,WAAEG,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAU,CAAA,EAA1BH;IACUA,eAAEE,CAAAA,EAAAA,OAAAA,GAAAA,SAAAA;IAAhBF,WAAEI,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAW,CAAA,CAAA,CAClBJ,CAAAA;EAAY,aAH6BM,EAUtCN,CAAAA,CAAEQ,UAVoCF,CAUzBN,CAAAA,CAAEE,SAVuBI,CAAAA;CAAS,EAAA,OAAlCC,EAWpBP,CAAAA,CAAEK,UAXkBE,EAAAA;EAAS,WAAtBC,EAYFC,MAZED,CAAAA,MAAAA,EAAAA;IAUaR,eAAEE,CAAAA,EAAAA,OAAAA,GAAAA,SAAAA;IAAfF,WAAEQ,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAU,CAAA,CAAA;EACP,aACPC,EAAAA,MAAAA;CAAM,EAAA;EAMC,WAnBOH,CAAAA,EAmBbG,MAnBaH,CAAAA,MAAAA,EAAAA;IAAS,eAAA,CAAA,EAAA,OAAA,GAAA,SAAA;IAuKhBI,WAAAA,CAAAA,EAAAA,MAAAA,GAAwB,SAAA;EAAA,CAAA,CAAA,GAAA,SAAA;EAAA,aAA0BT,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;CAAa,CAAA;;;;;;;;;;;;;;;;;AAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAxGS,wBAAAA,WAAmCV,CAAAA,CAAEW,aAAaV,iBAA6E,2BAAXD,CAAAA,CAAEM;eAC7HN,CAAAA,CAAEQ,WAAWR,CAAAA,CAAEO,UAAUP,CAAAA,CAAEE,WAAWF,CAAAA,CAAEM;qBAChCN,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;iBACpBH,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEE;cACrBF,CAAAA,CAAEK;;;;;;;iBAOCL,CAAAA,CAAEQ,WAAWR,CAAAA,CAAEE;YACtBF,CAAAA,CAAEK;eACGI;;;;;;gBAMCA"}

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

@@ -1,234 +0,0 @@
-import { createMiddleware } from "../middleware.js";
-import { AIMessage, ToolMessage, isAIMessage } from "@langchain/core/messages";
-import { interrupt } from "@langchain/langgraph";
-import { z } from "zod";
-import { v4 } from "uuid";
-
-//#region src/agents/middlewareAgent/middlewares/hitl.ts
-const contextSchema = z.object({
-	toolConfigs: z.record(z.object({
-		requireApproval: z.boolean().optional(),
-		description: z.string().optional()
-	})).default({}),
-	messagePrefix: z.string().default("Tool execution requires approval")
-});
-/**
-* Creates a Human-in-the-Loop (HITL) middleware for tool approval and oversight.
-*
-* This middleware intercepts tool calls made by an AI agent and provides human oversight
-* capabilities before execution. It enables selective approval workflows where certain tools
-* require human intervention while others can execute automatically.
-*
-* ## Features
-*
-* - **Selective Tool Approval**: Configure which tools require human approval
-* - **Multiple Response Types**: Accept, edit, ignore, or manually respond to tool calls
-* - **Asynchronous Workflow**: Uses LangGraph's interrupt mechanism for non-blocking approval
-* - **Custom Approval Messages**: Provide context-specific descriptions for approval requests
-*
-* ## Response Types
-*
-* When a tool requires approval, the human operator can respond with:
-* - `accept`: Execute the tool with original arguments
-* - `edit`: Modify the tool arguments before execution
-* - `ignore`: Skip the tool and terminate the agent
-* - `response`: Provide a manual response instead of executing the tool
-*
-* @param options - Configuration options for the middleware
-* @param options.toolConfigs - Per-tool configuration mapping tool names to their settings
-* @param options.toolConfigs[toolName].requireApproval - Whether the tool requires human approval
-* @param options.toolConfigs[toolName].description - Custom approval message for the tool
-* @param options.messagePrefix - Default prefix for approval messages (default: "Tool execution requires approval")
-*
-* @returns A middleware instance that can be passed to `createAgent`
-*
-* @example
-* Basic usage with selective tool approval
-* ```typescript
-* import { humanInTheLoopMiddleware } from "langchain/middleware";
-* import { createAgent } from "langchain";
-*
-* const hitlMiddleware = humanInTheLoopMiddleware({
-*   toolConfigs: {
-*     "write_file": {
-*       requireApproval: true,
-*       description: "⚠️ File write operation requires approval"
-*     },
-*     "read_file": {
-*       requireApproval: false  // Safe operation, no approval needed
-*     }
-*   }
-* });
-*
-* const agent = createAgent({
-*   model: "openai:gpt-4",
-*   tools: [writeFileTool, readFileTool],
-*   middlewares: [hitlMiddleware]
-* });
-* ```
-*
-* @example
-* Handling approval requests
-* ```typescript
-* import { Command } from "@langchain/langgraph";
-*
-* // Initial agent invocation
-* const result = await agent.invoke({
-*   messages: [new HumanMessage("Write 'Hello' to output.txt")]
-* }, config);
-*
-* // Check if agent is paused for approval
-* const state = await agent.graph.getState(config);
-* if (state.next?.length > 0) {
-*   // Get interrupt details
-*   const task = state.tasks?.[0];
-*   const requests = task?.interrupts?.[0]?.value;
-*
-*   // Show tool call details to user
-*   console.log("Tool:", requests[0].action);
-*   console.log("Args:", requests[0].args);
-*
-*   // Resume with approval
-*   await agent.invoke(
-*     new Command({ resume: [{ type: "accept" }] }),
-*     config
-*   );
-* }
-* ```
-*
-* @example
-* Different response types
-* ```typescript
-* // Accept the tool call as-is
-* new Command({ resume: [{ type: "accept" }] })
-*
-* // Edit the tool arguments
-* new Command({
-*   resume: [{
-*     type: "edit",
-*     args: { action: "write_file", args: { filename: "safe.txt", content: "Modified" } }
-*   }]
-* })
-*
-* // Skip tool and terminate agent
-* new Command({ resume: [{ type: "ignore" }] })
-*
-* // Provide manual response
-* new Command({
-*   resume: [{
-*     type: "response",
-*     args: "File operation not allowed in demo mode"
-*   }]
-* })
-* ```
-*
-* @example
-* Production use case with database operations
-* ```typescript
-* const hitlMiddleware = humanInTheLoopMiddleware({
-*   toolConfigs: {
-*     "execute_sql": {
-*       requireApproval: true,
-*       description: "🚨 SQL query requires DBA approval\nPlease review for safety and performance"
-*     },
-*     "read_schema": {
-*       requireApproval: false  // Reading metadata is safe
-*     },
-*     "delete_records": {
-*       requireApproval: true,
-*       description: "⛔ DESTRUCTIVE OPERATION - Requires manager approval"
-*     }
-*   },
-*   messagePrefix: "Database operation pending approval"
-* });
-* ```
-*
-* @remarks
-* - Tool calls are processed in the order they appear in the AI message
-* - Auto-approved tools execute immediately without interruption
-* - Multiple tools requiring approval are bundled into a single interrupt
-* - The middleware operates in the `afterModel` phase, intercepting before tool execution
-* - Requires a checkpointer to maintain state across interruptions
-*
-* @see {@link createAgent} for agent creation
-* @see {@link Command} for resuming interrupted execution
-* @public
-*/
-function humanInTheLoopMiddleware(options = {}) {
-	return createMiddleware({
-		name: "HumanInTheLoopMiddleware",
-		contextSchema,
-		afterModel: async (state, runtime, controls) => {
-			const config = {
-				...contextSchema.parse(options),
-				...runtime.context
-			};
-			const { messages } = state;
-			if (!messages.length) return;
-			const lastMessage = messages[messages.length - 1];
-			if (!isAIMessage(lastMessage) || !lastMessage.tool_calls?.length) return;
-			const interruptToolCalls = [];
-			const autoApprovedToolCalls = [];
-			for (const toolCall of lastMessage.tool_calls) {
-				const normalizedToolCall = {
-					id: toolCall.id || v4(),
-					name: toolCall.name,
-					args: toolCall.args
-				};
-				const toolConfig = config.toolConfigs[normalizedToolCall.name];
-				if (toolConfig?.requireApproval) interruptToolCalls.push(normalizedToolCall);
-				else autoApprovedToolCalls.push(normalizedToolCall);
-			}
-			if (!interruptToolCalls.length) return;
-			const approvedToolCalls = [...autoApprovedToolCalls];
-			const requests = interruptToolCalls.map((toolCall) => {
-				const toolConfig = config.toolConfigs[toolCall.name];
-				const description = toolConfig?.description || `${config.messagePrefix}\n\nTool: ${toolCall.name}\nArgs: ${JSON.stringify(toolCall.args, null, 2)}`;
-				return {
-					action: toolCall.name,
-					args: toolCall.args,
-					toolCallId: toolCall.id,
-					description
-				};
-			});
-			const responses = await interrupt(requests);
-			for (let i = 0; i < responses.length; i++) {
-				const response = responses[i];
-				const toolCall = interruptToolCalls[i];
-				switch (response.type) {
-					case "accept":
-						approvedToolCalls.push(toolCall);
-						break;
-					case "edit":
-						if (response.args && typeof response.args === "object" && "args" in response.args) approvedToolCalls.push({
-							...toolCall,
-							args: response.args.args
-						});
-						break;
-					case "ignore": return controls.terminate();
-					case "response": {
-						const toolMessage = new ToolMessage({
-							content: typeof response.args === "string" ? response.args : "",
-							tool_call_id: toolCall.id
-						});
-						return {
-							messages: [...state.messages, toolMessage],
-							jump_to: "model"
-						};
-					}
-					default: throw new Error(`Unknown response type: ${response.type}`);
-				}
-			}
-			const updatedMessage = new AIMessage({
-				content: lastMessage.content,
-				tool_calls: approvedToolCalls,
-				id: lastMessage.id
-			});
-			return { messages: [...state.messages.slice(0, -1), updatedMessage] };
-		}
-	});
-}
-
-//#endregion
-export { humanInTheLoopMiddleware };
-//# sourceMappingURL=hitl.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"hitl.js","names":["options: z.input<typeof contextSchema>","interruptToolCalls: ToolCall[]","autoApprovedToolCalls: ToolCall[]","normalizedToolCall: ToolCall","uuid","requests: ToolApprovalRequest[]"],"sources":["../../../../src/agents/middlewareAgent/middlewares/hitl.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { v4 as uuid } from \"uuid\";\nimport { AIMessage, ToolMessage, isAIMessage } from \"@langchain/core/messages\";\nimport { interrupt } from \"@langchain/langgraph\";\n\nimport { createMiddleware } from \"../middleware.js\";\nimport type { ToolCall } from \"../types.js\";\nimport { HumanResponse } from \"../../interrupt.js\";\n\n/**\n * Interrupt request for tool approval\n */\ninterface ToolApprovalRequest {\n  action: string;\n  args: Record<string, any>;\n  toolCallId: string;\n  description?: string;\n}\n\nconst contextSchema = z.object({\n  toolConfigs: z\n    .record(\n      z.object({\n        requireApproval: z.boolean().optional(),\n        description: z.string().optional(),\n      })\n    )\n    .default({}),\n  messagePrefix: z.string().default(\"Tool execution requires approval\"),\n});\n\n/**\n * Creates a Human-in-the-Loop (HITL) middleware for tool approval and oversight.\n *\n * This middleware intercepts tool calls made by an AI agent and provides human oversight\n * capabilities before execution. It enables selective approval workflows where certain tools\n * require human intervention while others can execute automatically.\n *\n * ## Features\n *\n * - **Selective Tool Approval**: Configure which tools require human approval\n * - **Multiple Response Types**: Accept, edit, ignore, or manually respond to tool calls\n * - **Asynchronous Workflow**: Uses LangGraph's interrupt mechanism for non-blocking approval\n * - **Custom Approval Messages**: Provide context-specific descriptions for approval requests\n *\n * ## Response Types\n *\n * When a tool requires approval, the human operator can respond with:\n * - `accept`: Execute the tool with original arguments\n * - `edit`: Modify the tool arguments before execution\n * - `ignore`: Skip the tool and terminate the agent\n * - `response`: Provide a manual response instead of executing the tool\n *\n * @param options - Configuration options for the middleware\n * @param options.toolConfigs - Per-tool configuration mapping tool names to their settings\n * @param options.toolConfigs[toolName].requireApproval - Whether the tool requires human approval\n * @param options.toolConfigs[toolName].description - Custom approval message for the tool\n * @param options.messagePrefix - Default prefix for approval messages (default: \"Tool execution requires approval\")\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @example\n * Basic usage with selective tool approval\n * ```typescript\n * import { humanInTheLoopMiddleware } from \"langchain/middleware\";\n * import { createAgent } from \"langchain\";\n *\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   toolConfigs: {\n *     \"write_file\": {\n *       requireApproval: true,\n *       description: \"⚠️ File write operation requires approval\"\n *     },\n *     \"read_file\": {\n *       requireApproval: false  // Safe operation, no approval needed\n *     }\n *   }\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4\",\n *   tools: [writeFileTool, readFileTool],\n *   middlewares: [hitlMiddleware]\n * });\n * ```\n *\n * @example\n * Handling approval requests\n * ```typescript\n * import { Command } from \"@langchain/langgraph\";\n *\n * // Initial agent invocation\n * const result = await agent.invoke({\n *   messages: [new HumanMessage(\"Write 'Hello' to output.txt\")]\n * }, config);\n *\n * // Check if agent is paused for approval\n * const state = await agent.graph.getState(config);\n * if (state.next?.length > 0) {\n *   // Get interrupt details\n *   const task = state.tasks?.[0];\n *   const requests = task?.interrupts?.[0]?.value;\n *\n *   // Show tool call details to user\n *   console.log(\"Tool:\", requests[0].action);\n *   console.log(\"Args:\", requests[0].args);\n *\n *   // Resume with approval\n *   await agent.invoke(\n *     new Command({ resume: [{ type: \"accept\" }] }),\n *     config\n *   );\n * }\n * ```\n *\n * @example\n * Different response types\n * ```typescript\n * // Accept the tool call as-is\n * new Command({ resume: [{ type: \"accept\" }] })\n *\n * // Edit the tool arguments\n * new Command({\n *   resume: [{\n *     type: \"edit\",\n *     args: { action: \"write_file\", args: { filename: \"safe.txt\", content: \"Modified\" } }\n *   }]\n * })\n *\n * // Skip tool and terminate agent\n * new Command({ resume: [{ type: \"ignore\" }] })\n *\n * // Provide manual response\n * new Command({\n *   resume: [{\n *     type: \"response\",\n *     args: \"File operation not allowed in demo mode\"\n *   }]\n * })\n * ```\n *\n * @example\n * Production use case with database operations\n * ```typescript\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   toolConfigs: {\n *     \"execute_sql\": {\n *       requireApproval: true,\n *       description: \"🚨 SQL query requires DBA approval\\nPlease review for safety and performance\"\n *     },\n *     \"read_schema\": {\n *       requireApproval: false  // Reading metadata is safe\n *     },\n *     \"delete_records\": {\n *       requireApproval: true,\n *       description: \"⛔ DESTRUCTIVE OPERATION - Requires manager approval\"\n *     }\n *   },\n *   messagePrefix: \"Database operation pending approval\"\n * });\n * ```\n *\n * @remarks\n * - Tool calls are processed in the order they appear in the AI message\n * - Auto-approved tools execute immediately without interruption\n * - Multiple tools requiring approval are bundled into a single interrupt\n * - The middleware operates in the `afterModel` phase, intercepting before tool execution\n * - Requires a checkpointer to maintain state across interruptions\n *\n * @see {@link createAgent} for agent creation\n * @see {@link Command} for resuming interrupted execution\n * @public\n */\nexport function humanInTheLoopMiddleware(\n  options: z.input<typeof contextSchema> = {}\n) {\n  return createMiddleware({\n    name: \"HumanInTheLoopMiddleware\",\n    contextSchema,\n    afterModel: async (state, runtime, controls) => {\n      const config = { ...contextSchema.parse(options), ...runtime.context };\n      const { messages } = state;\n\n      if (!messages.length) {\n        return;\n      }\n\n      const lastMessage = messages[messages.length - 1];\n\n      // Check if it's an AI message with tool calls\n      if (!isAIMessage(lastMessage) || !lastMessage.tool_calls?.length) {\n        return;\n      }\n\n      // Separate tool calls that need interrupts from those that don't\n      const interruptToolCalls: ToolCall[] = [];\n      const autoApprovedToolCalls: ToolCall[] = [];\n\n      for (const toolCall of lastMessage.tool_calls) {\n        // Ensure tool call has an ID\n        const normalizedToolCall: ToolCall = {\n          id: toolCall.id || uuid(),\n          name: toolCall.name,\n          args: toolCall.args,\n        };\n\n        const toolConfig = config.toolConfigs[normalizedToolCall.name];\n\n        if (toolConfig?.requireApproval) {\n          interruptToolCalls.push(normalizedToolCall);\n        } else {\n          autoApprovedToolCalls.push(normalizedToolCall);\n        }\n      }\n\n      // If no interrupts needed, return early\n      if (!interruptToolCalls.length) {\n        return;\n      }\n\n      const approvedToolCalls = [...autoApprovedToolCalls];\n\n      // Process tool calls that need interrupts\n      const requests: ToolApprovalRequest[] = interruptToolCalls.map(\n        (toolCall) => {\n          const toolConfig = config.toolConfigs[toolCall.name];\n          const description =\n            toolConfig?.description ||\n            `${config.messagePrefix}\\n\\nTool: ${\n              toolCall.name\n            }\\nArgs: ${JSON.stringify(toolCall.args, null, 2)}`;\n\n          return {\n            action: toolCall.name,\n            args: toolCall.args,\n            toolCallId: toolCall.id,\n            description,\n          };\n        }\n      );\n\n      // Interrupt and wait for human responses\n      const responses = (await interrupt(requests)) as HumanResponse[];\n\n      // Process responses\n      for (let i = 0; i < responses.length; i++) {\n        const response = responses[i];\n        const toolCall = interruptToolCalls[i];\n\n        switch (response.type) {\n          case \"accept\":\n            approvedToolCalls.push(toolCall);\n            break;\n\n          case \"edit\":\n            // For edit, args is an ActionRequest with updated args\n            if (\n              response.args &&\n              typeof response.args === \"object\" &&\n              \"args\" in response.args\n            ) {\n              approvedToolCalls.push({\n                ...toolCall,\n                args: (\n                  response.args as { action: string; args: Record<string, any> }\n                ).args,\n              });\n            }\n            break;\n\n          case \"ignore\":\n            // Skip to end - terminate the agent\n            return controls.terminate();\n\n          case \"response\": {\n            // Return manual tool response and jump back to model\n            // For response, args is a string\n            const toolMessage = new ToolMessage({\n              content: typeof response.args === \"string\" ? response.args : \"\",\n              tool_call_id: toolCall.id,\n            });\n            return {\n              messages: [...state.messages, toolMessage],\n              jump_to: \"model\",\n            };\n          }\n          default:\n            throw new Error(`Unknown response type: ${(response as any).type}`);\n        }\n      }\n\n      // Update the last message with approved tool calls\n      const updatedMessage = new AIMessage({\n        content: lastMessage.content,\n        tool_calls: approvedToolCalls,\n        id: lastMessage.id,\n      });\n\n      // Replace the last message with the updated one\n      return {\n        messages: [...state.messages.slice(0, -1), updatedMessage],\n      };\n    },\n  });\n}\n"],"mappings":";;;;;;;AAmBA,MAAM,gBAAgB,EAAE,OAAO;CAC7B,aAAa,EACV,OACC,EAAE,OAAO;EACP,iBAAiB,EAAE,SAAS,CAAC,UAAU;EACvC,aAAa,EAAE,QAAQ,CAAC,UAAU;CACnC,EAAC,CACH,CACA,QAAQ,CAAE,EAAC;CACd,eAAe,EAAE,QAAQ,CAAC,QAAQ,mCAAmC;AACtE,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgJF,SAAgB,yBACdA,UAAyC,CAAE,GAC3C;AACA,QAAO,iBAAiB;EACtB,MAAM;EACN;EACA,YAAY,OAAO,OAAO,SAAS,aAAa;GAC9C,MAAM,SAAS;IAAE,GAAG,cAAc,MAAM,QAAQ;IAAE,GAAG,QAAQ;GAAS;GACtE,MAAM,EAAE,UAAU,GAAG;AAErB,OAAI,CAAC,SAAS,OACZ;GAGF,MAAM,cAAc,SAAS,SAAS,SAAS;AAG/C,OAAI,CAAC,YAAY,YAAY,IAAI,CAAC,YAAY,YAAY,OACxD;GAIF,MAAMC,qBAAiC,CAAE;GACzC,MAAMC,wBAAoC,CAAE;AAE5C,QAAK,MAAM,YAAY,YAAY,YAAY;IAE7C,MAAMC,qBAA+B;KACnC,IAAI,SAAS,MAAMC,IAAM;KACzB,MAAM,SAAS;KACf,MAAM,SAAS;IAChB;IAED,MAAM,aAAa,OAAO,YAAY,mBAAmB;AAEzD,QAAI,YAAY,iBACd,mBAAmB,KAAK,mBAAmB;SAE3C,sBAAsB,KAAK,mBAAmB;GAEjD;AAGD,OAAI,CAAC,mBAAmB,OACtB;GAGF,MAAM,oBAAoB,CAAC,GAAG,qBAAsB;GAGpD,MAAMC,WAAkC,mBAAmB,IACzD,CAAC,aAAa;IACZ,MAAM,aAAa,OAAO,YAAY,SAAS;IAC/C,MAAM,cACJ,YAAY,eACZ,GAAG,OAAO,cAAc,UAAU,EAChC,SAAS,KACV,QAAQ,EAAE,KAAK,UAAU,SAAS,MAAM,MAAM,EAAE,EAAE;AAErD,WAAO;KACL,QAAQ,SAAS;KACjB,MAAM,SAAS;KACf,YAAY,SAAS;KACrB;IACD;GACF,EACF;GAGD,MAAM,YAAa,MAAM,UAAU,SAAS;AAG5C,QAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;IACzC,MAAM,WAAW,UAAU;IAC3B,MAAM,WAAW,mBAAmB;AAEpC,YAAQ,SAAS,MAAjB;KACE,KAAK;MACH,kBAAkB,KAAK,SAAS;AAChC;KAEF,KAAK;AAEH,UACE,SAAS,QACT,OAAO,SAAS,SAAS,YACzB,UAAU,SAAS,MAEnB,kBAAkB,KAAK;OACrB,GAAG;OACH,MACE,SAAS,KACT;MACH,EAAC;AAEJ;KAEF,KAAK,SAEH,QAAO,SAAS,WAAW;KAE7B,KAAK,YAAY;MAGf,MAAM,cAAc,IAAI,YAAY;OAClC,SAAS,OAAO,SAAS,SAAS,WAAW,SAAS,OAAO;OAC7D,cAAc,SAAS;MACxB;AACD,aAAO;OACL,UAAU,CAAC,GAAG,MAAM,UAAU,WAAY;OAC1C,SAAS;MACV;KACF;KACD,QACE,OAAM,IAAI,MAAM,CAAC,uBAAuB,EAAG,SAAiB,MAAM;IACrE;GACF;GAGD,MAAM,iBAAiB,IAAI,UAAU;IACnC,SAAS,YAAY;IACrB,YAAY;IACZ,IAAI,YAAY;GACjB;AAGD,UAAO,EACL,UAAU,CAAC,GAAG,MAAM,SAAS,MAAM,GAAG,GAAG,EAAE,cAAe,EAC3D;EACF;CACF,EAAC;AACH"}

package/dist/agents/middlewareAgent/middlewares/index.cjs

@@ -1,8 +0,0 @@
-const require_summarization = require('./summarization.cjs');
-const require_hitl = require('./hitl.cjs');
-const require_promptCaching = require('./promptCaching.cjs');
-
-exports.anthropicPromptCachingMiddleware = require_promptCaching.anthropicPromptCachingMiddleware;
-exports.countTokensApproximately = require_summarization.countTokensApproximately;
-exports.humanInTheLoopMiddleware = require_hitl.humanInTheLoopMiddleware;
-exports.summarizationMiddleware = require_summarization.summarizationMiddleware;

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

@@ -1,4 +0,0 @@
-import { countTokensApproximately, summarizationMiddleware } from "./summarization.cjs";
-import { humanInTheLoopMiddleware } from "./hitl.cjs";
-import { anthropicPromptCachingMiddleware } from "./promptCaching.cjs";
-export { anthropicPromptCachingMiddleware, countTokensApproximately, humanInTheLoopMiddleware, summarizationMiddleware };

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

@@ -1,4 +0,0 @@
-import { countTokensApproximately, summarizationMiddleware } from "./summarization.js";
-import { humanInTheLoopMiddleware } from "./hitl.js";
-import { anthropicPromptCachingMiddleware } from "./promptCaching.js";
-export { anthropicPromptCachingMiddleware, countTokensApproximately, humanInTheLoopMiddleware, summarizationMiddleware };

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

@@ -1,5 +0,0 @@
-import { countTokensApproximately, summarizationMiddleware } from "./summarization.js";
-import { humanInTheLoopMiddleware } from "./hitl.js";
-import { anthropicPromptCachingMiddleware } from "./promptCaching.js";
-
-export { anthropicPromptCachingMiddleware, countTokensApproximately, humanInTheLoopMiddleware, summarizationMiddleware };

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

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"summarization.cjs","names":["z","messages: BaseMessage[]","textContent: string","options: z.input<typeof contextSchema>","createMiddleware","RemoveMessage","REMOVE_ALL_MESSAGES","systemMessage: SystemMessage | null","conversationMessages: BaseMessage[]","cutoffIndex: number","originalSystemMessage: SystemMessage | null","summary: string","summaryPrefix: string","content","SystemMessage","messagesToKeep: number","message: BaseMessage","aiMessage: AIMessage","aiMessageIndex: number","toolCallIds: Set<string>","messagesToSummarize: BaseMessage[]","model: BaseLanguageModel","summaryPrompt: string","tokenCounter: TokenCounter"],"sources":["../../../../src/agents/middlewareAgent/middlewares/summarization.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { v4 as uuid } from \"uuid\";\nimport {\n  BaseMessage,\n  AIMessage,\n  SystemMessage,\n  isToolMessage,\n  RemoveMessage,\n  trimMessages,\n  isSystemMessage,\n  isAIMessage,\n} from \"@langchain/core/messages\";\nimport { BaseLanguageModel } from \"@langchain/core/language_models/base\";\nimport { REMOVE_ALL_MESSAGES } from \"@langchain/langgraph\";\nimport { createMiddleware } from \"../middleware.js\";\n\nconst DEFAULT_SUMMARY_PROMPT = `<role>\nContext Extraction Assistant\n</role>\n\n<primary_objective>\nYour sole objective in this task is to extract the highest quality/most relevant context from the conversation history below.\n</primary_objective>\n\n<objective_information>\nYou're nearing the total number of input tokens you can accept, so you must extract the highest quality/most relevant pieces of information from your conversation history.\nThis context will then overwrite the conversation history presented below. Because of this, ensure the context you extract is only the most important information to your overall goal.\n</objective_information>\n\n<instructions>\nThe conversation history below will be replaced with the context you extract in this step. Because of this, you must do your very best to extract and record all of the most important context from the conversation history.\nYou want to ensure that you don't repeat any actions you've already completed, so the context you extract from the conversation history should be focused on the most important information to your overall goal.\n</instructions>\n\nThe user will message you with the full message history you'll be extracting context from, to then replace. Carefully read over it all, and think deeply about what information is most important to your overall goal that should be saved:\n\nWith all of this in mind, please carefully read over the entire conversation history, and extract the most important and relevant context to replace it so that you can free up space in the conversation history.\nRespond ONLY with the extracted context. Do not include any additional information, or text before or after the extracted context.\n\n<messages>\nMessages to summarize:\n{messages}\n</messages>`;\n\nconst SUMMARY_PREFIX = \"## Previous conversation summary:\";\n\nconst DEFAULT_MESSAGES_TO_KEEP = 20;\nconst DEFAULT_TRIM_TOKEN_LIMIT = 4000;\nconst DEFAULT_FALLBACK_MESSAGE_COUNT = 15;\nconst SEARCH_RANGE_FOR_TOOL_PAIRS = 5;\n\ntype TokenCounter = (messages: BaseMessage[]) => number | Promise<number>;\n\nconst contextSchema = z.object({\n  model: z.custom<BaseLanguageModel>(),\n  maxTokensBeforeSummary: z.number().optional(),\n  messagesToKeep: z.number().default(DEFAULT_MESSAGES_TO_KEEP),\n  tokenCounter: z\n    .function()\n    .args(z.array(z.any()))\n    .returns(z.union([z.number(), z.promise(z.number())]))\n    .optional(),\n  summaryPrompt: z.string().default(DEFAULT_SUMMARY_PROMPT),\n  summaryPrefix: z.string().default(SUMMARY_PREFIX),\n});\n\n/**\n * Default token counter that approximates based on character count\n * @param messages Messages to count tokens for\n * @returns Approximate token count\n */\nexport function countTokensApproximately(messages: BaseMessage[]): number {\n  let totalChars = 0;\n  for (const msg of messages) {\n    let textContent: string;\n    if (typeof msg.content === \"string\") {\n      textContent = msg.content;\n    } else if (Array.isArray(msg.content)) {\n      textContent = msg.content\n        .map((item) => {\n          if (typeof item === \"string\") return item;\n          if (item.type === \"text\" && \"text\" in item) return item.text;\n          return \"\";\n        })\n        .join(\"\");\n    } else {\n      textContent = \"\";\n    }\n    totalChars += textContent.length;\n  }\n  // Approximate 1 token = 4 characters\n  return Math.ceil(totalChars / 4);\n}\n\n/**\n * Summarization middleware that automatically summarizes conversation history when token limits are approached.\n *\n * This middleware monitors message token counts and automatically summarizes older\n * messages when a threshold is reached, preserving recent messages and maintaining\n * context continuity by ensuring AI/Tool message pairs remain together.\n *\n * @param options Configuration options for the summarization middleware\n * @returns A middleware instance\n *\n * @example\n * ```ts\n * import { summarizationMiddleware } from \"langchain/middleware\";\n * import { createAgent } from \"langchain\";\n *\n * const agent = createAgent({\n *   llm: model,\n *   tools: [getWeather],\n *   middlewares: [\n *     summarizationMiddleware({\n *       model: new ChatOpenAI({ model: \"gpt-4o\" }),\n *       maxTokensBeforeSummary: 4000,\n *       messagesToKeep: 20,\n *     })\n *   ],\n * });\n *\n * ```\n */\nexport function summarizationMiddleware(\n  options: z.input<typeof contextSchema>\n) {\n  return createMiddleware({\n    name: \"SummarizationMiddleware\",\n    contextSchema,\n    beforeModel: async (state, runtime) => {\n      const config = { ...contextSchema.parse(options), ...runtime.context };\n      const { messages } = state;\n\n      // Ensure all messages have IDs\n      ensureMessageIds(messages);\n\n      const tokenCounter = config.tokenCounter || countTokensApproximately;\n      const totalTokens = await tokenCounter(messages);\n\n      if (\n        config.maxTokensBeforeSummary == null ||\n        totalTokens < config.maxTokensBeforeSummary\n      ) {\n        return;\n      }\n\n      const { systemMessage, conversationMessages } =\n        splitSystemMessage(messages);\n      const cutoffIndex = findSafeCutoff(\n        conversationMessages,\n        config.messagesToKeep\n      );\n\n      if (cutoffIndex <= 0) {\n        return;\n      }\n\n      const { messagesToSummarize, preservedMessages } = partitionMessages(\n        systemMessage,\n        conversationMessages,\n        cutoffIndex\n      );\n\n      const summary = await createSummary(\n        messagesToSummarize,\n        config.model,\n        config.summaryPrompt,\n        tokenCounter\n      );\n\n      const updatedSystemMessage = buildUpdatedSystemMessage(\n        systemMessage,\n        summary,\n        config.summaryPrefix\n      );\n\n      return {\n        messages: [\n          new RemoveMessage({ id: REMOVE_ALL_MESSAGES }),\n          updatedSystemMessage,\n          ...preservedMessages,\n        ],\n      };\n    },\n  });\n}\n\n/**\n * Ensure all messages have unique IDs\n */\nfunction ensureMessageIds(messages: BaseMessage[]): void {\n  for (const msg of messages) {\n    if (!msg.id) {\n      msg.id = uuid();\n    }\n  }\n}\n\n/**\n * Separate system message from conversation messages\n */\nfunction splitSystemMessage(messages: BaseMessage[]): {\n  systemMessage: SystemMessage | null;\n  conversationMessages: BaseMessage[];\n} {\n  if (messages.length > 0 && isSystemMessage(messages[0])) {\n    return {\n      systemMessage: messages[0] as SystemMessage,\n      conversationMessages: messages.slice(1),\n    };\n  }\n  return {\n    systemMessage: null,\n    conversationMessages: messages,\n  };\n}\n\n/**\n * Partition messages into those to summarize and those to preserve\n */\nfunction partitionMessages(\n  systemMessage: SystemMessage | null,\n  conversationMessages: BaseMessage[],\n  cutoffIndex: number\n): { messagesToSummarize: BaseMessage[]; preservedMessages: BaseMessage[] } {\n  const messagesToSummarize = conversationMessages.slice(0, cutoffIndex);\n  const preservedMessages = conversationMessages.slice(cutoffIndex);\n\n  // Include system message in messages to summarize to capture previous summaries\n  if (systemMessage) {\n    messagesToSummarize.unshift(systemMessage);\n  }\n\n  return { messagesToSummarize, preservedMessages };\n}\n\n/**\n * Build updated system message incorporating the summary\n */\nfunction buildUpdatedSystemMessage(\n  originalSystemMessage: SystemMessage | null,\n  summary: string,\n  summaryPrefix: string\n): SystemMessage {\n  let originalContent = \"\";\n  if (originalSystemMessage) {\n    const { content } = originalSystemMessage;\n    if (typeof content === \"string\") {\n      originalContent = content.split(summaryPrefix)[0].trim();\n    }\n  }\n\n  const content = originalContent\n    ? `${originalContent}\\n${summaryPrefix}\\n${summary}`\n    : `${summaryPrefix}\\n${summary}`;\n\n  return new SystemMessage({\n    content,\n    id: originalSystemMessage?.id || uuid(),\n  });\n}\n\n/**\n * Find safe cutoff point that preserves AI/Tool message pairs\n */\nfunction findSafeCutoff(\n  messages: BaseMessage[],\n  messagesToKeep: number\n): number {\n  if (messages.length <= messagesToKeep) {\n    return 0;\n  }\n\n  const targetCutoff = messages.length - messagesToKeep;\n\n  for (let i = targetCutoff; i >= 0; i--) {\n    if (isSafeCutoffPoint(messages, i)) {\n      return i;\n    }\n  }\n\n  return 0;\n}\n\n/**\n * Check if cutting at index would separate AI/Tool message pairs\n */\nfunction isSafeCutoffPoint(\n  messages: BaseMessage[],\n  cutoffIndex: number\n): boolean {\n  if (cutoffIndex >= messages.length) {\n    return true;\n  }\n\n  const searchStart = Math.max(0, cutoffIndex - SEARCH_RANGE_FOR_TOOL_PAIRS);\n  const searchEnd = Math.min(\n    messages.length,\n    cutoffIndex + SEARCH_RANGE_FOR_TOOL_PAIRS\n  );\n\n  for (let i = searchStart; i < searchEnd; i++) {\n    if (!hasToolCalls(messages[i])) {\n      continue;\n    }\n\n    const toolCallIds = extractToolCallIds(messages[i] as AIMessage);\n    if (cutoffSeparatesToolPair(messages, i, cutoffIndex, toolCallIds)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Check if message is an AI message with tool calls\n */\nfunction hasToolCalls(message: BaseMessage): boolean {\n  return (\n    isAIMessage(message) &&\n    \"tool_calls\" in message &&\n    Array.isArray(message.tool_calls) &&\n    message.tool_calls.length > 0\n  );\n}\n\n/**\n * Extract tool call IDs from an AI message\n */\nfunction extractToolCallIds(aiMessage: AIMessage): Set<string> {\n  const toolCallIds = new Set<string>();\n  if (aiMessage.tool_calls) {\n    for (const toolCall of aiMessage.tool_calls) {\n      const id =\n        typeof toolCall === \"object\" && \"id\" in toolCall ? toolCall.id : null;\n      if (id) {\n        toolCallIds.add(id);\n      }\n    }\n  }\n  return toolCallIds;\n}\n\n/**\n * Check if cutoff separates an AI message from its corresponding tool messages\n */\nfunction cutoffSeparatesToolPair(\n  messages: BaseMessage[],\n  aiMessageIndex: number,\n  cutoffIndex: number,\n  toolCallIds: Set<string>\n): boolean {\n  for (let j = aiMessageIndex + 1; j < messages.length; j++) {\n    const message = messages[j];\n    if (isToolMessage(message) && toolCallIds.has(message.tool_call_id)) {\n      const aiBeforeCutoff = aiMessageIndex < cutoffIndex;\n      const toolBeforeCutoff = j < cutoffIndex;\n      if (aiBeforeCutoff !== toolBeforeCutoff) {\n        return true;\n      }\n    }\n  }\n  return false;\n}\n\n/**\n * Generate summary for the given messages\n */\nasync function createSummary(\n  messagesToSummarize: BaseMessage[],\n  model: BaseLanguageModel,\n  summaryPrompt: string,\n  tokenCounter: TokenCounter\n): Promise<string> {\n  if (!messagesToSummarize.length) {\n    return \"No previous conversation history.\";\n  }\n\n  const trimmedMessages = await trimMessagesForSummary(\n    messagesToSummarize,\n    tokenCounter\n  );\n\n  if (!trimmedMessages.length) {\n    return \"Previous conversation was too long to summarize.\";\n  }\n\n  try {\n    const formattedPrompt = summaryPrompt.replace(\n      \"{messages}\",\n      JSON.stringify(trimmedMessages, null, 2)\n    );\n    const response = await model.invoke(formattedPrompt);\n    const { content } = response;\n    return typeof content === \"string\"\n      ? content.trim()\n      : \"Error generating summary: Invalid response format\";\n  } catch (e) {\n    return `Error generating summary: ${e}`;\n  }\n}\n\n/**\n * Trim messages to fit within summary generation limits\n */\nasync function trimMessagesForSummary(\n  messages: BaseMessage[],\n  tokenCounter: TokenCounter\n): Promise<BaseMessage[]> {\n  try {\n    return await trimMessages(messages, {\n      maxTokens: DEFAULT_TRIM_TOKEN_LIMIT,\n      tokenCounter: async (msgs) => Promise.resolve(tokenCounter(msgs)),\n      strategy: \"last\",\n      allowPartial: true,\n      includeSystem: true,\n    });\n  } catch (e) {\n    // Fallback to last N messages if trimming fails\n    return messages.slice(-DEFAULT_FALLBACK_MESSAGE_COUNT);\n  }\n}\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"summarization.d.cts","names":["___types_js0","z","BaseMessage","BaseLanguageModel","contextSchema","_langchain_core_language_models_base1","BaseLanguageModelCallOptions","ZodTypeDef","ZodType","ZodNumber","ZodOptional","ZodDefault","ZodAny","ZodArray","ZodUnknown","ZodTuple","ZodPromise","ZodUnion","ZodFunction","ZodString","ZodTypeAny","Promise","ZodObject","countTokensApproximately","summarizationMiddleware","input","AgentMiddleware"],"sources":["../../../../src/agents/middlewareAgent/middlewares/summarization.d.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { BaseMessage } from \"@langchain/core/messages\";\nimport { BaseLanguageModel } from \"@langchain/core/language_models/base\";\ndeclare const contextSchema: z.ZodObject<{\n    model: z.ZodType<BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>, z.ZodTypeDef, BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>>;\n    maxTokensBeforeSummary: z.ZodOptional<z.ZodNumber>;\n    messagesToKeep: z.ZodDefault<z.ZodNumber>;\n    tokenCounter: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodArray<z.ZodAny, \"many\">], z.ZodUnknown>, z.ZodUnion<[z.ZodNumber, z.ZodPromise<z.ZodNumber>]>>>;\n    summaryPrompt: z.ZodDefault<z.ZodString>;\n    summaryPrefix: z.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    model: BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>;\n    maxTokensBeforeSummary?: number | undefined;\n    messagesToKeep: number;\n    tokenCounter?: ((args_0: any[], ...args: unknown[]) => number | Promise<number>) | undefined;\n    summaryPrompt: string;\n    summaryPrefix: string;\n}, {\n    model: BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>;\n    maxTokensBeforeSummary?: number | undefined;\n    messagesToKeep?: number | undefined;\n    tokenCounter?: ((args_0: any[], ...args: unknown[]) => number | Promise<number>) | undefined;\n    summaryPrompt?: string | undefined;\n    summaryPrefix?: string | undefined;\n}>;\n/**\n * Default token counter that approximates based on character count\n * @param messages Messages to count tokens for\n * @returns Approximate token count\n */\nexport declare function countTokensApproximately(messages: BaseMessage[]): number;\n/**\n * Summarization middleware that automatically summarizes conversation history when token limits are approached.\n *\n * This middleware monitors message token counts and automatically summarizes older\n * messages when a threshold is reached, preserving recent messages and maintaining\n * context continuity by ensuring AI/Tool message pairs remain together.\n *\n * @param options Configuration options for the summarization middleware\n * @returns A middleware instance\n *\n * @example\n * ```ts\n * import { summarizationMiddleware } from \"langchain/middleware\";\n * import { createAgent } from \"langchain\";\n *\n * const agent = createAgent({\n *   llm: model,\n *   tools: [getWeather],\n *   middlewares: [\n *     summarizationMiddleware({\n *       model: new ChatOpenAI({ model: \"gpt-4o\" }),\n *       maxTokensBeforeSummary: 4000,\n *       messagesToKeep: 20,\n *     })\n *   ],\n * });\n *\n * ```\n */\nexport declare function summarizationMiddleware(options: z.input<typeof contextSchema>): import(\"../types.js\").AgentMiddleware<undefined, z.ZodObject<{\n    model: z.ZodType<BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>, z.ZodTypeDef, BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>>;\n    maxTokensBeforeSummary: z.ZodOptional<z.ZodNumber>;\n    messagesToKeep: z.ZodDefault<z.ZodNumber>;\n    tokenCounter: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodArray<z.ZodAny, \"many\">], z.ZodUnknown>, z.ZodUnion<[z.ZodNumber, z.ZodPromise<z.ZodNumber>]>>>;\n    summaryPrompt: z.ZodDefault<z.ZodString>;\n    summaryPrefix: z.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    model: BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>;\n    maxTokensBeforeSummary?: number | undefined;\n    messagesToKeep: number;\n    tokenCounter?: ((args_0: any[], ...args: unknown[]) => number | Promise<number>) | undefined;\n    summaryPrompt: string;\n    summaryPrefix: string;\n}, {\n    model: BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>;\n    maxTokensBeforeSummary?: number | undefined;\n    messagesToKeep?: number | undefined;\n    tokenCounter?: ((args_0: any[], ...args: unknown[]) => number | Promise<number>) | undefined;\n    summaryPrompt?: string | undefined;\n    summaryPrefix?: string | undefined;\n}>, any>;\nexport {};\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"summarization.d.ts","names":["___types_js0","z","BaseMessage","BaseLanguageModel","contextSchema","_langchain_core_language_models_base0","BaseLanguageModelCallOptions","ZodTypeDef","ZodType","ZodNumber","ZodOptional","ZodDefault","ZodAny","ZodArray","ZodUnknown","ZodTuple","ZodPromise","ZodUnion","ZodFunction","ZodString","ZodTypeAny","Promise","ZodObject","countTokensApproximately","summarizationMiddleware","input","AgentMiddleware"],"sources":["../../../../src/agents/middlewareAgent/middlewares/summarization.d.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { BaseMessage } from \"@langchain/core/messages\";\nimport { BaseLanguageModel } from \"@langchain/core/language_models/base\";\ndeclare const contextSchema: z.ZodObject<{\n    model: z.ZodType<BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>, z.ZodTypeDef, BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>>;\n    maxTokensBeforeSummary: z.ZodOptional<z.ZodNumber>;\n    messagesToKeep: z.ZodDefault<z.ZodNumber>;\n    tokenCounter: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodArray<z.ZodAny, \"many\">], z.ZodUnknown>, z.ZodUnion<[z.ZodNumber, z.ZodPromise<z.ZodNumber>]>>>;\n    summaryPrompt: z.ZodDefault<z.ZodString>;\n    summaryPrefix: z.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    model: BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>;\n    maxTokensBeforeSummary?: number | undefined;\n    messagesToKeep: number;\n    tokenCounter?: ((args_0: any[], ...args: unknown[]) => number | Promise<number>) | undefined;\n    summaryPrompt: string;\n    summaryPrefix: string;\n}, {\n    model: BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>;\n    maxTokensBeforeSummary?: number | undefined;\n    messagesToKeep?: number | undefined;\n    tokenCounter?: ((args_0: any[], ...args: unknown[]) => number | Promise<number>) | undefined;\n    summaryPrompt?: string | undefined;\n    summaryPrefix?: string | undefined;\n}>;\n/**\n * Default token counter that approximates based on character count\n * @param messages Messages to count tokens for\n * @returns Approximate token count\n */\nexport declare function countTokensApproximately(messages: BaseMessage[]): number;\n/**\n * Summarization middleware that automatically summarizes conversation history when token limits are approached.\n *\n * This middleware monitors message token counts and automatically summarizes older\n * messages when a threshold is reached, preserving recent messages and maintaining\n * context continuity by ensuring AI/Tool message pairs remain together.\n *\n * @param options Configuration options for the summarization middleware\n * @returns A middleware instance\n *\n * @example\n * ```ts\n * import { summarizationMiddleware } from \"langchain/middleware\";\n * import { createAgent } from \"langchain\";\n *\n * const agent = createAgent({\n *   llm: model,\n *   tools: [getWeather],\n *   middlewares: [\n *     summarizationMiddleware({\n *       model: new ChatOpenAI({ model: \"gpt-4o\" }),\n *       maxTokensBeforeSummary: 4000,\n *       messagesToKeep: 20,\n *     })\n *   ],\n * });\n *\n * ```\n */\nexport declare function summarizationMiddleware(options: z.input<typeof contextSchema>): import(\"../types.js\").AgentMiddleware<undefined, z.ZodObject<{\n    model: z.ZodType<BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>, z.ZodTypeDef, BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>>;\n    maxTokensBeforeSummary: z.ZodOptional<z.ZodNumber>;\n    messagesToKeep: z.ZodDefault<z.ZodNumber>;\n    tokenCounter: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodArray<z.ZodAny, \"many\">], z.ZodUnknown>, z.ZodUnion<[z.ZodNumber, z.ZodPromise<z.ZodNumber>]>>>;\n    summaryPrompt: z.ZodDefault<z.ZodString>;\n    summaryPrefix: z.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    model: BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>;\n    maxTokensBeforeSummary?: number | undefined;\n    messagesToKeep: number;\n    tokenCounter?: ((args_0: any[], ...args: unknown[]) => number | Promise<number>) | undefined;\n    summaryPrompt: string;\n    summaryPrefix: string;\n}, {\n    model: BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>;\n    maxTokensBeforeSummary?: number | undefined;\n    messagesToKeep?: number | undefined;\n    tokenCounter?: ((args_0: any[], ...args: unknown[]) => number | Promise<number>) | undefined;\n    summaryPrompt?: string | undefined;\n    summaryPrefix?: string | undefined;\n}>, any>;\nexport {};\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"summarization.js","names":["messages: BaseMessage[]","textContent: string","options: z.input<typeof contextSchema>","uuid","systemMessage: SystemMessage | null","conversationMessages: BaseMessage[]","cutoffIndex: number","originalSystemMessage: SystemMessage | null","summary: string","summaryPrefix: string","content","messagesToKeep: number","message: BaseMessage","aiMessage: AIMessage","aiMessageIndex: number","toolCallIds: Set<string>","messagesToSummarize: BaseMessage[]","model: BaseLanguageModel","summaryPrompt: string","tokenCounter: TokenCounter"],"sources":["../../../../src/agents/middlewareAgent/middlewares/summarization.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { v4 as uuid } from \"uuid\";\nimport {\n  BaseMessage,\n  AIMessage,\n  SystemMessage,\n  isToolMessage,\n  RemoveMessage,\n  trimMessages,\n  isSystemMessage,\n  isAIMessage,\n} from \"@langchain/core/messages\";\nimport { BaseLanguageModel } from \"@langchain/core/language_models/base\";\nimport { REMOVE_ALL_MESSAGES } from \"@langchain/langgraph\";\nimport { createMiddleware } from \"../middleware.js\";\n\nconst DEFAULT_SUMMARY_PROMPT = `<role>\nContext Extraction Assistant\n</role>\n\n<primary_objective>\nYour sole objective in this task is to extract the highest quality/most relevant context from the conversation history below.\n</primary_objective>\n\n<objective_information>\nYou're nearing the total number of input tokens you can accept, so you must extract the highest quality/most relevant pieces of information from your conversation history.\nThis context will then overwrite the conversation history presented below. Because of this, ensure the context you extract is only the most important information to your overall goal.\n</objective_information>\n\n<instructions>\nThe conversation history below will be replaced with the context you extract in this step. Because of this, you must do your very best to extract and record all of the most important context from the conversation history.\nYou want to ensure that you don't repeat any actions you've already completed, so the context you extract from the conversation history should be focused on the most important information to your overall goal.\n</instructions>\n\nThe user will message you with the full message history you'll be extracting context from, to then replace. Carefully read over it all, and think deeply about what information is most important to your overall goal that should be saved:\n\nWith all of this in mind, please carefully read over the entire conversation history, and extract the most important and relevant context to replace it so that you can free up space in the conversation history.\nRespond ONLY with the extracted context. Do not include any additional information, or text before or after the extracted context.\n\n<messages>\nMessages to summarize:\n{messages}\n</messages>`;\n\nconst SUMMARY_PREFIX = \"## Previous conversation summary:\";\n\nconst DEFAULT_MESSAGES_TO_KEEP = 20;\nconst DEFAULT_TRIM_TOKEN_LIMIT = 4000;\nconst DEFAULT_FALLBACK_MESSAGE_COUNT = 15;\nconst SEARCH_RANGE_FOR_TOOL_PAIRS = 5;\n\ntype TokenCounter = (messages: BaseMessage[]) => number | Promise<number>;\n\nconst contextSchema = z.object({\n  model: z.custom<BaseLanguageModel>(),\n  maxTokensBeforeSummary: z.number().optional(),\n  messagesToKeep: z.number().default(DEFAULT_MESSAGES_TO_KEEP),\n  tokenCounter: z\n    .function()\n    .args(z.array(z.any()))\n    .returns(z.union([z.number(), z.promise(z.number())]))\n    .optional(),\n  summaryPrompt: z.string().default(DEFAULT_SUMMARY_PROMPT),\n  summaryPrefix: z.string().default(SUMMARY_PREFIX),\n});\n\n/**\n * Default token counter that approximates based on character count\n * @param messages Messages to count tokens for\n * @returns Approximate token count\n */\nexport function countTokensApproximately(messages: BaseMessage[]): number {\n  let totalChars = 0;\n  for (const msg of messages) {\n    let textContent: string;\n    if (typeof msg.content === \"string\") {\n      textContent = msg.content;\n    } else if (Array.isArray(msg.content)) {\n      textContent = msg.content\n        .map((item) => {\n          if (typeof item === \"string\") return item;\n          if (item.type === \"text\" && \"text\" in item) return item.text;\n          return \"\";\n        })\n        .join(\"\");\n    } else {\n      textContent = \"\";\n    }\n    totalChars += textContent.length;\n  }\n  // Approximate 1 token = 4 characters\n  return Math.ceil(totalChars / 4);\n}\n\n/**\n * Summarization middleware that automatically summarizes conversation history when token limits are approached.\n *\n * This middleware monitors message token counts and automatically summarizes older\n * messages when a threshold is reached, preserving recent messages and maintaining\n * context continuity by ensuring AI/Tool message pairs remain together.\n *\n * @param options Configuration options for the summarization middleware\n * @returns A middleware instance\n *\n * @example\n * ```ts\n * import { summarizationMiddleware } from \"langchain/middleware\";\n * import { createAgent } from \"langchain\";\n *\n * const agent = createAgent({\n *   llm: model,\n *   tools: [getWeather],\n *   middlewares: [\n *     summarizationMiddleware({\n *       model: new ChatOpenAI({ model: \"gpt-4o\" }),\n *       maxTokensBeforeSummary: 4000,\n *       messagesToKeep: 20,\n *     })\n *   ],\n * });\n *\n * ```\n */\nexport function summarizationMiddleware(\n  options: z.input<typeof contextSchema>\n) {\n  return createMiddleware({\n    name: \"SummarizationMiddleware\",\n    contextSchema,\n    beforeModel: async (state, runtime) => {\n      const config = { ...contextSchema.parse(options), ...runtime.context };\n      const { messages } = state;\n\n      // Ensure all messages have IDs\n      ensureMessageIds(messages);\n\n      const tokenCounter = config.tokenCounter || countTokensApproximately;\n      const totalTokens = await tokenCounter(messages);\n\n      if (\n        config.maxTokensBeforeSummary == null ||\n        totalTokens < config.maxTokensBeforeSummary\n      ) {\n        return;\n      }\n\n      const { systemMessage, conversationMessages } =\n        splitSystemMessage(messages);\n      const cutoffIndex = findSafeCutoff(\n        conversationMessages,\n        config.messagesToKeep\n      );\n\n      if (cutoffIndex <= 0) {\n        return;\n      }\n\n      const { messagesToSummarize, preservedMessages } = partitionMessages(\n        systemMessage,\n        conversationMessages,\n        cutoffIndex\n      );\n\n      const summary = await createSummary(\n        messagesToSummarize,\n        config.model,\n        config.summaryPrompt,\n        tokenCounter\n      );\n\n      const updatedSystemMessage = buildUpdatedSystemMessage(\n        systemMessage,\n        summary,\n        config.summaryPrefix\n      );\n\n      return {\n        messages: [\n          new RemoveMessage({ id: REMOVE_ALL_MESSAGES }),\n          updatedSystemMessage,\n          ...preservedMessages,\n        ],\n      };\n    },\n  });\n}\n\n/**\n * Ensure all messages have unique IDs\n */\nfunction ensureMessageIds(messages: BaseMessage[]): void {\n  for (const msg of messages) {\n    if (!msg.id) {\n      msg.id = uuid();\n    }\n  }\n}\n\n/**\n * Separate system message from conversation messages\n */\nfunction splitSystemMessage(messages: BaseMessage[]): {\n  systemMessage: SystemMessage | null;\n  conversationMessages: BaseMessage[];\n} {\n  if (messages.length > 0 && isSystemMessage(messages[0])) {\n    return {\n      systemMessage: messages[0] as SystemMessage,\n      conversationMessages: messages.slice(1),\n    };\n  }\n  return {\n    systemMessage: null,\n    conversationMessages: messages,\n  };\n}\n\n/**\n * Partition messages into those to summarize and those to preserve\n */\nfunction partitionMessages(\n  systemMessage: SystemMessage | null,\n  conversationMessages: BaseMessage[],\n  cutoffIndex: number\n): { messagesToSummarize: BaseMessage[]; preservedMessages: BaseMessage[] } {\n  const messagesToSummarize = conversationMessages.slice(0, cutoffIndex);\n  const preservedMessages = conversationMessages.slice(cutoffIndex);\n\n  // Include system message in messages to summarize to capture previous summaries\n  if (systemMessage) {\n    messagesToSummarize.unshift(systemMessage);\n  }\n\n  return { messagesToSummarize, preservedMessages };\n}\n\n/**\n * Build updated system message incorporating the summary\n */\nfunction buildUpdatedSystemMessage(\n  originalSystemMessage: SystemMessage | null,\n  summary: string,\n  summaryPrefix: string\n): SystemMessage {\n  let originalContent = \"\";\n  if (originalSystemMessage) {\n    const { content } = originalSystemMessage;\n    if (typeof content === \"string\") {\n      originalContent = content.split(summaryPrefix)[0].trim();\n    }\n  }\n\n  const content = originalContent\n    ? `${originalContent}\\n${summaryPrefix}\\n${summary}`\n    : `${summaryPrefix}\\n${summary}`;\n\n  return new SystemMessage({\n    content,\n    id: originalSystemMessage?.id || uuid(),\n  });\n}\n\n/**\n * Find safe cutoff point that preserves AI/Tool message pairs\n */\nfunction findSafeCutoff(\n  messages: BaseMessage[],\n  messagesToKeep: number\n): number {\n  if (messages.length <= messagesToKeep) {\n    return 0;\n  }\n\n  const targetCutoff = messages.length - messagesToKeep;\n\n  for (let i = targetCutoff; i >= 0; i--) {\n    if (isSafeCutoffPoint(messages, i)) {\n      return i;\n    }\n  }\n\n  return 0;\n}\n\n/**\n * Check if cutting at index would separate AI/Tool message pairs\n */\nfunction isSafeCutoffPoint(\n  messages: BaseMessage[],\n  cutoffIndex: number\n): boolean {\n  if (cutoffIndex >= messages.length) {\n    return true;\n  }\n\n  const searchStart = Math.max(0, cutoffIndex - SEARCH_RANGE_FOR_TOOL_PAIRS);\n  const searchEnd = Math.min(\n    messages.length,\n    cutoffIndex + SEARCH_RANGE_FOR_TOOL_PAIRS\n  );\n\n  for (let i = searchStart; i < searchEnd; i++) {\n    if (!hasToolCalls(messages[i])) {\n      continue;\n    }\n\n    const toolCallIds = extractToolCallIds(messages[i] as AIMessage);\n    if (cutoffSeparatesToolPair(messages, i, cutoffIndex, toolCallIds)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Check if message is an AI message with tool calls\n */\nfunction hasToolCalls(message: BaseMessage): boolean {\n  return (\n    isAIMessage(message) &&\n    \"tool_calls\" in message &&\n    Array.isArray(message.tool_calls) &&\n    message.tool_calls.length > 0\n  );\n}\n\n/**\n * Extract tool call IDs from an AI message\n */\nfunction extractToolCallIds(aiMessage: AIMessage): Set<string> {\n  const toolCallIds = new Set<string>();\n  if (aiMessage.tool_calls) {\n    for (const toolCall of aiMessage.tool_calls) {\n      const id =\n        typeof toolCall === \"object\" && \"id\" in toolCall ? toolCall.id : null;\n      if (id) {\n        toolCallIds.add(id);\n      }\n    }\n  }\n  return toolCallIds;\n}\n\n/**\n * Check if cutoff separates an AI message from its corresponding tool messages\n */\nfunction cutoffSeparatesToolPair(\n  messages: BaseMessage[],\n  aiMessageIndex: number,\n  cutoffIndex: number,\n  toolCallIds: Set<string>\n): boolean {\n  for (let j = aiMessageIndex + 1; j < messages.length; j++) {\n    const message = messages[j];\n    if (isToolMessage(message) && toolCallIds.has(message.tool_call_id)) {\n      const aiBeforeCutoff = aiMessageIndex < cutoffIndex;\n      const toolBeforeCutoff = j < cutoffIndex;\n      if (aiBeforeCutoff !== toolBeforeCutoff) {\n        return true;\n      }\n    }\n  }\n  return false;\n}\n\n/**\n * Generate summary for the given messages\n */\nasync function createSummary(\n  messagesToSummarize: BaseMessage[],\n  model: BaseLanguageModel,\n  summaryPrompt: string,\n  tokenCounter: TokenCounter\n): Promise<string> {\n  if (!messagesToSummarize.length) {\n    return \"No previous conversation history.\";\n  }\n\n  const trimmedMessages = await trimMessagesForSummary(\n    messagesToSummarize,\n    tokenCounter\n  );\n\n  if (!trimmedMessages.length) {\n    return \"Previous conversation was too long to summarize.\";\n  }\n\n  try {\n    const formattedPrompt = summaryPrompt.replace(\n      \"{messages}\",\n      JSON.stringify(trimmedMessages, null, 2)\n    );\n    const response = await model.invoke(formattedPrompt);\n    const { content } = response;\n    return typeof content === \"string\"\n      ? content.trim()\n      : \"Error generating summary: Invalid response format\";\n  } catch (e) {\n    return `Error generating summary: ${e}`;\n  }\n}\n\n/**\n * Trim messages to fit within summary generation limits\n */\nasync function trimMessagesForSummary(\n  messages: BaseMessage[],\n  tokenCounter: TokenCounter\n): Promise<BaseMessage[]> {\n  try {\n    return await trimMessages(messages, {\n      maxTokens: DEFAULT_TRIM_TOKEN_LIMIT,\n      tokenCounter: async (msgs) => Promise.resolve(tokenCounter(msgs)),\n      strategy: \"last\",\n      allowPartial: true,\n      includeSystem: true,\n    });\n  } catch (e) {\n    // Fallback to last N messages if trimming fails\n    return messages.slice(-DEFAULT_FALLBACK_MESSAGE_COUNT);\n  }\n}\n"],"mappings":"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"}