langchain 1.1.6 → 1.2.1

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # langchain
 
+## 1.2.1
+
+### Patch Changes
+
+- Updated dependencies [[`a7b2a7d`](https://github.com/langchain-ai/langchainjs/commit/a7b2a7db5ef57df3731ae6c9931f4b663e909505), [`a496c5f`](https://github.com/langchain-ai/langchainjs/commit/a496c5fc64d94cc0809216325b0f1bfde3f92c45), [`1da1325`](https://github.com/langchain-ai/langchainjs/commit/1da1325aea044fb37af54a9de1f4ae0b9f47d4a2)]:
+  - @langchain/core@1.1.6
+
+## 1.2.0
+
+### Minor Changes
+
+- [#9651](https://github.com/langchain-ai/langchainjs/pull/9651) [`348c37c`](https://github.com/langchain-ai/langchainjs/commit/348c37c01a048c815fea1827c084878744e20742) Thanks [@christian-bromann](https://github.com/christian-bromann)! - feat(langchain): allow to set strict tag manually in providerStrategy #9578
+
 ## 1.1.6
 
 ### Patch Changes

package/README.md

@@ -38,12 +38,13 @@ Use LangChain for:
 
 LangChain.js is written in TypeScript and can be used in:
 
-- Node.js (ESM and CommonJS) - 18.x, 19.x, 20.x, 22.x
+- Node.js (ESM and CommonJS) - 20.x, 22.x, 24.x
 - Cloudflare Workers
 - Vercel / Next.js (Browser, Serverless and Edge functions)
 - Supabase Edge Functions
 - Browser
 - Deno
+- Bun
 
 ## 📖 Additional Resources
 

package/dist/agents/middleware/hitl.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"hitl.d.cts","names":["z","ToolCall","InferInteropZodInput","AgentBuiltInState","Runtime","DescriptionFunctionSchema","Record","ZodTypeDef","ZodType","ZodUnknown","ZodTuple","ZodString","ZodPromise","ZodUnion","ZodFunction","DescriptionFactory","infer","DecisionType","ZodEnum","InterruptOnConfigSchema","ZodArray","ZodOptional","ZodAny","ZodRecord","ZodTypeAny","Promise","ZodObject","InterruptOnConfig","input","Action","ActionRequest","ReviewConfig","HITLRequest","ApproveDecision","EditDecision","RejectDecision","Decision","HITLResponse","contextSchema","ZodBoolean","ZodDefault","HumanInTheLoopMiddlewareConfig","humanInTheLoopMiddleware","NonNullable","__types_js7","AgentMiddleware"],"sources":["../../../src/agents/middleware/hitl.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { ToolCall } from \"@langchain/core/messages\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\nimport type { AgentBuiltInState, Runtime } from \"../runtime.js\";\ndeclare const DescriptionFunctionSchema: z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>;\n/**\n * Function type that dynamically generates a description for a tool call approval request.\n *\n * @param toolCall - The tool call being reviewed\n * @param state - The current agent state\n * @param runtime - The agent runtime context\n * @returns A string description or Promise that resolves to a string description\n *\n * @example\n * ```typescript\n * import { type DescriptionFactory, type ToolCall } from \"langchain\";\n *\n * const descriptionFactory: DescriptionFactory = (toolCall, state, runtime) => {\n *   return `Please review: ${toolCall.name}(${JSON.stringify(toolCall.args)})`;\n * };\n * ```\n */\nexport type DescriptionFactory = z.infer<typeof DescriptionFunctionSchema>;\ndeclare const DecisionType: z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>;\nexport type DecisionType = z.infer<typeof DecisionType>;\ndeclare const InterruptOnConfigSchema: z.ZodObject<{\n    /**\n     * The decisions that are allowed for this action.\n     */\n    allowedDecisions: z.ZodArray<z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>, \"many\">;\n    /**\n     * The description attached to the request for human input.\n     * Can be either:\n     * - A static string describing the approval request\n     * - A callable that dynamically generates the description based on agent state,\n     *   runtime, and tool call information\n     *\n     * @example\n     * Static string description\n     * ```typescript\n     * import type { InterruptOnConfig } from \"langchain\";\n     *\n     * const config: InterruptOnConfig = {\n     *   allowedDecisions: [\"approve\", \"reject\"],\n     *   description: \"Please review this tool execution\"\n     * };\n     * ```\n     *\n     * @example\n     * Dynamic callable description\n     * ```typescript\n     * import type {\n     *   AgentBuiltInState,\n     *   Runtime,\n     *   DescriptionFactory,\n     *   ToolCall,\n     *   InterruptOnConfig\n     * } from \"langchain\";\n     *\n     * const formatToolDescription: DescriptionFactory = (\n     *   toolCall: ToolCall,\n     *   state: AgentBuiltInState,\n     *   runtime: Runtime<unknown>\n     * ) => {\n     *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n     * };\n     *\n     * const config: InterruptOnConfig = {\n     *   allowedDecisions: [\"approve\", \"edit\"],\n     *   description: formatToolDescription\n     * };\n     * ```\n     */\n    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;\n    /**\n     * JSON schema for the arguments associated with the action, if edits are allowed.\n     */\n    argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;\n}, \"strip\", z.ZodTypeAny, {\n    allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n    description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n    argsSchema?: Record<string, any> | undefined;\n}, {\n    allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n    description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n    argsSchema?: Record<string, any> | undefined;\n}>;\nexport type InterruptOnConfig = z.input<typeof InterruptOnConfigSchema>;\n/**\n * Represents an action with a name and arguments.\n */\nexport interface Action {\n    /**\n     * The type or name of action being requested (e.g., \"add_numbers\").\n     */\n    name: string;\n    /**\n     * Key-value pairs of arguments needed for the action (e.g., {\"a\": 1, \"b\": 2}).\n     */\n    args: Record<string, any>;\n}\n/**\n * Represents an action request with a name, arguments, and description.\n */\nexport interface ActionRequest {\n    /**\n     * The name of the action being requested.\n     */\n    name: string;\n    /**\n     * Key-value pairs of arguments needed for the action (e.g., {\"a\": 1, \"b\": 2}).\n     */\n    args: Record<string, any>;\n    /**\n     * The description of the action to be reviewed.\n     */\n    description?: string;\n}\n/**\n * Policy for reviewing a HITL request.\n */\nexport interface ReviewConfig {\n    /**\n     * Name of the action associated with this review configuration.\n     */\n    actionName: string;\n    /**\n     * The decisions that are allowed for this request.\n     */\n    allowedDecisions: DecisionType[];\n    /**\n     * JSON schema for the arguments associated with the action, if edits are allowed.\n     */\n    argsSchema?: Record<string, any>;\n}\n/**\n * Request for human feedback on a sequence of actions requested by a model.\n *\n * @example\n * ```ts\n * const hitlRequest: HITLRequest = {\n *   actionRequests: [\n *     { name: \"send_email\", args: { to: \"user@example.com\", subject: \"Hello\" } }\n *   ],\n *   reviewConfigs: [\n *     {\n *       actionName: \"send_email\",\n *       allowedDecisions: [\"approve\", \"edit\", \"reject\"],\n *       description: \"Please review the email before sending\"\n *     }\n *   ]\n * };\n * const response = interrupt(hitlRequest);\n * ```\n */\nexport interface HITLRequest {\n    /**\n     * A list of agent actions for human review.\n     */\n    actionRequests: ActionRequest[];\n    /**\n     * Review configuration for all possible actions.\n     */\n    reviewConfigs: ReviewConfig[];\n}\n/**\n * Response when a human approves the action.\n */\nexport interface ApproveDecision {\n    type: \"approve\";\n}\n/**\n * Response when a human edits the action.\n */\nexport interface EditDecision {\n    type: \"edit\";\n    /**\n     * Edited action for the agent to perform.\n     * Ex: for a tool call, a human reviewer can edit the tool name and args.\n     */\n    editedAction: Action;\n}\n/**\n * Response when a human rejects the action.\n */\nexport interface RejectDecision {\n    type: \"reject\";\n    /**\n     * The message sent to the model explaining why the action was rejected.\n     */\n    message?: string;\n}\n/**\n * Union of all possible decision types.\n */\nexport type Decision = ApproveDecision | EditDecision | RejectDecision;\n/**\n * Response payload for a HITLRequest.\n */\nexport interface HITLResponse {\n    /**\n     * The decisions made by the human.\n     */\n    decisions: Decision[];\n}\ndeclare const contextSchema: z.ZodObject<{\n    /**\n     * Mapping of tool name to allowed reviewer responses.\n     * If a tool doesn't have an entry, it's auto-approved by default.\n     *\n     * - `true` -> pause for approval and allow approve/edit/reject decisions\n     * - `false` -> auto-approve (no human review)\n     * - `InterruptOnConfig` -> explicitly specify which decisions are allowed for this tool\n     */\n    interruptOn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{\n        /**\n         * The decisions that are allowed for this action.\n         */\n        allowedDecisions: z.ZodArray<z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>, \"many\">;\n        /**\n         * The description attached to the request for human input.\n         * Can be either:\n         * - A static string describing the approval request\n         * - A callable that dynamically generates the description based on agent state,\n         *   runtime, and tool call information\n         *\n         * @example\n         * Static string description\n         * ```typescript\n         * import type { InterruptOnConfig } from \"langchain\";\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"reject\"],\n         *   description: \"Please review this tool execution\"\n         * };\n         * ```\n         *\n         * @example\n         * Dynamic callable description\n         * ```typescript\n         * import type {\n         *   AgentBuiltInState,\n         *   Runtime,\n         *   DescriptionFactory,\n         *   ToolCall,\n         *   InterruptOnConfig\n         * } from \"langchain\";\n         *\n         * const formatToolDescription: DescriptionFactory = (\n         *   toolCall: ToolCall,\n         *   state: AgentBuiltInState,\n         *   runtime: Runtime<unknown>\n         * ) => {\n         *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n         * };\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"edit\"],\n         *   description: formatToolDescription\n         * };\n         * ```\n         */\n        description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;\n        /**\n         * JSON schema for the arguments associated with the action, if edits are allowed.\n         */\n        argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;\n    }, \"strip\", z.ZodTypeAny, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }>]>>>;\n    /**\n     * Prefix used when constructing human-facing approval messages.\n     * Provides context about the tool call being reviewed; does not change the underlying action.\n     *\n     * Note: This prefix is only applied for tools that do not provide a custom\n     * `description` via their {@link InterruptOnConfig}. If a tool specifies a custom\n     * `description`, that per-tool text is used and this prefix is ignored.\n     */\n    descriptionPrefix: z.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix: string;\n}, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix?: string | undefined;\n}>;\nexport type HumanInTheLoopMiddlewareConfig = InferInteropZodInput<typeof contextSchema>;\n/**\n * Creates a Human-in-the-Loop (HITL) middleware for tool approval and oversight.\n *\n * This middleware intercepts tool calls made by an AI agent and provides human oversight\n * capabilities before execution. It enables selective approval workflows where certain tools\n * require human intervention while others can execute automatically.\n *\n * A invocation result that has been interrupted by the middleware will have a `__interrupt__`\n * property that contains the interrupt request.\n *\n * ```ts\n * import { type HITLRequest, type HITLResponse } from \"langchain\";\n * import { type Interrupt } from \"langchain\";\n *\n * const result = await agent.invoke(request);\n * const interruptRequest = result.__interrupt__?.[0] as Interrupt<HITLRequest>;\n *\n * // Examine the action requests and review configs\n * const actionRequests = interruptRequest.value.actionRequests;\n * const reviewConfigs = interruptRequest.value.reviewConfigs;\n *\n * // Create decisions for each action\n * const resume: HITLResponse = {\n *   decisions: actionRequests.map((action, i) => {\n *     if (action.name === \"calculator\") {\n *       return { type: \"approve\" };\n *     } else if (action.name === \"write_file\") {\n *       return {\n *         type: \"edit\",\n *         editedAction: { name: \"write_file\", args: { filename: \"safe.txt\", content: \"Safe content\" } }\n *       };\n *     }\n *     return { type: \"reject\", message: \"Action not allowed\" };\n *   })\n * };\n *\n * // Resume with decisions\n * await agent.invoke(new Command({ resume }), config);\n * ```\n *\n * ## Features\n *\n * - **Selective Tool Approval**: Configure which tools require human approval\n * - **Multiple Decision Types**: Approve, edit, or reject tool calls\n * - **Asynchronous Workflow**: Uses LangGraph's interrupt mechanism for non-blocking approval\n * - **Custom Approval Messages**: Provide context-specific descriptions for approval requests\n *\n * ## Decision Types\n *\n * When a tool requires approval, the human operator can respond with:\n * - `approve`: Execute the tool with original arguments\n * - `edit`: Modify the tool name and/or arguments before execution\n * - `reject`: Provide a manual response instead of executing the tool\n *\n * @param options - Configuration options for the middleware\n * @param options.interruptOn - Per-tool configuration mapping tool names to their settings\n * @param options.interruptOn[toolName].allowedDecisions - Array of decision types allowed for this tool (e.g., [\"approve\", \"edit\", \"reject\"])\n * @param options.interruptOn[toolName].description - Custom approval message for the tool. Can be either a static string or a callable that dynamically generates the description based on agent state, runtime, and tool call information\n * @param options.interruptOn[toolName].argsSchema - JSON schema for the arguments associated with the action, if edits are allowed\n * @param options.descriptionPrefix - Default prefix for approval messages (default: \"Tool execution requires approval\"). Only used for tools that do not define a custom `description` in their InterruptOnConfig.\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @example\n * Basic usage with selective tool approval\n * ```typescript\n * import { humanInTheLoopMiddleware } from \"langchain\";\n * import { createAgent } from \"langchain\";\n *\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     // Interrupt write_file tool and allow edits or approvals\n *     \"write_file\": {\n *       allowedDecisions: [\"approve\", \"edit\"],\n *       description: \"⚠️ File write operation requires approval\"\n *     },\n *     // Auto-approve read_file tool\n *     \"read_file\": false\n *   }\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4\",\n *   tools: [writeFileTool, readFileTool],\n *   middleware: [hitlMiddleware]\n * });\n * ```\n *\n * @example\n * Handling approval requests\n * ```typescript\n * import { type HITLRequest, type HITLResponse, type Interrupt } from \"langchain\";\n * import { Command } from \"@langchain/langgraph\";\n *\n * // Initial agent invocation\n * const result = await agent.invoke({\n *   messages: [new HumanMessage(\"Write 'Hello' to output.txt\")]\n * }, config);\n *\n * // Check if agent is paused for approval\n * if (result.__interrupt__) {\n *   const interruptRequest = result.__interrupt__?.[0] as Interrupt<HITLRequest>;\n *\n *   // Show tool call details to user\n *   console.log(\"Actions:\", interruptRequest.value.actionRequests);\n *   console.log(\"Review configs:\", interruptRequest.value.reviewConfigs);\n *\n *   // Resume with approval\n *   const resume: HITLResponse = {\n *     decisions: [{ type: \"approve\" }]\n *   };\n *   await agent.invoke(\n *     new Command({ resume }),\n *     config\n *   );\n * }\n * ```\n *\n * @example\n * Different decision types\n * ```typescript\n * import { type HITLResponse } from \"langchain\";\n *\n * // Approve the tool call as-is\n * const resume: HITLResponse = {\n *   decisions: [{ type: \"approve\" }]\n * };\n *\n * // Edit the tool arguments\n * const resume: HITLResponse = {\n *   decisions: [{\n *     type: \"edit\",\n *     editedAction: { name: \"write_file\", args: { filename: \"safe.txt\", content: \"Modified\" } }\n *   }]\n * };\n *\n * // Reject with feedback\n * const resume: HITLResponse = {\n *   decisions: [{\n *     type: \"reject\",\n *     message: \"File operation not allowed in demo mode\"\n *   }]\n * };\n * ```\n *\n * @example\n * Production use case with database operations\n * ```typescript\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     \"execute_sql\": {\n *       allowedDecisions: [\"approve\", \"edit\", \"reject\"],\n *       description: \"🚨 SQL query requires DBA approval\\nPlease review for safety and performance\"\n *     },\n *     \"read_schema\": false,  // Reading metadata is safe\n *     \"delete_records\": {\n *       allowedDecisions: [\"approve\", \"reject\"],\n *       description: \"⛔ DESTRUCTIVE OPERATION - Requires manager approval\"\n *     }\n *   },\n *   descriptionPrefix: \"Database operation pending approval\"\n * });\n * ```\n *\n * @example\n * Using dynamic callable descriptions\n * ```typescript\n * import { type DescriptionFactory, type ToolCall } from \"langchain\";\n * import type { AgentBuiltInState, Runtime } from \"langchain/agents\";\n *\n * // Define a dynamic description factory\n * const formatToolDescription: DescriptionFactory = (\n *   toolCall: ToolCall,\n *   state: AgentBuiltInState,\n *   runtime: Runtime<unknown>\n * ) => {\n *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n * };\n *\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     \"write_file\": {\n *       allowedDecisions: [\"approve\", \"edit\"],\n *       // Use dynamic description that can access tool call, state, and runtime\n *       description: formatToolDescription\n *     },\n *     // Or use an inline function\n *     \"send_email\": {\n *       allowedDecisions: [\"approve\", \"reject\"],\n *       description: (toolCall, state, runtime) => {\n *         const { to, subject } = toolCall.args;\n *         return `Email to ${to}\\nSubject: ${subject}\\n\\nRequires approval before sending`;\n *       }\n *     }\n *   }\n * });\n * ```\n *\n * @remarks\n * - Tool calls are processed in the order they appear in the AI message\n * - Auto-approved tools execute immediately without interruption\n * - Multiple tools requiring approval are bundled into a single interrupt request\n * - The middleware operates in the `afterModel` phase, intercepting before tool execution\n * - Requires a checkpointer to maintain state across interruptions\n *\n * @see {@link createAgent} for agent creation\n * @see {@link Command} for resuming interrupted execution\n * @public\n */\nexport declare function humanInTheLoopMiddleware(options: NonNullable<HumanInTheLoopMiddlewareConfig>): import(\"./types.js\").AgentMiddleware<undefined, z.ZodObject<{\n    /**\n     * Mapping of tool name to allowed reviewer responses.\n     * If a tool doesn't have an entry, it's auto-approved by default.\n     *\n     * - `true` -> pause for approval and allow approve/edit/reject decisions\n     * - `false` -> auto-approve (no human review)\n     * - `InterruptOnConfig` -> explicitly specify which decisions are allowed for this tool\n     */\n    interruptOn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{\n        /**\n         * The decisions that are allowed for this action.\n         */\n        allowedDecisions: z.ZodArray<z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>, \"many\">;\n        /**\n         * The description attached to the request for human input.\n         * Can be either:\n         * - A static string describing the approval request\n         * - A callable that dynamically generates the description based on agent state,\n         *   runtime, and tool call information\n         *\n         * @example\n         * Static string description\n         * ```typescript\n         * import type { InterruptOnConfig } from \"langchain\";\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"reject\"],\n         *   description: \"Please review this tool execution\"\n         * };\n         * ```\n         *\n         * @example\n         * Dynamic callable description\n         * ```typescript\n         * import type {\n         *   AgentBuiltInState,\n         *   Runtime,\n         *   DescriptionFactory,\n         *   ToolCall,\n         *   InterruptOnConfig\n         * } from \"langchain\";\n         *\n         * const formatToolDescription: DescriptionFactory = (\n         *   toolCall: ToolCall,\n         *   state: AgentBuiltInState,\n         *   runtime: Runtime<unknown>\n         * ) => {\n         *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n         * };\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"edit\"],\n         *   description: formatToolDescription\n         * };\n         * ```\n         */\n        description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;\n        /**\n         * JSON schema for the arguments associated with the action, if edits are allowed.\n         */\n        argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;\n    }, \"strip\", z.ZodTypeAny, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }>]>>>;\n    /**\n     * Prefix used when constructing human-facing approval messages.\n     * Provides context about the tool call being reviewed; does not change the underlying action.\n     *\n     * Note: This prefix is only applied for tools that do not provide a custom\n     * `description` via their {@link InterruptOnConfig}. If a tool specifies a custom\n     * `description`, that per-tool text is used and this prefix is ignored.\n     */\n    descriptionPrefix: z.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix: string;\n}, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix?: string | undefined;\n}>, any>;\nexport {};\n//# sourceMappingURL=hitl.d.ts.map"],"mappings":"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"}
+{"version":3,"file":"hitl.d.cts","names":["z","ToolCall","InferInteropZodInput","AgentBuiltInState","Runtime","DescriptionFunctionSchema","Record","ZodTypeDef","ZodType","ZodUnknown","ZodTuple","ZodString","ZodPromise","ZodUnion","ZodFunction","DescriptionFactory","infer","DecisionType","ZodEnum","InterruptOnConfigSchema","ZodArray","ZodOptional","ZodAny","ZodRecord","ZodTypeAny","Promise","ZodObject","InterruptOnConfig","input","Action","ActionRequest","ReviewConfig","HITLRequest","ApproveDecision","EditDecision","RejectDecision","Decision","HITLResponse","contextSchema","ZodBoolean","ZodDefault","HumanInTheLoopMiddlewareConfig","humanInTheLoopMiddleware","NonNullable","__types_js7","AgentMiddleware"],"sources":["../../../src/agents/middleware/hitl.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { ToolCall } from \"@langchain/core/messages\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\nimport type { AgentBuiltInState, Runtime } from \"../runtime.js\";\ndeclare const DescriptionFunctionSchema: z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>;\n/**\n * Function type that dynamically generates a description for a tool call approval request.\n *\n * @param toolCall - The tool call being reviewed\n * @param state - The current agent state\n * @param runtime - The agent runtime context\n * @returns A string description or Promise that resolves to a string description\n *\n * @example\n * ```typescript\n * import { type DescriptionFactory, type ToolCall } from \"langchain\";\n *\n * const descriptionFactory: DescriptionFactory = (toolCall, state, runtime) => {\n *   return `Please review: ${toolCall.name}(${JSON.stringify(toolCall.args)})`;\n * };\n * ```\n */\nexport type DescriptionFactory = z.infer<typeof DescriptionFunctionSchema>;\ndeclare const DecisionType: z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>;\nexport type DecisionType = z.infer<typeof DecisionType>;\ndeclare const InterruptOnConfigSchema: z.ZodObject<{\n    /**\n     * The decisions that are allowed for this action.\n     */\n    allowedDecisions: z.ZodArray<z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>, \"many\">;\n    /**\n     * The description attached to the request for human input.\n     * Can be either:\n     * - A static string describing the approval request\n     * - A callable that dynamically generates the description based on agent state,\n     *   runtime, and tool call information\n     *\n     * @example\n     * Static string description\n     * ```typescript\n     * import type { InterruptOnConfig } from \"langchain\";\n     *\n     * const config: InterruptOnConfig = {\n     *   allowedDecisions: [\"approve\", \"reject\"],\n     *   description: \"Please review this tool execution\"\n     * };\n     * ```\n     *\n     * @example\n     * Dynamic callable description\n     * ```typescript\n     * import type {\n     *   AgentBuiltInState,\n     *   Runtime,\n     *   DescriptionFactory,\n     *   ToolCall,\n     *   InterruptOnConfig\n     * } from \"langchain\";\n     *\n     * const formatToolDescription: DescriptionFactory = (\n     *   toolCall: ToolCall,\n     *   state: AgentBuiltInState,\n     *   runtime: Runtime<unknown>\n     * ) => {\n     *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n     * };\n     *\n     * const config: InterruptOnConfig = {\n     *   allowedDecisions: [\"approve\", \"edit\"],\n     *   description: formatToolDescription\n     * };\n     * ```\n     */\n    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;\n    /**\n     * JSON schema for the arguments associated with the action, if edits are allowed.\n     */\n    argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;\n}, \"strip\", z.ZodTypeAny, {\n    allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n    description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n    argsSchema?: Record<string, any> | undefined;\n}, {\n    allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n    description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n    argsSchema?: Record<string, any> | undefined;\n}>;\nexport type InterruptOnConfig = z.input<typeof InterruptOnConfigSchema>;\n/**\n * Represents an action with a name and arguments.\n */\nexport interface Action {\n    /**\n     * The type or name of action being requested (e.g., \"add_numbers\").\n     */\n    name: string;\n    /**\n     * Key-value pairs of arguments needed for the action (e.g., {\"a\": 1, \"b\": 2}).\n     */\n    args: Record<string, any>;\n}\n/**\n * Represents an action request with a name, arguments, and description.\n */\nexport interface ActionRequest {\n    /**\n     * The name of the action being requested.\n     */\n    name: string;\n    /**\n     * Key-value pairs of arguments needed for the action (e.g., {\"a\": 1, \"b\": 2}).\n     */\n    args: Record<string, any>;\n    /**\n     * The description of the action to be reviewed.\n     */\n    description?: string;\n}\n/**\n * Policy for reviewing a HITL request.\n */\nexport interface ReviewConfig {\n    /**\n     * Name of the action associated with this review configuration.\n     */\n    actionName: string;\n    /**\n     * The decisions that are allowed for this request.\n     */\n    allowedDecisions: DecisionType[];\n    /**\n     * JSON schema for the arguments associated with the action, if edits are allowed.\n     */\n    argsSchema?: Record<string, any>;\n}\n/**\n * Request for human feedback on a sequence of actions requested by a model.\n *\n * @example\n * ```ts\n * const hitlRequest: HITLRequest = {\n *   actionRequests: [\n *     { name: \"send_email\", args: { to: \"user@example.com\", subject: \"Hello\" } }\n *   ],\n *   reviewConfigs: [\n *     {\n *       actionName: \"send_email\",\n *       allowedDecisions: [\"approve\", \"edit\", \"reject\"],\n *       description: \"Please review the email before sending\"\n *     }\n *   ]\n * };\n * const response = interrupt(hitlRequest);\n * ```\n */\nexport interface HITLRequest {\n    /**\n     * A list of agent actions for human review.\n     */\n    actionRequests: ActionRequest[];\n    /**\n     * Review configuration for all possible actions.\n     */\n    reviewConfigs: ReviewConfig[];\n}\n/**\n * Response when a human approves the action.\n */\nexport interface ApproveDecision {\n    type: \"approve\";\n}\n/**\n * Response when a human edits the action.\n */\nexport interface EditDecision {\n    type: \"edit\";\n    /**\n     * Edited action for the agent to perform.\n     * Ex: for a tool call, a human reviewer can edit the tool name and args.\n     */\n    editedAction: Action;\n}\n/**\n * Response when a human rejects the action.\n */\nexport interface RejectDecision {\n    type: \"reject\";\n    /**\n     * The message sent to the model explaining why the action was rejected.\n     */\n    message?: string;\n}\n/**\n * Union of all possible decision types.\n */\nexport type Decision = ApproveDecision | EditDecision | RejectDecision;\n/**\n * Response payload for a HITLRequest.\n */\nexport interface HITLResponse {\n    /**\n     * The decisions made by the human.\n     */\n    decisions: Decision[];\n}\ndeclare const contextSchema: z.ZodObject<{\n    /**\n     * Mapping of tool name to allowed reviewer responses.\n     * If a tool doesn't have an entry, it's auto-approved by default.\n     *\n     * - `true` -> pause for approval and allow approve/edit/reject decisions\n     * - `false` -> auto-approve (no human review)\n     * - `InterruptOnConfig` -> explicitly specify which decisions are allowed for this tool\n     */\n    interruptOn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{\n        /**\n         * The decisions that are allowed for this action.\n         */\n        allowedDecisions: z.ZodArray<z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>, \"many\">;\n        /**\n         * The description attached to the request for human input.\n         * Can be either:\n         * - A static string describing the approval request\n         * - A callable that dynamically generates the description based on agent state,\n         *   runtime, and tool call information\n         *\n         * @example\n         * Static string description\n         * ```typescript\n         * import type { InterruptOnConfig } from \"langchain\";\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"reject\"],\n         *   description: \"Please review this tool execution\"\n         * };\n         * ```\n         *\n         * @example\n         * Dynamic callable description\n         * ```typescript\n         * import type {\n         *   AgentBuiltInState,\n         *   Runtime,\n         *   DescriptionFactory,\n         *   ToolCall,\n         *   InterruptOnConfig\n         * } from \"langchain\";\n         *\n         * const formatToolDescription: DescriptionFactory = (\n         *   toolCall: ToolCall,\n         *   state: AgentBuiltInState,\n         *   runtime: Runtime<unknown>\n         * ) => {\n         *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n         * };\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"edit\"],\n         *   description: formatToolDescription\n         * };\n         * ```\n         */\n        description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;\n        /**\n         * JSON schema for the arguments associated with the action, if edits are allowed.\n         */\n        argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;\n    }, \"strip\", z.ZodTypeAny, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }>]>>>;\n    /**\n     * Prefix used when constructing human-facing approval messages.\n     * Provides context about the tool call being reviewed; does not change the underlying action.\n     *\n     * Note: This prefix is only applied for tools that do not provide a custom\n     * `description` via their {@link InterruptOnConfig}. If a tool specifies a custom\n     * `description`, that per-tool text is used and this prefix is ignored.\n     */\n    descriptionPrefix: z.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix: string;\n}, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix?: string | undefined;\n}>;\nexport type HumanInTheLoopMiddlewareConfig = InferInteropZodInput<typeof contextSchema>;\n/**\n * Creates a Human-in-the-Loop (HITL) middleware for tool approval and oversight.\n *\n * This middleware intercepts tool calls made by an AI agent and provides human oversight\n * capabilities before execution. It enables selective approval workflows where certain tools\n * require human intervention while others can execute automatically.\n *\n * A invocation result that has been interrupted by the middleware will have a `__interrupt__`\n * property that contains the interrupt request.\n *\n * ```ts\n * import { type HITLRequest, type HITLResponse } from \"langchain\";\n * import { type Interrupt } from \"langchain\";\n *\n * const result = await agent.invoke(request);\n * const interruptRequest = result.__interrupt__?.[0] as Interrupt<HITLRequest>;\n *\n * // Examine the action requests and review configs\n * const actionRequests = interruptRequest.value.actionRequests;\n * const reviewConfigs = interruptRequest.value.reviewConfigs;\n *\n * // Create decisions for each action\n * const resume: HITLResponse = {\n *   decisions: actionRequests.map((action, i) => {\n *     if (action.name === \"calculator\") {\n *       return { type: \"approve\" };\n *     } else if (action.name === \"write_file\") {\n *       return {\n *         type: \"edit\",\n *         editedAction: { name: \"write_file\", args: { filename: \"safe.txt\", content: \"Safe content\" } }\n *       };\n *     }\n *     return { type: \"reject\", message: \"Action not allowed\" };\n *   })\n * };\n *\n * // Resume with decisions\n * await agent.invoke(new Command({ resume }), config);\n * ```\n *\n * ## Features\n *\n * - **Selective Tool Approval**: Configure which tools require human approval\n * - **Multiple Decision Types**: Approve, edit, or reject tool calls\n * - **Asynchronous Workflow**: Uses LangGraph's interrupt mechanism for non-blocking approval\n * - **Custom Approval Messages**: Provide context-specific descriptions for approval requests\n *\n * ## Decision Types\n *\n * When a tool requires approval, the human operator can respond with:\n * - `approve`: Execute the tool with original arguments\n * - `edit`: Modify the tool name and/or arguments before execution\n * - `reject`: Provide a manual response instead of executing the tool\n *\n * @param options - Configuration options for the middleware\n * @param options.interruptOn - Per-tool configuration mapping tool names to their settings\n * @param options.interruptOn[toolName].allowedDecisions - Array of decision types allowed for this tool (e.g., [\"approve\", \"edit\", \"reject\"])\n * @param options.interruptOn[toolName].description - Custom approval message for the tool. Can be either a static string or a callable that dynamically generates the description based on agent state, runtime, and tool call information\n * @param options.interruptOn[toolName].argsSchema - JSON schema for the arguments associated with the action, if edits are allowed\n * @param options.descriptionPrefix - Default prefix for approval messages (default: \"Tool execution requires approval\"). Only used for tools that do not define a custom `description` in their InterruptOnConfig.\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @example\n * Basic usage with selective tool approval\n * ```typescript\n * import { humanInTheLoopMiddleware } from \"langchain\";\n * import { createAgent } from \"langchain\";\n *\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     // Interrupt write_file tool and allow edits or approvals\n *     \"write_file\": {\n *       allowedDecisions: [\"approve\", \"edit\"],\n *       description: \"⚠️ File write operation requires approval\"\n *     },\n *     // Auto-approve read_file tool\n *     \"read_file\": false\n *   }\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4\",\n *   tools: [writeFileTool, readFileTool],\n *   middleware: [hitlMiddleware]\n * });\n * ```\n *\n * @example\n * Handling approval requests\n * ```typescript\n * import { type HITLRequest, type HITLResponse, type Interrupt } from \"langchain\";\n * import { Command } from \"@langchain/langgraph\";\n *\n * // Initial agent invocation\n * const result = await agent.invoke({\n *   messages: [new HumanMessage(\"Write 'Hello' to output.txt\")]\n * }, config);\n *\n * // Check if agent is paused for approval\n * if (result.__interrupt__) {\n *   const interruptRequest = result.__interrupt__?.[0] as Interrupt<HITLRequest>;\n *\n *   // Show tool call details to user\n *   console.log(\"Actions:\", interruptRequest.value.actionRequests);\n *   console.log(\"Review configs:\", interruptRequest.value.reviewConfigs);\n *\n *   // Resume with approval\n *   const resume: HITLResponse = {\n *     decisions: [{ type: \"approve\" }]\n *   };\n *   await agent.invoke(\n *     new Command({ resume }),\n *     config\n *   );\n * }\n * ```\n *\n * @example\n * Different decision types\n * ```typescript\n * import { type HITLResponse } from \"langchain\";\n *\n * // Approve the tool call as-is\n * const resume: HITLResponse = {\n *   decisions: [{ type: \"approve\" }]\n * };\n *\n * // Edit the tool arguments\n * const resume: HITLResponse = {\n *   decisions: [{\n *     type: \"edit\",\n *     editedAction: { name: \"write_file\", args: { filename: \"safe.txt\", content: \"Modified\" } }\n *   }]\n * };\n *\n * // Reject with feedback\n * const resume: HITLResponse = {\n *   decisions: [{\n *     type: \"reject\",\n *     message: \"File operation not allowed in demo mode\"\n *   }]\n * };\n * ```\n *\n * @example\n * Production use case with database operations\n * ```typescript\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     \"execute_sql\": {\n *       allowedDecisions: [\"approve\", \"edit\", \"reject\"],\n *       description: \"🚨 SQL query requires DBA approval\\nPlease review for safety and performance\"\n *     },\n *     \"read_schema\": false,  // Reading metadata is safe\n *     \"delete_records\": {\n *       allowedDecisions: [\"approve\", \"reject\"],\n *       description: \"⛔ DESTRUCTIVE OPERATION - Requires manager approval\"\n *     }\n *   },\n *   descriptionPrefix: \"Database operation pending approval\"\n * });\n * ```\n *\n * @example\n * Using dynamic callable descriptions\n * ```typescript\n * import { type DescriptionFactory, type ToolCall } from \"langchain\";\n * import type { AgentBuiltInState, Runtime } from \"langchain/agents\";\n *\n * // Define a dynamic description factory\n * const formatToolDescription: DescriptionFactory = (\n *   toolCall: ToolCall,\n *   state: AgentBuiltInState,\n *   runtime: Runtime<unknown>\n * ) => {\n *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n * };\n *\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     \"write_file\": {\n *       allowedDecisions: [\"approve\", \"edit\"],\n *       // Use dynamic description that can access tool call, state, and runtime\n *       description: formatToolDescription\n *     },\n *     // Or use an inline function\n *     \"send_email\": {\n *       allowedDecisions: [\"approve\", \"reject\"],\n *       description: (toolCall, state, runtime) => {\n *         const { to, subject } = toolCall.args;\n *         return `Email to ${to}\\nSubject: ${subject}\\n\\nRequires approval before sending`;\n *       }\n *     }\n *   }\n * });\n * ```\n *\n * @remarks\n * - Tool calls are processed in the order they appear in the AI message\n * - Auto-approved tools execute immediately without interruption\n * - Multiple tools requiring approval are bundled into a single interrupt request\n * - The middleware operates in the `afterModel` phase, intercepting before tool execution\n * - Requires a checkpointer to maintain state across interruptions\n *\n * @see {@link createAgent} for agent creation\n * @see {@link Command} for resuming interrupted execution\n * @public\n */\nexport declare function humanInTheLoopMiddleware(options: NonNullable<HumanInTheLoopMiddlewareConfig>): import(\"./types.js\").AgentMiddleware<undefined, z.ZodObject<{\n    /**\n     * Mapping of tool name to allowed reviewer responses.\n     * If a tool doesn't have an entry, it's auto-approved by default.\n     *\n     * - `true` -> pause for approval and allow approve/edit/reject decisions\n     * - `false` -> auto-approve (no human review)\n     * - `InterruptOnConfig` -> explicitly specify which decisions are allowed for this tool\n     */\n    interruptOn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{\n        /**\n         * The decisions that are allowed for this action.\n         */\n        allowedDecisions: z.ZodArray<z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>, \"many\">;\n        /**\n         * The description attached to the request for human input.\n         * Can be either:\n         * - A static string describing the approval request\n         * - A callable that dynamically generates the description based on agent state,\n         *   runtime, and tool call information\n         *\n         * @example\n         * Static string description\n         * ```typescript\n         * import type { InterruptOnConfig } from \"langchain\";\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"reject\"],\n         *   description: \"Please review this tool execution\"\n         * };\n         * ```\n         *\n         * @example\n         * Dynamic callable description\n         * ```typescript\n         * import type {\n         *   AgentBuiltInState,\n         *   Runtime,\n         *   DescriptionFactory,\n         *   ToolCall,\n         *   InterruptOnConfig\n         * } from \"langchain\";\n         *\n         * const formatToolDescription: DescriptionFactory = (\n         *   toolCall: ToolCall,\n         *   state: AgentBuiltInState,\n         *   runtime: Runtime<unknown>\n         * ) => {\n         *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n         * };\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"edit\"],\n         *   description: formatToolDescription\n         * };\n         * ```\n         */\n        description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;\n        /**\n         * JSON schema for the arguments associated with the action, if edits are allowed.\n         */\n        argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;\n    }, \"strip\", z.ZodTypeAny, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }>]>>>;\n    /**\n     * Prefix used when constructing human-facing approval messages.\n     * Provides context about the tool call being reviewed; does not change the underlying action.\n     *\n     * Note: This prefix is only applied for tools that do not provide a custom\n     * `description` via their {@link InterruptOnConfig}. If a tool specifies a custom\n     * `description`, that per-tool text is used and this prefix is ignored.\n     */\n    descriptionPrefix: z.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix: string;\n}, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix?: string | undefined;\n}>, any>;\nexport {};\n//# sourceMappingURL=hitl.d.ts.map"],"mappings":"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"}

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

@@ -1,5 +1,5 @@
 import { createMiddleware } from "../middleware.cjs";
-import * as _langchain_core_language_models_base0 from "@langchain/core/language_models/base";
+import * as _langchain_core_language_models_base7 from "@langchain/core/language_models/base";
 import { BaseLanguageModel } from "@langchain/core/language_models/base";
 import { InferInteropZodInput } from "@langchain/core/utils/types";
 import { z } from "zod/v3";
@@ -12,7 +12,7 @@ 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_base0.BaseLanguageModelCallOptions>, z.ZodTypeDef, BaseLanguageModel<unknown, _langchain_core_language_models_base0.BaseLanguageModelCallOptions>>]>>;
+  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.
    */
@@ -28,12 +28,12 @@ declare const LLMToolSelectorOptionsSchema: z.ZodObject<{
    */
   alwaysInclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
-  model?: string | BaseLanguageModel<unknown, _langchain_core_language_models_base0.BaseLanguageModelCallOptions> | undefined;
+  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_base0.BaseLanguageModelCallOptions> | undefined;
+  model?: string | BaseLanguageModel<unknown, _langchain_core_language_models_base7.BaseLanguageModelCallOptions> | undefined;
   systemPrompt?: string | undefined;
   maxTools?: number | undefined;
   alwaysInclude?: string[] | undefined;

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

@@ -1 +1 @@
-{"version":3,"file":"llmToolSelector.d.cts","names":["z","BaseLanguageModel","InferInteropZodInput","createMiddleware","LLMToolSelectorOptionsSchema","ZodString","_langchain_core_language_models_base0","BaseLanguageModelCallOptions","ZodTypeDef","ZodType","ZodUnion","ZodOptional","ZodNumber","ZodArray","ZodTypeAny","ZodObject","LLMToolSelectorConfig","llmToolSelectorMiddleware","ReturnType"],"sources":["../../../src/agents/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//# sourceMappingURL=llmToolSelector.d.ts.map"],"mappings":";;;;;;;;;;AAOqBI,cAAAA,4BA6BnB,EA7BiDJ,CAAAA,CAAEe,SA6BnD,CAAA;EAzBqCV;;;EAAgIG,KAAAA,EAA5JR,CAAAA,CAAEW,WAA0JH,CAA9IR,CAAAA,CAAEU,QAA4IF,CAAAA,CAAlIR,CAAAA,CAAEK,SAAgIG,EAArHR,CAAAA,CAAES,OAAmHD,CAA3GP,iBAA2GO,CAAAA,OAAAA,EAAvHF,qCAAAA,CAAsFC,4BAAAA,CAAiCC,EAAFR,CAAAA,CAAEQ,UAAAA,EAAYP,iBAAZO,CAAAA,OAAAA,EAAUF,qCAAAA,CAA4EC,4BAAAA,CAAtFC,CAAAA,CAAAA,CAAAA,CAAAA;EAAUF;;;EAAtJI,YAAAA,EAITV,CAAAA,CAAEW,WAJOD,CAIKV,CAAAA,CAAEK,SAJPK,CAAAA;EAAdC;;;;EASGA,QAAAA,EAAFX,CAAAA,CAAEW,WAAAA,CAAYX,CAAAA,CAAEY,SAAdD,CAAAA;EAK8BN;;;;EACtBC,aAAAA,EADLN,CAAAA,CAAEW,WACGL,CADSN,CAAAA,CAAEa,QAE4DN,CAFnDP,CAAAA,CAAEK,SAEiDE,EAAAA,MAAAA,CAAAA,CAAAA;CAA1EN,EAAAA,OAAAA,EADTD,CAAAA,CAAEc,UACOb,EAAAA;EAAiBK,KAAAA,CAAAA,EAAAA,MAAAA,GAAjBL,iBAAiBK,CAKyDC,OAAAA,EANvED,qCAAAA,CACuEC,4BAAAA,CAKAA,GAAAA,SAAAA;EAA1EN,YAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAzBgCc,QAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAS,aAAA,CAAA,EAAA,MAAA,EAAA,GAAA,SAAA;AA8B9D,CAAA,EAAA;EAuCwBE,KAAAA,CAAAA,EAAAA,MAAAA,GA5CHhB,iBA4C4B,CAAA,OAAA,EAjDXK,qCAAAA,CAKyDC,4BAAAA,CA4C9C,GAAA,SAAA;EAAUS,YAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAA0Cb,QAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAlBe,aAAAA,CAAAA,EAAAA,MAAAA,EAAAA,GAAAA,SAAAA;AAAU,CAAA,CAAA;KAvCjFF,qBAAAA,GAAwBd,4BAA4BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuCxCa,yBAAAA,UAAmCD,wBAAwBE,kBAAkBf"}
+{"version":3,"file":"llmToolSelector.d.cts","names":["z","BaseLanguageModel","InferInteropZodInput","createMiddleware","LLMToolSelectorOptionsSchema","ZodString","_langchain_core_language_models_base7","BaseLanguageModelCallOptions","ZodTypeDef","ZodType","ZodUnion","ZodOptional","ZodNumber","ZodArray","ZodTypeAny","ZodObject","LLMToolSelectorConfig","llmToolSelectorMiddleware","ReturnType"],"sources":["../../../src/agents/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//# sourceMappingURL=llmToolSelector.d.ts.map"],"mappings":";;;;;;;;;;AAOqBI,cAAAA,4BA6BnB,EA7BiDJ,CAAAA,CAAEe,SA6BnD,CAAA;EAzBqCV;;;EAAgIG,KAAAA,EAA5JR,CAAAA,CAAEW,WAA0JH,CAA9IR,CAAAA,CAAEU,QAA4IF,CAAAA,CAAlIR,CAAAA,CAAEK,SAAgIG,EAArHR,CAAAA,CAAES,OAAmHD,CAA3GP,iBAA2GO,CAAAA,OAAAA,EAAvHF,qCAAAA,CAAsFC,4BAAAA,CAAiCC,EAAFR,CAAAA,CAAEQ,UAAAA,EAAYP,iBAAZO,CAAAA,OAAAA,EAAUF,qCAAAA,CAA4EC,4BAAAA,CAAtFC,CAAAA,CAAAA,CAAAA,CAAAA;EAAUF;;;EAAtJI,YAAAA,EAITV,CAAAA,CAAEW,WAJOD,CAIKV,CAAAA,CAAEK,SAJPK,CAAAA;EAAdC;;;;EASGA,QAAAA,EAAFX,CAAAA,CAAEW,WAAAA,CAAYX,CAAAA,CAAEY,SAAdD,CAAAA;EAK8BN;;;;EACtBC,aAAAA,EADLN,CAAAA,CAAEW,WACGL,CADSN,CAAAA,CAAEa,QAE4DN,CAFnDP,CAAAA,CAAEK,SAEiDE,EAAAA,MAAAA,CAAAA,CAAAA;CAA1EN,EAAAA,OAAAA,EADTD,CAAAA,CAAEc,UACOb,EAAAA;EAAiBK,KAAAA,CAAAA,EAAAA,MAAAA,GAAjBL,iBAAiBK,CAKyDC,OAAAA,EANvED,qCAAAA,CACuEC,4BAAAA,CAKAA,GAAAA,SAAAA;EAA1EN,YAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAzBgCc,QAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAS,aAAA,CAAA,EAAA,MAAA,EAAA,GAAA,SAAA;AA8B9D,CAAA,EAAA;EAuCwBE,KAAAA,CAAAA,EAAAA,MAAAA,GA5CHhB,iBA4C4B,CAAA,OAAA,EAjDXK,qCAAAA,CAKyDC,4BAAAA,CA4C9C,GAAA,SAAA;EAAUS,YAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAA0Cb,QAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAlBe,aAAAA,CAAAA,EAAAA,MAAAA,EAAAA,GAAAA,SAAAA;AAAU,CAAA,CAAA;KAvCjFF,qBAAAA,GAAwBd,4BAA4BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuCxCa,yBAAAA,UAAmCD,wBAAwBE,kBAAkBf"}

package/dist/agents/middleware/modelCallLimit.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"modelCallLimit.d.cts","names":["z","InferInteropZodInput","contextSchema","ZodNumber","ZodOptional","ZodEnum","ZodTypeAny","ZodObject","ModelCallLimitMiddlewareConfig","Partial","modelCallLimitMiddleware","ZodDefault","__types_js13","AgentMiddleware"],"sources":["../../../src/agents/middleware/modelCallLimit.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\ndeclare const contextSchema: z.ZodObject<{\n    /**\n     * The maximum number of model calls allowed per thread.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The maximum number of model calls allowed per run.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The behavior to take when the limit is exceeded.\n     * - \"error\" will throw an error and stop the agent.\n     * - \"end\" will end the agent.\n     * @default \"end\"\n     */\n    exitBehavior: z.ZodOptional<z.ZodEnum<[\"error\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"error\" | undefined;\n}, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"error\" | undefined;\n}>;\nexport type ModelCallLimitMiddlewareConfig = Partial<InferInteropZodInput<typeof contextSchema>>;\n/**\n * Creates a middleware to limit the number of model calls at both thread and run levels.\n *\n * This middleware helps prevent excessive model API calls by enforcing limits on how many\n * times the model can be invoked. It supports two types of limits:\n *\n * - **Thread-level limit**: Restricts the total number of model calls across an entire conversation thread\n * - **Run-level limit**: Restricts the number of model calls within a single agent run/invocation\n *\n * ## How It Works\n *\n * The middleware intercepts model requests before they are sent and checks the current call counts\n * against the configured limits. If either limit is exceeded, it throws a `ModelCallLimitMiddlewareError`\n * to stop execution and prevent further API calls.\n *\n * ## Use Cases\n *\n * - **Cost Control**: Prevent runaway costs from excessive model calls in production\n * - **Testing**: Ensure agents don't make too many calls during development/testing\n * - **Safety**: Limit potential infinite loops or recursive agent behaviors\n * - **Rate Limiting**: Enforce organizational policies on model usage per conversation\n *\n * @param middlewareOptions - Configuration options for the call limits\n * @param middlewareOptions.threadLimit - Maximum number of model calls allowed per thread (optional)\n * @param middlewareOptions.runLimit - Maximum number of model calls allowed per run (optional)\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @throws {ModelCallLimitMiddlewareError} When either the thread or run limit is exceeded\n *\n * @example\n * ```typescript\n * import { createAgent, modelCallLimitMiddleware } from \"langchain\";\n *\n * // Limit to 10 calls per thread and 3 calls per run\n * const agent = createAgent({\n *   model: \"openai:gpt-4o-mini\",\n *   tools: [myTool],\n *   middleware: [\n *     modelCallLimitMiddleware({\n *       threadLimit: 10,\n *       runLimit: 3\n *     })\n *   ]\n * });\n * ```\n *\n * @example\n * ```typescript\n * // Limits can also be configured at runtime via context\n * const result = await agent.invoke(\n *   { messages: [\"Hello\"] },\n *   {\n *     configurable: {\n *       threadLimit: 5  // Override the default limit for this run\n *     }\n *   }\n * );\n * ```\n */\nexport declare function modelCallLimitMiddleware(middlewareOptions?: ModelCallLimitMiddlewareConfig): import(\"./types.js\").AgentMiddleware<z.ZodObject<{\n    threadModelCallCount: z.ZodDefault<z.ZodNumber>;\n    runModelCallCount: z.ZodDefault<z.ZodNumber>;\n}, \"strip\", z.ZodTypeAny, {\n    threadModelCallCount: number;\n    runModelCallCount: number;\n}, {\n    threadModelCallCount?: number | undefined;\n    runModelCallCount?: number | undefined;\n}>, z.ZodObject<{\n    /**\n     * The maximum number of model calls allowed per thread.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The maximum number of model calls allowed per run.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The behavior to take when the limit is exceeded.\n     * - \"error\" will throw an error and stop the agent.\n     * - \"end\" will end the agent.\n     * @default \"end\"\n     */\n    exitBehavior: z.ZodOptional<z.ZodEnum<[\"error\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"error\" | undefined;\n}, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"error\" | undefined;\n}>, any>;\nexport {};\n//# sourceMappingURL=modelCallLimit.d.ts.map"],"mappings":";;;;;cAEcE,eAAeF,CAAAA,CAAEO;;;AADoC;EAKlCJ,WAAAA,EAAhBH,CAAAA,CAAEI,WAAcD,CAAFH,CAAAA,CAAEG,SAAAA,CAAAA;EAAdC;;;EAWeC,QAAAA,EAPpBL,CAAAA,CAAEI,WAOkBC,CAPNL,CAAAA,CAAEG,SAOIE,CAAAA;EAAdD;;;AAfoB;AAyBxC;;EAAqDH,YAAAA,EAVnCD,CAAAA,CAAEI,WAUiCH,CAVrBD,CAAAA,CAAEK,OAUmBJ,CAAAA,CAAAA,OAAAA,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA;CAARQ,EAAAA,OAAAA,EATjCT,CAAAA,CAAEM,UAS+BG,EAAAA;EAAO,WAAA,CAAA,EAAA,MAAA,GAAA,SAAA;EA6D5BC,QAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAwB;EAAqBF,YAAAA,CAAAA,EAAAA,KAAAA,GAAAA,OAAAA,GAAAA,SAAAA;CAC9BR,EAAEG;EAAbQ,WAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EACUR,QAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAbQ,YAAAA,CAAAA,EAAAA,KAAAA,GAAAA,OAAAA,GAAAA,SAAAA;CACbX,CAAAA;AAHiIO,KA7DjIC,8BAAAA,GAAiCC,OA6DgGF,CA7DxFN,oBA6DwFM,CAAAA,OA7D5DL,aA6D4DK,CAAAA,CAAAA;;;;;;;;;;AAAH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAlHG,wBAAAA,qBAA6CF,iDAAsER,CAAAA,CAAEO;wBACnHP,CAAAA,CAAEW,WAAWX,CAAAA,CAAEG;qBAClBH,CAAAA,CAAEW,WAAWX,CAAAA,CAAEG;YAC1BH,CAAAA,CAAEM;;;;;;IAMVN,CAAAA,CAAEO;;;;eAIWP,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;;;;YAInBH,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;;;;;;;gBAOZH,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEK;YACtBL,CAAAA,CAAEM"}
+{"version":3,"file":"modelCallLimit.d.cts","names":["z","InferInteropZodInput","contextSchema","ZodNumber","ZodOptional","ZodEnum","ZodTypeAny","ZodObject","ModelCallLimitMiddlewareConfig","Partial","modelCallLimitMiddleware","ZodDefault","__types_js12","AgentMiddleware"],"sources":["../../../src/agents/middleware/modelCallLimit.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\ndeclare const contextSchema: z.ZodObject<{\n    /**\n     * The maximum number of model calls allowed per thread.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The maximum number of model calls allowed per run.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The behavior to take when the limit is exceeded.\n     * - \"error\" will throw an error and stop the agent.\n     * - \"end\" will end the agent.\n     * @default \"end\"\n     */\n    exitBehavior: z.ZodOptional<z.ZodEnum<[\"error\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"error\" | undefined;\n}, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"error\" | undefined;\n}>;\nexport type ModelCallLimitMiddlewareConfig = Partial<InferInteropZodInput<typeof contextSchema>>;\n/**\n * Creates a middleware to limit the number of model calls at both thread and run levels.\n *\n * This middleware helps prevent excessive model API calls by enforcing limits on how many\n * times the model can be invoked. It supports two types of limits:\n *\n * - **Thread-level limit**: Restricts the total number of model calls across an entire conversation thread\n * - **Run-level limit**: Restricts the number of model calls within a single agent run/invocation\n *\n * ## How It Works\n *\n * The middleware intercepts model requests before they are sent and checks the current call counts\n * against the configured limits. If either limit is exceeded, it throws a `ModelCallLimitMiddlewareError`\n * to stop execution and prevent further API calls.\n *\n * ## Use Cases\n *\n * - **Cost Control**: Prevent runaway costs from excessive model calls in production\n * - **Testing**: Ensure agents don't make too many calls during development/testing\n * - **Safety**: Limit potential infinite loops or recursive agent behaviors\n * - **Rate Limiting**: Enforce organizational policies on model usage per conversation\n *\n * @param middlewareOptions - Configuration options for the call limits\n * @param middlewareOptions.threadLimit - Maximum number of model calls allowed per thread (optional)\n * @param middlewareOptions.runLimit - Maximum number of model calls allowed per run (optional)\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @throws {ModelCallLimitMiddlewareError} When either the thread or run limit is exceeded\n *\n * @example\n * ```typescript\n * import { createAgent, modelCallLimitMiddleware } from \"langchain\";\n *\n * // Limit to 10 calls per thread and 3 calls per run\n * const agent = createAgent({\n *   model: \"openai:gpt-4o-mini\",\n *   tools: [myTool],\n *   middleware: [\n *     modelCallLimitMiddleware({\n *       threadLimit: 10,\n *       runLimit: 3\n *     })\n *   ]\n * });\n * ```\n *\n * @example\n * ```typescript\n * // Limits can also be configured at runtime via context\n * const result = await agent.invoke(\n *   { messages: [\"Hello\"] },\n *   {\n *     configurable: {\n *       threadLimit: 5  // Override the default limit for this run\n *     }\n *   }\n * );\n * ```\n */\nexport declare function modelCallLimitMiddleware(middlewareOptions?: ModelCallLimitMiddlewareConfig): import(\"./types.js\").AgentMiddleware<z.ZodObject<{\n    threadModelCallCount: z.ZodDefault<z.ZodNumber>;\n    runModelCallCount: z.ZodDefault<z.ZodNumber>;\n}, \"strip\", z.ZodTypeAny, {\n    threadModelCallCount: number;\n    runModelCallCount: number;\n}, {\n    threadModelCallCount?: number | undefined;\n    runModelCallCount?: number | undefined;\n}>, z.ZodObject<{\n    /**\n     * The maximum number of model calls allowed per thread.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The maximum number of model calls allowed per run.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The behavior to take when the limit is exceeded.\n     * - \"error\" will throw an error and stop the agent.\n     * - \"end\" will end the agent.\n     * @default \"end\"\n     */\n    exitBehavior: z.ZodOptional<z.ZodEnum<[\"error\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"error\" | undefined;\n}, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"error\" | undefined;\n}>, any>;\nexport {};\n//# sourceMappingURL=modelCallLimit.d.ts.map"],"mappings":";;;;;cAEcE,eAAeF,CAAAA,CAAEO;;;AADoC;EAKlCJ,WAAAA,EAAhBH,CAAAA,CAAEI,WAAcD,CAAFH,CAAAA,CAAEG,SAAAA,CAAAA;EAAdC;;;EAWeC,QAAAA,EAPpBL,CAAAA,CAAEI,WAOkBC,CAPNL,CAAAA,CAAEG,SAOIE,CAAAA;EAAdD;;;AAfoB;AAyBxC;;EAAqDH,YAAAA,EAVnCD,CAAAA,CAAEI,WAUiCH,CAVrBD,CAAAA,CAAEK,OAUmBJ,CAAAA,CAAAA,OAAAA,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA;CAARQ,EAAAA,OAAAA,EATjCT,CAAAA,CAAEM,UAS+BG,EAAAA;EAAO,WAAA,CAAA,EAAA,MAAA,GAAA,SAAA;EA6D5BC,QAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAwB;EAAqBF,YAAAA,CAAAA,EAAAA,KAAAA,GAAAA,OAAAA,GAAAA,SAAAA;CAC9BR,EAAEG;EAAbQ,WAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EACUR,QAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAbQ,YAAAA,CAAAA,EAAAA,KAAAA,GAAAA,OAAAA,GAAAA,SAAAA;CACbX,CAAAA;AAHiIO,KA7DjIC,8BAAAA,GAAiCC,OA6DgGF,CA7DxFN,oBA6DwFM,CAAAA,OA7D5DL,aA6D4DK,CAAAA,CAAAA;;;;;;;;;;AAAH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAlHG,wBAAAA,qBAA6CF,iDAAsER,CAAAA,CAAEO;wBACnHP,CAAAA,CAAEW,WAAWX,CAAAA,CAAEG;qBAClBH,CAAAA,CAAEW,WAAWX,CAAAA,CAAEG;YAC1BH,CAAAA,CAAEM;;;;;;IAMVN,CAAAA,CAAEO;;;;eAIWP,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;;;;YAInBH,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;;;;;;;gBAOZH,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEK;YACtBL,CAAAA,CAAEM"}

package/dist/agents/middleware/summarization.d.cts

@@ -1,5 +1,5 @@
 import { AgentMiddleware } from "./types.cjs";
-import * as _langchain_core_language_models_base3 from "@langchain/core/language_models/base";
+import * as _langchain_core_language_models_base0 from "@langchain/core/language_models/base";
 import { BaseLanguageModel } from "@langchain/core/language_models/base";
 import * as _langchain_core_messages0 from "@langchain/core/messages";
 import { BaseMessage } from "@langchain/core/messages";
@@ -71,7 +71,7 @@ declare const contextSchema: z.ZodObject<{
   /**
    * Model to use for summarization
    */
-  model: z.ZodType<string | BaseLanguageModel<any, _langchain_core_language_models_base3.BaseLanguageModelCallOptions>, z.ZodTypeDef, string | BaseLanguageModel<any, _langchain_core_language_models_base3.BaseLanguageModelCallOptions>>;
+  model: z.ZodType<string | BaseLanguageModel<any, _langchain_core_language_models_base0.BaseLanguageModelCallOptions>, z.ZodTypeDef, string | BaseLanguageModel<any, _langchain_core_language_models_base0.BaseLanguageModelCallOptions>>;
   /**
    * Trigger conditions for summarization.
    * Can be a single condition object (all properties must be met) or an array of conditions (any condition must be met).
@@ -203,7 +203,7 @@ declare const contextSchema: z.ZodObject<{
    */
   messagesToKeep: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-  model: string | BaseLanguageModel<any, _langchain_core_language_models_base3.BaseLanguageModelCallOptions>;
+  model: string | BaseLanguageModel<any, _langchain_core_language_models_base0.BaseLanguageModelCallOptions>;
   trigger?: {
     fraction?: number | undefined;
     tokens?: number | undefined;
@@ -225,7 +225,7 @@ declare const contextSchema: z.ZodObject<{
   maxTokensBeforeSummary?: number | undefined;
   messagesToKeep?: number | undefined;
 }, {
-  model: string | BaseLanguageModel<any, _langchain_core_language_models_base3.BaseLanguageModelCallOptions>;
+  model: string | BaseLanguageModel<any, _langchain_core_language_models_base0.BaseLanguageModelCallOptions>;
   trigger?: {
     fraction?: number | undefined;
     tokens?: number | undefined;
@@ -388,7 +388,7 @@ declare function summarizationMiddleware(options: SummarizationMiddlewareConfig)
   maxTokensBeforeSummary: z.ZodOptional<z.ZodNumber>;
   messagesToKeep: z.ZodOptional<z.ZodNumber>;
 } & {
-  model: z.ZodOptional<z.ZodType<BaseLanguageModel<any, _langchain_core_language_models_base3.BaseLanguageModelCallOptions>, z.ZodTypeDef, BaseLanguageModel<any, _langchain_core_language_models_base3.BaseLanguageModelCallOptions>>>;
+  model: z.ZodOptional<z.ZodType<BaseLanguageModel<any, _langchain_core_language_models_base0.BaseLanguageModelCallOptions>, z.ZodTypeDef, BaseLanguageModel<any, _langchain_core_language_models_base0.BaseLanguageModelCallOptions>>>;
 }, "strip", z.ZodTypeAny, {
   trigger?: {
     fraction?: number | undefined;
@@ -410,7 +410,7 @@ declare function summarizationMiddleware(options: SummarizationMiddlewareConfig)
   summaryPrefix?: string | undefined;
   maxTokensBeforeSummary?: number | undefined;
   messagesToKeep?: number | undefined;
-  model?: BaseLanguageModel<any, _langchain_core_language_models_base3.BaseLanguageModelCallOptions> | undefined;
+  model?: BaseLanguageModel<any, _langchain_core_language_models_base0.BaseLanguageModelCallOptions> | undefined;
 }, {
   trigger?: {
     fraction?: number | undefined;
@@ -432,7 +432,7 @@ declare function summarizationMiddleware(options: SummarizationMiddlewareConfig)
   summaryPrefix?: string | undefined;
   maxTokensBeforeSummary?: number | undefined;
   messagesToKeep?: number | undefined;
-  model?: BaseLanguageModel<any, _langchain_core_language_models_base3.BaseLanguageModelCallOptions> | undefined;
+  model?: BaseLanguageModel<any, _langchain_core_language_models_base0.BaseLanguageModelCallOptions> | undefined;
 }>, any>;
 //#endregion
 export { ContextSize, KeepSize, SummarizationMiddlewareConfig, TokenCounter, summarizationMiddleware };

package/dist/agents/middleware/summarization.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"summarization.d.cts","names":["_langchain_core_messages0","__types_js8","z","BaseMessage","BaseLanguageModel","InferInteropZodInput","DEFAULT_SUMMARY_PROMPT","TokenCounter","Promise","contextSizeSchema","ZodNumber","ZodOptional","ZodTypeAny","ZodObject","ZodEffects","ContextSize","infer","keepSchema","KeepSize","contextSchema","_langchain_core_language_models_base3","BaseLanguageModelCallOptions","ZodTypeDef","ZodType","ZodArray","ZodUnion","MessageStructure","MessageType","ZodUnknown","ZodTuple","ZodPromise","ZodFunction","ZodString","ZodDefault","SummarizationMiddlewareConfig","getProfileLimits","summarizationMiddleware","AgentMiddleware"],"sources":["../../../src/agents/middleware/summarization.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { BaseMessage } from \"@langchain/core/messages\";\nimport { BaseLanguageModel } from \"@langchain/core/language_models/base\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\nexport declare const DEFAULT_SUMMARY_PROMPT = \"<role>\\nContext Extraction Assistant\\n</role>\\n\\n<primary_objective>\\nYour sole objective in this task is to extract the highest quality/most relevant context from the conversation history below.\\n</primary_objective>\\n\\n<objective_information>\\nYou're nearing the total number of input tokens you can accept, so you must extract the highest quality/most relevant pieces of information from your conversation history.\\nThis context will then overwrite the conversation history presented below. Because of this, ensure the context you extract is only the most important information to your overall goal.\\n</objective_information>\\n\\n<instructions>\\nThe conversation history below will be replaced with the context you extract in this step. Because of this, you must do your very best to extract and record all of the most important context from the conversation history.\\nYou want to ensure that you don't repeat any actions you've already completed, so the context you extract from the conversation history should be focused on the most important information to your overall goal.\\n</instructions>\\n\\nThe user will message you with the full message history you'll be extracting context from, to then replace. Carefully read over it all, and think deeply about what information is most important to your overall goal that should be saved:\\n\\nWith all of this in mind, please carefully read over the entire conversation history, and extract the most important and relevant context to replace it so that you can free up space in the conversation history.\\nRespond ONLY with the extracted context. Do not include any additional information, or text before or after the extracted context.\\n\\n<messages>\\nMessages to summarize:\\n{messages}\\n</messages>\";\nexport type TokenCounter = (messages: BaseMessage[]) => number | Promise<number>;\nexport declare const contextSizeSchema: z.ZodEffects<z.ZodObject<{\n    /**\n     * Fraction of the model's context size to use as the trigger\n     */\n    fraction: z.ZodOptional<z.ZodNumber>;\n    /**\n     * Number of tokens to use as the trigger\n     */\n    tokens: z.ZodOptional<z.ZodNumber>;\n    /**\n     * Number of messages to use as the trigger\n     */\n    messages: z.ZodOptional<z.ZodNumber>;\n}, \"strip\", z.ZodTypeAny, {\n    fraction?: number | undefined;\n    tokens?: number | undefined;\n    messages?: number | undefined;\n}, {\n    fraction?: number | undefined;\n    tokens?: number | undefined;\n    messages?: number | undefined;\n}>, {\n    fraction?: number | undefined;\n    tokens?: number | undefined;\n    messages?: number | undefined;\n}, {\n    fraction?: number | undefined;\n    tokens?: number | undefined;\n    messages?: number | undefined;\n}>;\nexport type ContextSize = z.infer<typeof contextSizeSchema>;\nexport declare const keepSchema: z.ZodEffects<z.ZodObject<{\n    /**\n     * Fraction of the model's context size to keep\n     */\n    fraction: z.ZodOptional<z.ZodNumber>;\n    /**\n     * Number of tokens to keep\n     */\n    tokens: z.ZodOptional<z.ZodNumber>;\n    messages: z.ZodOptional<z.ZodNumber>;\n}, \"strip\", z.ZodTypeAny, {\n    fraction?: number | undefined;\n    tokens?: number | undefined;\n    messages?: number | undefined;\n}, {\n    fraction?: number | undefined;\n    tokens?: number | undefined;\n    messages?: number | undefined;\n}>, {\n    fraction?: number | undefined;\n    tokens?: number | undefined;\n    messages?: number | undefined;\n}, {\n    fraction?: number | undefined;\n    tokens?: number | undefined;\n    messages?: number | undefined;\n}>;\nexport type KeepSize = z.infer<typeof keepSchema>;\ndeclare const contextSchema: z.ZodObject<{\n    /**\n     * Model to use for summarization\n     */\n    model: z.ZodType<string | BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>, z.ZodTypeDef, string | BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>>;\n    /**\n     * Trigger conditions for summarization.\n     * Can be a single condition object (all properties must be met) or an array of conditions (any condition must be met).\n     *\n     * @example\n     * ```ts\n     * // Single condition: trigger if tokens >= 5000 AND messages >= 3\n     * trigger: { tokens: 5000, messages: 3 }\n     *\n     * // Multiple conditions: trigger if (tokens >= 5000 AND messages >= 3) OR (tokens >= 3000 AND messages >= 6)\n     * trigger: [\n     *   { tokens: 5000, messages: 3 },\n     *   { tokens: 3000, messages: 6 }\n     * ]\n     * ```\n     */\n    trigger: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodObject<{\n        /**\n         * Fraction of the model's context size to use as the trigger\n         */\n        fraction: z.ZodOptional<z.ZodNumber>;\n        /**\n         * Number of tokens to use as the trigger\n         */\n        tokens: z.ZodOptional<z.ZodNumber>;\n        /**\n         * Number of messages to use as the trigger\n         */\n        messages: z.ZodOptional<z.ZodNumber>;\n    }, \"strip\", z.ZodTypeAny, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }>, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }>, z.ZodArray<z.ZodEffects<z.ZodObject<{\n        /**\n         * Fraction of the model's context size to use as the trigger\n         */\n        fraction: z.ZodOptional<z.ZodNumber>;\n        /**\n         * Number of tokens to use as the trigger\n         */\n        tokens: z.ZodOptional<z.ZodNumber>;\n        /**\n         * Number of messages to use as the trigger\n         */\n        messages: z.ZodOptional<z.ZodNumber>;\n    }, \"strip\", z.ZodTypeAny, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }>, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }>, \"many\">]>>;\n    /**\n     * Keep conditions for summarization\n     */\n    keep: z.ZodOptional<z.ZodEffects<z.ZodObject<{\n        /**\n         * Fraction of the model's context size to keep\n         */\n        fraction: z.ZodOptional<z.ZodNumber>;\n        /**\n         * Number of tokens to keep\n         */\n        tokens: z.ZodOptional<z.ZodNumber>;\n        messages: z.ZodOptional<z.ZodNumber>;\n    }, \"strip\", z.ZodTypeAny, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }>, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }>>;\n    /**\n     * Token counter function to use for summarization\n     */\n    tokenCounter: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodArray<z.ZodType<BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>, z.ZodTypeDef, BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>>, \"many\">], z.ZodUnknown>, z.ZodUnion<[z.ZodNumber, z.ZodPromise<z.ZodNumber>]>>>;\n    /**\n     * Summary prompt to use for summarization\n     * @default {@link DEFAULT_SUMMARY_PROMPT}\n     */\n    summaryPrompt: z.ZodDefault<z.ZodString>;\n    /**\n     * Number of tokens to trim to before summarizing\n     */\n    trimTokensToSummarize: z.ZodOptional<z.ZodNumber>;\n    /**\n     * Prefix to add to the summary\n     */\n    summaryPrefix: z.ZodOptional<z.ZodString>;\n    /**\n     * @deprecated Use `trigger: { tokens: value }` instead.\n     */\n    maxTokensBeforeSummary: z.ZodOptional<z.ZodNumber>;\n    /**\n     * @deprecated Use `keep: { messages: value }` instead.\n     */\n    messagesToKeep: z.ZodOptional<z.ZodNumber>;\n}, \"strip\", z.ZodTypeAny, {\n    model: string | BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>;\n    trigger?: {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }[] | {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    } | undefined;\n    keep?: {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    } | undefined;\n    tokenCounter?: ((args_0: BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>[], ...args: unknown[]) => number | Promise<number>) | undefined;\n    summaryPrompt: string;\n    trimTokensToSummarize?: number | undefined;\n    summaryPrefix?: string | undefined;\n    maxTokensBeforeSummary?: number | undefined;\n    messagesToKeep?: number | undefined;\n}, {\n    model: string | BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>;\n    trigger?: {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }[] | {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    } | undefined;\n    keep?: {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    } | undefined;\n    tokenCounter?: ((args_0: BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>[], ...args: unknown[]) => number | Promise<number>) | undefined;\n    summaryPrompt?: string | undefined;\n    trimTokensToSummarize?: number | undefined;\n    summaryPrefix?: string | undefined;\n    maxTokensBeforeSummary?: number | undefined;\n    messagesToKeep?: number | undefined;\n}>;\nexport type SummarizationMiddlewareConfig = InferInteropZodInput<typeof contextSchema>;\n/**\n * Get max input tokens from model profile or fallback to model name lookup\n */\nexport declare function getProfileLimits(input: BaseLanguageModel): number | undefined;\n/**\n * Summarization middleware that automatically summarizes conversation history when token limits are approached.\n *\n * This middleware monitors message token counts and automatically summarizes older\n * messages when a threshold is reached, preserving recent messages and maintaining\n * context continuity by ensuring AI/Tool message pairs remain together.\n *\n * @param options Configuration options for the summarization middleware\n * @returns A middleware instance\n *\n * @example\n * ```ts\n * import { summarizationMiddleware } from \"langchain\";\n * import { createAgent } from \"langchain\";\n *\n * // Single condition: trigger if tokens >= 4000 AND messages >= 10\n * const agent1 = createAgent({\n *   llm: model,\n *   tools: [getWeather],\n *   middleware: [\n *     summarizationMiddleware({\n *       model: new ChatOpenAI({ model: \"gpt-4o\" }),\n *       trigger: { tokens: 4000, messages: 10 },\n *       keep: { messages: 20 },\n *     })\n *   ],\n * });\n *\n * // Multiple conditions: trigger if (tokens >= 5000 AND messages >= 3) OR (tokens >= 3000 AND messages >= 6)\n * const agent2 = createAgent({\n *   llm: model,\n *   tools: [getWeather],\n *   middleware: [\n *     summarizationMiddleware({\n *       model: new ChatOpenAI({ model: \"gpt-4o\" }),\n *       trigger: [\n *         { tokens: 5000, messages: 3 },\n *         { tokens: 3000, messages: 6 },\n *       ],\n *       keep: { messages: 20 },\n *     })\n *   ],\n * });\n *\n * ```\n */\nexport declare function summarizationMiddleware(options: SummarizationMiddlewareConfig): import(\"./types.js\").AgentMiddleware<undefined, z.ZodObject<{\n    trigger: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodObject<{\n        /**\n         * Fraction of the model's context size to use as the trigger\n         */\n        fraction: z.ZodOptional<z.ZodNumber>;\n        /**\n         * Number of tokens to use as the trigger\n         */\n        tokens: z.ZodOptional<z.ZodNumber>;\n        /**\n         * Number of messages to use as the trigger\n         */\n        messages: z.ZodOptional<z.ZodNumber>;\n    }, \"strip\", z.ZodTypeAny, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }>, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }>, z.ZodArray<z.ZodEffects<z.ZodObject<{\n        /**\n         * Fraction of the model's context size to use as the trigger\n         */\n        fraction: z.ZodOptional<z.ZodNumber>;\n        /**\n         * Number of tokens to use as the trigger\n         */\n        tokens: z.ZodOptional<z.ZodNumber>;\n        /**\n         * Number of messages to use as the trigger\n         */\n        messages: z.ZodOptional<z.ZodNumber>;\n    }, \"strip\", z.ZodTypeAny, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }>, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }>, \"many\">]>>;\n    keep: z.ZodOptional<z.ZodEffects<z.ZodObject<{\n        /**\n         * Fraction of the model's context size to keep\n         */\n        fraction: z.ZodOptional<z.ZodNumber>;\n        /**\n         * Number of tokens to keep\n         */\n        tokens: z.ZodOptional<z.ZodNumber>;\n        messages: z.ZodOptional<z.ZodNumber>;\n    }, \"strip\", z.ZodTypeAny, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }>, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }>>;\n    tokenCounter: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodArray<z.ZodType<BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>, z.ZodTypeDef, BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>>, \"many\">], z.ZodUnknown>, z.ZodUnion<[z.ZodNumber, z.ZodPromise<z.ZodNumber>]>>>;\n    summaryPrompt: z.ZodDefault<z.ZodString>;\n    trimTokensToSummarize: z.ZodOptional<z.ZodNumber>;\n    summaryPrefix: z.ZodOptional<z.ZodString>;\n    maxTokensBeforeSummary: z.ZodOptional<z.ZodNumber>;\n    messagesToKeep: z.ZodOptional<z.ZodNumber>;\n} & {\n    model: z.ZodOptional<z.ZodType<BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>, z.ZodTypeDef, BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>>>;\n}, \"strip\", z.ZodTypeAny, {\n    trigger?: {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }[] | {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    } | undefined;\n    keep?: {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    } | undefined;\n    tokenCounter?: ((args_0: BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>[], ...args: unknown[]) => number | Promise<number>) | undefined;\n    summaryPrompt: string;\n    trimTokensToSummarize?: number | undefined;\n    summaryPrefix?: string | undefined;\n    maxTokensBeforeSummary?: number | undefined;\n    messagesToKeep?: number | undefined;\n    model?: BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions> | undefined;\n}, {\n    trigger?: {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }[] | {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    } | undefined;\n    keep?: {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    } | undefined;\n    tokenCounter?: ((args_0: BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>[], ...args: unknown[]) => number | Promise<number>) | undefined;\n    summaryPrompt?: string | undefined;\n    trimTokensToSummarize?: number | undefined;\n    summaryPrefix?: string | undefined;\n    maxTokensBeforeSummary?: number | undefined;\n    messagesToKeep?: number | undefined;\n    model?: BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions> | undefined;\n}>, any>;\nexport {};\n//# sourceMappingURL=summarization.d.ts.map"],"mappings":"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"}
+{"version":3,"file":"summarization.d.cts","names":["_langchain_core_messages0","__types_js8","z","BaseMessage","BaseLanguageModel","InferInteropZodInput","DEFAULT_SUMMARY_PROMPT","TokenCounter","Promise","contextSizeSchema","ZodNumber","ZodOptional","ZodTypeAny","ZodObject","ZodEffects","ContextSize","infer","keepSchema","KeepSize","contextSchema","_langchain_core_language_models_base0","BaseLanguageModelCallOptions","ZodTypeDef","ZodType","ZodArray","ZodUnion","MessageStructure","MessageType","ZodUnknown","ZodTuple","ZodPromise","ZodFunction","ZodString","ZodDefault","SummarizationMiddlewareConfig","getProfileLimits","summarizationMiddleware","AgentMiddleware"],"sources":["../../../src/agents/middleware/summarization.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { BaseMessage } from \"@langchain/core/messages\";\nimport { BaseLanguageModel } from \"@langchain/core/language_models/base\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\nexport declare const DEFAULT_SUMMARY_PROMPT = \"<role>\\nContext Extraction Assistant\\n</role>\\n\\n<primary_objective>\\nYour sole objective in this task is to extract the highest quality/most relevant context from the conversation history below.\\n</primary_objective>\\n\\n<objective_information>\\nYou're nearing the total number of input tokens you can accept, so you must extract the highest quality/most relevant pieces of information from your conversation history.\\nThis context will then overwrite the conversation history presented below. Because of this, ensure the context you extract is only the most important information to your overall goal.\\n</objective_information>\\n\\n<instructions>\\nThe conversation history below will be replaced with the context you extract in this step. Because of this, you must do your very best to extract and record all of the most important context from the conversation history.\\nYou want to ensure that you don't repeat any actions you've already completed, so the context you extract from the conversation history should be focused on the most important information to your overall goal.\\n</instructions>\\n\\nThe user will message you with the full message history you'll be extracting context from, to then replace. Carefully read over it all, and think deeply about what information is most important to your overall goal that should be saved:\\n\\nWith all of this in mind, please carefully read over the entire conversation history, and extract the most important and relevant context to replace it so that you can free up space in the conversation history.\\nRespond ONLY with the extracted context. Do not include any additional information, or text before or after the extracted context.\\n\\n<messages>\\nMessages to summarize:\\n{messages}\\n</messages>\";\nexport type TokenCounter = (messages: BaseMessage[]) => number | Promise<number>;\nexport declare const contextSizeSchema: z.ZodEffects<z.ZodObject<{\n    /**\n     * Fraction of the model's context size to use as the trigger\n     */\n    fraction: z.ZodOptional<z.ZodNumber>;\n    /**\n     * Number of tokens to use as the trigger\n     */\n    tokens: z.ZodOptional<z.ZodNumber>;\n    /**\n     * Number of messages to use as the trigger\n     */\n    messages: z.ZodOptional<z.ZodNumber>;\n}, \"strip\", z.ZodTypeAny, {\n    fraction?: number | undefined;\n    tokens?: number | undefined;\n    messages?: number | undefined;\n}, {\n    fraction?: number | undefined;\n    tokens?: number | undefined;\n    messages?: number | undefined;\n}>, {\n    fraction?: number | undefined;\n    tokens?: number | undefined;\n    messages?: number | undefined;\n}, {\n    fraction?: number | undefined;\n    tokens?: number | undefined;\n    messages?: number | undefined;\n}>;\nexport type ContextSize = z.infer<typeof contextSizeSchema>;\nexport declare const keepSchema: z.ZodEffects<z.ZodObject<{\n    /**\n     * Fraction of the model's context size to keep\n     */\n    fraction: z.ZodOptional<z.ZodNumber>;\n    /**\n     * Number of tokens to keep\n     */\n    tokens: z.ZodOptional<z.ZodNumber>;\n    messages: z.ZodOptional<z.ZodNumber>;\n}, \"strip\", z.ZodTypeAny, {\n    fraction?: number | undefined;\n    tokens?: number | undefined;\n    messages?: number | undefined;\n}, {\n    fraction?: number | undefined;\n    tokens?: number | undefined;\n    messages?: number | undefined;\n}>, {\n    fraction?: number | undefined;\n    tokens?: number | undefined;\n    messages?: number | undefined;\n}, {\n    fraction?: number | undefined;\n    tokens?: number | undefined;\n    messages?: number | undefined;\n}>;\nexport type KeepSize = z.infer<typeof keepSchema>;\ndeclare const contextSchema: z.ZodObject<{\n    /**\n     * Model to use for summarization\n     */\n    model: z.ZodType<string | BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>, z.ZodTypeDef, string | BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>>;\n    /**\n     * Trigger conditions for summarization.\n     * Can be a single condition object (all properties must be met) or an array of conditions (any condition must be met).\n     *\n     * @example\n     * ```ts\n     * // Single condition: trigger if tokens >= 5000 AND messages >= 3\n     * trigger: { tokens: 5000, messages: 3 }\n     *\n     * // Multiple conditions: trigger if (tokens >= 5000 AND messages >= 3) OR (tokens >= 3000 AND messages >= 6)\n     * trigger: [\n     *   { tokens: 5000, messages: 3 },\n     *   { tokens: 3000, messages: 6 }\n     * ]\n     * ```\n     */\n    trigger: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodObject<{\n        /**\n         * Fraction of the model's context size to use as the trigger\n         */\n        fraction: z.ZodOptional<z.ZodNumber>;\n        /**\n         * Number of tokens to use as the trigger\n         */\n        tokens: z.ZodOptional<z.ZodNumber>;\n        /**\n         * Number of messages to use as the trigger\n         */\n        messages: z.ZodOptional<z.ZodNumber>;\n    }, \"strip\", z.ZodTypeAny, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }>, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }>, z.ZodArray<z.ZodEffects<z.ZodObject<{\n        /**\n         * Fraction of the model's context size to use as the trigger\n         */\n        fraction: z.ZodOptional<z.ZodNumber>;\n        /**\n         * Number of tokens to use as the trigger\n         */\n        tokens: z.ZodOptional<z.ZodNumber>;\n        /**\n         * Number of messages to use as the trigger\n         */\n        messages: z.ZodOptional<z.ZodNumber>;\n    }, \"strip\", z.ZodTypeAny, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }>, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }>, \"many\">]>>;\n    /**\n     * Keep conditions for summarization\n     */\n    keep: z.ZodOptional<z.ZodEffects<z.ZodObject<{\n        /**\n         * Fraction of the model's context size to keep\n         */\n        fraction: z.ZodOptional<z.ZodNumber>;\n        /**\n         * Number of tokens to keep\n         */\n        tokens: z.ZodOptional<z.ZodNumber>;\n        messages: z.ZodOptional<z.ZodNumber>;\n    }, \"strip\", z.ZodTypeAny, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }>, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }>>;\n    /**\n     * Token counter function to use for summarization\n     */\n    tokenCounter: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodArray<z.ZodType<BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>, z.ZodTypeDef, BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>>, \"many\">], z.ZodUnknown>, z.ZodUnion<[z.ZodNumber, z.ZodPromise<z.ZodNumber>]>>>;\n    /**\n     * Summary prompt to use for summarization\n     * @default {@link DEFAULT_SUMMARY_PROMPT}\n     */\n    summaryPrompt: z.ZodDefault<z.ZodString>;\n    /**\n     * Number of tokens to trim to before summarizing\n     */\n    trimTokensToSummarize: z.ZodOptional<z.ZodNumber>;\n    /**\n     * Prefix to add to the summary\n     */\n    summaryPrefix: z.ZodOptional<z.ZodString>;\n    /**\n     * @deprecated Use `trigger: { tokens: value }` instead.\n     */\n    maxTokensBeforeSummary: z.ZodOptional<z.ZodNumber>;\n    /**\n     * @deprecated Use `keep: { messages: value }` instead.\n     */\n    messagesToKeep: z.ZodOptional<z.ZodNumber>;\n}, \"strip\", z.ZodTypeAny, {\n    model: string | BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>;\n    trigger?: {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }[] | {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    } | undefined;\n    keep?: {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    } | undefined;\n    tokenCounter?: ((args_0: BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>[], ...args: unknown[]) => number | Promise<number>) | undefined;\n    summaryPrompt: string;\n    trimTokensToSummarize?: number | undefined;\n    summaryPrefix?: string | undefined;\n    maxTokensBeforeSummary?: number | undefined;\n    messagesToKeep?: number | undefined;\n}, {\n    model: string | BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>;\n    trigger?: {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }[] | {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    } | undefined;\n    keep?: {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    } | undefined;\n    tokenCounter?: ((args_0: BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>[], ...args: unknown[]) => number | Promise<number>) | undefined;\n    summaryPrompt?: string | undefined;\n    trimTokensToSummarize?: number | undefined;\n    summaryPrefix?: string | undefined;\n    maxTokensBeforeSummary?: number | undefined;\n    messagesToKeep?: number | undefined;\n}>;\nexport type SummarizationMiddlewareConfig = InferInteropZodInput<typeof contextSchema>;\n/**\n * Get max input tokens from model profile or fallback to model name lookup\n */\nexport declare function getProfileLimits(input: BaseLanguageModel): number | undefined;\n/**\n * Summarization middleware that automatically summarizes conversation history when token limits are approached.\n *\n * This middleware monitors message token counts and automatically summarizes older\n * messages when a threshold is reached, preserving recent messages and maintaining\n * context continuity by ensuring AI/Tool message pairs remain together.\n *\n * @param options Configuration options for the summarization middleware\n * @returns A middleware instance\n *\n * @example\n * ```ts\n * import { summarizationMiddleware } from \"langchain\";\n * import { createAgent } from \"langchain\";\n *\n * // Single condition: trigger if tokens >= 4000 AND messages >= 10\n * const agent1 = createAgent({\n *   llm: model,\n *   tools: [getWeather],\n *   middleware: [\n *     summarizationMiddleware({\n *       model: new ChatOpenAI({ model: \"gpt-4o\" }),\n *       trigger: { tokens: 4000, messages: 10 },\n *       keep: { messages: 20 },\n *     })\n *   ],\n * });\n *\n * // Multiple conditions: trigger if (tokens >= 5000 AND messages >= 3) OR (tokens >= 3000 AND messages >= 6)\n * const agent2 = createAgent({\n *   llm: model,\n *   tools: [getWeather],\n *   middleware: [\n *     summarizationMiddleware({\n *       model: new ChatOpenAI({ model: \"gpt-4o\" }),\n *       trigger: [\n *         { tokens: 5000, messages: 3 },\n *         { tokens: 3000, messages: 6 },\n *       ],\n *       keep: { messages: 20 },\n *     })\n *   ],\n * });\n *\n * ```\n */\nexport declare function summarizationMiddleware(options: SummarizationMiddlewareConfig): import(\"./types.js\").AgentMiddleware<undefined, z.ZodObject<{\n    trigger: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodObject<{\n        /**\n         * Fraction of the model's context size to use as the trigger\n         */\n        fraction: z.ZodOptional<z.ZodNumber>;\n        /**\n         * Number of tokens to use as the trigger\n         */\n        tokens: z.ZodOptional<z.ZodNumber>;\n        /**\n         * Number of messages to use as the trigger\n         */\n        messages: z.ZodOptional<z.ZodNumber>;\n    }, \"strip\", z.ZodTypeAny, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }>, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }>, z.ZodArray<z.ZodEffects<z.ZodObject<{\n        /**\n         * Fraction of the model's context size to use as the trigger\n         */\n        fraction: z.ZodOptional<z.ZodNumber>;\n        /**\n         * Number of tokens to use as the trigger\n         */\n        tokens: z.ZodOptional<z.ZodNumber>;\n        /**\n         * Number of messages to use as the trigger\n         */\n        messages: z.ZodOptional<z.ZodNumber>;\n    }, \"strip\", z.ZodTypeAny, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }>, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }>, \"many\">]>>;\n    keep: z.ZodOptional<z.ZodEffects<z.ZodObject<{\n        /**\n         * Fraction of the model's context size to keep\n         */\n        fraction: z.ZodOptional<z.ZodNumber>;\n        /**\n         * Number of tokens to keep\n         */\n        tokens: z.ZodOptional<z.ZodNumber>;\n        messages: z.ZodOptional<z.ZodNumber>;\n    }, \"strip\", z.ZodTypeAny, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }>, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }, {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }>>;\n    tokenCounter: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodArray<z.ZodType<BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>, z.ZodTypeDef, BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>>, \"many\">], z.ZodUnknown>, z.ZodUnion<[z.ZodNumber, z.ZodPromise<z.ZodNumber>]>>>;\n    summaryPrompt: z.ZodDefault<z.ZodString>;\n    trimTokensToSummarize: z.ZodOptional<z.ZodNumber>;\n    summaryPrefix: z.ZodOptional<z.ZodString>;\n    maxTokensBeforeSummary: z.ZodOptional<z.ZodNumber>;\n    messagesToKeep: z.ZodOptional<z.ZodNumber>;\n} & {\n    model: z.ZodOptional<z.ZodType<BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>, z.ZodTypeDef, BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>>>;\n}, \"strip\", z.ZodTypeAny, {\n    trigger?: {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }[] | {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    } | undefined;\n    keep?: {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    } | undefined;\n    tokenCounter?: ((args_0: BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>[], ...args: unknown[]) => number | Promise<number>) | undefined;\n    summaryPrompt: string;\n    trimTokensToSummarize?: number | undefined;\n    summaryPrefix?: string | undefined;\n    maxTokensBeforeSummary?: number | undefined;\n    messagesToKeep?: number | undefined;\n    model?: BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions> | undefined;\n}, {\n    trigger?: {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    }[] | {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    } | undefined;\n    keep?: {\n        fraction?: number | undefined;\n        tokens?: number | undefined;\n        messages?: number | undefined;\n    } | undefined;\n    tokenCounter?: ((args_0: BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>[], ...args: unknown[]) => number | Promise<number>) | undefined;\n    summaryPrompt?: string | undefined;\n    trimTokensToSummarize?: number | undefined;\n    summaryPrefix?: string | undefined;\n    maxTokensBeforeSummary?: number | undefined;\n    messagesToKeep?: number | undefined;\n    model?: BaseLanguageModel<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions> | undefined;\n}>, any>;\nexport {};\n//# sourceMappingURL=summarization.d.ts.map"],"mappings":"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"}

package/dist/agents/middleware/todoListMiddleware.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"todoListMiddleware.d.cts","names":["z","TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT","stateSchema","ZodString","ZodEnum","ZodTypeAny","ZodObject","ZodArray","ZodDefault","TodoMiddlewareState","infer","TodoListMiddlewareOptions","todoListMiddleware","__types_js12","AgentMiddleware"],"sources":["../../../src/agents/middleware/todoListMiddleware.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nexport declare const TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT = \"## `write_todos`\\n\\nYou have access to the `write_todos` tool to help you manage and plan complex objectives. \\nUse this tool for complex objectives to ensure that you are tracking each necessary step and giving the user visibility into your progress.\\nThis tool is very helpful for planning complex objectives, and for breaking down these larger complex objectives into smaller steps.\\n\\nIt is critical that you mark todos as completed as soon as you are done with a step. Do not batch up multiple steps before marking them as completed.\\nFor simple objectives that only require a few steps, it is better to just complete the objective directly and NOT use this tool.\\nWriting todos takes time and tokens, use it when it is helpful for managing complex many-step problems! But not for simple few-step requests.\\n\\n## Important To-Do List Usage Notes to Remember\\n- The `write_todos` tool should never be called multiple times in parallel.\\n- Don't be afraid to revise the To-Do list as you go. New information may reveal new tasks that need to be done, or old tasks that are irrelevant.\";\ndeclare const stateSchema: z.ZodObject<{\n    todos: z.ZodDefault<z.ZodArray<z.ZodObject<{\n        content: z.ZodString;\n        status: z.ZodEnum<[\"pending\", \"in_progress\", \"completed\"]>;\n    }, \"strip\", z.ZodTypeAny, {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }, {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }>, \"many\">>;\n}, \"strip\", z.ZodTypeAny, {\n    todos: {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }[];\n}, {\n    todos?: {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }[] | undefined;\n}>;\nexport type TodoMiddlewareState = z.infer<typeof stateSchema>;\nexport interface TodoListMiddlewareOptions {\n    /**\n     * Custom system prompt to guide the agent on using the todo tool.\n     * If not provided, uses the default {@link PLANNING_MIDDLEWARE_SYSTEM_PROMPT}.\n     */\n    systemPrompt?: string;\n    /**\n     * Custom description for the {@link writeTodos} tool.\n     * If not provided, uses the default {@link WRITE_TODOS_DESCRIPTION}.\n     */\n    toolDescription?: string;\n}\n/**\n * Creates a middleware that provides todo list management capabilities to agents.\n *\n * This middleware adds a `write_todos` tool that allows agents to create and manage\n * structured task lists for complex multi-step operations. It's designed to help\n * agents track progress, organize complex tasks, and provide users with visibility\n * into task completion status.\n *\n * The middleware automatically injects system prompts that guide the agent on when\n * and how to use the todo functionality effectively.\n *\n * @example\n * ```typescript\n * import { todoListMiddleware, createAgent } from 'langchain';\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [todoListMiddleware()],\n * });\n *\n * // Agent now has access to write_todos tool and todo state tracking\n * const result = await agent.invoke({\n *   messages: [new HumanMessage(\"Help me refactor my codebase\")]\n * });\n *\n * console.log(result.todos); // Array of todo items with status tracking\n * ```\n *\n * @returns A configured middleware instance that provides todo management capabilities\n *\n * @see {@link TodoMiddlewareState} for the state schema\n * @see {@link writeTodos} for the tool implementation\n */\nexport declare function todoListMiddleware(options?: TodoListMiddlewareOptions): import(\"./types.js\").AgentMiddleware<z.ZodObject<{\n    todos: z.ZodDefault<z.ZodArray<z.ZodObject<{\n        content: z.ZodString;\n        status: z.ZodEnum<[\"pending\", \"in_progress\", \"completed\"]>;\n    }, \"strip\", z.ZodTypeAny, {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }, {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }>, \"many\">>;\n}, \"strip\", z.ZodTypeAny, {\n    todos: {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }[];\n}, {\n    todos?: {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }[] | undefined;\n}>, undefined, any>;\nexport {};\n//# sourceMappingURL=todoListMiddleware.d.ts.map"],"mappings":";;;;cACqBC,kCAAAA;UAwBJU,yBAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6COC,kBAAAA,WAA6BD,4CAAiEX,CAAAA,CAAEM;SAC7GN,CAAAA,CAAEQ,WAAWR,CAAAA,CAAEO,SAASP,CAAAA,CAAEM;aACpBN,CAAAA,CAAEG;YACHH,CAAAA,CAAEI;cACFJ,CAAAA,CAAEK;;;;;;;YAONL,CAAAA,CAAEK"}
+{"version":3,"file":"todoListMiddleware.d.cts","names":["z","TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT","stateSchema","ZodString","ZodEnum","ZodTypeAny","ZodObject","ZodArray","ZodDefault","TodoMiddlewareState","infer","TodoListMiddlewareOptions","todoListMiddleware","__types_js13","AgentMiddleware"],"sources":["../../../src/agents/middleware/todoListMiddleware.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nexport declare const TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT = \"## `write_todos`\\n\\nYou have access to the `write_todos` tool to help you manage and plan complex objectives. \\nUse this tool for complex objectives to ensure that you are tracking each necessary step and giving the user visibility into your progress.\\nThis tool is very helpful for planning complex objectives, and for breaking down these larger complex objectives into smaller steps.\\n\\nIt is critical that you mark todos as completed as soon as you are done with a step. Do not batch up multiple steps before marking them as completed.\\nFor simple objectives that only require a few steps, it is better to just complete the objective directly and NOT use this tool.\\nWriting todos takes time and tokens, use it when it is helpful for managing complex many-step problems! But not for simple few-step requests.\\n\\n## Important To-Do List Usage Notes to Remember\\n- The `write_todos` tool should never be called multiple times in parallel.\\n- Don't be afraid to revise the To-Do list as you go. New information may reveal new tasks that need to be done, or old tasks that are irrelevant.\";\ndeclare const stateSchema: z.ZodObject<{\n    todos: z.ZodDefault<z.ZodArray<z.ZodObject<{\n        content: z.ZodString;\n        status: z.ZodEnum<[\"pending\", \"in_progress\", \"completed\"]>;\n    }, \"strip\", z.ZodTypeAny, {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }, {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }>, \"many\">>;\n}, \"strip\", z.ZodTypeAny, {\n    todos: {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }[];\n}, {\n    todos?: {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }[] | undefined;\n}>;\nexport type TodoMiddlewareState = z.infer<typeof stateSchema>;\nexport interface TodoListMiddlewareOptions {\n    /**\n     * Custom system prompt to guide the agent on using the todo tool.\n     * If not provided, uses the default {@link PLANNING_MIDDLEWARE_SYSTEM_PROMPT}.\n     */\n    systemPrompt?: string;\n    /**\n     * Custom description for the {@link writeTodos} tool.\n     * If not provided, uses the default {@link WRITE_TODOS_DESCRIPTION}.\n     */\n    toolDescription?: string;\n}\n/**\n * Creates a middleware that provides todo list management capabilities to agents.\n *\n * This middleware adds a `write_todos` tool that allows agents to create and manage\n * structured task lists for complex multi-step operations. It's designed to help\n * agents track progress, organize complex tasks, and provide users with visibility\n * into task completion status.\n *\n * The middleware automatically injects system prompts that guide the agent on when\n * and how to use the todo functionality effectively.\n *\n * @example\n * ```typescript\n * import { todoListMiddleware, createAgent } from 'langchain';\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [todoListMiddleware()],\n * });\n *\n * // Agent now has access to write_todos tool and todo state tracking\n * const result = await agent.invoke({\n *   messages: [new HumanMessage(\"Help me refactor my codebase\")]\n * });\n *\n * console.log(result.todos); // Array of todo items with status tracking\n * ```\n *\n * @returns A configured middleware instance that provides todo management capabilities\n *\n * @see {@link TodoMiddlewareState} for the state schema\n * @see {@link writeTodos} for the tool implementation\n */\nexport declare function todoListMiddleware(options?: TodoListMiddlewareOptions): import(\"./types.js\").AgentMiddleware<z.ZodObject<{\n    todos: z.ZodDefault<z.ZodArray<z.ZodObject<{\n        content: z.ZodString;\n        status: z.ZodEnum<[\"pending\", \"in_progress\", \"completed\"]>;\n    }, \"strip\", z.ZodTypeAny, {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }, {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }>, \"many\">>;\n}, \"strip\", z.ZodTypeAny, {\n    todos: {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }[];\n}, {\n    todos?: {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }[] | undefined;\n}>, undefined, any>;\nexport {};\n//# sourceMappingURL=todoListMiddleware.d.ts.map"],"mappings":";;;;cACqBC,kCAAAA;UAwBJU,yBAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6COC,kBAAAA,WAA6BD,4CAAiEX,CAAAA,CAAEM;SAC7GN,CAAAA,CAAEQ,WAAWR,CAAAA,CAAEO,SAASP,CAAAA,CAAEM;aACpBN,CAAAA,CAAEG;YACHH,CAAAA,CAAEI;cACFJ,CAAAA,CAAEK;;;;;;;YAONL,CAAAA,CAAEK"}

package/dist/agents/middleware/todoListMiddleware.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"todoListMiddleware.d.ts","names":["z","TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT","stateSchema","ZodString","ZodEnum","ZodTypeAny","ZodObject","ZodArray","ZodDefault","TodoMiddlewareState","infer","TodoListMiddlewareOptions","todoListMiddleware","__types_js11","AgentMiddleware"],"sources":["../../../src/agents/middleware/todoListMiddleware.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nexport declare const TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT = \"## `write_todos`\\n\\nYou have access to the `write_todos` tool to help you manage and plan complex objectives. \\nUse this tool for complex objectives to ensure that you are tracking each necessary step and giving the user visibility into your progress.\\nThis tool is very helpful for planning complex objectives, and for breaking down these larger complex objectives into smaller steps.\\n\\nIt is critical that you mark todos as completed as soon as you are done with a step. Do not batch up multiple steps before marking them as completed.\\nFor simple objectives that only require a few steps, it is better to just complete the objective directly and NOT use this tool.\\nWriting todos takes time and tokens, use it when it is helpful for managing complex many-step problems! But not for simple few-step requests.\\n\\n## Important To-Do List Usage Notes to Remember\\n- The `write_todos` tool should never be called multiple times in parallel.\\n- Don't be afraid to revise the To-Do list as you go. New information may reveal new tasks that need to be done, or old tasks that are irrelevant.\";\ndeclare const stateSchema: z.ZodObject<{\n    todos: z.ZodDefault<z.ZodArray<z.ZodObject<{\n        content: z.ZodString;\n        status: z.ZodEnum<[\"pending\", \"in_progress\", \"completed\"]>;\n    }, \"strip\", z.ZodTypeAny, {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }, {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }>, \"many\">>;\n}, \"strip\", z.ZodTypeAny, {\n    todos: {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }[];\n}, {\n    todos?: {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }[] | undefined;\n}>;\nexport type TodoMiddlewareState = z.infer<typeof stateSchema>;\nexport interface TodoListMiddlewareOptions {\n    /**\n     * Custom system prompt to guide the agent on using the todo tool.\n     * If not provided, uses the default {@link PLANNING_MIDDLEWARE_SYSTEM_PROMPT}.\n     */\n    systemPrompt?: string;\n    /**\n     * Custom description for the {@link writeTodos} tool.\n     * If not provided, uses the default {@link WRITE_TODOS_DESCRIPTION}.\n     */\n    toolDescription?: string;\n}\n/**\n * Creates a middleware that provides todo list management capabilities to agents.\n *\n * This middleware adds a `write_todos` tool that allows agents to create and manage\n * structured task lists for complex multi-step operations. It's designed to help\n * agents track progress, organize complex tasks, and provide users with visibility\n * into task completion status.\n *\n * The middleware automatically injects system prompts that guide the agent on when\n * and how to use the todo functionality effectively.\n *\n * @example\n * ```typescript\n * import { todoListMiddleware, createAgent } from 'langchain';\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [todoListMiddleware()],\n * });\n *\n * // Agent now has access to write_todos tool and todo state tracking\n * const result = await agent.invoke({\n *   messages: [new HumanMessage(\"Help me refactor my codebase\")]\n * });\n *\n * console.log(result.todos); // Array of todo items with status tracking\n * ```\n *\n * @returns A configured middleware instance that provides todo management capabilities\n *\n * @see {@link TodoMiddlewareState} for the state schema\n * @see {@link writeTodos} for the tool implementation\n */\nexport declare function todoListMiddleware(options?: TodoListMiddlewareOptions): import(\"./types.js\").AgentMiddleware<z.ZodObject<{\n    todos: z.ZodDefault<z.ZodArray<z.ZodObject<{\n        content: z.ZodString;\n        status: z.ZodEnum<[\"pending\", \"in_progress\", \"completed\"]>;\n    }, \"strip\", z.ZodTypeAny, {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }, {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }>, \"many\">>;\n}, \"strip\", z.ZodTypeAny, {\n    todos: {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }[];\n}, {\n    todos?: {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }[] | undefined;\n}>, undefined, any>;\nexport {};\n//# sourceMappingURL=todoListMiddleware.d.ts.map"],"mappings":";;;;cACqBC,kCAAAA;UAwBJU,yBAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6COC,kBAAAA,WAA6BD,4CAAiEX,CAAAA,CAAEM;SAC7GN,CAAAA,CAAEQ,WAAWR,CAAAA,CAAEO,SAASP,CAAAA,CAAEM;aACpBN,CAAAA,CAAEG;YACHH,CAAAA,CAAEI;cACFJ,CAAAA,CAAEK;;;;;;;YAONL,CAAAA,CAAEK"}
+{"version":3,"file":"todoListMiddleware.d.ts","names":["z","TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT","stateSchema","ZodString","ZodEnum","ZodTypeAny","ZodObject","ZodArray","ZodDefault","TodoMiddlewareState","infer","TodoListMiddlewareOptions","todoListMiddleware","__types_js12","AgentMiddleware"],"sources":["../../../src/agents/middleware/todoListMiddleware.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nexport declare const TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT = \"## `write_todos`\\n\\nYou have access to the `write_todos` tool to help you manage and plan complex objectives. \\nUse this tool for complex objectives to ensure that you are tracking each necessary step and giving the user visibility into your progress.\\nThis tool is very helpful for planning complex objectives, and for breaking down these larger complex objectives into smaller steps.\\n\\nIt is critical that you mark todos as completed as soon as you are done with a step. Do not batch up multiple steps before marking them as completed.\\nFor simple objectives that only require a few steps, it is better to just complete the objective directly and NOT use this tool.\\nWriting todos takes time and tokens, use it when it is helpful for managing complex many-step problems! But not for simple few-step requests.\\n\\n## Important To-Do List Usage Notes to Remember\\n- The `write_todos` tool should never be called multiple times in parallel.\\n- Don't be afraid to revise the To-Do list as you go. New information may reveal new tasks that need to be done, or old tasks that are irrelevant.\";\ndeclare const stateSchema: z.ZodObject<{\n    todos: z.ZodDefault<z.ZodArray<z.ZodObject<{\n        content: z.ZodString;\n        status: z.ZodEnum<[\"pending\", \"in_progress\", \"completed\"]>;\n    }, \"strip\", z.ZodTypeAny, {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }, {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }>, \"many\">>;\n}, \"strip\", z.ZodTypeAny, {\n    todos: {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }[];\n}, {\n    todos?: {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }[] | undefined;\n}>;\nexport type TodoMiddlewareState = z.infer<typeof stateSchema>;\nexport interface TodoListMiddlewareOptions {\n    /**\n     * Custom system prompt to guide the agent on using the todo tool.\n     * If not provided, uses the default {@link PLANNING_MIDDLEWARE_SYSTEM_PROMPT}.\n     */\n    systemPrompt?: string;\n    /**\n     * Custom description for the {@link writeTodos} tool.\n     * If not provided, uses the default {@link WRITE_TODOS_DESCRIPTION}.\n     */\n    toolDescription?: string;\n}\n/**\n * Creates a middleware that provides todo list management capabilities to agents.\n *\n * This middleware adds a `write_todos` tool that allows agents to create and manage\n * structured task lists for complex multi-step operations. It's designed to help\n * agents track progress, organize complex tasks, and provide users with visibility\n * into task completion status.\n *\n * The middleware automatically injects system prompts that guide the agent on when\n * and how to use the todo functionality effectively.\n *\n * @example\n * ```typescript\n * import { todoListMiddleware, createAgent } from 'langchain';\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [todoListMiddleware()],\n * });\n *\n * // Agent now has access to write_todos tool and todo state tracking\n * const result = await agent.invoke({\n *   messages: [new HumanMessage(\"Help me refactor my codebase\")]\n * });\n *\n * console.log(result.todos); // Array of todo items with status tracking\n * ```\n *\n * @returns A configured middleware instance that provides todo management capabilities\n *\n * @see {@link TodoMiddlewareState} for the state schema\n * @see {@link writeTodos} for the tool implementation\n */\nexport declare function todoListMiddleware(options?: TodoListMiddlewareOptions): import(\"./types.js\").AgentMiddleware<z.ZodObject<{\n    todos: z.ZodDefault<z.ZodArray<z.ZodObject<{\n        content: z.ZodString;\n        status: z.ZodEnum<[\"pending\", \"in_progress\", \"completed\"]>;\n    }, \"strip\", z.ZodTypeAny, {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }, {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }>, \"many\">>;\n}, \"strip\", z.ZodTypeAny, {\n    todos: {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }[];\n}, {\n    todos?: {\n        content: string;\n        status: \"completed\" | \"in_progress\" | \"pending\";\n    }[] | undefined;\n}>, undefined, any>;\nexport {};\n//# sourceMappingURL=todoListMiddleware.d.ts.map"],"mappings":";;;;cACqBC,kCAAAA;UAwBJU,yBAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6COC,kBAAAA,WAA6BD,4CAAiEX,CAAAA,CAAEM;SAC7GN,CAAAA,CAAEQ,WAAWR,CAAAA,CAAEO,SAASP,CAAAA,CAAEM;aACpBN,CAAAA,CAAEG;YACHH,CAAAA,CAAEI;cACFJ,CAAAA,CAAEK;;;;;;;YAONL,CAAAA,CAAEK"}

package/dist/agents/middleware/toolCallLimit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolCallLimit.d.ts","names":["z","InferInteropZodInput","ToolCallLimitExceededError","Error","ToolCallLimitOptionsSchema","ZodString","ZodOptional","ZodNumber","ZodEnum","ZodDefault","ZodTypeAny","ZodObject","ToolCallLimitConfig","toolCallLimitMiddleware","ZodRecord","Record","__types_js12","AgentMiddleware"],"sources":["../../../src/agents/middleware/toolCallLimit.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport type { InferInteropZodInput } from \"@langchain/core/utils/types\";\n/**\n * Exception raised when tool call limits are exceeded.\n *\n * This exception is raised when the configured exit behavior is 'error'\n * and either the thread or run tool call limit has been exceeded.\n */\nexport declare class ToolCallLimitExceededError extends Error {\n    /**\n     * Current thread tool call count.\n     */\n    threadCount: number;\n    /**\n     * Current run tool call count.\n     */\n    runCount: number;\n    /**\n     * Thread tool call limit (if set).\n     */\n    threadLimit: number | undefined;\n    /**\n     * Run tool call limit (if set).\n     */\n    runLimit: number | undefined;\n    /**\n     * Tool name being limited (if specific tool), or undefined for all tools.\n     */\n    toolName: string | undefined;\n    constructor(threadCount: number, runCount: number, threadLimit: number | undefined, runLimit: number | undefined, toolName?: string | undefined);\n}\n/**\n * Options for configuring the Tool Call Limit middleware.\n */\nexport declare const ToolCallLimitOptionsSchema: z.ZodObject<{\n    /**\n     * Name of the specific tool to limit. If undefined, limits apply to all tools.\n     */\n    toolName: z.ZodOptional<z.ZodString>;\n    /**\n     * Maximum number of tool calls allowed per thread.\n     * undefined means no limit.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * Maximum number of tool calls allowed per run.\n     * undefined means no limit.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * What to do when limits are exceeded.\n     * - \"continue\": Block exceeded tools with error messages, let other tools continue (default)\n     * - \"error\": Raise a ToolCallLimitExceededError exception\n     * - \"end\": Stop execution immediately, injecting a ToolMessage and an AI message\n     *   for the single tool call that exceeded the limit. Raises NotImplementedError\n     *   if there are multiple tool calls.\n     *\n     * @default \"continue\"\n     */\n    exitBehavior: z.ZodDefault<z.ZodEnum<[\"continue\", \"error\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    toolName?: string | undefined;\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior: \"continue\" | \"end\" | \"error\";\n}, {\n    toolName?: string | undefined;\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"continue\" | \"end\" | \"error\" | undefined;\n}>;\nexport type ToolCallLimitConfig = InferInteropZodInput<typeof ToolCallLimitOptionsSchema>;\n/**\n * Middleware that tracks tool call counts and enforces limits.\n *\n * This middleware monitors the number of tool calls made during agent execution\n * and can terminate the agent when specified limits are reached. It supports\n * both thread-level and run-level call counting with configurable exit behaviors.\n *\n * Thread-level: The middleware counts all tool calls in the entire message history\n * and persists this count across multiple runs (invocations) of the agent.\n *\n * Run-level: The middleware counts tool calls made after the last HumanMessage,\n * representing the current run (invocation) of the agent.\n *\n * @param options - Configuration options for the middleware\n * @param options.toolName - Name of the specific tool to limit. If undefined, limits apply to all tools.\n * @param options.threadLimit - Maximum number of tool calls allowed per thread. undefined means no limit.\n * @param options.runLimit - Maximum number of tool calls allowed per run. undefined means no limit.\n * @param options.exitBehavior - What to do when limits are exceeded.\n *   - \"continue\": Block exceeded tools with error messages, let other tools continue. Model decides when to end. (default)\n *   - \"error\": Raise a ToolCallLimitExceededError exception\n *   - \"end\": Stop execution immediately with a ToolMessage + AI message for the single tool call that exceeded the limit. Raises NotImplementedError if there are multiple tool calls.\n *\n * @throws {Error} If both limits are undefined, if exitBehavior is invalid, or if runLimit exceeds threadLimit.\n * @throws {NotImplementedError} If exitBehavior is \"end\" and there are multiple tool calls.\n *\n * @example Continue execution with blocked tools (default)\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * // Block exceeded tools but let other tools and model continue\n * const limiter = toolCallLimitMiddleware({\n *   threadLimit: 20,\n *   runLimit: 10,\n *   exitBehavior: \"continue\", // default\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [limiter]\n * });\n * ```\n *\n * @example Stop immediately when limit exceeded\n * ```ts\n * // End execution immediately with an AI message\n * const limiter = toolCallLimitMiddleware({\n *   runLimit: 5,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [limiter]\n * });\n * ```\n *\n * @example Raise exception on limit\n * ```ts\n * // Strict limit with exception handling\n * const limiter = toolCallLimitMiddleware({\n *   toolName: \"search\",\n *   threadLimit: 5,\n *   exitBehavior: \"error\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [limiter]\n * });\n *\n * try {\n *   const result = await agent.invoke({ messages: [new HumanMessage(\"Task\")] });\n * } catch (error) {\n *   if (error instanceof ToolCallLimitExceededError) {\n *     console.log(`Search limit exceeded: ${error}`);\n *   }\n * }\n * ```\n */\nexport declare function toolCallLimitMiddleware(options: ToolCallLimitConfig): import(\"./types.js\").AgentMiddleware<z.ZodObject<{\n    threadToolCallCount: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;\n    runToolCallCount: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadToolCallCount: Record<string, number>;\n    runToolCallCount: Record<string, number>;\n}, {\n    threadToolCallCount?: Record<string, number> | undefined;\n    runToolCallCount?: Record<string, number> | undefined;\n}>, undefined, any>;\n//# sourceMappingURL=toolCallLimit.d.ts.map"],"mappings":";;;;;;;;;AAQA;AA0BA;;AAIgBM,cA9BKJ,0BAAAA,SAAmCC,KAAK,CA8B7CG;EAKiBC;;;EAKjBD,WAAAA,EAAAA,MAAAA;EAWiBE;;;EAzBkBG,QAAAA,EAAAA,MAAAA;EAAS;AAqC5D;AAiFA;EAAyDC,WAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EACLP;;;EAAzBI,QAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EACsBJ;;;EAAzBI,QAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EACVC,WAAAA,CAAAA,WAAAA,EAAAA,MAAAA,EAAAA,QAAAA,EAAAA,MAAAA,EAAAA,WAAAA,EAAAA,MAAAA,GAAAA,SAAAA,EAAAA,QAAAA,EAAAA,MAAAA,GAAAA,SAAAA,EAAAA,QAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;;;;;AAHwGC,cAtHjGP,0BAsHiGO,EAtHrEX,CAAAA,CAAEW,SAsHmEA,CAAAA;;AAAH;;YAlHrGX,CAAAA,CAAEM,YAAYN,CAAAA,CAAEK;;;;;eAKbL,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;YAKnBP,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;;;;;;;gBAWZP,CAAAA,CAAES,WAAWT,CAAAA,CAAEQ;YACrBR,CAAAA,CAAEU;;;;;;;;;;;KAWFE,mBAAAA,GAAsBX,4BAA4BG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiFtCS,uBAAAA,UAAiCD,sCAA2DZ,CAAAA,CAAEW;uBAC7FX,CAAAA,CAAES,WAAWT,CAAAA,CAAEc,UAAUd,CAAAA,CAAEK,WAAWL,CAAAA,CAAEO;oBAC3CP,CAAAA,CAAES,WAAWT,CAAAA,CAAEc,UAAUd,CAAAA,CAAEK,WAAWL,CAAAA,CAAEO;YAClDP,CAAAA,CAAEU;uBACWK;oBACHA;;wBAEIA;qBACHA"}
+{"version":3,"file":"toolCallLimit.d.ts","names":["z","InferInteropZodInput","ToolCallLimitExceededError","Error","ToolCallLimitOptionsSchema","ZodString","ZodOptional","ZodNumber","ZodEnum","ZodDefault","ZodTypeAny","ZodObject","ToolCallLimitConfig","toolCallLimitMiddleware","ZodRecord","Record","__types_js11","AgentMiddleware"],"sources":["../../../src/agents/middleware/toolCallLimit.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport type { InferInteropZodInput } from \"@langchain/core/utils/types\";\n/**\n * Exception raised when tool call limits are exceeded.\n *\n * This exception is raised when the configured exit behavior is 'error'\n * and either the thread or run tool call limit has been exceeded.\n */\nexport declare class ToolCallLimitExceededError extends Error {\n    /**\n     * Current thread tool call count.\n     */\n    threadCount: number;\n    /**\n     * Current run tool call count.\n     */\n    runCount: number;\n    /**\n     * Thread tool call limit (if set).\n     */\n    threadLimit: number | undefined;\n    /**\n     * Run tool call limit (if set).\n     */\n    runLimit: number | undefined;\n    /**\n     * Tool name being limited (if specific tool), or undefined for all tools.\n     */\n    toolName: string | undefined;\n    constructor(threadCount: number, runCount: number, threadLimit: number | undefined, runLimit: number | undefined, toolName?: string | undefined);\n}\n/**\n * Options for configuring the Tool Call Limit middleware.\n */\nexport declare const ToolCallLimitOptionsSchema: z.ZodObject<{\n    /**\n     * Name of the specific tool to limit. If undefined, limits apply to all tools.\n     */\n    toolName: z.ZodOptional<z.ZodString>;\n    /**\n     * Maximum number of tool calls allowed per thread.\n     * undefined means no limit.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * Maximum number of tool calls allowed per run.\n     * undefined means no limit.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * What to do when limits are exceeded.\n     * - \"continue\": Block exceeded tools with error messages, let other tools continue (default)\n     * - \"error\": Raise a ToolCallLimitExceededError exception\n     * - \"end\": Stop execution immediately, injecting a ToolMessage and an AI message\n     *   for the single tool call that exceeded the limit. Raises NotImplementedError\n     *   if there are multiple tool calls.\n     *\n     * @default \"continue\"\n     */\n    exitBehavior: z.ZodDefault<z.ZodEnum<[\"continue\", \"error\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    toolName?: string | undefined;\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior: \"continue\" | \"end\" | \"error\";\n}, {\n    toolName?: string | undefined;\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"continue\" | \"end\" | \"error\" | undefined;\n}>;\nexport type ToolCallLimitConfig = InferInteropZodInput<typeof ToolCallLimitOptionsSchema>;\n/**\n * Middleware that tracks tool call counts and enforces limits.\n *\n * This middleware monitors the number of tool calls made during agent execution\n * and can terminate the agent when specified limits are reached. It supports\n * both thread-level and run-level call counting with configurable exit behaviors.\n *\n * Thread-level: The middleware counts all tool calls in the entire message history\n * and persists this count across multiple runs (invocations) of the agent.\n *\n * Run-level: The middleware counts tool calls made after the last HumanMessage,\n * representing the current run (invocation) of the agent.\n *\n * @param options - Configuration options for the middleware\n * @param options.toolName - Name of the specific tool to limit. If undefined, limits apply to all tools.\n * @param options.threadLimit - Maximum number of tool calls allowed per thread. undefined means no limit.\n * @param options.runLimit - Maximum number of tool calls allowed per run. undefined means no limit.\n * @param options.exitBehavior - What to do when limits are exceeded.\n *   - \"continue\": Block exceeded tools with error messages, let other tools continue. Model decides when to end. (default)\n *   - \"error\": Raise a ToolCallLimitExceededError exception\n *   - \"end\": Stop execution immediately with a ToolMessage + AI message for the single tool call that exceeded the limit. Raises NotImplementedError if there are multiple tool calls.\n *\n * @throws {Error} If both limits are undefined, if exitBehavior is invalid, or if runLimit exceeds threadLimit.\n * @throws {NotImplementedError} If exitBehavior is \"end\" and there are multiple tool calls.\n *\n * @example Continue execution with blocked tools (default)\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * // Block exceeded tools but let other tools and model continue\n * const limiter = toolCallLimitMiddleware({\n *   threadLimit: 20,\n *   runLimit: 10,\n *   exitBehavior: \"continue\", // default\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [limiter]\n * });\n * ```\n *\n * @example Stop immediately when limit exceeded\n * ```ts\n * // End execution immediately with an AI message\n * const limiter = toolCallLimitMiddleware({\n *   runLimit: 5,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [limiter]\n * });\n * ```\n *\n * @example Raise exception on limit\n * ```ts\n * // Strict limit with exception handling\n * const limiter = toolCallLimitMiddleware({\n *   toolName: \"search\",\n *   threadLimit: 5,\n *   exitBehavior: \"error\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [limiter]\n * });\n *\n * try {\n *   const result = await agent.invoke({ messages: [new HumanMessage(\"Task\")] });\n * } catch (error) {\n *   if (error instanceof ToolCallLimitExceededError) {\n *     console.log(`Search limit exceeded: ${error}`);\n *   }\n * }\n * ```\n */\nexport declare function toolCallLimitMiddleware(options: ToolCallLimitConfig): import(\"./types.js\").AgentMiddleware<z.ZodObject<{\n    threadToolCallCount: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;\n    runToolCallCount: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadToolCallCount: Record<string, number>;\n    runToolCallCount: Record<string, number>;\n}, {\n    threadToolCallCount?: Record<string, number> | undefined;\n    runToolCallCount?: Record<string, number> | undefined;\n}>, undefined, any>;\n//# sourceMappingURL=toolCallLimit.d.ts.map"],"mappings":";;;;;;;;;AAQA;AA0BA;;AAIgBM,cA9BKJ,0BAAAA,SAAmCC,KAAK,CA8B7CG;EAKiBC;;;EAKjBD,WAAAA,EAAAA,MAAAA;EAWiBE;;;EAzBkBG,QAAAA,EAAAA,MAAAA;EAAS;AAqC5D;AAiFA;EAAyDC,WAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EACLP;;;EAAzBI,QAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EACsBJ;;;EAAzBI,QAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EACVC,WAAAA,CAAAA,WAAAA,EAAAA,MAAAA,EAAAA,QAAAA,EAAAA,MAAAA,EAAAA,WAAAA,EAAAA,MAAAA,GAAAA,SAAAA,EAAAA,QAAAA,EAAAA,MAAAA,GAAAA,SAAAA,EAAAA,QAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;;;;;AAHwGC,cAtHjGP,0BAsHiGO,EAtHrEX,CAAAA,CAAEW,SAsHmEA,CAAAA;;AAAH;;YAlHrGX,CAAAA,CAAEM,YAAYN,CAAAA,CAAEK;;;;;eAKbL,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;YAKnBP,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;;;;;;;gBAWZP,CAAAA,CAAES,WAAWT,CAAAA,CAAEQ;YACrBR,CAAAA,CAAEU;;;;;;;;;;;KAWFE,mBAAAA,GAAsBX,4BAA4BG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiFtCS,uBAAAA,UAAiCD,sCAA2DZ,CAAAA,CAAEW;uBAC7FX,CAAAA,CAAES,WAAWT,CAAAA,CAAEc,UAAUd,CAAAA,CAAEK,WAAWL,CAAAA,CAAEO;oBAC3CP,CAAAA,CAAES,WAAWT,CAAAA,CAAEc,UAAUd,CAAAA,CAAEK,WAAWL,CAAAA,CAAEO;YAClDP,CAAAA,CAAEU;uBACWK;oBACHA;;wBAEIA;qBACHA"}

package/dist/agents/responses.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"responses.d.cts","names":["InteropZodObject","InteropZodType","AIMessage","LanguageModelLike","FunctionDefinition","StructuredOutputParsingError","MultipleStructuredOutputsError","ResponseFormatUndefined","ToolStrategy","S","_T","Record","ToolStrategyOptions","U","ProviderStrategy","T","ResponseFormat","transformResponseFormat","JsonSchemaFormat","TypedToolStrategy","Array","ToolStrategyError","Promise","toolStrategy","K","providerStrategy","hasSupportForJsonSchemaOutput"],"sources":["../../src/agents/responses.d.ts"],"sourcesContent":["import { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport { type AIMessage } from \"@langchain/core/messages\";\nimport { type LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { type FunctionDefinition } from \"@langchain/core/language_models/base\";\nimport { StructuredOutputParsingError, MultipleStructuredOutputsError } from \"./errors.js\";\n/**\n * Special type to indicate that no response format is provided.\n * When this type is used, the structuredResponse property should not be present in the result.\n */\nexport type ResponseFormatUndefined = {\n    __responseFormatUndefined: true;\n};\n/**\n * Information for tracking structured output tool metadata.\n * This contains all necessary information to handle structured responses generated\n * via tool calls, including the original schema, its type classification, and the\n * corresponding tool implementation used by the tools strategy.\n */\nexport declare class ToolStrategy<_T = unknown> {\n    readonly schema: Record<string, unknown>;\n    readonly tool: {\n        type: \"function\";\n        function: FunctionDefinition;\n    };\n    readonly options?: ToolStrategyOptions | undefined;\n    private constructor();\n    get name(): string;\n    static fromSchema<S extends InteropZodObject>(schema: S, outputOptions?: ToolStrategyOptions): ToolStrategy<S extends InteropZodType<infer U> ? U : unknown>;\n    static fromSchema(schema: Record<string, unknown>, outputOptions?: ToolStrategyOptions): ToolStrategy<Record<string, unknown>>;\n    /**\n     * Parse tool arguments according to the schema.\n     *\n     * @throws {StructuredOutputParsingError} if the response is not valid\n     * @param toolArgs - The arguments from the tool call\n     * @returns The parsed response according to the schema type\n     */\n    parse(toolArgs: Record<string, unknown>): Record<string, unknown>;\n}\nexport declare class ProviderStrategy<T = unknown> {\n    private _schemaType?;\n    /**\n     * The schema to use for the provider strategy\n     */\n    readonly schema: Record<string, unknown>;\n    /**\n     * Whether to use strict mode for the provider strategy\n     */\n    readonly strict: boolean;\n    private constructor();\n    private constructor();\n    static fromSchema<T>(schema: InteropZodType<T>, strict?: boolean): ProviderStrategy<T>;\n    static fromSchema(schema: Record<string, unknown>, strict?: boolean): ProviderStrategy<Record<string, unknown>>;\n    /**\n     * Parse tool arguments according to the schema. If the response is not valid, return undefined.\n     *\n     * @param response - The AI message response to parse\n     * @returns The parsed response according to the schema type\n     */\n    parse(response: AIMessage): any;\n}\nexport type ResponseFormat = ToolStrategy<any> | ProviderStrategy<any>;\n/**\n * Handle user input for `responseFormat` parameter of `CreateAgentParams`.\n * This function defines the default behavior for the `responseFormat` parameter, which is:\n *\n * - if value is a Zod schema, default to structured output via tool calling\n * - if value is a JSON schema, default to structured output via tool calling\n * - if value is a custom response format, return it as is\n * - if value is an array, ensure all array elements are instance of `ToolStrategy`\n * @param responseFormat - The response format to transform, provided by the user\n * @param options - The response format options for tool strategy\n * @param model - The model to check if it supports JSON schema output\n * @returns\n */\nexport declare function transformResponseFormat(responseFormat?: InteropZodType<any> | InteropZodType<any>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | ToolStrategy<any>[] | ResponseFormatUndefined, options?: ToolStrategyOptions, model?: LanguageModelLike | string): ResponseFormat[];\n/**\n * Branded type for ToolStrategy arrays that preserves type information\n */\nexport interface TypedToolStrategy<T = unknown> extends Array<ToolStrategy<any>> {\n    _schemaType?: T;\n}\nexport type ToolStrategyError = StructuredOutputParsingError | MultipleStructuredOutputsError;\nexport interface ToolStrategyOptions {\n    /**\n     * Allows you to customize the message that appears in the conversation history when structured\n     * output is generated.\n     */\n    toolMessageContent?: string;\n    /**\n     * Handle errors from the structured output tool call. Using tools to generate structured output\n     * can cause errors, e.g. if:\n     * - you provide multiple structured output schemas and the model calls multiple structured output tools\n     * - if the structured output generated by the tool call doesn't match provided schema\n     *\n     * This property allows to handle these errors in different ways:\n     * - `true` - retry the tool call\n     * - `false` - throw an error\n     * - `string` - retry the tool call with the provided message\n     * - `(error: ToolStrategyError) => Promise<string> | string` - retry with the provided message or throw the error\n     *\n     * @default true\n     */\n    handleError?: boolean | string | ((error: ToolStrategyError) => Promise<string> | string);\n}\nexport declare function toolStrategy<T extends InteropZodType<any>>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport declare function toolStrategy<T extends readonly InteropZodType<any>[]>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<{\n    [K in keyof T]: T[K] extends InteropZodType<infer U> ? U : never;\n}[number]>;\nexport declare function toolStrategy(responseFormat: JsonSchemaFormat, options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;\nexport declare function toolStrategy(responseFormat: JsonSchemaFormat[], options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;\n/**\n * Creates a provider strategy for structured output using native JSON schema support.\n *\n * This function is used to configure structured output for agents when the underlying model\n * supports native JSON schema output (e.g., OpenAI's `gpt-4o`, `gpt-4o-mini`, and newer models).\n * Unlike `toolStrategy`, which uses function calling to extract structured output, `providerStrategy`\n * leverages the provider's native structured output capabilities, resulting in more efficient\n * and reliable schema enforcement.\n *\n * When used with a model that supports JSON schema output, the model will return responses\n * that directly conform to the provided schema without requiring tool calls. This is the\n * recommended approach for structured output when your model supports it.\n *\n * @param responseFormat - The schema to enforce, either a Zod schema, a JSON schema object, or an options object with `schema` and optional `strict` flag\n * @returns A `ProviderStrategy` instance that can be used as the `responseFormat` in `createAgent`\n *\n * @example\n * ```ts\n * import { providerStrategy, createAgent } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const agent = createAgent({\n *   model: \"claude-haiku-4-5\",\n *   responseFormat: providerStrategy(\n *     z.object({\n *       answer: z.string().describe(\"The answer to the question\"),\n *       confidence: z.number().min(0).max(1),\n *     })\n *   ),\n * });\n * ```\n *\n * @example\n * ```ts\n * // Using strict mode for stricter schema enforcement\n * const agent = createAgent({\n *   model: \"claude-haiku-4-5\",\n *   responseFormat: providerStrategy({\n *     schema: z.object({\n *       name: z.string(),\n *       age: z.number(),\n *     }),\n *     strict: true\n *   }),\n * });\n * ```\n */\nexport declare function providerStrategy<T extends InteropZodType<unknown>>(responseFormat: T | {\n    schema: T;\n    strict?: boolean;\n}): ProviderStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport declare function providerStrategy(responseFormat: JsonSchemaFormat | {\n    schema: JsonSchemaFormat;\n    strict?: boolean;\n}): ProviderStrategy<Record<string, unknown>>;\n/**\n * Type representing a JSON Schema object format.\n * This is a strict type that excludes ToolStrategy and ProviderStrategy instances.\n */\nexport type JsonSchemaFormat = {\n    type: \"null\" | \"boolean\" | \"object\" | \"array\" | \"number\" | \"string\" | \"integer\";\n    properties?: Record<string, unknown>;\n    required?: string[];\n    additionalProperties?: boolean;\n    [key: string]: unknown;\n} & {\n    __brand?: never;\n};\n/**\n * Identifies the models that support JSON schema output\n * @param model - The model to check\n * @returns True if the model supports JSON schema output, false otherwise\n */\nexport declare function hasSupportForJsonSchemaOutput(model?: LanguageModelLike | string): boolean;\n//# sourceMappingURL=responses.d.ts.map"],"mappings":"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"}
+{"version":3,"file":"responses.d.cts","names":["InteropZodObject","InteropZodType","AIMessage","LanguageModelLike","FunctionDefinition","StructuredOutputParsingError","MultipleStructuredOutputsError","ResponseFormatUndefined","ToolStrategy","S","_T","Record","ToolStrategyOptions","U","ProviderStrategy","T","ResponseFormat","transformResponseFormat","JsonSchemaFormat","TypedToolStrategy","Array","ToolStrategyError","Promise","toolStrategy","K","providerStrategy","hasSupportForJsonSchemaOutput"],"sources":["../../src/agents/responses.d.ts"],"sourcesContent":["import { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport { type AIMessage } from \"@langchain/core/messages\";\nimport { type LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { type FunctionDefinition } from \"@langchain/core/language_models/base\";\nimport { StructuredOutputParsingError, MultipleStructuredOutputsError } from \"./errors.js\";\n/**\n * Special type to indicate that no response format is provided.\n * When this type is used, the structuredResponse property should not be present in the result.\n */\nexport type ResponseFormatUndefined = {\n    __responseFormatUndefined: true;\n};\n/**\n * Information for tracking structured output tool metadata.\n * This contains all necessary information to handle structured responses generated\n * via tool calls, including the original schema, its type classification, and the\n * corresponding tool implementation used by the tools strategy.\n */\nexport declare class ToolStrategy<_T = unknown> {\n    readonly schema: Record<string, unknown>;\n    readonly tool: {\n        type: \"function\";\n        function: FunctionDefinition;\n    };\n    readonly options?: ToolStrategyOptions | undefined;\n    private constructor();\n    get name(): string;\n    static fromSchema<S extends InteropZodObject>(schema: S, outputOptions?: ToolStrategyOptions): ToolStrategy<S extends InteropZodType<infer U> ? U : unknown>;\n    static fromSchema(schema: Record<string, unknown>, outputOptions?: ToolStrategyOptions): ToolStrategy<Record<string, unknown>>;\n    /**\n     * Parse tool arguments according to the schema.\n     *\n     * @throws {StructuredOutputParsingError} if the response is not valid\n     * @param toolArgs - The arguments from the tool call\n     * @returns The parsed response according to the schema type\n     */\n    parse(toolArgs: Record<string, unknown>): Record<string, unknown>;\n}\nexport declare class ProviderStrategy<T = unknown> {\n    private _schemaType?;\n    /**\n     * The schema to use for the provider strategy\n     */\n    readonly schema: Record<string, unknown>;\n    /**\n     * Whether to use strict mode for the provider strategy\n     */\n    readonly strict: boolean;\n    private constructor();\n    private constructor();\n    static fromSchema<T>(schema: InteropZodType<T>, strict?: boolean): ProviderStrategy<T>;\n    static fromSchema(schema: Record<string, unknown>, strict?: boolean): ProviderStrategy<Record<string, unknown>>;\n    /**\n     * Parse tool arguments according to the schema. If the response is not valid, return undefined.\n     *\n     * @param response - The AI message response to parse\n     * @returns The parsed response according to the schema type\n     */\n    parse(response: AIMessage): any;\n}\nexport type ResponseFormat = ToolStrategy<any> | ProviderStrategy<any>;\n/**\n * Handle user input for `responseFormat` parameter of `CreateAgentParams`.\n * This function defines the default behavior for the `responseFormat` parameter, which is:\n *\n * - if value is a Zod schema, default to structured output via tool calling\n * - if value is a JSON schema, default to structured output via tool calling\n * - if value is a custom response format, return it as is\n * - if value is an array, ensure all array elements are instance of `ToolStrategy`\n * @param responseFormat - The response format to transform, provided by the user\n * @param options - The response format options for tool strategy\n * @param model - The model to check if it supports JSON schema output\n * @returns\n */\nexport declare function transformResponseFormat(responseFormat?: InteropZodType<any> | InteropZodType<any>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | ToolStrategy<any>[] | ResponseFormatUndefined, options?: ToolStrategyOptions, model?: LanguageModelLike | string): ResponseFormat[];\n/**\n * Branded type for ToolStrategy arrays that preserves type information\n */\nexport interface TypedToolStrategy<T = unknown> extends Array<ToolStrategy<any>> {\n    _schemaType?: T;\n}\nexport type ToolStrategyError = StructuredOutputParsingError | MultipleStructuredOutputsError;\nexport interface ToolStrategyOptions {\n    /**\n     * Allows you to customize the message that appears in the conversation history when structured\n     * output is generated.\n     */\n    toolMessageContent?: string;\n    /**\n     * Handle errors from the structured output tool call. Using tools to generate structured output\n     * can cause errors, e.g. if:\n     * - you provide multiple structured output schemas and the model calls multiple structured output tools\n     * - if the structured output generated by the tool call doesn't match provided schema\n     *\n     * This property allows to handle these errors in different ways:\n     * - `true` - retry the tool call\n     * - `false` - throw an error\n     * - `string` - retry the tool call with the provided message\n     * - `(error: ToolStrategyError) => Promise<string> | string` - retry with the provided message or throw the error\n     *\n     * @default true\n     */\n    handleError?: boolean | string | ((error: ToolStrategyError) => Promise<string> | string);\n}\nexport declare function toolStrategy<T extends InteropZodType<any>>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport declare function toolStrategy<T extends readonly InteropZodType<any>[]>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<{\n    [K in keyof T]: T[K] extends InteropZodType<infer U> ? U : never;\n}[number]>;\nexport declare function toolStrategy(responseFormat: JsonSchemaFormat, options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;\nexport declare function toolStrategy(responseFormat: JsonSchemaFormat[], options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;\n/**\n * Creates a provider strategy for structured output using native JSON schema support.\n *\n * This function is used to configure structured output for agents when the underlying model\n * supports native JSON schema output (e.g., OpenAI's `gpt-4o`, `gpt-4o-mini`, and newer models).\n * Unlike `toolStrategy`, which uses function calling to extract structured output, `providerStrategy`\n * leverages the provider's native structured output capabilities, resulting in more efficient\n * and reliable schema enforcement.\n *\n * When used with a model that supports JSON schema output, the model will return responses\n * that directly conform to the provided schema without requiring tool calls. This is the\n * recommended approach for structured output when your model supports it.\n *\n * @param responseFormat - The schema to enforce, either a Zod schema, a JSON schema object, or an options object with `schema` and optional `strict` flag\n * @returns A `ProviderStrategy` instance that can be used as the `responseFormat` in `createAgent`\n *\n * @example\n * ```ts\n * import { providerStrategy, createAgent } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const agent = createAgent({\n *   model: \"claude-haiku-4-5\",\n *   responseFormat: providerStrategy(\n *     z.object({\n *       answer: z.string().describe(\"The answer to the question\"),\n *       confidence: z.number().min(0).max(1),\n *     })\n *   ),\n * });\n * ```\n *\n * @example\n * ```ts\n * // Using strict mode for stricter schema enforcement\n * const agent = createAgent({\n *   model: \"claude-haiku-4-5\",\n *   responseFormat: providerStrategy({\n *     schema: z.object({\n *       name: z.string(),\n *       age: z.number(),\n *     }),\n *     strict: true\n *   }),\n * });\n * ```\n */\nexport declare function providerStrategy<T extends InteropZodType<unknown>>(responseFormat: T | {\n    schema: T;\n    strict?: boolean;\n}): ProviderStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport declare function providerStrategy(responseFormat: JsonSchemaFormat | {\n    schema: JsonSchemaFormat;\n    strict?: boolean;\n}): ProviderStrategy<Record<string, unknown>>;\n/**\n * Type representing a JSON Schema object format.\n * This is a strict type that excludes ToolStrategy and ProviderStrategy instances.\n */\nexport type JsonSchemaFormat = {\n    type: \"null\" | \"boolean\" | \"object\" | \"array\" | \"number\" | \"string\" | \"integer\";\n    properties?: Record<string, unknown>;\n    required?: string[];\n    additionalProperties?: boolean;\n    [key: string]: unknown;\n} & {\n    __brand?: never;\n};\n/**\n * Identifies the models that support JSON schema output\n * @param model - The model to check\n * @returns True if the model supports JSON schema output, false otherwise\n */\nexport declare function hasSupportForJsonSchemaOutput(model?: LanguageModelLike | string): boolean;\n//# sourceMappingURL=responses.d.ts.map"],"mappings":"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"}

