langchain 1.0.0-alpha.8 → 1.0.0-alpha.9

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

@@ -1,340 +0,0 @@
-import { createMiddleware } from "../middleware.js";
-import { AIMessage, ToolMessage } from "@langchain/core/messages";
-import { interrupt } from "@langchain/langgraph";
-import { interopParse } from "@langchain/core/utils/types";
-import { z } from "zod/v3";
-
-//#region src/agents/middlewareAgent/middleware/hitl.ts
-const ToolConfigSchema = z.object({
-	allowAccept: z.boolean().optional(),
-	allowEdit: z.boolean().optional(),
-	allowRespond: z.boolean().optional(),
-	description: z.union([z.string(), z.function()]).optional()
-});
-const contextSchema = z.object({
-	interruptOn: z.record(z.union([z.boolean(), ToolConfigSchema])).optional(),
-	descriptionPrefix: 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.
-*
-* A invocation result that has been interrupted by the middleware will have a `__interrupt__`
-* property that contains the interrupt request. You can loop over the request to determine
-* which tools were interrupted, and how to handle them separately.
-*
-* ```ts
-* import { type ToolApprovalRequest, type HumanInTheLoopMiddlewareHumanResponse } from "langchain";
-* import { type Interrupt } from "langchain";
-*
-* const result = await agent.invoke(request);
-* const interruptRequest = initialResult.__interrupt__?.[0] as Interrupt<
-*   ToolApprovalRequest[]
-* >;
-* const resume: HumanInTheLoopMiddlewareHumanResponse[] =
-*   interruptRequest.value.map((request) => {
-*     if (request.action === "calculator") {
-*       return { id: request.toolCallId, type: "accept" };
-*     } else if (request.action === "write_file") {
-*       return {
-*         id: request.toolCallId,
-*         type: "edit",
-*         args: { filename: "safe.txt", content: "Safe content" },
-*       };
-*     }
-*
-*     throw new Error(`Unknown action: ${request.action}`);
-*   });
-*
-* // Resume with approval
-* await agent.invoke(new Command({ resume }), config);
-* ```
-*
-* ## 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.interruptOn - Per-tool configuration mapping tool names to their settings
-* @param options.interruptOn[toolName].allowAccept - Whether the human can approve the current action without changes
-* @param options.interruptOn[toolName].allowEdit - Whether the human can reject the current action with feedback
-* @param options.interruptOn[toolName].allowRespond - Whether the human can approve the current action with edited content
-* @param options.interruptOn[toolName].description - Custom approval message for the tool. Can be either a static string or a callable that dynamically generates the description based on agent state, runtime, and tool call information
-* @param options.messagePrefix - Default prefix for approval messages (default: "Tool execution requires approval"). Only used for tools that do not define a custom `description` in their ToolConfig.
-*
-* @returns A middleware instance that can be passed to `createAgent`
-*
-* @example
-* Basic usage with selective tool approval
-* ```typescript
-* import { humanInTheLoopMiddleware } from "langchain";
-* import { createAgent } from "langchain";
-*
-* const hitlMiddleware = humanInTheLoopMiddleware({
-*   interruptOn: {
-*     // Interrupt write_file tool and allow edits or accepts
-*     "write_file": {
-*       allowEdit: true,
-*       allowAccept: true,
-*       description: "⚠️ File write operation requires approval"
-*     },
-*     // Auto-approve read_file tool
-*     "read_file": false
-*   }
-* });
-*
-* const agent = createAgent({
-*   model: "openai:gpt-4",
-*   tools: [writeFileTool, readFileTool],
-*   middleware: [hitlMiddleware]
-* });
-* ```
-*
-* @example
-* Handling approval requests
-* ```typescript
-* import { type HumanInTheLoopRequest, type Interrupt } from "langchain";
-* 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
-* if (result.__interrupt__) {
-*   const interruptRequest = initialResult.__interrupt__?.[0] as Interrupt<
-*     HumanInTheLoopRequest[]
-*   >;
-*
-*   // Show tool call details to user
-*   console.log("Tool:", interruptRequest.value[0].actionRequest);
-*   console.log("Allowed actions:", interruptRequest.value[0].config);
-*
-*   // 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: "response" }] })
-*
-* // Provide manual response
-* new Command({
-*   resume: [{
-*     type: "response",
-*     // this must be a string
-*     args: "File operation not allowed in demo mode"
-*   }]
-* })
-* ```
-*
-* @example
-* Production use case with database operations
-* ```typescript
-* const hitlMiddleware = humanInTheLoopMiddleware({
-*   interruptOn: {
-*     "execute_sql": {
-*       allowAccept: true,
-*       allowEdit: true,
-*       allowRespond: true,
-*       description: "🚨 SQL query requires DBA approval\nPlease review for safety and performance"
-*     },
-*     "read_schema": false  // Reading metadata is safe
-*     "delete_records": {
-*       allowAccept: true,
-*       description: "⛔ DESTRUCTIVE OPERATION - Requires manager approval"
-*     }
-*   },
-*   messagePrefix: "Database operation pending approval"
-* });
-* ```
-*
-* @example
-* Using dynamic callable descriptions
-* ```typescript
-* import { type DescriptionFactory } from "langchain";
-*
-* // Define a dynamic description factory
-* const formatToolDescription: DescriptionFactory = (toolCall, state, runtime) => {
-*   return `Tool: ${toolCall.name}\nArguments:\n${JSON.stringify(toolCall.args, null, 2)}`;
-* };
-*
-* const hitlMiddleware = humanInTheLoopMiddleware({
-*   interruptOn: {
-*     "write_file": {
-*       allowAccept: true,
-*       allowEdit: true,
-*       // Use dynamic description that can access tool call, state, and runtime
-*       description: formatToolDescription
-*     },
-*     // Or use an inline function
-*     "send_email": {
-*       allowAccept: true,
-*       description: (toolCall, state, runtime) => {
-*         const { to, subject } = toolCall.args;
-*         return `Email to ${to}\nSubject: ${subject}\n\nRequires approval before sending`;
-*       }
-*     }
-*   }
-* });
-* ```
-*
-* @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,
-		afterModelJumpTo: ["model"],
-		afterModel: async (state, runtime) => {
-			const config = interopParse(contextSchema, {
-				...options,
-				...runtime.context || {}
-			});
-			if (!config) return;
-			const { messages } = state;
-			if (!messages.length) return;
-			/**
-			* Don't do anything if the last message isn't an AI message with tool calls.
-			*/
-			const lastMessage = [...messages].reverse().find((msg) => AIMessage.isInstance(msg));
-			if (!lastMessage || !lastMessage.tool_calls?.length) return;
-			/**
-			* If the user omits the interruptOn config, we don't do anything.
-			*/
-			if (!config.interruptOn) return;
-			const resolvedToolConfigs = {};
-			for (const [toolName, toolConfig] of Object.entries(config.interruptOn)) if (typeof toolConfig === "boolean") {
-				if (toolConfig === true) resolvedToolConfigs[toolName] = {
-					allowAccept: true,
-					allowEdit: true,
-					allowRespond: true
-				};
-			} else resolvedToolConfigs[toolName] = toolConfig;
-			const interruptToolCalls = [];
-			const autoApprovedToolCalls = [];
-			for (const toolCall of lastMessage.tool_calls) if (toolCall.name in resolvedToolConfigs) interruptToolCalls.push(toolCall);
-			else autoApprovedToolCalls.push(toolCall);
-			/**
-			* No interrupt tool calls, so we can just return.
-			*/
-			if (!interruptToolCalls.length) return;
-			const hitlRequests = await Promise.all(interruptToolCalls.map(async (toolCall) => {
-				const toolConfig = resolvedToolConfigs[toolCall.name];
-				const description = toolConfig.description ? typeof toolConfig.description === "function" ? await toolConfig.description(toolCall, state, runtime) : toolConfig.description : `${config.descriptionPrefix}\n\nTool: ${toolCall.name}\nArgs: ${JSON.stringify(toolCall.args, null, 2)}`;
-				return {
-					actionRequest: {
-						action: toolCall.name,
-						args: toolCall.args
-					},
-					config: toolConfig,
-					description
-				};
-			}));
-			const responses = await interrupt(hitlRequests);
-			if (responses.length !== interruptToolCalls.length) throw new Error(`Number of human responses (${responses.length}) does not match number of hanging tool calls (${interruptToolCalls.length}).`);
-			const approvedToolCalls = [...autoApprovedToolCalls];
-			const artificialToolMessages = [];
-			for (const [i, response] of responses.entries()) {
-				const toolCall = interruptToolCalls[i];
-				const toolConfig = resolvedToolConfigs[toolCall.name];
-				if (response.type === "accept" && toolConfig?.allowAccept) {
-					approvedToolCalls.push(toolCall);
-					continue;
-				}
-				if (response.type === "edit" && toolConfig?.allowEdit) {
-					const edited = response.args;
-					approvedToolCalls.push({
-						id: toolCall.id,
-						name: edited.action,
-						args: edited.args
-					});
-					continue;
-				}
-				if (response.type === "response" && toolConfig?.allowRespond) {
-					const content = response.args ?? `User rejected the tool call for \`${toolCall.name}\` with id ${toolCall.id}`;
-					/**
-					* Providing a meaningful error message for this case that should never happen.
-					*/
-					if (!toolCall.id) throw new Error(`Can't provide custom tool response for tool call without an ID: ${toolCall.name}!\nThis use case is not expected to happen, please report this as a bug.`);
-					/**
-					* ToolMessage expects a string, so we need to throw an error if it's not a string
-					* as we currently have no way to proper type responses from users through the
-					* Command object.
-					*/
-					if (typeof content !== "string") throw new Error(`Tool call response for "${toolCall.name}" must be a string, got ${typeof content}`);
-					artificialToolMessages.push(new ToolMessage({
-						content,
-						name: toolCall.name,
-						tool_call_id: toolCall.id,
-						status: "error"
-					}));
-					continue;
-				}
-				const allowedActions = [
-					toolConfig?.allowAccept && "accept",
-					toolConfig?.allowEdit && "edit",
-					toolConfig?.allowRespond && "response"
-				].filter(Boolean).join("\", \"");
-				throw new Error(`Unexpected human response: ${JSON.stringify(response)}. Response action '${response.type}' is not allowed for tool '${toolCall.name}'. Expected one of: "${allowedActions}", based on the tool's configuration.`);
-			}
-			/**
-			* Replace the tool calls with the approved tool calls
-			*/
-			if (AIMessage.isInstance(lastMessage)) lastMessage.tool_calls = lastMessage.tool_calls?.map((tc) => {
-				const approvedToolCall = approvedToolCalls.find((atc) => atc.id === tc.id);
-				return approvedToolCall ?? tc;
-			});
-			if (approvedToolCalls.length > 0) return { messages: [...state.messages, ...artificialToolMessages] };
-			return {
-				jumpTo: "model",
-				messages: [...state.messages, ...artificialToolMessages]
-			};
-		}
-	});
-}
-
-//#endregion
-export { humanInTheLoopMiddleware };
-//# sourceMappingURL=hitl.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"hitl.js","names":["options: NonNullable<HumanInTheLoopMiddlewareConfig>","resolvedToolConfigs: Record<string, ToolConfig>","interruptToolCalls: ToolCall[]","autoApprovedToolCalls: ToolCall[]","hitlRequests: HumanInTheLoopRequest[]","approvedToolCalls: ToolCall[]","artificialToolMessages: ToolMessage[]"],"sources":["../../../../src/agents/middlewareAgent/middleware/hitl.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { z } from \"zod/v3\";\nimport { AIMessage, ToolMessage } from \"@langchain/core/messages\";\nimport {\n  InferInteropZodInput,\n  interopParse,\n} from \"@langchain/core/utils/types\";\nimport { interrupt } from \"@langchain/langgraph\";\n\nimport { createMiddleware } from \"../middleware.js\";\nimport type { AgentBuiltInState, Runtime } from \"../types.js\";\n\nconst ToolConfigSchema = z.object({\n  /**\n   * Whether the human can approve the current action without changes\n   */\n  allowAccept: z.boolean().optional(),\n  /**\n   * Whether the human can reject the current action with feedback\n   */\n  allowEdit: z.boolean().optional(),\n  /**\n   * Whether the human can approve the current action with edited content\n   */\n  allowRespond: z.boolean().optional(),\n  /**\n   * The description attached to the request for human input.\n   * Can be either:\n   * - A static string describing the approval request\n   * - A callable that dynamically generates the description based on agent state,\n   *   runtime, and tool call information\n   *\n   * @example\n   * Static string description\n   * ```typescript\n   * const config: ToolConfig = {\n   *   allowAccept: true,\n   *   description: \"Please review this tool execution\"\n   * };\n   * ```\n   *\n   * @example\n   * Dynamic callable description\n   * ```typescript\n   * const formatToolDescription: DescriptionFactory = (toolCall, state, runtime) => {\n   *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n   * };\n   *\n   * const config: ToolConfig = {\n   *   allowAccept: true,\n   *   description: formatToolDescription\n   * };\n   * ```\n   */\n  description: z.union([z.string(), z.function()]).optional(),\n});\n\ntype ToolConfigSchema = z.input<typeof ToolConfigSchema>;\ntype ToolCall = NonNullable<AIMessage[\"tool_calls\"]>[number];\n\n/**\n * Function type that dynamically generates a description based on agent state,\n * runtime, and tool call information.\n */\nexport type DescriptionFactory<\n  State extends AgentBuiltInState = AgentBuiltInState\n> = (\n  toolCall: ToolCall,\n  state: State,\n  runtime: Runtime<unknown>\n) => string | Promise<string>;\n\n/**\n * Configuration that defines which reviewer response types are permitted during a human interrupt.\n * These flags control what the human reviewer may do (e.g., accept/edit/respond),\n * not the tool action the agent has requested.\n */\nexport interface HumanInTheLoopConfig\n  extends Omit<ToolConfigSchema, \"description\"> {}\n\n/**\n * Describes the agent-requested tool action (name and arguments).\n * This is what the AI intends to execute, subject to human review.\n */\nexport interface ActionRequest {\n  /**\n   * The tool/action name requested by the agent (e.g., \"send_email\").\n   */\n  action: string;\n  /**\n   * Arguments for the requested tool call (e.g., {\"a\": 1, \"b\": 2}).\n   */\n  args: Record<string, any>;\n}\n\n/**\n * Represents an interrupt triggered by the graph that requires human intervention\n * to approve, edit, or respond to an agent-requested tool action.\n *\n * @example\n * ```ts\n * const hitlRequest: HumanInTheLoopRequest = {\n *   actionRequest: { action: \"Approve XYZ action\", args: { ... } },\n *   config: { allowAccept: true, allowEdit: true, allowRespond: true },\n *   description: \"Please review the command before execution\"\n * };\n * response = interrupt([request])[0]\n * ```\n */\nexport interface HumanInTheLoopRequest {\n  /**\n   * The agent-requested tool action to be reviewed.\n   */\n  actionRequest: ActionRequest;\n  /**\n   * Which reviewer responses are allowed (accept/edit/respond).\n   */\n  config: HumanInTheLoopConfig;\n  /**\n   * Optional human-facing description shown in the approval prompt.\n   */\n  description?: string;\n}\n\n/**\n * Response when a human approves the agent-requested action.\n */\nexport interface AcceptPayload {\n  type: \"accept\";\n}\n\n/**\n * Response when a human provides a manual response instead of executing\n * the agent-requested action.\n */\nexport interface ResponsePayload {\n  type: \"response\";\n  args?: string;\n}\n\n/**\n * Response when a human edits the agent-requested action (tool name and/or args).\n */\nexport interface EditPayload {\n  type: \"edit\";\n  args: ActionRequest;\n}\n\nexport type HumanInTheLoopMiddlewareHumanResponse =\n  | AcceptPayload\n  | ResponsePayload\n  | EditPayload;\n\n/**\n * Configuration for a tool requiring human in the loop.\n */\nexport interface ToolConfig extends HumanInTheLoopConfig {\n  /**\n   * Human-facing description shown in the approval request.\n   * Can be either:\n   * - A static string describing the approval request\n   * - A callable that dynamically generates the description based on agent state,\n   *   runtime, and tool call information\n   */\n  description?: string | DescriptionFactory;\n}\n\nconst contextSchema = z.object({\n  /**\n   * Mapping of tool name to allowed reviewer responses.\n   * If a tool doesn't have an entry, it's auto-approved by default.\n   *\n   * - `true` -> pause for approval and allow accept/edit/respond\n   * - `false` -> auto-approve (no human review)\n   * - `ToolConfig` -> explicitly specify which reviewer responses are allowed for this tool\n   */\n  interruptOn: z.record(z.union([z.boolean(), ToolConfigSchema])).optional(),\n  /**\n   * Prefix used when constructing human-facing approval messages.\n   * Provides context about the tool call being reviewed; does not change the underlying action.\n   *\n   * Note: This prefix is only applied for tools that do not provide a custom\n   * `description` via their {@link ToolConfig}. If a tool specifies a custom\n   * `description`, that per-tool text is used and this prefix is ignored.\n   */\n  descriptionPrefix: z.string().default(\"Tool execution requires approval\"),\n});\nexport type HumanInTheLoopMiddlewareConfig = InferInteropZodInput<\n  typeof contextSchema\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 * A invocation result that has been interrupted by the middleware will have a `__interrupt__`\n * property that contains the interrupt request. You can loop over the request to determine\n * which tools were interrupted, and how to handle them separately.\n *\n * ```ts\n * import { type ToolApprovalRequest, type HumanInTheLoopMiddlewareHumanResponse } from \"langchain\";\n * import { type Interrupt } from \"langchain\";\n *\n * const result = await agent.invoke(request);\n * const interruptRequest = initialResult.__interrupt__?.[0] as Interrupt<\n *   ToolApprovalRequest[]\n * >;\n * const resume: HumanInTheLoopMiddlewareHumanResponse[] =\n *   interruptRequest.value.map((request) => {\n *     if (request.action === \"calculator\") {\n *       return { id: request.toolCallId, type: \"accept\" };\n *     } else if (request.action === \"write_file\") {\n *       return {\n *         id: request.toolCallId,\n *         type: \"edit\",\n *         args: { filename: \"safe.txt\", content: \"Safe content\" },\n *       };\n *     }\n *\n *     throw new Error(`Unknown action: ${request.action}`);\n *   });\n *\n * // Resume with approval\n * await agent.invoke(new Command({ resume }), config);\n * ```\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.interruptOn - Per-tool configuration mapping tool names to their settings\n * @param options.interruptOn[toolName].allowAccept - Whether the human can approve the current action without changes\n * @param options.interruptOn[toolName].allowEdit - Whether the human can reject the current action with feedback\n * @param options.interruptOn[toolName].allowRespond - Whether the human can approve the current action with edited content\n * @param options.interruptOn[toolName].description - Custom approval message for the tool. Can be either a static string or a callable that dynamically generates the description based on agent state, runtime, and tool call information\n * @param options.messagePrefix - Default prefix for approval messages (default: \"Tool execution requires approval\"). Only used for tools that do not define a custom `description` in their ToolConfig.\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\";\n * import { createAgent } from \"langchain\";\n *\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     // Interrupt write_file tool and allow edits or accepts\n *     \"write_file\": {\n *       allowEdit: true,\n *       allowAccept: true,\n *       description: \"⚠️ File write operation requires approval\"\n *     },\n *     // Auto-approve read_file tool\n *     \"read_file\": false\n *   }\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4\",\n *   tools: [writeFileTool, readFileTool],\n *   middleware: [hitlMiddleware]\n * });\n * ```\n *\n * @example\n * Handling approval requests\n * ```typescript\n * import { type HumanInTheLoopRequest, type Interrupt } from \"langchain\";\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 * if (result.__interrupt__) {\n *   const interruptRequest = initialResult.__interrupt__?.[0] as Interrupt<\n *     HumanInTheLoopRequest[]\n *   >;\n *\n *   // Show tool call details to user\n *   console.log(\"Tool:\", interruptRequest.value[0].actionRequest);\n *   console.log(\"Allowed actions:\", interruptRequest.value[0].config);\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: \"response\" }] })\n *\n * // Provide manual response\n * new Command({\n *   resume: [{\n *     type: \"response\",\n *     // this must be a string\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 *   interruptOn: {\n *     \"execute_sql\": {\n *       allowAccept: true,\n *       allowEdit: true,\n *       allowRespond: true,\n *       description: \"🚨 SQL query requires DBA approval\\nPlease review for safety and performance\"\n *     },\n *     \"read_schema\": false  // Reading metadata is safe\n *     \"delete_records\": {\n *       allowAccept: true,\n *       description: \"⛔ DESTRUCTIVE OPERATION - Requires manager approval\"\n *     }\n *   },\n *   messagePrefix: \"Database operation pending approval\"\n * });\n * ```\n *\n * @example\n * Using dynamic callable descriptions\n * ```typescript\n * import { type DescriptionFactory } from \"langchain\";\n *\n * // Define a dynamic description factory\n * const formatToolDescription: DescriptionFactory = (toolCall, state, runtime) => {\n *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n * };\n *\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     \"write_file\": {\n *       allowAccept: true,\n *       allowEdit: true,\n *       // Use dynamic description that can access tool call, state, and runtime\n *       description: formatToolDescription\n *     },\n *     // Or use an inline function\n *     \"send_email\": {\n *       allowAccept: true,\n *       description: (toolCall, state, runtime) => {\n *         const { to, subject } = toolCall.args;\n *         return `Email to ${to}\\nSubject: ${subject}\\n\\nRequires approval before sending`;\n *       }\n *     }\n *   }\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: NonNullable<HumanInTheLoopMiddlewareConfig>\n) {\n  return createMiddleware({\n    name: \"HumanInTheLoopMiddleware\",\n    contextSchema,\n    afterModelJumpTo: [\"model\"],\n    afterModel: async (state, runtime) => {\n      const config = interopParse(contextSchema, {\n        ...options,\n        ...(runtime.context || {}),\n      });\n      if (!config) {\n        return;\n      }\n\n      const { messages } = state;\n      if (!messages.length) {\n        return;\n      }\n\n      /**\n       * Don't do anything if the last message isn't an AI message with tool calls.\n       */\n      const lastMessage = [...messages]\n        .reverse()\n        .find((msg) => AIMessage.isInstance(msg)) as AIMessage;\n      if (!lastMessage || !lastMessage.tool_calls?.length) {\n        return;\n      }\n\n      /**\n       * If the user omits the interruptOn config, we don't do anything.\n       */\n      if (!config.interruptOn) {\n        return;\n      }\n\n      // Resolve per-tool configs (boolean true -> all actions allowed; false -> auto-approve)\n      const resolvedToolConfigs: Record<string, ToolConfig> = {};\n      for (const [toolName, toolConfig] of Object.entries(config.interruptOn)) {\n        if (typeof toolConfig === \"boolean\") {\n          if (toolConfig === true) {\n            resolvedToolConfigs[toolName] = {\n              allowAccept: true,\n              allowEdit: true,\n              allowRespond: true,\n            };\n          }\n        } else {\n          resolvedToolConfigs[toolName] = toolConfig as ToolConfig;\n        }\n      }\n\n      const interruptToolCalls: ToolCall[] = [];\n      const autoApprovedToolCalls: ToolCall[] = [];\n\n      for (const toolCall of lastMessage.tool_calls) {\n        if (toolCall.name in resolvedToolConfigs) {\n          interruptToolCalls.push(toolCall);\n        } else {\n          autoApprovedToolCalls.push(toolCall);\n        }\n      }\n\n      /**\n       * No interrupt tool calls, so we can just return.\n       */\n      if (!interruptToolCalls.length) {\n        return;\n      }\n\n      const hitlRequests: HumanInTheLoopRequest[] = await Promise.all(\n        interruptToolCalls.map(async (toolCall) => {\n          const toolConfig = resolvedToolConfigs[toolCall.name]!;\n          const description = toolConfig.description\n            ? typeof toolConfig.description === \"function\"\n              ? /**\n                 * If description is a function, call it with the required parameters\n                 */\n                await toolConfig.description(toolCall, state, runtime)\n              : /**\n                 * Otherwise, use the static string\n                 */\n                toolConfig.description\n            : /**\n               * Fall back to the default description\n               */\n              `${config.descriptionPrefix}\\n\\nTool: ${\n                toolCall.name\n              }\\nArgs: ${JSON.stringify(toolCall.args, null, 2)}`;\n\n          return {\n            actionRequest: { action: toolCall.name, args: toolCall.args },\n            config: toolConfig,\n            description,\n          };\n        })\n      );\n\n      const responses = (await interrupt(\n        hitlRequests\n      )) as HumanInTheLoopMiddlewareHumanResponse[];\n\n      if (responses.length !== interruptToolCalls.length) {\n        throw new Error(\n          `Number of human responses (${responses.length}) does not match number of hanging tool calls (${interruptToolCalls.length}).`\n        );\n      }\n\n      const approvedToolCalls: ToolCall[] = [...autoApprovedToolCalls];\n      const artificialToolMessages: ToolMessage[] = [];\n\n      for (const [i, response] of responses.entries()) {\n        const toolCall = interruptToolCalls[i]!;\n        const toolConfig = resolvedToolConfigs[toolCall.name]!;\n\n        if (response.type === \"accept\" && toolConfig?.allowAccept) {\n          approvedToolCalls.push(toolCall);\n          continue;\n        }\n\n        if (response.type === \"edit\" && toolConfig?.allowEdit) {\n          const edited = response.args;\n          approvedToolCalls.push({\n            id: toolCall.id,\n            name: edited.action,\n            args: edited.args,\n          });\n          continue;\n        }\n\n        if (response.type === \"response\" && toolConfig?.allowRespond) {\n          const content =\n            response.args ??\n            `User rejected the tool call for \\`${toolCall.name}\\` with id ${toolCall.id}`;\n\n          /**\n           * Providing a meaningful error message for this case that should never happen.\n           */\n          if (!toolCall.id) {\n            throw new Error(\n              `Can't provide custom tool response for tool call without an ID: ${toolCall.name}!\\n` +\n                \"This use case is not expected to happen, please report this as a bug.\"\n            );\n          }\n\n          /**\n           * ToolMessage expects a string, so we need to throw an error if it's not a string\n           * as we currently have no way to proper type responses from users through the\n           * Command object.\n           */\n          if (typeof content !== \"string\") {\n            throw new Error(\n              `Tool call response for \"${\n                toolCall.name\n              }\" must be a string, got ${typeof content}`\n            );\n          }\n\n          artificialToolMessages.push(\n            new ToolMessage({\n              content,\n              name: toolCall.name,\n              tool_call_id: toolCall.id,\n              status: \"error\",\n            })\n          );\n          continue;\n        }\n\n        const allowedActions = [\n          toolConfig?.allowAccept && \"accept\",\n          toolConfig?.allowEdit && \"edit\",\n          toolConfig?.allowRespond && \"response\",\n        ]\n          .filter(Boolean)\n          .join('\", \"');\n        throw new Error(\n          `Unexpected human response: ${JSON.stringify(\n            response\n          )}. Response action '${response.type}' is not allowed for tool '${\n            toolCall.name\n          }'. Expected one of: \"${allowedActions}\", based on the tool's configuration.`\n        );\n      }\n\n      /**\n       * Replace the tool calls with the approved tool calls\n       */\n      if (AIMessage.isInstance(lastMessage)) {\n        lastMessage.tool_calls = lastMessage.tool_calls?.map((tc) => {\n          const approvedToolCall = approvedToolCalls.find(\n            (atc) => atc.id === tc.id\n          );\n          return approvedToolCall ?? tc;\n        });\n      }\n\n      if (approvedToolCalls.length > 0) {\n        return { messages: [...state.messages, ...artificialToolMessages] };\n      }\n\n      return {\n        jumpTo: \"model\",\n        messages: [...state.messages, ...artificialToolMessages],\n      };\n    },\n  });\n}\n"],"mappings":";;;;;;;AAYA,MAAM,mBAAmB,EAAE,OAAO;CAIhC,aAAa,EAAE,SAAS,CAAC,UAAU;CAInC,WAAW,EAAE,SAAS,CAAC,UAAU;CAIjC,cAAc,EAAE,SAAS,CAAC,UAAU;CA8BpC,aAAa,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,EAAE,UAAU,AAAC,EAAC,CAAC,UAAU;AAC5D,EAAC;AAgHF,MAAM,gBAAgB,EAAE,OAAO;CAS7B,aAAa,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,SAAS,EAAE,gBAAiB,EAAC,CAAC,CAAC,UAAU;CAS1E,mBAAmB,EAAE,QAAQ,CAAC,QAAQ,mCAAmC;AAC1E,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoNF,SAAgB,yBACdA,SACA;AACA,QAAO,iBAAiB;EACtB,MAAM;EACN;EACA,kBAAkB,CAAC,OAAQ;EAC3B,YAAY,OAAO,OAAO,YAAY;GACpC,MAAM,SAAS,aAAa,eAAe;IACzC,GAAG;IACH,GAAI,QAAQ,WAAW,CAAE;GAC1B,EAAC;AACF,OAAI,CAAC,OACH;GAGF,MAAM,EAAE,UAAU,GAAG;AACrB,OAAI,CAAC,SAAS,OACZ;;;;GAMF,MAAM,cAAc,CAAC,GAAG,QAAS,EAC9B,SAAS,CACT,KAAK,CAAC,QAAQ,UAAU,WAAW,IAAI,CAAC;AAC3C,OAAI,CAAC,eAAe,CAAC,YAAY,YAAY,OAC3C;;;;AAMF,OAAI,CAAC,OAAO,YACV;GAIF,MAAMC,sBAAkD,CAAE;AAC1D,QAAK,MAAM,CAAC,UAAU,WAAW,IAAI,OAAO,QAAQ,OAAO,YAAY,CACrE,KAAI,OAAO,eAAe,WACxB;QAAI,eAAe,MACjB,oBAAoB,YAAY;KAC9B,aAAa;KACb,WAAW;KACX,cAAc;IACf;GACF,OAED,oBAAoB,YAAY;GAIpC,MAAMC,qBAAiC,CAAE;GACzC,MAAMC,wBAAoC,CAAE;AAE5C,QAAK,MAAM,YAAY,YAAY,WACjC,KAAI,SAAS,QAAQ,qBACnB,mBAAmB,KAAK,SAAS;QAEjC,sBAAsB,KAAK,SAAS;;;;AAOxC,OAAI,CAAC,mBAAmB,OACtB;GAGF,MAAMC,eAAwC,MAAM,QAAQ,IAC1D,mBAAmB,IAAI,OAAO,aAAa;IACzC,MAAM,aAAa,oBAAoB,SAAS;IAChD,MAAM,cAAc,WAAW,cAC3B,OAAO,WAAW,gBAAgB,aAIhC,MAAM,WAAW,YAAY,UAAU,OAAO,QAAQ,GAItD,WAAW,cAIb,GAAG,OAAO,kBAAkB,UAAU,EACpC,SAAS,KACV,QAAQ,EAAE,KAAK,UAAU,SAAS,MAAM,MAAM,EAAE,EAAE;AAEvD,WAAO;KACL,eAAe;MAAE,QAAQ,SAAS;MAAM,MAAM,SAAS;KAAM;KAC7D,QAAQ;KACR;IACD;GACF,EAAC,CACH;GAED,MAAM,YAAa,MAAM,UACvB,aACD;AAED,OAAI,UAAU,WAAW,mBAAmB,OAC1C,OAAM,IAAI,MACR,CAAC,2BAA2B,EAAE,UAAU,OAAO,+CAA+C,EAAE,mBAAmB,OAAO,EAAE,CAAC;GAIjI,MAAMC,oBAAgC,CAAC,GAAG,qBAAsB;GAChE,MAAMC,yBAAwC,CAAE;AAEhD,QAAK,MAAM,CAAC,GAAG,SAAS,IAAI,UAAU,SAAS,EAAE;IAC/C,MAAM,WAAW,mBAAmB;IACpC,MAAM,aAAa,oBAAoB,SAAS;AAEhD,QAAI,SAAS,SAAS,YAAY,YAAY,aAAa;KACzD,kBAAkB,KAAK,SAAS;AAChC;IACD;AAED,QAAI,SAAS,SAAS,UAAU,YAAY,WAAW;KACrD,MAAM,SAAS,SAAS;KACxB,kBAAkB,KAAK;MACrB,IAAI,SAAS;MACb,MAAM,OAAO;MACb,MAAM,OAAO;KACd,EAAC;AACF;IACD;AAED,QAAI,SAAS,SAAS,cAAc,YAAY,cAAc;KAC5D,MAAM,UACJ,SAAS,QACT,CAAC,kCAAkC,EAAE,SAAS,KAAK,WAAW,EAAE,SAAS,IAAI;;;;AAK/E,SAAI,CAAC,SAAS,GACZ,OAAM,IAAI,MACR,CAAC,gEAAgE,EAAE,SAAS,KAAK,wEAAG,CACX;;;;;;AAS7E,SAAI,OAAO,YAAY,SACrB,OAAM,IAAI,MACR,CAAC,wBAAwB,EACvB,SAAS,KACV,wBAAwB,EAAE,OAAO,SAAS;KAI/C,uBAAuB,KACrB,IAAI,YAAY;MACd;MACA,MAAM,SAAS;MACf,cAAc,SAAS;MACvB,QAAQ;KACT,GACF;AACD;IACD;IAED,MAAM,iBAAiB;KACrB,YAAY,eAAe;KAC3B,YAAY,aAAa;KACzB,YAAY,gBAAgB;IAC7B,EACE,OAAO,QAAQ,CACf,KAAK,SAAO;AACf,UAAM,IAAI,MACR,CAAC,2BAA2B,EAAE,KAAK,UACjC,SACD,CAAC,mBAAmB,EAAE,SAAS,KAAK,2BAA2B,EAC9D,SAAS,KACV,qBAAqB,EAAE,eAAe,qCAAqC,CAAC;GAEhF;;;;AAKD,OAAI,UAAU,WAAW,YAAY,EACnC,YAAY,aAAa,YAAY,YAAY,IAAI,CAAC,OAAO;IAC3D,MAAM,mBAAmB,kBAAkB,KACzC,CAAC,QAAQ,IAAI,OAAO,GAAG,GACxB;AACD,WAAO,oBAAoB;GAC5B,EAAC;AAGJ,OAAI,kBAAkB,SAAS,EAC7B,QAAO,EAAE,UAAU,CAAC,GAAG,MAAM,UAAU,GAAG,sBAAuB,EAAE;AAGrE,UAAO;IACL,QAAQ;IACR,UAAU,CAAC,GAAG,MAAM,UAAU,GAAG,sBAAuB;GACzD;EACF;CACF,EAAC;AACH"}

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

