langchain 1.0.0-alpha.7 → 1.0.0-alpha.9

package/dist/agents/middleware/callLimit.cjs

@@ -0,0 +1,128 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_middleware = require('../middleware.cjs');
+const __langchain_core_messages = require_rolldown_runtime.__toESM(require("@langchain/core/messages"));
+const zod_v3 = require_rolldown_runtime.__toESM(require("zod/v3"));
+
+//#region src/agents/middleware/callLimit.ts
+const DEFAULT_EXIT_BEHAVIOR = "end";
+const contextSchema = zod_v3.z.object({
+	threadLimit: zod_v3.z.number().optional(),
+	runLimit: zod_v3.z.number().optional(),
+	exitBehavior: zod_v3.z.enum(["throw", "end"]).optional()
+});
+/**
+* Error thrown when the model call limit is exceeded.
+*
+* @param threadLimit - The maximum number of model calls allowed per thread.
+* @param runLimit - The maximum number of model calls allowed per run.
+* @param threadCount - The number of model calls made at the thread level.
+* @param runCount - The number of model calls made at the run level.
+*/
+var ModelCallLimitMiddlewareError = class extends Error {
+	constructor({ threadLimit, runLimit, threadCount, runCount }) {
+		const exceededHint = [];
+		if (typeof threadLimit === "number" && typeof threadCount === "number") exceededHint.push(`thread level call limit reached with ${threadCount} model calls`);
+		if (typeof runLimit === "number" && typeof runCount === "number") exceededHint.push(`run level call limit reached with ${runCount} model calls`);
+		super(`Model call limits exceeded${exceededHint.length > 0 ? `: ${exceededHint.join(", ")}` : ""}`);
+		this.name = "ModelCallLimitMiddlewareError";
+	}
+};
+/**
+* Creates a middleware to limit the number of model calls at both thread and run levels.
+*
+* This middleware helps prevent excessive model API calls by enforcing limits on how many
+* times the model can be invoked. It supports two types of limits:
+*
+* - **Thread-level limit**: Restricts the total number of model calls across an entire conversation thread
+* - **Run-level limit**: Restricts the number of model calls within a single agent run/invocation
+*
+* ## How It Works
+*
+* The middleware intercepts model requests before they are sent and checks the current call counts
+* against the configured limits. If either limit is exceeded, it throws a `ModelCallLimitMiddlewareError`
+* to stop execution and prevent further API calls.
+*
+* ## Use Cases
+*
+* - **Cost Control**: Prevent runaway costs from excessive model calls in production
+* - **Testing**: Ensure agents don't make too many calls during development/testing
+* - **Safety**: Limit potential infinite loops or recursive agent behaviors
+* - **Rate Limiting**: Enforce organizational policies on model usage per conversation
+*
+* @param middlewareOptions - Configuration options for the call limits
+* @param middlewareOptions.threadLimit - Maximum number of model calls allowed per thread (optional)
+* @param middlewareOptions.runLimit - Maximum number of model calls allowed per run (optional)
+*
+* @returns A middleware instance that can be passed to `createAgent`
+*
+* @throws {ModelCallLimitMiddlewareError} When either the thread or run limit is exceeded
+*
+* @example
+* ```typescript
+* import { createAgent, modelCallLimitMiddleware } from "langchain";
+*
+* // Limit to 10 calls per thread and 3 calls per run
+* const agent = createAgent({
+*   model: "openai:gpt-4o-mini",
+*   tools: [myTool],
+*   middleware: [
+*     modelCallLimitMiddleware({
+*       threadLimit: 10,
+*       runLimit: 3
+*     })
+*   ]
+* });
+* ```
+*
+* @example
+* ```typescript
+* // Limits can also be configured at runtime via context
+* const result = await agent.invoke(
+*   { messages: ["Hello"] },
+*   {
+*     configurable: {
+*       threadLimit: 5  // Override the default limit for this run
+*     }
+*   }
+* );
+* ```
+*/
+function modelCallLimitMiddleware(middlewareOptions) {
+	return require_middleware.createMiddleware({
+		name: "ModelCallLimitMiddleware",
+		contextSchema,
+		beforeModelJumpTo: ["end"],
+		beforeModel: (state, runtime) => {
+			const exitBehavior = runtime.context.exitBehavior ?? middlewareOptions?.exitBehavior ?? DEFAULT_EXIT_BEHAVIOR;
+			const threadLimit = runtime.context.threadLimit ?? middlewareOptions?.threadLimit;
+			const runLimit = runtime.context.runLimit ?? middlewareOptions?.runLimit;
+			if (typeof threadLimit === "number" && threadLimit <= runtime.threadLevelCallCount) {
+				const error = new ModelCallLimitMiddlewareError({
+					threadLimit,
+					threadCount: runtime.threadLevelCallCount
+				});
+				if (exitBehavior === "end") return {
+					jumpTo: "end",
+					messages: [new __langchain_core_messages.AIMessage(error.message)]
+				};
+				throw error;
+			}
+			if (typeof runLimit === "number" && runLimit <= runtime.runModelCallCount) {
+				const error = new ModelCallLimitMiddlewareError({
+					runLimit,
+					runCount: runtime.runModelCallCount
+				});
+				if (exitBehavior === "end") return {
+					jumpTo: "end",
+					messages: [new __langchain_core_messages.AIMessage(error.message)]
+				};
+				throw error;
+			}
+			return state;
+		}
+	});
+}
+
+//#endregion
+exports.modelCallLimitMiddleware = modelCallLimitMiddleware;
+//# sourceMappingURL=callLimit.cjs.map

