langchain 1.0.2 → 1.0.4

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_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"}
+{"version":3,"file":"toolCallLimit.d.cts","names":["z","InferInteropZodInput","ToolCallLimitExceededError","Error","ToolCallLimitOptionsSchema","ZodString","ZodOptional","ZodNumber","ZodEnum","ZodDefault","ZodTypeAny","ZodObject","ToolCallLimitConfig","toolCallLimitMiddleware","ZodRecord","Record","__types_js13","AgentMiddleware"],"sources":["../../../src/agents/middleware/toolCallLimit.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport type { InferInteropZodInput } from \"@langchain/core/utils/types\";\n/**\n * Exception raised when tool call limits are exceeded.\n *\n * This exception is raised when the configured exit behavior is 'error'\n * and either the thread or run tool call limit has been exceeded.\n */\nexport declare class ToolCallLimitExceededError extends Error {\n    /**\n     * Current thread tool call count.\n     */\n    threadCount: number;\n    /**\n     * Current run tool call count.\n     */\n    runCount: number;\n    /**\n     * Thread tool call limit (if set).\n     */\n    threadLimit: number | undefined;\n    /**\n     * Run tool call limit (if set).\n     */\n    runLimit: number | undefined;\n    /**\n     * Tool name being limited (if specific tool), or undefined for all tools.\n     */\n    toolName: string | undefined;\n    constructor(threadCount: number, runCount: number, threadLimit: number | undefined, runLimit: number | undefined, toolName?: string | undefined);\n}\n/**\n * Options for configuring the Tool Call Limit middleware.\n */\nexport declare const ToolCallLimitOptionsSchema: z.ZodObject<{\n    /**\n     * Name of the specific tool to limit. If undefined, limits apply to all tools.\n     */\n    toolName: z.ZodOptional<z.ZodString>;\n    /**\n     * Maximum number of tool calls allowed per thread.\n     * undefined means no limit.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * Maximum number of tool calls allowed per run.\n     * undefined means no limit.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * What to do when limits are exceeded.\n     * - \"continue\": Block exceeded tools with error messages, let other tools continue (default)\n     * - \"error\": Raise a ToolCallLimitExceededError exception\n     * - \"end\": Stop execution immediately, injecting a ToolMessage and an AI message\n     *   for the single tool call that exceeded the limit. Raises NotImplementedError\n     *   if there are multiple tool calls.\n     *\n     * @default \"continue\"\n     */\n    exitBehavior: z.ZodDefault<z.ZodEnum<[\"continue\", \"error\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    toolName?: string | undefined;\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior: \"continue\" | \"end\" | \"error\";\n}, {\n    toolName?: string | undefined;\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"continue\" | \"end\" | \"error\" | undefined;\n}>;\nexport type ToolCallLimitConfig = InferInteropZodInput<typeof ToolCallLimitOptionsSchema>;\n/**\n * Middleware that tracks tool call counts and enforces limits.\n *\n * This middleware monitors the number of tool calls made during agent execution\n * and can terminate the agent when specified limits are reached. It supports\n * both thread-level and run-level call counting with configurable exit behaviors.\n *\n * Thread-level: The middleware counts all tool calls in the entire message history\n * and persists this count across multiple runs (invocations) of the agent.\n *\n * Run-level: The middleware counts tool calls made after the last HumanMessage,\n * representing the current run (invocation) of the agent.\n *\n * @param options - Configuration options for the middleware\n * @param options.toolName - Name of the specific tool to limit. If undefined, limits apply to all tools.\n * @param options.threadLimit - Maximum number of tool calls allowed per thread. undefined means no limit.\n * @param options.runLimit - Maximum number of tool calls allowed per run. undefined means no limit.\n * @param options.exitBehavior - What to do when limits are exceeded.\n *   - \"continue\": Block exceeded tools with error messages, let other tools continue. Model decides when to end. (default)\n *   - \"error\": Raise a ToolCallLimitExceededError exception\n *   - \"end\": Stop execution immediately with a ToolMessage + AI message for the single tool call that exceeded the limit. Raises NotImplementedError if there are multiple tool calls.\n *\n * @throws {Error} If both limits are undefined, if exitBehavior is invalid, or if runLimit exceeds threadLimit.\n * @throws {NotImplementedError} If exitBehavior is \"end\" and there are multiple tool calls.\n *\n * @example Continue execution with blocked tools (default)\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * // Block exceeded tools but let other tools and model continue\n * const limiter = toolCallLimitMiddleware({\n *   threadLimit: 20,\n *   runLimit: 10,\n *   exitBehavior: \"continue\", // default\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [limiter]\n * });\n * ```\n *\n * @example Stop immediately when limit exceeded\n * ```ts\n * // End execution immediately with an AI message\n * const limiter = toolCallLimitMiddleware({\n *   runLimit: 5,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [limiter]\n * });\n * ```\n *\n * @example Raise exception on limit\n * ```ts\n * // Strict limit with exception handling\n * const limiter = toolCallLimitMiddleware({\n *   toolName: \"search\",\n *   threadLimit: 5,\n *   exitBehavior: \"error\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [limiter]\n * });\n *\n * try {\n *   const result = await agent.invoke({ messages: [new HumanMessage(\"Task\")] });\n * } catch (error) {\n *   if (error instanceof ToolCallLimitExceededError) {\n *     console.log(`Search limit exceeded: ${error}`);\n *   }\n * }\n * ```\n */\nexport declare function toolCallLimitMiddleware(options: ToolCallLimitConfig): import(\"./types.js\").AgentMiddleware<z.ZodObject<{\n    threadToolCallCount: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;\n    runToolCallCount: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadToolCallCount: Record<string, number>;\n    runToolCallCount: Record<string, number>;\n}, {\n    threadToolCallCount?: Record<string, number> | undefined;\n    runToolCallCount?: Record<string, number> | undefined;\n}>, undefined, any>;\n"],"mappings":";;;;;;;;;AAQA;AA0BA;;AAI4BA,cA9BPE,0BAAAA,SAAmCC,KAAK,CA8B/BE;EAAS;;;EAKT,WAKAE,EAAAA,MAAAA;EAAS;;;EAWT,QAChBG,EAAAA,MAAAA;EAAU;AA1BoC;AAqC5D;EAA+B,WAAA,EAAA,MAAA,GAAA,SAAA;EAAA;;AAAuB;EAiF9BG,QAAAA,EAAAA,MAAAA,GAAAA,SAAuB;EAAA;;;EACc,QAAIN,EAAAA,MAAAA,GAAAA,SAAAA;EAAS,WAAlCO,CAAAA,WAAAA,EAAAA,MAAAA,EAAAA,QAAAA,EAAAA,MAAAA,EAAAA,WAAAA,EAAAA,MAAAA,GAAAA,SAAAA,EAAAA,QAAAA,EAAAA,MAAAA,GAAAA,SAAAA,EAAAA,QAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;;;;;AAClBd,cAxHDI,0BAwHGK,EAxHyBT,CAAAA,CAAEW,SAwH3BF,CAAAA;EAAU;;;EAGN,QAEFM,EAzHZf,CAAAA,CAAEM,WAyHUS,CAzHEf,CAAAA,CAAEK,SAyHJU,CAAAA;EAAM;;;AAPmF;eA7GlGf,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;YAKnBP,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;;;;;;;gBAWZP,CAAAA,CAAES,WAAWT,CAAAA,CAAEQ;YACrBR,CAAAA,CAAEU;;;;;;;;;;;KAWFE,mBAAAA,GAAsBX,4BAA4BG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiFtCS,uBAAAA,UAAiCD,sBAAsE,gBAAXZ,CAAAA,CAAEW;uBAC7FX,CAAAA,CAAES,WAAWT,CAAAA,CAAEc,UAAUd,CAAAA,CAAEK,WAAWL,CAAAA,CAAEO;oBAC3CP,CAAAA,CAAES,WAAWT,CAAAA,CAAEc,UAAUd,CAAAA,CAAEK,WAAWL,CAAAA,CAAEO;YAClDP,CAAAA,CAAEU;uBACWK;oBACHA;;wBAEIA;qBACHA"}

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