@@ -1,52 +0,0 @@
-const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
-const require_utils = require('./utils.cjs');
-const require_summarization = require('./summarization.cjs');
-const require_hitl = require('./hitl.cjs');
-const require_promptCaching = require('./promptCaching.cjs');
-const require_dynamicSystemPrompt = require('./dynamicSystemPrompt.cjs');
-const require_llmToolSelector = require('./llmToolSelector.cjs');
-const require_piiRedaction = require('./piiRedaction.cjs');
-const require_contextEditing = require('./contextEditing.cjs');
-const require_toolCallLimit = require('./toolCallLimit.cjs');
-const require_callLimit = require('./callLimit.cjs');
-const require_modelFallback = require('./modelFallback.cjs');
-
-//#region src/agents/middlewareAgent/middleware/index.ts
-var middleware_exports = {};
-require_rolldown_runtime.__export(middleware_exports, {
-	ClearToolUsesEdit: () => require_contextEditing.ClearToolUsesEdit,
-	ToolCallLimitExceededError: () => require_toolCallLimit.ToolCallLimitExceededError,
-	anthropicPromptCachingMiddleware: () => require_promptCaching.anthropicPromptCachingMiddleware,
-	contextEditingMiddleware: () => require_contextEditing.contextEditingMiddleware,
-	countTokensApproximately: () => require_utils.countTokensApproximately,
-	dynamicSystemPromptMiddleware: () => require_dynamicSystemPrompt.dynamicSystemPromptMiddleware,
-	humanInTheLoopMiddleware: () => require_hitl.humanInTheLoopMiddleware,
-	llmToolSelectorMiddleware: () => require_llmToolSelector.llmToolSelectorMiddleware,
-	modelCallLimitMiddleware: () => require_callLimit.modelCallLimitMiddleware,
-	modelFallbackMiddleware: () => require_modelFallback.modelFallbackMiddleware,
-	piiRedactionMiddleware: () => require_piiRedaction.piiRedactionMiddleware,
-	summarizationMiddleware: () => require_summarization.summarizationMiddleware,
-	toolCallLimitMiddleware: () => require_toolCallLimit.toolCallLimitMiddleware
-});
-
-//#endregion
-exports.ClearToolUsesEdit = require_contextEditing.ClearToolUsesEdit;
-exports.ToolCallLimitExceededError = require_toolCallLimit.ToolCallLimitExceededError;
-exports.anthropicPromptCachingMiddleware = require_promptCaching.anthropicPromptCachingMiddleware;
-exports.contextEditingMiddleware = require_contextEditing.contextEditingMiddleware;
-exports.countTokensApproximately = require_utils.countTokensApproximately;
-exports.dynamicSystemPromptMiddleware = require_dynamicSystemPrompt.dynamicSystemPromptMiddleware;
-exports.humanInTheLoopMiddleware = require_hitl.humanInTheLoopMiddleware;
-exports.llmToolSelectorMiddleware = require_llmToolSelector.llmToolSelectorMiddleware;
-Object.defineProperty(exports, 'middleware_exports', {
-  enumerable: true,
-  get: function () {
-    return middleware_exports;
-  }
-});
-exports.modelCallLimitMiddleware = require_callLimit.modelCallLimitMiddleware;
-exports.modelFallbackMiddleware = require_modelFallback.modelFallbackMiddleware;
-exports.piiRedactionMiddleware = require_piiRedaction.piiRedactionMiddleware;
-exports.summarizationMiddleware = require_summarization.summarizationMiddleware;
-exports.toolCallLimitMiddleware = require_toolCallLimit.toolCallLimitMiddleware;
-//# sourceMappingURL=index.cjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","names":[],"sources":["../../../../src/agents/middlewareAgent/middleware/index.ts"],"sourcesContent":["export {\n  summarizationMiddleware,\n  type SummarizationMiddlewareConfig,\n} from \"./summarization.js\";\nexport {\n  humanInTheLoopMiddleware,\n  type HumanInTheLoopRequest,\n  type HumanInTheLoopMiddlewareHumanResponse,\n  type HumanInTheLoopMiddlewareConfig,\n  type ActionRequest,\n} from \"./hitl.js\";\nexport {\n  anthropicPromptCachingMiddleware,\n  type PromptCachingMiddlewareConfig,\n} from \"./promptCaching.js\";\nexport {\n  dynamicSystemPromptMiddleware,\n  type DynamicSystemPromptMiddlewareConfig,\n} from \"./dynamicSystemPrompt.js\";\nexport {\n  llmToolSelectorMiddleware,\n  type LLMToolSelectorConfig,\n} from \"./llmToolSelector.js\";\nexport {\n  piiRedactionMiddleware,\n  type PIIRedactionMiddlewareConfig,\n} from \"./piiRedaction.js\";\nexport {\n  contextEditingMiddleware,\n  ClearToolUsesEdit,\n  type ContextEditingMiddlewareConfig,\n  type ContextEdit,\n  type ClearToolUsesEditConfig,\n  type TokenCounter,\n} from \"./contextEditing.js\";\nexport {\n  toolCallLimitMiddleware,\n  ToolCallLimitExceededError,\n  type ToolCallLimitConfig,\n} from \"./toolCallLimit.js\";\nexport {\n  modelCallLimitMiddleware,\n  type ModelCallLimitMiddlewareConfig,\n} from \"./callLimit.js\";\nexport { modelFallbackMiddleware } from \"./modelFallback.js\";\nexport { type AgentMiddleware } from \"../types.js\";\nexport { countTokensApproximately } from \"./utils.js\";\n"],"mappings":""}

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