package/dist/agents/middleware/callLimit.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"callLimit.cjs","names":["z","exceededHint: string[]","middlewareOptions?: ModelCallLimitMiddlewareConfig","createMiddleware","AIMessage"],"sources":["../../../src/agents/middleware/callLimit.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { AIMessage } from \"@langchain/core/messages\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\n\nimport { createMiddleware } from \"../middleware.js\";\n\nconst DEFAULT_EXIT_BEHAVIOR = \"end\";\n\nconst contextSchema = z.object({\n  /**\n   * The maximum number of model calls allowed per thread.\n   */\n  threadLimit: z.number().optional(),\n  /**\n   * The maximum number of model calls allowed per run.\n   */\n  runLimit: z.number().optional(),\n  /**\n   * The behavior to take when the limit is exceeded.\n   * - \"throw\" will throw an error and stop the agent.\n   * - \"end\" will end the agent.\n   * @default \"end\"\n   */\n  exitBehavior: z.enum([\"throw\", \"end\"]).optional(),\n});\nexport type ModelCallLimitMiddlewareConfig = Partial<\n  InferInteropZodInput<typeof contextSchema>\n>;\n\n/**\n * Error thrown when the model call limit is exceeded.\n *\n * @param threadLimit - The maximum number of model calls allowed per thread.\n * @param runLimit - The maximum number of model calls allowed per run.\n * @param threadCount - The number of model calls made at the thread level.\n * @param runCount - The number of model calls made at the run level.\n */\nclass ModelCallLimitMiddlewareError extends Error {\n  constructor({\n    threadLimit,\n    runLimit,\n    threadCount,\n    runCount,\n  }: {\n    threadLimit?: number;\n    runLimit?: number;\n    threadCount?: number;\n    runCount?: number;\n  }) {\n    const exceededHint: string[] = [];\n    if (typeof threadLimit === \"number\" && typeof threadCount === \"number\") {\n      exceededHint.push(\n        `thread level call limit reached with ${threadCount} model calls`\n      );\n    }\n    if (typeof runLimit === \"number\" && typeof runCount === \"number\") {\n      exceededHint.push(\n        `run level call limit reached with ${runCount} model calls`\n      );\n    }\n    super(\n      `Model call limits exceeded${\n        exceededHint.length > 0 ? `: ${exceededHint.join(\", \")}` : \"\"\n      }`\n    );\n    this.name = \"ModelCallLimitMiddlewareError\";\n  }\n}\n\n/**\n * Creates a middleware to limit the number of model calls at both thread and run levels.\n *\n * This middleware helps prevent excessive model API calls by enforcing limits on how many\n * times the model can be invoked. It supports two types of limits:\n *\n * - **Thread-level limit**: Restricts the total number of model calls across an entire conversation thread\n * - **Run-level limit**: Restricts the number of model calls within a single agent run/invocation\n *\n * ## How It Works\n *\n * The middleware intercepts model requests before they are sent and checks the current call counts\n * against the configured limits. If either limit is exceeded, it throws a `ModelCallLimitMiddlewareError`\n * to stop execution and prevent further API calls.\n *\n * ## Use Cases\n *\n * - **Cost Control**: Prevent runaway costs from excessive model calls in production\n * - **Testing**: Ensure agents don't make too many calls during development/testing\n * - **Safety**: Limit potential infinite loops or recursive agent behaviors\n * - **Rate Limiting**: Enforce organizational policies on model usage per conversation\n *\n * @param middlewareOptions - Configuration options for the call limits\n * @param middlewareOptions.threadLimit - Maximum number of model calls allowed per thread (optional)\n * @param middlewareOptions.runLimit - Maximum number of model calls allowed per run (optional)\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @throws {ModelCallLimitMiddlewareError} When either the thread or run limit is exceeded\n *\n * @example\n * ```typescript\n * import { createAgent, modelCallLimitMiddleware } from \"langchain\";\n *\n * // Limit to 10 calls per thread and 3 calls per run\n * const agent = createAgent({\n *   model: \"openai:gpt-4o-mini\",\n *   tools: [myTool],\n *   middleware: [\n *     modelCallLimitMiddleware({\n *       threadLimit: 10,\n *       runLimit: 3\n *     })\n *   ]\n * });\n * ```\n *\n * @example\n * ```typescript\n * // Limits can also be configured at runtime via context\n * const result = await agent.invoke(\n *   { messages: [\"Hello\"] },\n *   {\n *     configurable: {\n *       threadLimit: 5  // Override the default limit for this run\n *     }\n *   }\n * );\n * ```\n */\nexport function modelCallLimitMiddleware(\n  middlewareOptions?: ModelCallLimitMiddlewareConfig\n) {\n  return createMiddleware({\n    name: \"ModelCallLimitMiddleware\",\n    contextSchema,\n    beforeModelJumpTo: [\"end\"],\n    beforeModel: (state, runtime) => {\n      const exitBehavior =\n        runtime.context.exitBehavior ??\n        middlewareOptions?.exitBehavior ??\n        DEFAULT_EXIT_BEHAVIOR;\n      const threadLimit =\n        runtime.context.threadLimit ?? middlewareOptions?.threadLimit;\n      const runLimit = runtime.context.runLimit ?? middlewareOptions?.runLimit;\n\n      if (\n        typeof threadLimit === \"number\" &&\n        threadLimit <= runtime.threadLevelCallCount\n      ) {\n        const error = new ModelCallLimitMiddlewareError({\n          threadLimit,\n          threadCount: runtime.threadLevelCallCount,\n        });\n        if (exitBehavior === \"end\") {\n          return {\n            jumpTo: \"end\",\n            messages: [new AIMessage(error.message)],\n          };\n        }\n\n        throw error;\n      }\n      if (\n        typeof runLimit === \"number\" &&\n        runLimit <= runtime.runModelCallCount\n      ) {\n        const error = new ModelCallLimitMiddlewareError({\n          runLimit,\n          runCount: runtime.runModelCallCount,\n        });\n        if (exitBehavior === \"end\") {\n          return {\n            jumpTo: \"end\",\n            messages: [new AIMessage(error.message)],\n          };\n        }\n\n        throw error;\n      }\n\n      return state;\n    },\n  });\n}\n"],"mappings":";;;;;;AAMA,MAAM,wBAAwB;AAE9B,MAAM,gBAAgBA,SAAE,OAAO;CAI7B,aAAaA,SAAE,QAAQ,CAAC,UAAU;CAIlC,UAAUA,SAAE,QAAQ,CAAC,UAAU;CAO/B,cAAcA,SAAE,KAAK,CAAC,SAAS,KAAM,EAAC,CAAC,UAAU;AAClD,EAAC;;;;;;;;;AAaF,IAAM,gCAAN,cAA4C,MAAM;CAChD,YAAY,EACV,aACA,UACA,aACA,UAMD,EAAE;EACD,MAAMC,eAAyB,CAAE;AACjC,MAAI,OAAO,gBAAgB,YAAY,OAAO,gBAAgB,UAC5D,aAAa,KACX,CAAC,qCAAqC,EAAE,YAAY,YAAY,CAAC,CAClE;AAEH,MAAI,OAAO,aAAa,YAAY,OAAO,aAAa,UACtD,aAAa,KACX,CAAC,kCAAkC,EAAE,SAAS,YAAY,CAAC,CAC5D;EAEH,MACE,CAAC,0BAA0B,EACzB,aAAa,SAAS,IAAI,CAAC,EAAE,EAAE,aAAa,KAAK,KAAK,EAAE,GAAG,IAC3D,CACH;EACD,KAAK,OAAO;CACb;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8DD,SAAgB,yBACdC,mBACA;AACA,QAAOC,oCAAiB;EACtB,MAAM;EACN;EACA,mBAAmB,CAAC,KAAM;EAC1B,aAAa,CAAC,OAAO,YAAY;GAC/B,MAAM,eACJ,QAAQ,QAAQ,gBAChB,mBAAmB,gBACnB;GACF,MAAM,cACJ,QAAQ,QAAQ,eAAe,mBAAmB;GACpD,MAAM,WAAW,QAAQ,QAAQ,YAAY,mBAAmB;AAEhE,OACE,OAAO,gBAAgB,YACvB,eAAe,QAAQ,sBACvB;IACA,MAAM,QAAQ,IAAI,8BAA8B;KAC9C;KACA,aAAa,QAAQ;IACtB;AACD,QAAI,iBAAiB,MACnB,QAAO;KACL,QAAQ;KACR,UAAU,CAAC,IAAIC,oCAAU,MAAM,QAAS;IACzC;AAGH,UAAM;GACP;AACD,OACE,OAAO,aAAa,YACpB,YAAY,QAAQ,mBACpB;IACA,MAAM,QAAQ,IAAI,8BAA8B;KAC9C;KACA,UAAU,QAAQ;IACnB;AACD,QAAI,iBAAiB,MACnB,QAAO;KACL,QAAQ;KACR,UAAU,CAAC,IAAIA,oCAAU,MAAM,QAAS;IACzC;AAGH,UAAM;GACP;AAED,UAAO;EACR;CACF,EAAC;AACH"}

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

