langchain 1.0.0-alpha.7 → 1.0.0-alpha.8

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"}

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

@@ -0,0 +1,192 @@
+import { initChatModel } from "../../../chat_models/universal.js";
+import { createMiddleware } from "../middleware.js";
+import { HumanMessage } from "@langchain/core/messages";
+import { z } from "zod/v3";
+import { BaseLanguageModel } from "@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) => z.literal(tool.name));
+	const toolEnum = z.union(toolLiterals);
+	return z.object({ tools: z.array(toolEnum).describe("Tools to use. Place the most relevant tools first.") });
+}
+/**
+* Options for configuring the LLM Tool Selector middleware.
+*/
+const LLMToolSelectorOptionsSchema = z.object({
+	model: z.string().or(z.instanceof(BaseLanguageModel)).optional(),
+	systemPrompt: z.string().optional(),
+	maxTools: z.number().optional(),
+	alwaysInclude: z.array(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 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 (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 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
+export { llmToolSelectorMiddleware };
+//# sourceMappingURL=llmToolSelector.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"llmToolSelector.js","names":["tools: StructuredToolInterface[]","options: LLMToolSelectorConfig","request: ModelRequest","runtime: Runtime<LLMToolSelectorConfig>","lastUserMessage: HumanMessage | undefined","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/modelFallback.cjs

@@ -0,0 +1,67 @@
+const require_chat_models_universal = require('../../../chat_models/universal.cjs');
+const require_middleware = require('../middleware.cjs');
+
+//#region src/agents/middlewareAgent/middleware/modelFallback.ts
+/**
+* Middleware that provides automatic model fallback on errors.
+*
+* This middleware attempts to retry failed model calls with alternative models
+* in sequence. When a model call fails, it tries the next model in the fallback
+* list until either a call succeeds or all models have been exhausted.
+*
+* @example
+* ```ts
+* import { createAgent, modelFallbackMiddleware } from "langchain";
+*
+* // Create middleware with fallback models (not including primary)
+* const fallback = modelFallbackMiddleware({
+*   "openai:gpt-4o-mini",  // First fallback
+*   "anthropic:claude-3-5-sonnet-20241022",  // Second fallback
+* });
+*
+* const agent = createAgent({
+*   model: "openai:gpt-4o",  // Primary model
+*   middleware: [fallback],
+*   tools: [],
+* });
+*
+* // If gpt-4o fails, automatically tries gpt-4o-mini, then claude
+* const result = await agent.invoke({
+*   messages: [{ role: "user", content: "Hello" }]
+* });
+* ```
+*
+* @param fallbackModels - The fallback models to try, in order.
+* @returns A middleware instance that handles model failures with fallbacks
+*/
+function modelFallbackMiddleware(...fallbackModels) {
+	return require_middleware.createMiddleware({
+		name: "modelFallbackMiddleware",
+		retryModelRequest: async (_error, request, _state, _runtime, attempt) => {
+			/**
+			* attempt 1 = primary model failed, try models[0] (first fallback)
+			*/
+			const fallbackIndex = attempt - 1;
+			/**
+			* All fallback models exhausted
+			*/
+			if (fallbackIndex >= fallbackModels.length) return void 0;
+			/**
+			* Get or initialize the fallback model
+			*/
+			const fallbackModel = fallbackModels[fallbackIndex];
+			const model = typeof fallbackModel === "string" ? await require_chat_models_universal.initChatModel(fallbackModel) : fallbackModel;
+			/**
+			* Try next fallback model
+			*/
+			return {
+				...request,
+				model
+			};
+		}
+	});
+}
+
+//#endregion
+exports.modelFallbackMiddleware = modelFallbackMiddleware;
+//# sourceMappingURL=modelFallback.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"modelFallback.cjs","names":["createMiddleware","initChatModel"],"sources":["../../../../src/agents/middlewareAgent/middleware/modelFallback.ts"],"sourcesContent":["import type { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { initChatModel } from \"../../../chat_models/universal.js\";\nimport type { ModelRequest, AgentMiddleware } from \"../types.js\";\nimport { createMiddleware } from \"../middleware.js\";\n\n/**\n * Middleware that provides automatic model fallback on errors.\n *\n * This middleware attempts to retry failed model calls with alternative models\n * in sequence. When a model call fails, it tries the next model in the fallback\n * list until either a call succeeds or all models have been exhausted.\n *\n * @example\n * ```ts\n * import { createAgent, modelFallbackMiddleware } from \"langchain\";\n *\n * // Create middleware with fallback models (not including primary)\n * const fallback = modelFallbackMiddleware({\n *   \"openai:gpt-4o-mini\",  // First fallback\n *   \"anthropic:claude-3-5-sonnet-20241022\",  // Second fallback\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",  // Primary model\n *   middleware: [fallback],\n *   tools: [],\n * });\n *\n * // If gpt-4o fails, automatically tries gpt-4o-mini, then claude\n * const result = await agent.invoke({\n *   messages: [{ role: \"user\", content: \"Hello\" }]\n * });\n * ```\n *\n * @param fallbackModels - The fallback models to try, in order.\n * @returns A middleware instance that handles model failures with fallbacks\n */\nexport function modelFallbackMiddleware(\n  /**\n   * The fallback models to try, in order.\n   */\n  ...fallbackModels: (string | LanguageModelLike)[]\n): AgentMiddleware {\n  return createMiddleware({\n    name: \"modelFallbackMiddleware\",\n    retryModelRequest: async (\n      _error,\n      request,\n      _state,\n      _runtime,\n      attempt\n    ): Promise<ModelRequest | undefined> => {\n      /**\n       * attempt 1 = primary model failed, try models[0] (first fallback)\n       */\n      const fallbackIndex = attempt - 1;\n\n      /**\n       * All fallback models exhausted\n       */\n      if (fallbackIndex >= fallbackModels.length) {\n        return undefined;\n      }\n\n      /**\n       * Get or initialize the fallback model\n       */\n      const fallbackModel = fallbackModels[fallbackIndex];\n      const model =\n        typeof fallbackModel === \"string\"\n          ? await initChatModel(fallbackModel)\n          : fallbackModel;\n\n      /**\n       * Try next fallback model\n       */\n      return {\n        ...request,\n        model,\n      };\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,SAAgB,wBAId,GAAG,gBACc;AACjB,QAAOA,oCAAiB;EACtB,MAAM;EACN,mBAAmB,OACjB,QACA,SACA,QACA,UACA,YACsC;;;;GAItC,MAAM,gBAAgB,UAAU;;;;AAKhC,OAAI,iBAAiB,eAAe,OAClC,QAAO;;;;GAMT,MAAM,gBAAgB,eAAe;GACrC,MAAM,QACJ,OAAO,kBAAkB,WACrB,MAAMC,4CAAc,cAAc,GAClC;;;;AAKN,UAAO;IACL,GAAG;IACH;GACD;EACF;CACF,EAAC;AACH"}

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

@@ -0,0 +1,45 @@
+import { AgentMiddleware } from "../types.cjs";
+import { LanguageModelLike } from "@langchain/core/language_models/base";
+
+//#region src/agents/middlewareAgent/middleware/modelFallback.d.ts
+
+/**
+ * Middleware that provides automatic model fallback on errors.
+ *
+ * This middleware attempts to retry failed model calls with alternative models
+ * in sequence. When a model call fails, it tries the next model in the fallback
+ * list until either a call succeeds or all models have been exhausted.
+ *
+ * @example
+ * ```ts
+ * import { createAgent, modelFallbackMiddleware } from "langchain";
+ *
+ * // Create middleware with fallback models (not including primary)
+ * const fallback = modelFallbackMiddleware({
+ *   "openai:gpt-4o-mini",  // First fallback
+ *   "anthropic:claude-3-5-sonnet-20241022",  // Second fallback
+ * });
+ *
+ * const agent = createAgent({
+ *   model: "openai:gpt-4o",  // Primary model
+ *   middleware: [fallback],
+ *   tools: [],
+ * });
+ *
+ * // If gpt-4o fails, automatically tries gpt-4o-mini, then claude
+ * const result = await agent.invoke({
+ *   messages: [{ role: "user", content: "Hello" }]
+ * });
+ * ```
+ *
+ * @param fallbackModels - The fallback models to try, in order.
+ * @returns A middleware instance that handles model failures with fallbacks
+ */
+declare function modelFallbackMiddleware(
+/**
+ * The fallback models to try, in order.
+ */
+...fallbackModels: (string | LanguageModelLike)[]): AgentMiddleware;
+//#endregion
+export { modelFallbackMiddleware };
+//# sourceMappingURL=modelFallback.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"modelFallback.d.cts","names":["LanguageModelLike","AgentMiddleware","modelFallbackMiddleware"],"sources":["../../../../src/agents/middlewareAgent/middleware/modelFallback.d.ts"],"sourcesContent":["import type { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport type { AgentMiddleware } from \"../types.js\";\n/**\n * Middleware that provides automatic model fallback on errors.\n *\n * This middleware attempts to retry failed model calls with alternative models\n * in sequence. When a model call fails, it tries the next model in the fallback\n * list until either a call succeeds or all models have been exhausted.\n *\n * @example\n * ```ts\n * import { createAgent, modelFallbackMiddleware } from \"langchain\";\n *\n * // Create middleware with fallback models (not including primary)\n * const fallback = modelFallbackMiddleware({\n *   \"openai:gpt-4o-mini\",  // First fallback\n *   \"anthropic:claude-3-5-sonnet-20241022\",  // Second fallback\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",  // Primary model\n *   middleware: [fallback],\n *   tools: [],\n * });\n *\n * // If gpt-4o fails, automatically tries gpt-4o-mini, then claude\n * const result = await agent.invoke({\n *   messages: [{ role: \"user\", content: \"Hello\" }]\n * });\n * ```\n *\n * @param fallbackModels - The fallback models to try, in order.\n * @returns A middleware instance that handles model failures with fallbacks\n */\nexport declare function modelFallbackMiddleware(\n/**\n * The fallback models to try, in order.\n */\n...fallbackModels: (string | LanguageModelLike)[]): AgentMiddleware;\n"],"mappings":";;;;;;;AAkCA;;;;AAImE;;;;;;;;;;;;;;;;;;;;;;;;;;iBAJ3CE,uBAAAA;;;;6BAIKF,uBAAuBC"}

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

@@ -0,0 +1,45 @@
+import { AgentMiddleware } from "../types.js";
+import { LanguageModelLike } from "@langchain/core/language_models/base";
+
+//#region src/agents/middlewareAgent/middleware/modelFallback.d.ts
+
+/**
+ * Middleware that provides automatic model fallback on errors.
+ *
+ * This middleware attempts to retry failed model calls with alternative models
+ * in sequence. When a model call fails, it tries the next model in the fallback
+ * list until either a call succeeds or all models have been exhausted.
+ *
+ * @example
+ * ```ts
+ * import { createAgent, modelFallbackMiddleware } from "langchain";
+ *
+ * // Create middleware with fallback models (not including primary)
+ * const fallback = modelFallbackMiddleware({
+ *   "openai:gpt-4o-mini",  // First fallback
+ *   "anthropic:claude-3-5-sonnet-20241022",  // Second fallback
+ * });
+ *
+ * const agent = createAgent({
+ *   model: "openai:gpt-4o",  // Primary model
+ *   middleware: [fallback],
+ *   tools: [],
+ * });
+ *
+ * // If gpt-4o fails, automatically tries gpt-4o-mini, then claude
+ * const result = await agent.invoke({
+ *   messages: [{ role: "user", content: "Hello" }]
+ * });
+ * ```
+ *
+ * @param fallbackModels - The fallback models to try, in order.
+ * @returns A middleware instance that handles model failures with fallbacks
+ */
+declare function modelFallbackMiddleware(
+/**
+ * The fallback models to try, in order.
+ */
+...fallbackModels: (string | LanguageModelLike)[]): AgentMiddleware;
+//#endregion
+export { modelFallbackMiddleware };
+//# sourceMappingURL=modelFallback.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"modelFallback.d.ts","names":["LanguageModelLike","AgentMiddleware","modelFallbackMiddleware"],"sources":["../../../../src/agents/middlewareAgent/middleware/modelFallback.d.ts"],"sourcesContent":["import type { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport type { AgentMiddleware } from \"../types.js\";\n/**\n * Middleware that provides automatic model fallback on errors.\n *\n * This middleware attempts to retry failed model calls with alternative models\n * in sequence. When a model call fails, it tries the next model in the fallback\n * list until either a call succeeds or all models have been exhausted.\n *\n * @example\n * ```ts\n * import { createAgent, modelFallbackMiddleware } from \"langchain\";\n *\n * // Create middleware with fallback models (not including primary)\n * const fallback = modelFallbackMiddleware({\n *   \"openai:gpt-4o-mini\",  // First fallback\n *   \"anthropic:claude-3-5-sonnet-20241022\",  // Second fallback\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",  // Primary model\n *   middleware: [fallback],\n *   tools: [],\n * });\n *\n * // If gpt-4o fails, automatically tries gpt-4o-mini, then claude\n * const result = await agent.invoke({\n *   messages: [{ role: \"user\", content: \"Hello\" }]\n * });\n * ```\n *\n * @param fallbackModels - The fallback models to try, in order.\n * @returns A middleware instance that handles model failures with fallbacks\n */\nexport declare function modelFallbackMiddleware(\n/**\n * The fallback models to try, in order.\n */\n...fallbackModels: (string | LanguageModelLike)[]): AgentMiddleware;\n"],"mappings":";;;;;;;AAkCA;;;;AAImE;;;;;;;;;;;;;;;;;;;;;;;;;;iBAJ3CE,uBAAAA;;;;6BAIKF,uBAAuBC"}

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

@@ -0,0 +1,67 @@
+import { initChatModel } from "../../../chat_models/universal.js";
+import { createMiddleware } from "../middleware.js";
+
+//#region src/agents/middlewareAgent/middleware/modelFallback.ts
+/**
+* Middleware that provides automatic model fallback on errors.
+*
+* This middleware attempts to retry failed model calls with alternative models
+* in sequence. When a model call fails, it tries the next model in the fallback
+* list until either a call succeeds or all models have been exhausted.
+*
+* @example
+* ```ts
+* import { createAgent, modelFallbackMiddleware } from "langchain";
+*
+* // Create middleware with fallback models (not including primary)
+* const fallback = modelFallbackMiddleware({
+*   "openai:gpt-4o-mini",  // First fallback
+*   "anthropic:claude-3-5-sonnet-20241022",  // Second fallback
+* });
+*
+* const agent = createAgent({
+*   model: "openai:gpt-4o",  // Primary model
+*   middleware: [fallback],
+*   tools: [],
+* });
+*
+* // If gpt-4o fails, automatically tries gpt-4o-mini, then claude
+* const result = await agent.invoke({
+*   messages: [{ role: "user", content: "Hello" }]
+* });
+* ```
+*
+* @param fallbackModels - The fallback models to try, in order.
+* @returns A middleware instance that handles model failures with fallbacks
+*/
+function modelFallbackMiddleware(...fallbackModels) {
+	return createMiddleware({
+		name: "modelFallbackMiddleware",
+		retryModelRequest: async (_error, request, _state, _runtime, attempt) => {
+			/**
+			* attempt 1 = primary model failed, try models[0] (first fallback)
+			*/
+			const fallbackIndex = attempt - 1;
+			/**
+			* All fallback models exhausted
+			*/
+			if (fallbackIndex >= fallbackModels.length) return void 0;
+			/**
+			* Get or initialize the fallback model
+			*/
+			const fallbackModel = fallbackModels[fallbackIndex];
+			const model = typeof fallbackModel === "string" ? await initChatModel(fallbackModel) : fallbackModel;
+			/**
+			* Try next fallback model
+			*/
+			return {
+				...request,
+				model
+			};
+		}
+	});
+}
+
+//#endregion
+export { modelFallbackMiddleware };
+//# sourceMappingURL=modelFallback.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"modelFallback.js","names":[],"sources":["../../../../src/agents/middlewareAgent/middleware/modelFallback.ts"],"sourcesContent":["import type { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { initChatModel } from \"../../../chat_models/universal.js\";\nimport type { ModelRequest, AgentMiddleware } from \"../types.js\";\nimport { createMiddleware } from \"../middleware.js\";\n\n/**\n * Middleware that provides automatic model fallback on errors.\n *\n * This middleware attempts to retry failed model calls with alternative models\n * in sequence. When a model call fails, it tries the next model in the fallback\n * list until either a call succeeds or all models have been exhausted.\n *\n * @example\n * ```ts\n * import { createAgent, modelFallbackMiddleware } from \"langchain\";\n *\n * // Create middleware with fallback models (not including primary)\n * const fallback = modelFallbackMiddleware({\n *   \"openai:gpt-4o-mini\",  // First fallback\n *   \"anthropic:claude-3-5-sonnet-20241022\",  // Second fallback\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",  // Primary model\n *   middleware: [fallback],\n *   tools: [],\n * });\n *\n * // If gpt-4o fails, automatically tries gpt-4o-mini, then claude\n * const result = await agent.invoke({\n *   messages: [{ role: \"user\", content: \"Hello\" }]\n * });\n * ```\n *\n * @param fallbackModels - The fallback models to try, in order.\n * @returns A middleware instance that handles model failures with fallbacks\n */\nexport function modelFallbackMiddleware(\n  /**\n   * The fallback models to try, in order.\n   */\n  ...fallbackModels: (string | LanguageModelLike)[]\n): AgentMiddleware {\n  return createMiddleware({\n    name: \"modelFallbackMiddleware\",\n    retryModelRequest: async (\n      _error,\n      request,\n      _state,\n      _runtime,\n      attempt\n    ): Promise<ModelRequest | undefined> => {\n      /**\n       * attempt 1 = primary model failed, try models[0] (first fallback)\n       */\n      const fallbackIndex = attempt - 1;\n\n      /**\n       * All fallback models exhausted\n       */\n      if (fallbackIndex >= fallbackModels.length) {\n        return undefined;\n      }\n\n      /**\n       * Get or initialize the fallback model\n       */\n      const fallbackModel = fallbackModels[fallbackIndex];\n      const model =\n        typeof fallbackModel === \"string\"\n          ? await initChatModel(fallbackModel)\n          : fallbackModel;\n\n      /**\n       * Try next fallback model\n       */\n      return {\n        ...request,\n        model,\n      };\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,SAAgB,wBAId,GAAG,gBACc;AACjB,QAAO,iBAAiB;EACtB,MAAM;EACN,mBAAmB,OACjB,QACA,SACA,QACA,UACA,YACsC;;;;GAItC,MAAM,gBAAgB,UAAU;;;;AAKhC,OAAI,iBAAiB,eAAe,OAClC,QAAO;;;;GAMT,MAAM,gBAAgB,eAAe;GACrC,MAAM,QACJ,OAAO,kBAAkB,WACrB,MAAM,cAAc,cAAc,GAClC;;;;AAKN,UAAO;IACL,GAAG;IACH;GACD;EACF;CACF,EAAC;AACH"}