@@ -1,13 +0,0 @@
-import { SummarizationMiddlewareConfig, summarizationMiddleware } from "./summarization.cjs";
-import { AgentMiddleware } from "../types.cjs";
-import { ActionRequest, HumanInTheLoopMiddlewareConfig, HumanInTheLoopMiddlewareHumanResponse, HumanInTheLoopRequest, humanInTheLoopMiddleware } from "./hitl.cjs";
-import { PromptCachingMiddlewareConfig, anthropicPromptCachingMiddleware } from "./promptCaching.cjs";
-import { DynamicSystemPromptMiddlewareConfig, dynamicSystemPromptMiddleware } from "./dynamicSystemPrompt.cjs";
-import { LLMToolSelectorConfig, llmToolSelectorMiddleware } from "./llmToolSelector.cjs";
-import { PIIRedactionMiddlewareConfig, piiRedactionMiddleware } from "./piiRedaction.cjs";
-import { ClearToolUsesEdit, ClearToolUsesEditConfig, ContextEdit, ContextEditingMiddlewareConfig, TokenCounter, contextEditingMiddleware } from "./contextEditing.cjs";
-import { ToolCallLimitConfig, ToolCallLimitExceededError, toolCallLimitMiddleware } from "./toolCallLimit.cjs";
-import { ModelCallLimitMiddlewareConfig, modelCallLimitMiddleware } from "./callLimit.cjs";
-import { modelFallbackMiddleware } from "./modelFallback.cjs";
-import { countTokensApproximately } from "./utils.cjs";
-export { type ActionRequest, type AgentMiddleware, ClearToolUsesEdit, type ClearToolUsesEditConfig, type ContextEdit, type ContextEditingMiddlewareConfig, type DynamicSystemPromptMiddlewareConfig, type HumanInTheLoopMiddlewareConfig, type HumanInTheLoopMiddlewareHumanResponse, type HumanInTheLoopRequest, type LLMToolSelectorConfig, type ModelCallLimitMiddlewareConfig, type PIIRedactionMiddlewareConfig, type PromptCachingMiddlewareConfig, type SummarizationMiddlewareConfig, type TokenCounter, type ToolCallLimitConfig, ToolCallLimitExceededError, anthropicPromptCachingMiddleware, contextEditingMiddleware, countTokensApproximately, dynamicSystemPromptMiddleware, humanInTheLoopMiddleware, llmToolSelectorMiddleware, modelCallLimitMiddleware, modelFallbackMiddleware, piiRedactionMiddleware, summarizationMiddleware, toolCallLimitMiddleware };

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