@@ -0,0 +1,119 @@
+import { AgentMiddleware } from "./types.cjs";
+import { InferInteropZodInput } from "@langchain/core/utils/types";
+import { z } from "zod/v3";
+
+//#region src/agents/middleware/callLimit.d.ts
+declare const contextSchema: z.ZodObject<{
+  /**
+   * The maximum number of model calls allowed per thread.
+   */
+  threadLimit: z.ZodOptional<z.ZodNumber>;
+  /**
+   * The maximum number of model calls allowed per run.
+   */
+  runLimit: z.ZodOptional<z.ZodNumber>;
+  /**
+   * The behavior to take when the limit is exceeded.
+   * - "throw" will throw an error and stop the agent.
+   * - "end" will end the agent.
+   * @default "end"
+   */
+  exitBehavior: z.ZodOptional<z.ZodEnum<["throw", "end"]>>;
+}, "strip", z.ZodTypeAny, {
+  threadLimit?: number | undefined;
+  runLimit?: number | undefined;
+  exitBehavior?: "end" | "throw" | undefined;
+}, {
+  threadLimit?: number | undefined;
+  runLimit?: number | undefined;
+  exitBehavior?: "end" | "throw" | undefined;
+}>;
+type ModelCallLimitMiddlewareConfig = Partial<InferInteropZodInput<typeof contextSchema>>;
+/**
+ * Creates a middleware to limit the number of model calls at both thread and run levels.
+ *
+ * This middleware helps prevent excessive model API calls by enforcing limits on how many
+ * times the model can be invoked. It supports two types of limits:
+ *
+ * - **Thread-level limit**: Restricts the total number of model calls across an entire conversation thread
+ * - **Run-level limit**: Restricts the number of model calls within a single agent run/invocation
+ *
+ * ## How It Works
+ *
+ * The middleware intercepts model requests before they are sent and checks the current call counts
+ * against the configured limits. If either limit is exceeded, it throws a `ModelCallLimitMiddlewareError`
+ * to stop execution and prevent further API calls.
+ *
+ * ## Use Cases
+ *
+ * - **Cost Control**: Prevent runaway costs from excessive model calls in production
+ * - **Testing**: Ensure agents don't make too many calls during development/testing
+ * - **Safety**: Limit potential infinite loops or recursive agent behaviors
+ * - **Rate Limiting**: Enforce organizational policies on model usage per conversation
+ *
+ * @param middlewareOptions - Configuration options for the call limits
+ * @param middlewareOptions.threadLimit - Maximum number of model calls allowed per thread (optional)
+ * @param middlewareOptions.runLimit - Maximum number of model calls allowed per run (optional)
+ *
+ * @returns A middleware instance that can be passed to `createAgent`
+ *
+ * @throws {ModelCallLimitMiddlewareError} When either the thread or run limit is exceeded
+ *
+ * @example
+ * ```typescript
+ * import { createAgent, modelCallLimitMiddleware } from "langchain";
+ *
+ * // Limit to 10 calls per thread and 3 calls per run
+ * const agent = createAgent({
+ *   model: "openai:gpt-4o-mini",
+ *   tools: [myTool],
+ *   middleware: [
+ *     modelCallLimitMiddleware({
+ *       threadLimit: 10,
+ *       runLimit: 3
+ *     })
+ *   ]
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Limits can also be configured at runtime via context
+ * const result = await agent.invoke(
+ *   { messages: ["Hello"] },
+ *   {
+ *     configurable: {
+ *       threadLimit: 5  // Override the default limit for this run
+ *     }
+ *   }
+ * );
+ * ```
+ */
+declare function modelCallLimitMiddleware(middlewareOptions?: ModelCallLimitMiddlewareConfig): AgentMiddleware<undefined, z.ZodObject<{
+  /**
+   * The maximum number of model calls allowed per thread.
+   */
+  threadLimit: z.ZodOptional<z.ZodNumber>;
+  /**
+   * The maximum number of model calls allowed per run.
+   */
+  runLimit: z.ZodOptional<z.ZodNumber>;
+  /**
+   * The behavior to take when the limit is exceeded.
+   * - "throw" will throw an error and stop the agent.
+   * - "end" will end the agent.
+   * @default "end"
+   */
+  exitBehavior: z.ZodOptional<z.ZodEnum<["throw", "end"]>>;
+}, "strip", z.ZodTypeAny, {
+  threadLimit?: number | undefined;
+  runLimit?: number | undefined;
+  exitBehavior?: "end" | "throw" | undefined;
+}, {
+  threadLimit?: number | undefined;
+  runLimit?: number | undefined;
+  exitBehavior?: "end" | "throw" | undefined;
+}>, any>;
+//#endregion
+export { ModelCallLimitMiddlewareConfig, modelCallLimitMiddleware };
+//# sourceMappingURL=callLimit.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"callLimit.d.cts","names":["z","InferInteropZodInput","contextSchema","ZodNumber","ZodOptional","ZodEnum","ZodTypeAny","ZodObject","ModelCallLimitMiddlewareConfig","Partial","modelCallLimitMiddleware","__types_js3","AgentMiddleware"],"sources":["../../../src/agents/middleware/callLimit.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\ndeclare const contextSchema: z.ZodObject<{\n    /**\n     * The maximum number of model calls allowed per thread.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The maximum number of model calls allowed per run.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The behavior to take when the limit is exceeded.\n     * - \"throw\" will throw an error and stop the agent.\n     * - \"end\" will end the agent.\n     * @default \"end\"\n     */\n    exitBehavior: z.ZodOptional<z.ZodEnum<[\"throw\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}>;\nexport type ModelCallLimitMiddlewareConfig = Partial<InferInteropZodInput<typeof contextSchema>>;\n/**\n * Creates a middleware to limit the number of model calls at both thread and run levels.\n *\n * This middleware helps prevent excessive model API calls by enforcing limits on how many\n * times the model can be invoked. It supports two types of limits:\n *\n * - **Thread-level limit**: Restricts the total number of model calls across an entire conversation thread\n * - **Run-level limit**: Restricts the number of model calls within a single agent run/invocation\n *\n * ## How It Works\n *\n * The middleware intercepts model requests before they are sent and checks the current call counts\n * against the configured limits. If either limit is exceeded, it throws a `ModelCallLimitMiddlewareError`\n * to stop execution and prevent further API calls.\n *\n * ## Use Cases\n *\n * - **Cost Control**: Prevent runaway costs from excessive model calls in production\n * - **Testing**: Ensure agents don't make too many calls during development/testing\n * - **Safety**: Limit potential infinite loops or recursive agent behaviors\n * - **Rate Limiting**: Enforce organizational policies on model usage per conversation\n *\n * @param middlewareOptions - Configuration options for the call limits\n * @param middlewareOptions.threadLimit - Maximum number of model calls allowed per thread (optional)\n * @param middlewareOptions.runLimit - Maximum number of model calls allowed per run (optional)\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @throws {ModelCallLimitMiddlewareError} When either the thread or run limit is exceeded\n *\n * @example\n * ```typescript\n * import { createAgent, modelCallLimitMiddleware } from \"langchain\";\n *\n * // Limit to 10 calls per thread and 3 calls per run\n * const agent = createAgent({\n *   model: \"openai:gpt-4o-mini\",\n *   tools: [myTool],\n *   middleware: [\n *     modelCallLimitMiddleware({\n *       threadLimit: 10,\n *       runLimit: 3\n *     })\n *   ]\n * });\n * ```\n *\n * @example\n * ```typescript\n * // Limits can also be configured at runtime via context\n * const result = await agent.invoke(\n *   { messages: [\"Hello\"] },\n *   {\n *     configurable: {\n *       threadLimit: 5  // Override the default limit for this run\n *     }\n *   }\n * );\n * ```\n */\nexport declare function modelCallLimitMiddleware(middlewareOptions?: ModelCallLimitMiddlewareConfig): import(\"./types.js\").AgentMiddleware<undefined, z.ZodObject<{\n    /**\n     * The maximum number of model calls allowed per thread.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The maximum number of model calls allowed per run.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The behavior to take when the limit is exceeded.\n     * - \"throw\" will throw an error and stop the agent.\n     * - \"end\" will end the agent.\n     * @default \"end\"\n     */\n    exitBehavior: z.ZodOptional<z.ZodEnum<[\"throw\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}>, any>;\nexport {};\n"],"mappings":";;;;;cAEcE,eAAeF,CAAAA,CAAEO;;;AADoC;EAyBjE,WAAA,EApBeP,CAAAA,CAAEI,WAoBjB,CApB6BJ,CAAAA,CAAEG,SAoB/B,CAAA;EAAA;;;EAhBqC,QAAvBC,EAAFJ,CAAAA,CAAEI,WAAAA,CAAYJ,CAAAA,CAAEG,SAAdC,CAAAA;EAAW;;;;AARa;AAyBxC;EAA0C,YAAA,EAVxBJ,CAAAA,CAAEI,WAUsB,CAVVJ,CAAAA,CAAEK,OAUQ,CAAA,CAAA,OAAA,EAAA,KAAA,CAAA,CAAA,CAAA;CAAA,EAAA,OAAuCH,EATrEF,CAAAA,CAAEM,UASmEJ,EAAAA;EAAa,WAAzCD,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAoB,QAA5BQ,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAO,YAAA,CAAA,EAAA,KAAA,GAAA,OAAA,GAAA,SAAA;AA6DpD,CAAA,EAAA;EAAgD,WAAA,CAAA,EAAA,MAAA,GAAA,SAAA;EAAA,QAAqBD,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAA8B,YAIlEL,CAAAA,EAAAA,KAAAA,GAAAA,OAAAA,GAAAA,SAAAA;CAAS,CAAA;AAIdH,KArEhBQ,8BAAAA,GAAiCC,OAqEfN,CArEuBF,oBAqEvBE,CAAAA,OArEmDD,aAqEnDC,CAAAA,CAAAA;;;;;;;AAR4G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAlHO,wBAAAA,qBAA6CF,iCAA4F,2BAAXR,CAAAA,CAAEO;;;;eAIvIP,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;;;;YAInBH,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;;;;;;;gBAOZH,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEK;YACtBL,CAAAA,CAAEM"}

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

