langchain 1.0.0-alpha.6 → 1.0.0-alpha.8

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

@@ -0,0 +1,158 @@
+import { AgentMiddleware } from "../types.cjs";
+import { z } from "zod/v3";
+import { InferInteropZodInput } from "@langchain/core/utils/types";
+
+//#region src/agents/middlewareAgent/middleware/toolCallLimit.d.ts
+
+/**
+ * Exception raised when tool call limits are exceeded.
+ *
+ * This exception is raised when the configured exit behavior is 'error'
+ * and either the thread or run tool call limit has been exceeded.
+ */
+declare class ToolCallLimitExceededError extends Error {
+  /**
+   * Current thread tool call count.
+   */
+  threadCount: number;
+  /**
+   * Current run tool call count.
+   */
+  runCount: number;
+  /**
+   * Thread tool call limit (if set).
+   */
+  threadLimit: number | undefined;
+  /**
+   * Run tool call limit (if set).
+   */
+  runLimit: number | undefined;
+  /**
+   * Tool name being limited (if specific tool), or undefined for all tools.
+   */
+  toolName: string | undefined;
+  constructor(threadCount: number, runCount: number, threadLimit: number | undefined, runLimit: number | undefined, toolName?: string | undefined);
+}
+/**
+ * Options for configuring the Tool Call Limit middleware.
+ */
+declare const ToolCallLimitOptionsSchema: z.ZodObject<{
+  /**
+   * Name of the specific tool to limit. If undefined, limits apply to all tools.
+   */
+  toolName: z.ZodOptional<z.ZodString>;
+  /**
+   * Maximum number of tool calls allowed per thread.
+   * undefined means no limit.
+   */
+  threadLimit: z.ZodOptional<z.ZodNumber>;
+  /**
+   * Maximum number of tool calls allowed per run.
+   * undefined means no limit.
+   */
+  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
+   */
+  exitBehavior: z.ZodDefault<z.ZodEnum<["end", "error"]>>;
+}, "strip", z.ZodTypeAny, {
+  toolName?: string | undefined;
+  threadLimit?: number | undefined;
+  runLimit?: number | undefined;
+  exitBehavior: "end" | "error";
+}, {
+  toolName?: string | undefined;
+  threadLimit?: number | undefined;
+  runLimit?: number | undefined;
+  exitBehavior?: "end" | "error" | undefined;
+}>;
+type ToolCallLimitConfig = InferInteropZodInput<typeof ToolCallLimitOptionsSchema>;
+/**
+ * Middleware that tracks tool call counts and enforces limits.
+ *
+ * This middleware monitors the number of tool calls made during agent execution
+ * and can terminate the agent when specified limits are reached. It supports
+ * both thread-level and run-level call counting with configurable exit behaviors.
+ *
+ * Thread-level: The middleware counts all tool calls in the entire message history
+ * and persists this count across multiple runs (invocations) of the agent.
+ *
+ * Run-level: The middleware counts tool calls made after the last HumanMessage,
+ * representing the current run (invocation) of the agent.
+ *
+ * @param options - Configuration options for the middleware
+ * @param options.toolName - Name of the specific tool to limit. If undefined, limits apply to all tools.
+ * @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
+ *
+ * @throws {Error} If both limits are undefined or if exitBehavior is invalid.
+ *
+ * @example Limit all tool calls globally
+ * ```ts
+ * import { toolCallLimitMiddleware } from "@langchain/langchain/agents/middleware";
+ * import { createAgent } from "@langchain/langchain/agents";
+ *
+ * const globalLimiter = toolCallLimitMiddleware({
+ *   threadLimit: 20,
+ *   runLimit: 10,
+ *   exitBehavior: "end"
+ * });
+ *
+ * const agent = createAgent({
+ *   model: "openai:gpt-4o",
+ *   middleware: [globalLimiter]
+ * });
+ * ```
+ *
+ * @example Limit a specific tool
+ * ```ts
+ * import { toolCallLimitMiddleware } from "@langchain/langchain/agents/middleware";
+ * import { createAgent } from "@langchain/langchain/agents";
+ *
+ * const searchLimiter = toolCallLimitMiddleware({
+ *   toolName: "search",
+ *   threadLimit: 5,
+ *   runLimit: 3,
+ *   exitBehavior: "end"
+ * });
+ *
+ * const agent = createAgent({
+ *   model: "openai:gpt-4o",
+ *   middleware: [searchLimiter]
+ * });
+ * ```
+ *
+ * @example Use both in the same agent
+ * ```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({
+ *   toolName: "search",
+ *   threadLimit: 5,
+ *   runLimit: 3,
+ *   exitBehavior: "end"
+ * });
+ *
+ * const agent = createAgent({
+ *   model: "openai:gpt-4o",
+ *   middleware: [globalLimiter, searchLimiter]
+ * });
+ * ```
+ */
+declare function toolCallLimitMiddleware(options: ToolCallLimitConfig): AgentMiddleware<undefined, undefined, any>;
+//#endregion
+export { ToolCallLimitConfig, ToolCallLimitExceededError, toolCallLimitMiddleware };
+//# sourceMappingURL=toolCallLimit.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolCallLimit.d.cts","names":["z","InferInteropZodInput","ToolCallLimitExceededError","Error","ToolCallLimitOptionsSchema","ZodString","ZodOptional","ZodNumber","ZodEnum","ZodDefault","ZodTypeAny","ZodObject","ToolCallLimitConfig","toolCallLimitMiddleware","__index_js5","AgentMiddleware"],"sources":["../../../../src/agents/middlewareAgent/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(\"./index.js\").AgentMiddleware<undefined, undefined, any>;\n"],"mappings":";;;;;;;;;AAQA;AA0BA;;AAI4BA,cA9BPE,0BAAAA,SAAmCC,KAAK,CA8B/BE;EAAS;;;EAKT,WAKAE,EAAAA,MAAAA;EAAS;;;EAOT,QAChBG,EAAAA,MAAAA;EAAU;AAtBoC;AAiC5D;EAA+B,WAAA,EAAA,MAAA,GAAA,SAAA;EAAA;;AAAuB;EAmF9BG,QAAAA,EAAAA,MAAAA,GAAAA,SAAuB;EAAA;;;EAAoE,QAAA,EAAA,MAAA,GAAA,SAAA;;;;;;cApH9FT,4BAA4BJ,CAAAA,CAAEW;;;;YAIrCX,CAAAA,CAAEM,YAAYN,CAAAA,CAAEK;;;;;eAKbL,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;YAKnBP,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;;;gBAOZP,CAAAA,CAAES,WAAWT,CAAAA,CAAEQ;YACrBR,CAAAA,CAAEU;;;;;;;;;;;KAWFE,mBAAAA,GAAsBX,4BAA4BG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmFtCS,uBAAAA,UAAiCD,sBAAmB"}

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

