npm - langchain - Versions diffs - 1.0.2 → 1.0.3 - Mend

langchain 1.0.2 → 1.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (431) hide show

package/dist/agents/middleware/toolCallLimit.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"toolCallLimit.cjs","names":["messages: BaseMessage[]","toolName?: string","AIMessage","HumanMessage","threadCount: number","runCount: number","threadLimit: number \| undefined","runLimit: number \| undefined","toolName: string \| undefined","exceededLimits: string[]","z","options: ToolCallLimitConfig","createMiddleware"],"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":"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"}
1	+ {"version":3,"file":"toolCallLimit.cjs","names":["toolName: string \| undefined","threadCount: number","runCount: number","threadLimit: number \| undefined","runLimit: number \| undefined","exceededLimits: string[]","z","options: ToolCallLimitConfig","createMiddleware","AIMessage","toolCall: { name?: string }","toolCalls: ToolCall[]","allowed: ToolCall[]","blocked: ToolCall[]","blocked","allowed","artificialMessages: Array<ToolMessage \| AIMessage>","ToolMessage","otherTools: ToolCall[]"],"sources":["../../../src/agents/middleware/toolCallLimit.ts"],"sourcesContent":["import { AIMessage, ToolMessage } from \"@langchain/core/messages\";\nimport { z } from \"zod/v3\";\nimport type { InferInteropZodInput } from \"@langchain/core/utils/types\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\n\nimport { createMiddleware } from \"../middleware.js\";\n\n/*\n Build the error message content for ToolMessage when limit is exceeded.\n \n This message is sent to the model, so it should not reference thread/run concepts\n * that the model has no notion of.\n \n @param toolName - Tool name being limited (if specific tool), or undefined for all tools.\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 * @returns A concise message. If only run limit is exceeded (not thread limit),\n * returns a simple \"limit exceeded\" message without instructing model to stop.\n * If thread limit is exceeded, includes instruction not to call again.\n /\nfunction buildToolMessageContent(\n toolName: string \| undefined,\n threadCount: number,\n runCount: number,\n threadLimit: number \| undefined,\n runLimit: number \| undefined\n): string {\n // Check if thread limit is exceeded\n const threadExceeded = threadLimit !== undefined && threadCount > threadLimit;\n // Check if only run limit is exceeded (not thread limit)\n const onlyRunExceeded =\n runLimit !== undefined && runCount > runLimit && !threadExceeded;\n\n if (onlyRunExceeded) {\n // Run limit exceeded but thread limit not exceeded - simpler message\n if (toolName) {\n return `Tool call limit exceeded for '${toolName}'.`;\n }\n return \"Tool call limit exceeded.\";\n }\n\n // Thread limit exceeded (or both) - include instruction not to call again\n if (toolName) {\n return `Tool call limit exceeded. Do not call '${toolName}' again.`;\n }\n return \"Tool call limit exceeded. Do not make additional tool calls.\";\n}\n\n/\n Build the final AI message content for 'end' behavior.\n \n This message is displayed to the user, so it should include detailed information\n * about which limits were exceeded.\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 exceeded.\n /\nfunction buildFinalAIMessageContent(\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` : \"Tool\";\n const exceededLimits: string[] = [];\n\n if (threadLimit !== undefined && threadCount > threadLimit) {\n exceededLimits.push(\n `thread limit exceeded (${threadCount}/${threadLimit} calls)`\n );\n }\n if (runLimit !== undefined && runCount > runLimit) {\n exceededLimits.push(`run limit exceeded (${runCount}/${runLimit} calls)`);\n }\n\n const limitsText = exceededLimits.join(\" and \");\n return `${toolDesc} call limit reached: ${limitsText}.`;\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 = buildFinalAIMessageContent(\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 * - \"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 exitBehavior: z.enum([\"continue\", \"error\", \"end\"]).default(\"continue\"),\n});\n\nexport type ToolCallLimitConfig = InferInteropZodInput<\n typeof ToolCallLimitOptionsSchema\n>;\n\n/\n Middleware state schema to track the number of model calls made at the thread and run level.\n /\nconst stateSchema = z.object({\n threadToolCallCount: z.record(z.string(), z.number()).default({}),\n runToolCallCount: z.record(z.string(), z.number()).default({}),\n});\n\nconst DEFAULT_TOOL_COUNT_KEY = \"__all__\";\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 * - \"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.\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 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\n /\n const exitBehavior = options.exitBehavior ?? \"continue\";\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 stateSchema,\n afterModel: {\n canJumpTo: [\"end\"],\n hook: (state) => {\n /\n Get the last AI message to check for tool calls\n /\n const lastAIMessage = [...state.messages]\n .reverse()\n .find(AIMessage.isInstance);\n\n if (!lastAIMessage \|\| !lastAIMessage.tool_calls) {\n return undefined;\n }\n\n /\n Helper to check if limit would be exceeded by one more call\n /\n const wouldExceedLimit = (\n threadCount: number,\n runCount: number\n ): boolean => {\n return (\n (options.threadLimit !== undefined &&\n threadCount + 1 > options.threadLimit) \|\|\n (options.runLimit !== undefined && runCount + 1 > options.runLimit)\n );\n };\n\n /\n Helper to check if a tool call matches our filter\n /\n const matchesToolFilter = (toolCall: { name?: string }): boolean => {\n return (\n options.toolName === undefined \|\| toolCall.name === options.toolName\n );\n };\n\n /\n Separate tool calls into allowed and blocked based on limits\n /\n const separateToolCalls = (\n toolCalls: ToolCall[],\n threadCount: number,\n runCount: number\n ): {\n allowed: ToolCall[];\n blocked: ToolCall[];\n finalThreadCount: number;\n finalRunCount: number;\n } => {\n const allowed: ToolCall[] = [];\n const blocked: ToolCall[] = [];\n let tempThreadCount = threadCount;\n let tempRunCount = runCount;\n\n for (const toolCall of toolCalls) {\n if (!matchesToolFilter(toolCall)) {\n // Tool call doesn't match our filter, skip it\n continue;\n }\n\n if (wouldExceedLimit(tempThreadCount, tempRunCount)) {\n blocked.push(toolCall);\n } else {\n allowed.push(toolCall);\n tempThreadCount += 1;\n tempRunCount += 1;\n }\n }\n\n return {\n allowed,\n blocked,\n finalThreadCount: tempThreadCount + blocked.length,\n finalRunCount: tempRunCount + blocked.length,\n };\n };\n\n /\n Get the count key for this middleware instance\n /\n const countKey = options.toolName ?? DEFAULT_TOOL_COUNT_KEY;\n\n /\n Get current counts\n /\n const threadCounts = { ...(state.threadToolCallCount ?? {}) };\n const runCounts = { ...(state.runToolCallCount ?? {}) };\n const currentThreadCount = threadCounts[countKey] ?? 0;\n const currentRunCount = runCounts[countKey] ?? 0;\n\n /\n Separate tool calls into allowed and blocked\n /\n const { allowed, blocked, finalThreadCount, finalRunCount } =\n separateToolCalls(\n lastAIMessage.tool_calls,\n currentThreadCount,\n currentRunCount\n );\n\n /\n Update counts to include ALL tool call attempts (both allowed and blocked)\n /\n threadCounts[countKey] = finalThreadCount;\n runCounts[countKey] = finalRunCount;\n\n /\n If no tool calls are blocked, just update counts\n /\n if (blocked.length === 0) {\n if (allowed.length > 0) {\n return {\n threadToolCallCount: threadCounts,\n runToolCallCount: runCounts,\n };\n }\n return undefined;\n }\n\n /\n Handle different exit behaviors\n /\n if (exitBehavior === \"error\") {\n throw new ToolCallLimitExceededError(\n finalThreadCount,\n finalRunCount,\n options.threadLimit,\n options.runLimit,\n options.toolName\n );\n }\n\n /\n Build tool message content (sent to model - no thread/run details)\n /\n const toolMsgContent = buildToolMessageContent(\n options.toolName,\n finalThreadCount,\n finalRunCount,\n options.threadLimit,\n options.runLimit\n );\n\n /\n Inject artificial error ToolMessages for blocked tool calls\n /\n const artificialMessages: Array<ToolMessage \| AIMessage> = blocked.map(\n (toolCall) =>\n new ToolMessage({\n content: toolMsgContent,\n tool_call_id: toolCall.id!,\n name: toolCall.name,\n status: \"error\",\n })\n );\n\n if (exitBehavior === \"end\") {\n /\n Check if there are tool calls to other tools that would continue executing\n * For tool-specific limiters: check for calls to other tools\n * For global limiters: check if there are multiple different tool types\n /\n let otherTools: ToolCall[] = [];\n if (options.toolName !== undefined) {\n /\n Tool-specific limiter: check for calls to other tools\n /\n otherTools = lastAIMessage.tool_calls.filter(\n (tc) => tc.name !== options.toolName\n );\n } else {\n /\n Global limiter: check if there are multiple different tool types\n * If there are allowed calls, those would execute\n * But even if all are blocked, we can't handle multiple tool types with \"end\"\n /\n const uniqueToolNames = new Set(\n lastAIMessage.tool_calls.map((tc) => tc.name).filter(Boolean)\n );\n if (uniqueToolNames.size > 1) {\n /\n Multiple different tool types - use allowed calls to show which ones\n /\n otherTools =\n allowed.length > 0 ? allowed : lastAIMessage.tool_calls;\n }\n }\n\n if (otherTools.length > 0) {\n const toolNames = Array.from(\n new Set(otherTools.map((tc) => tc.name).filter(Boolean))\n ).join(\", \");\n throw new Error(\n `Cannot end execution with other tool calls pending. Found calls to: ${toolNames}. Use 'continue' or 'error' behavior instead.`\n );\n }\n\n /\n Build final AI message content (displayed to user - includes thread/run details)\n /\n const finalMsgContent = buildFinalAIMessageContent(\n finalThreadCount,\n finalRunCount,\n options.threadLimit,\n options.runLimit,\n options.toolName\n );\n artificialMessages.push(new AIMessage(finalMsgContent));\n\n return {\n threadToolCallCount: threadCounts,\n runToolCallCount: runCounts,\n jumpTo: \"end\" as const,\n messages: artificialMessages,\n };\n }\n\n /\n For exit_behavior=\"continue\", return error messages to block exceeded tools\n /\n return {\n threadToolCallCount: threadCounts,\n runToolCallCount: runCounts,\n messages: artificialMessages,\n };\n },\n },\n /\n reset the run tool call count after the agent execution completes\n */\n afterAgent: () => ({\n runToolCallCount: {},\n }),\n });\n}\n"],"mappings":"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"}