@@ -1,13 +0,0 @@
-import { SummarizationMiddlewareConfig, summarizationMiddleware } from "./summarization.js";
-import { AgentMiddleware } from "../types.js";
-import { ActionRequest, HumanInTheLoopMiddlewareConfig, HumanInTheLoopMiddlewareHumanResponse, HumanInTheLoopRequest, humanInTheLoopMiddleware } from "./hitl.js";
-import { PromptCachingMiddlewareConfig, anthropicPromptCachingMiddleware } from "./promptCaching.js";
-import { DynamicSystemPromptMiddlewareConfig, dynamicSystemPromptMiddleware } from "./dynamicSystemPrompt.js";
-import { LLMToolSelectorConfig, llmToolSelectorMiddleware } from "./llmToolSelector.js";
-import { PIIRedactionMiddlewareConfig, piiRedactionMiddleware } from "./piiRedaction.js";
-import { ClearToolUsesEdit, ClearToolUsesEditConfig, ContextEdit, ContextEditingMiddlewareConfig, TokenCounter, contextEditingMiddleware } from "./contextEditing.js";
-import { ToolCallLimitConfig, ToolCallLimitExceededError, toolCallLimitMiddleware } from "./toolCallLimit.js";
-import { ModelCallLimitMiddlewareConfig, modelCallLimitMiddleware } from "./callLimit.js";
-import { modelFallbackMiddleware } from "./modelFallback.js";
-import { countTokensApproximately } from "./utils.js";
-export { type ActionRequest, type AgentMiddleware, ClearToolUsesEdit, type ClearToolUsesEditConfig, type ContextEdit, type ContextEditingMiddlewareConfig, type DynamicSystemPromptMiddlewareConfig, type HumanInTheLoopMiddlewareConfig, type HumanInTheLoopMiddlewareHumanResponse, type HumanInTheLoopRequest, type LLMToolSelectorConfig, type ModelCallLimitMiddlewareConfig, type PIIRedactionMiddlewareConfig, type PromptCachingMiddlewareConfig, type SummarizationMiddlewareConfig, type TokenCounter, type ToolCallLimitConfig, ToolCallLimitExceededError, anthropicPromptCachingMiddleware, contextEditingMiddleware, countTokensApproximately, dynamicSystemPromptMiddleware, humanInTheLoopMiddleware, llmToolSelectorMiddleware, modelCallLimitMiddleware, modelFallbackMiddleware, piiRedactionMiddleware, summarizationMiddleware, toolCallLimitMiddleware };

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