@@ -0,0 +1,158 @@
+import { AgentMiddleware } from "../types.js";
+import { InferInteropZodInput } from "@langchain/core/utils/types";
+import { z } from "zod/v3";
+
+//#region src/agents/middlewareAgent/middleware/toolCallLimit.d.ts
+
+/**
+ * Exception raised when tool call limits are exceeded.
+ *
+ * This exception is raised when the configured exit behavior is 'error'
+ * and either the thread or run tool call limit has been exceeded.
+ */
+declare class ToolCallLimitExceededError extends Error {
+  /**
+   * Current thread tool call count.
+   */
+  threadCount: number;
+  /**
+   * Current run tool call count.
+   */
+  runCount: number;
+  /**
+   * Thread tool call limit (if set).
+   */
+  threadLimit: number | undefined;
+  /**
+   * Run tool call limit (if set).
+   */
+  runLimit: number | undefined;
+  /**
+   * Tool name being limited (if specific tool), or undefined for all tools.
+   */
+  toolName: string | undefined;
+  constructor(threadCount: number, runCount: number, threadLimit: number | undefined, runLimit: number | undefined, toolName?: string | undefined);
+}
+/**
+ * Options for configuring the Tool Call Limit middleware.
+ */
+declare const ToolCallLimitOptionsSchema: z.ZodObject<{
+  /**
+   * Name of the specific tool to limit. If undefined, limits apply to all tools.
+   */
+  toolName: z.ZodOptional<z.ZodString>;
+  /**
+   * Maximum number of tool calls allowed per thread.
+   * undefined means no limit.
+   */
+  threadLimit: z.ZodOptional<z.ZodNumber>;
+  /**
+   * Maximum number of tool calls allowed per run.
+   * undefined means no limit.
+   */
+  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
+   */
+  exitBehavior: z.ZodDefault<z.ZodEnum<["end", "error"]>>;
+}, "strip", z.ZodTypeAny, {
+  toolName?: string | undefined;
+  threadLimit?: number | undefined;
+  runLimit?: number | undefined;
+  exitBehavior: "end" | "error";
+}, {
+  toolName?: string | undefined;
+  threadLimit?: number | undefined;
+  runLimit?: number | undefined;
+  exitBehavior?: "end" | "error" | undefined;
+}>;
+type ToolCallLimitConfig = InferInteropZodInput<typeof ToolCallLimitOptionsSchema>;
+/**
+ * Middleware that tracks tool call counts and enforces limits.
+ *
+ * This middleware monitors the number of tool calls made during agent execution
+ * and can terminate the agent when specified limits are reached. It supports
+ * both thread-level and run-level call counting with configurable exit behaviors.
+ *
+ * Thread-level: The middleware counts all tool calls in the entire message history
+ * and persists this count across multiple runs (invocations) of the agent.
+ *
+ * Run-level: The middleware counts tool calls made after the last HumanMessage,
+ * representing the current run (invocation) of the agent.
+ *
+ * @param options - Configuration options for the middleware
+ * @param options.toolName - Name of the specific tool to limit. If undefined, limits apply to all tools.
+ * @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
+ *
+ * @throws {Error} If both limits are undefined or if exitBehavior is invalid.
+ *
+ * @example Limit all tool calls globally
+ * ```ts
+ * import { toolCallLimitMiddleware } from "@langchain/langchain/agents/middleware";
+ * import { createAgent } from "@langchain/langchain/agents";
+ *
+ * const globalLimiter = toolCallLimitMiddleware({
+ *   threadLimit: 20,
+ *   runLimit: 10,
+ *   exitBehavior: "end"
+ * });
+ *
+ * const agent = createAgent({
+ *   model: "openai:gpt-4o",
+ *   middleware: [globalLimiter]
+ * });
+ * ```
+ *
+ * @example Limit a specific tool
+ * ```ts
+ * import { toolCallLimitMiddleware } from "@langchain/langchain/agents/middleware";
+ * import { createAgent } from "@langchain/langchain/agents";
+ *
+ * const searchLimiter = toolCallLimitMiddleware({
+ *   toolName: "search",
+ *   threadLimit: 5,
+ *   runLimit: 3,
+ *   exitBehavior: "end"
+ * });
+ *
+ * const agent = createAgent({
+ *   model: "openai:gpt-4o",
+ *   middleware: [searchLimiter]
+ * });
+ * ```
+ *
+ * @example Use both in the same agent
+ * ```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({
+ *   toolName: "search",
+ *   threadLimit: 5,
+ *   runLimit: 3,
+ *   exitBehavior: "end"
+ * });
+ *
+ * const agent = createAgent({
+ *   model: "openai:gpt-4o",
+ *   middleware: [globalLimiter, searchLimiter]
+ * });
+ * ```
+ */
+declare function toolCallLimitMiddleware(options: ToolCallLimitConfig): AgentMiddleware<undefined, undefined, any>;
+//#endregion
+export { ToolCallLimitConfig, ToolCallLimitExceededError, toolCallLimitMiddleware };
+//# sourceMappingURL=toolCallLimit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolCallLimit.d.ts","names":["z","InferInteropZodInput","ToolCallLimitExceededError","Error","ToolCallLimitOptionsSchema","ZodString","ZodOptional","ZodNumber","ZodEnum","ZodDefault","ZodTypeAny","ZodObject","ToolCallLimitConfig","toolCallLimitMiddleware","__index_js4","AgentMiddleware"],"sources":["../../../../src/agents/middlewareAgent/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(\"./index.js\").AgentMiddleware<undefined, undefined, any>;\n"],"mappings":";;;;;;;;;AAQA;AA0BA;;AAI4BA,cA9BPE,0BAAAA,SAAmCC,KAAK,CA8B/BE;EAAS;;;EAKT,WAKAE,EAAAA,MAAAA;EAAS;;;EAOT,QAChBG,EAAAA,MAAAA;EAAU;AAtBoC;AAiC5D;EAA+B,WAAA,EAAA,MAAA,GAAA,SAAA;EAAA;;AAAuB;EAmF9BG,QAAAA,EAAAA,MAAAA,GAAAA,SAAuB;EAAA;;;EAAoE,QAAA,EAAA,MAAA,GAAA,SAAA;;;;;;cApH9FT,4BAA4BJ,CAAAA,CAAEW;;;;YAIrCX,CAAAA,CAAEM,YAAYN,CAAAA,CAAEK;;;;;eAKbL,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;YAKnBP,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;;;gBAOZP,CAAAA,CAAES,WAAWT,CAAAA,CAAEQ;YACrBR,CAAAA,CAAEU;;;;;;;;;;;KAWFE,mBAAAA,GAAsBX,4BAA4BG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmFtCS,uBAAAA,UAAiCD,sBAAmB"}

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