@@ -53,21 +53,25 @@ declare const ToolCallLimitOptionsSchema: z.ZodObject<{
   runLimit: z.ZodOptional<z.ZodNumber>;
   /**
    * What to do when limits are exceeded.
-   * - "end": Jump to the end of the agent execution and inject an artificial
-   *   AI message indicating that the limit was exceeded.
-   * - "error": throws a ToolCallLimitExceededError
+   * - "continue": Block exceeded tools with error messages, let other tools continue (default)
+   * - "error": Raise a ToolCallLimitExceededError exception
+   * - "end": Stop execution immediately, injecting a ToolMessage and an AI message
+   *   for the single tool call that exceeded the limit. Raises NotImplementedError
+   *   if there are multiple tool calls.
+   *
+   * @default "continue"
    */
-  exitBehavior: z.ZodDefault<z.ZodEnum<["end", "error"]>>;
+  exitBehavior: z.ZodDefault<z.ZodEnum<["continue", "error", "end"]>>;
 }, "strip", z.ZodTypeAny, {
   toolName?: string | undefined;
   threadLimit?: number | undefined;
   runLimit?: number | undefined;
-  exitBehavior: "end" | "error";
+  exitBehavior: "continue" | "end" | "error";
 }, {
   toolName?: string | undefined;
   threadLimit?: number | undefined;
   runLimit?: number | undefined;
-  exitBehavior?: "end" | "error" | undefined;
+  exitBehavior?: "continue" | "end" | "error" | undefined;
 }>;
 type ToolCallLimitConfig = InferInteropZodInput<typeof ToolCallLimitOptionsSchema>;
 /**
@@ -88,71 +92,78 @@ type ToolCallLimitConfig = InferInteropZodInput<typeof ToolCallLimitOptionsSchem
  * @param options.threadLimit - Maximum number of tool calls allowed per thread. undefined means no limit.
  * @param options.runLimit - Maximum number of tool calls allowed per run. undefined means no limit.
  * @param options.exitBehavior - What to do when limits are exceeded.
- *   - "end": Jump to the end of the agent execution and inject an artificial AI message indicating that the limit was exceeded.
- *   - "error": throws a ToolCallLimitExceededError
+ *   - "continue": Block exceeded tools with error messages, let other tools continue. Model decides when to end. (default)
+ *   - "error": Raise a ToolCallLimitExceededError exception
+ *   - "end": Stop execution immediately with a ToolMessage + AI message for the single tool call that exceeded the limit. Raises NotImplementedError if there are multiple tool calls.
  *
- * @throws {Error} If both limits are undefined or if exitBehavior is invalid.
+ * @throws {Error} If both limits are undefined, if exitBehavior is invalid, or if runLimit exceeds threadLimit.
+ * @throws {NotImplementedError} If exitBehavior is "end" and there are multiple tool calls.
  *
- * @example Limit all tool calls globally
+ * @example Continue execution with blocked tools (default)
  * ```ts
  * import { toolCallLimitMiddleware } from "@langchain/langchain/agents/middleware";
  * import { createAgent } from "@langchain/langchain/agents";
  *
- * const globalLimiter = toolCallLimitMiddleware({
+ * // Block exceeded tools but let other tools and model continue
+ * const limiter = toolCallLimitMiddleware({
  *   threadLimit: 20,
  *   runLimit: 10,
- *   exitBehavior: "end"
+ *   exitBehavior: "continue", // default
  * });
  *
  * const agent = createAgent({
  *   model: "openai:gpt-4o",
- *   middleware: [globalLimiter]
+ *   middleware: [limiter]
  * });
  * ```
  *
- * @example Limit a specific tool
+ * @example Stop immediately when limit exceeded
  * ```ts
- * import { toolCallLimitMiddleware } from "@langchain/langchain/agents/middleware";
- * import { createAgent } from "@langchain/langchain/agents";
- *
- * const searchLimiter = toolCallLimitMiddleware({
- *   toolName: "search",
- *   threadLimit: 5,
- *   runLimit: 3,
+ * // End execution immediately with an AI message
+ * const limiter = toolCallLimitMiddleware({
+ *   runLimit: 5,
  *   exitBehavior: "end"
  * });
  *
  * const agent = createAgent({
  *   model: "openai:gpt-4o",
- *   middleware: [searchLimiter]
+ *   middleware: [limiter]
  * });
  * ```
  *
- * @example Use both in the same agent
+ * @example Raise exception on limit
  * ```ts
- * import { toolCallLimitMiddleware } from "@langchain/langchain/agents/middleware";
- * import { createAgent } from "@langchain/langchain/agents";
- *
- * const globalLimiter = toolCallLimitMiddleware({
- *   threadLimit: 20,
- *   runLimit: 10,
- *   exitBehavior: "end"
- * });
- *
- * const searchLimiter = toolCallLimitMiddleware({
+ * // Strict limit with exception handling
+ * const limiter = toolCallLimitMiddleware({
  *   toolName: "search",
  *   threadLimit: 5,
- *   runLimit: 3,
- *   exitBehavior: "end"
+ *   exitBehavior: "error"
  * });
  *
  * const agent = createAgent({
  *   model: "openai:gpt-4o",
- *   middleware: [globalLimiter, searchLimiter]
+ *   middleware: [limiter]
  * });
+ *
+ * try {
+ *   const result = await agent.invoke({ messages: [new HumanMessage("Task")] });
+ * } catch (error) {
+ *   if (error instanceof ToolCallLimitExceededError) {
+ *     console.log(`Search limit exceeded: ${error}`);
+ *   }
+ * }
  * ```
  */
