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

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

@@ -0,0 +1,113 @@
+import { AgentMiddleware } from "../types.js";
+import * as _langchain_core_messages0 from "@langchain/core/messages";
+import * as _langchain_core_language_models_chat_models0 from "@langchain/core/language_models/chat_models";
+import { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import { InferInteropZodInput } from "@langchain/core/utils/types";
+import { z } from "zod/v3";
+
+//#region src/agents/middlewareAgent/middleware/bigTool.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<BaseChatModel<_langchain_core_language_models_chat_models0.BaseChatModelCallOptions, _langchain_core_messages0.BaseMessageChunk<_langchain_core_messages0.MessageStructure, _langchain_core_messages0.MessageType>>, z.ZodTypeDef, BaseChatModel<_langchain_core_language_models_chat_models0.BaseChatModelCallOptions, _langchain_core_messages0.BaseMessageChunk<_langchain_core_messages0.MessageStructure, _langchain_core_messages0.MessageType>>>]>>;
+  /**
+   * System prompt for the tool selection model.
+   */
+  systemPrompt: z.ZodDefault<z.ZodString>;
+  /**
+   * Maximum number of tools to select.
+   */
+  maxTools: z.ZodOptional<z.ZodNumber>;
+  /**
+   * Whether to include the full conversation history in the tool selection prompt.
+   */
+  includeFullHistory: z.ZodDefault<z.ZodBoolean>;
+  /**
+   * Maximum number of retries if the model selects incorrect tools.
+   */
+  maxRetries: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+  model?: string | BaseChatModel<_langchain_core_language_models_chat_models0.BaseChatModelCallOptions, _langchain_core_messages0.BaseMessageChunk<_langchain_core_messages0.MessageStructure, _langchain_core_messages0.MessageType>> | undefined;
+  systemPrompt: string;
+  maxTools?: number | undefined;
+  includeFullHistory: boolean;
+  maxRetries: number;
+}, {
+  model?: string | BaseChatModel<_langchain_core_language_models_chat_models0.BaseChatModelCallOptions, _langchain_core_messages0.BaseMessageChunk<_langchain_core_messages0.MessageStructure, _langchain_core_messages0.MessageType>> | undefined;
+  systemPrompt?: string | undefined;
+  maxTools?: number | undefined;
+  includeFullHistory?: boolean | undefined;
+  maxRetries?: number | undefined;
+}>;
+type LLMToolSelectorConfig = InferInteropZodInput<typeof LLMToolSelectorOptionsSchema>;
+/**
+ * Middleware for selecting tools using an LLM-based strategy.
+ *
+ * This middleware analyzes the user's query and available tools to select
+ * the most relevant tools for the task, reducing the cognitive load on the
+ * main model and improving response quality.
+ *
+ * @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 - System prompt for the tool selection model.
+ * @param options.maxTools - Maximum number of tools to select.
+ * @param options.includeFullHistory - Whether to include the full conversation history in the tool selection prompt.
+ * @param options.maxRetries - Maximum number of retries if the model selects incorrect tools.
+ *
+ * @example
+ * ```ts
+ * import { llmToolSelectorMiddleware } from "langchain/agents/middleware";
+ *
+ * const middleware = llmToolSelectorMiddleware({
+ *   maxTools: 3,
+ *   systemPrompt: "Select the most relevant tools for the user's query."
+ * });
+ *
+ * const agent = createAgent({
+ *   model: "openai:gpt-4o",
+ *   tools: [tool1, tool2, tool3, tool4, tool5],
+ *   middleware: [middleware],
+ * });
+ * ```
+ */
+declare function llmToolSelectorMiddleware(options: LLMToolSelectorConfig): AgentMiddleware<undefined, 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<BaseChatModel<_langchain_core_language_models_chat_models0.BaseChatModelCallOptions, _langchain_core_messages0.BaseMessageChunk<_langchain_core_messages0.MessageStructure, _langchain_core_messages0.MessageType>>, z.ZodTypeDef, BaseChatModel<_langchain_core_language_models_chat_models0.BaseChatModelCallOptions, _langchain_core_messages0.BaseMessageChunk<_langchain_core_messages0.MessageStructure, _langchain_core_messages0.MessageType>>>]>>;
+  /**
+   * System prompt for the tool selection model.
+   */
+  systemPrompt: z.ZodDefault<z.ZodString>;
+  /**
+   * Maximum number of tools to select.
+   */
+  maxTools: z.ZodOptional<z.ZodNumber>;
+  /**
+   * Whether to include the full conversation history in the tool selection prompt.
+   */
+  includeFullHistory: z.ZodDefault<z.ZodBoolean>;
+  /**
+   * Maximum number of retries if the model selects incorrect tools.
+   */
+  maxRetries: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+  model?: string | BaseChatModel<_langchain_core_language_models_chat_models0.BaseChatModelCallOptions, _langchain_core_messages0.BaseMessageChunk<_langchain_core_messages0.MessageStructure, _langchain_core_messages0.MessageType>> | undefined;
+  systemPrompt: string;
+  maxTools?: number | undefined;
+  includeFullHistory: boolean;
+  maxRetries: number;
+}, {
+  model?: string | BaseChatModel<_langchain_core_language_models_chat_models0.BaseChatModelCallOptions, _langchain_core_messages0.BaseMessageChunk<_langchain_core_messages0.MessageStructure, _langchain_core_messages0.MessageType>> | undefined;
+  systemPrompt?: string | undefined;
+  maxTools?: number | undefined;
+  includeFullHistory?: boolean | undefined;
+  maxRetries?: number | undefined;
+}>, any>;
+//#endregion
+export { LLMToolSelectorConfig, llmToolSelectorMiddleware };
+//# sourceMappingURL=bigTool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bigTool.d.ts","names":["_langchain_core_messages0","___types_js3","z","BaseChatModel","InferInteropZodInput","LLMToolSelectorOptionsSchema","ZodString","_langchain_core_language_models_chat_models0","BaseChatModelCallOptions","MessageStructure","MessageType","BaseMessageChunk","ZodTypeDef","ZodType","ZodUnion","ZodOptional","ZodDefault","ZodNumber","ZodBoolean","ZodTypeAny","ZodObject","LLMToolSelectorConfig","llmToolSelectorMiddleware","AgentMiddleware"],"sources":["../../../../src/agents/middlewareAgent/middleware/bigTool.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport type { InferInteropZodInput } from \"@langchain/core/utils/types\";\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<BaseChatModel<import(\"@langchain/core/language_models/chat_models\").BaseChatModelCallOptions, import(\"@langchain/core/messages\").BaseMessageChunk<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>>, z.ZodTypeDef, BaseChatModel<import(\"@langchain/core/language_models/chat_models\").BaseChatModelCallOptions, import(\"@langchain/core/messages\").BaseMessageChunk<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>>>]>>;\n    /**\n     * System prompt for the tool selection model.\n     */\n    systemPrompt: z.ZodDefault<z.ZodString>;\n    /**\n     * Maximum number of tools to select.\n     */\n    maxTools: z.ZodOptional<z.ZodNumber>;\n    /**\n     * Whether to include the full conversation history in the tool selection prompt.\n     */\n    includeFullHistory: z.ZodDefault<z.ZodBoolean>;\n    /**\n     * Maximum number of retries if the model selects incorrect tools.\n     */\n    maxRetries: z.ZodDefault<z.ZodNumber>;\n}, \"strip\", z.ZodTypeAny, {\n    model?: string | BaseChatModel<import(\"@langchain/core/language_models/chat_models\").BaseChatModelCallOptions, import(\"@langchain/core/messages\").BaseMessageChunk<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>> | undefined;\n    systemPrompt: string;\n    maxTools?: number | undefined;\n    includeFullHistory: boolean;\n    maxRetries: number;\n}, {\n    model?: string | BaseChatModel<import(\"@langchain/core/language_models/chat_models\").BaseChatModelCallOptions, import(\"@langchain/core/messages\").BaseMessageChunk<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>> | undefined;\n    systemPrompt?: string | undefined;\n    maxTools?: number | undefined;\n    includeFullHistory?: boolean | undefined;\n    maxRetries?: number | undefined;\n}>;\nexport type LLMToolSelectorConfig = InferInteropZodInput<typeof LLMToolSelectorOptionsSchema>;\n/**\n * Middleware for selecting tools using an LLM-based strategy.\n *\n * This middleware analyzes the user's query and available tools to select\n * the most relevant tools for the task, reducing the cognitive load on the\n * main model and improving response quality.\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 - System prompt for the tool selection model.\n * @param options.maxTools - Maximum number of tools to select.\n * @param options.includeFullHistory - Whether to include the full conversation history in the tool selection prompt.\n * @param options.maxRetries - Maximum number of retries if the model selects incorrect tools.\n *\n * @example\n * ```ts\n * import { llmToolSelectorMiddleware } from \"langchain/agents/middleware\";\n *\n * const middleware = llmToolSelectorMiddleware({\n *   maxTools: 3,\n *   systemPrompt: \"Select the most relevant tools for the user's query.\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [tool1, tool2, tool3, tool4, tool5],\n *   middleware: [middleware],\n * });\n * ```\n */\nexport declare function llmToolSelectorMiddleware(options: LLMToolSelectorConfig): import(\"../types.js\").AgentMiddleware<undefined, 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<BaseChatModel<import(\"@langchain/core/language_models/chat_models\").BaseChatModelCallOptions, import(\"@langchain/core/messages\").BaseMessageChunk<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>>, z.ZodTypeDef, BaseChatModel<import(\"@langchain/core/language_models/chat_models\").BaseChatModelCallOptions, import(\"@langchain/core/messages\").BaseMessageChunk<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>>>]>>;\n    /**\n     * System prompt for the tool selection model.\n     */\n    systemPrompt: z.ZodDefault<z.ZodString>;\n    /**\n     * Maximum number of tools to select.\n     */\n    maxTools: z.ZodOptional<z.ZodNumber>;\n    /**\n     * Whether to include the full conversation history in the tool selection prompt.\n     */\n    includeFullHistory: z.ZodDefault<z.ZodBoolean>;\n    /**\n     * Maximum number of retries if the model selects incorrect tools.\n     */\n    maxRetries: z.ZodDefault<z.ZodNumber>;\n}, \"strip\", z.ZodTypeAny, {\n    model?: string | BaseChatModel<import(\"@langchain/core/language_models/chat_models\").BaseChatModelCallOptions, import(\"@langchain/core/messages\").BaseMessageChunk<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>> | undefined;\n    systemPrompt: string;\n    maxTools?: number | undefined;\n    includeFullHistory: boolean;\n    maxRetries: number;\n}, {\n    model?: string | BaseChatModel<import(\"@langchain/core/language_models/chat_models\").BaseChatModelCallOptions, import(\"@langchain/core/messages\").BaseMessageChunk<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>> | undefined;\n    systemPrompt?: string | undefined;\n    maxTools?: number | undefined;\n    includeFullHistory?: boolean | undefined;\n    maxRetries?: number | undefined;\n}>, any>;\n"],"mappings":"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"}

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