package/dist/agents/middleware/toolCallLimit.d.cts CHANGED Viewed

@@ -53,21 +53,23 @@ 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.
    */
-  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 +90,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.
+ * @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.cts.map

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

	@@ -1 +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~~"}
1	+ {"version":3,"file":"toolCallLimit.d.cts","names":["z","InferInteropZodInput","ToolCallLimitExceededError","Error","ToolCallLimitOptionsSchema","ZodString","ZodOptional","ZodNumber","ZodEnum","ZodDefault","ZodTypeAny","ZodObject","ToolCallLimitConfig","toolCallLimitMiddleware","ZodRecord","Record","__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 * - \"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 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.\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;;;EAST,QAChBG,EAAAA,MAAAA;EAAU;AAxBoC;AAmC5D;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,cAtHDI,0BAsHGK,EAtHyBT,CAAAA,CAAEW,SAsH3BF,CAAAA;EAAU;;;EAGN,QAEFM,EAvHZf,CAAAA,CAAEM,WAuHUS,CAvHEf,CAAAA,CAAEK,SAuHJU,CAAAA;EAAM;;;AAPmF;eA3GlGf,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;YAKnBP,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;;;;;gBASZP,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 CHANGED Viewed

@@ -53,21 +53,23 @@ 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.
    */
-  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 +90,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.
+ * @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 CHANGED Viewed

	@@ -1 +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~~"}
1	+ {"version":3,"file":"toolCallLimit.d.ts","names":["z","InferInteropZodInput","ToolCallLimitExceededError","Error","ToolCallLimitOptionsSchema","ZodString","ZodOptional","ZodNumber","ZodEnum","ZodDefault","ZodTypeAny","ZodObject","ToolCallLimitConfig","toolCallLimitMiddleware","ZodRecord","Record","__types_js14","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 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.\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;;;EAST,QAChBG,EAAAA,MAAAA;EAAU;AAxBoC;AAmC5D;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,cAtHDI,0BAsHGK,EAtHyBT,CAAAA,CAAEW,SAsH3BF,CAAAA;EAAU;;;EAGN,QAEFM,EAvHZf,CAAAA,CAAEM,WAuHUS,CAvHEf,CAAAA,CAAEK,SAuHJU,CAAAA;EAAM;;;AAPmF;eA3GlGf,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;YAKnBP,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;;;;;gBASZP,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"}