-declare function toolCallLimitMiddleware(options: ToolCallLimitConfig): AgentMiddleware<undefined, undefined, any>;
+declare function toolCallLimitMiddleware(options: ToolCallLimitConfig): AgentMiddleware<z.ZodObject<{
+  threadToolCallCount: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+  runToolCallCount: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+  threadToolCallCount: Record<string, number>;
+  runToolCallCount: Record<string, number>;
+}, {
+  threadToolCallCount?: Record<string, number> | undefined;
+  runToolCallCount?: Record<string, number> | undefined;
+}>, undefined, any>;
 //#endregion
 export { ToolCallLimitConfig, ToolCallLimitExceededError, toolCallLimitMiddleware };
 //# sourceMappingURL=toolCallLimit.d.ts.map

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_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"}
+{"version":3,"file":"toolCallLimit.d.ts","names":["z","InferInteropZodInput","ToolCallLimitExceededError","Error","ToolCallLimitOptionsSchema","ZodString","ZodOptional","ZodNumber","ZodEnum","ZodDefault","ZodTypeAny","ZodObject","ToolCallLimitConfig","toolCallLimitMiddleware","ZodRecord","Record","__types_js4","AgentMiddleware"],"sources":["../../../src/agents/middleware/toolCallLimit.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport type { InferInteropZodInput } from \"@langchain/core/utils/types\";\n/**\n * Exception raised when tool call limits are exceeded.\n *\n * This exception is raised when the configured exit behavior is 'error'\n * and either the thread or run tool call limit has been exceeded.\n */\nexport declare class ToolCallLimitExceededError extends Error {\n    /**\n     * Current thread tool call count.\n     */\n    threadCount: number;\n    /**\n     * Current run tool call count.\n     */\n    runCount: number;\n    /**\n     * Thread tool call limit (if set).\n     */\n    threadLimit: number | undefined;\n    /**\n     * Run tool call limit (if set).\n     */\n    runLimit: number | undefined;\n    /**\n     * Tool name being limited (if specific tool), or undefined for all tools.\n     */\n    toolName: string | undefined;\n    constructor(threadCount: number, runCount: number, threadLimit: number | undefined, runLimit: number | undefined, toolName?: string | undefined);\n}\n/**\n * Options for configuring the Tool Call Limit middleware.\n */\nexport declare const ToolCallLimitOptionsSchema: z.ZodObject<{\n    /**\n     * Name of the specific tool to limit. If undefined, limits apply to all tools.\n     */\n    toolName: z.ZodOptional<z.ZodString>;\n    /**\n     * Maximum number of tool calls allowed per thread.\n     * undefined means no limit.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * Maximum number of tool calls allowed per run.\n     * undefined means no limit.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * What to do when limits are exceeded.\n     * - \"continue\": Block exceeded tools with error messages, let other tools continue (default)\n     * - \"error\": Raise a ToolCallLimitExceededError exception\n     * - \"end\": Stop execution immediately, injecting a ToolMessage and an AI message\n     *   for the single tool call that exceeded the limit. Raises NotImplementedError\n     *   if there are multiple tool calls.\n     *\n     * @default \"continue\"\n     */\n    exitBehavior: z.ZodDefault<z.ZodEnum<[\"continue\", \"error\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    toolName?: string | undefined;\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior: \"continue\" | \"end\" | \"error\";\n}, {\n    toolName?: string | undefined;\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"continue\" | \"end\" | \"error\" | undefined;\n}>;\nexport type ToolCallLimitConfig = InferInteropZodInput<typeof ToolCallLimitOptionsSchema>;\n/**\n * Middleware that tracks tool call counts and enforces limits.\n *\n * This middleware monitors the number of tool calls made during agent execution\n * and can terminate the agent when specified limits are reached. It supports\n * both thread-level and run-level call counting with configurable exit behaviors.\n *\n * Thread-level: The middleware counts all tool calls in the entire message history\n * and persists this count across multiple runs (invocations) of the agent.\n *\n * Run-level: The middleware counts tool calls made after the last HumanMessage,\n * representing the current run (invocation) of the agent.\n *\n * @param options - Configuration options for the middleware\n * @param options.toolName - Name of the specific tool to limit. If undefined, limits apply to all tools.\n * @param options.threadLimit - Maximum number of tool calls allowed per thread. undefined means no limit.\n * @param options.runLimit - Maximum number of tool calls allowed per run. undefined means no limit.\n * @param options.exitBehavior - What to do when limits are exceeded.\n *   - \"continue\": Block exceeded tools with error messages, let other tools continue. Model decides when to end. (default)\n *   - \"error\": Raise a ToolCallLimitExceededError exception\n *   - \"end\": Stop execution immediately with a ToolMessage + AI message for the single tool call that exceeded the limit. Raises NotImplementedError if there are multiple tool calls.\n *\n * @throws {Error} If both limits are undefined, if exitBehavior is invalid, or if runLimit exceeds threadLimit.\n * @throws {NotImplementedError} If exitBehavior is \"end\" and there are multiple tool calls.\n *\n * @example Continue execution with blocked tools (default)\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * // Block exceeded tools but let other tools and model continue\n * const limiter = toolCallLimitMiddleware({\n *   threadLimit: 20,\n *   runLimit: 10,\n *   exitBehavior: \"continue\", // default\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [limiter]\n * });\n * ```\n *\n * @example Stop immediately when limit exceeded\n * ```ts\n * // End execution immediately with an AI message\n * const limiter = toolCallLimitMiddleware({\n *   runLimit: 5,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [limiter]\n * });\n * ```\n *\n * @example Raise exception on limit\n * ```ts\n * // Strict limit with exception handling\n * const limiter = toolCallLimitMiddleware({\n *   toolName: \"search\",\n *   threadLimit: 5,\n *   exitBehavior: \"error\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [limiter]\n * });\n *\n * try {\n *   const result = await agent.invoke({ messages: [new HumanMessage(\"Task\")] });\n * } catch (error) {\n *   if (error instanceof ToolCallLimitExceededError) {\n *     console.log(`Search limit exceeded: ${error}`);\n *   }\n * }\n * ```\n */\nexport declare function toolCallLimitMiddleware(options: ToolCallLimitConfig): import(\"./types.js\").AgentMiddleware<z.ZodObject<{\n    threadToolCallCount: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;\n    runToolCallCount: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadToolCallCount: Record<string, number>;\n    runToolCallCount: Record<string, number>;\n}, {\n    threadToolCallCount?: Record<string, number> | undefined;\n    runToolCallCount?: Record<string, number> | undefined;\n}>, undefined, any>;\n"],"mappings":";;;;;;;;;AAQA;AA0BA;;AAI4BA,cA9BPE,0BAAAA,SAAmCC,KAAK,CA8B/BE;EAAS;;;EAKT,WAKAE,EAAAA,MAAAA;EAAS;;;EAWT,QAChBG,EAAAA,MAAAA;EAAU;AA1BoC;AAqC5D;EAA+B,WAAA,EAAA,MAAA,GAAA,SAAA;EAAA;;AAAuB;EAiF9BG,QAAAA,EAAAA,MAAAA,GAAAA,SAAuB;EAAA;;;EACc,QAAIN,EAAAA,MAAAA,GAAAA,SAAAA;EAAS,WAAlCO,CAAAA,WAAAA,EAAAA,MAAAA,EAAAA,QAAAA,EAAAA,MAAAA,EAAAA,WAAAA,EAAAA,MAAAA,GAAAA,SAAAA,EAAAA,QAAAA,EAAAA,MAAAA,GAAAA,SAAAA,EAAAA,QAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;;;;;AAClBd,cAxHDI,0BAwHGK,EAxHyBT,CAAAA,CAAEW,SAwH3BF,CAAAA;EAAU;;;EAGN,QAEFM,EAzHZf,CAAAA,CAAEM,WAyHUS,CAzHEf,CAAAA,CAAEK,SAyHJU,CAAAA;EAAM;;;AAPmF;eA7GlGf,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;YAKnBP,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;;;;;;;gBAWZP,CAAAA,CAAES,WAAWT,CAAAA,CAAEQ;YACrBR,CAAAA,CAAEU;;;;;;;;;;;KAWFE,mBAAAA,GAAsBX,4BAA4BG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiFtCS,uBAAAA,UAAiCD,sBAAsE,gBAAXZ,CAAAA,CAAEW;uBAC7FX,CAAAA,CAAES,WAAWT,CAAAA,CAAEc,UAAUd,CAAAA,CAAEK,WAAWL,CAAAA,CAAEO;oBAC3CP,CAAAA,CAAES,WAAWT,CAAAA,CAAEc,UAAUd,CAAAA,CAAEK,WAAWL,CAAAA,CAAEO;YAClDP,CAAAA,CAAEU;uBACWK;oBACHA;;wBAEIA;qBACHA"}