@@ -0,0 +1,161 @@
+import { initChatModel } from "../../../chat_models/universal.js";
+import { createMiddleware } from "../middleware.js";
+import { HumanMessage } from "@langchain/core/messages";
+import { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import { z } from "zod/v3";
+
+//#region src/agents/middlewareAgent/middleware/bigTool.ts
+/**
+* Zod schema for tool selection structured output.
+*/
+const ToolSelectionSchema = z.object({ selectedTools: z.array(z.string()).describe("List of selected tool names") });
+const DEFAULT_SYSTEM_PROMPT = "Your goal is to select the most relevant tool for answering the user's query.";
+const DEFAULT_INCLUDE_FULL_HISTORY = false;
+const DEFAULT_MAX_RETRIES = 3;
+/**
+* Options for configuring the LLM Tool Selector middleware.
+*/
+const LLMToolSelectorOptionsSchema = z.object({
+	model: z.string().or(z.instanceof(BaseChatModel)).optional(),
+	systemPrompt: z.string().default(DEFAULT_SYSTEM_PROMPT),
+	maxTools: z.number().optional(),
+	includeFullHistory: z.boolean().default(DEFAULT_INCLUDE_FULL_HISTORY),
+	maxRetries: z.number().default(DEFAULT_MAX_RETRIES)
+});
+/**
+* Middleware for selecting tools using an LLM-based strategy.
+*
+* This middleware analyzes the user's query and available tools to select
+* the most relevant tools for the task, reducing the cognitive load on the
+* main model and improving response quality.
+*
+* @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 - System prompt for the tool selection model.
+* @param options.maxTools - Maximum number of tools to select.
+* @param options.includeFullHistory - Whether to include the full conversation history in the tool selection prompt.
+* @param options.maxRetries - Maximum number of retries if the model selects incorrect tools.
+*
+* @example
+* ```ts
+* import { llmToolSelectorMiddleware } from "langchain/agents/middleware";
+*
+* const middleware = llmToolSelectorMiddleware({
+*   maxTools: 3,
+*   systemPrompt: "Select the most relevant tools for the user's query."
+* });
+*
+* const agent = createAgent({
+*   model: "openai:gpt-4o",
+*   tools: [tool1, tool2, tool3, tool4, tool5],
+*   middleware: [middleware],
+* });
+* ```
+*/
+function llmToolSelectorMiddleware(options) {
+	return createMiddleware({
+		name: "LLMToolSelector",
+		contextSchema: LLMToolSelectorOptionsSchema,
+		async modifyModelRequest(request, _, runtime) {
+			const model = runtime.context.model ?? options.model;
+			const maxTools = runtime.context.maxTools ?? options.maxTools;
+			const includeFullHistory = runtime.context.includeFullHistory === DEFAULT_INCLUDE_FULL_HISTORY ? options.includeFullHistory ?? runtime.context.includeFullHistory : runtime.context.includeFullHistory ?? options.includeFullHistory;
+			const maxRetries = runtime.context.maxRetries === DEFAULT_MAX_RETRIES ? options.maxRetries ?? runtime.context.maxRetries : runtime.context.maxRetries ?? options.maxRetries;
+			const defaultSystemPrompt = runtime.context.systemPrompt === DEFAULT_SYSTEM_PROMPT ? options.systemPrompt ?? runtime.context.systemPrompt : runtime.context.systemPrompt ?? options.systemPrompt;
+			/**
+			* If no tools available, return request unchanged
+			*/
+			if (!request.tools || request.tools.length === 0) return request;
+			/**
+			* Extract tool information
+			*/
+			const toolInfo = runtime.tools.map((tool) => ({
+				name: tool.name,
+				description: tool.description,
+				tool
+			}));
+			/**
+			* Build tool representation for the prompt
+			*/
+			const toolRepresentation = toolInfo.map(({ name, description }) => `- ${name}: ${description}`).join("\n");
+			/**
+			* Build system message
+			*/
+			let systemMessage = `You are an agent that can use the following tools:\n${toolRepresentation}\n${defaultSystemPrompt}`;
+			if (includeFullHistory) {
+				const userMessages = request.messages.filter(HumanMessage.isInstance).map((msg) => msg.content).join("\n");
+				systemMessage += `\nThe full conversation history is:\n${userMessages}`;
+			}
+			if (maxTools !== void 0) systemMessage += ` You can select up to ${maxTools} tools.`;
+			/**
+			* Get the latest user message
+			*/
+			const latestMessage = request.messages.at(-1);
+			const userContent = typeof latestMessage?.content === "string" ? latestMessage?.content : JSON.stringify(latestMessage?.content);
+			/**
+			* Create tool selection model
+			*/
+			const toolSelectionModel = !model ? request.model : typeof model === "string" ? await initChatModel(model) : model;
+			const validToolNames = toolInfo.map(({ name }) => name);
+			const structuredModel = await toolSelectionModel.withStructuredOutput(ToolSelectionSchema);
+			let attempts = 0;
+			let selectedToolNames = [...validToolNames];
+			while (attempts <= maxRetries) try {
+				const response = await structuredModel.invoke([{
+					role: "system",
+					content: systemMessage
+				}, {
+					role: "user",
+					content: userContent
+				}]);
+				selectedToolNames = response.selectedTools;
+				/**
+				* Validate that selected tools exist
+				*/
+				const invalidTools = selectedToolNames.filter((name) => !validToolNames.includes(name));
+				if (selectedToolNames.length === 0) {
+					systemMessage += `\n\nNote: You have not selected any tools. Please select at least one tool.`;
+					attempts++;
+				} else if (invalidTools.length === 0 && maxTools && selectedToolNames.length > maxTools) {
+					systemMessage += `\n\nNote: You have selected more tools than the maximum allowed. You can select up to ${maxTools} tools.`;
+					attempts++;
+				} else if (invalidTools.length === 0)
+ /**
+				* Success
+				*/
+				break;
+				else if (attempts < maxRetries) {
+					/**
+					* Retry with feedback about invalid tools
+					*/
+					systemMessage += `\n\nNote: The following tools are not available: ${invalidTools.join(", ")}. Please select only from the available tools.`;
+					attempts++;
+				} else {
+					/**
+					* Filter out invalid tools on final attempt
+					*/
+					selectedToolNames = selectedToolNames.filter((name) => validToolNames.includes(name));
+					break;
+				}
+			} catch {
+				/**
+				* Fall back to using all tools
+				*/
+				if (attempts >= maxRetries) return request;
+				attempts++;
+			}
+			/**
+			* Filter tools based on selection
+			*/
+			const selectedTools = toolInfo.filter(({ name }) => selectedToolNames.includes(name)).map(({ name }) => name);
+			return {
+				...request,
+				tools: selectedTools
+			};
+		}
+	});
+}
+
+//#endregion
+export { llmToolSelectorMiddleware };
+//# sourceMappingURL=bigTool.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bigTool.js","names":["options: LLMToolSelectorConfig","msg: BaseMessage","selectedToolNames: string[]"],"sources":["../../../../src/agents/middlewareAgent/middleware/bigTool.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport type { InferInteropZodInput } from \"@langchain/core/utils/types\";\nimport { BaseMessage, HumanMessage } from \"@langchain/core/messages\";\n\nimport { createMiddleware } from \"../middleware.js\";\nimport { initChatModel } from \"../../../chat_models/universal.js\";\nimport type { ModelRequest } from \"../types.js\";\n\n/**\n * Zod schema for tool selection structured output.\n */\nconst ToolSelectionSchema = z.object({\n  selectedTools: z.array(z.string()).describe(\"List of selected tool names\"),\n});\n\nconst DEFAULT_SYSTEM_PROMPT =\n  \"Your goal is to select the most relevant tool for answering the user's query.\";\nconst DEFAULT_INCLUDE_FULL_HISTORY = false;\nconst DEFAULT_MAX_RETRIES = 3;\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(BaseChatModel)).optional(),\n  /**\n   * System prompt for the tool selection model.\n   */\n  systemPrompt: z.string().default(DEFAULT_SYSTEM_PROMPT),\n  /**\n   * Maximum number of tools to select.\n   */\n  maxTools: z.number().optional(),\n  /**\n   * Whether to include the full conversation history in the tool selection prompt.\n   */\n  includeFullHistory: z.boolean().default(DEFAULT_INCLUDE_FULL_HISTORY),\n  /**\n   * Maximum number of retries if the model selects incorrect tools.\n   */\n  maxRetries: z.number().default(DEFAULT_MAX_RETRIES),\n});\nexport type LLMToolSelectorConfig = InferInteropZodInput<\n  typeof LLMToolSelectorOptionsSchema\n>;\n\n/**\n * Middleware for selecting tools using an LLM-based strategy.\n *\n * This middleware analyzes the user's query and available tools to select\n * the most relevant tools for the task, reducing the cognitive load on the\n * main model and improving response quality.\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 - System prompt for the tool selection model.\n * @param options.maxTools - Maximum number of tools to select.\n * @param options.includeFullHistory - Whether to include the full conversation history in the tool selection prompt.\n * @param options.maxRetries - Maximum number of retries if the model selects incorrect tools.\n *\n * @example\n * ```ts\n * import { llmToolSelectorMiddleware } from \"langchain/agents/middleware\";\n *\n * const middleware = llmToolSelectorMiddleware({\n *   maxTools: 3,\n *   systemPrompt: \"Select the most relevant tools for the user's query.\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [tool1, tool2, tool3, tool4, tool5],\n *   middleware: [middleware],\n * });\n * ```\n */\nexport function llmToolSelectorMiddleware(options: LLMToolSelectorConfig) {\n  return createMiddleware({\n    name: \"LLMToolSelector\",\n    contextSchema: LLMToolSelectorOptionsSchema,\n    async modifyModelRequest(request, _, runtime): Promise<ModelRequest> {\n      const model = runtime.context.model ?? options.model;\n      const maxTools = runtime.context.maxTools ?? options.maxTools;\n      const includeFullHistory =\n        runtime.context.includeFullHistory === DEFAULT_INCLUDE_FULL_HISTORY\n          ? options.includeFullHistory ?? runtime.context.includeFullHistory\n          : runtime.context.includeFullHistory ?? options.includeFullHistory;\n      const maxRetries =\n        runtime.context.maxRetries === DEFAULT_MAX_RETRIES\n          ? options.maxRetries ?? runtime.context.maxRetries\n          : runtime.context.maxRetries ?? options.maxRetries;\n      const defaultSystemPrompt =\n        runtime.context.systemPrompt === DEFAULT_SYSTEM_PROMPT\n          ? options.systemPrompt ?? runtime.context.systemPrompt\n          : runtime.context.systemPrompt ?? options.systemPrompt;\n\n      /**\n       * If no tools available, return request unchanged\n       */\n      if (!request.tools || request.tools.length === 0) {\n        return request;\n      }\n\n      /**\n       * Extract tool information\n       */\n      const toolInfo = runtime.tools.map((tool) => ({\n        name: tool.name as string,\n        description: tool.description,\n        tool,\n      }));\n\n      /**\n       * Build tool representation for the prompt\n       */\n      const toolRepresentation = toolInfo\n        .map(({ name, description }) => `- ${name}: ${description}`)\n        .join(\"\\n\");\n\n      /**\n       * Build system message\n       */\n      let systemMessage = `You are an agent that can use the following tools:\\n${toolRepresentation}\\n${defaultSystemPrompt}`;\n\n      if (includeFullHistory) {\n        const userMessages = request.messages\n          .filter(HumanMessage.isInstance)\n          .map((msg: BaseMessage) => msg.content)\n          .join(\"\\n\");\n        systemMessage += `\\nThe full conversation history is:\\n${userMessages}`;\n      }\n\n      if (maxTools !== undefined) {\n        systemMessage += ` You can select up to ${maxTools} tools.`;\n      }\n\n      /**\n       * Get the latest user message\n       */\n      const latestMessage = request.messages.at(-1);\n      const userContent =\n        typeof latestMessage?.content === \"string\"\n          ? latestMessage?.content\n          : JSON.stringify(latestMessage?.content);\n\n      /**\n       * Create tool selection model\n       */\n      const toolSelectionModel = !model\n        ? (request.model as BaseChatModel)\n        : typeof model === \"string\"\n        ? await initChatModel(model)\n        : model;\n\n      const validToolNames = toolInfo.map(({ name }) => name);\n      const structuredModel = await toolSelectionModel.withStructuredOutput(\n        ToolSelectionSchema\n      );\n\n      let attempts = 0;\n      let selectedToolNames: string[] = [...validToolNames];\n\n      while (attempts <= maxRetries) {\n        try {\n          const response = await structuredModel.invoke([\n            { role: \"system\", content: systemMessage },\n            { role: \"user\", content: userContent },\n          ]);\n\n          selectedToolNames = response.selectedTools;\n\n          /**\n           * Validate that selected tools exist\n           */\n          const invalidTools = selectedToolNames.filter(\n            (name) => !validToolNames.includes(name)\n          );\n\n          if (selectedToolNames.length === 0) {\n            systemMessage += `\\n\\nNote: You have not selected any tools. Please select at least one tool.`;\n            attempts++;\n          } else if (\n            invalidTools.length === 0 &&\n            maxTools &&\n            selectedToolNames.length > maxTools\n          ) {\n            systemMessage += `\\n\\nNote: You have selected more tools than the maximum allowed. You can select up to ${maxTools} tools.`;\n            attempts++;\n          } else if (invalidTools.length === 0) {\n            /**\n             * Success\n             */\n            break;\n          } else if (attempts < maxRetries) {\n            /**\n             * Retry with feedback about invalid tools\n             */\n            systemMessage += `\\n\\nNote: The following tools are not available: ${invalidTools.join(\n              \", \"\n            )}. Please select only from the available tools.`;\n            attempts++;\n          } else {\n            /**\n             * Filter out invalid tools on final attempt\n             */\n            selectedToolNames = selectedToolNames.filter((name) =>\n              validToolNames.includes(name)\n            );\n            break;\n          }\n        } catch {\n          /**\n           * Fall back to using all tools\n           */\n          if (attempts >= maxRetries) {\n            return request;\n          }\n          attempts++;\n        }\n      }\n\n      /**\n       * Filter tools based on selection\n       */\n      const selectedTools = toolInfo\n        .filter(({ name }) => selectedToolNames.includes(name))\n        .map(({ name }) => name);\n\n      return {\n        ...request,\n        tools: selectedTools,\n      };\n    },\n  });\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,58 @@
+const require_middleware = require('../middleware.cjs');
+
+//#region src/agents/middlewareAgent/middleware/dynamicSystemPrompt.ts
+/**
+* Dynamic System Prompt Middleware
+*
+* Allows setting the system prompt dynamically right before each model invocation.
+* Useful when the prompt depends on the current agent state or per-invocation context.
+*
+* @typeParam TContextSchema - The shape of the runtime context available at invocation time.
+* If your agent defines a `contextSchema`, pass the inferred type here to get full type-safety
+* for `runtime.context`.
+*
+* @param fn - Function that receives the current agent `state` and `runtime`, and
+* returns the system prompt for the next model call as a string.
+*
+* @returns A middleware instance that sets `systemPrompt` for the next model call.
+*
+* @example Basic usage with typed context
+* ```ts
+* import { z } from "zod";
+* import { dynamicSystemPrompt } from "langchain/middleware";
+* import { createAgent, SystemMessage } from "langchain";
+*
+* const contextSchema = z.object({ region: z.string().optional() });
+*
+* const middleware = dynamicSystemPrompt<z.infer<typeof contextSchema>>(
+*   (_state, runtime) => `You are a helpful assistant. Region: ${runtime.context.region ?? "n/a"}`
+* );
+*
+* const agent = createAgent({
+*   model: "anthropic:claude-3-5-sonnet",
+*   contextSchema,
+*   middleware: [middleware],
+* });
+*
+* await agent.invoke({ messages }, { context: { region: "EU" } });
+* ```
+*
+* @public
+*/
+function dynamicSystemPromptMiddleware(fn) {
+	return require_middleware.createMiddleware({
+		name: "DynamicSystemPromptMiddleware",
+		modifyModelRequest: async (options, state, runtime) => {
+			const systemPrompt = await fn(state, runtime);
+			if (typeof systemPrompt !== "string") throw new Error("dynamicSystemPromptMiddleware function must return a string");
+			return {
+				...options,
+				systemPrompt
+			};
+		}
+	});
+}
+
+//#endregion
+exports.dynamicSystemPromptMiddleware = dynamicSystemPromptMiddleware;
+//# sourceMappingURL=dynamicSystemPrompt.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dynamicSystemPrompt.cjs","names":["fn: DynamicSystemPromptMiddlewareConfig<TContextSchema>","createMiddleware"],"sources":["../../../../src/agents/middlewareAgent/middleware/dynamicSystemPrompt.ts"],"sourcesContent":["import { createMiddleware } from \"../middleware.js\";\nimport type { Runtime, AgentBuiltInState } from \"../types.js\";\n\nexport type DynamicSystemPromptMiddlewareConfig<TContextSchema> = (\n  state: AgentBuiltInState,\n  runtime: Runtime<AgentBuiltInState, TContextSchema>\n) => string | Promise<string>;\n\n/**\n * Dynamic System Prompt Middleware\n *\n * Allows setting the system prompt dynamically right before each model invocation.\n * Useful when the prompt depends on the current agent state or per-invocation context.\n *\n * @typeParam TContextSchema - The shape of the runtime context available at invocation time.\n * If your agent defines a `contextSchema`, pass the inferred type here to get full type-safety\n * for `runtime.context`.\n *\n * @param fn - Function that receives the current agent `state` and `runtime`, and\n * returns the system prompt for the next model call as a string.\n *\n * @returns A middleware instance that sets `systemPrompt` for the next model call.\n *\n * @example Basic usage with typed context\n * ```ts\n * import { z } from \"zod\";\n * import { dynamicSystemPrompt } from \"langchain/middleware\";\n * import { createAgent, SystemMessage } from \"langchain\";\n *\n * const contextSchema = z.object({ region: z.string().optional() });\n *\n * const middleware = dynamicSystemPrompt<z.infer<typeof contextSchema>>(\n *   (_state, runtime) => `You are a helpful assistant. Region: ${runtime.context.region ?? \"n/a\"}`\n * );\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   contextSchema,\n *   middleware: [middleware],\n * });\n *\n * await agent.invoke({ messages }, { context: { region: \"EU\" } });\n * ```\n *\n * @public\n */\nexport function dynamicSystemPromptMiddleware<TContextSchema = unknown>(\n  fn: DynamicSystemPromptMiddlewareConfig<TContextSchema>\n) {\n  return createMiddleware({\n    name: \"DynamicSystemPromptMiddleware\",\n    modifyModelRequest: async (options, state, runtime) => {\n      const systemPrompt = await fn(\n        state as AgentBuiltInState,\n        runtime as Runtime<AgentBuiltInState, TContextSchema>\n      );\n\n      if (typeof systemPrompt !== \"string\") {\n        throw new Error(\n          \"dynamicSystemPromptMiddleware function must return a string\"\n        );\n      }\n\n      return { ...options, systemPrompt };\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CA,SAAgB,8BACdA,IACA;AACA,QAAOC,oCAAiB;EACtB,MAAM;EACN,oBAAoB,OAAO,SAAS,OAAO,YAAY;GACrD,MAAM,eAAe,MAAM,GACzB,OACA,QACD;AAED,OAAI,OAAO,iBAAiB,SAC1B,OAAM,IAAI,MACR;AAIJ,UAAO;IAAE,GAAG;IAAS;GAAc;EACpC;CACF,EAAC;AACH"}

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

@@ -0,0 +1,46 @@
+import { AgentBuiltInState, AgentMiddleware, Runtime } from "../types.cjs";
+
+//#region src/agents/middlewareAgent/middleware/dynamicSystemPrompt.d.ts
+type DynamicSystemPromptMiddlewareConfig<TContextSchema> = (state: AgentBuiltInState, runtime: Runtime<AgentBuiltInState, TContextSchema>) => string | Promise<string>;
+/**
+ * Dynamic System Prompt Middleware
+ *
+ * Allows setting the system prompt dynamically right before each model invocation.
+ * Useful when the prompt depends on the current agent state or per-invocation context.
+ *
+ * @typeParam TContextSchema - The shape of the runtime context available at invocation time.
+ * If your agent defines a `contextSchema`, pass the inferred type here to get full type-safety
+ * for `runtime.context`.
+ *
+ * @param fn - Function that receives the current agent `state` and `runtime`, and
+ * returns the system prompt for the next model call as a string.
+ *
+ * @returns A middleware instance that sets `systemPrompt` for the next model call.
+ *
+ * @example Basic usage with typed context
+ * ```ts
+ * import { z } from "zod";
+ * import { dynamicSystemPrompt } from "langchain/middleware";
+ * import { createAgent, SystemMessage } from "langchain";
+ *
+ * const contextSchema = z.object({ region: z.string().optional() });
+ *
+ * const middleware = dynamicSystemPrompt<z.infer<typeof contextSchema>>(
+ *   (_state, runtime) => `You are a helpful assistant. Region: ${runtime.context.region ?? "n/a"}`
+ * );
+ *
+ * const agent = createAgent({
+ *   model: "anthropic:claude-3-5-sonnet",
+ *   contextSchema,
+ *   middleware: [middleware],
+ * });
+ *
+ * await agent.invoke({ messages }, { context: { region: "EU" } });
+ * ```
+ *
+ * @public
+ */
+declare function dynamicSystemPromptMiddleware<TContextSchema = unknown>(fn: DynamicSystemPromptMiddlewareConfig<TContextSchema>): AgentMiddleware<undefined, undefined, any>;
+//#endregion
+export { DynamicSystemPromptMiddlewareConfig, dynamicSystemPromptMiddleware };
+//# sourceMappingURL=dynamicSystemPrompt.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dynamicSystemPrompt.d.cts","names":["Runtime","AgentBuiltInState","DynamicSystemPromptMiddlewareConfig","TContextSchema","Promise","dynamicSystemPromptMiddleware","___types_js1","AgentMiddleware"],"sources":["../../../../src/agents/middlewareAgent/middleware/dynamicSystemPrompt.d.ts"],"sourcesContent":["import type { Runtime, AgentBuiltInState } from \"../types.js\";\nexport type DynamicSystemPromptMiddlewareConfig<TContextSchema> = (state: AgentBuiltInState, runtime: Runtime<AgentBuiltInState, TContextSchema>) => string | Promise<string>;\n/**\n * Dynamic System Prompt Middleware\n *\n * Allows setting the system prompt dynamically right before each model invocation.\n * Useful when the prompt depends on the current agent state or per-invocation context.\n *\n * @typeParam TContextSchema - The shape of the runtime context available at invocation time.\n * If your agent defines a `contextSchema`, pass the inferred type here to get full type-safety\n * for `runtime.context`.\n *\n * @param fn - Function that receives the current agent `state` and `runtime`, and\n * returns the system prompt for the next model call as a string.\n *\n * @returns A middleware instance that sets `systemPrompt` for the next model call.\n *\n * @example Basic usage with typed context\n * ```ts\n * import { z } from \"zod\";\n * import { dynamicSystemPrompt } from \"langchain/middleware\";\n * import { createAgent, SystemMessage } from \"langchain\";\n *\n * const contextSchema = z.object({ region: z.string().optional() });\n *\n * const middleware = dynamicSystemPrompt<z.infer<typeof contextSchema>>(\n *   (_state, runtime) => `You are a helpful assistant. Region: ${runtime.context.region ?? \"n/a\"}`\n * );\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   contextSchema,\n *   middleware: [middleware],\n * });\n *\n * await agent.invoke({ messages }, { context: { region: \"EU\" } });\n * ```\n *\n * @public\n */\nexport declare function dynamicSystemPromptMiddleware<TContextSchema = unknown>(fn: DynamicSystemPromptMiddlewareConfig<TContextSchema>): import(\"../types.js\").AgentMiddleware<undefined, undefined, any>;\n"],"mappings":";;;KACYE,8DAA8DD,4BAA4BD,QAAQC,mBAAmBE,6BAA6BC;;AAA9J;;;;;;;AAAqK;AAuCrK;;;;;AAA+K;;;;;;;;;;;;;;;;;;;;;;;;iBAAvJC,4DAA4DH,oCAAoCC,kBAAD"}

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

@@ -0,0 +1,46 @@
+import { AgentBuiltInState, AgentMiddleware, Runtime } from "../types.js";
+
+//#region src/agents/middlewareAgent/middleware/dynamicSystemPrompt.d.ts
+type DynamicSystemPromptMiddlewareConfig<TContextSchema> = (state: AgentBuiltInState, runtime: Runtime<AgentBuiltInState, TContextSchema>) => string | Promise<string>;
+/**
+ * Dynamic System Prompt Middleware
+ *
+ * Allows setting the system prompt dynamically right before each model invocation.
+ * Useful when the prompt depends on the current agent state or per-invocation context.
+ *
+ * @typeParam TContextSchema - The shape of the runtime context available at invocation time.
+ * If your agent defines a `contextSchema`, pass the inferred type here to get full type-safety
+ * for `runtime.context`.
+ *
+ * @param fn - Function that receives the current agent `state` and `runtime`, and
+ * returns the system prompt for the next model call as a string.
+ *
+ * @returns A middleware instance that sets `systemPrompt` for the next model call.
+ *
+ * @example Basic usage with typed context
+ * ```ts
+ * import { z } from "zod";
+ * import { dynamicSystemPrompt } from "langchain/middleware";
+ * import { createAgent, SystemMessage } from "langchain";
+ *
+ * const contextSchema = z.object({ region: z.string().optional() });
+ *
+ * const middleware = dynamicSystemPrompt<z.infer<typeof contextSchema>>(
+ *   (_state, runtime) => `You are a helpful assistant. Region: ${runtime.context.region ?? "n/a"}`
+ * );
+ *
+ * const agent = createAgent({
+ *   model: "anthropic:claude-3-5-sonnet",
+ *   contextSchema,
+ *   middleware: [middleware],
+ * });
+ *
+ * await agent.invoke({ messages }, { context: { region: "EU" } });
+ * ```
+ *
+ * @public
+ */
+declare function dynamicSystemPromptMiddleware<TContextSchema = unknown>(fn: DynamicSystemPromptMiddlewareConfig<TContextSchema>): AgentMiddleware<undefined, undefined, any>;
+//#endregion
+export { DynamicSystemPromptMiddlewareConfig, dynamicSystemPromptMiddleware };
+//# sourceMappingURL=dynamicSystemPrompt.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dynamicSystemPrompt.d.ts","names":["Runtime","AgentBuiltInState","DynamicSystemPromptMiddlewareConfig","TContextSchema","Promise","dynamicSystemPromptMiddleware","___types_js2","AgentMiddleware"],"sources":["../../../../src/agents/middlewareAgent/middleware/dynamicSystemPrompt.d.ts"],"sourcesContent":["import type { Runtime, AgentBuiltInState } from \"../types.js\";\nexport type DynamicSystemPromptMiddlewareConfig<TContextSchema> = (state: AgentBuiltInState, runtime: Runtime<AgentBuiltInState, TContextSchema>) => string | Promise<string>;\n/**\n * Dynamic System Prompt Middleware\n *\n * Allows setting the system prompt dynamically right before each model invocation.\n * Useful when the prompt depends on the current agent state or per-invocation context.\n *\n * @typeParam TContextSchema - The shape of the runtime context available at invocation time.\n * If your agent defines a `contextSchema`, pass the inferred type here to get full type-safety\n * for `runtime.context`.\n *\n * @param fn - Function that receives the current agent `state` and `runtime`, and\n * returns the system prompt for the next model call as a string.\n *\n * @returns A middleware instance that sets `systemPrompt` for the next model call.\n *\n * @example Basic usage with typed context\n * ```ts\n * import { z } from \"zod\";\n * import { dynamicSystemPrompt } from \"langchain/middleware\";\n * import { createAgent, SystemMessage } from \"langchain\";\n *\n * const contextSchema = z.object({ region: z.string().optional() });\n *\n * const middleware = dynamicSystemPrompt<z.infer<typeof contextSchema>>(\n *   (_state, runtime) => `You are a helpful assistant. Region: ${runtime.context.region ?? \"n/a\"}`\n * );\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   contextSchema,\n *   middleware: [middleware],\n * });\n *\n * await agent.invoke({ messages }, { context: { region: \"EU\" } });\n * ```\n *\n * @public\n */\nexport declare function dynamicSystemPromptMiddleware<TContextSchema = unknown>(fn: DynamicSystemPromptMiddlewareConfig<TContextSchema>): import(\"../types.js\").AgentMiddleware<undefined, undefined, any>;\n"],"mappings":";;;KACYE,8DAA8DD,4BAA4BD,QAAQC,mBAAmBE,6BAA6BC;;AAA9J;;;;;;;AAAqK;AAuCrK;;;;;AAA+K;;;;;;;;;;;;;;;;;;;;;;;;iBAAvJC,4DAA4DH,oCAAoCC,kBAAD"}

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

@@ -0,0 +1,58 @@
+import { createMiddleware } from "../middleware.js";
+
+//#region src/agents/middlewareAgent/middleware/dynamicSystemPrompt.ts
+/**
+* Dynamic System Prompt Middleware
+*
+* Allows setting the system prompt dynamically right before each model invocation.
+* Useful when the prompt depends on the current agent state or per-invocation context.
+*
+* @typeParam TContextSchema - The shape of the runtime context available at invocation time.
+* If your agent defines a `contextSchema`, pass the inferred type here to get full type-safety
+* for `runtime.context`.
+*
+* @param fn - Function that receives the current agent `state` and `runtime`, and
+* returns the system prompt for the next model call as a string.
+*
+* @returns A middleware instance that sets `systemPrompt` for the next model call.
+*
+* @example Basic usage with typed context
+* ```ts
+* import { z } from "zod";
+* import { dynamicSystemPrompt } from "langchain/middleware";
+* import { createAgent, SystemMessage } from "langchain";
+*
+* const contextSchema = z.object({ region: z.string().optional() });
+*
+* const middleware = dynamicSystemPrompt<z.infer<typeof contextSchema>>(
+*   (_state, runtime) => `You are a helpful assistant. Region: ${runtime.context.region ?? "n/a"}`
+* );
+*
+* const agent = createAgent({
+*   model: "anthropic:claude-3-5-sonnet",
+*   contextSchema,
+*   middleware: [middleware],
+* });
+*
+* await agent.invoke({ messages }, { context: { region: "EU" } });
+* ```
+*
+* @public
+*/
+function dynamicSystemPromptMiddleware(fn) {
+	return createMiddleware({
+		name: "DynamicSystemPromptMiddleware",
+		modifyModelRequest: async (options, state, runtime) => {
+			const systemPrompt = await fn(state, runtime);
+			if (typeof systemPrompt !== "string") throw new Error("dynamicSystemPromptMiddleware function must return a string");
+			return {
+				...options,
+				systemPrompt
+			};
+		}
+	});
+}
+
+//#endregion
+export { dynamicSystemPromptMiddleware };
+//# sourceMappingURL=dynamicSystemPrompt.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dynamicSystemPrompt.js","names":["fn: DynamicSystemPromptMiddlewareConfig<TContextSchema>"],"sources":["../../../../src/agents/middlewareAgent/middleware/dynamicSystemPrompt.ts"],"sourcesContent":["import { createMiddleware } from \"../middleware.js\";\nimport type { Runtime, AgentBuiltInState } from \"../types.js\";\n\nexport type DynamicSystemPromptMiddlewareConfig<TContextSchema> = (\n  state: AgentBuiltInState,\n  runtime: Runtime<AgentBuiltInState, TContextSchema>\n) => string | Promise<string>;\n\n/**\n * Dynamic System Prompt Middleware\n *\n * Allows setting the system prompt dynamically right before each model invocation.\n * Useful when the prompt depends on the current agent state or per-invocation context.\n *\n * @typeParam TContextSchema - The shape of the runtime context available at invocation time.\n * If your agent defines a `contextSchema`, pass the inferred type here to get full type-safety\n * for `runtime.context`.\n *\n * @param fn - Function that receives the current agent `state` and `runtime`, and\n * returns the system prompt for the next model call as a string.\n *\n * @returns A middleware instance that sets `systemPrompt` for the next model call.\n *\n * @example Basic usage with typed context\n * ```ts\n * import { z } from \"zod\";\n * import { dynamicSystemPrompt } from \"langchain/middleware\";\n * import { createAgent, SystemMessage } from \"langchain\";\n *\n * const contextSchema = z.object({ region: z.string().optional() });\n *\n * const middleware = dynamicSystemPrompt<z.infer<typeof contextSchema>>(\n *   (_state, runtime) => `You are a helpful assistant. Region: ${runtime.context.region ?? \"n/a\"}`\n * );\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   contextSchema,\n *   middleware: [middleware],\n * });\n *\n * await agent.invoke({ messages }, { context: { region: \"EU\" } });\n * ```\n *\n * @public\n */\nexport function dynamicSystemPromptMiddleware<TContextSchema = unknown>(\n  fn: DynamicSystemPromptMiddlewareConfig<TContextSchema>\n) {\n  return createMiddleware({\n    name: \"DynamicSystemPromptMiddleware\",\n    modifyModelRequest: async (options, state, runtime) => {\n      const systemPrompt = await fn(\n        state as AgentBuiltInState,\n        runtime as Runtime<AgentBuiltInState, TContextSchema>\n      );\n\n      if (typeof systemPrompt !== \"string\") {\n        throw new Error(\n          \"dynamicSystemPromptMiddleware function must return a string\"\n        );\n      }\n\n      return { ...options, systemPrompt };\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CA,SAAgB,8BACdA,IACA;AACA,QAAO,iBAAiB;EACtB,MAAM;EACN,oBAAoB,OAAO,SAAS,OAAO,YAAY;GACrD,MAAM,eAAe,MAAM,GACzB,OACA,QACD;AAED,OAAI,OAAO,iBAAiB,SAC1B,OAAM,IAAI,MACR;AAIJ,UAAO;IAAE,GAAG;IAAS;GAAc;EACpC;CACF,EAAC;AACH"}