langchain 1.0.0-alpha.9 → 1.0.2

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

@@ -1 +1 @@
-{"version":3,"file":"toolCallLimit.d.cts","names":["z","InferInteropZodInput","ToolCallLimitExceededError","Error","ToolCallLimitOptionsSchema","ZodString","ZodOptional","ZodNumber","ZodEnum","ZodDefault","ZodTypeAny","ZodObject","ToolCallLimitConfig","toolCallLimitMiddleware","__types_js6","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     * - \"end\": Jump to the end of the agent execution and inject an artificial\n     *   AI message indicating that the limit was exceeded.\n     * - \"error\": throws a ToolCallLimitExceededError\n     */\n    exitBehavior: z.ZodDefault<z.ZodEnum<[\"end\", \"error\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    toolName?: string | undefined;\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior: \"end\" | \"error\";\n}, {\n    toolName?: string | undefined;\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"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 *   - \"end\": Jump to the end of the agent execution and inject an artificial AI message indicating that the limit was exceeded.\n *   - \"error\": throws a ToolCallLimitExceededError\n *\n * @throws {Error} If both limits are undefined or if exitBehavior is invalid.\n *\n * @example Limit all tool calls globally\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * const globalLimiter = toolCallLimitMiddleware({\n *   threadLimit: 20,\n *   runLimit: 10,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [globalLimiter]\n * });\n * ```\n *\n * @example Limit a specific tool\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * const searchLimiter = toolCallLimitMiddleware({\n *   toolName: \"search\",\n *   threadLimit: 5,\n *   runLimit: 3,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [searchLimiter]\n * });\n * ```\n *\n * @example Use both in the same agent\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * const globalLimiter = toolCallLimitMiddleware({\n *   threadLimit: 20,\n *   runLimit: 10,\n *   exitBehavior: \"end\"\n * });\n *\n * const searchLimiter = toolCallLimitMiddleware({\n *   toolName: \"search\",\n *   threadLimit: 5,\n *   runLimit: 3,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [globalLimiter, searchLimiter]\n * });\n * ```\n */\nexport declare function toolCallLimitMiddleware(options: ToolCallLimitConfig): import(\"./types.js\").AgentMiddleware<undefined, undefined, any>;\n"],"mappings":";;;;;;;;;AAQA;AA0BA;;AAI4BA,cA9BPE,0BAAAA,SAAmCC,KAAK,CA8B/BE;EAAS;;;EAKT,WAKAE,EAAAA,MAAAA;EAAS;;;EAOT,QAChBG,EAAAA,MAAAA;EAAU;AAtBoC;AAiC5D;EAA+B,WAAA,EAAA,MAAA,GAAA,SAAA;EAAA;;AAAuB;EAmF9BG,QAAAA,EAAAA,MAAAA,GAAAA,SAAuB;EAAA;;;EAAoE,QAAA,EAAA,MAAA,GAAA,SAAA;;;;;;cApH9FT,4BAA4BJ,CAAAA,CAAEW;;;;YAIrCX,CAAAA,CAAEM,YAAYN,CAAAA,CAAEK;;;;;eAKbL,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;YAKnBP,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;;;gBAOZP,CAAAA,CAAES,WAAWT,CAAAA,CAAEQ;YACrBR,CAAAA,CAAEU;;;;;;;;;;;KAWFE,mBAAAA,GAAsBX,4BAA4BG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmFtCS,uBAAAA,UAAiCD,sBAAmB"}
+{"version":3,"file":"toolCallLimit.d.cts","names":["z","InferInteropZodInput","ToolCallLimitExceededError","Error","ToolCallLimitOptionsSchema","ZodString","ZodOptional","ZodNumber","ZodEnum","ZodDefault","ZodTypeAny","ZodObject","ToolCallLimitConfig","toolCallLimitMiddleware","__types_js2","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     * - \"end\": Jump to the end of the agent execution and inject an artificial\n     *   AI message indicating that the limit was exceeded.\n     * - \"error\": throws a ToolCallLimitExceededError\n     */\n    exitBehavior: z.ZodDefault<z.ZodEnum<[\"end\", \"error\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    toolName?: string | undefined;\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior: \"end\" | \"error\";\n}, {\n    toolName?: string | undefined;\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"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 *   - \"end\": Jump to the end of the agent execution and inject an artificial AI message indicating that the limit was exceeded.\n *   - \"error\": throws a ToolCallLimitExceededError\n *\n * @throws {Error} If both limits are undefined or if exitBehavior is invalid.\n *\n * @example Limit all tool calls globally\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * const globalLimiter = toolCallLimitMiddleware({\n *   threadLimit: 20,\n *   runLimit: 10,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [globalLimiter]\n * });\n * ```\n *\n * @example Limit a specific tool\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * const searchLimiter = toolCallLimitMiddleware({\n *   toolName: \"search\",\n *   threadLimit: 5,\n *   runLimit: 3,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [searchLimiter]\n * });\n * ```\n *\n * @example Use both in the same agent\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * const globalLimiter = toolCallLimitMiddleware({\n *   threadLimit: 20,\n *   runLimit: 10,\n *   exitBehavior: \"end\"\n * });\n *\n * const searchLimiter = toolCallLimitMiddleware({\n *   toolName: \"search\",\n *   threadLimit: 5,\n *   runLimit: 3,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [globalLimiter, searchLimiter]\n * });\n * ```\n */\nexport declare function toolCallLimitMiddleware(options: ToolCallLimitConfig): import(\"./types.js\").AgentMiddleware<undefined, undefined, any>;\n"],"mappings":";;;;;;;;;AAQA;AA0BA;;AAI4BA,cA9BPE,0BAAAA,SAAmCC,KAAK,CA8B/BE;EAAS;;;EAKT,WAKAE,EAAAA,MAAAA;EAAS;;;EAOT,QAChBG,EAAAA,MAAAA;EAAU;AAtBoC;AAiC5D;EAA+B,WAAA,EAAA,MAAA,GAAA,SAAA;EAAA;;AAAuB;EAmF9BG,QAAAA,EAAAA,MAAAA,GAAAA,SAAuB;EAAA;;;EAAoE,QAAA,EAAA,MAAA,GAAA,SAAA;;;;;;cApH9FT,4BAA4BJ,CAAAA,CAAEW;;;;YAIrCX,CAAAA,CAAEM,YAAYN,CAAAA,CAAEK;;;;;eAKbL,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;YAKnBP,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;;;gBAOZP,CAAAA,CAAES,WAAWT,CAAAA,CAAEQ;YACrBR,CAAAA,CAAEU;;;;;;;;;;;KAWFE,mBAAAA,GAAsBX,4BAA4BG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmFtCS,uBAAAA,UAAiCD,sBAAmB"}

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","__types_js3","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     * - \"end\": Jump to the end of the agent execution and inject an artificial\n     *   AI message indicating that the limit was exceeded.\n     * - \"error\": throws a ToolCallLimitExceededError\n     */\n    exitBehavior: z.ZodDefault<z.ZodEnum<[\"end\", \"error\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    toolName?: string | undefined;\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior: \"end\" | \"error\";\n}, {\n    toolName?: string | undefined;\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"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 *   - \"end\": Jump to the end of the agent execution and inject an artificial AI message indicating that the limit was exceeded.\n *   - \"error\": throws a ToolCallLimitExceededError\n *\n * @throws {Error} If both limits are undefined or if exitBehavior is invalid.\n *\n * @example Limit all tool calls globally\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * const globalLimiter = toolCallLimitMiddleware({\n *   threadLimit: 20,\n *   runLimit: 10,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [globalLimiter]\n * });\n * ```\n *\n * @example Limit a specific tool\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * const searchLimiter = toolCallLimitMiddleware({\n *   toolName: \"search\",\n *   threadLimit: 5,\n *   runLimit: 3,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [searchLimiter]\n * });\n * ```\n *\n * @example Use both in the same agent\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * const globalLimiter = toolCallLimitMiddleware({\n *   threadLimit: 20,\n *   runLimit: 10,\n *   exitBehavior: \"end\"\n * });\n *\n * const searchLimiter = toolCallLimitMiddleware({\n *   toolName: \"search\",\n *   threadLimit: 5,\n *   runLimit: 3,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [globalLimiter, searchLimiter]\n * });\n * ```\n */\nexport declare function toolCallLimitMiddleware(options: ToolCallLimitConfig): import(\"./types.js\").AgentMiddleware<undefined, undefined, any>;\n"],"mappings":";;;;;;;;;AAQA;AA0BA;;AAI4BA,cA9BPE,0BAAAA,SAAmCC,KAAK,CA8B/BE;EAAS;;;EAKT,WAKAE,EAAAA,MAAAA;EAAS;;;EAOT,QAChBG,EAAAA,MAAAA;EAAU;AAtBoC;AAiC5D;EAA+B,WAAA,EAAA,MAAA,GAAA,SAAA;EAAA;;AAAuB;EAmF9BG,QAAAA,EAAAA,MAAAA,GAAAA,SAAuB;EAAA;;;EAAoE,QAAA,EAAA,MAAA,GAAA,SAAA;;;;;;cApH9FT,4BAA4BJ,CAAAA,CAAEW;;;;YAIrCX,CAAAA,CAAEM,YAAYN,CAAAA,CAAEK;;;;;eAKbL,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;YAKnBP,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;;;gBAOZP,CAAAA,CAAES,WAAWT,CAAAA,CAAEQ;YACrBR,CAAAA,CAAEU;;;;;;;;;;;KAWFE,mBAAAA,GAAsBX,4BAA4BG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmFtCS,uBAAAA,UAAiCD,sBAAmB"}
+{"version":3,"file":"toolCallLimit.d.ts","names":["z","InferInteropZodInput","ToolCallLimitExceededError","Error","ToolCallLimitOptionsSchema","ZodString","ZodOptional","ZodNumber","ZodEnum","ZodDefault","ZodTypeAny","ZodObject","ToolCallLimitConfig","toolCallLimitMiddleware","__types_js10","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     * - \"end\": Jump to the end of the agent execution and inject an artificial\n     *   AI message indicating that the limit was exceeded.\n     * - \"error\": throws a ToolCallLimitExceededError\n     */\n    exitBehavior: z.ZodDefault<z.ZodEnum<[\"end\", \"error\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    toolName?: string | undefined;\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior: \"end\" | \"error\";\n}, {\n    toolName?: string | undefined;\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"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 *   - \"end\": Jump to the end of the agent execution and inject an artificial AI message indicating that the limit was exceeded.\n *   - \"error\": throws a ToolCallLimitExceededError\n *\n * @throws {Error} If both limits are undefined or if exitBehavior is invalid.\n *\n * @example Limit all tool calls globally\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * const globalLimiter = toolCallLimitMiddleware({\n *   threadLimit: 20,\n *   runLimit: 10,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [globalLimiter]\n * });\n * ```\n *\n * @example Limit a specific tool\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * const searchLimiter = toolCallLimitMiddleware({\n *   toolName: \"search\",\n *   threadLimit: 5,\n *   runLimit: 3,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [searchLimiter]\n * });\n * ```\n *\n * @example Use both in the same agent\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * const globalLimiter = toolCallLimitMiddleware({\n *   threadLimit: 20,\n *   runLimit: 10,\n *   exitBehavior: \"end\"\n * });\n *\n * const searchLimiter = toolCallLimitMiddleware({\n *   toolName: \"search\",\n *   threadLimit: 5,\n *   runLimit: 3,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [globalLimiter, searchLimiter]\n * });\n * ```\n */\nexport declare function toolCallLimitMiddleware(options: ToolCallLimitConfig): import(\"./types.js\").AgentMiddleware<undefined, undefined, any>;\n"],"mappings":";;;;;;;;;AAQA;AA0BA;;AAI4BA,cA9BPE,0BAAAA,SAAmCC,KAAK,CA8B/BE;EAAS;;;EAKT,WAKAE,EAAAA,MAAAA;EAAS;;;EAOT,QAChBG,EAAAA,MAAAA;EAAU;AAtBoC;AAiC5D;EAA+B,WAAA,EAAA,MAAA,GAAA,SAAA;EAAA;;AAAuB;EAmF9BG,QAAAA,EAAAA,MAAAA,GAAAA,SAAuB;EAAA;;;EAAoE,QAAA,EAAA,MAAA,GAAA,SAAA;;;;;;cApH9FT,4BAA4BJ,CAAAA,CAAEW;;;;YAIrCX,CAAAA,CAAEM,YAAYN,CAAAA,CAAEK;;;;;eAKbL,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;YAKnBP,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;;;gBAOZP,CAAAA,CAAES,WAAWT,CAAAA,CAAEQ;YACrBR,CAAAA,CAAEU;;;;;;;;;;;KAWFE,mBAAAA,GAAsBX,4BAA4BG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmFtCS,uBAAAA,UAAiCD,sBAAmB"}