package/dist/agents/middleware/toolCallLimit.js

@@ -1,64 +1,54 @@
 import { createMiddleware } from "../middleware.js";
-import { AIMessage, HumanMessage } from "@langchain/core/messages";
+import { AIMessage, ToolMessage } from "@langchain/core/messages";
 import { z } from "zod/v3";
+import { z as z$1 } from "zod/v4";
 
 //#region src/agents/middleware/toolCallLimit.ts
 /**
-* Count tool calls in a list of messages.
+* Build the error message content for ToolMessage when limit is exceeded.
 *
-* @param messages - List of messages to count tool calls in.
-* @param toolName - If specified, only count calls to this specific tool.
-*   If undefined, count all tool calls.
-* @returns The total number of tool calls (optionally filtered by toolName).
-*/
-function countToolCallsInMessages(messages, toolName) {
-	let count = 0;
-	for (const message of messages) if (AIMessage.isInstance(message) && message.tool_calls) if (toolName === void 0) count += message.tool_calls.length;
-	else count += message.tool_calls.filter((tc) => tc.name === toolName).length;
-	return count;
-}
-/**
-* Get messages from the current run (after the last HumanMessage).
+* This message is sent to the model, so it should not reference thread/run concepts
+* that the model has no notion of.
 *
-* @param messages - Full list of messages.
-* @returns Messages from the current run (after last HumanMessage).
+* @param toolName - Tool name being limited (if specific tool), or undefined for all tools.
+* @returns A concise message instructing the model not to call the tool again.
 */