@@ -1,34 +0,0 @@
-import { __export } from "../../../_virtual/rolldown_runtime.js";
-import { countTokensApproximately } from "./utils.js";
-import { summarizationMiddleware } from "./summarization.js";
-import { humanInTheLoopMiddleware } from "./hitl.js";
-import { anthropicPromptCachingMiddleware } from "./promptCaching.js";
-import { dynamicSystemPromptMiddleware } from "./dynamicSystemPrompt.js";
-import { llmToolSelectorMiddleware } from "./llmToolSelector.js";
-import { piiRedactionMiddleware } from "./piiRedaction.js";
-import { ClearToolUsesEdit, contextEditingMiddleware } from "./contextEditing.js";
-import { ToolCallLimitExceededError, toolCallLimitMiddleware } from "./toolCallLimit.js";
-import { modelCallLimitMiddleware } from "./callLimit.js";
-import { modelFallbackMiddleware } from "./modelFallback.js";
-
-//#region src/agents/middlewareAgent/middleware/index.ts
-var middleware_exports = {};
-__export(middleware_exports, {
-	ClearToolUsesEdit: () => ClearToolUsesEdit,
-	ToolCallLimitExceededError: () => ToolCallLimitExceededError,
-	anthropicPromptCachingMiddleware: () => anthropicPromptCachingMiddleware,
-	contextEditingMiddleware: () => contextEditingMiddleware,
-	countTokensApproximately: () => countTokensApproximately,
-	dynamicSystemPromptMiddleware: () => dynamicSystemPromptMiddleware,
-	humanInTheLoopMiddleware: () => humanInTheLoopMiddleware,
-	llmToolSelectorMiddleware: () => llmToolSelectorMiddleware,
-	modelCallLimitMiddleware: () => modelCallLimitMiddleware,
-	modelFallbackMiddleware: () => modelFallbackMiddleware,
-	piiRedactionMiddleware: () => piiRedactionMiddleware,
-	summarizationMiddleware: () => summarizationMiddleware,
-	toolCallLimitMiddleware: () => toolCallLimitMiddleware
-});
-
-//#endregion
-export { ClearToolUsesEdit, ToolCallLimitExceededError, anthropicPromptCachingMiddleware, contextEditingMiddleware, countTokensApproximately, dynamicSystemPromptMiddleware, humanInTheLoopMiddleware, llmToolSelectorMiddleware, middleware_exports, modelCallLimitMiddleware, modelFallbackMiddleware, piiRedactionMiddleware, summarizationMiddleware, toolCallLimitMiddleware };
-//# sourceMappingURL=index.js.map