package/dist/agents/types.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.cts","names":["InteropZodObject","InteropZodType","START","END","StateGraph","LanguageModelLike","BaseMessage","SystemMessage","BaseCheckpointSaver","BaseStore","Messages","ClientTool","ServerTool","ResponseFormat","ToolStrategy","TypedToolStrategy","ProviderStrategy","JsonSchemaFormat","ResponseFormatUndefined","AgentMiddleware","AnyAnnotationRoot","InferSchemaInput","JumpToTarget","N","Interrupt","TValue","BuiltInState","UserInput","TStateSchema","ToolCall","Record","ToolResult","JumpTo","ExecutedToolCall","CreateAgentParams","StructuredResponseType","StateSchema","ContextSchema","ResponseFormatType","AbortSignal","ExtractZodArrayTypes","T","Rest","A","WithStateGraphNodes","K","Graph","SD","S","U","I","O","C"],"sources":["../../src/agents/types.d.ts"],"sourcesContent":["import type { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport type { START, END, StateGraph } from \"@langchain/langgraph\";\nimport type { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport type { BaseMessage, SystemMessage } from \"@langchain/core/messages\";\nimport type { BaseCheckpointSaver, BaseStore } from \"@langchain/langgraph-checkpoint\";\nimport type { Messages } from \"@langchain/langgraph/\";\nimport type { ClientTool, ServerTool } from \"@langchain/core/tools\";\nimport type { ResponseFormat, ToolStrategy, TypedToolStrategy, ProviderStrategy, JsonSchemaFormat, ResponseFormatUndefined } from \"./responses.js\";\nimport type { AgentMiddleware, AnyAnnotationRoot, InferSchemaInput } from \"./middleware/types.js\";\nimport type { JumpToTarget } from \"./constants.js\";\nexport type N = typeof START | \"model_request\" | \"tools\";\n/**\n * Represents information about an interrupt.\n */\nexport interface Interrupt<TValue = unknown> {\n    /**\n     * The ID of the interrupt.\n     */\n    id: string;\n    /**\n     * The requests for human input.\n     */\n    value: TValue;\n}\nexport interface BuiltInState {\n    messages: BaseMessage[];\n    __interrupt__?: Interrupt[];\n    /**\n     * Optional property to control routing after afterModel middleware execution.\n     * When set by middleware, the agent will jump to the specified node instead of\n     * following normal routing logic. The property is automatically cleared after use.\n     *\n     * - \"model_request\": Jump back to the model for another LLM call\n     * - \"tools\": Jump to tool execution (requires tools to be available)\n     */\n    jumpTo?: JumpToTarget;\n}\n/**\n * Base input type for `.invoke` and `.stream` methods.\n */\nexport type UserInput<TStateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined> = InferSchemaInput<TStateSchema> & {\n    messages: Messages;\n};\n/**\n * Information about a tool call that has been executed.\n */\nexport interface ToolCall {\n    /**\n     * The ID of the tool call.\n     */\n    id: string;\n    /**\n     * The name of the tool that was called.\n     */\n    name: string;\n    /**\n     * The arguments that were passed to the tool.\n     */\n    args: Record<string, any>;\n    /**\n     * The result of the tool call.\n     */\n    result?: unknown;\n    /**\n     * An optional error message if the tool call failed.\n     */\n    error?: string;\n}\n/**\n * Information about a tool result from a tool execution.\n */\nexport interface ToolResult {\n    /**\n     * The ID of the tool call.\n     */\n    id: string;\n    /**\n     * The result of the tool call.\n     */\n    result: any;\n    /**\n     * An optional error message if the tool call failed.\n     */\n    error?: string;\n}\n/**\n * jump targets (internal)\n */\nexport type JumpTo = \"model_request\" | \"tools\" | typeof END;\n/**\n * Information about a tool call that has been executed.\n */\nexport interface ExecutedToolCall {\n    /**\n     * The name of the tool that was called.\n     */\n    name: string;\n    /**\n     * The arguments that were passed to the tool.\n     */\n    args: Record<string, unknown>;\n    /**\n     * The ID of the tool call.\n     */\n    tool_id: string;\n    /**\n     * The result of the tool call (if available).\n     */\n    result?: unknown;\n}\nexport type CreateAgentParams<StructuredResponseType extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ResponseFormatType = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined> = {\n    /**\n     * Defines a model to use for the agent. You can either pass in an instance of a LangChain chat model\n     * or a string. If a string is provided the agent initializes a ChatModel based on the provided model name and provider.\n     * It supports various model providers and allows for runtime configuration of model parameters.\n     *\n     * @uses {@link initChatModel}\n     * @example\n     * ```ts\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-7-sonnet-latest\",\n     *   // ...\n     * });\n     * ```\n     *\n     * @example\n     * ```ts\n     * import { ChatOpenAI } from \"@langchain/openai\";\n     * const agent = createAgent({\n     *   model: new ChatOpenAI({ model: \"gpt-4o\" }),\n     *   // ...\n     * });\n     * ```\n     */\n    model: string | LanguageModelLike;\n    /**\n     * A list of tools or a ToolNode.\n     *\n     * @example\n     * ```ts\n     * import { tool } from \"langchain\";\n     *\n     * const weatherTool = tool(() => \"Sunny!\", {\n     *   name: \"get_weather\",\n     *   description: \"Get the weather for a location\",\n     *   schema: z.object({\n     *     location: z.string().describe(\"The location to get weather for\"),\n     *   }),\n     * });\n     *\n     * const agent = createAgent({\n     *   tools: [weatherTool],\n     *   // ...\n     * });\n     * ```\n     */\n    tools?: (ServerTool | ClientTool)[];\n    /**\n     * An optional system message for the model.\n     *\n     * **Use a `string`** for simple, static system prompts. This is the most common use case\n     * and works well with template literals for dynamic content. When a string is provided,\n     * it's converted to a single text block internally.\n     *\n     * **Use a `SystemMessage`** when you need advanced features that require structured content:\n     * - **Anthropic cache control**: Use `SystemMessage` with array content to enable per-block\n     *   cache control settings (e.g., `cache_control: { type: \"ephemeral\" }`). This allows you\n     *   to have different cache settings for different parts of your system prompt.\n     * - **Multiple content blocks**: When you need multiple text blocks with different metadata\n     *   or formatting requirements.\n     * - **Integration with existing code**: When working with code that already produces\n     *   `SystemMessage` instances.\n     *\n     * @example Using a string (recommended for most cases)\n     * ```ts\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-5-sonnet\",\n     *   systemPrompt: \"You are a helpful assistant.\",\n     *   // ...\n     * });\n     * ```\n     *\n     * @example Using a string with template literals\n     * ```ts\n     * const userRole = \"premium\";\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-5-sonnet\",\n     *   systemPrompt: `You are a helpful assistant for ${userRole} users.`,\n     *   // ...\n     * });\n     * ```\n     *\n     * @example Using SystemMessage with cache control (Anthropic)\n     * ```ts\n     * import { SystemMessage } from \"@langchain/core/messages\";\n     *\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-5-sonnet\",\n     *   systemPrompt: new SystemMessage({\n     *     content: [\n     *       {\n     *         type: \"text\",\n     *         text: \"You are a helpful assistant.\",\n     *       },\n     *       {\n     *         type: \"text\",\n     *         text: \"Today's date is 2024-06-01.\",\n     *         cache_control: { type: \"ephemeral\" },\n     *       },\n     *     ],\n     *   }),\n     *   // ...\n     * });\n     * ```\n     *\n     * @example Using SystemMessage (simple)\n     * ```ts\n     * import { SystemMessage } from \"@langchain/core/messages\";\n     *\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-5-sonnet\",\n     *   systemPrompt: new SystemMessage(\"You are a helpful assistant.\"),\n     *   // ...\n     * });\n     * ```\n     */\n    systemPrompt?: string | SystemMessage;\n    /**\n     * An optional schema for the agent state. It allows you to define custom state properties that persist\n     * across agent invocations and can be accessed in hooks, middleware, and throughout the agent's execution.\n     * The state is persisted when using a checkpointer and can be updated by middleware or during execution.\n     *\n     * As opposed to the context (defined in `contextSchema`), the state is persisted between agent invocations\n     * when using a checkpointer, making it suitable for maintaining conversation history, user preferences,\n     * or any other data that should persist across multiple interactions.\n     *\n     * @example\n     * ```ts\n     * import { z } from \"zod\";\n     * import { createAgent } from \"@langchain/langgraph\";\n     *\n     * const agent = createAgent({\n     *   model: \"openai:gpt-4o\",\n     *   tools: [getWeather],\n     *   stateSchema: z.object({\n     *     userPreferences: z.object({\n     *       temperatureUnit: z.enum([\"celsius\", \"fahrenheit\"]).default(\"celsius\"),\n     *       location: z.string().optional(),\n     *     }).optional(),\n     *     conversationCount: z.number().default(0),\n     *   }),\n     *   prompt: (state, config) => {\n     *     const unit = state.userPreferences?.temperatureUnit || \"celsius\";\n     *     return [\n     *       new SystemMessage(`You are a helpful assistant. Use ${unit} for temperature.`),\n     *     ];\n     *   },\n     * });\n     *\n     * const result = await agent.invoke({\n     *   messages: [\n     *     new HumanMessage(\"What's the weather like?\"),\n     *   ],\n     *   userPreferences: {\n     *     temperatureUnit: \"fahrenheit\",\n     *     location: \"New York\",\n     *   },\n     *   conversationCount: 1,\n     * });\n     * ```\n     */\n    stateSchema?: StateSchema;\n    /**\n     * An optional schema for the context. It allows to pass in a typed context object into the agent\n     * invocation and allows to access it in hooks such as `prompt` and middleware.\n     * As opposed to the agent state, defined in `stateSchema`, the context is not persisted between\n     * agent invocations.\n     *\n     * @example\n     * ```ts\n     * const agent = createAgent({\n     *   llm: model,\n     *   tools: [getWeather],\n     *   contextSchema: z.object({\n     *     capital: z.string(),\n     *   }),\n     *   prompt: (state, config) => {\n     *     return [\n     *       new SystemMessage(`You are a helpful assistant. The capital of France is ${config.context.capital}.`),\n     *     ];\n     *   },\n     * });\n     *\n     * const result = await agent.invoke({\n     *   messages: [\n     *     new SystemMessage(\"You are a helpful assistant.\"),\n     *     new HumanMessage(\"What is the capital of France?\"),\n     *   ],\n     * }, {\n     *   context: {\n     *     capital: \"Paris\",\n     *   },\n     * });\n     * ```\n     */\n    contextSchema?: ContextSchema;\n    /**\n     * An optional checkpoint saver to persist the agent's state.\n     * @see {@link https://docs.langchain.com/oss/javascript/langgraph/persistence | Checkpointing}\n     */\n    checkpointer?: BaseCheckpointSaver | boolean;\n    /**\n     * An optional store to persist the agent's state.\n     * @see {@link https://docs.langchain.com/oss/javascript/langgraph/memory#memory-storage | Long-term memory}\n     */\n    store?: BaseStore;\n    /**\n     * An optional schema for the final agent output.\n     *\n     * If provided, output will be formatted to match the given schema and returned in the 'structuredResponse' state key.\n     * If not provided, `structuredResponse` will not be present in the output state.\n     *\n     * Can be passed in as:\n     *   - Zod schema\n     *     ```ts\n     *     const agent = createAgent({\n     *       responseFormat: z.object({\n     *         capital: z.string(),\n     *       }),\n     *       // ...\n     *     });\n     *     ```\n     *   - JSON schema\n     *     ```ts\n     *     const agent = createAgent({\n     *       responseFormat: {\n     *         type: \"json_schema\",\n     *         schema: {\n     *           type: \"object\",\n     *           properties: {\n     *             capital: { type: \"string\" },\n     *           },\n     *           required: [\"capital\"],\n     *         },\n     *       },\n     *       // ...\n     *     });\n     *     ```\n     *   - Create React Agent ResponseFormat\n     *     ```ts\n     *     import { providerStrategy, toolStrategy } from \"langchain\";\n     *     const agent = createAgent({\n     *       responseFormat: providerStrategy(\n     *         z.object({\n     *           capital: z.string(),\n     *         })\n     *       ),\n     *       // or\n     *       responseFormat: [\n     *         toolStrategy({ ... }),\n     *         toolStrategy({ ... }),\n     *       ]\n     *       // ...\n     *     });\n     *     ```\n     *\n     * **Note**: The graph will make a separate call to the LLM to generate the structured response after the agent loop is finished.\n     * This is not the only strategy to get structured responses, see more options in [this guide](https://langchain-ai.github.io/langgraph/how-tos/react-agent-structured-output/).\n     */\n    responseFormat?: ResponseFormatType;\n    /**\n     * Middleware instances to run during agent execution.\n     * Each middleware can define its own state schema and hook into the agent lifecycle.\n     *\n     * @see {@link https://docs.langchain.com/oss/javascript/langchain/middleware | Middleware}\n     */\n    middleware?: readonly AgentMiddleware<any, any, any>[];\n    /**\n     * An optional name for the agent.\n     */\n    name?: string;\n    /**\n     * An optional description for the agent.\n     * This can be used to describe the agent to the underlying supervisor LLM.\n     */\n    description?: string;\n    /**\n     * Use to specify how to expose the agent name to the underlying supervisor LLM.\n     *   - `undefined`: Relies on the LLM provider {@link AIMessage#name}. Currently, only OpenAI supports this.\n     *   - `\"inline\"`: Add the agent name directly into the content field of the {@link AIMessage} using XML-style tags.\n     *       Example: `\"How can I help you\"` -> `\"<name>agent_name</name><content>How can I help you?</content>\"`\n     */\n    includeAgentName?: \"inline\" | undefined;\n    /**\n     * An optional abort signal that indicates that the overall operation should be aborted.\n     */\n    signal?: AbortSignal;\n    /**\n     * Determines the version of the graph to create.\n     *\n     * Can be one of\n     * - `\"v1\"`: The tool node processes a single message. All tool calls in the message are\n     *           executed in parallel within the tool node.\n     * - `\"v2\"`: The tool node processes a single tool call. Tool calls are distributed across\n     *           multiple instances of the tool node using the Send API.\n     *\n     * @default `\"v2\"`\n     */\n    version?: \"v1\" | \"v2\";\n};\n/**\n * Type helper to extract union type from an array of Zod schemas\n */\nexport type ExtractZodArrayTypes<T extends readonly InteropZodType<any>[]> = T extends readonly [InteropZodType<infer A>, ...infer Rest] ? Rest extends readonly InteropZodType<any>[] ? A | ExtractZodArrayTypes<Rest> : A : never;\nexport type WithStateGraphNodes<K extends string, Graph> = Graph extends StateGraph<infer SD, infer S, infer U, infer N, infer I, infer O, infer C> ? StateGraph<SD, S, U, N | K, I, O, C> : never;\n//# sourceMappingURL=types.d.ts.map"],"mappings":";;;;;;;;;;;;KAUYuB,CAAAA,UAAWrB;;AAAvB;AAIA;AAUiBwB,UAVAF,SAUY,CAAA,SAAA,OAAA,CAAA,CAAA;EACflB;;;EAUW,EAAA,EAAA,MAAA;EAKbqB;;;EAAgHC,KAAAA,EAlBjHH,MAkBiHG;;AAC9GlB,UAjBGgB,YAAAA,CAiBHhB;EAAQ,QAAA,EAhBRJ,WAgBQ,EAAA;EAKLuB,aAAQ,CAAA,EApBLL,SAgCVM,EAAAA;EAaOC;AAiBjB;AAIA;AAkBA;;;;;EAAgNX,MAAAA,CAAAA,EA3EnME,YA2EmMF;;;;;AAAwHnB,KAtE5T0B,SAsE4T1B,CAAAA,qBAtE7RmB,iBAsE6RnB,GAtEzQD,gBAsEyQC,GAAAA,SAAAA,GAAAA,SAAAA,CAAAA,GAtE7NoB,gBAsE6NpB,CAtE5M2B,YAsE4M3B,CAAAA,GAAAA;EAA4BgB,QAAAA,EArEtVP,QAqEsVO;CAAmBA;;;;AAA+FkB,UAhErcN,UAAAA,CAgEqcM;EAAbrB;;;EAAkFI,EAAAA,EAAAA,MAAAA;EAwBvgBb;;;EA4FQE,IAAAA,EAAAA,MAAAA;EA6CV6B;;;EA4CN3B,IAAAA,EAjQFqB,MAiQErB,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;EAsDS6B;;;EA2BG,MAAA,CAAA,EAAA,OAAA;EAiBZE;;;EAAqFvC,KAAAA,CAAAA,EAAAA,MAAAA;;;;;AAA4FuC,UAtV5KT,UAAAA,CAsV4KS;EAA6BG;AAAC;AAC3N;EAA2DG,EAAAA,EAAAA,MAAAA;EAAc1C;;;EAA+F6C,MAAAA,EAAAA,GAAAA;EAAG1B;;;EAAU4B,KAAAA,CAAAA,EAAAA,MAAAA;;;AAArB;;KAtUpJnB,MAAAA,sCAA4C7B;;;;UAIvC8B,gBAAAA;;;;;;;;QAQPH;;;;;;;;;;KAUEI,iDAAiDJ,sBAAsBA,yCAAyCV,oBAAoBpB,gEAAgEoB,oBAAoBpB,mBAAmBoB,wCAAwCnB,eAAekC,0BAA0BlC,4BAA4BgB,mBAAmBA,qBAAqBJ,iBAAiBE,kBAAkBoB,0BAA0BrB,aAAaqB,0BAA0BnB,iBAAiBmB,0BAA0BjB;;;;;;;;;;;;;;;;;;;;;;;;kBAwBvgBb;;;;;;;;;;;;;;;;;;;;;;WAsBPO,aAAaD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAsEEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA6CV6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkCEC;;;;;iBAKD7B;;;;;UAKPC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAsDS6B;;;;;;;wBAOKnB;;;;;;;;;;;;;;;;;;;;WAoBboB;;;;;;;;;;;;;;;;;KAiBDC,wCAAwCvC,yBAAyBwC,oBAAoBxC,0CAA0CyC,sBAAsBzC,wBAAwB0C,IAAIH,qBAAqBE,QAAQC;KAC9MC,+CAA+CE,cAAc1C,6EAA6EA,WAAW2C,IAAIC,GAAGC,GAAG1B,IAAIsB,GAAGK,GAAGC,GAAGC"}
+{"version":3,"file":"types.d.cts","names":["InteropZodObject","InteropZodType","START","END","StateGraph","LanguageModelLike","BaseMessage","SystemMessage","BaseCheckpointSaver","BaseStore","Messages","ClientTool","ServerTool","ResponseFormat","ToolStrategy","TypedToolStrategy","ProviderStrategy","JsonSchemaFormat","ResponseFormatUndefined","AgentMiddleware","AnyAnnotationRoot","InferSchemaInput","JumpToTarget","N","Interrupt","TValue","BuiltInState","UserInput","TStateSchema","ToolCall","Record","ToolResult","JumpTo","ExecutedToolCall","CreateAgentParams","StructuredResponseType","StateSchema","ContextSchema","ResponseFormatType","AbortSignal","ExtractZodArrayTypes","T","Rest","A","WithStateGraphNodes","K","Graph","SD","S","U","I","O","C"],"sources":["../../src/agents/types.d.ts"],"sourcesContent":["import type { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport type { START, END, StateGraph } from \"@langchain/langgraph\";\nimport type { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport type { BaseMessage, SystemMessage } from \"@langchain/core/messages\";\nimport type { BaseCheckpointSaver, BaseStore } from \"@langchain/langgraph-checkpoint\";\nimport type { Messages } from \"@langchain/langgraph/\";\nimport type { ClientTool, ServerTool } from \"@langchain/core/tools\";\nimport type { ResponseFormat, ToolStrategy, TypedToolStrategy, ProviderStrategy, JsonSchemaFormat, ResponseFormatUndefined } from \"./responses.js\";\nimport type { AgentMiddleware, AnyAnnotationRoot, InferSchemaInput } from \"./middleware/types.js\";\nimport type { JumpToTarget } from \"./constants.js\";\nexport type N = typeof START | \"model_request\" | \"tools\";\n/**\n * Represents information about an interrupt.\n */\nexport interface Interrupt<TValue = unknown> {\n    /**\n     * The ID of the interrupt.\n     */\n    id: string;\n    /**\n     * The requests for human input.\n     */\n    value: TValue;\n}\nexport interface BuiltInState {\n    messages: BaseMessage[];\n    __interrupt__?: Interrupt[];\n    /**\n     * Optional property to control routing after afterModel middleware execution.\n     * When set by middleware, the agent will jump to the specified node instead of\n     * following normal routing logic. The property is automatically cleared after use.\n     *\n     * - \"model_request\": Jump back to the model for another LLM call\n     * - \"tools\": Jump to tool execution (requires tools to be available)\n     */\n    jumpTo?: JumpToTarget;\n}\n/**\n * Base input type for `.invoke` and `.stream` methods.\n */\nexport type UserInput<TStateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined> = InferSchemaInput<TStateSchema> & {\n    messages: Messages;\n};\n/**\n * Information about a tool call that has been executed.\n */\nexport interface ToolCall {\n    /**\n     * The ID of the tool call.\n     */\n    id: string;\n    /**\n     * The name of the tool that was called.\n     */\n    name: string;\n    /**\n     * The arguments that were passed to the tool.\n     */\n    args: Record<string, any>;\n    /**\n     * The result of the tool call.\n     */\n    result?: unknown;\n    /**\n     * An optional error message if the tool call failed.\n     */\n    error?: string;\n}\n/**\n * Information about a tool result from a tool execution.\n */\nexport interface ToolResult {\n    /**\n     * The ID of the tool call.\n     */\n    id: string;\n    /**\n     * The result of the tool call.\n     */\n    result: any;\n    /**\n     * An optional error message if the tool call failed.\n     */\n    error?: string;\n}\n/**\n * jump targets (internal)\n */\nexport type JumpTo = \"model_request\" | \"tools\" | typeof END;\n/**\n * Information about a tool call that has been executed.\n */\nexport interface ExecutedToolCall {\n    /**\n     * The name of the tool that was called.\n     */\n    name: string;\n    /**\n     * The arguments that were passed to the tool.\n     */\n    args: Record<string, unknown>;\n    /**\n     * The ID of the tool call.\n     */\n    tool_id: string;\n    /**\n     * The result of the tool call (if available).\n     */\n    result?: unknown;\n}\nexport type CreateAgentParams<StructuredResponseType extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ResponseFormatType = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined> = {\n    /**\n     * Defines a model to use for the agent. You can either pass in an instance of a LangChain chat model\n     * or a string. If a string is provided the agent initializes a ChatModel based on the provided model name and provider.\n     * It supports various model providers and allows for runtime configuration of model parameters.\n     *\n     * @uses {@link initChatModel}\n     * @example\n     * ```ts\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-7-sonnet-latest\",\n     *   // ...\n     * });\n     * ```\n     *\n     * @example\n     * ```ts\n     * import { ChatOpenAI } from \"@langchain/openai\";\n     * const agent = createAgent({\n     *   model: new ChatOpenAI({ model: \"gpt-4o\" }),\n     *   // ...\n     * });\n     * ```\n     */\n    model: string | LanguageModelLike;\n    /**\n     * A list of tools or a ToolNode.\n     *\n     * @example\n     * ```ts\n     * import { tool } from \"langchain\";\n     *\n     * const weatherTool = tool(() => \"Sunny!\", {\n     *   name: \"get_weather\",\n     *   description: \"Get the weather for a location\",\n     *   schema: z.object({\n     *     location: z.string().describe(\"The location to get weather for\"),\n     *   }),\n     * });\n     *\n     * const agent = createAgent({\n     *   tools: [weatherTool],\n     *   // ...\n     * });\n     * ```\n     */\n    tools?: (ServerTool | ClientTool)[];\n    /**\n     * An optional system message for the model.\n     *\n     * **Use a `string`** for simple, static system prompts. This is the most common use case\n     * and works well with template literals for dynamic content. When a string is provided,\n     * it's converted to a single text block internally.\n     *\n     * **Use a `SystemMessage`** when you need advanced features that require structured content:\n     * - **Anthropic cache control**: Use `SystemMessage` with array content to enable per-block\n     *   cache control settings (e.g., `cache_control: { type: \"ephemeral\" }`). This allows you\n     *   to have different cache settings for different parts of your system prompt.\n     * - **Multiple content blocks**: When you need multiple text blocks with different metadata\n     *   or formatting requirements.\n     * - **Integration with existing code**: When working with code that already produces\n     *   `SystemMessage` instances.\n     *\n     * @example Using a string (recommended for most cases)\n     * ```ts\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-5-sonnet\",\n     *   systemPrompt: \"You are a helpful assistant.\",\n     *   // ...\n     * });\n     * ```\n     *\n     * @example Using a string with template literals\n     * ```ts\n     * const userRole = \"premium\";\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-5-sonnet\",\n     *   systemPrompt: `You are a helpful assistant for ${userRole} users.`,\n     *   // ...\n     * });\n     * ```\n     *\n     * @example Using SystemMessage with cache control (Anthropic)\n     * ```ts\n     * import { SystemMessage } from \"@langchain/core/messages\";\n     *\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-5-sonnet\",\n     *   systemPrompt: new SystemMessage({\n     *     content: [\n     *       {\n     *         type: \"text\",\n     *         text: \"You are a helpful assistant.\",\n     *       },\n     *       {\n     *         type: \"text\",\n     *         text: \"Today's date is 2024-06-01.\",\n     *         cache_control: { type: \"ephemeral\" },\n     *       },\n     *     ],\n     *   }),\n     *   // ...\n     * });\n     * ```\n     *\n     * @example Using SystemMessage (simple)\n     * ```ts\n     * import { SystemMessage } from \"@langchain/core/messages\";\n     *\n     * const agent = createAgent({\n     *   model: \"anthropic:claude-3-5-sonnet\",\n     *   systemPrompt: new SystemMessage(\"You are a helpful assistant.\"),\n     *   // ...\n     * });\n     * ```\n     */\n    systemPrompt?: string | SystemMessage;\n    /**\n     * An optional schema for the agent state. It allows you to define custom state properties that persist\n     * across agent invocations and can be accessed in hooks, middleware, and throughout the agent's execution.\n     * The state is persisted when using a checkpointer and can be updated by middleware or during execution.\n     *\n     * As opposed to the context (defined in `contextSchema`), the state is persisted between agent invocations\n     * when using a checkpointer, making it suitable for maintaining conversation history, user preferences,\n     * or any other data that should persist across multiple interactions.\n     *\n     * @example\n     * ```ts\n     * import { z } from \"zod\";\n     * import { createAgent } from \"@langchain/langgraph\";\n     *\n     * const agent = createAgent({\n     *   model: \"openai:gpt-4o\",\n     *   tools: [getWeather],\n     *   stateSchema: z.object({\n     *     userPreferences: z.object({\n     *       temperatureUnit: z.enum([\"celsius\", \"fahrenheit\"]).default(\"celsius\"),\n     *       location: z.string().optional(),\n     *     }).optional(),\n     *     conversationCount: z.number().default(0),\n     *   }),\n     *   prompt: (state, config) => {\n     *     const unit = state.userPreferences?.temperatureUnit || \"celsius\";\n     *     return [\n     *       new SystemMessage(`You are a helpful assistant. Use ${unit} for temperature.`),\n     *     ];\n     *   },\n     * });\n     *\n     * const result = await agent.invoke({\n     *   messages: [\n     *     new HumanMessage(\"What's the weather like?\"),\n     *   ],\n     *   userPreferences: {\n     *     temperatureUnit: \"fahrenheit\",\n     *     location: \"New York\",\n     *   },\n     *   conversationCount: 1,\n     * });\n     * ```\n     */\n    stateSchema?: StateSchema;\n    /**\n     * An optional schema for the context. It allows to pass in a typed context object into the agent\n     * invocation and allows to access it in hooks such as `prompt` and middleware.\n     * As opposed to the agent state, defined in `stateSchema`, the context is not persisted between\n     * agent invocations.\n     *\n     * @example\n     * ```ts\n     * const agent = createAgent({\n     *   llm: model,\n     *   tools: [getWeather],\n     *   contextSchema: z.object({\n     *     capital: z.string(),\n     *   }),\n     *   prompt: (state, config) => {\n     *     return [\n     *       new SystemMessage(`You are a helpful assistant. The capital of France is ${config.context.capital}.`),\n     *     ];\n     *   },\n     * });\n     *\n     * const result = await agent.invoke({\n     *   messages: [\n     *     new SystemMessage(\"You are a helpful assistant.\"),\n     *     new HumanMessage(\"What is the capital of France?\"),\n     *   ],\n     * }, {\n     *   context: {\n     *     capital: \"Paris\",\n     *   },\n     * });\n     * ```\n     */\n    contextSchema?: ContextSchema;\n    /**\n     * An optional checkpoint saver to persist the agent's state.\n     * @see {@link https://docs.langchain.com/oss/javascript/langgraph/persistence | Checkpointing}\n     */\n    checkpointer?: BaseCheckpointSaver | boolean;\n    /**\n     * An optional store to persist the agent's state.\n     * @see {@link https://docs.langchain.com/oss/javascript/langgraph/memory#memory-storage | Long-term memory}\n     */\n    store?: BaseStore;\n    /**\n     * An optional schema for the final agent output.\n     *\n     * If provided, output will be formatted to match the given schema and returned in the 'structuredResponse' state key.\n     * If not provided, `structuredResponse` will not be present in the output state.\n     *\n     * Can be passed in as:\n     *   - Zod schema\n     *     ```ts\n     *     const agent = createAgent({\n     *       responseFormat: z.object({\n     *         capital: z.string(),\n     *       }),\n     *       // ...\n     *     });\n     *     ```\n     *   - JSON schema\n     *     ```ts\n     *     const agent = createAgent({\n     *       responseFormat: {\n     *         type: \"json_schema\",\n     *         schema: {\n     *           type: \"object\",\n     *           properties: {\n     *             capital: { type: \"string\" },\n     *           },\n     *           required: [\"capital\"],\n     *         },\n     *       },\n     *       // ...\n     *     });\n     *     ```\n     *   - Create React Agent ResponseFormat\n     *     ```ts\n     *     import { providerStrategy, toolStrategy } from \"langchain\";\n     *     const agent = createAgent({\n     *       responseFormat: providerStrategy(\n     *         z.object({\n     *           capital: z.string(),\n     *         })\n     *       ),\n     *       // or\n     *       responseFormat: [\n     *         toolStrategy({ ... }),\n     *         toolStrategy({ ... }),\n     *       ]\n     *       // ...\n     *     });\n     *     ```\n     *\n     * **Note**: The graph will make a separate call to the LLM to generate the structured response after the agent loop is finished.\n     * This is not the only strategy to get structured responses, see more options in [this guide](https://langchain-ai.github.io/langgraph/how-tos/react-agent-structured-output/).\n     */\n    responseFormat?: ResponseFormatType;\n    /**\n     * Middleware instances to run during agent execution.\n     * Each middleware can define its own state schema and hook into the agent lifecycle.\n     *\n     * @see {@link https://docs.langchain.com/oss/javascript/langchain/middleware | Middleware}\n     */\n    middleware?: readonly AgentMiddleware<any, any, any>[];\n    /**\n     * An optional name for the agent.\n     */\n    name?: string;\n    /**\n     * An optional description for the agent.\n     * This can be used to describe the agent to the underlying supervisor LLM.\n     */\n    description?: string;\n    /**\n     * Use to specify how to expose the agent name to the underlying supervisor LLM.\n     *   - `undefined`: Relies on the LLM provider {@link AIMessage#name}. Currently, only OpenAI supports this.\n     *   - `\"inline\"`: Add the agent name directly into the content field of the {@link AIMessage} using XML-style tags.\n     *       Example: `\"How can I help you\"` -> `\"<name>agent_name</name><content>How can I help you?</content>\"`\n     */\n    includeAgentName?: \"inline\" | undefined;\n    /**\n     * An optional abort signal that indicates that the overall operation should be aborted.\n     */\n    signal?: AbortSignal;\n    /**\n     * Determines the version of the graph to create.\n     *\n     * Can be one of\n     * - `\"v1\"`: The tool node processes a single message. All tool calls in the message are\n     *           executed in parallel within the tool node.\n     * - `\"v2\"`: The tool node processes a single tool call. Tool calls are distributed across\n     *           multiple instances of the tool node using the Send API.\n     *\n     * @default `\"v2\"`\n     */\n    version?: \"v1\" | \"v2\";\n};\n/**\n * Type helper to extract union type from an array of Zod schemas\n */\nexport type ExtractZodArrayTypes<T extends readonly InteropZodType<any>[]> = T extends readonly [InteropZodType<infer A>, ...infer Rest] ? Rest extends readonly InteropZodType<any>[] ? A | ExtractZodArrayTypes<Rest> : A : never;\nexport type WithStateGraphNodes<K extends string, Graph> = Graph extends StateGraph<infer SD, infer S, infer U, infer N, infer I, infer O, infer C> ? StateGraph<SD, S, U, N | K, I, O, C> : never;\n//# sourceMappingURL=types.d.ts.map"],"mappings":";;;;;;;;;;;;KAUYuB,CAAAA,UAAWrB;;AAAvB;AAIA;AAUiBwB,UAVAF,SAUY,CAAA,SAAA,OAAA,CAAA,CAAA;EACflB;;;EAUW,EAAA,EAAA,MAAA;EAKbqB;;;EAAgHC,KAAAA,EAlBjHH,MAkBiHG;;AAC9GlB,UAjBGgB,YAAAA,CAiBHhB;EAAQ,QAAA,EAhBRJ,WAgBQ,EAAA;EAKLuB,aAAQ,CAAA,EApBLL,SAoBK,EAYfM;EAaOC;AAiBjB;AAIA;AAkBA;;;;;EAAgNX,MAAAA,CAAAA,EA3EnME,YA2EmMF;;;;;AAAwHnB,KAtE5T0B,SAsE4T1B,CAAAA,qBAtE7RmB,iBAsE6RnB,GAtEzQD,gBAsEyQC,GAAAA,SAAAA,GAAAA,SAAAA,CAAAA,GAtE7NoB,gBAsE6NpB,CAtE5M2B,YAsE4M3B,CAAAA,GAAAA;EAA4BgB,QAAAA,EArEtVP,QAqEsVO;CAAmBA;;;;AAA+FkB,UAhErcN,UAAAA,CAgEqcM;EAAbrB;;;EAAkFI,EAAAA,EAAAA,MAAAA;EAwBvgBb;;;EA4FQE,IAAAA,EAAAA,MAAAA;EA6CV6B;;;EA4CN3B,IAAAA,EAjQFqB,MAiQErB,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;EAsDS6B;;;EA2BG,MAAA,CAAA,EAAA,OAAA;EAiBZE;;;EAAqFvC,KAAAA,CAAAA,EAAAA,MAAAA;;;;;AAA4FuC,UAtV5KT,UAAAA,CAsV4KS;EAA6BG;AAAC;AAC3N;EAA2DG,EAAAA,EAAAA,MAAAA;EAAc1C;;;EAA+F6C,MAAAA,EAAAA,GAAAA;EAAG1B;;;EAAU4B,KAAAA,CAAAA,EAAAA,MAAAA;;;AAArB;;KAtUpJnB,MAAAA,sCAA4C7B;;;;UAIvC8B,gBAAAA;;;;;;;;QAQPH;;;;;;;;;;KAUEI,iDAAiDJ,sBAAsBA,yCAAyCV,oBAAoBpB,gEAAgEoB,oBAAoBpB,mBAAmBoB,wCAAwCnB,eAAekC,0BAA0BlC,4BAA4BgB,mBAAmBA,qBAAqBJ,iBAAiBE,kBAAkBoB,0BAA0BrB,aAAaqB,0BAA0BnB,iBAAiBmB,0BAA0BjB;;;;;;;;;;;;;;;;;;;;;;;;kBAwBvgBb;;;;;;;;;;;;;;;;;;;;;;WAsBPO,aAAaD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAsEEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA6CV6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkCEC;;;;;iBAKD7B;;;;;UAKPC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAsDS6B;;;;;;;wBAOKnB;;;;;;;;;;;;;;;;;;;;WAoBboB;;;;;;;;;;;;;;;;;KAiBDC,wCAAwCvC,yBAAyBwC,oBAAoBxC,0CAA0CyC,sBAAsBzC,wBAAwB0C,IAAIH,qBAAqBE,QAAQC;KAC9MC,+CAA+CE,cAAc1C,6EAA6EA,WAAW2C,IAAIC,GAAGC,GAAG1B,IAAIsB,GAAGK,GAAGC,GAAGC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langchain",
-  "version": "1.1.6",
+  "version": "1.2.1",
   "description": "Typescript bindings for langchain",
   "author": "LangChain",
   "license": "MIT",
@@ -53,15 +53,15 @@
     "typescript": "~5.8.3",
     "vitest": "^3.2.4",
     "yaml": "^2.8.1",
-    "@langchain/anthropic": "1.3.0",
+    "@langchain/anthropic": "1.3.1",
     "@langchain/cohere": "1.0.1",
-    "@langchain/core": "1.1.5",
+    "@langchain/core": "1.1.6",
     "@langchain/eslint": "0.1.1",
     "@langchain/openai": "1.2.0",
     "@langchain/tsconfig": "0.0.1"
   },
   "peerDependencies": {
-    "@langchain/core": "1.1.5"
+    "@langchain/core": "1.1.6"
   },
   "dependencies": {
     "@langchain/langgraph": "^1.0.0",