@@ -0,0 +1,240 @@
+import { createMiddleware } from "../middleware.js";
+import { AIMessage, HumanMessage } from "@langchain/core/messages";
+import { z } from "zod/v3";
+
+//#region src/agents/middlewareAgent/middleware/toolCallLimit.ts
+/**
+* Count tool calls in a list of messages.
+*
+* @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).
+*
+* @param messages - Full list of messages.
+* @returns Messages from the current run (after last HumanMessage).
+*/
+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);
+}
+/**
+* Build a message indicating which tool call limits were reached.
+*
+* @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.
+*/
+function buildToolLimitExceededMessage(threadCount, runCount, threadLimit, runLimit, toolName) {
+	const toolDesc = toolName ? `'${toolName}' tool call` : "Tool call";
+	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.`;
+}
+/**
+* Exception raised when tool call limits are exceeded.
+*
+* This exception is raised when the configured exit behavior is 'error'
+* and either the thread or run tool call limit has been exceeded.
+*/
+var ToolCallLimitExceededError = class extends Error {
+	/**
+	* Current thread tool call count.
+	*/
+	threadCount;
+	/**
+	* Current run tool call count.
+	*/
+	runCount;
+	/**
+	* Thread tool call limit (if set).
+	*/
+	threadLimit;
+	/**
+	* Run tool call limit (if set).
+	*/
+	runLimit;
+	/**
+	* Tool name being limited (if specific tool), or undefined for all tools.
+	*/
+	toolName;
+	constructor(threadCount, runCount, threadLimit, runLimit, toolName = void 0) {
+		const message = buildToolLimitExceededMessage(threadCount, runCount, threadLimit, runLimit, toolName);
+		super(message);
+		this.name = "ToolCallLimitExceededError";
+		this.threadCount = threadCount;
+		this.runCount = runCount;
+		this.threadLimit = threadLimit;
+		this.runLimit = runLimit;
+		this.toolName = toolName;
+	}
+};
+/**
+* Options for configuring the Tool Call Limit middleware.
+*/
+const ToolCallLimitOptionsSchema = z.object({
+	toolName: z.string().optional(),
+	threadLimit: z.number().optional(),
+	runLimit: z.number().optional(),
+	exitBehavior: z.enum(["end", "error"]).default("end")
+});
+/**
+* Middleware that tracks tool call counts and enforces limits.
+*
+* This middleware monitors the number of tool calls made during agent execution
+* and can terminate the agent when specified limits are reached. It supports
+* both thread-level and run-level call counting with configurable exit behaviors.
+*
+* Thread-level: The middleware counts all tool calls in the entire message history
+* and persists this count across multiple runs (invocations) of the agent.
+*
+* Run-level: The middleware counts tool calls made after the last HumanMessage,
+* representing the current run (invocation) of the agent.
+*
+* @param options - Configuration options for the middleware
+* @param options.toolName - Name of the specific tool to limit. If undefined, limits apply to all tools.
+* @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
+*
+* @throws {Error} If both limits are undefined or if exitBehavior is invalid.
+*
+* @example Limit all tool calls globally
+* ```ts
+* import { toolCallLimitMiddleware } from "@langchain/langchain/agents/middleware";
+* import { createAgent } from "@langchain/langchain/agents";
+*
+* const globalLimiter = toolCallLimitMiddleware({
+*   threadLimit: 20,
+*   runLimit: 10,
+*   exitBehavior: "end"
+* });
+*
+* const agent = createAgent({
+*   model: "openai:gpt-4o",
+*   middleware: [globalLimiter]
+* });
+* ```
+*
+* @example Limit a specific tool
+* ```ts
+* import { toolCallLimitMiddleware } from "@langchain/langchain/agents/middleware";
+* import { createAgent } from "@langchain/langchain/agents";
+*
+* const searchLimiter = toolCallLimitMiddleware({
+*   toolName: "search",
+*   threadLimit: 5,
+*   runLimit: 3,
+*   exitBehavior: "end"
+* });
+*
+* const agent = createAgent({
+*   model: "openai:gpt-4o",
+*   middleware: [searchLimiter]
+* });
+* ```
+*
+* @example Use both in the same agent
+* ```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({
+*   toolName: "search",
+*   threadLimit: 5,
+*   runLimit: 3,
+*   exitBehavior: "end"
+* });
+*
+* const agent = createAgent({
+*   model: "openai:gpt-4o",
+*   middleware: [globalLimiter, searchLimiter]
+* });
+* ```
+*/
+function toolCallLimitMiddleware(options) {
+	/**
+	* Validate that at least one limit is specified
+	*/
+	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
+	*/
+	const exitBehavior = options.exitBehavior ?? "end";
+	if (exitBehavior !== "end" && exitBehavior !== "error") throw new Error(`Invalid exit behavior: ${exitBehavior}. Must be 'end' or 'error'`);
+	/**
+	* Generate the middleware name based on the tool name
+	*/
+	const middlewareName = options.toolName ? `ToolCallLimitMiddleware[${options.toolName}]` : "ToolCallLimitMiddleware";
+	return createMiddleware({
+		name: middlewareName,
+		beforeModelJumpTo: ["end"],
+		async beforeModel(state) {
+			const messages = state.messages;
+			/**
+			* Count tool calls in entire thread
+			*/
+			const threadCount = countToolCallsInMessages(messages, options.toolName);
+			/**
+			* Count tool calls in current run (after last HumanMessage)
+			*/
+			const runMessages = getRunMessages(messages);
+			const runCount = countToolCallsInMessages(runMessages, options.toolName);
+			/**
+			* Check if any limits are exceeded
+			*/
+			const threadLimitExceeded = options.threadLimit !== void 0 && threadCount >= options.threadLimit;
+			const runLimitExceeded = options.runLimit !== void 0 && runCount >= options.runLimit;
+			if (!threadLimitExceeded && !runLimitExceeded) return void 0;
+			if (exitBehavior === "error") throw new ToolCallLimitExceededError(threadCount, runCount, options.threadLimit, options.runLimit, options.toolName);
+			/**
+			* Create a message indicating the limit was exceeded
+			*/
+			const limitMessage = buildToolLimitExceededMessage(threadCount, runCount, options.threadLimit, options.runLimit, options.toolName);
+			const limitAiMessage = new AIMessage(limitMessage);
+			return {
+				jumpTo: "end",
+				messages: [limitAiMessage]
+			};
+		}
+	});
+}
+
+//#endregion
+export { ToolCallLimitExceededError, toolCallLimitMiddleware };
+//# sourceMappingURL=toolCallLimit.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolCallLimit.js","names":["messages: BaseMessage[]","toolName?: string","threadCount: number","runCount: number","threadLimit: number | undefined","runLimit: number | undefined","toolName: string | undefined","exceededLimits: string[]","options: ToolCallLimitConfig","state: AgentBuiltInState"],"sources":["../../../../src/agents/middlewareAgent/middleware/toolCallLimit.ts"],"sourcesContent":["/**\n * Tool call limit middleware for agents.\n */\n\nimport { AIMessage, BaseMessage, HumanMessage } from \"@langchain/core/messages\";\nimport { z } from \"zod/v3\";\nimport type { InferInteropZodInput } from \"@langchain/core/utils/types\";\n\nimport { createMiddleware } from \"../middleware.js\";\nimport type { AgentBuiltInState } from \"../types.js\";\n\n/**\n * Count tool calls in a list of messages.\n *\n * @param messages - List of messages to count tool calls in.\n * @param toolName - If specified, only count calls to this specific tool.\n *   If undefined, count all tool calls.\n * @returns The total number of tool calls (optionally filtered by toolName).\n */\nfunction countToolCallsInMessages(\n  messages: BaseMessage[],\n  toolName?: string\n): number {\n  let count = 0;\n  for (const message of messages) {\n    if (AIMessage.isInstance(message) && message.tool_calls) {\n      if (toolName === undefined) {\n        // Count all tool calls\n        count += message.tool_calls.length;\n      } else {\n        // Count only calls to the specified tool\n        count += message.tool_calls.filter((tc) => tc.name === toolName).length;\n      }\n    }\n  }\n  return count;\n}\n\n/**\n * Get messages from the current run (after the last HumanMessage).\n *\n * @param messages - Full list of messages.\n * @returns Messages from the current run (after last HumanMessage).\n */\nfunction getRunMessages(messages: BaseMessage[]): BaseMessage[] {\n  /**\n   * Find the last HumanMessage\n   */\n  let lastHumanIndex = -1;\n  for (let i = messages.length - 1; i >= 0; i--) {\n    if (HumanMessage.isInstance(messages[i])) {\n      lastHumanIndex = i;\n      break;\n    }\n  }\n\n  /**\n   * If no HumanMessage found, return all messages\n   */\n  if (lastHumanIndex === -1) {\n    return messages;\n  }\n\n  /**\n   * Return messages after the last HumanMessage\n   */\n  return messages.slice(lastHumanIndex + 1);\n}\n\n/**\n * Build a message indicating which tool call limits were reached.\n *\n * @param threadCount - Current thread tool call count.\n * @param runCount - Current run tool call count.\n * @param threadLimit - Thread tool call limit (if set).\n * @param runLimit - Run tool call limit (if set).\n * @param toolName - Tool name being limited (if specific tool), or undefined for all tools.\n * @returns A formatted message describing which limits were reached.\n */\nfunction buildToolLimitExceededMessage(\n  threadCount: number,\n  runCount: number,\n  threadLimit: number | undefined,\n  runLimit: number | undefined,\n  toolName: string | undefined\n): string {\n  const toolDesc = toolName ? `'${toolName}' tool call` : \"Tool call\";\n  const exceededLimits: string[] = [];\n\n  if (threadLimit !== undefined && threadCount >= threadLimit) {\n    exceededLimits.push(`thread limit reached (${threadCount}/${threadLimit})`);\n  }\n  if (runLimit !== undefined && runCount >= runLimit) {\n    exceededLimits.push(`run limit reached (${runCount}/${runLimit})`);\n  }\n\n  return `${toolDesc} limit${\n    exceededLimits.length > 1 ? \"s\" : \"\"\n  }: ${exceededLimits.join(\", \")}. Stopping to prevent further tool calls.`;\n}\n\n/**\n * Exception raised when tool call limits are exceeded.\n *\n * This exception is raised when the configured exit behavior is 'error'\n * and either the thread or run tool call limit has been exceeded.\n */\nexport class ToolCallLimitExceededError extends Error {\n  /**\n   * Current thread tool call count.\n   */\n  threadCount: number;\n  /**\n   * Current run tool call count.\n   */\n  runCount: number;\n  /**\n   * Thread tool call limit (if set).\n   */\n  threadLimit: number | undefined;\n  /**\n   * Run tool call limit (if set).\n   */\n  runLimit: number | undefined;\n  /**\n   * Tool name being limited (if specific tool), or undefined for all tools.\n   */\n  toolName: string | undefined;\n\n  constructor(\n    threadCount: number,\n    runCount: number,\n    threadLimit: number | undefined,\n    runLimit: number | undefined,\n    toolName: string | undefined = undefined\n  ) {\n    const message = buildToolLimitExceededMessage(\n      threadCount,\n      runCount,\n      threadLimit,\n      runLimit,\n      toolName\n    );\n    super(message);\n\n    this.name = \"ToolCallLimitExceededError\";\n    this.threadCount = threadCount;\n    this.runCount = runCount;\n    this.threadLimit = threadLimit;\n    this.runLimit = runLimit;\n    this.toolName = toolName;\n  }\n}\n\n/**\n * Options for configuring the Tool Call Limit middleware.\n */\nexport const ToolCallLimitOptionsSchema = z.object({\n  /**\n   * Name of the specific tool to limit. If undefined, limits apply to all tools.\n   */\n  toolName: z.string().optional(),\n  /**\n   * Maximum number of tool calls allowed per thread.\n   * undefined means no limit.\n   */\n  threadLimit: z.number().optional(),\n  /**\n   * Maximum number of tool calls allowed per run.\n   * undefined means no limit.\n   */\n  runLimit: z.number().optional(),\n  /**\n   * What to do when limits are exceeded.\n   * - \"end\": Jump to the end of the agent execution and inject an artificial\n   *   AI message indicating that the limit was exceeded.\n   * - \"error\": throws a ToolCallLimitExceededError\n   */\n  exitBehavior: z.enum([\"end\", \"error\"]).default(\"end\"),\n});\n\nexport type ToolCallLimitConfig = InferInteropZodInput<\n  typeof ToolCallLimitOptionsSchema\n>;\n\n/**\n * Middleware that tracks tool call counts and enforces limits.\n *\n * This middleware monitors the number of tool calls made during agent execution\n * and can terminate the agent when specified limits are reached. It supports\n * both thread-level and run-level call counting with configurable exit behaviors.\n *\n * Thread-level: The middleware counts all tool calls in the entire message history\n * and persists this count across multiple runs (invocations) of the agent.\n *\n * Run-level: The middleware counts tool calls made after the last HumanMessage,\n * representing the current run (invocation) of the agent.\n *\n * @param options - Configuration options for the middleware\n * @param options.toolName - Name of the specific tool to limit. If undefined, limits apply to all tools.\n * @param options.threadLimit - Maximum number of tool calls allowed per thread. undefined means no limit.\n * @param options.runLimit - Maximum number of tool calls allowed per run. undefined means no limit.\n * @param options.exitBehavior - What to do when limits are exceeded.\n *   - \"end\": Jump to the end of the agent execution and inject an artificial AI message indicating that the limit was exceeded.\n *   - \"error\": throws a ToolCallLimitExceededError\n *\n * @throws {Error} If both limits are undefined or if exitBehavior is invalid.\n *\n * @example Limit all tool calls globally\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * const globalLimiter = toolCallLimitMiddleware({\n *   threadLimit: 20,\n *   runLimit: 10,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [globalLimiter]\n * });\n * ```\n *\n * @example Limit a specific tool\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * const searchLimiter = toolCallLimitMiddleware({\n *   toolName: \"search\",\n *   threadLimit: 5,\n *   runLimit: 3,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [searchLimiter]\n * });\n * ```\n *\n * @example Use both in the same agent\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * const globalLimiter = toolCallLimitMiddleware({\n *   threadLimit: 20,\n *   runLimit: 10,\n *   exitBehavior: \"end\"\n * });\n *\n * const searchLimiter = toolCallLimitMiddleware({\n *   toolName: \"search\",\n *   threadLimit: 5,\n *   runLimit: 3,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [globalLimiter, searchLimiter]\n * });\n * ```\n */\nexport function toolCallLimitMiddleware(options: ToolCallLimitConfig) {\n  /**\n   * Validate that at least one limit is specified\n   */\n  if (options.threadLimit === undefined && options.runLimit === undefined) {\n    throw new Error(\n      \"At least one limit must be specified (threadLimit or runLimit)\"\n    );\n  }\n\n  /**\n   * Apply default for exitBehavior and validate\n   */\n  const exitBehavior = options.exitBehavior ?? \"end\";\n  if (exitBehavior !== \"end\" && exitBehavior !== \"error\") {\n    throw new Error(\n      `Invalid exit behavior: ${exitBehavior}. Must be 'end' or 'error'`\n    );\n  }\n\n  /**\n   * Generate the middleware name based on the tool name\n   */\n  const middlewareName = options.toolName\n    ? `ToolCallLimitMiddleware[${options.toolName}]`\n    : \"ToolCallLimitMiddleware\";\n\n  return createMiddleware({\n    name: middlewareName,\n    beforeModelJumpTo: [\"end\"],\n    async beforeModel(state: AgentBuiltInState) {\n      const messages = state.messages;\n\n      /**\n       * Count tool calls in entire thread\n       */\n      const threadCount = countToolCallsInMessages(messages, options.toolName);\n\n      /**\n       * Count tool calls in current run (after last HumanMessage)\n       */\n      const runMessages = getRunMessages(messages);\n      const runCount = countToolCallsInMessages(runMessages, options.toolName);\n\n      /**\n       * Check if any limits are exceeded\n       */\n      const threadLimitExceeded =\n        options.threadLimit !== undefined && threadCount >= options.threadLimit;\n      const runLimitExceeded =\n        options.runLimit !== undefined && runCount >= options.runLimit;\n\n      if (!threadLimitExceeded && !runLimitExceeded) {\n        return undefined;\n      }\n\n      if (exitBehavior === \"error\") {\n        throw new ToolCallLimitExceededError(\n          threadCount,\n          runCount,\n          options.threadLimit,\n          options.runLimit,\n          options.toolName\n        );\n      }\n\n      /**\n       * Create a message indicating the limit was exceeded\n       */\n      const limitMessage = buildToolLimitExceededMessage(\n        threadCount,\n        runCount,\n        options.threadLimit,\n        options.runLimit,\n        options.toolName\n      );\n      const limitAiMessage = new AIMessage(limitMessage);\n\n      return {\n        jumpTo: \"end\",\n        messages: [limitAiMessage],\n      };\n    },\n  });\n}\n"],"mappings":"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"}