package/dist/agents/middlewareAgent/middleware/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../../src/agents/middlewareAgent/middleware/index.ts"],"sourcesContent":["export {\n  summarizationMiddleware,\n  type SummarizationMiddlewareConfig,\n} from \"./summarization.js\";\nexport {\n  humanInTheLoopMiddleware,\n  type HumanInTheLoopRequest,\n  type HumanInTheLoopMiddlewareHumanResponse,\n  type HumanInTheLoopMiddlewareConfig,\n  type ActionRequest,\n} from \"./hitl.js\";\nexport {\n  anthropicPromptCachingMiddleware,\n  type PromptCachingMiddlewareConfig,\n} from \"./promptCaching.js\";\nexport {\n  dynamicSystemPromptMiddleware,\n  type DynamicSystemPromptMiddlewareConfig,\n} from \"./dynamicSystemPrompt.js\";\nexport {\n  llmToolSelectorMiddleware,\n  type LLMToolSelectorConfig,\n} from \"./llmToolSelector.js\";\nexport {\n  piiRedactionMiddleware,\n  type PIIRedactionMiddlewareConfig,\n} from \"./piiRedaction.js\";\nexport {\n  contextEditingMiddleware,\n  ClearToolUsesEdit,\n  type ContextEditingMiddlewareConfig,\n  type ContextEdit,\n  type ClearToolUsesEditConfig,\n  type TokenCounter,\n} from \"./contextEditing.js\";\nexport {\n  toolCallLimitMiddleware,\n  ToolCallLimitExceededError,\n  type ToolCallLimitConfig,\n} from \"./toolCallLimit.js\";\nexport {\n  modelCallLimitMiddleware,\n  type ModelCallLimitMiddlewareConfig,\n} from \"./callLimit.js\";\nexport { modelFallbackMiddleware } from \"./modelFallback.js\";\nexport { type AgentMiddleware } from \"../types.js\";\nexport { countTokensApproximately } from \"./utils.js\";\n"],"mappings":""}

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