-function getRunMessages(messages) {
-	/**
-	* Find the last HumanMessage
-	*/
-	let lastHumanIndex = -1;
-	for (let i = messages.length - 1; i >= 0; i--) if (HumanMessage.isInstance(messages[i])) {
-		lastHumanIndex = i;
-		break;
-	}
-	/**
-	* If no HumanMessage found, return all messages
-	*/
-	if (lastHumanIndex === -1) return messages;
-	/**
-	* Return messages after the last HumanMessage
-	*/
-	return messages.slice(lastHumanIndex + 1);
+function buildToolMessageContent(toolName) {
+	if (toolName) return `Tool call limit exceeded. Do not call '${toolName}' again.`;
+	return "Tool call limit exceeded. Do not make additional tool calls.";
 }
+const VALID_EXIT_BEHAVIORS = [
+	"continue",
+	"error",
+	"end"
+];
+const DEFAULT_EXIT_BEHAVIOR = "continue";
 /**
-* Build a message indicating which tool call limits were reached.
+* Build the final AI message content for 'end' behavior.
+*
+* This message is displayed to the user, so it should include detailed information
+* about which limits were exceeded.
 *
 * @param threadCount - Current thread tool call count.
 * @param runCount - Current run tool call count.
 * @param threadLimit - Thread tool call limit (if set).
 * @param runLimit - Run tool call limit (if set).
 * @param toolName - Tool name being limited (if specific tool), or undefined for all tools.
-* @returns A formatted message describing which limits were reached.
+* @returns A formatted message describing which limits were exceeded.
 */
-function buildToolLimitExceededMessage(threadCount, runCount, threadLimit, runLimit, toolName) {
-	const toolDesc = toolName ? `'${toolName}' tool call` : "Tool call";
+function buildFinalAIMessageContent(threadCount, runCount, threadLimit, runLimit, toolName) {
+	const toolDesc = toolName ? `'${toolName}' tool` : "Tool";
 	const exceededLimits = [];
-	if (threadLimit !== void 0 && threadCount >= threadLimit) exceededLimits.push(`thread limit reached (${threadCount}/${threadLimit})`);
-	if (runLimit !== void 0 && runCount >= runLimit) exceededLimits.push(`run limit reached (${runCount}/${runLimit})`);
-	return `${toolDesc} limit${exceededLimits.length > 1 ? "s" : ""}: ${exceededLimits.join(", ")}. Stopping to prevent further tool calls.`;
+	if (threadLimit !== void 0 && threadCount > threadLimit) exceededLimits.push(`thread limit exceeded (${threadCount}/${threadLimit} calls)`);
+	if (runLimit !== void 0 && runCount > runLimit) exceededLimits.push(`run limit exceeded (${runCount}/${runLimit} calls)`);
+	const limitsText = exceededLimits.join(" and ");
+	return `${toolDesc} call limit reached: ${limitsText}.`;
 }
 /**
+* Schema for the exit behavior.
+*/
+const exitBehaviorSchema = z.enum(VALID_EXIT_BEHAVIORS).default(DEFAULT_EXIT_BEHAVIOR);
+/**
 * Exception raised when tool call limits are exceeded.
 *
 * This exception is raised when the configured exit behavior is 'error'
@@ -86,7 +76,7 @@ var ToolCallLimitExceededError = class extends Error {
 	*/
 	toolName;
 	constructor(threadCount, runCount, threadLimit, runLimit, toolName = void 0) {
-		const message = buildToolLimitExceededMessage(threadCount, runCount, threadLimit, runLimit, toolName);
+		const message = buildFinalAIMessageContent(threadCount, runCount, threadLimit, runLimit, toolName);
 		super(message);
 		this.name = "ToolCallLimitExceededError";
 		this.threadCount = threadCount;
@@ -103,9 +93,17 @@ const ToolCallLimitOptionsSchema = z.object({
 	toolName: z.string().optional(),
 	threadLimit: z.number().optional(),
 	runLimit: z.number().optional(),
-	exitBehavior: z.enum(["end", "error"]).default("end")
+	exitBehavior: exitBehaviorSchema
 });
 /**
+* Middleware state schema to track the number of model calls made at the thread and run level.
+*/
+const stateSchema = z.object({
+	threadToolCallCount: z.record(z.string(), z.number()).default({}),
+	runToolCallCount: z.record(z.string(), z.number()).default({})
+});
+const DEFAULT_TOOL_COUNT_KEY = "__all__";
+/**
 * Middleware that tracks tool call counts and enforces limits.
 *
 * This middleware monitors the number of tool calls made during agent execution
@@ -123,68 +121,66 @@ const ToolCallLimitOptionsSchema = z.object({
 * @param options.threadLimit - Maximum number of tool calls allowed per thread. undefined means no limit.
 * @param options.runLimit - Maximum number of tool calls allowed per run. undefined means no limit.
 * @param options.exitBehavior - What to do when limits are exceeded.
-*   - "end": Jump to the end of the agent execution and inject an artificial AI message indicating that the limit was exceeded.
-*   - "error": throws a ToolCallLimitExceededError
+*   - "continue": Block exceeded tools with error messages, let other tools continue. Model decides when to end. (default)
+*   - "error": Raise a ToolCallLimitExceededError exception
+*   - "end": Stop execution immediately with a ToolMessage + AI message for the single tool call that exceeded the limit. Raises NotImplementedError if there are multiple tool calls.
 *
-* @throws {Error} If both limits are undefined or if exitBehavior is invalid.
+* @throws {Error} If both limits are undefined, if exitBehavior is invalid, or if runLimit exceeds threadLimit.
+* @throws {NotImplementedError} If exitBehavior is "end" and there are multiple tool calls.
 *
-* @example Limit all tool calls globally
+* @example Continue execution with blocked tools (default)
 * ```ts
 * import { toolCallLimitMiddleware } from "@langchain/langchain/agents/middleware";
 * import { createAgent } from "@langchain/langchain/agents";
 *
-* const globalLimiter = toolCallLimitMiddleware({
+* // Block exceeded tools but let other tools and model continue
+* const limiter = toolCallLimitMiddleware({
 *   threadLimit: 20,
 *   runLimit: 10,
-*   exitBehavior: "end"
+*   exitBehavior: "continue", // default
 * });
 *
 * const agent = createAgent({
 *   model: "openai:gpt-4o",
-*   middleware: [globalLimiter]
+*   middleware: [limiter]
 * });
 * ```
 *
-* @example Limit a specific tool
+* @example Stop immediately when limit exceeded
 * ```ts
-* import { toolCallLimitMiddleware } from "@langchain/langchain/agents/middleware";
-* import { createAgent } from "@langchain/langchain/agents";
-*
-* const searchLimiter = toolCallLimitMiddleware({
-*   toolName: "search",
-*   threadLimit: 5,
-*   runLimit: 3,
+* // End execution immediately with an AI message
+* const limiter = toolCallLimitMiddleware({
+*   runLimit: 5,
 *   exitBehavior: "end"
 * });
 *
 * const agent = createAgent({
 *   model: "openai:gpt-4o",
-*   middleware: [searchLimiter]
+*   middleware: [limiter]
 * });
 * ```
 *
-* @example Use both in the same agent
+* @example Raise exception on limit
 * ```ts
-* import { toolCallLimitMiddleware } from "@langchain/langchain/agents/middleware";
-* import { createAgent } from "@langchain/langchain/agents";
-*
-* const globalLimiter = toolCallLimitMiddleware({
-*   threadLimit: 20,
-*   runLimit: 10,
-*   exitBehavior: "end"
-* });
-*
-* const searchLimiter = toolCallLimitMiddleware({
+* // Strict limit with exception handling
+* const limiter = toolCallLimitMiddleware({
 *   toolName: "search",
 *   threadLimit: 5,
-*   runLimit: 3,
-*   exitBehavior: "end"
+*   exitBehavior: "error"
 * });
 *
 * const agent = createAgent({
 *   model: "openai:gpt-4o",
-*   middleware: [globalLimiter, searchLimiter]
+*   middleware: [limiter]
 * });
+*
+* try {
+*   const result = await agent.invoke({ messages: [new HumanMessage("Task")] });
+* } catch (error) {
+*   if (error instanceof ToolCallLimitExceededError) {
+*     console.log(`Search limit exceeded: ${error}`);
+*   }
+* }
 * ```
 */
 function toolCallLimitMiddleware(options) {
@@ -193,47 +189,173 @@ function toolCallLimitMiddleware(options) {
 	*/
 	if (options.threadLimit === void 0 && options.runLimit === void 0) throw new Error("At least one limit must be specified (threadLimit or runLimit)");
 	/**
-	* Apply default for exitBehavior and validate
+	* Validate exitBehavior (Zod schema already validates, but provide helpful error)
+	*/
+	const exitBehavior = options.exitBehavior ?? DEFAULT_EXIT_BEHAVIOR;
+	const parseResult = exitBehaviorSchema.safeParse(exitBehavior);
+	if (!parseResult.success) throw new Error(z$1.prettifyError(parseResult.error).slice(2));
+	/**
+	* Validate that runLimit does not exceed threadLimit
 	*/
-	const exitBehavior = options.exitBehavior ?? "end";
-	if (exitBehavior !== "end" && exitBehavior !== "error") throw new Error(`Invalid exit behavior: ${exitBehavior}. Must be 'end' or 'error'`);
+	if (options.threadLimit !== void 0 && options.runLimit !== void 0 && options.runLimit > options.threadLimit) throw new Error(`runLimit (${options.runLimit}) cannot exceed threadLimit (${options.threadLimit}). The run limit should be less than or equal to the thread limit.`);
 	/**
 	* Generate the middleware name based on the tool name
 	*/
 	const middlewareName = options.toolName ? `ToolCallLimitMiddleware[${options.toolName}]` : "ToolCallLimitMiddleware";
 	return createMiddleware({
 		name: middlewareName,
-		beforeModel: {
+		stateSchema,
+		afterModel: {
 			canJumpTo: ["end"],
 			hook: (state) => {
-				const messages = state.messages;
 				/**
-				* Count tool calls in entire thread
+				* Get the last AI message to check for tool calls
+				*/
+				const lastAIMessage = [...state.messages].reverse().find(AIMessage.isInstance);
+				if (!lastAIMessage || !lastAIMessage.tool_calls) return void 0;
+				/**
+				* Helper to check if limit would be exceeded by one more call
+				*/
+				const wouldExceedLimit = (threadCount, runCount) => {
+					return options.threadLimit !== void 0 && threadCount + 1 > options.threadLimit || options.runLimit !== void 0 && runCount + 1 > options.runLimit;
+				};
+				/**
+				* Helper to check if a tool call matches our filter
+				*/
+				const matchesToolFilter = (toolCall) => {
+					return options.toolName === void 0 || toolCall.name === options.toolName;
+				};
+				/**
+				* Separate tool calls into allowed and blocked based on limits
+				*/
+				const separateToolCalls = (toolCalls, threadCount, runCount) => {
+					const allowed$1 = [];
+					const blocked$1 = [];
+					let tempThreadCount = threadCount;
+					let tempRunCount = runCount;
+					for (const toolCall of toolCalls) {
+						if (!matchesToolFilter(toolCall)) continue;
+						if (wouldExceedLimit(tempThreadCount, tempRunCount)) blocked$1.push(toolCall);
+						else {
+							allowed$1.push(toolCall);
+							tempThreadCount += 1;
+							tempRunCount += 1;
+						}
+					}
+					return {
+						allowed: allowed$1,
+						blocked: blocked$1,
+						finalThreadCount: tempThreadCount,
+						finalRunCount: tempRunCount + blocked$1.length
+					};
+				};
+				/**
+				* Get the count key for this middleware instance
+				*/
+				const countKey = options.toolName ?? DEFAULT_TOOL_COUNT_KEY;
+				/**
+				* Get current counts
+				*/
+				const threadCounts = { ...state.threadToolCallCount ?? {} };
+				const runCounts = { ...state.runToolCallCount ?? {} };
+				const currentThreadCount = threadCounts[countKey] ?? 0;
+				const currentRunCount = runCounts[countKey] ?? 0;
+				/**
+				* Separate tool calls into allowed and blocked
+				*/
+				const { allowed, blocked, finalThreadCount, finalRunCount } = separateToolCalls(lastAIMessage.tool_calls, currentThreadCount, currentRunCount);
+				/**
+				* Update counts:
+				* - Thread count includes only allowed calls (blocked calls don't count towards thread-level tracking)
+				* - Run count includes blocked calls since they were attempted in this run
+				*/
+				threadCounts[countKey] = finalThreadCount;
+				runCounts[countKey] = finalRunCount;
+				/**
+				* If no tool calls are blocked, just update counts
+				*/
+				if (blocked.length === 0) {
+					if (allowed.length > 0) return {
+						threadToolCallCount: threadCounts,
+						runToolCallCount: runCounts
+					};
+					return void 0;
+				}
+				/**
+				* Handle different exit behaviors
 				*/
-				const threadCount = countToolCallsInMessages(messages, options.toolName);
+				if (exitBehavior === "error") {
+					const hypotheticalThreadCount = finalThreadCount + blocked.length;
+					throw new ToolCallLimitExceededError(hypotheticalThreadCount, finalRunCount, options.threadLimit, options.runLimit, options.toolName);
+				}
 				/**
-				* Count tool calls in current run (after last HumanMessage)
+				* Build tool message content (sent to model - no thread/run details)
 				*/
-				const runMessages = getRunMessages(messages);
-				const runCount = countToolCallsInMessages(runMessages, options.toolName);
+				const toolMsgContent = buildToolMessageContent(options.toolName);
 				/**
-				* Check if any limits are exceeded
+				* Inject artificial error ToolMessages for blocked tool calls
 				*/
-				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);
+				const artificialMessages = blocked.map((toolCall) => new ToolMessage({
+					content: toolMsgContent,
+					tool_call_id: toolCall.id,
+					name: toolCall.name,
+					status: "error"
+				}));
+				if (exitBehavior === "end") {
+					/**
+					* Check if there are tool calls to other tools that would continue executing
+					* For tool-specific limiters: check for calls to other tools
+					* For global limiters: check if there are multiple different tool types
+					*/
+					let otherTools = [];
+					if (options.toolName !== void 0)
+ /**
+					* Tool-specific limiter: check for calls to other tools
+					*/
+					otherTools = lastAIMessage.tool_calls.filter((tc) => tc.name !== options.toolName);
+					else {
+						/**
+						* Global limiter: check if there are multiple different tool types
+						* If there are allowed calls, those would execute
+						* But even if all are blocked, we can't handle multiple tool types with "end"
+						*/
+						const uniqueToolNames = new Set(lastAIMessage.tool_calls.map((tc) => tc.name).filter(Boolean));
+						if (uniqueToolNames.size > 1)
+ /**
+						* Multiple different tool types - use allowed calls to show which ones
+						*/
+						otherTools = allowed.length > 0 ? allowed : lastAIMessage.tool_calls;
+					}
+					if (otherTools.length > 0) {
+						const toolNames = Array.from(new Set(otherTools.map((tc) => tc.name).filter(Boolean))).join(", ");
+						throw new Error(`Cannot end execution with other tool calls pending. Found calls to: ${toolNames}. Use 'continue' or 'error' behavior instead.`);
+					}
+					/**
+					* Build final AI message content (displayed to user - includes thread/run details)
+					* Use hypothetical thread count (what it would have been if call wasn't blocked)
+					* to show which limit was actually exceeded
+					*/
+					const hypotheticalThreadCount = finalThreadCount + blocked.length;
+					const finalMsgContent = buildFinalAIMessageContent(hypotheticalThreadCount, finalRunCount, options.threadLimit, options.runLimit, options.toolName);
+					artificialMessages.push(new AIMessage(finalMsgContent));
+					return {
+						threadToolCallCount: threadCounts,
+						runToolCallCount: runCounts,
+						jumpTo: "end",
+						messages: artificialMessages
+					};
+				}
 				/**
-				* Create a message indicating the limit was exceeded
+				* For exit_behavior="continue", return error messages to block exceeded tools
 				*/
-				const limitMessage = buildToolLimitExceededMessage(threadCount, runCount, options.threadLimit, options.runLimit, options.toolName);
-				const limitAiMessage = new AIMessage(limitMessage);
 				return {
-					jumpTo: "end",
-					messages: [limitAiMessage]
+					threadToolCallCount: threadCounts,
+					runToolCallCount: runCounts,
+					messages: artificialMessages
 				};
 			}
-		}
+		},
+		afterAgent: () => ({ runToolCallCount: {} })
 	});
 }