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

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

@@ -1,4 +1,13 @@
-import { countTokensApproximately, summarizationMiddleware } from "./summarization.cjs";
-import { humanInTheLoopMiddleware } from "./hitl.cjs";
-import { anthropicPromptCachingMiddleware } from "./promptCaching.cjs";
-export { anthropicPromptCachingMiddleware, countTokensApproximately, humanInTheLoopMiddleware, summarizationMiddleware };
+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,4 +1,13 @@
-import { countTokensApproximately, summarizationMiddleware } from "./summarization.js";
-import { humanInTheLoopMiddleware } from "./hitl.js";
-import { anthropicPromptCachingMiddleware } from "./promptCaching.js";
-export { anthropicPromptCachingMiddleware, countTokensApproximately, humanInTheLoopMiddleware, summarizationMiddleware };
+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,17 +1,34 @@
 import { __export } from "../../../_virtual/rolldown_runtime.js";
-import { countTokensApproximately, summarizationMiddleware } from "./summarization.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,
-	summarizationMiddleware: () => summarizationMiddleware
+	llmToolSelectorMiddleware: () => llmToolSelectorMiddleware,
+	modelCallLimitMiddleware: () => modelCallLimitMiddleware,
+	modelFallbackMiddleware: () => modelFallbackMiddleware,
+	piiRedactionMiddleware: () => piiRedactionMiddleware,
+	summarizationMiddleware: () => summarizationMiddleware,
+	toolCallLimitMiddleware: () => toolCallLimitMiddleware
 });
 
 //#endregion
-export { anthropicPromptCachingMiddleware, countTokensApproximately, humanInTheLoopMiddleware, middleware_exports, summarizationMiddleware };
+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 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../../src/agents/middlewareAgent/middleware/index.ts"],"sourcesContent":["export {\n  summarizationMiddleware,\n  countTokensApproximately,\n} from \"./summarization.js\";\nexport { humanInTheLoopMiddleware } from \"./hitl.js\";\nexport { anthropicPromptCachingMiddleware } from \"./promptCaching.js\";\n"],"mappings":""}
+{"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

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

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

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

@@ -0,0 +1,83 @@
+import { createMiddleware } from "../middleware.cjs";
+import * as _langchain_core_language_models_base7 from "@langchain/core/language_models/base";
+import { BaseLanguageModel } from "@langchain/core/language_models/base";
+import { z } from "zod/v3";
+import { InferInteropZodInput } from "@langchain/core/utils/types";
+
+//#region src/agents/middlewareAgent/middleware/llmToolSelector.d.ts
+/**
+ * Options for configuring the LLM Tool Selector middleware.
+ */
+declare const LLMToolSelectorOptionsSchema: z.ZodObject<{
+  /**
+   * The language model to use for tool selection (default: the provided model from the agent options).
+   */
+  model: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodType<BaseLanguageModel<unknown, _langchain_core_language_models_base7.BaseLanguageModelCallOptions>, z.ZodTypeDef, BaseLanguageModel<unknown, _langchain_core_language_models_base7.BaseLanguageModelCallOptions>>]>>;
+  /**
+   * System prompt for the tool selection model.
+   */
+  systemPrompt: z.ZodOptional<z.ZodString>;
+  /**
+   * Maximum number of tools to select. If the model selects more,
+   * only the first maxTools will be used. No limit if not specified.
+   */
+  maxTools: z.ZodOptional<z.ZodNumber>;
+  /**
+   * Tool names to always include regardless of selection.
+   * These do not count against the maxTools limit.
+   */
+  alwaysInclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+  model?: string | BaseLanguageModel<unknown, _langchain_core_language_models_base7.BaseLanguageModelCallOptions> | undefined;
+  systemPrompt?: string | undefined;
+  maxTools?: number | undefined;
+  alwaysInclude?: string[] | undefined;
+}, {
+  model?: string | BaseLanguageModel<unknown, _langchain_core_language_models_base7.BaseLanguageModelCallOptions> | undefined;
+  systemPrompt?: string | undefined;
+  maxTools?: number | undefined;
+  alwaysInclude?: string[] | undefined;
+}>;
+type LLMToolSelectorConfig = InferInteropZodInput<typeof LLMToolSelectorOptionsSchema>;
+/**
+ * Middleware for selecting tools using an LLM-based strategy.
+ *
+ * When an agent has many tools available, this middleware filters them down
+ * to only the most relevant ones for the user's query. This reduces token usage
+ * and helps the main model focus on the right tools.
+ *
+ * @param options - Configuration options for the middleware
+ * @param options.model - The language model to use for tool selection (default: the provided model from the agent options).
+ * @param options.systemPrompt - Instructions for the selection model.
+ * @param options.maxTools - Maximum number of tools to select. If the model selects more,
+ *   only the first maxTools will be used. No limit if not specified.
+ * @param options.alwaysInclude - Tool names to always include regardless of selection.
+ *   These do not count against the maxTools limit.
+ *
+ * @example
+ * Limit to 3 tools:
+ * ```ts
+ * import { llmToolSelectorMiddleware } from "langchain/agents/middleware";
+ *
+ * const middleware = llmToolSelectorMiddleware({ maxTools: 3 });
+ *
+ * const agent = createAgent({
+ *   model: "openai:gpt-4o",
+ *   tools: [tool1, tool2, tool3, tool4, tool5],
+ *   middleware: [middleware],
+ * });
+ * ```
+ *
+ * @example
+ * Use a smaller model for selection:
+ * ```ts
+ * const middleware = llmToolSelectorMiddleware({
+ *   model: "openai:gpt-4o-mini",
+ *   maxTools: 2
+ * });
+ * ```
+ */
+declare function llmToolSelectorMiddleware(options: LLMToolSelectorConfig): ReturnType<typeof createMiddleware>;
+//#endregion
+export { LLMToolSelectorConfig, llmToolSelectorMiddleware };
+//# sourceMappingURL=llmToolSelector.d.cts.map

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

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