@@ -0,0 +1,119 @@
+import { AgentMiddleware } from "./types.js";
+import { z } from "zod/v3";
+import { InferInteropZodInput } from "@langchain/core/utils/types";
+
+//#region src/agents/middleware/callLimit.d.ts
+declare const contextSchema: z.ZodObject<{
+  /**
+   * The maximum number of model calls allowed per thread.
+   */
+  threadLimit: z.ZodOptional<z.ZodNumber>;
+  /**
+   * The maximum number of model calls allowed per run.
+   */
+  runLimit: z.ZodOptional<z.ZodNumber>;
+  /**
+   * The behavior to take when the limit is exceeded.
+   * - "throw" will throw an error and stop the agent.
+   * - "end" will end the agent.
+   * @default "end"
+   */
+  exitBehavior: z.ZodOptional<z.ZodEnum<["throw", "end"]>>;
+}, "strip", z.ZodTypeAny, {
+  threadLimit?: number | undefined;
+  runLimit?: number | undefined;
+  exitBehavior?: "end" | "throw" | undefined;
+}, {
+  threadLimit?: number | undefined;
+  runLimit?: number | undefined;
+  exitBehavior?: "end" | "throw" | undefined;
+}>;
+type ModelCallLimitMiddlewareConfig = Partial<InferInteropZodInput<typeof contextSchema>>;
+/**
+ * Creates a middleware to limit the number of model calls at both thread and run levels.
+ *
+ * This middleware helps prevent excessive model API calls by enforcing limits on how many
+ * times the model can be invoked. It supports two types of limits:
+ *
+ * - **Thread-level limit**: Restricts the total number of model calls across an entire conversation thread
+ * - **Run-level limit**: Restricts the number of model calls within a single agent run/invocation
+ *
+ * ## How It Works
+ *
+ * The middleware intercepts model requests before they are sent and checks the current call counts
+ * against the configured limits. If either limit is exceeded, it throws a `ModelCallLimitMiddlewareError`
+ * to stop execution and prevent further API calls.
+ *
+ * ## Use Cases
+ *
+ * - **Cost Control**: Prevent runaway costs from excessive model calls in production
+ * - **Testing**: Ensure agents don't make too many calls during development/testing
+ * - **Safety**: Limit potential infinite loops or recursive agent behaviors
+ * - **Rate Limiting**: Enforce organizational policies on model usage per conversation
+ *
+ * @param middlewareOptions - Configuration options for the call limits
+ * @param middlewareOptions.threadLimit - Maximum number of model calls allowed per thread (optional)
+ * @param middlewareOptions.runLimit - Maximum number of model calls allowed per run (optional)
+ *
+ * @returns A middleware instance that can be passed to `createAgent`
+ *
+ * @throws {ModelCallLimitMiddlewareError} When either the thread or run limit is exceeded
+ *
+ * @example
+ * ```typescript
+ * import { createAgent, modelCallLimitMiddleware } from "langchain";
+ *
+ * // Limit to 10 calls per thread and 3 calls per run
+ * const agent = createAgent({
+ *   model: "openai:gpt-4o-mini",
+ *   tools: [myTool],
+ *   middleware: [
+ *     modelCallLimitMiddleware({
+ *       threadLimit: 10,
+ *       runLimit: 3
+ *     })
+ *   ]
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Limits can also be configured at runtime via context
+ * const result = await agent.invoke(
+ *   { messages: ["Hello"] },
+ *   {
+ *     configurable: {
+ *       threadLimit: 5  // Override the default limit for this run
+ *     }
+ *   }
+ * );
+ * ```
+ */
+declare function modelCallLimitMiddleware(middlewareOptions?: ModelCallLimitMiddlewareConfig): AgentMiddleware<undefined, z.ZodObject<{
+  /**
+   * The maximum number of model calls allowed per thread.
+   */
+  threadLimit: z.ZodOptional<z.ZodNumber>;
+  /**
+   * The maximum number of model calls allowed per run.
+   */
+  runLimit: z.ZodOptional<z.ZodNumber>;
+  /**
+   * The behavior to take when the limit is exceeded.
+   * - "throw" will throw an error and stop the agent.
+   * - "end" will end the agent.
+   * @default "end"
+   */
+  exitBehavior: z.ZodOptional<z.ZodEnum<["throw", "end"]>>;
+}, "strip", z.ZodTypeAny, {
+  threadLimit?: number | undefined;
+  runLimit?: number | undefined;
+  exitBehavior?: "end" | "throw" | undefined;
+}, {
+  threadLimit?: number | undefined;
+  runLimit?: number | undefined;
+  exitBehavior?: "end" | "throw" | undefined;
+}>, any>;
+//#endregion
+export { ModelCallLimitMiddlewareConfig, modelCallLimitMiddleware };
+//# sourceMappingURL=callLimit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"callLimit.d.ts","names":["z","InferInteropZodInput","contextSchema","ZodNumber","ZodOptional","ZodEnum","ZodTypeAny","ZodObject","ModelCallLimitMiddlewareConfig","Partial","modelCallLimitMiddleware","__types_js6","AgentMiddleware"],"sources":["../../../src/agents/middleware/callLimit.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\ndeclare const contextSchema: z.ZodObject<{\n    /**\n     * The maximum number of model calls allowed per thread.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The maximum number of model calls allowed per run.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The behavior to take when the limit is exceeded.\n     * - \"throw\" will throw an error and stop the agent.\n     * - \"end\" will end the agent.\n     * @default \"end\"\n     */\n    exitBehavior: z.ZodOptional<z.ZodEnum<[\"throw\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}>;\nexport type ModelCallLimitMiddlewareConfig = Partial<InferInteropZodInput<typeof contextSchema>>;\n/**\n * Creates a middleware to limit the number of model calls at both thread and run levels.\n *\n * This middleware helps prevent excessive model API calls by enforcing limits on how many\n * times the model can be invoked. It supports two types of limits:\n *\n * - **Thread-level limit**: Restricts the total number of model calls across an entire conversation thread\n * - **Run-level limit**: Restricts the number of model calls within a single agent run/invocation\n *\n * ## How It Works\n *\n * The middleware intercepts model requests before they are sent and checks the current call counts\n * against the configured limits. If either limit is exceeded, it throws a `ModelCallLimitMiddlewareError`\n * to stop execution and prevent further API calls.\n *\n * ## Use Cases\n *\n * - **Cost Control**: Prevent runaway costs from excessive model calls in production\n * - **Testing**: Ensure agents don't make too many calls during development/testing\n * - **Safety**: Limit potential infinite loops or recursive agent behaviors\n * - **Rate Limiting**: Enforce organizational policies on model usage per conversation\n *\n * @param middlewareOptions - Configuration options for the call limits\n * @param middlewareOptions.threadLimit - Maximum number of model calls allowed per thread (optional)\n * @param middlewareOptions.runLimit - Maximum number of model calls allowed per run (optional)\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @throws {ModelCallLimitMiddlewareError} When either the thread or run limit is exceeded\n *\n * @example\n * ```typescript\n * import { createAgent, modelCallLimitMiddleware } from \"langchain\";\n *\n * // Limit to 10 calls per thread and 3 calls per run\n * const agent = createAgent({\n *   model: \"openai:gpt-4o-mini\",\n *   tools: [myTool],\n *   middleware: [\n *     modelCallLimitMiddleware({\n *       threadLimit: 10,\n *       runLimit: 3\n *     })\n *   ]\n * });\n * ```\n *\n * @example\n * ```typescript\n * // Limits can also be configured at runtime via context\n * const result = await agent.invoke(\n *   { messages: [\"Hello\"] },\n *   {\n *     configurable: {\n *       threadLimit: 5  // Override the default limit for this run\n *     }\n *   }\n * );\n * ```\n */\nexport declare function modelCallLimitMiddleware(middlewareOptions?: ModelCallLimitMiddlewareConfig): import(\"./types.js\").AgentMiddleware<undefined, z.ZodObject<{\n    /**\n     * The maximum number of model calls allowed per thread.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The maximum number of model calls allowed per run.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The behavior to take when the limit is exceeded.\n     * - \"throw\" will throw an error and stop the agent.\n     * - \"end\" will end the agent.\n     * @default \"end\"\n     */\n    exitBehavior: z.ZodOptional<z.ZodEnum<[\"throw\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}>, any>;\nexport {};\n"],"mappings":";;;;;cAEcE,eAAeF,CAAAA,CAAEO;;;AADoC;EAyBjE,WAAA,EApBeP,CAAAA,CAAEI,WAoBjB,CApB6BJ,CAAAA,CAAEG,SAoB/B,CAAA;EAAA;;;EAhBqC,QAAvBC,EAAFJ,CAAAA,CAAEI,WAAAA,CAAYJ,CAAAA,CAAEG,SAAdC,CAAAA;EAAW;;;;AARa;AAyBxC;EAA0C,YAAA,EAVxBJ,CAAAA,CAAEI,WAUsB,CAVVJ,CAAAA,CAAEK,OAUQ,CAAA,CAAA,OAAA,EAAA,KAAA,CAAA,CAAA,CAAA;CAAA,EAAA,OAAuCH,EATrEF,CAAAA,CAAEM,UASmEJ,EAAAA;EAAa,WAAzCD,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAoB,QAA5BQ,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAO,YAAA,CAAA,EAAA,KAAA,GAAA,OAAA,GAAA,SAAA;AA6DpD,CAAA,EAAA;EAAgD,WAAA,CAAA,EAAA,MAAA,GAAA,SAAA;EAAA,QAAqBD,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAA8B,YAIlEL,CAAAA,EAAAA,KAAAA,GAAAA,OAAAA,GAAAA,SAAAA;CAAS,CAAA;AAIdH,KArEhBQ,8BAAAA,GAAiCC,OAqEfN,CArEuBF,oBAqEvBE,CAAAA,OArEmDD,aAqEnDC,CAAAA,CAAAA;;;;;;;AAR4G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAlHO,wBAAAA,qBAA6CF,iCAA4F,2BAAXR,CAAAA,CAAEO;;;;eAIvIP,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;;;;YAInBH,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;;;;;;;gBAOZH,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEK;YACtBL,CAAAA,CAAEM"}