package/dist/agents/middleware/toolCallLimit.js

@@ -203,34 +203,36 @@ function toolCallLimitMiddleware(options) {
 	const middlewareName = options.toolName ? `ToolCallLimitMiddleware[${options.toolName}]` : "ToolCallLimitMiddleware";
 	return createMiddleware({
 		name: middlewareName,
-		beforeModelJumpTo: ["end"],
-		async beforeModel(state) {
-			const messages = state.messages;
-			/**
-			* Count tool calls in entire thread
-			*/
-			const threadCount = countToolCallsInMessages(messages, options.toolName);
-			/**
-			* Count tool calls in current run (after last HumanMessage)
-			*/
-			const runMessages = getRunMessages(messages);
-			const runCount = countToolCallsInMessages(runMessages, options.toolName);
-			/**
-			* Check if any limits are exceeded
-			*/
-			const threadLimitExceeded = options.threadLimit !== void 0 && threadCount >= options.threadLimit;
-			const runLimitExceeded = options.runLimit !== void 0 && runCount >= options.runLimit;
-			if (!threadLimitExceeded && !runLimitExceeded) return void 0;
-			if (exitBehavior === "error") throw new ToolCallLimitExceededError(threadCount, runCount, options.threadLimit, options.runLimit, options.toolName);
-			/**
-			* Create a message indicating the limit was exceeded
-			*/
-			const limitMessage = buildToolLimitExceededMessage(threadCount, runCount, options.threadLimit, options.runLimit, options.toolName);
-			const limitAiMessage = new AIMessage(limitMessage);
-			return {
-				jumpTo: "end",
-				messages: [limitAiMessage]
-			};
+		beforeModel: {
+			canJumpTo: ["end"],
+			hook: (state) => {
+				const messages = state.messages;
+				/**
+				* Count tool calls in entire thread
+				*/
+				const threadCount = countToolCallsInMessages(messages, options.toolName);
+				/**
+				* Count tool calls in current run (after last HumanMessage)
+				*/
+				const runMessages = getRunMessages(messages);
+				const runCount = countToolCallsInMessages(runMessages, options.toolName);
+				/**
+				* Check if any limits are exceeded
+				*/
+				const threadLimitExceeded = options.threadLimit !== void 0 && threadCount >= options.threadLimit;
+				const runLimitExceeded = options.runLimit !== void 0 && runCount >= options.runLimit;
+				if (!threadLimitExceeded && !runLimitExceeded) return void 0;
+				if (exitBehavior === "error") throw new ToolCallLimitExceededError(threadCount, runCount, options.threadLimit, options.runLimit, options.toolName);
+				/**
+				* Create a message indicating the limit was exceeded
+				*/
+				const limitMessage = buildToolLimitExceededMessage(threadCount, runCount, options.threadLimit, options.runLimit, options.toolName);
+				const limitAiMessage = new AIMessage(limitMessage);
+				return {
+					jumpTo: "end",
+					messages: [limitAiMessage]
+				};
+			}
 		}
 	});
 }

package/dist/agents/middleware/toolCallLimit.js.map

@@ -1 +1 @@
-{"version":3,"file":"toolCallLimit.js","names":["messages: BaseMessage[]","toolName?: string","threadCount: number","runCount: number","threadLimit: number | undefined","runLimit: number | undefined","toolName: string | undefined","exceededLimits: string[]","options: ToolCallLimitConfig","state: AgentBuiltInState"],"sources":["../../../src/agents/middleware/toolCallLimit.ts"],"sourcesContent":["/**\n * Tool call limit middleware for agents.\n */\n\nimport { AIMessage, BaseMessage, HumanMessage } from \"@langchain/core/messages\";\nimport { z } from \"zod/v3\";\nimport type { InferInteropZodInput } from \"@langchain/core/utils/types\";\n\nimport { createMiddleware } from \"../middleware.js\";\nimport type { AgentBuiltInState } from \"../runtime.js\";\n\n/**\n * Count tool calls in a list of messages.\n *\n * @param messages - List of messages to count tool calls in.\n * @param toolName - If specified, only count calls to this specific tool.\n *   If undefined, count all tool calls.\n * @returns The total number of tool calls (optionally filtered by toolName).\n */\nfunction countToolCallsInMessages(\n  messages: BaseMessage[],\n  toolName?: string\n): number {\n  let count = 0;\n  for (const message of messages) {\n    if (AIMessage.isInstance(message) && message.tool_calls) {\n      if (toolName === undefined) {\n        // Count all tool calls\n        count += message.tool_calls.length;\n      } else {\n        // Count only calls to the specified tool\n        count += message.tool_calls.filter((tc) => tc.name === toolName).length;\n      }\n    }\n  }\n  return count;\n}\n\n/**\n * Get messages from the current run (after the last HumanMessage).\n *\n * @param messages - Full list of messages.\n * @returns Messages from the current run (after last HumanMessage).\n */\nfunction getRunMessages(messages: BaseMessage[]): BaseMessage[] {\n  /**\n   * Find the last HumanMessage\n   */\n  let lastHumanIndex = -1;\n  for (let i = messages.length - 1; i >= 0; i--) {\n    if (HumanMessage.isInstance(messages[i])) {\n      lastHumanIndex = i;\n      break;\n    }\n  }\n\n  /**\n   * If no HumanMessage found, return all messages\n   */\n  if (lastHumanIndex === -1) {\n    return messages;\n  }\n\n  /**\n   * Return messages after the last HumanMessage\n   */\n  return messages.slice(lastHumanIndex + 1);\n}\n\n/**\n * Build a message indicating which tool call limits were reached.\n *\n * @param threadCount - Current thread tool call count.\n * @param runCount - Current run tool call count.\n * @param threadLimit - Thread tool call limit (if set).\n * @param runLimit - Run tool call limit (if set).\n * @param toolName - Tool name being limited (if specific tool), or undefined for all tools.\n * @returns A formatted message describing which limits were reached.\n */\nfunction buildToolLimitExceededMessage(\n  threadCount: number,\n  runCount: number,\n  threadLimit: number | undefined,\n  runLimit: number | undefined,\n  toolName: string | undefined\n): string {\n  const toolDesc = toolName ? `'${toolName}' tool call` : \"Tool call\";\n  const exceededLimits: string[] = [];\n\n  if (threadLimit !== undefined && threadCount >= threadLimit) {\n    exceededLimits.push(`thread limit reached (${threadCount}/${threadLimit})`);\n  }\n  if (runLimit !== undefined && runCount >= runLimit) {\n    exceededLimits.push(`run limit reached (${runCount}/${runLimit})`);\n  }\n\n  return `${toolDesc} limit${\n    exceededLimits.length > 1 ? \"s\" : \"\"\n  }: ${exceededLimits.join(\", \")}. Stopping to prevent further tool calls.`;\n}\n\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 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\n  constructor(\n    threadCount: number,\n    runCount: number,\n    threadLimit: number | undefined,\n    runLimit: number | undefined,\n    toolName: string | undefined = undefined\n  ) {\n    const message = buildToolLimitExceededMessage(\n      threadCount,\n      runCount,\n      threadLimit,\n      runLimit,\n      toolName\n    );\n    super(message);\n\n    this.name = \"ToolCallLimitExceededError\";\n    this.threadCount = threadCount;\n    this.runCount = runCount;\n    this.threadLimit = threadLimit;\n    this.runLimit = runLimit;\n    this.toolName = toolName;\n  }\n}\n\n/**\n * Options for configuring the Tool Call Limit middleware.\n */\nexport const ToolCallLimitOptionsSchema = z.object({\n  /**\n   * Name of the specific tool to limit. If undefined, limits apply to all tools.\n   */\n  toolName: z.string().optional(),\n  /**\n   * Maximum number of tool calls allowed per thread.\n   * undefined means no limit.\n   */\n  threadLimit: z.number().optional(),\n  /**\n   * Maximum number of tool calls allowed per run.\n   * undefined means no limit.\n   */\n  runLimit: z.number().optional(),\n  /**\n   * What to do when limits are exceeded.\n   * - \"end\": Jump to the end of the agent execution and inject an artificial\n   *   AI message indicating that the limit was exceeded.\n   * - \"error\": throws a ToolCallLimitExceededError\n   */\n  exitBehavior: z.enum([\"end\", \"error\"]).default(\"end\"),\n});\n\nexport type ToolCallLimitConfig = InferInteropZodInput<\n  typeof ToolCallLimitOptionsSchema\n>;\n\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 *   - \"end\": Jump to the end of the agent execution and inject an artificial AI message indicating that the limit was exceeded.\n *   - \"error\": throws a ToolCallLimitExceededError\n *\n * @throws {Error} If both limits are undefined or if exitBehavior is invalid.\n *\n * @example Limit all tool calls globally\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * const globalLimiter = toolCallLimitMiddleware({\n *   threadLimit: 20,\n *   runLimit: 10,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [globalLimiter]\n * });\n * ```\n *\n * @example Limit a specific tool\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * const searchLimiter = toolCallLimitMiddleware({\n *   toolName: \"search\",\n *   threadLimit: 5,\n *   runLimit: 3,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [searchLimiter]\n * });\n * ```\n *\n * @example Use both in the same agent\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * const globalLimiter = toolCallLimitMiddleware({\n *   threadLimit: 20,\n *   runLimit: 10,\n *   exitBehavior: \"end\"\n * });\n *\n * const searchLimiter = toolCallLimitMiddleware({\n *   toolName: \"search\",\n *   threadLimit: 5,\n *   runLimit: 3,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [globalLimiter, searchLimiter]\n * });\n * ```\n */\nexport function toolCallLimitMiddleware(options: ToolCallLimitConfig) {\n  /**\n   * Validate that at least one limit is specified\n   */\n  if (options.threadLimit === undefined && options.runLimit === undefined) {\n    throw new Error(\n      \"At least one limit must be specified (threadLimit or runLimit)\"\n    );\n  }\n\n  /**\n   * Apply default for exitBehavior and validate\n   */\n  const exitBehavior = options.exitBehavior ?? \"end\";\n  if (exitBehavior !== \"end\" && exitBehavior !== \"error\") {\n    throw new Error(\n      `Invalid exit behavior: ${exitBehavior}. Must be 'end' or 'error'`\n    );\n  }\n\n  /**\n   * Generate the middleware name based on the tool name\n   */\n  const middlewareName = options.toolName\n    ? `ToolCallLimitMiddleware[${options.toolName}]`\n    : \"ToolCallLimitMiddleware\";\n\n  return createMiddleware({\n    name: middlewareName,\n    beforeModelJumpTo: [\"end\"],\n    async beforeModel(state: AgentBuiltInState) {\n      const messages = state.messages;\n\n      /**\n       * Count tool calls in entire thread\n       */\n      const threadCount = countToolCallsInMessages(messages, options.toolName);\n\n      /**\n       * Count tool calls in current run (after last HumanMessage)\n       */\n      const runMessages = getRunMessages(messages);\n      const runCount = countToolCallsInMessages(runMessages, options.toolName);\n\n      /**\n       * Check if any limits are exceeded\n       */\n      const threadLimitExceeded =\n        options.threadLimit !== undefined && threadCount >= options.threadLimit;\n      const runLimitExceeded =\n        options.runLimit !== undefined && runCount >= options.runLimit;\n\n      if (!threadLimitExceeded && !runLimitExceeded) {\n        return undefined;\n      }\n\n      if (exitBehavior === \"error\") {\n        throw new ToolCallLimitExceededError(\n          threadCount,\n          runCount,\n          options.threadLimit,\n          options.runLimit,\n          options.toolName\n        );\n      }\n\n      /**\n       * Create a message indicating the limit was exceeded\n       */\n      const limitMessage = buildToolLimitExceededMessage(\n        threadCount,\n        runCount,\n        options.threadLimit,\n        options.runLimit,\n        options.toolName\n      );\n      const limitAiMessage = new AIMessage(limitMessage);\n\n      return {\n        jumpTo: \"end\",\n        messages: [limitAiMessage],\n      };\n    },\n  });\n}\n"],"mappings":"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"}
+{"version":3,"file":"toolCallLimit.js","names":["messages: BaseMessage[]","toolName?: string","threadCount: number","runCount: number","threadLimit: number | undefined","runLimit: number | undefined","toolName: string | undefined","exceededLimits: string[]","options: ToolCallLimitConfig"],"sources":["../../../src/agents/middleware/toolCallLimit.ts"],"sourcesContent":["/**\n * Tool call limit middleware for agents.\n */\n\nimport { AIMessage, BaseMessage, HumanMessage } from \"@langchain/core/messages\";\nimport { z } from \"zod/v3\";\nimport type { InferInteropZodInput } from \"@langchain/core/utils/types\";\n\nimport { createMiddleware } from \"../middleware.js\";\n\n/**\n * Count tool calls in a list of messages.\n *\n * @param messages - List of messages to count tool calls in.\n * @param toolName - If specified, only count calls to this specific tool.\n *   If undefined, count all tool calls.\n * @returns The total number of tool calls (optionally filtered by toolName).\n */\nfunction countToolCallsInMessages(\n  messages: BaseMessage[],\n  toolName?: string\n): number {\n  let count = 0;\n  for (const message of messages) {\n    if (AIMessage.isInstance(message) && message.tool_calls) {\n      if (toolName === undefined) {\n        // Count all tool calls\n        count += message.tool_calls.length;\n      } else {\n        // Count only calls to the specified tool\n        count += message.tool_calls.filter((tc) => tc.name === toolName).length;\n      }\n    }\n  }\n  return count;\n}\n\n/**\n * Get messages from the current run (after the last HumanMessage).\n *\n * @param messages - Full list of messages.\n * @returns Messages from the current run (after last HumanMessage).\n */\nfunction getRunMessages(messages: BaseMessage[]): BaseMessage[] {\n  /**\n   * Find the last HumanMessage\n   */\n  let lastHumanIndex = -1;\n  for (let i = messages.length - 1; i >= 0; i--) {\n    if (HumanMessage.isInstance(messages[i])) {\n      lastHumanIndex = i;\n      break;\n    }\n  }\n\n  /**\n   * If no HumanMessage found, return all messages\n   */\n  if (lastHumanIndex === -1) {\n    return messages;\n  }\n\n  /**\n   * Return messages after the last HumanMessage\n   */\n  return messages.slice(lastHumanIndex + 1);\n}\n\n/**\n * Build a message indicating which tool call limits were reached.\n *\n * @param threadCount - Current thread tool call count.\n * @param runCount - Current run tool call count.\n * @param threadLimit - Thread tool call limit (if set).\n * @param runLimit - Run tool call limit (if set).\n * @param toolName - Tool name being limited (if specific tool), or undefined for all tools.\n * @returns A formatted message describing which limits were reached.\n */\nfunction buildToolLimitExceededMessage(\n  threadCount: number,\n  runCount: number,\n  threadLimit: number | undefined,\n  runLimit: number | undefined,\n  toolName: string | undefined\n): string {\n  const toolDesc = toolName ? `'${toolName}' tool call` : \"Tool call\";\n  const exceededLimits: string[] = [];\n\n  if (threadLimit !== undefined && threadCount >= threadLimit) {\n    exceededLimits.push(`thread limit reached (${threadCount}/${threadLimit})`);\n  }\n  if (runLimit !== undefined && runCount >= runLimit) {\n    exceededLimits.push(`run limit reached (${runCount}/${runLimit})`);\n  }\n\n  return `${toolDesc} limit${\n    exceededLimits.length > 1 ? \"s\" : \"\"\n  }: ${exceededLimits.join(\", \")}. Stopping to prevent further tool calls.`;\n}\n\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 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\n  constructor(\n    threadCount: number,\n    runCount: number,\n    threadLimit: number | undefined,\n    runLimit: number | undefined,\n    toolName: string | undefined = undefined\n  ) {\n    const message = buildToolLimitExceededMessage(\n      threadCount,\n      runCount,\n      threadLimit,\n      runLimit,\n      toolName\n    );\n    super(message);\n\n    this.name = \"ToolCallLimitExceededError\";\n    this.threadCount = threadCount;\n    this.runCount = runCount;\n    this.threadLimit = threadLimit;\n    this.runLimit = runLimit;\n    this.toolName = toolName;\n  }\n}\n\n/**\n * Options for configuring the Tool Call Limit middleware.\n */\nexport const ToolCallLimitOptionsSchema = z.object({\n  /**\n   * Name of the specific tool to limit. If undefined, limits apply to all tools.\n   */\n  toolName: z.string().optional(),\n  /**\n   * Maximum number of tool calls allowed per thread.\n   * undefined means no limit.\n   */\n  threadLimit: z.number().optional(),\n  /**\n   * Maximum number of tool calls allowed per run.\n   * undefined means no limit.\n   */\n  runLimit: z.number().optional(),\n  /**\n   * What to do when limits are exceeded.\n   * - \"end\": Jump to the end of the agent execution and inject an artificial\n   *   AI message indicating that the limit was exceeded.\n   * - \"error\": throws a ToolCallLimitExceededError\n   */\n  exitBehavior: z.enum([\"end\", \"error\"]).default(\"end\"),\n});\n\nexport type ToolCallLimitConfig = InferInteropZodInput<\n  typeof ToolCallLimitOptionsSchema\n>;\n\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 *   - \"end\": Jump to the end of the agent execution and inject an artificial AI message indicating that the limit was exceeded.\n *   - \"error\": throws a ToolCallLimitExceededError\n *\n * @throws {Error} If both limits are undefined or if exitBehavior is invalid.\n *\n * @example Limit all tool calls globally\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * const globalLimiter = toolCallLimitMiddleware({\n *   threadLimit: 20,\n *   runLimit: 10,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [globalLimiter]\n * });\n * ```\n *\n * @example Limit a specific tool\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * const searchLimiter = toolCallLimitMiddleware({\n *   toolName: \"search\",\n *   threadLimit: 5,\n *   runLimit: 3,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [searchLimiter]\n * });\n * ```\n *\n * @example Use both in the same agent\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * const globalLimiter = toolCallLimitMiddleware({\n *   threadLimit: 20,\n *   runLimit: 10,\n *   exitBehavior: \"end\"\n * });\n *\n * const searchLimiter = toolCallLimitMiddleware({\n *   toolName: \"search\",\n *   threadLimit: 5,\n *   runLimit: 3,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [globalLimiter, searchLimiter]\n * });\n * ```\n */\nexport function toolCallLimitMiddleware(options: ToolCallLimitConfig) {\n  /**\n   * Validate that at least one limit is specified\n   */\n  if (options.threadLimit === undefined && options.runLimit === undefined) {\n    throw new Error(\n      \"At least one limit must be specified (threadLimit or runLimit)\"\n    );\n  }\n\n  /**\n   * Apply default for exitBehavior and validate\n   */\n  const exitBehavior = options.exitBehavior ?? \"end\";\n  if (exitBehavior !== \"end\" && exitBehavior !== \"error\") {\n    throw new Error(\n      `Invalid exit behavior: ${exitBehavior}. Must be 'end' or 'error'`\n    );\n  }\n\n  /**\n   * Generate the middleware name based on the tool name\n   */\n  const middlewareName = options.toolName\n    ? `ToolCallLimitMiddleware[${options.toolName}]`\n    : \"ToolCallLimitMiddleware\";\n\n  return createMiddleware({\n    name: middlewareName,\n    beforeModel: {\n      canJumpTo: [\"end\"],\n      hook: (state) => {\n        const messages = state.messages;\n\n        /**\n         * Count tool calls in entire thread\n         */\n        const threadCount = countToolCallsInMessages(\n          messages,\n          options.toolName\n        );\n\n        /**\n         * Count tool calls in current run (after last HumanMessage)\n         */\n        const runMessages = getRunMessages(messages);\n        const runCount = countToolCallsInMessages(\n          runMessages,\n          options.toolName\n        );\n\n        /**\n         * Check if any limits are exceeded\n         */\n        const threadLimitExceeded =\n          options.threadLimit !== undefined &&\n          threadCount >= options.threadLimit;\n        const runLimitExceeded =\n          options.runLimit !== undefined && runCount >= options.runLimit;\n\n        if (!threadLimitExceeded && !runLimitExceeded) {\n          return undefined;\n        }\n\n        if (exitBehavior === \"error\") {\n          throw new ToolCallLimitExceededError(\n            threadCount,\n            runCount,\n            options.threadLimit,\n            options.runLimit,\n            options.toolName\n          );\n        }\n\n        /**\n         * Create a message indicating the limit was exceeded\n         */\n        const limitMessage = buildToolLimitExceededMessage(\n          threadCount,\n          runCount,\n          options.threadLimit,\n          options.runLimit,\n          options.toolName\n        );\n        const limitAiMessage = new AIMessage(limitMessage);\n\n        return {\n          jumpTo: \"end\",\n          messages: [limitAiMessage],\n        };\n      },\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;AAkBA,SAAS,yBACPA,UACAC,UACQ;CACR,IAAI,QAAQ;AACZ,MAAK,MAAM,WAAW,SACpB,KAAI,UAAU,WAAW,QAAQ,IAAI,QAAQ,WAC3C,KAAI,aAAa,QAEf,SAAS,QAAQ,WAAW;MAG5B,SAAS,QAAQ,WAAW,OAAO,CAAC,OAAO,GAAG,SAAS,SAAS,CAAC;AAIvE,QAAO;AACR;;;;;;;AAQD,SAAS,eAAeD,UAAwC;;;;CAI9D,IAAI,iBAAiB;AACrB,MAAK,IAAI,IAAI,SAAS,SAAS,GAAG,KAAK,GAAG,IACxC,KAAI,aAAa,WAAW,SAAS,GAAG,EAAE;EACxC,iBAAiB;AACjB;CACD;;;;AAMH,KAAI,mBAAmB,GACrB,QAAO;;;;AAMT,QAAO,SAAS,MAAM,iBAAiB,EAAE;AAC1C;;;;;;;;;;;AAYD,SAAS,8BACPE,aACAC,UACAC,aACAC,UACAC,UACQ;CACR,MAAM,WAAW,WAAW,CAAC,CAAC,EAAE,SAAS,WAAW,CAAC,GAAG;CACxD,MAAMC,iBAA2B,CAAE;AAEnC,KAAI,gBAAgB,UAAa,eAAe,aAC9C,eAAe,KAAK,CAAC,sBAAsB,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC;AAE7E,KAAI,aAAa,UAAa,YAAY,UACxC,eAAe,KAAK,CAAC,mBAAmB,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;AAGpE,QAAO,GAAG,SAAS,MAAM,EACvB,eAAe,SAAS,IAAI,MAAM,GACnC,EAAE,EAAE,eAAe,KAAK,KAAK,CAAC,yCAAyC,CAAC;AAC1E;;;;;;;AAQD,IAAa,6BAAb,cAAgD,MAAM;;;;CAIpD;;;;CAIA;;;;CAIA;;;;CAIA;;;;CAIA;CAEA,YACEL,aACAC,UACAC,aACAC,UACAC,WAA+B,QAC/B;EACA,MAAM,UAAU,8BACd,aACA,UACA,aACA,UACA,SACD;EACD,MAAM,QAAQ;EAEd,KAAK,OAAO;EACZ,KAAK,cAAc;EACnB,KAAK,WAAW;EAChB,KAAK,cAAc;EACnB,KAAK,WAAW;EAChB,KAAK,WAAW;CACjB;AACF;;;;AAKD,MAAa,6BAA6B,EAAE,OAAO;CAIjD,UAAU,EAAE,QAAQ,CAAC,UAAU;CAK/B,aAAa,EAAE,QAAQ,CAAC,UAAU;CAKlC,UAAU,EAAE,QAAQ,CAAC,UAAU;CAO/B,cAAc,EAAE,KAAK,CAAC,OAAO,OAAQ,EAAC,CAAC,QAAQ,MAAM;AACtD,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwFF,SAAgB,wBAAwBE,SAA8B;;;;AAIpE,KAAI,QAAQ,gBAAgB,UAAa,QAAQ,aAAa,OAC5D,OAAM,IAAI,MACR;;;;CAOJ,MAAM,eAAe,QAAQ,gBAAgB;AAC7C,KAAI,iBAAiB,SAAS,iBAAiB,QAC7C,OAAM,IAAI,MACR,CAAC,uBAAuB,EAAE,aAAa,0BAA0B,CAAC;;;;CAOtE,MAAM,iBAAiB,QAAQ,WAC3B,CAAC,wBAAwB,EAAE,QAAQ,SAAS,CAAC,CAAC,GAC9C;AAEJ,QAAO,iBAAiB;EACtB,MAAM;EACN,aAAa;GACX,WAAW,CAAC,KAAM;GAClB,MAAM,CAAC,UAAU;IACf,MAAM,WAAW,MAAM;;;;IAKvB,MAAM,cAAc,yBAClB,UACA,QAAQ,SACT;;;;IAKD,MAAM,cAAc,eAAe,SAAS;IAC5C,MAAM,WAAW,yBACf,aACA,QAAQ,SACT;;;;IAKD,MAAM,sBACJ,QAAQ,gBAAgB,UACxB,eAAe,QAAQ;IACzB,MAAM,mBACJ,QAAQ,aAAa,UAAa,YAAY,QAAQ;AAExD,QAAI,CAAC,uBAAuB,CAAC,iBAC3B,QAAO;AAGT,QAAI,iBAAiB,QACnB,OAAM,IAAI,2BACR,aACA,UACA,QAAQ,aACR,QAAQ,UACR,QAAQ;;;;IAOZ,MAAM,eAAe,8BACnB,aACA,UACA,QAAQ,aACR,QAAQ,UACR,QAAQ,SACT;IACD,MAAM,iBAAiB,IAAI,UAAU;AAErC,WAAO;KACL,QAAQ;KACR,UAAU,CAAC,cAAe;IAC3B;GACF;EACF;CACF,EAAC;AACH"}

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

@@ -9,7 +9,9 @@ import { AnnotationRoot, Command } from "@langchain/langgraph";
 import { InteropZodToStateDefinition } from "@langchain/langgraph/zod";
 
 //#region src/agents/middleware/types.d.ts
+type PromiseOrValue<T> = T | Promise<T>;
 type AnyAnnotationRoot = AnnotationRoot<any>;
+type NormalizedSchemaInput<TSchema extends InteropZodObject | undefined = any> = TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {};
 /**
  * Result type for middleware functions.
  */
@@ -39,25 +41,136 @@ interface ToolCallRequest<TState extends Record<string, unknown> = Record<string
 }
 /**
  * Handler function type for wrapping tool calls.
- * Takes a tool call and returns the tool result or a command.
+ * Takes a tool call request and returns the tool result or a command.
  */
-type ToolCallHandler = (toolCall: ToolCall$1) => Promise<ToolMessage | Command> | ToolMessage | Command;
+type ToolCallHandler<TSchema extends InteropZodObject | undefined = any, TContext = unknown> = (request: ToolCallRequest<NormalizedSchemaInput<TSchema> & AgentBuiltInState, TContext>) => PromiseOrValue<ToolMessage | Command>;
 /**
  * Wrapper function type for the wrapToolCall hook.
  * Allows middleware to intercept and modify tool execution.
  */
-type ToolCallWrapper<TState extends Record<string, unknown> = Record<string, unknown>, TContext = unknown> = (request: ToolCallRequest<TState, TContext>, handler: ToolCallHandler) => Promise<ToolMessage | Command> | ToolMessage | Command;
+type WrapToolCallHook<TSchema extends InteropZodObject | undefined = any, TContext = unknown> = (request: ToolCallRequest<NormalizedSchemaInput<TSchema> & AgentBuiltInState, TContext>, handler: ToolCallHandler<TSchema, TContext>) => PromiseOrValue<ToolMessage | Command>;
+/**
+ * Handler function type for wrapping model calls.
+ * Takes a model request and returns the AI message response.
+ *
+ * @param request - The model request containing model, messages, systemPrompt, tools, state, and runtime
+ * @returns The AI message response from the model
+ */
+type WrapModelCallHandler<TSchema extends InteropZodObject | undefined = any, TContext = unknown> = (request: ModelRequest<NormalizedSchemaInput<TSchema> & AgentBuiltInState, TContext>) => PromiseOrValue<AIMessage>;
+/**
+ * Wrapper function type for the wrapModelCall hook.
+ * Allows middleware to intercept and modify model execution.
+ * This enables you to:
+ * - Modify the request before calling the model (e.g., change system prompt, add/remove tools)
+ * - Handle errors and retry with different parameters
+ * - Post-process the response
+ * - Implement custom caching, logging, or other cross-cutting concerns
+ *
+ * @param request - The model request containing all parameters needed for the model call
+ * @param handler - The function that invokes the model. Call this with a ModelRequest to get the response
+ * @returns The AI message response from the model (or a modified version)
+ */
+type WrapModelCallHook<TSchema extends InteropZodObject | undefined = any, TContext = unknown> = (request: ModelRequest<NormalizedSchemaInput<TSchema> & AgentBuiltInState, TContext>, handler: WrapModelCallHandler<TSchema, TContext>) => PromiseOrValue<AIMessage>;
+/**
+ * Handler function type for the beforeAgent hook.
+ * Called once at the start of agent invocation before any model calls or tool executions.
+ *
+ * @param state - The current agent state (includes both middleware state and built-in state)
+ * @param runtime - The runtime context containing metadata, signal, writer, interrupt, etc.
+ * @returns A middleware result containing partial state updates or undefined to pass through
+ */
+type BeforeAgentHandler<TSchema extends InteropZodObject | undefined = any, TContext = unknown> = (state: NormalizedSchemaInput<TSchema> & AgentBuiltInState, runtime: Runtime<TContext>) => PromiseOrValue<MiddlewareResult<Partial<NormalizedSchemaInput<TSchema>>>>;
+/**
+ * Hook type for the beforeAgent lifecycle event.
+ * Can be either a handler function or an object with a handler and optional jump targets.
+ * This hook is called once at the start of the agent invocation.
+ */
+type BeforeAgentHook<TSchema extends InteropZodObject | undefined = any, TContext = unknown> = BeforeAgentHandler<TSchema, TContext> | {
+  hook: BeforeAgentHandler<TSchema, TContext>;
+  canJumpTo?: JumpToTarget[];
+};
+/**
+ * Handler function type for the beforeModel hook.
+ * Called before the model is invoked and before the wrapModelCall hook.
+ *
+ * @param state - The current agent state (includes both middleware state and built-in state)
+ * @param runtime - The runtime context containing metadata, signal, writer, interrupt, etc.
+ * @returns A middleware result containing partial state updates or undefined to pass through
+ */
+type BeforeModelHandler<TSchema extends InteropZodObject | undefined = any, TContext = unknown> = (state: NormalizedSchemaInput<TSchema> & AgentBuiltInState, runtime: Runtime<TContext>) => PromiseOrValue<MiddlewareResult<Partial<NormalizedSchemaInput<TSchema>>>>;
+/**
+ * Hook type for the beforeModel lifecycle event.
+ * Can be either a handler function or an object with a handler and optional jump targets.
+ * This hook is called before each model invocation.
+ */
+type BeforeModelHook<TSchema extends InteropZodObject | undefined = any, TContext = unknown> = BeforeModelHandler<TSchema, TContext> | {
+  hook: BeforeModelHandler<TSchema, TContext>;
+  canJumpTo?: JumpToTarget[];
+};
+/**
+ * Handler function type for the afterModel hook.
+ * Called after the model is invoked and before any tools are called.
+ * Allows modifying the agent state after model invocation, e.g., to update tool call parameters.
+ *
+ * @param state - The current agent state (includes both middleware state and built-in state)
+ * @param runtime - The runtime context containing metadata, signal, writer, interrupt, etc.
+ * @returns A middleware result containing partial state updates or undefined to pass through
+ */
+type AfterModelHandler<TSchema extends InteropZodObject | undefined = any, TContext = unknown> = (state: NormalizedSchemaInput<TSchema> & AgentBuiltInState, runtime: Runtime<TContext>) => PromiseOrValue<MiddlewareResult<Partial<NormalizedSchemaInput<TSchema>>>>;
+/**
+ * Hook type for the afterModel lifecycle event.
+ * Can be either a handler function or an object with a handler and optional jump targets.
+ * This hook is called after each model invocation.
+ */
+type AfterModelHook<TSchema extends InteropZodObject | undefined = any, TContext = unknown> = AfterModelHandler<TSchema, TContext> | {
+  hook: AfterModelHandler<TSchema, TContext>;
+  canJumpTo?: JumpToTarget[];
+};
+/**
+ * Handler function type for the afterAgent hook.
+ * Called once at the end of agent invocation after all model calls and tool executions are complete.
+ *
+ * @param state - The current agent state (includes both middleware state and built-in state)
+ * @param runtime - The runtime context containing metadata, signal, writer, interrupt, etc.
+ * @returns A middleware result containing partial state updates or undefined to pass through
+ */
+type AfterAgentHandler<TSchema extends InteropZodObject | undefined = any, TContext = unknown> = (state: NormalizedSchemaInput<TSchema> & AgentBuiltInState, runtime: Runtime<TContext>) => PromiseOrValue<MiddlewareResult<Partial<NormalizedSchemaInput<TSchema>>>>;
+/**
+ * Hook type for the afterAgent lifecycle event.
+ * Can be either a handler function or an object with a handler and optional jump targets.
+ * This hook is called once at the end of the agent invocation.
+ */
+type AfterAgentHook<TSchema extends InteropZodObject | undefined = any, TContext = unknown> = AfterAgentHandler<TSchema, TContext> | {
+  hook: AfterAgentHandler<TSchema, TContext>;
+  canJumpTo?: JumpToTarget[];
+};
 /**
  * Base middleware interface.
  */
 interface AgentMiddleware<TSchema extends InteropZodObject | undefined = any, TContextSchema extends InteropZodObject | InteropZodDefault<InteropZodObject> | InteropZodOptional<InteropZodObject> | undefined = any, TFullContext = any> {
+  /**
+   * The name of the middleware.
+   */
+  name: string;
+  /**
+   * The schema of the middleware state. Middleware state is persisted between multiple invocations. It can be either:
+   * - A Zod object
+   * - A Zod optional object
+   * - A Zod default object
+   * - Undefined
+   */
   stateSchema?: TSchema;
+  /**
+   * The schema of the middleware context. Middleware context is read-only and not persisted between multiple invocations. It can be either:
+   * - A Zod object
+   * - A Zod optional object
+   * - A Zod default object
+   * - Undefined
+   */
   contextSchema?: TContextSchema;
-  name: string;
-  beforeAgentJumpTo?: JumpToTarget[];
-  beforeModelJumpTo?: JumpToTarget[];
-  afterModelJumpTo?: JumpToTarget[];
-  afterAgentJumpTo?: JumpToTarget[];
+  /**
+   * Additional tools registered by the middleware.
+   */
   tools?: (ClientTool | ServerTool)[];
   /**
    * Wraps tool execution with custom logic. This allows you to:
@@ -71,7 +184,7 @@ interface AgentMiddleware<TSchema extends InteropZodObject | undefined = any, TC
    * along with a handler function to execute the actual tool.
    *
    * @param request - The tool call request containing toolCall, state, and runtime.
-   * @param handler - The function that executes the tool. Call this with a ToolCall to get the result.
+   * @param handler - The function that executes the tool. Call this with a ToolCallRequest to get the result.
    * @returns The tool result as a ToolMessage or a Command for advanced control flow.
    *
    * @example
@@ -82,7 +195,7 @@ interface AgentMiddleware<TSchema extends InteropZodObject | undefined = any, TC
    *
    *   try {
    *     // Execute the tool
-   *     const result = await handler(request.toolCall);
+   *     const result = await handler(request);
    *     console.log(`Tool ${request.tool.name} succeeded`);
    *     return result;
    *   } catch (error) {
@@ -103,7 +216,7 @@ interface AgentMiddleware<TSchema extends InteropZodObject | undefined = any, TC
    *       tool_call_id: request.toolCall.id,
    *     });
    *   }
-   *   return handler(request.toolCall);
+   *   return handler(request);
    * }
    * ```
    *
@@ -115,13 +228,13 @@ interface AgentMiddleware<TSchema extends InteropZodObject | undefined = any, TC
    *   if (cache.has(cacheKey)) {
    *     return cache.get(cacheKey);
    *   }
-   *   const result = await handler(request.toolCall);
+   *   const result = await handler(request);
    *   cache.set(cacheKey, result);
    *   return result;
    * }
    * ```
    */
-  wrapToolCall?: ToolCallWrapper<(TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, TFullContext>;
+  wrapToolCall?: WrapToolCallHook<TSchema, TFullContext>;
   /**
    * Wraps the model invocation with custom logic. This allows you to:
    * - Modify the request before calling the model
@@ -150,11 +263,43 @@ interface AgentMiddleware<TSchema extends InteropZodObject | undefined = any, TC
    * }
    * ```
    */
-  wrapModelCall?(request: ModelRequest<(TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, TFullContext>, handler: (request: ModelRequest<(TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, TFullContext>) => Promise<AIMessage> | AIMessage): Promise<AIMessage> | AIMessage;
-  beforeAgent?(state: (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>): Promise<MiddlewareResult<Partial<TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}>>>;
-  beforeModel?(state: (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>): Promise<MiddlewareResult<Partial<TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}>>>;
-  afterModel?(state: (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>): Promise<MiddlewareResult<Partial<TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}>>>;
-  afterAgent?(state: (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>): Promise<MiddlewareResult<Partial<TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}>>>;
+  wrapModelCall?: WrapModelCallHook<TSchema, TFullContext>;
+  /**
+   * The function to run before the agent execution starts. This function is called once at the start of the agent invocation.
+   * It allows to modify the state of the agent before any model calls or tool executions.
+   *
+   * @param state - The middleware state
+   * @param runtime - The middleware runtime
+   * @returns The modified middleware state or undefined to pass through
+   */
+  beforeAgent?: BeforeAgentHook<TSchema, TFullContext>;
+  /**
+   * The function to run before the model call. This function is called before the model is invoked and before the `wrapModelCall` hook.
+   * It allows to modify the state of the agent.
+   *
+   * @param state - The middleware state
+   * @param runtime - The middleware runtime
+   * @returns The modified middleware state or undefined to pass through
+   */
+  beforeModel?: BeforeModelHook<TSchema, TFullContext>;
+  /**
+   * The function to run after the model call. This function is called after the model is invoked and before any tools are called.
+   * It allows to modify the state of the agent after the model is invoked, e.g. to update tool call parameters.
+   *
+   * @param state - The middleware state
+   * @param runtime - The middleware runtime
+   * @returns The modified middleware state or undefined to pass through
+   */
+  afterModel?: AfterModelHook<TSchema, TFullContext>;
+  /**
+   * The function to run after the agent execution completes. This function is called once at the end of the agent invocation.
+   * It allows to modify the final state of the agent after all model calls and tool executions are complete.
+   *
+   * @param state - The middleware state
+   * @param runtime - The middleware runtime
+   * @returns The modified middleware state or undefined to pass through
+   */
+  afterAgent?: AfterAgentHook<TSchema, TFullContext>;
 }
 /**
  * Helper type to filter out properties that start with underscore (private properties)
@@ -203,6 +348,7 @@ type InferMiddlewareContextInputs<T extends readonly AgentMiddleware[]> = T exte
  */
 type InferContextInput<ContextSchema extends AnyAnnotationRoot | InteropZodObject> = ContextSchema extends InteropZodObject ? InferInteropZodInput<ContextSchema> : ContextSchema extends AnyAnnotationRoot ? ToAnnotationRoot<ContextSchema>["State"] : {};
 type ToAnnotationRoot<A extends AnyAnnotationRoot | InteropZodObject> = A extends AnyAnnotationRoot ? A : A extends InteropZodObject ? AnnotationRoot<InteropZodToStateDefinition<A>> : never;
+type InferSchemaInput<A extends AnyAnnotationRoot | InteropZodObject | undefined> = A extends AnyAnnotationRoot | InteropZodObject ? ToAnnotationRoot<A>["State"] : {};
 //#endregion
-export { AgentMiddleware, AnyAnnotationRoot, InferContextInput, InferMiddlewareContextInputs, InferMiddlewareInputStates, InferMiddlewareStates, MiddlewareResult, ToAnnotationRoot, ToolCallHandler, ToolCallRequest, ToolCallWrapper };
+export { AfterAgentHook, AfterModelHook, AgentMiddleware, AnyAnnotationRoot, BeforeAgentHook, BeforeModelHook, InferContextInput, InferMiddlewareContextInputs, InferMiddlewareInputStates, InferMiddlewareStates, InferSchemaInput, ToAnnotationRoot, ToolCallHandler, ToolCallRequest, WrapModelCallHook, WrapToolCallHook };
 //# sourceMappingURL=types.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.cts","names":["InteropZodObject","InteropZodDefault","InteropZodOptional","InferInteropZodInput","InferInteropZodOutput","AnnotationRoot","InteropZodToStateDefinition","AIMessage","ToolMessage","ToolCall","Command","JumpToTarget","ClientTool","ServerTool","Runtime","AgentBuiltInState","ModelRequest","AnyAnnotationRoot","MiddlewareResult","TState","ToolCallRequest","Record","TContext","ToolCallHandler","Promise","ToolCallWrapper","AgentMiddleware","TSchema","TContextSchema","TFullContext","Partial","FilterPrivateProps","T","K","InferMiddlewareState","S","InferMiddlewareInputState","InferMiddlewareStates","First","Rest","InferMiddlewareInputStates","InferMergedState","InferMergedInputState","InferMiddlewareContext","C","InferMiddlewareContextInput","Inner","InferMiddlewareContexts","MergeContextTypes","A","B","InferMiddlewareContextInputs","InferContextInput","ContextSchema","ToAnnotationRoot"],"sources":["../../../src/agents/middleware/types.d.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { InteropZodObject, InteropZodDefault, InteropZodOptional, InferInteropZodInput, InferInteropZodOutput } from \"@langchain/core/utils/types\";\nimport type { AnnotationRoot } from \"@langchain/langgraph\";\nimport type { InteropZodToStateDefinition } from \"@langchain/langgraph/zod\";\nimport type { AIMessage, ToolMessage } from \"@langchain/core/messages\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport type { Command } from \"@langchain/langgraph\";\nimport type { JumpToTarget } from \"../constants.js\";\nimport type { ClientTool, ServerTool } from \"../tools.js\";\nimport type { Runtime, AgentBuiltInState } from \"../runtime.js\";\nimport type { ModelRequest } from \"../nodes/types.js\";\nexport type AnyAnnotationRoot = AnnotationRoot<any>;\n/**\n * Result type for middleware functions.\n */\nexport type MiddlewareResult<TState> = TState | void;\n/**\n * Represents a tool call request for the wrapToolCall hook.\n * Contains the tool call information along with the agent's current state and runtime.\n */\nexport interface ToolCallRequest<TState extends Record<string, unknown> = Record<string, unknown>, TContext = unknown> {\n    /**\n     * The tool call to be executed\n     */\n    toolCall: ToolCall;\n    /**\n     * The BaseTool instance being invoked.\n     * Provides access to tool metadata like name, description, schema, etc.\n     */\n    tool: ClientTool | ServerTool;\n    /**\n     * The current agent state (includes both middleware state and built-in state).\n     */\n    state: TState & AgentBuiltInState;\n    /**\n     * The runtime context containing metadata, signal, writer, interrupt, etc.\n     */\n    runtime: Runtime<TContext>;\n}\n/**\n * Handler function type for wrapping tool calls.\n * Takes a tool call and returns the tool result or a command.\n */\nexport type ToolCallHandler = (toolCall: ToolCall) => Promise<ToolMessage | Command> | ToolMessage | Command;\n/**\n * Wrapper function type for the wrapToolCall hook.\n * Allows middleware to intercept and modify tool execution.\n */\nexport type ToolCallWrapper<TState extends Record<string, unknown> = Record<string, unknown>, TContext = unknown> = (request: ToolCallRequest<TState, TContext>, handler: ToolCallHandler) => Promise<ToolMessage | Command> | ToolMessage | Command;\n/**\n * Base middleware interface.\n */\nexport interface AgentMiddleware<TSchema extends InteropZodObject | undefined = any, TContextSchema extends InteropZodObject | InteropZodDefault<InteropZodObject> | InteropZodOptional<InteropZodObject> | undefined = any, TFullContext = any> {\n    stateSchema?: TSchema;\n    contextSchema?: TContextSchema;\n    name: string;\n    beforeAgentJumpTo?: JumpToTarget[];\n    beforeModelJumpTo?: JumpToTarget[];\n    afterModelJumpTo?: JumpToTarget[];\n    afterAgentJumpTo?: JumpToTarget[];\n    tools?: (ClientTool | ServerTool)[];\n    /**\n     * Wraps tool execution with custom logic. This allows you to:\n     * - Modify tool call parameters before execution\n     * - Handle errors and retry with different parameters\n     * - Post-process tool results\n     * - Implement caching, logging, authentication, or other cross-cutting concerns\n     * - Return Command objects for advanced control flow\n     *\n     * The handler receives a ToolCallRequest containing the tool call, state, and runtime,\n     * along with a handler function to execute the actual tool.\n     *\n     * @param request - The tool call request containing toolCall, state, and runtime.\n     * @param handler - The function that executes the tool. Call this with a ToolCall to get the result.\n     * @returns The tool result as a ToolMessage or a Command for advanced control flow.\n     *\n     * @example\n     * ```ts\n     * wrapToolCall: async (request, handler) => {\n     *   console.log(`Calling tool: ${request.tool.name}`);\n     *   console.log(`Tool description: ${request.tool.description}`);\n     *\n     *   try {\n     *     // Execute the tool\n     *     const result = await handler(request.toolCall);\n     *     console.log(`Tool ${request.tool.name} succeeded`);\n     *     return result;\n     *   } catch (error) {\n     *     console.error(`Tool ${request.tool.name} failed:`, error);\n     *     // Could return a custom error message or retry\n     *     throw error;\n     *   }\n     * }\n     * ```\n     *\n     * @example Authentication\n     * ```ts\n     * wrapToolCall: async (request, handler) => {\n     *   // Check if user is authorized for this tool\n     *   if (!request.runtime.context.isAuthorized(request.tool.name)) {\n     *     return new ToolMessage({\n     *       content: \"Unauthorized to call this tool\",\n     *       tool_call_id: request.toolCall.id,\n     *     });\n     *   }\n     *   return handler(request.toolCall);\n     * }\n     * ```\n     *\n     * @example Caching\n     * ```ts\n     * const cache = new Map();\n     * wrapToolCall: async (request, handler) => {\n     *   const cacheKey = `${request.tool.name}:${JSON.stringify(request.toolCall.args)}`;\n     *   if (cache.has(cacheKey)) {\n     *     return cache.get(cacheKey);\n     *   }\n     *   const result = await handler(request.toolCall);\n     *   cache.set(cacheKey, result);\n     *   return result;\n     * }\n     * ```\n     */\n    wrapToolCall?: ToolCallWrapper<(TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, TFullContext>;\n    /**\n     * Wraps the model invocation with custom logic. This allows you to:\n     * - Modify the request before calling the model\n     * - Handle errors and retry with different parameters\n     * - Post-process the response\n     * - Implement custom caching, logging, or other cross-cutting concerns\n     *\n     * @param request - The model request containing model, messages, systemPrompt, tools, state, and runtime.\n     * @param handler - The function that invokes the model. Call this with a ModelRequest to get the response.\n     * @returns The response from the model (or a modified version).\n     *\n     * @example\n     * ```ts\n     * wrapModelCall: async (request, handler) => {\n     *   // Modify request before calling\n     *   const modifiedRequest = { ...request, systemPrompt: \"You are helpful\" };\n     *\n     *   try {\n     *     // Call the model\n     *     return await handler(modifiedRequest);\n     *   } catch (error) {\n     *     // Handle errors and retry with fallback\n     *     const fallbackRequest = { ...request, model: fallbackModel };\n     *     return await handler(fallbackRequest);\n     *   }\n     * }\n     * ```\n     */\n    wrapModelCall?(request: ModelRequest<(TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, TFullContext>, handler: (request: ModelRequest<(TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, TFullContext>) => Promise<AIMessage> | AIMessage): Promise<AIMessage> | AIMessage;\n    beforeAgent?(state: (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>): Promise<MiddlewareResult<Partial<TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}>>>;\n    beforeModel?(state: (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>): Promise<MiddlewareResult<Partial<TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}>>>;\n    afterModel?(state: (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>): Promise<MiddlewareResult<Partial<TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}>>>;\n    afterAgent?(state: (TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}) & AgentBuiltInState, runtime: Runtime<TFullContext>): Promise<MiddlewareResult<Partial<TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {}>>>;\n}\n/**\n * Helper type to filter out properties that start with underscore (private properties)\n */\ntype FilterPrivateProps<T> = {\n    [K in keyof T as K extends `_${string}` ? never : K]: T[K];\n};\n/**\n * Helper type to infer the state schema type from a middleware\n * This filters out private properties (those starting with underscore)\n */\nexport type InferMiddlewareState<T extends AgentMiddleware> = T extends AgentMiddleware<infer S, any, any> ? S extends InteropZodObject ? FilterPrivateProps<InferInteropZodOutput<S>> : {} : {};\n/**\n * Helper type to infer the input state schema type from a middleware (all properties optional)\n * This filters out private properties (those starting with underscore)\n */\nexport type InferMiddlewareInputState<T extends AgentMiddleware> = T extends AgentMiddleware<infer S, any, any> ? S extends InteropZodObject ? FilterPrivateProps<InferInteropZodInput<S>> : {} : {};\n/**\n * Helper type to infer merged state from an array of middleware (just the middleware states)\n */\nexport type InferMiddlewareStates<T = AgentMiddleware[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware ? Rest extends readonly AgentMiddleware[] ? InferMiddlewareState<First> & InferMiddlewareStates<Rest> : InferMiddlewareState<First> : {} : {};\n/**\n * Helper type to infer merged input state from an array of middleware (with optional defaults)\n */\nexport type InferMiddlewareInputStates<T extends readonly AgentMiddleware[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware ? Rest extends readonly AgentMiddleware[] ? InferMiddlewareInputState<First> & InferMiddlewareInputStates<Rest> : InferMiddlewareInputState<First> : {} : {};\n/**\n * Helper type to infer merged state from an array of middleware (includes built-in state)\n */\nexport type InferMergedState<T extends readonly AgentMiddleware[]> = InferMiddlewareStates<T> & AgentBuiltInState;\n/**\n * Helper type to infer merged input state from an array of middleware (includes built-in state)\n */\nexport type InferMergedInputState<T extends readonly AgentMiddleware[]> = InferMiddlewareInputStates<T> & AgentBuiltInState;\n/**\n * Helper type to infer the context schema type from a middleware\n */\nexport type InferMiddlewareContext<T extends AgentMiddleware> = T extends AgentMiddleware<any, infer C, any> ? C extends InteropZodObject ? InferInteropZodInput<C> : {} : {};\n/**\n * Helper type to infer the input context schema type from a middleware (with optional defaults)\n */\nexport type InferMiddlewareContextInput<T extends AgentMiddleware> = T extends AgentMiddleware<any, infer C, any> ? C extends InteropZodOptional<infer Inner> ? InferInteropZodInput<Inner> | undefined : C extends InteropZodObject ? InferInteropZodInput<C> : {} : {};\n/**\n * Helper type to infer merged context from an array of middleware\n */\nexport type InferMiddlewareContexts<T extends readonly AgentMiddleware[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware ? Rest extends readonly AgentMiddleware[] ? InferMiddlewareContext<First> & InferMiddlewareContexts<Rest> : InferMiddlewareContext<First> : {} : {};\n/**\n * Helper to merge two context types, preserving undefined unions\n */\ntype MergeContextTypes<A, B> = [A] extends [undefined] ? [B] extends [undefined] ? undefined : B | undefined : [B] extends [undefined] ? A | undefined : [A] extends [B] ? A : [B] extends [A] ? B : A & B;\n/**\n * Helper type to infer merged input context from an array of middleware (with optional defaults)\n */\nexport type InferMiddlewareContextInputs<T extends readonly AgentMiddleware[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware ? Rest extends readonly AgentMiddleware[] ? MergeContextTypes<InferMiddlewareContextInput<First>, InferMiddlewareContextInputs<Rest>> : InferMiddlewareContextInput<First> : {} : {};\n/**\n * Helper type to extract input type from context schema (with optional defaults)\n */\nexport type InferContextInput<ContextSchema extends AnyAnnotationRoot | InteropZodObject> = ContextSchema extends InteropZodObject ? InferInteropZodInput<ContextSchema> : ContextSchema extends AnyAnnotationRoot ? ToAnnotationRoot<ContextSchema>[\"State\"] : {};\nexport type ToAnnotationRoot<A extends AnyAnnotationRoot | InteropZodObject> = A extends AnyAnnotationRoot ? A : A extends InteropZodObject ? AnnotationRoot<InteropZodToStateDefinition<A>> : never;\nexport {};\n"],"mappings":"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"}
+{"version":3,"file":"types.d.cts","names":["InteropZodObject","InteropZodDefault","InteropZodOptional","InferInteropZodInput","InferInteropZodOutput","InteropZodToStateDefinition","AnnotationRoot","AIMessage","ToolMessage","ToolCall","Command","JumpToTarget","ClientTool","ServerTool","Runtime","AgentBuiltInState","ModelRequest","PromiseOrValue","T","Promise","AnyAnnotationRoot","NormalizedSchemaInput","TSchema","MiddlewareResult","TState","ToolCallRequest","Record","TContext","ToolCallHandler","WrapToolCallHook","WrapModelCallHandler","WrapModelCallHook","BeforeAgentHandler","Partial","BeforeAgentHook","BeforeModelHandler","BeforeModelHook","AfterModelHandler","AfterModelHook","AfterAgentHandler","AfterAgentHook","AgentMiddleware","TContextSchema","TFullContext","FilterPrivateProps","K","InferChannelType","ToAnnotationRoot","InferMiddlewareState","S","InferMiddlewareInputState","InferMiddlewareStates","First","Rest","InferMiddlewareInputStates","InferMergedState","InferMergedInputState","InferMiddlewareContext","C","InferMiddlewareContextInput","Inner","InferMiddlewareContexts","MergeContextTypes","A","B","InferMiddlewareContextInputs","InferContextInput","ContextSchema","InferSchemaInput"],"sources":["../../../src/agents/middleware/types.d.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { InteropZodObject, InteropZodDefault, InteropZodOptional, InferInteropZodInput, InferInteropZodOutput } from \"@langchain/core/utils/types\";\nimport type { InteropZodToStateDefinition } from \"@langchain/langgraph/zod\";\nimport type { AnnotationRoot } from \"@langchain/langgraph\";\nimport type { AIMessage, ToolMessage } from \"@langchain/core/messages\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport type { Command } from \"@langchain/langgraph\";\nimport type { JumpToTarget } from \"../constants.js\";\nimport type { ClientTool, ServerTool } from \"../tools.js\";\nimport type { Runtime, AgentBuiltInState } from \"../runtime.js\";\nimport type { ModelRequest } from \"../nodes/types.js\";\ntype PromiseOrValue<T> = T | Promise<T>;\nexport type AnyAnnotationRoot = AnnotationRoot<any>;\ntype NormalizedSchemaInput<TSchema extends InteropZodObject | undefined = any> = TSchema extends InteropZodObject ? InferInteropZodInput<TSchema> : {};\n/**\n * Result type for middleware functions.\n */\nexport type MiddlewareResult<TState> = TState | void;\n/**\n * Represents a tool call request for the wrapToolCall hook.\n * Contains the tool call information along with the agent's current state and runtime.\n */\nexport interface ToolCallRequest<TState extends Record<string, unknown> = Record<string, unknown>, TContext = unknown> {\n    /**\n     * The tool call to be executed\n     */\n    toolCall: ToolCall;\n    /**\n     * The BaseTool instance being invoked.\n     * Provides access to tool metadata like name, description, schema, etc.\n     */\n    tool: ClientTool | ServerTool;\n    /**\n     * The current agent state (includes both middleware state and built-in state).\n     */\n    state: TState & AgentBuiltInState;\n    /**\n     * The runtime context containing metadata, signal, writer, interrupt, etc.\n     */\n    runtime: Runtime<TContext>;\n}\n/**\n * Handler function type for wrapping tool calls.\n * Takes a tool call request and returns the tool result or a command.\n */\nexport type ToolCallHandler<TSchema extends InteropZodObject | undefined = any, TContext = unknown> = (request: ToolCallRequest<NormalizedSchemaInput<TSchema> & AgentBuiltInState, TContext>) => PromiseOrValue<ToolMessage | Command>;\n/**\n * Wrapper function type for the wrapToolCall hook.\n * Allows middleware to intercept and modify tool execution.\n */\nexport type WrapToolCallHook<TSchema extends InteropZodObject | undefined = any, TContext = unknown> = (request: ToolCallRequest<NormalizedSchemaInput<TSchema> & AgentBuiltInState, TContext>, handler: ToolCallHandler<TSchema, TContext>) => PromiseOrValue<ToolMessage | Command>;\n/**\n * Handler function type for wrapping model calls.\n * Takes a model request and returns the AI message response.\n *\n * @param request - The model request containing model, messages, systemPrompt, tools, state, and runtime\n * @returns The AI message response from the model\n */\nexport type WrapModelCallHandler<TSchema extends InteropZodObject | undefined = any, TContext = unknown> = (request: ModelRequest<NormalizedSchemaInput<TSchema> & AgentBuiltInState, TContext>) => PromiseOrValue<AIMessage>;\n/**\n * Wrapper function type for the wrapModelCall hook.\n * Allows middleware to intercept and modify model execution.\n * This enables you to:\n * - Modify the request before calling the model (e.g., change system prompt, add/remove tools)\n * - Handle errors and retry with different parameters\n * - Post-process the response\n * - Implement custom caching, logging, or other cross-cutting concerns\n *\n * @param request - The model request containing all parameters needed for the model call\n * @param handler - The function that invokes the model. Call this with a ModelRequest to get the response\n * @returns The AI message response from the model (or a modified version)\n */\nexport type WrapModelCallHook<TSchema extends InteropZodObject | undefined = any, TContext = unknown> = (request: ModelRequest<NormalizedSchemaInput<TSchema> & AgentBuiltInState, TContext>, handler: WrapModelCallHandler<TSchema, TContext>) => PromiseOrValue<AIMessage>;\n/**\n * Handler function type for the beforeAgent hook.\n * Called once at the start of agent invocation before any model calls or tool executions.\n *\n * @param state - The current agent state (includes both middleware state and built-in state)\n * @param runtime - The runtime context containing metadata, signal, writer, interrupt, etc.\n * @returns A middleware result containing partial state updates or undefined to pass through\n */\nexport type BeforeAgentHandler<TSchema extends InteropZodObject | undefined = any, TContext = unknown> = (state: NormalizedSchemaInput<TSchema> & AgentBuiltInState, runtime: Runtime<TContext>) => PromiseOrValue<MiddlewareResult<Partial<NormalizedSchemaInput<TSchema>>>>;\n/**\n * Hook type for the beforeAgent lifecycle event.\n * Can be either a handler function or an object with a handler and optional jump targets.\n * This hook is called once at the start of the agent invocation.\n */\nexport type BeforeAgentHook<TSchema extends InteropZodObject | undefined = any, TContext = unknown> = BeforeAgentHandler<TSchema, TContext> | {\n    hook: BeforeAgentHandler<TSchema, TContext>;\n    canJumpTo?: JumpToTarget[];\n};\n/**\n * Handler function type for the beforeModel hook.\n * Called before the model is invoked and before the wrapModelCall hook.\n *\n * @param state - The current agent state (includes both middleware state and built-in state)\n * @param runtime - The runtime context containing metadata, signal, writer, interrupt, etc.\n * @returns A middleware result containing partial state updates or undefined to pass through\n */\nexport type BeforeModelHandler<TSchema extends InteropZodObject | undefined = any, TContext = unknown> = (state: NormalizedSchemaInput<TSchema> & AgentBuiltInState, runtime: Runtime<TContext>) => PromiseOrValue<MiddlewareResult<Partial<NormalizedSchemaInput<TSchema>>>>;\n/**\n * Hook type for the beforeModel lifecycle event.\n * Can be either a handler function or an object with a handler and optional jump targets.\n * This hook is called before each model invocation.\n */\nexport type BeforeModelHook<TSchema extends InteropZodObject | undefined = any, TContext = unknown> = BeforeModelHandler<TSchema, TContext> | {\n    hook: BeforeModelHandler<TSchema, TContext>;\n    canJumpTo?: JumpToTarget[];\n};\n/**\n * Handler function type for the afterModel hook.\n * Called after the model is invoked and before any tools are called.\n * Allows modifying the agent state after model invocation, e.g., to update tool call parameters.\n *\n * @param state - The current agent state (includes both middleware state and built-in state)\n * @param runtime - The runtime context containing metadata, signal, writer, interrupt, etc.\n * @returns A middleware result containing partial state updates or undefined to pass through\n */\nexport type AfterModelHandler<TSchema extends InteropZodObject | undefined = any, TContext = unknown> = (state: NormalizedSchemaInput<TSchema> & AgentBuiltInState, runtime: Runtime<TContext>) => PromiseOrValue<MiddlewareResult<Partial<NormalizedSchemaInput<TSchema>>>>;\n/**\n * Hook type for the afterModel lifecycle event.\n * Can be either a handler function or an object with a handler and optional jump targets.\n * This hook is called after each model invocation.\n */\nexport type AfterModelHook<TSchema extends InteropZodObject | undefined = any, TContext = unknown> = AfterModelHandler<TSchema, TContext> | {\n    hook: AfterModelHandler<TSchema, TContext>;\n    canJumpTo?: JumpToTarget[];\n};\n/**\n * Handler function type for the afterAgent hook.\n * Called once at the end of agent invocation after all model calls and tool executions are complete.\n *\n * @param state - The current agent state (includes both middleware state and built-in state)\n * @param runtime - The runtime context containing metadata, signal, writer, interrupt, etc.\n * @returns A middleware result containing partial state updates or undefined to pass through\n */\nexport type AfterAgentHandler<TSchema extends InteropZodObject | undefined = any, TContext = unknown> = (state: NormalizedSchemaInput<TSchema> & AgentBuiltInState, runtime: Runtime<TContext>) => PromiseOrValue<MiddlewareResult<Partial<NormalizedSchemaInput<TSchema>>>>;\n/**\n * Hook type for the afterAgent lifecycle event.\n * Can be either a handler function or an object with a handler and optional jump targets.\n * This hook is called once at the end of the agent invocation.\n */\nexport type AfterAgentHook<TSchema extends InteropZodObject | undefined = any, TContext = unknown> = AfterAgentHandler<TSchema, TContext> | {\n    hook: AfterAgentHandler<TSchema, TContext>;\n    canJumpTo?: JumpToTarget[];\n};\n/**\n * Base middleware interface.\n */\nexport interface AgentMiddleware<TSchema extends InteropZodObject | undefined = any, TContextSchema extends InteropZodObject | InteropZodDefault<InteropZodObject> | InteropZodOptional<InteropZodObject> | undefined = any, TFullContext = any> {\n    /**\n     * The name of the middleware.\n     */\n    name: string;\n    /**\n     * The schema of the middleware state. Middleware state is persisted between multiple invocations. It can be either:\n     * - A Zod object\n     * - A Zod optional object\n     * - A Zod default object\n     * - Undefined\n     */\n    stateSchema?: TSchema;\n    /**\n     * The schema of the middleware context. Middleware context is read-only and not persisted between multiple invocations. It can be either:\n     * - A Zod object\n     * - A Zod optional object\n     * - A Zod default object\n     * - Undefined\n     */\n    contextSchema?: TContextSchema;\n    /**\n     * Additional tools registered by the middleware.\n     */\n    tools?: (ClientTool | ServerTool)[];\n    /**\n     * Wraps tool execution with custom logic. This allows you to:\n     * - Modify tool call parameters before execution\n     * - Handle errors and retry with different parameters\n     * - Post-process tool results\n     * - Implement caching, logging, authentication, or other cross-cutting concerns\n     * - Return Command objects for advanced control flow\n     *\n     * The handler receives a ToolCallRequest containing the tool call, state, and runtime,\n     * along with a handler function to execute the actual tool.\n     *\n     * @param request - The tool call request containing toolCall, state, and runtime.\n     * @param handler - The function that executes the tool. Call this with a ToolCallRequest to get the result.\n     * @returns The tool result as a ToolMessage or a Command for advanced control flow.\n     *\n     * @example\n     * ```ts\n     * wrapToolCall: async (request, handler) => {\n     *   console.log(`Calling tool: ${request.tool.name}`);\n     *   console.log(`Tool description: ${request.tool.description}`);\n     *\n     *   try {\n     *     // Execute the tool\n     *     const result = await handler(request);\n     *     console.log(`Tool ${request.tool.name} succeeded`);\n     *     return result;\n     *   } catch (error) {\n     *     console.error(`Tool ${request.tool.name} failed:`, error);\n     *     // Could return a custom error message or retry\n     *     throw error;\n     *   }\n     * }\n     * ```\n     *\n     * @example Authentication\n     * ```ts\n     * wrapToolCall: async (request, handler) => {\n     *   // Check if user is authorized for this tool\n     *   if (!request.runtime.context.isAuthorized(request.tool.name)) {\n     *     return new ToolMessage({\n     *       content: \"Unauthorized to call this tool\",\n     *       tool_call_id: request.toolCall.id,\n     *     });\n     *   }\n     *   return handler(request);\n     * }\n     * ```\n     *\n     * @example Caching\n     * ```ts\n     * const cache = new Map();\n     * wrapToolCall: async (request, handler) => {\n     *   const cacheKey = `${request.tool.name}:${JSON.stringify(request.toolCall.args)}`;\n     *   if (cache.has(cacheKey)) {\n     *     return cache.get(cacheKey);\n     *   }\n     *   const result = await handler(request);\n     *   cache.set(cacheKey, result);\n     *   return result;\n     * }\n     * ```\n     */\n    wrapToolCall?: WrapToolCallHook<TSchema, TFullContext>;\n    /**\n     * Wraps the model invocation with custom logic. This allows you to:\n     * - Modify the request before calling the model\n     * - Handle errors and retry with different parameters\n     * - Post-process the response\n     * - Implement custom caching, logging, or other cross-cutting concerns\n     *\n     * @param request - The model request containing model, messages, systemPrompt, tools, state, and runtime.\n     * @param handler - The function that invokes the model. Call this with a ModelRequest to get the response.\n     * @returns The response from the model (or a modified version).\n     *\n     * @example\n     * ```ts\n     * wrapModelCall: async (request, handler) => {\n     *   // Modify request before calling\n     *   const modifiedRequest = { ...request, systemPrompt: \"You are helpful\" };\n     *\n     *   try {\n     *     // Call the model\n     *     return await handler(modifiedRequest);\n     *   } catch (error) {\n     *     // Handle errors and retry with fallback\n     *     const fallbackRequest = { ...request, model: fallbackModel };\n     *     return await handler(fallbackRequest);\n     *   }\n     * }\n     * ```\n     */\n    wrapModelCall?: WrapModelCallHook<TSchema, TFullContext>;\n    /**\n     * The function to run before the agent execution starts. This function is called once at the start of the agent invocation.\n     * It allows to modify the state of the agent before any model calls or tool executions.\n     *\n     * @param state - The middleware state\n     * @param runtime - The middleware runtime\n     * @returns The modified middleware state or undefined to pass through\n     */\n    beforeAgent?: BeforeAgentHook<TSchema, TFullContext>;\n    /**\n     * The function to run before the model call. This function is called before the model is invoked and before the `wrapModelCall` hook.\n     * It allows to modify the state of the agent.\n     *\n     * @param state - The middleware state\n     * @param runtime - The middleware runtime\n     * @returns The modified middleware state or undefined to pass through\n     */\n    beforeModel?: BeforeModelHook<TSchema, TFullContext>;\n    /**\n     * The function to run after the model call. This function is called after the model is invoked and before any tools are called.\n     * It allows to modify the state of the agent after the model is invoked, e.g. to update tool call parameters.\n     *\n     * @param state - The middleware state\n     * @param runtime - The middleware runtime\n     * @returns The modified middleware state or undefined to pass through\n     */\n    afterModel?: AfterModelHook<TSchema, TFullContext>;\n    /**\n     * The function to run after the agent execution completes. This function is called once at the end of the agent invocation.\n     * It allows to modify the final state of the agent after all model calls and tool executions are complete.\n     *\n     * @param state - The middleware state\n     * @param runtime - The middleware runtime\n     * @returns The modified middleware state or undefined to pass through\n     */\n    afterAgent?: AfterAgentHook<TSchema, TFullContext>;\n}\n/**\n * Helper type to filter out properties that start with underscore (private properties)\n */\ntype FilterPrivateProps<T> = {\n    [K in keyof T as K extends `_${string}` ? never : K]: T[K];\n};\nexport type InferChannelType<T extends AnyAnnotationRoot | InteropZodObject> = T extends AnyAnnotationRoot ? ToAnnotationRoot<T>[\"State\"] : T extends InteropZodObject ? InferInteropZodInput<T> : {};\n/**\n * Helper type to infer the state schema type from a middleware\n * This filters out private properties (those starting with underscore)\n */\nexport type InferMiddlewareState<T extends AgentMiddleware> = T extends AgentMiddleware<infer S, any, any> ? S extends InteropZodObject ? FilterPrivateProps<InferInteropZodOutput<S>> : {} : {};\n/**\n * Helper type to infer the input state schema type from a middleware (all properties optional)\n * This filters out private properties (those starting with underscore)\n */\nexport type InferMiddlewareInputState<T extends AgentMiddleware> = T extends AgentMiddleware<infer S, any, any> ? S extends InteropZodObject ? FilterPrivateProps<InferInteropZodInput<S>> : {} : {};\n/**\n * Helper type to infer merged state from an array of middleware (just the middleware states)\n */\nexport type InferMiddlewareStates<T = AgentMiddleware[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware ? Rest extends readonly AgentMiddleware[] ? InferMiddlewareState<First> & InferMiddlewareStates<Rest> : InferMiddlewareState<First> : {} : {};\n/**\n * Helper type to infer merged input state from an array of middleware (with optional defaults)\n */\nexport type InferMiddlewareInputStates<T extends readonly AgentMiddleware[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware ? Rest extends readonly AgentMiddleware[] ? InferMiddlewareInputState<First> & InferMiddlewareInputStates<Rest> : InferMiddlewareInputState<First> : {} : {};\n/**\n * Helper type to infer merged state from an array of middleware (includes built-in state)\n */\nexport type InferMergedState<T extends readonly AgentMiddleware[]> = InferMiddlewareStates<T> & AgentBuiltInState;\n/**\n * Helper type to infer merged input state from an array of middleware (includes built-in state)\n */\nexport type InferMergedInputState<T extends readonly AgentMiddleware[]> = InferMiddlewareInputStates<T> & AgentBuiltInState;\n/**\n * Helper type to infer the context schema type from a middleware\n */\nexport type InferMiddlewareContext<T extends AgentMiddleware> = T extends AgentMiddleware<any, infer C, any> ? C extends InteropZodObject ? InferInteropZodInput<C> : {} : {};\n/**\n * Helper type to infer the input context schema type from a middleware (with optional defaults)\n */\nexport type InferMiddlewareContextInput<T extends AgentMiddleware> = T extends AgentMiddleware<any, infer C, any> ? C extends InteropZodOptional<infer Inner> ? InferInteropZodInput<Inner> | undefined : C extends InteropZodObject ? InferInteropZodInput<C> : {} : {};\n/**\n * Helper type to infer merged context from an array of middleware\n */\nexport type InferMiddlewareContexts<T extends readonly AgentMiddleware[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware ? Rest extends readonly AgentMiddleware[] ? InferMiddlewareContext<First> & InferMiddlewareContexts<Rest> : InferMiddlewareContext<First> : {} : {};\n/**\n * Helper to merge two context types, preserving undefined unions\n */\ntype MergeContextTypes<A, B> = [A] extends [undefined] ? [B] extends [undefined] ? undefined : B | undefined : [B] extends [undefined] ? A | undefined : [A] extends [B] ? A : [B] extends [A] ? B : A & B;\n/**\n * Helper type to infer merged input context from an array of middleware (with optional defaults)\n */\nexport type InferMiddlewareContextInputs<T extends readonly AgentMiddleware[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware ? Rest extends readonly AgentMiddleware[] ? MergeContextTypes<InferMiddlewareContextInput<First>, InferMiddlewareContextInputs<Rest>> : InferMiddlewareContextInput<First> : {} : {};\n/**\n * Helper type to extract input type from context schema (with optional defaults)\n */\nexport type InferContextInput<ContextSchema extends AnyAnnotationRoot | InteropZodObject> = ContextSchema extends InteropZodObject ? InferInteropZodInput<ContextSchema> : ContextSchema extends AnyAnnotationRoot ? ToAnnotationRoot<ContextSchema>[\"State\"] : {};\nexport type ToAnnotationRoot<A extends AnyAnnotationRoot | InteropZodObject> = A extends AnyAnnotationRoot ? A : A extends InteropZodObject ? AnnotationRoot<InteropZodToStateDefinition<A>> : never;\nexport type InferSchemaInput<A extends AnyAnnotationRoot | InteropZodObject | undefined> = A extends AnyAnnotationRoot | InteropZodObject ? ToAnnotationRoot<A>[\"State\"] : {};\nexport {};\n"],"mappings":"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"}