@@ -1 +0,0 @@
-{"version":3,"file":"llmToolSelector.cjs","names":["tools: StructuredToolInterface[]","z","BaseLanguageModel","options: LLMToolSelectorConfig","createMiddleware","request: ModelRequest","runtime: Runtime<LLMToolSelectorConfig>","lastUserMessage: HumanMessage | undefined","HumanMessage","initChatModel","response: { tools: string[] }","availableTools: StructuredToolInterface[]","validToolNames: string[]","selectedToolNames: string[]","invalidToolSelections: string[]"],"sources":["../../../../src/agents/middlewareAgent/middleware/llmToolSelector.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { BaseLanguageModel } from \"@langchain/core/language_models/base\";\nimport type { InferInteropZodInput } from \"@langchain/core/utils/types\";\nimport { HumanMessage } from \"@langchain/core/messages\";\nimport type { StructuredToolInterface } from \"@langchain/core/tools\";\n\nimport { createMiddleware } from \"../middleware.js\";\nimport { initChatModel } from \"../../../chat_models/universal.js\";\nimport type { ModelRequest, Runtime } from \"../types.js\";\n\nconst DEFAULT_SYSTEM_PROMPT =\n  \"Your goal is to select the most relevant tools for answering the user's query.\";\n\n/**\n * Prepared inputs for tool selection.\n */\ninterface SelectionRequest {\n  availableTools: StructuredToolInterface[];\n  systemMessage: string;\n  lastUserMessage: HumanMessage;\n  model: BaseLanguageModel;\n  validToolNames: string[];\n}\n\n/**\n * Create a structured output schema for tool selection.\n *\n * @param tools - Available tools to include in the schema.\n * @returns Zod schema where each tool name is a literal with its description.\n */\nfunction createToolSelectionResponse(tools: StructuredToolInterface[]) {\n  if (!tools || tools.length === 0) {\n    throw new Error(\"Invalid usage: tools must be non-empty\");\n  }\n\n  // Create a union of literals for each tool name\n  const toolLiterals = tools.map((tool) => z.literal(tool.name));\n  const toolEnum = z.union(\n    toolLiterals as [\n      z.ZodLiteral<string>,\n      z.ZodLiteral<string>,\n      ...z.ZodLiteral<string>[]\n    ]\n  );\n\n  return z.object({\n    tools: z\n      .array(toolEnum)\n      .describe(\"Tools to use. Place the most relevant tools first.\"),\n  });\n}\n\n/**\n * Options for configuring the LLM Tool Selector middleware.\n */\nexport const LLMToolSelectorOptionsSchema = z.object({\n  /**\n   * The language model to use for tool selection (default: the provided model from the agent options).\n   */\n  model: z.string().or(z.instanceof(BaseLanguageModel)).optional(),\n  /**\n   * System prompt for the tool selection model.\n   */\n  systemPrompt: z.string().optional(),\n  /**\n   * Maximum number of tools to select. If the model selects more,\n   * only the first maxTools will be used. No limit if not specified.\n   */\n  maxTools: z.number().optional(),\n  /**\n   * Tool names to always include regardless of selection.\n   * These do not count against the maxTools limit.\n   */\n  alwaysInclude: z.array(z.string()).optional(),\n});\nexport type LLMToolSelectorConfig = InferInteropZodInput<\n  typeof LLMToolSelectorOptionsSchema\n>;\n\n/**\n * Middleware for selecting tools using an LLM-based strategy.\n *\n * When an agent has many tools available, this middleware filters them down\n * to only the most relevant ones for the user's query. This reduces token usage\n * and helps the main model focus on the right tools.\n *\n * @param options - Configuration options for the middleware\n * @param options.model - The language model to use for tool selection (default: the provided model from the agent options).\n * @param options.systemPrompt - Instructions for the selection model.\n * @param options.maxTools - Maximum number of tools to select. If the model selects more,\n *   only the first maxTools will be used. No limit if not specified.\n * @param options.alwaysInclude - Tool names to always include regardless of selection.\n *   These do not count against the maxTools limit.\n *\n * @example\n * Limit to 3 tools:\n * ```ts\n * import { llmToolSelectorMiddleware } from \"langchain/agents/middleware\";\n *\n * const middleware = llmToolSelectorMiddleware({ maxTools: 3 });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [tool1, tool2, tool3, tool4, tool5],\n *   middleware: [middleware],\n * });\n * ```\n *\n * @example\n * Use a smaller model for selection:\n * ```ts\n * const middleware = llmToolSelectorMiddleware({\n *   model: \"openai:gpt-4o-mini\",\n *   maxTools: 2\n * });\n * ```\n */\nexport function llmToolSelectorMiddleware(\n  options: LLMToolSelectorConfig\n): ReturnType<typeof createMiddleware> {\n  return createMiddleware({\n    name: \"LLMToolSelector\",\n    contextSchema: LLMToolSelectorOptionsSchema,\n    async modifyModelRequest(request, _, runtime): Promise<ModelRequest> {\n      const selectionRequest = await prepareSelectionRequest(\n        request,\n        options,\n        runtime\n      );\n      if (!selectionRequest) {\n        return request;\n      }\n\n      // Create dynamic response model with union of literal tool names\n      const toolSelectionSchema = createToolSelectionResponse(\n        selectionRequest.availableTools\n      );\n      const structuredModel =\n        await selectionRequest.model.withStructuredOutput?.(\n          toolSelectionSchema\n        );\n\n      const response = await structuredModel?.invoke([\n        { role: \"system\", content: selectionRequest.systemMessage },\n        selectionRequest.lastUserMessage,\n      ]);\n\n      // Response should be an object with a tools array\n      if (!response || typeof response !== \"object\" || !(\"tools\" in response)) {\n        throw new Error(\n          `Expected object response with tools array, got ${typeof response}`\n        );\n      }\n\n      return processSelectionResponse(\n        response as { tools: string[] },\n        selectionRequest.availableTools,\n        selectionRequest.validToolNames,\n        request,\n        options\n      );\n    },\n  });\n}\n\n/**\n * Prepare inputs for tool selection.\n *\n * @param request - The model request to process.\n * @param options - Configuration options.\n * @param runtime - Runtime context.\n * @returns SelectionRequest with prepared inputs, or null if no selection is needed.\n */\nasync function prepareSelectionRequest(\n  request: ModelRequest,\n  options: LLMToolSelectorConfig,\n  runtime: Runtime<LLMToolSelectorConfig>\n): Promise<SelectionRequest | undefined> {\n  const model = runtime.context.model ?? options.model;\n  const maxTools = runtime.context.maxTools ?? options.maxTools;\n  const alwaysInclude =\n    runtime.context.alwaysInclude ?? options.alwaysInclude ?? [];\n  const systemPrompt =\n    runtime.context.systemPrompt ??\n    options.systemPrompt ??\n    DEFAULT_SYSTEM_PROMPT;\n\n  /**\n   * If no tools available, return null\n   */\n  if (!request.tools || request.tools.length === 0) {\n    return undefined;\n  }\n\n  /**\n   * Filter to only StructuredToolInterface instances (exclude provider-specific tool dicts)\n   */\n  const baseTools = request.tools.filter(\n    (tool): tool is StructuredToolInterface =>\n      typeof tool === \"object\" &&\n      \"name\" in tool &&\n      \"description\" in tool &&\n      typeof tool.name === \"string\"\n  );\n\n  /**\n   * Validate that alwaysInclude tools exist\n   */\n  if (alwaysInclude.length > 0) {\n    const availableToolNames = new Set(baseTools.map((tool) => tool.name));\n    const missingTools = alwaysInclude.filter(\n      (name) => !availableToolNames.has(name)\n    );\n    if (missingTools.length > 0) {\n      throw new Error(\n        `Tools in alwaysInclude not found in request: ${missingTools.join(\n          \", \"\n        )}. ` +\n          `Available tools: ${Array.from(availableToolNames).sort().join(\", \")}`\n      );\n    }\n  }\n\n  /**\n   * Separate tools that are always included from those available for selection\n   */\n  const availableTools = baseTools.filter(\n    (tool) => !alwaysInclude.includes(tool.name)\n  );\n\n  /**\n   * If no tools available for selection, return null\n   */\n  if (availableTools.length === 0) {\n    return undefined;\n  }\n\n  let systemMessage = systemPrompt;\n  /**\n   * If there's a maxTools limit, append instructions to the system prompt\n   */\n  if (maxTools !== undefined) {\n    systemMessage +=\n      `\\nIMPORTANT: List the tool names in order of relevance, ` +\n      `with the most relevant first. ` +\n      `If you exceed the maximum number of tools, ` +\n      `only the first ${maxTools} will be used.`;\n  }\n\n  /**\n   * Get the last user message from the conversation history\n   */\n  let lastUserMessage: HumanMessage | undefined;\n  for (const message of request.messages) {\n    if (HumanMessage.isInstance(message)) {\n      lastUserMessage = message;\n    }\n  }\n\n  if (!lastUserMessage) {\n    throw new Error(\"No user message found in request messages\");\n  }\n\n  const modelInstance = !model\n    ? (request.model as BaseLanguageModel)\n    : typeof model === \"string\"\n    ? await initChatModel(model)\n    : model;\n\n  const validToolNames = availableTools.map((tool) => tool.name);\n\n  return {\n    availableTools,\n    systemMessage,\n    lastUserMessage,\n    model: modelInstance,\n    validToolNames,\n  };\n}\n\n/**\n * Process the selection response and return filtered ModelRequest.\n *\n * @param response - The structured output response from the model.\n * @param availableTools - Tools available for selection.\n * @param validToolNames - Valid tool names that can be selected.\n * @param request - Original model request.\n * @param options - Configuration options.\n * @returns Modified ModelRequest with filtered tools.\n */\nfunction processSelectionResponse(\n  response: { tools: string[] },\n  availableTools: StructuredToolInterface[],\n  validToolNames: string[],\n  request: ModelRequest,\n  options: LLMToolSelectorConfig\n): ModelRequest {\n  const maxTools = options.maxTools;\n  const alwaysInclude = options.alwaysInclude ?? [];\n\n  const selectedToolNames: string[] = [];\n  const invalidToolSelections: string[] = [];\n\n  for (const toolName of response.tools) {\n    if (!validToolNames.includes(toolName)) {\n      invalidToolSelections.push(toolName);\n      continue;\n    }\n\n    /**\n     * Only add if not already selected and within maxTools limit\n     */\n    if (\n      !selectedToolNames.includes(toolName) &&\n      (maxTools === undefined || selectedToolNames.length < maxTools)\n    ) {\n      selectedToolNames.push(toolName);\n    }\n  }\n\n  if (invalidToolSelections.length > 0) {\n    throw new Error(\n      `Model selected invalid tools: ${invalidToolSelections.join(\", \")}`\n    );\n  }\n\n  /**\n   * Filter tools based on selection\n   */\n  const selectedTools = availableTools.filter((tool) =>\n    selectedToolNames.includes(tool.name)\n  );\n\n  /**\n   * Append always-included tools\n   */\n  const alwaysIncludedTools = (request.tools ?? []).filter(\n    (tool): tool is StructuredToolInterface =>\n      typeof tool === \"object\" &&\n      \"name\" in tool &&\n      typeof tool.name === \"string\" &&\n      alwaysInclude.includes(tool.name)\n  );\n  selectedTools.push(...alwaysIncludedTools);\n\n  /**\n   * Also preserve any provider-specific tool dicts from the original request\n   */\n  const providerTools = (request.tools ?? []).filter(\n    (tool) =>\n      !(\n        typeof tool === \"object\" &&\n        \"name\" in tool &&\n        \"description\" in tool &&\n        typeof tool.name === \"string\"\n      )\n  );\n\n  return {\n    ...request,\n    tools: [...selectedTools, ...providerTools],\n  };\n}\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"llmToolSelector.d.cts","names":["z","BaseLanguageModel","InferInteropZodInput","createMiddleware","LLMToolSelectorOptionsSchema","ZodString","_langchain_core_language_models_base7","BaseLanguageModelCallOptions","ZodTypeDef","ZodType","ZodUnion","ZodOptional","ZodNumber","ZodArray","ZodTypeAny","ZodObject","LLMToolSelectorConfig","llmToolSelectorMiddleware","ReturnType"],"sources":["../../../../src/agents/middlewareAgent/middleware/llmToolSelector.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { BaseLanguageModel } from \"@langchain/core/language_models/base\";\nimport type { InferInteropZodInput } from \"@langchain/core/utils/types\";\nimport { createMiddleware } from \"../middleware.js\";\n/**\n * Options for configuring the LLM Tool Selector middleware.\n */\nexport declare const LLMToolSelectorOptionsSchema: z.ZodObject<{\n    /**\n     * The language model to use for tool selection (default: the provided model from the agent options).\n     */\n    model: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodType<BaseLanguageModel<unknown, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>, z.ZodTypeDef, BaseLanguageModel<unknown, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>>]>>;\n    /**\n     * System prompt for the tool selection model.\n     */\n    systemPrompt: z.ZodOptional<z.ZodString>;\n    /**\n     * Maximum number of tools to select. If the model selects more,\n     * only the first maxTools will be used. No limit if not specified.\n     */\n    maxTools: z.ZodOptional<z.ZodNumber>;\n    /**\n     * Tool names to always include regardless of selection.\n     * These do not count against the maxTools limit.\n     */\n    alwaysInclude: z.ZodOptional<z.ZodArray<z.ZodString, \"many\">>;\n}, \"strip\", z.ZodTypeAny, {\n    model?: string | BaseLanguageModel<unknown, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions> | undefined;\n    systemPrompt?: string | undefined;\n    maxTools?: number | undefined;\n    alwaysInclude?: string[] | undefined;\n}, {\n    model?: string | BaseLanguageModel<unknown, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions> | undefined;\n    systemPrompt?: string | undefined;\n    maxTools?: number | undefined;\n    alwaysInclude?: string[] | undefined;\n}>;\nexport type LLMToolSelectorConfig = InferInteropZodInput<typeof LLMToolSelectorOptionsSchema>;\n/**\n * Middleware for selecting tools using an LLM-based strategy.\n *\n * When an agent has many tools available, this middleware filters them down\n * to only the most relevant ones for the user's query. This reduces token usage\n * and helps the main model focus on the right tools.\n *\n * @param options - Configuration options for the middleware\n * @param options.model - The language model to use for tool selection (default: the provided model from the agent options).\n * @param options.systemPrompt - Instructions for the selection model.\n * @param options.maxTools - Maximum number of tools to select. If the model selects more,\n *   only the first maxTools will be used. No limit if not specified.\n * @param options.alwaysInclude - Tool names to always include regardless of selection.\n *   These do not count against the maxTools limit.\n *\n * @example\n * Limit to 3 tools:\n * ```ts\n * import { llmToolSelectorMiddleware } from \"langchain/agents/middleware\";\n *\n * const middleware = llmToolSelectorMiddleware({ maxTools: 3 });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [tool1, tool2, tool3, tool4, tool5],\n *   middleware: [middleware],\n * });\n * ```\n *\n * @example\n * Use a smaller model for selection:\n * ```ts\n * const middleware = llmToolSelectorMiddleware({\n *   model: \"openai:gpt-4o-mini\",\n *   maxTools: 2\n * });\n * ```\n */\nexport declare function llmToolSelectorMiddleware(options: LLMToolSelectorConfig): ReturnType<typeof createMiddleware>;\n"],"mappings":";;;;;;;;;;AAOqBI,cAAAA,4BA6BnB,EA7BiDJ,CAAAA,CAAEe,SA6BnD,CAAA;EAAA;;;EAzBgK,KAAtGd,EAAjDD,CAAAA,CAAEW,WAA+CV,CAAnCD,CAAAA,CAAEU,QAAiCT,CAAAA,CAAvBD,CAAAA,CAAEK,SAAqBJ,EAAVD,CAAAA,CAAES,OAAQR,CAAAA,iBAAAA,CAAAA,OAAAA,EAAZK,qCAAAA,CAAsFC,4BAAAA,CAA1EN,EAAyGD,CAAAA,CAAEQ,UAA3GP,EAAuHA,iBAAvHA,CAAAA,OAAAA,EAAqHK,qCAAAA,CAA4EC,4BAAAA,CAAjMN,CAAAA,CAAAA,CAAAA,CAAAA;EAAiB;;;EAAuH,YAAhJQ,EAIlCT,CAAAA,CAAEW,WAJgCF,CAIpBT,CAAAA,CAAEK,SAJkBI,CAAAA;EAAO;;;;EAI5B,QAKDG,EAAhBZ,CAAAA,CAAEW,WAAcC,CAAFZ,CAAAA,CAAEY,SAAAA,CAAAA;EAAS;;;;EAKP,aAClBE,EADKd,CAAAA,CAAEW,WACPG,CADmBd,CAAAA,CAAEa,QACrBC,CAD8Bd,CAAAA,CAAEK,SAChCS,EAAAA,MAAAA,CAAAA,CAAAA;CAAU,EAAA,OAAAR,EAAZN,CAAAA,CAAEc,UAAUR,EAAAA;EACmG,KAAtGL,CAAAA,EAAAA,MAAAA,GAAAA,iBAAAA,CAAAA,OAAAA,EADGK,qCAAAA,CACuEC,4BAAAA,CAA1EN,GAAAA,SAAAA;EAAiB,YAAAK,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAKqF,QAAtGL,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAiB,aAzBec,CAAAA,EAAAA,MAAAA,EAAAA,GAAAA,SAAAA;AAAS,CAAA,EAAA;EA8BlDC,KAAAA,CAAAA,EAAAA,MAAAA,GALSf,iBAKY,CAAA,OAAA,EAVKK,qCAAAA,CAKyDC,4BAAAA,CAK9D,GAAA,SAAA;EAAA,YAAA,CAAA,EAAA,MAAA,GAAA,SAAA;EAAA,QAA+BH,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAA4B,aAAxDF,CAAAA,EAAAA,MAAAA,EAAAA,GAAAA,SAAAA;AAAoB,CAAA,CAAA;AAuChCe,KAvCZD,qBAAAA,GAAwBd,oBAuCa,CAAA,OAvCeE,4BAuCf,CAAA;;;;;AAA4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAArEa,yBAAAA,UAAmCD,wBAAwBE,kBAAkBf"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"llmToolSelector.d.ts","names":["z","BaseLanguageModel","InferInteropZodInput","createMiddleware","LLMToolSelectorOptionsSchema","ZodString","_langchain_core_language_models_base7","BaseLanguageModelCallOptions","ZodTypeDef","ZodType","ZodUnion","ZodOptional","ZodNumber","ZodArray","ZodTypeAny","ZodObject","LLMToolSelectorConfig","llmToolSelectorMiddleware","ReturnType"],"sources":["../../../../src/agents/middlewareAgent/middleware/llmToolSelector.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { BaseLanguageModel } from \"@langchain/core/language_models/base\";\nimport type { InferInteropZodInput } from \"@langchain/core/utils/types\";\nimport { createMiddleware } from \"../middleware.js\";\n/**\n * Options for configuring the LLM Tool Selector middleware.\n */\nexport declare const LLMToolSelectorOptionsSchema: z.ZodObject<{\n    /**\n     * The language model to use for tool selection (default: the provided model from the agent options).\n     */\n    model: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodType<BaseLanguageModel<unknown, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>, z.ZodTypeDef, BaseLanguageModel<unknown, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>>]>>;\n    /**\n     * System prompt for the tool selection model.\n     */\n    systemPrompt: z.ZodOptional<z.ZodString>;\n    /**\n     * Maximum number of tools to select. If the model selects more,\n     * only the first maxTools will be used. No limit if not specified.\n     */\n    maxTools: z.ZodOptional<z.ZodNumber>;\n    /**\n     * Tool names to always include regardless of selection.\n     * These do not count against the maxTools limit.\n     */\n    alwaysInclude: z.ZodOptional<z.ZodArray<z.ZodString, \"many\">>;\n}, \"strip\", z.ZodTypeAny, {\n    model?: string | BaseLanguageModel<unknown, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions> | undefined;\n    systemPrompt?: string | undefined;\n    maxTools?: number | undefined;\n    alwaysInclude?: string[] | undefined;\n}, {\n    model?: string | BaseLanguageModel<unknown, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions> | undefined;\n    systemPrompt?: string | undefined;\n    maxTools?: number | undefined;\n    alwaysInclude?: string[] | undefined;\n}>;\nexport type LLMToolSelectorConfig = InferInteropZodInput<typeof LLMToolSelectorOptionsSchema>;\n/**\n * Middleware for selecting tools using an LLM-based strategy.\n *\n * When an agent has many tools available, this middleware filters them down\n * to only the most relevant ones for the user's query. This reduces token usage\n * and helps the main model focus on the right tools.\n *\n * @param options - Configuration options for the middleware\n * @param options.model - The language model to use for tool selection (default: the provided model from the agent options).\n * @param options.systemPrompt - Instructions for the selection model.\n * @param options.maxTools - Maximum number of tools to select. If the model selects more,\n *   only the first maxTools will be used. No limit if not specified.\n * @param options.alwaysInclude - Tool names to always include regardless of selection.\n *   These do not count against the maxTools limit.\n *\n * @example\n * Limit to 3 tools:\n * ```ts\n * import { llmToolSelectorMiddleware } from \"langchain/agents/middleware\";\n *\n * const middleware = llmToolSelectorMiddleware({ maxTools: 3 });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [tool1, tool2, tool3, tool4, tool5],\n *   middleware: [middleware],\n * });\n * ```\n *\n * @example\n * Use a smaller model for selection:\n * ```ts\n * const middleware = llmToolSelectorMiddleware({\n *   model: \"openai:gpt-4o-mini\",\n *   maxTools: 2\n * });\n * ```\n */\nexport declare function llmToolSelectorMiddleware(options: LLMToolSelectorConfig): ReturnType<typeof createMiddleware>;\n"],"mappings":";;;;;;;;;;AAOqBI,cAAAA,4BA6BnB,EA7BiDJ,CAAAA,CAAEe,SA6BnD,CAAA;EAAA;;;EAzBgK,KAAtGd,EAAjDD,CAAAA,CAAEW,WAA+CV,CAAnCD,CAAAA,CAAEU,QAAiCT,CAAAA,CAAvBD,CAAAA,CAAEK,SAAqBJ,EAAVD,CAAAA,CAAES,OAAQR,CAAAA,iBAAAA,CAAAA,OAAAA,EAAZK,qCAAAA,CAAsFC,4BAAAA,CAA1EN,EAAyGD,CAAAA,CAAEQ,UAA3GP,EAAuHA,iBAAvHA,CAAAA,OAAAA,EAAqHK,qCAAAA,CAA4EC,4BAAAA,CAAjMN,CAAAA,CAAAA,CAAAA,CAAAA;EAAiB;;;EAAuH,YAAhJQ,EAIlCT,CAAAA,CAAEW,WAJgCF,CAIpBT,CAAAA,CAAEK,SAJkBI,CAAAA;EAAO;;;;EAI5B,QAKDG,EAAhBZ,CAAAA,CAAEW,WAAcC,CAAFZ,CAAAA,CAAEY,SAAAA,CAAAA;EAAS;;;;EAKP,aAClBE,EADKd,CAAAA,CAAEW,WACPG,CADmBd,CAAAA,CAAEa,QACrBC,CAD8Bd,CAAAA,CAAEK,SAChCS,EAAAA,MAAAA,CAAAA,CAAAA;CAAU,EAAA,OAAAR,EAAZN,CAAAA,CAAEc,UAAUR,EAAAA;EACmG,KAAtGL,CAAAA,EAAAA,MAAAA,GAAAA,iBAAAA,CAAAA,OAAAA,EADGK,qCAAAA,CACuEC,4BAAAA,CAA1EN,GAAAA,SAAAA;EAAiB,YAAAK,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAKqF,QAAtGL,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAiB,aAzBec,CAAAA,EAAAA,MAAAA,EAAAA,GAAAA,SAAAA;AAAS,CAAA,EAAA;EA8BlDC,KAAAA,CAAAA,EAAAA,MAAAA,GALSf,iBAKY,CAAA,OAAA,EAVKK,qCAAAA,CAKyDC,4BAAAA,CAK9D,GAAA,SAAA;EAAA,YAAA,CAAA,EAAA,MAAA,GAAA,SAAA;EAAA,QAA+BH,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAA4B,aAAxDF,CAAAA,EAAAA,MAAAA,EAAAA,GAAAA,SAAAA;AAAoB,CAAA,CAAA;AAuChCe,KAvCZD,qBAAAA,GAAwBd,oBAuCa,CAAA,OAvCeE,4BAuCf,CAAA;;;;;AAA4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAArEa,yBAAAA,UAAmCD,wBAAwBE,kBAAkBf"}