package/dist/agents/middleware/callLimit.js

@@ -0,0 +1,127 @@
+import { createMiddleware } from "../middleware.js";
+import { AIMessage } from "@langchain/core/messages";
+import { z } from "zod/v3";
+
+//#region src/agents/middleware/callLimit.ts
+const DEFAULT_EXIT_BEHAVIOR = "end";
+const contextSchema = z.object({
+	threadLimit: z.number().optional(),
+	runLimit: z.number().optional(),
+	exitBehavior: z.enum(["throw", "end"]).optional()
+});
+/**
+* Error thrown when the model call limit is exceeded.
+*
+* @param threadLimit - The maximum number of model calls allowed per thread.
+* @param runLimit - The maximum number of model calls allowed per run.
+* @param threadCount - The number of model calls made at the thread level.
+* @param runCount - The number of model calls made at the run level.
+*/
+var ModelCallLimitMiddlewareError = class extends Error {
+	constructor({ threadLimit, runLimit, threadCount, runCount }) {
+		const exceededHint = [];
+		if (typeof threadLimit === "number" && typeof threadCount === "number") exceededHint.push(`thread level call limit reached with ${threadCount} model calls`);
+		if (typeof runLimit === "number" && typeof runCount === "number") exceededHint.push(`run level call limit reached with ${runCount} model calls`);
+		super(`Model call limits exceeded${exceededHint.length > 0 ? `: ${exceededHint.join(", ")}` : ""}`);
+		this.name = "ModelCallLimitMiddlewareError";
+	}
+};
+/**
+* Creates a middleware to limit the number of model calls at both thread and run levels.
+*
+* This middleware helps prevent excessive model API calls by enforcing limits on how many
+* times the model can be invoked. It supports two types of limits:
+*
+* - **Thread-level limit**: Restricts the total number of model calls across an entire conversation thread
+* - **Run-level limit**: Restricts the number of model calls within a single agent run/invocation
+*
+* ## How It Works
+*
+* The middleware intercepts model requests before they are sent and checks the current call counts
+* against the configured limits. If either limit is exceeded, it throws a `ModelCallLimitMiddlewareError`
+* to stop execution and prevent further API calls.
+*
+* ## Use Cases
+*
+* - **Cost Control**: Prevent runaway costs from excessive model calls in production
+* - **Testing**: Ensure agents don't make too many calls during development/testing
+* - **Safety**: Limit potential infinite loops or recursive agent behaviors
+* - **Rate Limiting**: Enforce organizational policies on model usage per conversation
+*
+* @param middlewareOptions - Configuration options for the call limits
+* @param middlewareOptions.threadLimit - Maximum number of model calls allowed per thread (optional)
+* @param middlewareOptions.runLimit - Maximum number of model calls allowed per run (optional)
+*
+* @returns A middleware instance that can be passed to `createAgent`
+*
+* @throws {ModelCallLimitMiddlewareError} When either the thread or run limit is exceeded
+*
+* @example
+* ```typescript
+* import { createAgent, modelCallLimitMiddleware } from "langchain";
+*
+* // Limit to 10 calls per thread and 3 calls per run
+* const agent = createAgent({
+*   model: "openai:gpt-4o-mini",
+*   tools: [myTool],
+*   middleware: [
+*     modelCallLimitMiddleware({
+*       threadLimit: 10,
+*       runLimit: 3
+*     })
+*   ]
+* });
+* ```
+*
+* @example
+* ```typescript
+* // Limits can also be configured at runtime via context
+* const result = await agent.invoke(
+*   { messages: ["Hello"] },
+*   {
+*     configurable: {
+*       threadLimit: 5  // Override the default limit for this run
+*     }
+*   }
+* );
+* ```
+*/
+function modelCallLimitMiddleware(middlewareOptions) {
+	return createMiddleware({
+		name: "ModelCallLimitMiddleware",
+		contextSchema,
+		beforeModelJumpTo: ["end"],
+		beforeModel: (state, runtime) => {
+			const exitBehavior = runtime.context.exitBehavior ?? middlewareOptions?.exitBehavior ?? DEFAULT_EXIT_BEHAVIOR;
+			const threadLimit = runtime.context.threadLimit ?? middlewareOptions?.threadLimit;
+			const runLimit = runtime.context.runLimit ?? middlewareOptions?.runLimit;
+			if (typeof threadLimit === "number" && threadLimit <= runtime.threadLevelCallCount) {
+				const error = new ModelCallLimitMiddlewareError({
+					threadLimit,
+					threadCount: runtime.threadLevelCallCount
+				});
+				if (exitBehavior === "end") return {
+					jumpTo: "end",
+					messages: [new AIMessage(error.message)]
+				};
+				throw error;
+			}
+			if (typeof runLimit === "number" && runLimit <= runtime.runModelCallCount) {
+				const error = new ModelCallLimitMiddlewareError({
+					runLimit,
+					runCount: runtime.runModelCallCount
+				});
+				if (exitBehavior === "end") return {
+					jumpTo: "end",
+					messages: [new AIMessage(error.message)]
+				};
+				throw error;
+			}
+			return state;
+		}
+	});
+}
+
+//#endregion
+export { modelCallLimitMiddleware };
+//# sourceMappingURL=callLimit.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"callLimit.js","names":["exceededHint: string[]","middlewareOptions?: ModelCallLimitMiddlewareConfig"],"sources":["../../../src/agents/middleware/callLimit.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { AIMessage } from \"@langchain/core/messages\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\n\nimport { createMiddleware } from \"../middleware.js\";\n\nconst DEFAULT_EXIT_BEHAVIOR = \"end\";\n\nconst contextSchema = z.object({\n  /**\n   * The maximum number of model calls allowed per thread.\n   */\n  threadLimit: z.number().optional(),\n  /**\n   * The maximum number of model calls allowed per run.\n   */\n  runLimit: z.number().optional(),\n  /**\n   * The behavior to take when the limit is exceeded.\n   * - \"throw\" will throw an error and stop the agent.\n   * - \"end\" will end the agent.\n   * @default \"end\"\n   */\n  exitBehavior: z.enum([\"throw\", \"end\"]).optional(),\n});\nexport type ModelCallLimitMiddlewareConfig = Partial<\n  InferInteropZodInput<typeof contextSchema>\n>;\n\n/**\n * Error thrown when the model call limit is exceeded.\n *\n * @param threadLimit - The maximum number of model calls allowed per thread.\n * @param runLimit - The maximum number of model calls allowed per run.\n * @param threadCount - The number of model calls made at the thread level.\n * @param runCount - The number of model calls made at the run level.\n */\nclass ModelCallLimitMiddlewareError extends Error {\n  constructor({\n    threadLimit,\n    runLimit,\n    threadCount,\n    runCount,\n  }: {\n    threadLimit?: number;\n    runLimit?: number;\n    threadCount?: number;\n    runCount?: number;\n  }) {\n    const exceededHint: string[] = [];\n    if (typeof threadLimit === \"number\" && typeof threadCount === \"number\") {\n      exceededHint.push(\n        `thread level call limit reached with ${threadCount} model calls`\n      );\n    }\n    if (typeof runLimit === \"number\" && typeof runCount === \"number\") {\n      exceededHint.push(\n        `run level call limit reached with ${runCount} model calls`\n      );\n    }\n    super(\n      `Model call limits exceeded${\n        exceededHint.length > 0 ? `: ${exceededHint.join(\", \")}` : \"\"\n      }`\n    );\n    this.name = \"ModelCallLimitMiddlewareError\";\n  }\n}\n\n/**\n * Creates a middleware to limit the number of model calls at both thread and run levels.\n *\n * This middleware helps prevent excessive model API calls by enforcing limits on how many\n * times the model can be invoked. It supports two types of limits:\n *\n * - **Thread-level limit**: Restricts the total number of model calls across an entire conversation thread\n * - **Run-level limit**: Restricts the number of model calls within a single agent run/invocation\n *\n * ## How It Works\n *\n * The middleware intercepts model requests before they are sent and checks the current call counts\n * against the configured limits. If either limit is exceeded, it throws a `ModelCallLimitMiddlewareError`\n * to stop execution and prevent further API calls.\n *\n * ## Use Cases\n *\n * - **Cost Control**: Prevent runaway costs from excessive model calls in production\n * - **Testing**: Ensure agents don't make too many calls during development/testing\n * - **Safety**: Limit potential infinite loops or recursive agent behaviors\n * - **Rate Limiting**: Enforce organizational policies on model usage per conversation\n *\n * @param middlewareOptions - Configuration options for the call limits\n * @param middlewareOptions.threadLimit - Maximum number of model calls allowed per thread (optional)\n * @param middlewareOptions.runLimit - Maximum number of model calls allowed per run (optional)\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @throws {ModelCallLimitMiddlewareError} When either the thread or run limit is exceeded\n *\n * @example\n * ```typescript\n * import { createAgent, modelCallLimitMiddleware } from \"langchain\";\n *\n * // Limit to 10 calls per thread and 3 calls per run\n * const agent = createAgent({\n *   model: \"openai:gpt-4o-mini\",\n *   tools: [myTool],\n *   middleware: [\n *     modelCallLimitMiddleware({\n *       threadLimit: 10,\n *       runLimit: 3\n *     })\n *   ]\n * });\n * ```\n *\n * @example\n * ```typescript\n * // Limits can also be configured at runtime via context\n * const result = await agent.invoke(\n *   { messages: [\"Hello\"] },\n *   {\n *     configurable: {\n *       threadLimit: 5  // Override the default limit for this run\n *     }\n *   }\n * );\n * ```\n */\nexport function modelCallLimitMiddleware(\n  middlewareOptions?: ModelCallLimitMiddlewareConfig\n) {\n  return createMiddleware({\n    name: \"ModelCallLimitMiddleware\",\n    contextSchema,\n    beforeModelJumpTo: [\"end\"],\n    beforeModel: (state, runtime) => {\n      const exitBehavior =\n        runtime.context.exitBehavior ??\n        middlewareOptions?.exitBehavior ??\n        DEFAULT_EXIT_BEHAVIOR;\n      const threadLimit =\n        runtime.context.threadLimit ?? middlewareOptions?.threadLimit;\n      const runLimit = runtime.context.runLimit ?? middlewareOptions?.runLimit;\n\n      if (\n        typeof threadLimit === \"number\" &&\n        threadLimit <= runtime.threadLevelCallCount\n      ) {\n        const error = new ModelCallLimitMiddlewareError({\n          threadLimit,\n          threadCount: runtime.threadLevelCallCount,\n        });\n        if (exitBehavior === \"end\") {\n          return {\n            jumpTo: \"end\",\n            messages: [new AIMessage(error.message)],\n          };\n        }\n\n        throw error;\n      }\n      if (\n        typeof runLimit === \"number\" &&\n        runLimit <= runtime.runModelCallCount\n      ) {\n        const error = new ModelCallLimitMiddlewareError({\n          runLimit,\n          runCount: runtime.runModelCallCount,\n        });\n        if (exitBehavior === \"end\") {\n          return {\n            jumpTo: \"end\",\n            messages: [new AIMessage(error.message)],\n          };\n        }\n\n        throw error;\n      }\n\n      return state;\n    },\n  });\n}\n"],"mappings":";;;;;AAMA,MAAM,wBAAwB;AAE9B,MAAM,gBAAgB,EAAE,OAAO;CAI7B,aAAa,EAAE,QAAQ,CAAC,UAAU;CAIlC,UAAU,EAAE,QAAQ,CAAC,UAAU;CAO/B,cAAc,EAAE,KAAK,CAAC,SAAS,KAAM,EAAC,CAAC,UAAU;AAClD,EAAC;;;;;;;;;AAaF,IAAM,gCAAN,cAA4C,MAAM;CAChD,YAAY,EACV,aACA,UACA,aACA,UAMD,EAAE;EACD,MAAMA,eAAyB,CAAE;AACjC,MAAI,OAAO,gBAAgB,YAAY,OAAO,gBAAgB,UAC5D,aAAa,KACX,CAAC,qCAAqC,EAAE,YAAY,YAAY,CAAC,CAClE;AAEH,MAAI,OAAO,aAAa,YAAY,OAAO,aAAa,UACtD,aAAa,KACX,CAAC,kCAAkC,EAAE,SAAS,YAAY,CAAC,CAC5D;EAEH,MACE,CAAC,0BAA0B,EACzB,aAAa,SAAS,IAAI,CAAC,EAAE,EAAE,aAAa,KAAK,KAAK,EAAE,GAAG,IAC3D,CACH;EACD,KAAK,OAAO;CACb;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8DD,SAAgB,yBACdC,mBACA;AACA,QAAO,iBAAiB;EACtB,MAAM;EACN;EACA,mBAAmB,CAAC,KAAM;EAC1B,aAAa,CAAC,OAAO,YAAY;GAC/B,MAAM,eACJ,QAAQ,QAAQ,gBAChB,mBAAmB,gBACnB;GACF,MAAM,cACJ,QAAQ,QAAQ,eAAe,mBAAmB;GACpD,MAAM,WAAW,QAAQ,QAAQ,YAAY,mBAAmB;AAEhE,OACE,OAAO,gBAAgB,YACvB,eAAe,QAAQ,sBACvB;IACA,MAAM,QAAQ,IAAI,8BAA8B;KAC9C;KACA,aAAa,QAAQ;IACtB;AACD,QAAI,iBAAiB,MACnB,QAAO;KACL,QAAQ;KACR,UAAU,CAAC,IAAI,UAAU,MAAM,QAAS;IACzC;AAGH,UAAM;GACP;AACD,OACE,OAAO,aAAa,YACpB,YAAY,QAAQ,mBACpB;IACA,MAAM,QAAQ,IAAI,8BAA8B;KAC9C;KACA,UAAU,QAAQ;IACnB;AACD,QAAI,iBAAiB,MACnB,QAAO;KACL,QAAQ;KACR,UAAU,CAAC,IAAI,UAAU,MAAM,QAAS;IACzC;AAGH,UAAM;GACP;AAED,UAAO;EACR;CACF,EAAC;AACH"}