@@ -0,0 +1,83 @@
+import { createMiddleware } from "../middleware.js";
+import { InferInteropZodInput } from "@langchain/core/utils/types";
+import { z } from "zod/v3";
+import * as _langchain_core_language_models_base7 from "@langchain/core/language_models/base";
+import { BaseLanguageModel } from "@langchain/core/language_models/base";
+
+//#region src/agents/middlewareAgent/middleware/llmToolSelector.d.ts
+/**
+ * Options for configuring the LLM Tool Selector middleware.
+ */
+declare const LLMToolSelectorOptionsSchema: z.ZodObject<{
+  /**
+   * The language model to use for tool selection (default: the provided model from the agent options).
+   */
+  model: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodType<BaseLanguageModel<unknown, _langchain_core_language_models_base7.BaseLanguageModelCallOptions>, z.ZodTypeDef, BaseLanguageModel<unknown, _langchain_core_language_models_base7.BaseLanguageModelCallOptions>>]>>;
+  /**
+   * System prompt for the tool selection model.
+   */
+  systemPrompt: z.ZodOptional<z.ZodString>;
+  /**
+   * Maximum number of tools to select. If the model selects more,
+   * only the first maxTools will be used. No limit if not specified.
+   */
+  maxTools: z.ZodOptional<z.ZodNumber>;
+  /**
+   * Tool names to always include regardless of selection.
+   * These do not count against the maxTools limit.
+   */
+  alwaysInclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+  model?: string | BaseLanguageModel<unknown, _langchain_core_language_models_base7.BaseLanguageModelCallOptions> | undefined;
+  systemPrompt?: string | undefined;
+  maxTools?: number | undefined;
+  alwaysInclude?: string[] | undefined;
+}, {
+  model?: string | BaseLanguageModel<unknown, _langchain_core_language_models_base7.BaseLanguageModelCallOptions> | undefined;
+  systemPrompt?: string | undefined;
+  maxTools?: number | undefined;
+  alwaysInclude?: string[] | undefined;
+}>;
+type LLMToolSelectorConfig = InferInteropZodInput<typeof LLMToolSelectorOptionsSchema>;
+/**
+ * Middleware for selecting tools using an LLM-based strategy.
+ *
+ * When an agent has many tools available, this middleware filters them down
+ * to only the most relevant ones for the user's query. This reduces token usage
+ * and helps the main model focus on the right tools.
+ *
+ * @param options - Configuration options for the middleware
+ * @param options.model - The language model to use for tool selection (default: the provided model from the agent options).
+ * @param options.systemPrompt - Instructions for the selection model.
+ * @param options.maxTools - Maximum number of tools to select. If the model selects more,
+ *   only the first maxTools will be used. No limit if not specified.
+ * @param options.alwaysInclude - Tool names to always include regardless of selection.
+ *   These do not count against the maxTools limit.
+ *
+ * @example
+ * Limit to 3 tools:
+ * ```ts
+ * import { llmToolSelectorMiddleware } from "langchain/agents/middleware";
+ *
+ * const middleware = llmToolSelectorMiddleware({ maxTools: 3 });
+ *
+ * const agent = createAgent({
+ *   model: "openai:gpt-4o",
+ *   tools: [tool1, tool2, tool3, tool4, tool5],
+ *   middleware: [middleware],
+ * });
+ * ```
+ *
+ * @example
+ * Use a smaller model for selection:
+ * ```ts
+ * const middleware = llmToolSelectorMiddleware({
+ *   model: "openai:gpt-4o-mini",
+ *   maxTools: 2
+ * });
+ * ```
+ */
+declare function llmToolSelectorMiddleware(options: LLMToolSelectorConfig): ReturnType<typeof createMiddleware>;
+//#endregion
+export { LLMToolSelectorConfig, llmToolSelectorMiddleware };
+//# sourceMappingURL=llmToolSelector.d.ts.map

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

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