package/dist/agents/middlewareAgent/middleware/utils.cjs

@@ -0,0 +1,26 @@
+
+//#region src/agents/middlewareAgent/middleware/utils.ts
+/**
+* Default token counter that approximates based on character count
+* @param messages Messages to count tokens for
+* @returns Approximate token count
+*/
+function countTokensApproximately(messages) {
+	let totalChars = 0;
+	for (const msg of messages) {
+		let textContent;
+		if (typeof msg.content === "string") textContent = msg.content;
+		else if (Array.isArray(msg.content)) textContent = msg.content.map((item) => {
+			if (typeof item === "string") return item;
+			if (item.type === "text" && "text" in item) return item.text;
+			return "";
+		}).join("");
+		else textContent = "";
+		totalChars += textContent.length;
+	}
+	return Math.ceil(totalChars / 4);
+}
+
+//#endregion
+exports.countTokensApproximately = countTokensApproximately;
+//# sourceMappingURL=utils.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.cjs","names":["messages: BaseMessage[]","textContent: string"],"sources":["../../../../src/agents/middlewareAgent/middleware/utils.ts"],"sourcesContent":["import type { BaseMessage } from \"@langchain/core/messages\";\n\n/**\n * Default token counter that approximates based on character count\n * @param messages Messages to count tokens for\n * @returns Approximate token count\n */\nexport function countTokensApproximately(messages: BaseMessage[]): number {\n  let totalChars = 0;\n  for (const msg of messages) {\n    let textContent: string;\n    if (typeof msg.content === \"string\") {\n      textContent = msg.content;\n    } else if (Array.isArray(msg.content)) {\n      textContent = msg.content\n        .map((item) => {\n          if (typeof item === \"string\") return item;\n          if (item.type === \"text\" && \"text\" in item) return item.text;\n          return \"\";\n        })\n        .join(\"\");\n    } else {\n      textContent = \"\";\n    }\n    totalChars += textContent.length;\n  }\n  // Approximate 1 token = 4 characters\n  return Math.ceil(totalChars / 4);\n}\n"],"mappings":";;;;;;;AAOA,SAAgB,yBAAyBA,UAAiC;CACxE,IAAI,aAAa;AACjB,MAAK,MAAM,OAAO,UAAU;EAC1B,IAAIC;AACJ,MAAI,OAAO,IAAI,YAAY,UACzB,cAAc,IAAI;WACT,MAAM,QAAQ,IAAI,QAAQ,EACnC,cAAc,IAAI,QACf,IAAI,CAAC,SAAS;AACb,OAAI,OAAO,SAAS,SAAU,QAAO;AACrC,OAAI,KAAK,SAAS,UAAU,UAAU,KAAM,QAAO,KAAK;AACxD,UAAO;EACR,EAAC,CACD,KAAK,GAAG;OAEX,cAAc;EAEhB,cAAc,YAAY;CAC3B;AAED,QAAO,KAAK,KAAK,aAAa,EAAE;AACjC"}

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

@@ -0,0 +1,13 @@
+import { BaseMessage } from "@langchain/core/messages";
+
+//#region src/agents/middlewareAgent/middleware/utils.d.ts
+
+/**
+ * Default token counter that approximates based on character count
+ * @param messages Messages to count tokens for
+ * @returns Approximate token count
+ */
+declare function countTokensApproximately(messages: BaseMessage[]): number;
+//#endregion
+export { countTokensApproximately };
+//# sourceMappingURL=utils.d.cts.map