langchain 1.1.5 → 1.1.6-dev-1765432861398

package/dist/agents/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","ZodRecord","Record","__types_js10","AgentMiddleware"],"sources":["../../../src/agents/middleware/toolCallLimit.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport type { InferInteropZodInput } from \"@langchain/core/utils/types\";\n/**\n * Exception raised when tool call limits are exceeded.\n *\n * This exception is raised when the configured exit behavior is 'error'\n * and either the thread or run tool call limit has been exceeded.\n */\nexport declare class ToolCallLimitExceededError extends Error {\n    /**\n     * Current thread tool call count.\n     */\n    threadCount: number;\n    /**\n     * Current run tool call count.\n     */\n    runCount: number;\n    /**\n     * Thread tool call limit (if set).\n     */\n    threadLimit: number | undefined;\n    /**\n     * Run tool call limit (if set).\n     */\n    runLimit: number | undefined;\n    /**\n     * Tool name being limited (if specific tool), or undefined for all tools.\n     */\n    toolName: string | undefined;\n    constructor(threadCount: number, runCount: number, threadLimit: number | undefined, runLimit: number | undefined, toolName?: string | undefined);\n}\n/**\n * Options for configuring the Tool Call Limit middleware.\n */\nexport declare const ToolCallLimitOptionsSchema: z.ZodObject<{\n    /**\n     * Name of the specific tool to limit. If undefined, limits apply to all tools.\n     */\n    toolName: z.ZodOptional<z.ZodString>;\n    /**\n     * Maximum number of tool calls allowed per thread.\n     * undefined means no limit.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * Maximum number of tool calls allowed per run.\n     * undefined means no limit.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * What to do when limits are exceeded.\n     * - \"continue\": Block exceeded tools with error messages, let other tools continue (default)\n     * - \"error\": Raise a ToolCallLimitExceededError exception\n     * - \"end\": Stop execution immediately, injecting a ToolMessage and an AI message\n     *   for the single tool call that exceeded the limit. Raises NotImplementedError\n     *   if there are multiple tool calls.\n     *\n     * @default \"continue\"\n     */\n    exitBehavior: z.ZodDefault<z.ZodEnum<[\"continue\", \"error\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    toolName?: string | undefined;\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior: \"continue\" | \"end\" | \"error\";\n}, {\n    toolName?: string | undefined;\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"continue\" | \"end\" | \"error\" | undefined;\n}>;\nexport type ToolCallLimitConfig = InferInteropZodInput<typeof ToolCallLimitOptionsSchema>;\n/**\n * Middleware that tracks tool call counts and enforces limits.\n *\n * This middleware monitors the number of tool calls made during agent execution\n * and can terminate the agent when specified limits are reached. It supports\n * both thread-level and run-level call counting with configurable exit behaviors.\n *\n * Thread-level: The middleware counts all tool calls in the entire message history\n * and persists this count across multiple runs (invocations) of the agent.\n *\n * Run-level: The middleware counts tool calls made after the last HumanMessage,\n * representing the current run (invocation) of the agent.\n *\n * @param options - Configuration options for the middleware\n * @param options.toolName - Name of the specific tool to limit. If undefined, limits apply to all tools.\n * @param options.threadLimit - Maximum number of tool calls allowed per thread. undefined means no limit.\n * @param options.runLimit - Maximum number of tool calls allowed per run. undefined means no limit.\n * @param options.exitBehavior - What to do when limits are exceeded.\n *   - \"continue\": Block exceeded tools with error messages, let other tools continue. Model decides when to end. (default)\n *   - \"error\": Raise a ToolCallLimitExceededError exception\n *   - \"end\": Stop execution immediately with a ToolMessage + AI message for the single tool call that exceeded the limit. Raises NotImplementedError if there are multiple tool calls.\n *\n * @throws {Error} If both limits are undefined, if exitBehavior is invalid, or if runLimit exceeds threadLimit.\n * @throws {NotImplementedError} If exitBehavior is \"end\" and there are multiple tool calls.\n *\n * @example Continue execution with blocked tools (default)\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * // Block exceeded tools but let other tools and model continue\n * const limiter = toolCallLimitMiddleware({\n *   threadLimit: 20,\n *   runLimit: 10,\n *   exitBehavior: \"continue\", // default\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [limiter]\n * });\n * ```\n *\n * @example Stop immediately when limit exceeded\n * ```ts\n * // End execution immediately with an AI message\n * const limiter = toolCallLimitMiddleware({\n *   runLimit: 5,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [limiter]\n * });\n * ```\n *\n * @example Raise exception on limit\n * ```ts\n * // Strict limit with exception handling\n * const limiter = toolCallLimitMiddleware({\n *   toolName: \"search\",\n *   threadLimit: 5,\n *   exitBehavior: \"error\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [limiter]\n * });\n *\n * try {\n *   const result = await agent.invoke({ messages: [new HumanMessage(\"Task\")] });\n * } catch (error) {\n *   if (error instanceof ToolCallLimitExceededError) {\n *     console.log(`Search limit exceeded: ${error}`);\n *   }\n * }\n * ```\n */\nexport declare function toolCallLimitMiddleware(options: ToolCallLimitConfig): import(\"./types.js\").AgentMiddleware<z.ZodObject<{\n    threadToolCallCount: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;\n    runToolCallCount: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadToolCallCount: Record<string, number>;\n    runToolCallCount: Record<string, number>;\n}, {\n    threadToolCallCount?: Record<string, number> | undefined;\n    runToolCallCount?: Record<string, number> | undefined;\n}>, undefined, any>;\n//# sourceMappingURL=toolCallLimit.d.ts.map"],"mappings":";;;;;;;;;AAQA;AA0BA;;AAIgBM,cA9BKJ,0BAAAA,SAAmCC,KAAK,CA8B7CG;EAKiBC;;;EAKjBD,WAAAA,EAAAA,MAAAA;EAWiBE;;;EAzBkBG,QAAAA,EAAAA,MAAAA;EAAS;AAqC5D;AAiFA;EAAyDC,WAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EACLP;;;EAAzBI,QAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EACsBJ;;;EAAzBI,QAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EACVC,WAAAA,CAAAA,WAAAA,EAAAA,MAAAA,EAAAA,QAAAA,EAAAA,MAAAA,EAAAA,WAAAA,EAAAA,MAAAA,GAAAA,SAAAA,EAAAA,QAAAA,EAAAA,MAAAA,GAAAA,SAAAA,EAAAA,QAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;;;;;AAHwGC,cAtHjGP,0BAsHiGO,EAtHrEX,CAAAA,CAAEW,SAsHmEA,CAAAA;;AAAH;;YAlHrGX,CAAAA,CAAEM,YAAYN,CAAAA,CAAEK;;;;;eAKbL,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;YAKnBP,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;;;;;;;gBAWZP,CAAAA,CAAES,WAAWT,CAAAA,CAAEQ;YACrBR,CAAAA,CAAEU;;;;;;;;;;;KAWFE,mBAAAA,GAAsBX,4BAA4BG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiFtCS,uBAAAA,UAAiCD,sCAA2DZ,CAAAA,CAAEW;uBAC7FX,CAAAA,CAAES,WAAWT,CAAAA,CAAEc,UAAUd,CAAAA,CAAEK,WAAWL,CAAAA,CAAEO;oBAC3CP,CAAAA,CAAES,WAAWT,CAAAA,CAAEc,UAAUd,CAAAA,CAAEK,WAAWL,CAAAA,CAAEO;YAClDP,CAAAA,CAAEU;uBACWK;oBACHA;;wBAEIA;qBACHA"}

package/dist/agents/middleware/toolCallLimit.d.ts.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","ZodRecord","Record","__types_js9","AgentMiddleware"],"sources":["../../../src/agents/middleware/toolCallLimit.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport type { InferInteropZodInput } from \"@langchain/core/utils/types\";\n/**\n * Exception raised when tool call limits are exceeded.\n *\n * This exception is raised when the configured exit behavior is 'error'\n * and either the thread or run tool call limit has been exceeded.\n */\nexport declare class ToolCallLimitExceededError extends Error {\n    /**\n     * Current thread tool call count.\n     */\n    threadCount: number;\n    /**\n     * Current run tool call count.\n     */\n    runCount: number;\n    /**\n     * Thread tool call limit (if set).\n     */\n    threadLimit: number | undefined;\n    /**\n     * Run tool call limit (if set).\n     */\n    runLimit: number | undefined;\n    /**\n     * Tool name being limited (if specific tool), or undefined for all tools.\n     */\n    toolName: string | undefined;\n    constructor(threadCount: number, runCount: number, threadLimit: number | undefined, runLimit: number | undefined, toolName?: string | undefined);\n}\n/**\n * Options for configuring the Tool Call Limit middleware.\n */\nexport declare const ToolCallLimitOptionsSchema: z.ZodObject<{\n    /**\n     * Name of the specific tool to limit. If undefined, limits apply to all tools.\n     */\n    toolName: z.ZodOptional<z.ZodString>;\n    /**\n     * Maximum number of tool calls allowed per thread.\n     * undefined means no limit.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * Maximum number of tool calls allowed per run.\n     * undefined means no limit.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * What to do when limits are exceeded.\n     * - \"continue\": Block exceeded tools with error messages, let other tools continue (default)\n     * - \"error\": Raise a ToolCallLimitExceededError exception\n     * - \"end\": Stop execution immediately, injecting a ToolMessage and an AI message\n     *   for the single tool call that exceeded the limit. Raises NotImplementedError\n     *   if there are multiple tool calls.\n     *\n     * @default \"continue\"\n     */\n    exitBehavior: z.ZodDefault<z.ZodEnum<[\"continue\", \"error\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    toolName?: string | undefined;\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior: \"continue\" | \"end\" | \"error\";\n}, {\n    toolName?: string | undefined;\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"continue\" | \"end\" | \"error\" | undefined;\n}>;\nexport type ToolCallLimitConfig = InferInteropZodInput<typeof ToolCallLimitOptionsSchema>;\n/**\n * Middleware that tracks tool call counts and enforces limits.\n *\n * This middleware monitors the number of tool calls made during agent execution\n * and can terminate the agent when specified limits are reached. It supports\n * both thread-level and run-level call counting with configurable exit behaviors.\n *\n * Thread-level: The middleware counts all tool calls in the entire message history\n * and persists this count across multiple runs (invocations) of the agent.\n *\n * Run-level: The middleware counts tool calls made after the last HumanMessage,\n * representing the current run (invocation) of the agent.\n *\n * @param options - Configuration options for the middleware\n * @param options.toolName - Name of the specific tool to limit. If undefined, limits apply to all tools.\n * @param options.threadLimit - Maximum number of tool calls allowed per thread. undefined means no limit.\n * @param options.runLimit - Maximum number of tool calls allowed per run. undefined means no limit.\n * @param options.exitBehavior - What to do when limits are exceeded.\n *   - \"continue\": Block exceeded tools with error messages, let other tools continue. Model decides when to end. (default)\n *   - \"error\": Raise a ToolCallLimitExceededError exception\n *   - \"end\": Stop execution immediately with a ToolMessage + AI message for the single tool call that exceeded the limit. Raises NotImplementedError if there are multiple tool calls.\n *\n * @throws {Error} If both limits are undefined, if exitBehavior is invalid, or if runLimit exceeds threadLimit.\n * @throws {NotImplementedError} If exitBehavior is \"end\" and there are multiple tool calls.\n *\n * @example Continue execution with blocked tools (default)\n * ```ts\n * import { toolCallLimitMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * // Block exceeded tools but let other tools and model continue\n * const limiter = toolCallLimitMiddleware({\n *   threadLimit: 20,\n *   runLimit: 10,\n *   exitBehavior: \"continue\", // default\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [limiter]\n * });\n * ```\n *\n * @example Stop immediately when limit exceeded\n * ```ts\n * // End execution immediately with an AI message\n * const limiter = toolCallLimitMiddleware({\n *   runLimit: 5,\n *   exitBehavior: \"end\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [limiter]\n * });\n * ```\n *\n * @example Raise exception on limit\n * ```ts\n * // Strict limit with exception handling\n * const limiter = toolCallLimitMiddleware({\n *   toolName: \"search\",\n *   threadLimit: 5,\n *   exitBehavior: \"error\"\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [limiter]\n * });\n *\n * try {\n *   const result = await agent.invoke({ messages: [new HumanMessage(\"Task\")] });\n * } catch (error) {\n *   if (error instanceof ToolCallLimitExceededError) {\n *     console.log(`Search limit exceeded: ${error}`);\n *   }\n * }\n * ```\n */\nexport declare function toolCallLimitMiddleware(options: ToolCallLimitConfig): import(\"./types.js\").AgentMiddleware<z.ZodObject<{\n    threadToolCallCount: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;\n    runToolCallCount: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadToolCallCount: Record<string, number>;\n    runToolCallCount: Record<string, number>;\n}, {\n    threadToolCallCount?: Record<string, number> | undefined;\n    runToolCallCount?: Record<string, number> | undefined;\n}>, undefined, any>;\n//# sourceMappingURL=toolCallLimit.d.ts.map"],"mappings":";;;;;;;;;AAQA;AA0BA;;AAIgBM,cA9BKJ,0BAAAA,SAAmCC,KAAK,CA8B7CG;EAKiBC;;;EAKjBD,WAAAA,EAAAA,MAAAA;EAWiBE;;;EAzBkBG,QAAAA,EAAAA,MAAAA;EAAS;AAqC5D;AAiFA;EAAyDC,WAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EACLP;;;EAAzBI,QAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EACsBJ;;;EAAzBI,QAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EACVC,WAAAA,CAAAA,WAAAA,EAAAA,MAAAA,EAAAA,QAAAA,EAAAA,MAAAA,EAAAA,WAAAA,EAAAA,MAAAA,GAAAA,SAAAA,EAAAA,QAAAA,EAAAA,MAAAA,GAAAA,SAAAA,EAAAA,QAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;;;;;AAHwGC,cAtHjGP,0BAsHiGO,EAtHrEX,CAAAA,CAAEW,SAsHmEA,CAAAA;;AAAH;;YAlHrGX,CAAAA,CAAEM,YAAYN,CAAAA,CAAEK;;;;;eAKbL,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;YAKnBP,CAAAA,CAAEM,YAAYN,CAAAA,CAAEO;;;;;;;;;;;gBAWZP,CAAAA,CAAES,WAAWT,CAAAA,CAAEQ;YACrBR,CAAAA,CAAEU;;;;;;;;;;;KAWFE,mBAAAA,GAAsBX,4BAA4BG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiFtCS,uBAAAA,UAAiCD,sCAA2DZ,CAAAA,CAAEW;uBAC7FX,CAAAA,CAAES,WAAWT,CAAAA,CAAEc,UAAUd,CAAAA,CAAEK,WAAWL,CAAAA,CAAEO;oBAC3CP,CAAAA,CAAES,WAAWT,CAAAA,CAAEc,UAAUd,CAAAA,CAAEK,WAAWL,CAAAA,CAAEO;YAClDP,CAAAA,CAAEU;uBACWK;oBACHA;;wBAEIA;qBACHA"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolEmulator.d.cts","names":["BaseChatModel","ClientTool","ServerTool","createMiddleware","ToolEmulatorOptions","toolEmulatorMiddleware","ReturnType"],"sources":["../../../src/agents/middleware/toolEmulator.d.ts"],"sourcesContent":["import type { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport type { ClientTool, ServerTool } from \"@langchain/core/tools\";\nimport { createMiddleware } from \"../middleware.js\";\n/**\n * Options for configuring the Tool Emulator middleware.\n */\nexport interface ToolEmulatorOptions {\n    /**\n     * List of tool names (string) or tool instances to emulate.\n     * - If `undefined` (default), ALL tools will be emulated.\n     * - If empty array, no tools will be emulated.\n     * - If array with tool names/instances, only those tools will be emulated.\n     */\n    tools?: (string | ClientTool | ServerTool)[];\n    /**\n     * Model to use for emulation.\n     * - Can be a model identifier string (e.g., \"anthropic:claude-sonnet-4-5-20250929\")\n     * - Can be a BaseChatModel instance\n     * - Defaults to agent model\n     */\n    model?: string | BaseChatModel;\n}\n/**\n * Middleware that emulates specified tools using an LLM instead of executing them.\n *\n * This middleware allows selective emulation of tools for testing purposes.\n * By default (when `tools` is undefined), all tools are emulated. You can specify\n * which tools to emulate by passing a list of tool names or tool instances.\n *\n * @param options - Configuration options for the middleware\n * @param options.tools - List of tool names or tool instances to emulate. If undefined, all tools are emulated.\n * @param options.model - Model to use for emulation. Defaults to \"anthropic:claude-sonnet-4-5-20250929\".\n *\n * @example Emulate all tools (default behavior)\n * ```ts\n * import { toolEmulatorMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * const middleware = toolEmulatorMiddleware();\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [getWeather, getUserLocation, calculator],\n *   middleware: [middleware],\n * });\n * ```\n *\n * @example Emulate specific tools by name\n * ```ts\n * const middleware = toolEmulatorMiddleware({\n *   tools: [\"get_weather\", \"get_user_location\"]\n * });\n * ```\n *\n * @example Use a custom model for emulation\n * ```ts\n * const middleware = toolEmulatorMiddleware({\n *   tools: [\"get_weather\"],\n *   model: \"anthropic:claude-sonnet-4-5-20250929\"\n * });\n * ```\n *\n * @example Emulate specific tools by passing tool instances\n * ```ts\n * const middleware = toolEmulatorMiddleware({\n *   tools: [getWeather, getUserLocation]\n * });\n * ```\n */\nexport declare function toolEmulatorMiddleware(options?: ToolEmulatorOptions): ReturnType<typeof createMiddleware>;\n//# sourceMappingURL=toolEmulator.d.ts.map"],"mappings":";;;;;;;;AAMA;AAOsBC,UAPLG,mBAAAA,CAOKH;EAAaC;;AAOD;AAiDlC;;;EAA+EI,KAAAA,CAAAA,EAAAA,CAAAA,MAAAA,GAxDzDL,UAwDyDK,GAxD5CJ,UAwD4CI,CAAAA,EAAAA;EAAU;;;;;;mBAjDpEN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiDGK,sBAAAA,WAAiCD,sBAAsBE,kBAAkBH"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolEmulator.d.ts","names":["BaseChatModel","ClientTool","ServerTool","createMiddleware","ToolEmulatorOptions","toolEmulatorMiddleware","ReturnType"],"sources":["../../../src/agents/middleware/toolEmulator.d.ts"],"sourcesContent":["import type { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport type { ClientTool, ServerTool } from \"@langchain/core/tools\";\nimport { createMiddleware } from \"../middleware.js\";\n/**\n * Options for configuring the Tool Emulator middleware.\n */\nexport interface ToolEmulatorOptions {\n    /**\n     * List of tool names (string) or tool instances to emulate.\n     * - If `undefined` (default), ALL tools will be emulated.\n     * - If empty array, no tools will be emulated.\n     * - If array with tool names/instances, only those tools will be emulated.\n     */\n    tools?: (string | ClientTool | ServerTool)[];\n    /**\n     * Model to use for emulation.\n     * - Can be a model identifier string (e.g., \"anthropic:claude-sonnet-4-5-20250929\")\n     * - Can be a BaseChatModel instance\n     * - Defaults to agent model\n     */\n    model?: string | BaseChatModel;\n}\n/**\n * Middleware that emulates specified tools using an LLM instead of executing them.\n *\n * This middleware allows selective emulation of tools for testing purposes.\n * By default (when `tools` is undefined), all tools are emulated. You can specify\n * which tools to emulate by passing a list of tool names or tool instances.\n *\n * @param options - Configuration options for the middleware\n * @param options.tools - List of tool names or tool instances to emulate. If undefined, all tools are emulated.\n * @param options.model - Model to use for emulation. Defaults to \"anthropic:claude-sonnet-4-5-20250929\".\n *\n * @example Emulate all tools (default behavior)\n * ```ts\n * import { toolEmulatorMiddleware } from \"@langchain/langchain/agents/middleware\";\n * import { createAgent } from \"@langchain/langchain/agents\";\n *\n * const middleware = toolEmulatorMiddleware();\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [getWeather, getUserLocation, calculator],\n *   middleware: [middleware],\n * });\n * ```\n *\n * @example Emulate specific tools by name\n * ```ts\n * const middleware = toolEmulatorMiddleware({\n *   tools: [\"get_weather\", \"get_user_location\"]\n * });\n * ```\n *\n * @example Use a custom model for emulation\n * ```ts\n * const middleware = toolEmulatorMiddleware({\n *   tools: [\"get_weather\"],\n *   model: \"anthropic:claude-sonnet-4-5-20250929\"\n * });\n * ```\n *\n * @example Emulate specific tools by passing tool instances\n * ```ts\n * const middleware = toolEmulatorMiddleware({\n *   tools: [getWeather, getUserLocation]\n * });\n * ```\n */\nexport declare function toolEmulatorMiddleware(options?: ToolEmulatorOptions): ReturnType<typeof createMiddleware>;\n//# sourceMappingURL=toolEmulator.d.ts.map"],"mappings":";;;;;;;;AAMA;AAOsBC,UAPLG,mBAAAA,CAOKH;EAAaC;;AAOD;AAiDlC;;;EAA+EI,KAAAA,CAAAA,EAAAA,CAAAA,MAAAA,GAxDzDL,UAwDyDK,GAxD5CJ,UAwD4CI,CAAAA,EAAAA;EAAU;;;;;;mBAjDpEN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiDGK,sBAAAA,WAAiCD,sBAAsBE,kBAAkBH"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolRetry.d.cts","names":["z","ClientTool","ServerTool","AgentMiddleware","ToolRetryMiddlewareOptionsSchema","ZodTypeDef","ZodType","ZodString","ZodUnion","ZodArray","ZodOptional","ZodLiteral","Error","ZodUnknown","ZodTuple","ZodFunction","ZodDefault","ZodNumber","ZodBoolean","ZodTypeAny","ZodObject","ToolRetryMiddlewareConfig","input","toolRetryMiddleware"],"sources":["../../../src/agents/middleware/toolRetry.d.ts"],"sourcesContent":["/**\n * Tool retry middleware for agents.\n */\nimport { z } from \"zod/v3\";\nimport type { ClientTool, ServerTool } from \"@langchain/core/tools\";\nimport type { AgentMiddleware } from \"./types.js\";\n/**\n * Configuration options for the Tool Retry Middleware.\n */\nexport declare const ToolRetryMiddlewareOptionsSchema: z.ZodObject<{\n    /**\n     * Optional list of tools or tool names to apply retry logic to.\n     * Can be a list of `BaseTool` instances or tool name strings.\n     * If `undefined`, applies to all tools. Default is `undefined`.\n     */\n    tools: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodType<ClientTool, z.ZodTypeDef, ClientTool>, z.ZodType<ServerTool, z.ZodTypeDef, ServerTool>, z.ZodString]>, \"many\">>;\n    /**\n     * Behavior when all retries are exhausted. Options:\n     * - `\"continue\"` (default): Return an AIMessage with error details, allowing\n     *   the agent to potentially handle the failure gracefully.\n     * - `\"error\"`: Re-raise the exception, stopping agent execution.\n     * - Custom function: Function that takes the exception and returns a string\n     *   for the AIMessage content, allowing custom error formatting.\n     *\n     * Deprecated values:\n     * - `\"raise\"`: use `\"error\"` instead.\n     * - `\"return_message\"`: use `\"continue\"` instead.\n     */\n    onFailure: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<\"error\">, z.ZodLiteral<\"continue\">, z.ZodLiteral<\"raise\">, z.ZodLiteral<\"return_message\">, z.ZodFunction<z.ZodTuple<[z.ZodType<Error, z.ZodTypeDef, Error>], z.ZodUnknown>, z.ZodString>]>>;\n} & {\n    maxRetries: z.ZodDefault<z.ZodNumber>;\n    retryOn: z.ZodDefault<z.ZodUnion<[z.ZodFunction<z.ZodTuple<[z.ZodType<Error, z.ZodTypeDef, Error>], z.ZodUnknown>, z.ZodBoolean>, z.ZodArray<z.ZodType<new (...args: any[]) => Error, z.ZodTypeDef, new (...args: any[]) => Error>, \"many\">]>>;\n    backoffFactor: z.ZodDefault<z.ZodNumber>;\n    initialDelayMs: z.ZodDefault<z.ZodNumber>;\n    maxDelayMs: z.ZodDefault<z.ZodNumber>;\n    jitter: z.ZodDefault<z.ZodBoolean>;\n}, \"strip\", z.ZodTypeAny, {\n    maxRetries: number;\n    retryOn: (new (...args: any[]) => Error)[] | ((args_0: Error, ...args: unknown[]) => boolean);\n    backoffFactor: number;\n    initialDelayMs: number;\n    maxDelayMs: number;\n    jitter: boolean;\n    tools?: (string | ServerTool | ClientTool)[] | undefined;\n    onFailure: \"continue\" | \"error\" | \"raise\" | \"return_message\" | ((args_0: Error, ...args: unknown[]) => string);\n}, {\n    maxRetries?: number | undefined;\n    retryOn?: (new (...args: any[]) => Error)[] | ((args_0: Error, ...args: unknown[]) => boolean) | undefined;\n    backoffFactor?: number | undefined;\n    initialDelayMs?: number | undefined;\n    maxDelayMs?: number | undefined;\n    jitter?: boolean | undefined;\n    tools?: (string | ServerTool | ClientTool)[] | undefined;\n    onFailure?: \"continue\" | \"error\" | \"raise\" | \"return_message\" | ((args_0: Error, ...args: unknown[]) => string) | undefined;\n}>;\nexport type ToolRetryMiddlewareConfig = z.input<typeof ToolRetryMiddlewareOptionsSchema>;\n/**\n * Middleware that automatically retries failed tool calls with configurable backoff.\n *\n * Supports retrying on specific exceptions and exponential backoff.\n *\n * @example Basic usage with default settings (2 retries, exponential backoff)\n * ```ts\n * import { createAgent, toolRetryMiddleware } from \"langchain\";\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [searchTool],\n *   middleware: [toolRetryMiddleware()],\n * });\n * ```\n *\n * @example Retry specific exceptions only\n * ```ts\n * import { toolRetryMiddleware } from \"langchain\";\n *\n * const retry = toolRetryMiddleware({\n *   maxRetries: 4,\n *   retryOn: [TimeoutError, NetworkError],\n *   backoffFactor: 1.5,\n * });\n * ```\n *\n * @example Custom exception filtering\n * ```ts\n * function shouldRetry(error: Error): boolean {\n *   // Only retry on 5xx errors\n *   if (error.name === \"HTTPError\" && \"statusCode\" in error) {\n *     const statusCode = (error as any).statusCode;\n *     return 500 <= statusCode && statusCode < 600;\n *   }\n *   return false;\n * }\n *\n * const retry = toolRetryMiddleware({\n *   maxRetries: 3,\n *   retryOn: shouldRetry,\n * });\n * ```\n *\n * @example Apply to specific tools with custom error handling\n * ```ts\n * const formatError = (error: Error) =>\n *   \"Database temporarily unavailable. Please try again later.\";\n *\n * const retry = toolRetryMiddleware({\n *   maxRetries: 4,\n *   tools: [\"search_database\"],\n *   onFailure: formatError,\n * });\n * ```\n *\n * @example Apply to specific tools using BaseTool instances\n * ```ts\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n *\n * const searchDatabase = tool(\n *   async ({ query }) => {\n *     // Search implementation\n *     return results;\n *   },\n *   {\n *     name: \"search_database\",\n *     description: \"Search the database\",\n *     schema: z.object({ query: z.string() }),\n *   }\n * );\n *\n * const retry = toolRetryMiddleware({\n *   maxRetries: 4,\n *   tools: [searchDatabase], // Pass BaseTool instance\n * });\n * ```\n *\n * @example Constant backoff (no exponential growth)\n * ```ts\n * const retry = toolRetryMiddleware({\n *   maxRetries: 5,\n *   backoffFactor: 0.0, // No exponential growth\n *   initialDelayMs: 2000, // Always wait 2 seconds\n * });\n * ```\n *\n * @example Raise exception on failure\n * ```ts\n * const retry = toolRetryMiddleware({\n *   maxRetries: 2,\n *   onFailure: \"raise\", // Re-raise exception instead of returning message\n * });\n * ```\n *\n * @param config - Configuration options for the retry middleware\n * @returns A middleware instance that handles tool failures with retries\n */\nexport declare function toolRetryMiddleware(config?: ToolRetryMiddlewareConfig): AgentMiddleware;\n//# sourceMappingURL=toolRetry.d.ts.map"],"mappings":"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"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolRetry.d.ts","names":["z","ClientTool","ServerTool","AgentMiddleware","ToolRetryMiddlewareOptionsSchema","ZodTypeDef","ZodType","ZodString","ZodUnion","ZodArray","ZodOptional","ZodLiteral","Error","ZodUnknown","ZodTuple","ZodFunction","ZodDefault","ZodNumber","ZodBoolean","ZodTypeAny","ZodObject","ToolRetryMiddlewareConfig","input","toolRetryMiddleware"],"sources":["../../../src/agents/middleware/toolRetry.d.ts"],"sourcesContent":["/**\n * Tool retry middleware for agents.\n */\nimport { z } from \"zod/v3\";\nimport type { ClientTool, ServerTool } from \"@langchain/core/tools\";\nimport type { AgentMiddleware } from \"./types.js\";\n/**\n * Configuration options for the Tool Retry Middleware.\n */\nexport declare const ToolRetryMiddlewareOptionsSchema: z.ZodObject<{\n    /**\n     * Optional list of tools or tool names to apply retry logic to.\n     * Can be a list of `BaseTool` instances or tool name strings.\n     * If `undefined`, applies to all tools. Default is `undefined`.\n     */\n    tools: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodType<ClientTool, z.ZodTypeDef, ClientTool>, z.ZodType<ServerTool, z.ZodTypeDef, ServerTool>, z.ZodString]>, \"many\">>;\n    /**\n     * Behavior when all retries are exhausted. Options:\n     * - `\"continue\"` (default): Return an AIMessage with error details, allowing\n     *   the agent to potentially handle the failure gracefully.\n     * - `\"error\"`: Re-raise the exception, stopping agent execution.\n     * - Custom function: Function that takes the exception and returns a string\n     *   for the AIMessage content, allowing custom error formatting.\n     *\n     * Deprecated values:\n     * - `\"raise\"`: use `\"error\"` instead.\n     * - `\"return_message\"`: use `\"continue\"` instead.\n     */\n    onFailure: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<\"error\">, z.ZodLiteral<\"continue\">, z.ZodLiteral<\"raise\">, z.ZodLiteral<\"return_message\">, z.ZodFunction<z.ZodTuple<[z.ZodType<Error, z.ZodTypeDef, Error>], z.ZodUnknown>, z.ZodString>]>>;\n} & {\n    maxRetries: z.ZodDefault<z.ZodNumber>;\n    retryOn: z.ZodDefault<z.ZodUnion<[z.ZodFunction<z.ZodTuple<[z.ZodType<Error, z.ZodTypeDef, Error>], z.ZodUnknown>, z.ZodBoolean>, z.ZodArray<z.ZodType<new (...args: any[]) => Error, z.ZodTypeDef, new (...args: any[]) => Error>, \"many\">]>>;\n    backoffFactor: z.ZodDefault<z.ZodNumber>;\n    initialDelayMs: z.ZodDefault<z.ZodNumber>;\n    maxDelayMs: z.ZodDefault<z.ZodNumber>;\n    jitter: z.ZodDefault<z.ZodBoolean>;\n}, \"strip\", z.ZodTypeAny, {\n    maxRetries: number;\n    retryOn: (new (...args: any[]) => Error)[] | ((args_0: Error, ...args: unknown[]) => boolean);\n    backoffFactor: number;\n    initialDelayMs: number;\n    maxDelayMs: number;\n    jitter: boolean;\n    tools?: (string | ServerTool | ClientTool)[] | undefined;\n    onFailure: \"continue\" | \"error\" | \"raise\" | \"return_message\" | ((args_0: Error, ...args: unknown[]) => string);\n}, {\n    maxRetries?: number | undefined;\n    retryOn?: (new (...args: any[]) => Error)[] | ((args_0: Error, ...args: unknown[]) => boolean) | undefined;\n    backoffFactor?: number | undefined;\n    initialDelayMs?: number | undefined;\n    maxDelayMs?: number | undefined;\n    jitter?: boolean | undefined;\n    tools?: (string | ServerTool | ClientTool)[] | undefined;\n    onFailure?: \"continue\" | \"error\" | \"raise\" | \"return_message\" | ((args_0: Error, ...args: unknown[]) => string) | undefined;\n}>;\nexport type ToolRetryMiddlewareConfig = z.input<typeof ToolRetryMiddlewareOptionsSchema>;\n/**\n * Middleware that automatically retries failed tool calls with configurable backoff.\n *\n * Supports retrying on specific exceptions and exponential backoff.\n *\n * @example Basic usage with default settings (2 retries, exponential backoff)\n * ```ts\n * import { createAgent, toolRetryMiddleware } from \"langchain\";\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [searchTool],\n *   middleware: [toolRetryMiddleware()],\n * });\n * ```\n *\n * @example Retry specific exceptions only\n * ```ts\n * import { toolRetryMiddleware } from \"langchain\";\n *\n * const retry = toolRetryMiddleware({\n *   maxRetries: 4,\n *   retryOn: [TimeoutError, NetworkError],\n *   backoffFactor: 1.5,\n * });\n * ```\n *\n * @example Custom exception filtering\n * ```ts\n * function shouldRetry(error: Error): boolean {\n *   // Only retry on 5xx errors\n *   if (error.name === \"HTTPError\" && \"statusCode\" in error) {\n *     const statusCode = (error as any).statusCode;\n *     return 500 <= statusCode && statusCode < 600;\n *   }\n *   return false;\n * }\n *\n * const retry = toolRetryMiddleware({\n *   maxRetries: 3,\n *   retryOn: shouldRetry,\n * });\n * ```\n *\n * @example Apply to specific tools with custom error handling\n * ```ts\n * const formatError = (error: Error) =>\n *   \"Database temporarily unavailable. Please try again later.\";\n *\n * const retry = toolRetryMiddleware({\n *   maxRetries: 4,\n *   tools: [\"search_database\"],\n *   onFailure: formatError,\n * });\n * ```\n *\n * @example Apply to specific tools using BaseTool instances\n * ```ts\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n *\n * const searchDatabase = tool(\n *   async ({ query }) => {\n *     // Search implementation\n *     return results;\n *   },\n *   {\n *     name: \"search_database\",\n *     description: \"Search the database\",\n *     schema: z.object({ query: z.string() }),\n *   }\n * );\n *\n * const retry = toolRetryMiddleware({\n *   maxRetries: 4,\n *   tools: [searchDatabase], // Pass BaseTool instance\n * });\n * ```\n *\n * @example Constant backoff (no exponential growth)\n * ```ts\n * const retry = toolRetryMiddleware({\n *   maxRetries: 5,\n *   backoffFactor: 0.0, // No exponential growth\n *   initialDelayMs: 2000, // Always wait 2 seconds\n * });\n * ```\n *\n * @example Raise exception on failure\n * ```ts\n * const retry = toolRetryMiddleware({\n *   maxRetries: 2,\n *   onFailure: \"raise\", // Re-raise exception instead of returning message\n * });\n * ```\n *\n * @param config - Configuration options for the retry middleware\n * @returns A middleware instance that handles tool failures with retries\n */\nexport declare function toolRetryMiddleware(config?: ToolRetryMiddlewareConfig): AgentMiddleware;\n//# sourceMappingURL=toolRetry.d.ts.map"],"mappings":"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"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","names":["InteropZodObject","InteropZodDefault","InteropZodOptional","InferInteropZodInput","InferInteropZodOutput","InteropZodToStateDefinition","AnnotationRoot","AIMessage","SystemMessage","ToolMessage","ToolCall","Command","ClientTool","ServerTool","JumpToTarget","Runtime","AgentBuiltInState","ModelRequest","PromiseOrValue","T","Promise","AnyAnnotationRoot","NormalizedSchemaInput","TSchema","Record","MiddlewareResult","TState","ToolCallRequest","TContext","ToolCallHandler","WrapToolCallHook","WrapModelCallHandler","Omit","WrapModelCallHook","BeforeAgentHandler","Partial","BeforeAgentHook","BeforeModelHandler","BeforeModelHook","AfterModelHandler","AfterModelHook","AfterAgentHandler","AfterAgentHook","AgentMiddleware","TContextSchema","TFullContext","FilterPrivateProps","K","InferChannelType","ToAnnotationRoot","InferMiddlewareState","S","InferMiddlewareInputState","InferMiddlewareStates","First","Rest","InferMiddlewareInputStates","InferMergedState","InferMergedInputState","InferMiddlewareContext","C","InferMiddlewareContextInput","Inner","InferMiddlewareContexts","MergeContextTypes","A","B","InferMiddlewareContextInputs","InferContextInput","ContextSchema","InferSchemaInput"],"sources":["../../../src/agents/middleware/types.d.ts"],"sourcesContent":["import type { InteropZodObject, InteropZodDefault, InteropZodOptional, InferInteropZodInput, InferInteropZodOutput } from \"@langchain/core/utils/types\";\nimport type { InteropZodToStateDefinition } from \"@langchain/langgraph/zod\";\nimport type { AnnotationRoot } from \"@langchain/langgraph\";\nimport type { AIMessage, SystemMessage, ToolMessage } from \"@langchain/core/messages\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport type { Command } from \"@langchain/langgraph\";\nimport type { ClientTool, ServerTool } from \"@langchain/core/tools\";\nimport type { JumpToTarget } from \"../constants.js\";\nimport type { Runtime, AgentBuiltInState } from \"../runtime.js\";\nimport type { ModelRequest } from \"../nodes/types.js\";\ntype PromiseOrValue<T> = T | Promise<T>;\nexport type AnyAnnotationRoot = AnnotationRoot<any>;\nexport type NormalizedSchemaInput<TSchema extends InteropZodObject | undefined | never = any> = [TSchema] extends [never] ? AgentBuiltInState : TSchema extends InteropZodObject ? InferInteropZodOutput<TSchema> & AgentBuiltInState : TSchema extends Record<string, unknown> ? TSchema & AgentBuiltInState : AgentBuiltInState;\n/**\n * Result type for middleware functions.\n */\nexport type MiddlewareResult<TState> = (TState & {\n    jumpTo?: JumpToTarget;\n}) | void;\n/**\n * Represents a tool call request for the wrapToolCall hook.\n * Contains the tool call information along with the agent's current state and runtime.\n */\nexport interface ToolCallRequest<TState extends Record<string, unknown> = Record<string, unknown>, TContext = unknown> {\n    /**\n     * The tool call to be executed\n     */\n    toolCall: ToolCall;\n    /**\n     * The BaseTool instance being invoked.\n     * Provides access to tool metadata like name, description, schema, etc.\n     */\n    tool: ClientTool | ServerTool;\n    /**\n     * The current agent state (includes both middleware state and built-in state).\n     */\n    state: TState & AgentBuiltInState;\n    /**\n     * The runtime context containing metadata, signal, writer, interrupt, etc.\n     */\n    runtime: Runtime<TContext>;\n}\n/**\n * Handler function type for wrapping tool calls.\n * Takes a tool call request and returns the tool result or a command.\n */\nexport type ToolCallHandler<TSchema extends Record<string, unknown> = AgentBuiltInState, TContext = unknown> = (request: ToolCallRequest<TSchema, TContext>) => PromiseOrValue<ToolMessage | Command>;\n/**\n * Wrapper function type for the wrapToolCall hook.\n * Allows middleware to intercept and modify tool execution.\n */\nexport type WrapToolCallHook<TSchema extends InteropZodObject | undefined = undefined, TContext = unknown> = (request: ToolCallRequest<NormalizedSchemaInput<TSchema>, TContext>, handler: ToolCallHandler<NormalizedSchemaInput<TSchema>, TContext>) => PromiseOrValue<ToolMessage | Command>;\n/**\n * Handler function type for wrapping model calls.\n * Takes a model request and returns the AI message response.\n *\n * @param request - The model request containing model, messages, systemPrompt, tools, state, and runtime\n * @returns The AI message response from the model\n */\nexport type WrapModelCallHandler<TSchema extends InteropZodObject | undefined = undefined, TContext = unknown> = (request: Omit<ModelRequest<NormalizedSchemaInput<TSchema>, TContext>, \n/**\n * allow to reset the system prompt or system message\n */\n\"systemPrompt\" | \"systemMessage\"> & {\n    systemPrompt?: string;\n    systemMessage?: SystemMessage;\n}) => PromiseOrValue<AIMessage>;\n/**\n * Wrapper function type for the wrapModelCall hook.\n * Allows middleware to intercept and modify model execution.\n * This enables you to:\n * - Modify the request before calling the model (e.g., change system prompt, add/remove tools)\n * - Handle errors and retry with different parameters\n * - Post-process the response\n * - Implement custom caching, logging, or other cross-cutting concerns\n *\n * @param request - The model request containing all parameters needed for the model call\n * @param handler - The function that invokes the model. Call this with a ModelRequest to get the response\n * @returns The AI message response from the model (or a modified version)\n */\nexport type WrapModelCallHook<TSchema extends InteropZodObject | undefined = undefined, TContext = unknown> = (request: ModelRequest<NormalizedSchemaInput<TSchema>, TContext>, handler: WrapModelCallHandler<TSchema, TContext>) => PromiseOrValue<AIMessage>;\n/**\n * Handler function type for the beforeAgent hook.\n * Called once at the start of agent invocation before any model calls or tool executions.\n *\n * @param state - The current agent state (includes both middleware state and built-in state)\n * @param runtime - The runtime context containing metadata, signal, writer, interrupt, etc.\n * @returns A middleware result containing partial state updates or undefined to pass through\n */\ntype BeforeAgentHandler<TSchema, TContext> = (state: TSchema, runtime: Runtime<TContext>) => PromiseOrValue<MiddlewareResult<Partial<TSchema>>>;\n/**\n * Hook type for the beforeAgent lifecycle event.\n * Can be either a handler function or an object with a handler and optional jump targets.\n * This hook is called once at the start of the agent invocation.\n */\nexport type BeforeAgentHook<TSchema extends InteropZodObject | undefined = undefined, TContext = unknown> = BeforeAgentHandler<NormalizedSchemaInput<TSchema>, TContext> | {\n    hook: BeforeAgentHandler<NormalizedSchemaInput<TSchema>, TContext>;\n    canJumpTo?: JumpToTarget[];\n};\n/**\n * Handler function type for the beforeModel hook.\n * Called before the model is invoked and before the wrapModelCall hook.\n *\n * @param state - The current agent state (includes both middleware state and built-in state)\n * @param runtime - The runtime context containing metadata, signal, writer, interrupt, etc.\n * @returns A middleware result containing partial state updates or undefined to pass through\n */\ntype BeforeModelHandler<TSchema, TContext> = (state: TSchema, runtime: Runtime<TContext>) => PromiseOrValue<MiddlewareResult<Partial<TSchema>>>;\n/**\n * Hook type for the beforeModel lifecycle event.\n * Can be either a handler function or an object with a handler and optional jump targets.\n * This hook is called before each model invocation.\n */\nexport type BeforeModelHook<TSchema extends InteropZodObject | undefined = undefined, TContext = unknown> = BeforeModelHandler<NormalizedSchemaInput<TSchema>, TContext> | {\n    hook: BeforeModelHandler<NormalizedSchemaInput<TSchema>, TContext>;\n    canJumpTo?: JumpToTarget[];\n};\n/**\n * Handler function type for the afterModel hook.\n * Called after the model is invoked and before any tools are called.\n * Allows modifying the agent state after model invocation, e.g., to update tool call parameters.\n *\n * @param state - The current agent state (includes both middleware state and built-in state)\n * @param runtime - The runtime context containing metadata, signal, writer, interrupt, etc.\n * @returns A middleware result containing partial state updates or undefined to pass through\n */\ntype AfterModelHandler<TSchema, TContext> = (state: TSchema, runtime: Runtime<TContext>) => PromiseOrValue<MiddlewareResult<Partial<TSchema>>>;\n/**\n * Hook type for the afterModel lifecycle event.\n * Can be either a handler function or an object with a handler and optional jump targets.\n * This hook is called after each model invocation.\n */\nexport type AfterModelHook<TSchema extends InteropZodObject | undefined = undefined, TContext = unknown> = AfterModelHandler<NormalizedSchemaInput<TSchema>, TContext> | {\n    hook: AfterModelHandler<NormalizedSchemaInput<TSchema>, TContext>;\n    canJumpTo?: JumpToTarget[];\n};\n/**\n * Handler function type for the afterAgent hook.\n * Called once at the end of agent invocation after all model calls and tool executions are complete.\n *\n * @param state - The current agent state (includes both middleware state and built-in state)\n * @param runtime - The runtime context containing metadata, signal, writer, interrupt, etc.\n * @returns A middleware result containing partial state updates or undefined to pass through\n */\ntype AfterAgentHandler<TSchema, TContext> = (state: TSchema, runtime: Runtime<TContext>) => PromiseOrValue<MiddlewareResult<Partial<TSchema>>>;\n/**\n * Hook type for the afterAgent lifecycle event.\n * Can be either a handler function or an object with a handler and optional jump targets.\n * This hook is called once at the end of the agent invocation.\n */\nexport type AfterAgentHook<TSchema extends InteropZodObject | undefined = undefined, TContext = unknown> = AfterAgentHandler<NormalizedSchemaInput<TSchema>, TContext> | {\n    hook: AfterAgentHandler<NormalizedSchemaInput<TSchema>, TContext>;\n    canJumpTo?: JumpToTarget[];\n};\n/**\n * Base middleware interface.\n */\nexport interface AgentMiddleware<TSchema extends InteropZodObject | undefined = any, TContextSchema extends InteropZodObject | InteropZodDefault<InteropZodObject> | InteropZodOptional<InteropZodObject> | undefined = any, TFullContext = any> {\n    /**\n     * The name of the middleware.\n     */\n    name: string;\n    /**\n     * The schema of the middleware state. Middleware state is persisted between multiple invocations. It can be either:\n     * - A Zod object\n     * - A Zod optional object\n     * - A Zod default object\n     * - Undefined\n     */\n    stateSchema?: TSchema;\n    /**\n     * The schema of the middleware context. Middleware context is read-only and not persisted between multiple invocations. It can be either:\n     * - A Zod object\n     * - A Zod optional object\n     * - A Zod default object\n     * - Undefined\n     */\n    contextSchema?: TContextSchema;\n    /**\n     * Additional tools registered by the middleware.\n     */\n    tools?: (ClientTool | ServerTool)[];\n    /**\n     * Wraps tool execution with custom logic. This allows you to:\n     * - Modify tool call parameters before execution\n     * - Handle errors and retry with different parameters\n     * - Post-process tool results\n     * - Implement caching, logging, authentication, or other cross-cutting concerns\n     * - Return Command objects for advanced control flow\n     *\n     * The handler receives a ToolCallRequest containing the tool call, state, and runtime,\n     * along with a handler function to execute the actual tool.\n     *\n     * @param request - The tool call request containing toolCall, state, and runtime.\n     * @param handler - The function that executes the tool. Call this with a ToolCallRequest to get the result.\n     * @returns The tool result as a ToolMessage or a Command for advanced control flow.\n     *\n     * @example\n     * ```ts\n     * wrapToolCall: async (request, handler) => {\n     *   console.log(`Calling tool: ${request.tool.name}`);\n     *   console.log(`Tool description: ${request.tool.description}`);\n     *\n     *   try {\n     *     // Execute the tool\n     *     const result = await handler(request);\n     *     console.log(`Tool ${request.tool.name} succeeded`);\n     *     return result;\n     *   } catch (error) {\n     *     console.error(`Tool ${request.tool.name} failed:`, error);\n     *     // Could return a custom error message or retry\n     *     throw error;\n     *   }\n     * }\n     * ```\n     *\n     * @example Authentication\n     * ```ts\n     * wrapToolCall: async (request, handler) => {\n     *   // Check if user is authorized for this tool\n     *   if (!request.runtime.context.isAuthorized(request.tool.name)) {\n     *     return new ToolMessage({\n     *       content: \"Unauthorized to call this tool\",\n     *       tool_call_id: request.toolCall.id,\n     *     });\n     *   }\n     *   return handler(request);\n     * }\n     * ```\n     *\n     * @example Caching\n     * ```ts\n     * const cache = new Map();\n     * wrapToolCall: async (request, handler) => {\n     *   const cacheKey = `${request.tool.name}:${JSON.stringify(request.toolCall.args)}`;\n     *   if (cache.has(cacheKey)) {\n     *     return cache.get(cacheKey);\n     *   }\n     *   const result = await handler(request);\n     *   cache.set(cacheKey, result);\n     *   return result;\n     * }\n     * ```\n     */\n    wrapToolCall?: WrapToolCallHook<TSchema, TFullContext>;\n    /**\n     * Wraps the model invocation with custom logic. This allows you to:\n     * - Modify the request before calling the model\n     * - Handle errors and retry with different parameters\n     * - Post-process the response\n     * - Implement custom caching, logging, or other cross-cutting concerns\n     *\n     * @param request - The model request containing model, messages, systemPrompt, tools, state, and runtime.\n     * @param handler - The function that invokes the model. Call this with a ModelRequest to get the response.\n     * @returns The response from the model (or a modified version).\n     *\n     * @example\n     * ```ts\n     * wrapModelCall: async (request, handler) => {\n     *   // Modify request before calling\n     *   const modifiedRequest = { ...request, systemPrompt: \"You are helpful\" };\n     *\n     *   try {\n     *     // Call the model\n     *     return await handler(modifiedRequest);\n     *   } catch (error) {\n     *     // Handle errors and retry with fallback\n     *     const fallbackRequest = { ...request, model: fallbackModel };\n     *     return await handler(fallbackRequest);\n     *   }\n     * }\n     * ```\n     */\n    wrapModelCall?: WrapModelCallHook<TSchema, TFullContext>;\n    /**\n     * The function to run before the agent execution starts. This function is called once at the start of the agent invocation.\n     * It allows to modify the state of the agent before any model calls or tool executions.\n     *\n     * @param state - The middleware state\n     * @param runtime - The middleware runtime\n     * @returns The modified middleware state or undefined to pass through\n     */\n    beforeAgent?: BeforeAgentHook<TSchema, TFullContext>;\n    /**\n     * The function to run before the model call. This function is called before the model is invoked and before the `wrapModelCall` hook.\n     * It allows to modify the state of the agent.\n     *\n     * @param state - The middleware state\n     * @param runtime - The middleware runtime\n     * @returns The modified middleware state or undefined to pass through\n     */\n    beforeModel?: BeforeModelHook<TSchema, TFullContext>;\n    /**\n     * The function to run after the model call. This function is called after the model is invoked and before any tools are called.\n     * It allows to modify the state of the agent after the model is invoked, e.g. to update tool call parameters.\n     *\n     * @param state - The middleware state\n     * @param runtime - The middleware runtime\n     * @returns The modified middleware state or undefined to pass through\n     */\n    afterModel?: AfterModelHook<TSchema, TFullContext>;\n    /**\n     * The function to run after the agent execution completes. This function is called once at the end of the agent invocation.\n     * It allows to modify the final state of the agent after all model calls and tool executions are complete.\n     *\n     * @param state - The middleware state\n     * @param runtime - The middleware runtime\n     * @returns The modified middleware state or undefined to pass through\n     */\n    afterAgent?: AfterAgentHook<TSchema, TFullContext>;\n}\n/**\n * Helper type to filter out properties that start with underscore (private properties)\n */\ntype FilterPrivateProps<T> = {\n    [K in keyof T as K extends `_${string}` ? never : K]: T[K];\n};\nexport type InferChannelType<T extends AnyAnnotationRoot | InteropZodObject> = T extends AnyAnnotationRoot ? ToAnnotationRoot<T>[\"State\"] : T extends InteropZodObject ? InferInteropZodInput<T> : {};\n/**\n * Helper type to infer the state schema type from a middleware\n * This filters out private properties (those starting with underscore)\n */\nexport type InferMiddlewareState<T extends AgentMiddleware> = T extends AgentMiddleware<infer S, any, any> ? S extends InteropZodObject ? FilterPrivateProps<InferInteropZodOutput<S>> : {} : {};\n/**\n * Helper type to infer the input state schema type from a middleware (all properties optional)\n * This filters out private properties (those starting with underscore)\n */\nexport type InferMiddlewareInputState<T extends AgentMiddleware> = T extends AgentMiddleware<infer S, any, any> ? S extends InteropZodObject ? FilterPrivateProps<InferInteropZodInput<S>> : {} : {};\n/**\n * Helper type to infer merged state from an array of middleware (just the middleware states)\n */\nexport type InferMiddlewareStates<T = AgentMiddleware[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware ? Rest extends readonly AgentMiddleware[] ? InferMiddlewareState<First> & InferMiddlewareStates<Rest> : InferMiddlewareState<First> : {} : {};\n/**\n * Helper type to infer merged input state from an array of middleware (with optional defaults)\n */\nexport type InferMiddlewareInputStates<T extends readonly AgentMiddleware[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware ? Rest extends readonly AgentMiddleware[] ? InferMiddlewareInputState<First> & InferMiddlewareInputStates<Rest> : InferMiddlewareInputState<First> : {} : {};\n/**\n * Helper type to infer merged state from an array of middleware (includes built-in state)\n */\nexport type InferMergedState<T extends readonly AgentMiddleware[]> = InferMiddlewareStates<T> & AgentBuiltInState;\n/**\n * Helper type to infer merged input state from an array of middleware (includes built-in state)\n */\nexport type InferMergedInputState<T extends readonly AgentMiddleware[]> = InferMiddlewareInputStates<T> & AgentBuiltInState;\n/**\n * Helper type to infer the context schema type from a middleware\n */\nexport type InferMiddlewareContext<T extends AgentMiddleware> = T extends AgentMiddleware<any, infer C, any> ? C extends InteropZodObject ? InferInteropZodInput<C> : {} : {};\n/**\n * Helper type to infer the input context schema type from a middleware (with optional defaults)\n */\nexport type InferMiddlewareContextInput<T extends AgentMiddleware> = T extends AgentMiddleware<any, infer C, any> ? C extends InteropZodOptional<infer Inner> ? InferInteropZodInput<Inner> | undefined : C extends InteropZodObject ? InferInteropZodInput<C> : {} : {};\n/**\n * Helper type to infer merged context from an array of middleware\n */\nexport type InferMiddlewareContexts<T extends readonly AgentMiddleware[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware ? Rest extends readonly AgentMiddleware[] ? InferMiddlewareContext<First> & InferMiddlewareContexts<Rest> : InferMiddlewareContext<First> : {} : {};\n/**\n * Helper to merge two context types, preserving undefined unions\n */\ntype MergeContextTypes<A, B> = [A] extends [undefined] ? [B] extends [undefined] ? undefined : B | undefined : [B] extends [undefined] ? A | undefined : [A] extends [B] ? A : [B] extends [A] ? B : A & B;\n/**\n * Helper type to infer merged input context from an array of middleware (with optional defaults)\n */\nexport type InferMiddlewareContextInputs<T extends readonly AgentMiddleware[]> = T extends readonly [] ? {} : T extends readonly [infer First, ...infer Rest] ? First extends AgentMiddleware ? Rest extends readonly AgentMiddleware[] ? MergeContextTypes<InferMiddlewareContextInput<First>, InferMiddlewareContextInputs<Rest>> : InferMiddlewareContextInput<First> : {} : {};\n/**\n * Helper type to extract input type from context schema (with optional defaults)\n */\nexport type InferContextInput<ContextSchema extends AnyAnnotationRoot | InteropZodObject> = ContextSchema extends InteropZodObject ? InferInteropZodInput<ContextSchema> : ContextSchema extends AnyAnnotationRoot ? ToAnnotationRoot<ContextSchema>[\"State\"] : {};\nexport type ToAnnotationRoot<A extends AnyAnnotationRoot | InteropZodObject> = A extends AnyAnnotationRoot ? A : A extends InteropZodObject ? AnnotationRoot<InteropZodToStateDefinition<A>> : never;\nexport type InferSchemaInput<A extends AnyAnnotationRoot | InteropZodObject | undefined> = A extends AnyAnnotationRoot | InteropZodObject ? ToAnnotationRoot<A>[\"State\"] : {};\nexport {};\n//# sourceMappingURL=types.d.ts.map"],"mappings":";;;;;;;;;;;KAUKkB,oBAAoBC,IAAIC,QAAQD;AAAhCD,KACOG,iBAAAA,GAAoBf,cADb,CAAA,GAAA,CAAA;AAAMa,KAEbG,qBAFaH,CAAAA,gBAEyBnB,gBAFzBmB,GAAAA,SAAAA,GAAAA,KAAAA,GAAAA,GAAAA,CAAAA,GAAAA,CAEwEI,OAFxEJ,CAAAA,SAAAA,CAAAA,KAAAA,CAAAA,GAEmGH,iBAFnGG,GAEuHI,OAFvHJ,SAEuInB,gBAFvImB,GAE0Jf,qBAF1Je,CAEgLI,OAFhLJ,CAAAA,GAE2LH,iBAF3LG,GAE+MI,OAF/MJ,SAE+NK,MAF/NL,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,GAEyPI,OAFzPJ,GAEmQH,iBAFnQG,GAEuRH,iBAFvRG;;;AAAW;AACxBE,KAKAI,gBALiB,CAAA,MAAA,CAAA,GAAGnB,CAKQoB,MALRpB,GAAAA;EACpBgB,MAAAA,CAAAA,EAKCR,YALDQ;CAAsCtB,CAAAA,GAAAA,IAAAA;;;;;AAAuJuB,UAWxLI,eAXwLJ,CAAAA,eAWzJC,MAXyJD,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,GAW/HC,MAX+HD,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EAAAA,WAAAA,OAAAA,CAAAA,CAAAA;EAAtBnB;;;EAAqEoB,QAAAA,EAe1Od,UAf0Oc;EAA0BD;;;AAA+C;EAIrTE,IAAAA,EAgBFb,UAhBEa,GAgBWZ,UAhBKa;EAOXC;;;EAIHjB,KAAAA,EASHgB,MATGhB,GASMM,iBATNN;EAKJE;;;EAIUI,OAAAA,EAIPD,OAJOC,CAICY,QAJDZ,CAAAA;;;AAIA;AAMpB;;AAAsEA,KAA1Da,eAA0Db,CAAAA,gBAA1BQ,MAA0BR,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,GAAAA,iBAAAA,EAAAA,WAAAA,OAAAA,CAAAA,GAAAA,CAAAA,OAAAA,EAAmDW,eAAnDX,CAAmEO,OAAnEP,EAA4EY,QAA5EZ,CAAAA,EAAAA,GAA0FE,cAA1FF,CAAyGP,WAAzGO,GAAuHL,OAAvHK,CAAAA;;;;;AAAuHL,KAKjLmB,gBALiLnB,CAAAA,gBAKhJX,gBALgJW,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,WAAAA,OAAAA,CAAAA,GAAAA,CAAAA,OAAAA,EAKtEgB,eALsEhB,CAKtDW,qBALsDX,CAKhCY,OALgCZ,CAAAA,EAKtBiB,QALsBjB,CAAAA,EAAAA,OAAAA,EAKFkB,eALElB,CAKcW,qBALdX,CAKoCY,OALpCZ,CAAAA,EAK8CiB,QAL9CjB,CAAAA,EAAAA,GAK4DO,cAL5DP,CAK2EF,WAL3EE,GAKyFA,OALzFA,CAAAA;;AAAf;AAK9K;;;;;AAAuHgB,KAQ3GI,oBAR2GJ,CAAAA,gBAQtE3B,gBARsE2B,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,WAAAA,OAAAA,CAAAA,GAAAA,CAAAA,OAAAA,EAQIK,IARJL,CAQSV,YARTU,CAQsBL,qBARtBK,CAQ4CJ,OAR5CI,CAAAA,EAQsDC,QARtDD,CAAAA;;;;cAAoEE,GAAAA,eAAAA,CAAAA,GAAAA;EAA6EpB,YAAAA,CAAAA,EAAAA,MAAAA;EAAcE,aAAAA,CAAAA,EAclQH,aAdkQG;CAA7BO,EAAAA,GAenPA,cAfmPA,CAepOX,SAfoOW,CAAAA;AAAc;AAQvQ;;;;;;;;;;AAOoB;AAcpB;AAA8ClB,KAAlCiC,iBAAkCjC,CAAAA,gBAAAA,gBAAAA,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,WAAAA,OAAAA,CAAAA,GAAAA,CAAAA,OAAAA,EAA0EiB,YAA1EjB,CAAuFsB,qBAAvFtB,CAA6GuB,OAA7GvB,CAAAA,EAAuH4B,QAAvH5B,CAAAA,EAAAA,OAAAA,EAA2I+B,oBAA3I/B,CAAgKuB,OAAhKvB,EAAyK4B,QAAzK5B,CAAAA,EAAAA,GAAuLkB,cAAvLlB,CAAsMO,SAAtMP,CAAAA;;;;;;;;;KASzCkC,kBATgOhB,CAAAA,OAAAA,EAAAA,QAAAA,CAAAA,GAAAA,CAAAA,KAAAA,EAShLK,OATgLL,EAAAA,OAAAA,EAS9JH,OAT8JG,CAStJU,QATsJV,CAAAA,EAAAA,GASxIA,cATwIA,CASzHO,gBATyHP,CASxGiB,OATwGjB,CAShGK,OATgGL,CAAAA,CAAAA,CAAAA;AAAc;AAAY;;;;AAS1HK,KAMzHa,eANyHb,CAAAA,gBAMzFvB,gBANyFuB,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,WAAAA,OAAAA,CAAAA,GAMzBW,kBANyBX,CAMND,qBANMC,CAMgBA,OANhBA,CAAAA,EAM0BK,QAN1BL,CAAAA,GAAAA;EAARY,IAAAA,EAOnHD,kBAPmHC,CAOhGb,qBAPgGa,CAO1EZ,OAP0EY,CAAAA,EAOhEP,QAPgEO,CAAAA;EAAjBV,SAAAA,CAAAA,EAQ5FX,YAR4FW,EAAAA;CAAfP;AAAc;AAM3G;;;;;;;KAYKmB,kBAXwBf,CAAAA,OAAAA,EAAAA,QAAAA,CAAAA,GAAAA,CAAAA,KAAAA,EAWwBC,OAXxBD,EAAAA,OAAAA,EAW0CP,OAX1CO,CAWkDM,QAXlDN,CAAAA,EAAAA,GAWgEJ,cAXhEI,CAW+EG,gBAX/EH,CAWgGa,OAXhGb,CAWwGC,OAXxGD,CAAAA,CAAAA,CAAAA;;;;AACD;AAC1B;AASmDC,KAMzCe,eANyCf,CAAAA,gBAMTvB,gBANSuB,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,WAAAA,OAAAA,CAAAA,GAMuDc,kBANvDd,CAM0ED,qBAN1EC,CAMgGA,OANhGA,CAAAA,EAM0GK,QAN1GL,CAAAA,GAAAA;EAA0BK,IAAAA,EAOrES,kBAPqET,CAOlDN,qBAPkDM,CAO5BL,OAP4BK,CAAAA,EAOlBA,QAPkBA,CAAAA;EAARb,SAAAA,CAAAA,EAQvDD,YARuDC,EAAAA;CAA8DQ;;;;AAA1B;AAM3G;;;;;KAaKgB,iBAbuGF,CAAAA,OAAAA,EAAAA,QAAAA,CAAAA,GAAAA,CAAAA,KAAAA,EAaxDd,OAbwDc,EAAAA,OAAAA,EAatCtB,OAbsCsB,CAa9BT,QAb8BS,CAAAA,EAAAA,GAahBnB,cAbgBmB,CAaDZ,gBAbCY,CAagBF,OAbhBE,CAawBd,OAbxBc,CAAAA,CAAAA,CAAAA;;;;;;AAEhF,KAiBhBG,cAjBgB,CAAA,gBAiBexC,gBAjBf,GAAA,SAAA,GAAA,SAAA,EAAA,WAAA,OAAA,CAAA,GAiB+EuC,iBAjB/E,CAiBiGjB,qBAjBjG,CAiBuHC,OAjBvH,CAAA,EAiBiIK,QAjBjI,CAAA,GAAA;EAWvBW,IAAAA,EAOKA,iBAPY,CAOMjB,qBAPNM,CAO4BL,OAP5B,CAAA,EAOsCK,QAPtC,CAAA;EAA8BL,SAAAA,CAAAA,EAQpCT,YARoCS,EAAAA;CAA0BK;;;;;;AAA4B;AAM1G;;KAYKa,iBAZ8IlB,CAAAA,OAAAA,EAAAA,QAAAA,CAAAA,GAAAA,CAAAA,KAAAA,EAY/FA,OAZ+FA,EAAAA,OAAAA,EAY7ER,OAZ6EQ,CAYrEK,QAZqEL,CAAAA,EAAAA,GAYvDL,cAZuDK,CAYxCE,gBAZwCF,CAYvBY,OAZuBZ,CAYfA,OAZeA,CAAAA,CAAAA,CAAAA;;;;;;AACvFK,KAiBhDc,cAjBgDd,CAAAA,gBAiBjB5B,gBAjBiB4B,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,WAAAA,OAAAA,CAAAA,GAiB+Ca,iBAjB/Cb,CAiBiEN,qBAjBjEM,CAiBuFL,OAjBvFK,CAAAA,EAiBiGA,QAjBjGA,CAAAA,GAAAA;EAAlDW,IAAAA,EAkBAE,iBAlBAF,CAkBkBjB,qBAlBlBiB,CAkBwChB,OAlBxCgB,CAAAA,EAkBkDX,QAlBlDW,CAAAA;EACMzB,SAAAA,CAAAA,EAkBAA,YAlBAA,EAAAA;AAAY,CAAA;AAC1B;;;AASoEC,UAarD4B,eAbqD5B,CAAAA,gBAarBf,gBAbqBe,GAAAA,SAAAA,GAAAA,GAAAA,EAAAA,uBAasCf,gBAbtCe,GAayDd,iBAbzDc,CAa2Ef,gBAb3Ee,CAAAA,GAa+Fb,kBAb/Fa,CAakHf,gBAblHe,CAAAA,GAAAA,SAAAA,GAAAA,GAAAA,EAAAA,eAAAA,GAAAA,CAAAA,CAAAA;EAA8DQ;;;EAAxCL,IAAAA,EAAAA,MAAAA;EAAc;AAM1G;;;;;;EACkDK,WAAAA,CAAAA,EAkBhCA,OAlBgCA;EAAtBD;;;;AACA;AAK5B;;EAA4GtB,aAAAA,CAAAA,EAoBxF4C,cApBwF5C;EAAqCA;;;EAAoBE,KAAAA,CAAAA,EAAAA,CAwBxJU,UAxBwJV,GAwB3IW,UAxB2IX,CAAAA,EAAAA;EAYnJqB;;;;;;;;;;;;;;;;;;;;;;AA4Ia;AAC9B;;;;;;AAK4D;AAE7D;;;;;;;;;;;AAA6L;AAK7L;;;;;;;;;AAA4J;AAK5J;;;;;;;;;AAAiK;EAIrJ8B,YAAAA,CAAAA,EAvFOvB,gBAuFcX,CAvFGI,OAuFH,EAvFYsB,YAuFZ,CAAA;EAAKF;;;;;;;;;;;;;AAA8P;AAIpS;;;;;;;;;;;;;;EAAuU,aAAA,CAAA,EA9DnTV,iBA8DmT,CA9DjSV,OA8DiS,EA9DxRsB,YA8DwR,CAAA;EAI3TY;;;;;AAAqG;AAIjH;;EAAqGtC,WAAAA,CAAAA,EA7DnFiB,eA6DmFjB,CA7DnEI,OA6DmEJ,EA7D1D0B,YA6D0D1B,CAAAA;EAA3BqC;;AAAiD;AAI3H;;;;;EAAyHxD,WAAAA,CAAAA,EAxDvGsC,eAwDuGtC,CAxDvFuB,OAwDuFvB,EAxD9E6C,YAwD8E7C,CAAAA;EAAwC4D;;AAAD;AAIhK;;;;;EAA8H1D,UAAAA,CAAAA,EAnD7GsC,cAmD6GtC,CAnD9FqB,OAmD8FrB,EAnDrF2C,YAmDqF3C,CAAAA;EAAuD4D;;;;;;AAAsE;AAI3P;EAAuDnB,UAAAA,CAAAA,EA9CtCD,cA8CsCC,CA9CvBpB,OA8CuBoB,EA9CdE,YA8CcF,CAAAA;;;;;KAzClDG,kBAyCsLS,CAAAA,CAAAA,CAAAA,GAAAA,QAAsBZ,MAxCjMxB,CAwCiMwB,IAxC5LI,CAwC4LJ,SAAAA,IAAAA,MAAAA,EAAAA,GAAAA,KAAAA,GAxC3JI,CAwC2JJ,GAxCvJxB,CAwCuJwB,CAxCrJI,CAwCqJJ,CAAAA,EAA2CW;AAAvBK,KAtCzNX,gBAsCyNW,CAAAA,UAtC9LtC,iBAsC8LsC,GAtC1K3D,gBAsC0K2D,CAAAA,GAtCtJxC,CAsCsJwC,SAtC5ItC,iBAsC4IsC,GAtCxHV,gBAsCwHU,CAtCvGxC,CAsCuGwC,CAAAA,CAAAA,OAAAA,CAAAA,GAtCzFxC,CAsCyFwC,SAtC/E3D,gBAsC+E2D,GAtC5DxD,oBAsC4DwD,CAtCvCxC,CAsCuCwC,CAAAA,GAAAA,CAAAA,CAAAA;;;;;AAAsF,KAjC/ST,oBAiC+S,CAAA,UAjChRP,eAiCgR,CAAA,GAjC7PxB,CAiC6P,SAjCnPwB,eAiCmP,CAAA,KAAA,EAAA,EAAA,GAAA,EAAA,GAAA,CAAA,GAjC9MQ,CAiC8M,SAjCpMnD,gBAiCoM,GAjCjL8C,kBAiCiL,CAjC9J1C,qBAiC8J,CAjCxI+C,CAiCwI,CAAA,CAAA,GAAA,CAAA,CAAA,GAAA,CAAA,CAAA;AAAkB;;;;AAI7Ne,KAhCpGd,yBAgCoGc,CAAAA,UAhChEvB,eAgCgEuB,CAAAA,GAhC7C/C,CAgC6C+C,SAhCnCvB,eAgCmCuB,CAAAA,KAAAA,EAAAA,EAAAA,GAAAA,EAAAA,GAAAA,CAAAA,GAhCEf,CAgCFe,SAhCYlE,gBAgCZkE,GAhC+BpB,kBAgC/BoB,CAhCkD/D,oBAgClD+D,CAhCuEf,CAgCvEe,CAAAA,CAAAA,GAAAA,CAAAA,CAAAA,GAAAA,CAAAA,CAAAA;;;;AAA2DD,KA5B/JZ,qBA4B+JY,CAAAA,IA5BrItB,eA4BqIsB,EAAAA,CAAAA,GA5BhH9C,CA4BgH8C,SAAAA,SAAAA,EAAAA,GAAAA,CAAAA,CAAAA,GA5BnF9C,CA4BmF8C,SAAAA,SAAAA,CAAAA,KAAAA,MAAAA,EAAAA,GAAAA,KAAAA,KAAAA,CAAAA,GA5BjCX,KA4BiCW,SA5BnBtB,eA4BmBsB,GA5BDV,IA4BCU,SAAAA,SA5BqBtB,eA4BrBsB,EAAAA,GA5ByCf,oBA4BzCe,CA5B8DX,KA4B9DW,CAAAA,GA5BuEZ,qBA4BvEY,CA5B6FV,IA4B7FU,CAAAA,GA5BqGf,oBA4BrGe,CA5B0HX,KA4B1HW,CAAAA,GAAAA,CAAAA,CAAAA,GAAAA,CAAAA,CAAAA;;;;AAA0BA,KAxBzLT,0BAwByLS,CAAAA,UAAAA,SAxB3ItB,eAwB2IsB,EAAAA,CAAAA,GAxBtH9C,CAwBsH8C,SAAAA,SAAAA,EAAAA,GAAAA,CAAAA,CAAAA,GAxBzF9C,CAwByF8C,SAAAA,SAAAA,CAAAA,KAAAA,MAAAA,EAAAA,GAAAA,KAAAA,KAAAA,CAAAA,GAxBvCX,KAwBuCW,SAxBzBtB,eAwByBsB,GAxBPV,IAwBOU,SAAAA,SAxBetB,eAwBfsB,EAAAA,GAxBmCb,yBAwBnCa,CAxB6DX,KAwB7DW,CAAAA,GAxBsET,0BAwBtES,CAxBiGV,IAwBjGU,CAAAA,GAxByGb,yBAwBzGa,CAxBmIX,KAwBnIW,CAAAA,GAAAA,CAAAA,CAAAA,GAAAA,CAAAA,CAAAA;;AAAK;AAI1M;AAA4DtB,KAxBhDc,gBAwBgDd,CAAAA,UAAAA,SAxBZA,eAwBYA,EAAAA,CAAAA,GAxBSU,qBAwBTV,CAxB+BxB,CAwB/BwB,CAAAA,GAxBoC3B,iBAwBpC2B;;;;AAAkHA,KApBlKe,qBAoBkKf,CAAAA,UAAAA,SApBzHA,eAoByHA,EAAAA,CAAAA,GApBpGa,0BAoBoGb,CApBzExB,CAoByEwB,CAAAA,GApBpE3B,iBAoBoE2B;;;;AAA8EkB,KAhBhPF,sBAgBgPE,CAAAA,UAhB/MlB,eAgB+MkB,CAAAA,GAhB5L1C,CAgB4L0C,SAhBlLlB,eAgBkLkB,CAAAA,GAAAA,EAAAA,KAAAA,EAAAA,EAAAA,GAAAA,CAAAA,GAhB7ID,CAgB6IC,SAhBnI7D,gBAgBmI6D,GAhBhH1D,oBAgBgH0D,CAhB3FD,CAgB2FC,CAAAA,GAAAA,CAAAA,CAAAA,GAAAA,CAAAA,CAAAA;;;;AAAsGP,KAZtVO,2BAYsVP,CAAAA,UAZhTX,eAYgTW,CAAAA,GAZ7RnC,CAY6RmC,SAZnRX,eAYmRW,CAAAA,GAAAA,EAAAA,KAAAA,EAAAA,EAAAA,GAAAA,CAAAA,GAZ9OM,CAY8ON,SAZpOpD,kBAYoOoD,CAAAA,KAAAA,MAAAA,CAAAA,GAZlMnD,oBAYkMmD,CAZ7KQ,KAY6KR,CAAAA,GAAAA,SAAAA,GAZxJM,CAYwJN,SAZ9ItD,gBAY8IsD,GAZ3HnD,oBAY2HmD,CAZtGM,CAYsGN,CAAAA,GAAAA,CAAAA,CAAAA,GAAAA,CAAAA,CAAAA;;AAAD;AAIjW;AAAoDjC,KAZxC0C,uBAYwC1C,CAAAA,UAAAA,SAZGsB,eAYHtB,EAAAA,CAAAA,GAZwBF,CAYxBE,SAAAA,SAAAA,EAAAA,GAAAA,CAAAA,CAAAA,GAZqDF,CAYrDE,SAAAA,SAAAA,CAAAA,KAAAA,MAAAA,EAAAA,GAAAA,KAAAA,KAAAA,CAAAA,GAZuGiC,KAYvGjC,SAZqHsB,eAYrHtB,GAZuIkC,IAYvIlC,SAAAA,SAZ6JsB,eAY7JtB,EAAAA,GAZiLsC,sBAYjLtC,CAZwMiC,KAYxMjC,CAAAA,GAZiN0C,uBAYjN1C,CAZyOkC,IAYzOlC,CAAAA,GAZiPsC,sBAYjPtC,CAZwQiC,KAYxQjC,CAAAA,GAAAA,CAAAA,CAAAA,GAAAA,CAAAA,CAAAA;;;;KAR/C2C,iBAQqJK,CAAAA,CAAAA,EAAAA,CAAAA,CAAAA,GAAAA,CAR1HJ,CAQ0HI,CAAAA,SAAAA,CAAAA,SAAAA,CAAAA,GAAAA,CARhGH,CAQgGG,CAAAA,SAAAA,CAAAA,SAAAA,CAAAA,GAAAA,SAAAA,GAR3DH,CAQ2DG,GAAAA,SAAAA,GAAAA,CAR1CH,CAQ0CG,CAAAA,SAAAA,CAAAA,SAAAA,CAAAA,GARjBJ,CAQiBI,GAAAA,SAAAA,GAAAA,CARAJ,CAQAI,CAAAA,SAAAA,CARYH,CAQZG,CAAAA,GARiBJ,CAQjBI,GAAAA,CARsBH,CAQtBG,CAAAA,SAAAA,CARkCJ,CAQlCI,CAAAA,GARuCH,CAQvCG,GAR2CJ,CAQ3CI,GAR+CH,CAQ/CG;;;;AAA4EA,KAJ1NF,4BAI0NE,CAAAA,UAAAA,SAJ1K1B,eAI0K0B,EAAAA,CAAAA,GAJrJlD,CAIqJkD,SAAAA,SAAAA,EAAAA,GAAAA,CAAAA,CAAAA,GAJxHlD,CAIwHkD,SAAAA,SAAAA,CAAAA,KAAAA,MAAAA,EAAAA,GAAAA,KAAAA,KAAAA,CAAAA,GAJtEf,KAIsEe,SAJxD1B,eAIwD0B,GAJtCd,IAIsCc,SAAAA,SAJhB1B,eAIgB0B,EAAAA,GAJIL,iBAIJK,CAJsBR,2BAItBQ,CAJkDf,KAIlDe,CAAAA,EAJ0DF,4BAI1DE,CAJuFd,IAIvFc,CAAAA,CAAAA,GAJgGR,2BAIhGQ,CAJ4Hf,KAI5He,CAAAA,GAAAA,CAAAA,CAAAA,GAAAA,CAAAA,CAAAA;;AAAD;AACrO;AAAuChD,KAD3B+C,iBAC2B/C,CAAAA,sBADaA,iBACbA,GADiCrB,gBACjCqB,CAAAA,GADqDgD,aACrDhD,SAD2ErB,gBAC3EqB,GAD8FlB,oBAC9FkB,CADmHgD,aACnHhD,CAAAA,GADoIgD,aACpIhD,SAD0JA,iBAC1JA,GAD8K4B,gBAC9K5B,CAD+LgD,aAC/LhD,CAAAA,CAAAA,OAAAA,CAAAA,GAAAA,CAAAA,CAAAA;AAAoBrB,KAA/CiD,gBAA+CjD,CAAAA,UAApBqB,iBAAoBrB,GAAAA,gBAAAA,CAAAA,GAAoBiE,CAApBjE,SAA8BqB,iBAA9BrB,GAAkDiE,CAAlDjE,GAAsDiE,CAAtDjE,SAAgEA,gBAAhEA,GAAmFM,cAAnFN,CAAkGK,2BAAlGL,CAA8HiE,CAA9HjE,CAAAA,CAAAA,GAAAA,KAAAA;AAAoBiE,KACnEK,gBADmEL,CAAAA,UACxC5C,iBADwC4C,GACpBjE,gBADoBiE,GAAAA,SAAAA,CAAAA,GACYA,CADZA,SACsB5C,iBADtB4C,GAC0CjE,gBAD1CiE,GAC6DhB,gBAD7DgB,CAC8EA,CAD9EA,CAAAA,CAAAA,OAAAA,CAAAA,GAAAA,CAAAA,CAAAA"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.cts","names":["__types_js0","BaseMessage","AfterModelHook","AfterAgentHook","BeforeAgentHook","BeforeModelHook","JumpToTarget","countTokensApproximately","getHookConstraint","getHookFunction","___runtime_js0","AgentBuiltInState","Runtime","Partial","MiddlewareResult","Promise","sleep","calculateRetryDelay"],"sources":["../../../src/agents/middleware/utils.d.ts"],"sourcesContent":["import { type BaseMessage } from \"@langchain/core/messages\";\nimport { AfterModelHook, AfterAgentHook, BeforeAgentHook, BeforeModelHook } from \"./types.js\";\nimport { JumpToTarget } from \"../constants.js\";\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 declare function countTokensApproximately(messages: BaseMessage[]): number;\nexport declare function getHookConstraint(hook: BeforeAgentHook | BeforeModelHook | AfterAgentHook | AfterModelHook | undefined): JumpToTarget[] | undefined;\nexport declare function getHookFunction(arg: BeforeAgentHook | BeforeModelHook | AfterAgentHook | AfterModelHook): ((state: import(\"../runtime.js\").AgentBuiltInState, runtime: import(\"../runtime.js\").Runtime<unknown>) => Promise<import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>> | import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>) | ((state: import(\"../runtime.js\").AgentBuiltInState, runtime: import(\"../runtime.js\").Runtime<unknown>) => Promise<import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>> | import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>) | ((state: import(\"../runtime.js\").AgentBuiltInState, runtime: import(\"../runtime.js\").Runtime<unknown>) => Promise<import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>> | import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>) | ((state: import(\"../runtime.js\").AgentBuiltInState, runtime: import(\"../runtime.js\").Runtime<unknown>) => Promise<import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>> | import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>);\n/**\n * Sleep for the specified number of milliseconds.\n */\nexport declare function sleep(ms: number): Promise<void>;\n/**\n * Calculate delay for a retry attempt with exponential backoff and jitter.\n *\n * @param retryNumber - The retry attempt number (0-indexed)\n * @param config - Configuration for backoff calculation\n * @returns Delay in milliseconds before next retry\n *\n * @internal Exported for testing purposes\n */\nexport declare function calculateRetryDelay(config: {\n    backoffFactor: number;\n    initialDelayMs: number;\n    maxDelayMs: number;\n    jitter: boolean;\n}, retryNumber: number): number;\n//# sourceMappingURL=utils.d.ts.map"],"mappings":";;;;AAQA;;;;;iBAAwBO,wBAAAA,WAAmCN"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","names":["__types_js0","BaseMessage","AfterModelHook","AfterAgentHook","BeforeAgentHook","BeforeModelHook","JumpToTarget","countTokensApproximately","getHookConstraint","getHookFunction","___runtime_js0","AgentBuiltInState","Runtime","Partial","MiddlewareResult","Promise","sleep","calculateRetryDelay"],"sources":["../../../src/agents/middleware/utils.d.ts"],"sourcesContent":["import { type BaseMessage } from \"@langchain/core/messages\";\nimport { AfterModelHook, AfterAgentHook, BeforeAgentHook, BeforeModelHook } from \"./types.js\";\nimport { JumpToTarget } from \"../constants.js\";\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 declare function countTokensApproximately(messages: BaseMessage[]): number;\nexport declare function getHookConstraint(hook: BeforeAgentHook | BeforeModelHook | AfterAgentHook | AfterModelHook | undefined): JumpToTarget[] | undefined;\nexport declare function getHookFunction(arg: BeforeAgentHook | BeforeModelHook | AfterAgentHook | AfterModelHook): ((state: import(\"../runtime.js\").AgentBuiltInState, runtime: import(\"../runtime.js\").Runtime<unknown>) => Promise<import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>> | import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>) | ((state: import(\"../runtime.js\").AgentBuiltInState, runtime: import(\"../runtime.js\").Runtime<unknown>) => Promise<import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>> | import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>) | ((state: import(\"../runtime.js\").AgentBuiltInState, runtime: import(\"../runtime.js\").Runtime<unknown>) => Promise<import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>> | import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>) | ((state: import(\"../runtime.js\").AgentBuiltInState, runtime: import(\"../runtime.js\").Runtime<unknown>) => Promise<import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>> | import(\"./types.js\").MiddlewareResult<Partial<import(\"../runtime.js\").AgentBuiltInState>>);\n/**\n * Sleep for the specified number of milliseconds.\n */\nexport declare function sleep(ms: number): Promise<void>;\n/**\n * Calculate delay for a retry attempt with exponential backoff and jitter.\n *\n * @param retryNumber - The retry attempt number (0-indexed)\n * @param config - Configuration for backoff calculation\n * @returns Delay in milliseconds before next retry\n *\n * @internal Exported for testing purposes\n */\nexport declare function calculateRetryDelay(config: {\n    backoffFactor: number;\n    initialDelayMs: number;\n    maxDelayMs: number;\n    jitter: boolean;\n}, retryNumber: number): number;\n//# sourceMappingURL=utils.d.ts.map"],"mappings":";;;;;;;;AAQA;;;iBAAwBO,wBAAAA,WAAmCN"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.cts","names":["InteropZodObject","InferInteropZodOutput","ClientTool","ServerTool","AgentMiddleware","WrapToolCallHook","WrapModelCallHook","BeforeAgentHook","BeforeModelHook","AfterModelHook","AfterAgentHook","createMiddleware","TSchema","TContextSchema","NormalizeContextSchema"],"sources":["../../src/agents/middleware.d.ts"],"sourcesContent":["import type { InteropZodObject, InferInteropZodOutput } from \"@langchain/core/utils/types\";\nimport type { ClientTool, ServerTool } from \"@langchain/core/tools\";\nimport type { AgentMiddleware, WrapToolCallHook, WrapModelCallHook, BeforeAgentHook, BeforeModelHook, AfterModelHook, AfterAgentHook } from \"./middleware/types.js\";\n/**\n * Creates a middleware instance with automatic schema inference.\n *\n * @param config - Middleware configuration\n * @param config.name - The name of the middleware\n * @param config.stateSchema - The schema of the middleware state\n * @param config.contextSchema - The schema of the middleware context\n * @param config.wrapModelCall - The function to wrap model invocation\n * @param config.wrapToolCall - The function to wrap tool invocation\n * @param config.beforeModel - The function to run before the model call\n * @param config.afterModel - The function to run after the model call\n * @param config.beforeAgent - The function to run before the agent execution starts\n * @param config.afterAgent - The function to run after the agent execution completes\n * @returns A middleware instance\n *\n * @example\n * ```ts\n * const authMiddleware = createMiddleware({\n *   name: \"AuthMiddleware\",\n *   stateSchema: z.object({\n *     isAuthenticated: z.boolean().default(false),\n *   }),\n *   contextSchema: z.object({\n *     userId: z.string(),\n *   }),\n *   beforeModel: async (state, runtime, controls) => {\n *     if (!state.isAuthenticated) {\n *       return controls.terminate(new Error(\"Not authenticated\"));\n *     }\n *   },\n * });\n * ```\n */\nexport declare function createMiddleware<TSchema extends InteropZodObject | undefined = undefined, TContextSchema extends InteropZodObject | undefined = undefined>(config: {\n    /**\n     * The name of the middleware\n     */\n    name: string;\n    /**\n     * The schema of the middleware state. Middleware state is persisted between multiple invocations. It can be either:\n     * - A Zod object\n     * - A Zod optional object\n     * - A Zod default object\n     * - Undefined\n     */\n    stateSchema?: TSchema;\n    /**\n     * The schema of the middleware context. Middleware context is read-only and not persisted between multiple invocations. It can be either:\n     * - A Zod object\n     * - A Zod optional object\n     * - A Zod default object\n     * - Undefined\n     */\n    contextSchema?: TContextSchema;\n    /**\n     * Additional tools registered by the middleware.\n     */\n    tools?: (ClientTool | ServerTool)[];\n    /**\n     * Wraps tool execution with custom logic. This allows you to:\n     * - Modify tool call parameters before execution\n     * - Handle errors and retry with different parameters\n     * - Post-process tool results\n     * - Implement caching, logging, authentication, or other cross-cutting concerns\n     * - Return Command objects for advanced control flow\n     *\n     * The handler receives a ToolCallRequest containing the tool call, state, and runtime,\n     * along with a handler function to execute the actual tool.\n     *\n     * @param request - The tool call request containing toolCall, state, and runtime.\n     * @param handler - The function that executes the tool. Call this with a ToolCallRequest to get the result.\n     * @returns The tool result as a ToolMessage or a Command for advanced control flow.\n     *\n     * @example\n     * ```ts\n     * wrapToolCall: async (request, handler) => {\n     *   console.log(`Calling tool: ${request.tool.name}`);\n     *   console.log(`Tool description: ${request.tool.description}`);\n     *\n     *   try {\n     *     // Execute the tool\n     *     const result = await handler(request);\n     *     console.log(`Tool ${request.tool.name} succeeded`);\n     *     return result;\n     *   } catch (error) {\n     *     console.error(`Tool ${request.tool.name} failed:`, error);\n     *     // Could return a custom error message or retry\n     *     throw error;\n     *   }\n     * }\n     * ```\n     *\n     * @example Authentication\n     * ```ts\n     * wrapToolCall: async (request, handler) => {\n     *   // Check if user is authorized for this tool\n     *   if (!request.runtime.context.isAuthorized(request.tool.name)) {\n     *     return new ToolMessage({\n     *       content: \"Unauthorized to call this tool\",\n     *       tool_call_id: request.toolCall.id,\n     *     });\n     *   }\n     *   return handler(request);\n     * }\n     * ```\n     */\n    wrapToolCall?: WrapToolCallHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n    /**\n     * Wraps the model invocation with custom logic. This allows you to:\n     * - Modify the request before calling the model\n     * - Handle errors and retry with different parameters\n     * - Post-process the response\n     * - Implement custom caching, logging, or other cross-cutting concerns\n     *\n     * The request parameter contains: model, messages, systemPrompt, tools, state, and runtime.\n     *\n     * @param request - The model request containing all the parameters needed.\n     * @param handler - The function that invokes the model. Call this with a ModelRequest to get the response.\n     * @returns The response from the model (or a modified version).\n     *\n     * @example\n     * ```ts\n     * wrapModelCall: async (request, handler) => {\n     *   // Modify request before calling\n     *   const modifiedRequest = { ...request, systemPrompt: \"You are helpful\" };\n     *\n     *   try {\n     *     // Call the model\n     *     return await handler(modifiedRequest);\n     *   } catch (error) {\n     *     // Handle errors and retry with fallback\n     *     const fallbackRequest = { ...request, model: fallbackModel };\n     *     return await handler(fallbackRequest);\n     *   }\n     * }\n     * ```\n     */\n    wrapModelCall?: WrapModelCallHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n    /**\n     * The function to run before the agent execution starts. This function is called once at the start of the agent invocation.\n     * It allows to modify the state of the agent before any model calls or tool executions.\n     *\n     * @param state - The middleware state\n     * @param runtime - The middleware runtime\n     * @returns The modified middleware state or undefined to pass through\n     */\n    beforeAgent?: BeforeAgentHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n    /**\n     * The function to run before the model call. This function is called before the model is invoked and before the `wrapModelCall` hook.\n     * It allows to modify the state of the agent.\n     *\n     * @param state - The middleware state\n     * @param runtime - The middleware runtime\n     * @returns The modified middleware state or undefined to pass through\n     */\n    beforeModel?: BeforeModelHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n    /**\n     * The function to run after the model call. This function is called after the model is invoked and before any tools are called.\n     * It allows to modify the state of the agent after the model is invoked, e.g. to update tool call parameters.\n     *\n     * @param state - The middleware state\n     * @param runtime - The middleware runtime\n     * @returns The modified middleware state or undefined to pass through\n     */\n    afterModel?: AfterModelHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n    /**\n     * The function to run after the agent execution completes. This function is called once at the end of the agent invocation.\n     * It allows to modify the final state of the agent after all model calls and tool executions are complete.\n     *\n     * @param state - The middleware state\n     * @param runtime - The middleware runtime\n     * @returns The modified middleware state or undefined to pass through\n     */\n    afterAgent?: AfterAgentHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n}): AgentMiddleware<TSchema, TContextSchema, any>;\ntype NormalizeContextSchema<TContextSchema extends InteropZodObject | undefined = undefined> = TContextSchema extends InteropZodObject ? InferInteropZodOutput<TContextSchema> : never;\nexport {};\n//# sourceMappingURL=middleware.d.ts.map"],"mappings":";;;;;;;;AAoCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6IoBY,iBA7IID,gBA6IJC,CAAAA,gBA7IqCZ,gBA6IrCY,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,uBA7IsGZ,gBA6ItGY,GAAAA,SAAAA,GAAAA,SAAAA,CAAAA,CAAAA,MAAAA,EAAAA;EAASC;;AAAV;EACdC,IAAAA,EAAAA,MAAAA;EAA8Cd;;;;;AAA2G;;gBAlI5IY;;;;;;;;kBAQEC;;;;WAIPX,aAAaC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiDPE,iBAAiBO,SAASE,uBAAuBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA+BhDP,kBAAkBM,SAASE,uBAAuBD;;;;;;;;;gBASpDN,gBAAgBK,SAASE,uBAAuBD;;;;;;;;;gBAShDL,gBAAgBI,SAASE,uBAAuBD;;;;;;;;;eASjDJ,eAAeG,SAASE,uBAAuBD;;;;;;;;;eAS/CH,eAAeE,SAASE,uBAAuBD;IAC5DT,gBAAgBQ,SAASC;KACxBC,8CAA8Cd,4CAA4Ca,uBAAuBb,mBAAmBC,sBAAsBY"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","names":["InteropZodObject","InferInteropZodOutput","ClientTool","ServerTool","AgentMiddleware","WrapToolCallHook","WrapModelCallHook","BeforeAgentHook","BeforeModelHook","AfterModelHook","AfterAgentHook","createMiddleware","TSchema","TContextSchema","NormalizeContextSchema"],"sources":["../../src/agents/middleware.d.ts"],"sourcesContent":["import type { InteropZodObject, InferInteropZodOutput } from \"@langchain/core/utils/types\";\nimport type { ClientTool, ServerTool } from \"@langchain/core/tools\";\nimport type { AgentMiddleware, WrapToolCallHook, WrapModelCallHook, BeforeAgentHook, BeforeModelHook, AfterModelHook, AfterAgentHook } from \"./middleware/types.js\";\n/**\n * Creates a middleware instance with automatic schema inference.\n *\n * @param config - Middleware configuration\n * @param config.name - The name of the middleware\n * @param config.stateSchema - The schema of the middleware state\n * @param config.contextSchema - The schema of the middleware context\n * @param config.wrapModelCall - The function to wrap model invocation\n * @param config.wrapToolCall - The function to wrap tool invocation\n * @param config.beforeModel - The function to run before the model call\n * @param config.afterModel - The function to run after the model call\n * @param config.beforeAgent - The function to run before the agent execution starts\n * @param config.afterAgent - The function to run after the agent execution completes\n * @returns A middleware instance\n *\n * @example\n * ```ts\n * const authMiddleware = createMiddleware({\n *   name: \"AuthMiddleware\",\n *   stateSchema: z.object({\n *     isAuthenticated: z.boolean().default(false),\n *   }),\n *   contextSchema: z.object({\n *     userId: z.string(),\n *   }),\n *   beforeModel: async (state, runtime, controls) => {\n *     if (!state.isAuthenticated) {\n *       return controls.terminate(new Error(\"Not authenticated\"));\n *     }\n *   },\n * });\n * ```\n */\nexport declare function createMiddleware<TSchema extends InteropZodObject | undefined = undefined, TContextSchema extends InteropZodObject | undefined = undefined>(config: {\n    /**\n     * The name of the middleware\n     */\n    name: string;\n    /**\n     * The schema of the middleware state. Middleware state is persisted between multiple invocations. It can be either:\n     * - A Zod object\n     * - A Zod optional object\n     * - A Zod default object\n     * - Undefined\n     */\n    stateSchema?: TSchema;\n    /**\n     * The schema of the middleware context. Middleware context is read-only and not persisted between multiple invocations. It can be either:\n     * - A Zod object\n     * - A Zod optional object\n     * - A Zod default object\n     * - Undefined\n     */\n    contextSchema?: TContextSchema;\n    /**\n     * Additional tools registered by the middleware.\n     */\n    tools?: (ClientTool | ServerTool)[];\n    /**\n     * Wraps tool execution with custom logic. This allows you to:\n     * - Modify tool call parameters before execution\n     * - Handle errors and retry with different parameters\n     * - Post-process tool results\n     * - Implement caching, logging, authentication, or other cross-cutting concerns\n     * - Return Command objects for advanced control flow\n     *\n     * The handler receives a ToolCallRequest containing the tool call, state, and runtime,\n     * along with a handler function to execute the actual tool.\n     *\n     * @param request - The tool call request containing toolCall, state, and runtime.\n     * @param handler - The function that executes the tool. Call this with a ToolCallRequest to get the result.\n     * @returns The tool result as a ToolMessage or a Command for advanced control flow.\n     *\n     * @example\n     * ```ts\n     * wrapToolCall: async (request, handler) => {\n     *   console.log(`Calling tool: ${request.tool.name}`);\n     *   console.log(`Tool description: ${request.tool.description}`);\n     *\n     *   try {\n     *     // Execute the tool\n     *     const result = await handler(request);\n     *     console.log(`Tool ${request.tool.name} succeeded`);\n     *     return result;\n     *   } catch (error) {\n     *     console.error(`Tool ${request.tool.name} failed:`, error);\n     *     // Could return a custom error message or retry\n     *     throw error;\n     *   }\n     * }\n     * ```\n     *\n     * @example Authentication\n     * ```ts\n     * wrapToolCall: async (request, handler) => {\n     *   // Check if user is authorized for this tool\n     *   if (!request.runtime.context.isAuthorized(request.tool.name)) {\n     *     return new ToolMessage({\n     *       content: \"Unauthorized to call this tool\",\n     *       tool_call_id: request.toolCall.id,\n     *     });\n     *   }\n     *   return handler(request);\n     * }\n     * ```\n     */\n    wrapToolCall?: WrapToolCallHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n    /**\n     * Wraps the model invocation with custom logic. This allows you to:\n     * - Modify the request before calling the model\n     * - Handle errors and retry with different parameters\n     * - Post-process the response\n     * - Implement custom caching, logging, or other cross-cutting concerns\n     *\n     * The request parameter contains: model, messages, systemPrompt, tools, state, and runtime.\n     *\n     * @param request - The model request containing all the parameters needed.\n     * @param handler - The function that invokes the model. Call this with a ModelRequest to get the response.\n     * @returns The response from the model (or a modified version).\n     *\n     * @example\n     * ```ts\n     * wrapModelCall: async (request, handler) => {\n     *   // Modify request before calling\n     *   const modifiedRequest = { ...request, systemPrompt: \"You are helpful\" };\n     *\n     *   try {\n     *     // Call the model\n     *     return await handler(modifiedRequest);\n     *   } catch (error) {\n     *     // Handle errors and retry with fallback\n     *     const fallbackRequest = { ...request, model: fallbackModel };\n     *     return await handler(fallbackRequest);\n     *   }\n     * }\n     * ```\n     */\n    wrapModelCall?: WrapModelCallHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n    /**\n     * The function to run before the agent execution starts. This function is called once at the start of the agent invocation.\n     * It allows to modify the state of the agent before any model calls or tool executions.\n     *\n     * @param state - The middleware state\n     * @param runtime - The middleware runtime\n     * @returns The modified middleware state or undefined to pass through\n     */\n    beforeAgent?: BeforeAgentHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n    /**\n     * The function to run before the model call. This function is called before the model is invoked and before the `wrapModelCall` hook.\n     * It allows to modify the state of the agent.\n     *\n     * @param state - The middleware state\n     * @param runtime - The middleware runtime\n     * @returns The modified middleware state or undefined to pass through\n     */\n    beforeModel?: BeforeModelHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n    /**\n     * The function to run after the model call. This function is called after the model is invoked and before any tools are called.\n     * It allows to modify the state of the agent after the model is invoked, e.g. to update tool call parameters.\n     *\n     * @param state - The middleware state\n     * @param runtime - The middleware runtime\n     * @returns The modified middleware state or undefined to pass through\n     */\n    afterModel?: AfterModelHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n    /**\n     * The function to run after the agent execution completes. This function is called once at the end of the agent invocation.\n     * It allows to modify the final state of the agent after all model calls and tool executions are complete.\n     *\n     * @param state - The middleware state\n     * @param runtime - The middleware runtime\n     * @returns The modified middleware state or undefined to pass through\n     */\n    afterAgent?: AfterAgentHook<TSchema, NormalizeContextSchema<TContextSchema>>;\n}): AgentMiddleware<TSchema, TContextSchema, any>;\ntype NormalizeContextSchema<TContextSchema extends InteropZodObject | undefined = undefined> = TContextSchema extends InteropZodObject ? InferInteropZodOutput<TContextSchema> : never;\nexport {};\n//# sourceMappingURL=middleware.d.ts.map"],"mappings":";;;;;;;;AAoCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6IoBY,iBA7IID,gBA6IJC,CAAAA,gBA7IqCZ,gBA6IrCY,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,uBA7IsGZ,gBA6ItGY,GAAAA,SAAAA,GAAAA,SAAAA,CAAAA,CAAAA,MAAAA,EAAAA;EAASC;;AAAV;EACdC,IAAAA,EAAAA,MAAAA;EAA8Cd;;;;;AAA2G;;gBAlI5IY;;;;;;;;kBAQEC;;;;WAIPX,aAAaC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiDPE,iBAAiBO,SAASE,uBAAuBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA+BhDP,kBAAkBM,SAASE,uBAAuBD;;;;;;;;;gBASpDN,gBAAgBK,SAASE,uBAAuBD;;;;;;;;;gBAShDL,gBAAgBI,SAASE,uBAAuBD;;;;;;;;;eASjDJ,eAAeG,SAASE,uBAAuBD;;;;;;;;;eAS/CH,eAAeE,SAASE,uBAAuBD;IAC5DT,gBAAgBQ,SAASC;KACxBC,8CAA8Cd,4CAA4Ca,uBAAuBb,mBAAmBC,sBAAsBY"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","names":["LanguageModelLike","BaseMessage","SystemMessage","ServerTool","ClientTool","Runtime","AgentBuiltInState","ModelRequest","TState","TContext","Record"],"sources":["../../../src/agents/nodes/types.d.ts"],"sourcesContent":["import type { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport type { BaseMessage, SystemMessage } from \"@langchain/core/messages\";\nimport type { ServerTool, ClientTool } from \"@langchain/core/tools\";\nimport type { Runtime, AgentBuiltInState } from \"../runtime.js\";\n/**\n * Configuration for modifying a model call at runtime.\n * All fields are optional and only provided fields will override defaults.\n *\n * @template TState - The agent's state type, must extend Record<string, unknown>. Defaults to Record<string, unknown>.\n * @template TContext - The runtime context type for accessing metadata and control flow. Defaults to unknown.\n */\nexport interface ModelRequest<TState extends Record<string, unknown> = Record<string, unknown>, TContext = unknown> {\n    /**\n     * The model to use for this step.\n     */\n    model: LanguageModelLike;\n    /**\n     * The messages to send to the model.\n     */\n    messages: BaseMessage[];\n    /**\n     * The system message string for this step.\n     *\n     * @default \"\"\n     * @deprecated Use {@link ModelRequest.systemMessage} instead.\n     */\n    systemPrompt: string;\n    /**\n     * The system message for this step. If no `systemPrompt` was provided, when `createAgent`\n     * was initialized, an empty system message will be used.\n     *\n     * @default new SystemMessage(\"\")\n     * @example extend system message with a string\n     * ```ts\n     * wrapModelCall: async (request, handler) => {\n     *   return handler({\n     *     ...request,\n     *     systemMessage: request.systemMessage.concat(\"something\")\n     *   });\n     * }\n     * ```\n     * @example extend system message with a SystemMessage and cache control\n     * ```ts\n     * wrapModelCall: async (request, handler) => {\n     *   return handler({\n     *     ...request,\n     *     systemMessage: request.systemMessage.concat(\n     *       new SystemMessage({\n     *         content: [{\n     *           type: \"text\",\n     *           text: \"something\",\n     *           cache_control: { type: \"ephemeral\", ttl: \"1m\" }\n     *         }],\n     *       })\n     *     ),\n     *   });\n     * }\n     * ```\n     */\n    systemMessage: SystemMessage;\n    /**\n     * Tool choice configuration (model-specific format).\n     * Can be one of:\n     * - `\"auto\"`: means the model can pick between generating a message or calling one or more tools.\n     * - `\"none\"`: means the model will not call any tool and instead generates a message.\n     * - `\"required\"`: means the model must call one or more tools.\n     * - `{ type: \"function\", function: { name: string } }`: The model will use the specified function.\n     */\n    toolChoice?: \"auto\" | \"none\" | \"required\" | {\n        type: \"function\";\n        function: {\n            name: string;\n        };\n    };\n    /**\n     * The tools to make available for this step.\n     */\n    tools: (ServerTool | ClientTool)[];\n    /**\n     * The current agent state (includes both middleware state and built-in state).\n     */\n    state: TState & AgentBuiltInState;\n    /**\n     * The runtime context containing metadata, signal, writer, interrupt, etc.\n     */\n    runtime: Runtime<TContext>;\n    /**\n     * Additional settings to bind to the model when preparing it for invocation.\n     * These settings are applied via `bindTools()` and can include parameters like\n     * `headers`, `container`, etc. The model is re-bound on each request,\n     * so these settings can vary per invocation.\n     *\n     * @example\n     * ```ts\n     * modelSettings: {\n     *   headers: { \"anthropic-beta\": \"code-execution-2025-08-25\" },\n     *   container: \"container_abc123\"\n     * }\n     * ```\n     */\n    modelSettings?: Record<string, unknown>;\n}\n//# sourceMappingURL=types.d.ts.map"],"mappings":";;;;;;;;;AAWA;;;;;AAgDmBE,UAhDFK,YAgDEL,CAAAA,eAhD0BQ,MAgD1BR,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,GAhDoDQ,MAgDpDR,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EAAAA,WAAAA,OAAAA,CAAAA,CAAAA;EAkBPC;;;EAIQG,KAAAA,EAlETN,iBAkESM;EAICG;;;EAeK,QAAA,EAjFZR,WAiFY,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAzCPC;;;;;;;;;;;;;;;;;;UAkBPC,aAAaC;;;;SAIdI,SAASF;;;;WAIPD,QAAQI;;;;;;;;;;;;;;;kBAeDC"}

package/dist/agents/nodes/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":["LanguageModelLike","BaseMessage","SystemMessage","ServerTool","ClientTool","Runtime","AgentBuiltInState","ModelRequest","TState","TContext","Record"],"sources":["../../../src/agents/nodes/types.d.ts"],"sourcesContent":["import type { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport type { BaseMessage, SystemMessage } from \"@langchain/core/messages\";\nimport type { ServerTool, ClientTool } from \"@langchain/core/tools\";\nimport type { Runtime, AgentBuiltInState } from \"../runtime.js\";\n/**\n * Configuration for modifying a model call at runtime.\n * All fields are optional and only provided fields will override defaults.\n *\n * @template TState - The agent's state type, must extend Record<string, unknown>. Defaults to Record<string, unknown>.\n * @template TContext - The runtime context type for accessing metadata and control flow. Defaults to unknown.\n */\nexport interface ModelRequest<TState extends Record<string, unknown> = Record<string, unknown>, TContext = unknown> {\n    /**\n     * The model to use for this step.\n     */\n    model: LanguageModelLike;\n    /**\n     * The messages to send to the model.\n     */\n    messages: BaseMessage[];\n    /**\n     * The system message string for this step.\n     *\n     * @default \"\"\n     * @deprecated Use {@link ModelRequest.systemMessage} instead.\n     */\n    systemPrompt: string;\n    /**\n     * The system message for this step. If no `systemPrompt` was provided, when `createAgent`\n     * was initialized, an empty system message will be used.\n     *\n     * @default new SystemMessage(\"\")\n     * @example extend system message with a string\n     * ```ts\n     * wrapModelCall: async (request, handler) => {\n     *   return handler({\n     *     ...request,\n     *     systemMessage: request.systemMessage.concat(\"something\")\n     *   });\n     * }\n     * ```\n     * @example extend system message with a SystemMessage and cache control\n     * ```ts\n     * wrapModelCall: async (request, handler) => {\n     *   return handler({\n     *     ...request,\n     *     systemMessage: request.systemMessage.concat(\n     *       new SystemMessage({\n     *         content: [{\n     *           type: \"text\",\n     *           text: \"something\",\n     *           cache_control: { type: \"ephemeral\", ttl: \"1m\" }\n     *         }],\n     *       })\n     *     ),\n     *   });\n     * }\n     * ```\n     */\n    systemMessage: SystemMessage;\n    /**\n     * Tool choice configuration (model-specific format).\n     * Can be one of:\n     * - `\"auto\"`: means the model can pick between generating a message or calling one or more tools.\n     * - `\"none\"`: means the model will not call any tool and instead generates a message.\n     * - `\"required\"`: means the model must call one or more tools.\n     * - `{ type: \"function\", function: { name: string } }`: The model will use the specified function.\n     */\n    toolChoice?: \"auto\" | \"none\" | \"required\" | {\n        type: \"function\";\n        function: {\n            name: string;\n        };\n    };\n    /**\n     * The tools to make available for this step.\n     */\n    tools: (ServerTool | ClientTool)[];\n    /**\n     * The current agent state (includes both middleware state and built-in state).\n     */\n    state: TState & AgentBuiltInState;\n    /**\n     * The runtime context containing metadata, signal, writer, interrupt, etc.\n     */\n    runtime: Runtime<TContext>;\n    /**\n     * Additional settings to bind to the model when preparing it for invocation.\n     * These settings are applied via `bindTools()` and can include parameters like\n     * `headers`, `container`, etc. The model is re-bound on each request,\n     * so these settings can vary per invocation.\n     *\n     * @example\n     * ```ts\n     * modelSettings: {\n     *   headers: { \"anthropic-beta\": \"code-execution-2025-08-25\" },\n     *   container: \"container_abc123\"\n     * }\n     * ```\n     */\n    modelSettings?: Record<string, unknown>;\n}\n//# sourceMappingURL=types.d.ts.map"],"mappings":";;;;;;;;;AAWA;;;;;AAgDmBE,UAhDFK,YAgDEL,CAAAA,eAhD0BQ,MAgD1BR,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,GAhDoDQ,MAgDpDR,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EAAAA,WAAAA,OAAAA,CAAAA,CAAAA;EAkBPC;;;EAIQG,KAAAA,EAlETN,iBAkESM;EAICG;;;EAeK,QAAA,EAjFZR,WAiFY,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAzCPC;;;;;;;;;;;;;;;;;;UAkBPC,aAAaC;;;;SAIdI,SAASF;;;;WAIPD,QAAQI;;;;;;;;;;;;;;;kBAeDC"}

package/dist/agents/responses.d.cts

@@ -40,7 +40,6 @@ declare class ToolStrategy<_T = unknown> {
 }
 declare class ProviderStrategy<T = unknown> {
   readonly schema: Record<string, unknown>;
-  // @ts-expect-error - _schemaType is used only for type inference
   private _schemaType?;
   private constructor();
   static fromSchema<T>(schema: InteropZodType<T>): ProviderStrategy<T>;
@@ -100,7 +99,6 @@ type JsonSchemaFormat = {
   additionalProperties?: boolean;
   [key: string]: unknown;
 } & {
-  // Brand to ensure this is not a ToolStrategy or ProviderStrategy
   __brand?: never;
 };
 //#endregion

package/dist/agents/responses.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responses.d.cts","names":["InteropZodObject","InteropZodType","AIMessage","LanguageModelLike","FunctionDefinition","StructuredOutputParsingError","MultipleStructuredOutputsError","ResponseFormatUndefined","ToolStrategy","S","_T","Record","ToolStrategyOptions","U","ProviderStrategy","T","ResponseFormat","transformResponseFormat","JsonSchemaFormat","TypedToolStrategy","Array","ToolStrategyError","Promise","toolStrategy","K","providerStrategy","hasSupportForJsonSchemaOutput"],"sources":["../../src/agents/responses.d.ts"],"sourcesContent":["import { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport { type AIMessage } from \"@langchain/core/messages\";\nimport { type LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { type FunctionDefinition } from \"@langchain/core/language_models/base\";\nimport { StructuredOutputParsingError, MultipleStructuredOutputsError } from \"./errors.js\";\n/**\n * Special type to indicate that no response format is provided.\n * When this type is used, the structuredResponse property should not be present in the result.\n */\nexport type ResponseFormatUndefined = {\n    __responseFormatUndefined: true;\n};\n/**\n * Information for tracking structured output tool metadata.\n * This contains all necessary information to handle structured responses generated\n * via tool calls, including the original schema, its type classification, and the\n * corresponding tool implementation used by the tools strategy.\n */\nexport declare class ToolStrategy<_T = unknown> {\n    readonly schema: Record<string, unknown>;\n    readonly tool: {\n        type: \"function\";\n        function: FunctionDefinition;\n    };\n    readonly options?: ToolStrategyOptions | undefined;\n    private constructor();\n    get name(): string;\n    static fromSchema<S extends InteropZodObject>(schema: S, outputOptions?: ToolStrategyOptions): ToolStrategy<S extends InteropZodType<infer U> ? U : unknown>;\n    static fromSchema(schema: Record<string, unknown>, outputOptions?: ToolStrategyOptions): ToolStrategy<Record<string, unknown>>;\n    /**\n     * Parse tool arguments according to the schema.\n     *\n     * @throws {StructuredOutputParsingError} if the response is not valid\n     * @param toolArgs - The arguments from the tool call\n     * @returns The parsed response according to the schema type\n     */\n    parse(toolArgs: Record<string, unknown>): Record<string, unknown>;\n}\nexport declare class ProviderStrategy<T = unknown> {\n    readonly schema: Record<string, unknown>;\n    private _schemaType?;\n    private constructor();\n    static fromSchema<T>(schema: InteropZodType<T>): ProviderStrategy<T>;\n    static fromSchema(schema: Record<string, unknown>): ProviderStrategy<Record<string, unknown>>;\n    /**\n     * Parse tool arguments according to the schema. If the response is not valid, return undefined.\n     *\n     * @param toolArgs - The arguments from the tool call\n     * @returns The parsed response according to the schema type\n     */\n    parse(response: AIMessage): any;\n}\nexport type ResponseFormat = ToolStrategy<any> | ProviderStrategy<any>;\n/**\n * Handle user input for `responseFormat` parameter of `CreateAgentParams`.\n * This function defines the default behavior for the `responseFormat` parameter, which is:\n *\n * - if value is a Zod schema, default to structured output via tool calling\n * - if value is a JSON schema, default to structured output via tool calling\n * - if value is a custom response format, return it as is\n * - if value is an array, ensure all array elements are instance of `ToolStrategy`\n * @param responseFormat - The response format to transform, provided by the user\n * @param options - The response format options for tool strategy\n * @param model - The model to check if it supports JSON schema output\n * @returns\n */\nexport declare function transformResponseFormat(responseFormat?: InteropZodType<any> | InteropZodType<any>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | ToolStrategy<any>[] | ResponseFormatUndefined, options?: ToolStrategyOptions, model?: LanguageModelLike | string): ResponseFormat[];\n/**\n * Branded type for ToolStrategy arrays that preserves type information\n */\nexport interface TypedToolStrategy<T = unknown> extends Array<ToolStrategy<any>> {\n    _schemaType?: T;\n}\nexport type ToolStrategyError = StructuredOutputParsingError | MultipleStructuredOutputsError;\nexport interface ToolStrategyOptions {\n    /**\n     * Allows you to customize the message that appears in the conversation history when structured\n     * output is generated.\n     */\n    toolMessageContent?: string;\n    /**\n     * Handle errors from the structured output tool call. Using tools to generate structured output\n     * can cause errors, e.g. if:\n     * - you provide multiple structured output schemas and the model calls multiple structured output tools\n     * - if the structured output generated by the tool call doesn't match provided schema\n     *\n     * This property allows to handle these errors in different ways:\n     * - `true` - retry the tool call\n     * - `false` - throw an error\n     * - `string` - retry the tool call with the provided message\n     * - `(error: ToolStrategyError) => Promise<string> | string` - retry with the provided message or throw the error\n     *\n     * @default true\n     */\n    handleError?: boolean | string | ((error: ToolStrategyError) => Promise<string> | string);\n}\nexport declare function toolStrategy<T extends InteropZodType<any>>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport declare function toolStrategy<T extends readonly InteropZodType<any>[]>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<{\n    [K in keyof T]: T[K] extends InteropZodType<infer U> ? U : never;\n}[number]>;\nexport declare function toolStrategy(responseFormat: JsonSchemaFormat, options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;\nexport declare function toolStrategy(responseFormat: JsonSchemaFormat[], options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;\nexport declare function providerStrategy<T extends InteropZodType<any>>(responseFormat: T): ProviderStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport declare function providerStrategy(responseFormat: JsonSchemaFormat): ProviderStrategy<Record<string, unknown>>;\n/**\n * Type representing a JSON Schema object format.\n * This is a strict type that excludes ToolStrategy and ProviderStrategy instances.\n */\nexport type JsonSchemaFormat = {\n    type: \"null\" | \"boolean\" | \"object\" | \"array\" | \"number\" | \"string\" | \"integer\";\n    properties?: Record<string, unknown>;\n    required?: string[];\n    additionalProperties?: boolean;\n    [key: string]: unknown;\n} & {\n    __brand?: never;\n};\n/**\n * Identifies the models that support JSON schema output\n * @param model - The model to check\n * @returns True if the model supports JSON schema output, false otherwise\n */\nexport declare function hasSupportForJsonSchemaOutput(model?: LanguageModelLike | string): boolean;\n//# sourceMappingURL=responses.d.ts.map"],"mappings":"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"}

package/dist/agents/responses.d.ts

@@ -40,7 +40,6 @@ declare class ToolStrategy<_T = unknown> {
 }
 declare class ProviderStrategy<T = unknown> {
   readonly schema: Record<string, unknown>;
-  // @ts-expect-error - _schemaType is used only for type inference
   private _schemaType?;
   private constructor();
   static fromSchema<T>(schema: InteropZodType<T>): ProviderStrategy<T>;
@@ -100,7 +99,6 @@ type JsonSchemaFormat = {
   additionalProperties?: boolean;
   [key: string]: unknown;
 } & {
-  // Brand to ensure this is not a ToolStrategy or ProviderStrategy
   __brand?: never;
 };
 //#endregion

package/dist/agents/responses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responses.d.ts","names":["InteropZodObject","InteropZodType","AIMessage","LanguageModelLike","FunctionDefinition","StructuredOutputParsingError","MultipleStructuredOutputsError","ResponseFormatUndefined","ToolStrategy","S","_T","Record","ToolStrategyOptions","U","ProviderStrategy","T","ResponseFormat","transformResponseFormat","JsonSchemaFormat","TypedToolStrategy","Array","ToolStrategyError","Promise","toolStrategy","K","providerStrategy","hasSupportForJsonSchemaOutput"],"sources":["../../src/agents/responses.d.ts"],"sourcesContent":["import { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport { type AIMessage } from \"@langchain/core/messages\";\nimport { type LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { type FunctionDefinition } from \"@langchain/core/language_models/base\";\nimport { StructuredOutputParsingError, MultipleStructuredOutputsError } from \"./errors.js\";\n/**\n * Special type to indicate that no response format is provided.\n * When this type is used, the structuredResponse property should not be present in the result.\n */\nexport type ResponseFormatUndefined = {\n    __responseFormatUndefined: true;\n};\n/**\n * Information for tracking structured output tool metadata.\n * This contains all necessary information to handle structured responses generated\n * via tool calls, including the original schema, its type classification, and the\n * corresponding tool implementation used by the tools strategy.\n */\nexport declare class ToolStrategy<_T = unknown> {\n    readonly schema: Record<string, unknown>;\n    readonly tool: {\n        type: \"function\";\n        function: FunctionDefinition;\n    };\n    readonly options?: ToolStrategyOptions | undefined;\n    private constructor();\n    get name(): string;\n    static fromSchema<S extends InteropZodObject>(schema: S, outputOptions?: ToolStrategyOptions): ToolStrategy<S extends InteropZodType<infer U> ? U : unknown>;\n    static fromSchema(schema: Record<string, unknown>, outputOptions?: ToolStrategyOptions): ToolStrategy<Record<string, unknown>>;\n    /**\n     * Parse tool arguments according to the schema.\n     *\n     * @throws {StructuredOutputParsingError} if the response is not valid\n     * @param toolArgs - The arguments from the tool call\n     * @returns The parsed response according to the schema type\n     */\n    parse(toolArgs: Record<string, unknown>): Record<string, unknown>;\n}\nexport declare class ProviderStrategy<T = unknown> {\n    readonly schema: Record<string, unknown>;\n    private _schemaType?;\n    private constructor();\n    static fromSchema<T>(schema: InteropZodType<T>): ProviderStrategy<T>;\n    static fromSchema(schema: Record<string, unknown>): ProviderStrategy<Record<string, unknown>>;\n    /**\n     * Parse tool arguments according to the schema. If the response is not valid, return undefined.\n     *\n     * @param toolArgs - The arguments from the tool call\n     * @returns The parsed response according to the schema type\n     */\n    parse(response: AIMessage): any;\n}\nexport type ResponseFormat = ToolStrategy<any> | ProviderStrategy<any>;\n/**\n * Handle user input for `responseFormat` parameter of `CreateAgentParams`.\n * This function defines the default behavior for the `responseFormat` parameter, which is:\n *\n * - if value is a Zod schema, default to structured output via tool calling\n * - if value is a JSON schema, default to structured output via tool calling\n * - if value is a custom response format, return it as is\n * - if value is an array, ensure all array elements are instance of `ToolStrategy`\n * @param responseFormat - The response format to transform, provided by the user\n * @param options - The response format options for tool strategy\n * @param model - The model to check if it supports JSON schema output\n * @returns\n */\nexport declare function transformResponseFormat(responseFormat?: InteropZodType<any> | InteropZodType<any>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | ToolStrategy<any>[] | ResponseFormatUndefined, options?: ToolStrategyOptions, model?: LanguageModelLike | string): ResponseFormat[];\n/**\n * Branded type for ToolStrategy arrays that preserves type information\n */\nexport interface TypedToolStrategy<T = unknown> extends Array<ToolStrategy<any>> {\n    _schemaType?: T;\n}\nexport type ToolStrategyError = StructuredOutputParsingError | MultipleStructuredOutputsError;\nexport interface ToolStrategyOptions {\n    /**\n     * Allows you to customize the message that appears in the conversation history when structured\n     * output is generated.\n     */\n    toolMessageContent?: string;\n    /**\n     * Handle errors from the structured output tool call. Using tools to generate structured output\n     * can cause errors, e.g. if:\n     * - you provide multiple structured output schemas and the model calls multiple structured output tools\n     * - if the structured output generated by the tool call doesn't match provided schema\n     *\n     * This property allows to handle these errors in different ways:\n     * - `true` - retry the tool call\n     * - `false` - throw an error\n     * - `string` - retry the tool call with the provided message\n     * - `(error: ToolStrategyError) => Promise<string> | string` - retry with the provided message or throw the error\n     *\n     * @default true\n     */\n    handleError?: boolean | string | ((error: ToolStrategyError) => Promise<string> | string);\n}\nexport declare function toolStrategy<T extends InteropZodType<any>>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport declare function toolStrategy<T extends readonly InteropZodType<any>[]>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<{\n    [K in keyof T]: T[K] extends InteropZodType<infer U> ? U : never;\n}[number]>;\nexport declare function toolStrategy(responseFormat: JsonSchemaFormat, options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;\nexport declare function toolStrategy(responseFormat: JsonSchemaFormat[], options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;\nexport declare function providerStrategy<T extends InteropZodType<any>>(responseFormat: T): ProviderStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport declare function providerStrategy(responseFormat: JsonSchemaFormat): ProviderStrategy<Record<string, unknown>>;\n/**\n * Type representing a JSON Schema object format.\n * This is a strict type that excludes ToolStrategy and ProviderStrategy instances.\n */\nexport type JsonSchemaFormat = {\n    type: \"null\" | \"boolean\" | \"object\" | \"array\" | \"number\" | \"string\" | \"integer\";\n    properties?: Record<string, unknown>;\n    required?: string[];\n    additionalProperties?: boolean;\n    [key: string]: unknown;\n} & {\n    __brand?: never;\n};\n/**\n * Identifies the models that support JSON schema output\n * @param model - The model to check\n * @returns True if the model supports JSON schema output, false otherwise\n */\nexport declare function hasSupportForJsonSchemaOutput(model?: LanguageModelLike | string): boolean;\n//# sourceMappingURL=responses.d.ts.map"],"mappings":"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"}

package/dist/agents/runtime.d.cts

@@ -70,9 +70,7 @@ type ExtractNonUndefined<T> = T extends undefined ? never : T;
 /**
  * Helper type to check if all properties of a type are optional
  */
-type IsAllOptional<T> =
-// If T includes undefined, then it's optional (can be omitted entirely)
-undefined extends T ? true : IsOptionalType<T> extends true ? true : ExtractNonUndefined<T> extends Record<string, any> ? {} extends ExtractNonUndefined<T> ? true : false : IsOptionalType<T>;
+type IsAllOptional<T> = undefined extends T ? true : IsOptionalType<T> extends true ? true : ExtractNonUndefined<T> extends Record<string, any> ? {} extends ExtractNonUndefined<T> ? true : false : IsOptionalType<T>;
 /**
  * Pregel options that are propagated to the agent
  */

package/dist/agents/runtime.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.cts","names":["InteropZodOptional","InteropZodDefault","Runtime","LangGraphRuntime","PregelOptions","StreamMode","BaseMessage","BaseCallbackConfig","ResponseFormatUndefined","AgentBuiltInState","Record","IsOptionalZodObject","T","IsDefaultZodObject","WithMaybeContext","TContext","Omit","Partial","InternalAgentState","StructuredResponseType","IsOptionalType","ExtractNonUndefined","IsAllOptional","CreateAgentPregelOptions","CreateAgentPregelStreamOptions","InvokeConfiguration","ContextSchema","Pick","StreamConfiguration","TStreamMode","TEncoding"],"sources":["../../src/agents/runtime.d.ts"],"sourcesContent":["import type { InteropZodOptional } from \"@langchain/core/utils/types\";\nimport type { InteropZodDefault } from \"@langchain/core/utils/types\";\nimport type { Runtime as LangGraphRuntime, PregelOptions, StreamMode } from \"@langchain/langgraph\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport type { BaseCallbackConfig } from \"@langchain/core/callbacks/manager\";\nimport type { ResponseFormatUndefined } from \"./responses.js\";\n/**\n * Type for the agent's built-in state properties.\n */\nexport type AgentBuiltInState = {\n    /**\n     * Array of messages representing the conversation history.\n     *\n     * This includes all messages exchanged during the agent's execution:\n     * - Human messages: Input from the user\n     * - AI messages: Responses from the language model\n     * - Tool messages: Results from tool executions\n     * - System messages: System-level instructions or information\n     *\n     * Messages are accumulated throughout the agent's lifecycle and can be\n     * accessed or modified by middleware hooks during execution.\n     */\n    messages: BaseMessage[];\n    /**\n     * Structured response data returned by the agent when a `responseFormat` is configured.\n     *\n     * This property is only populated when you provide a `responseFormat` schema\n     * (as Zod or JSON schema) to the agent configuration. The agent will format\n     * its final output to match the specified schema and store it in this property.\n     *\n     * Note: The type is specified as `Record<string, unknown>` because TypeScript cannot\n     * infer the actual response format type in contexts like middleware, where the agent's\n     * generic type parameters are not accessible. You may need to cast this to your specific\n     * response type when accessing it.\n     */\n    structuredResponse?: Record<string, unknown>;\n};\n/**\n * Type helper to check if TContext is an optional Zod schema\n */\ntype IsOptionalZodObject<T> = T extends InteropZodOptional<any> ? true : false;\ntype IsDefaultZodObject<T> = T extends InteropZodDefault<any> ? true : false;\nexport type WithMaybeContext<TContext> = undefined extends TContext ? {\n    readonly context?: TContext;\n} : IsOptionalZodObject<TContext> extends true ? {\n    readonly context?: TContext;\n} : IsDefaultZodObject<TContext> extends true ? {\n    readonly context?: TContext;\n} : {\n    readonly context: TContext;\n};\n/**\n * Runtime information available to middleware (readonly).\n */\nexport type Runtime<TContext = unknown> = Partial<Omit<LangGraphRuntime<TContext>, \"context\" | \"configurable\">> & WithMaybeContext<TContext> & {\n    configurable?: {\n        thread_id?: string;\n        [key: string]: unknown;\n    };\n};\nexport type InternalAgentState<StructuredResponseType extends Record<string, unknown> | undefined = Record<string, unknown>> = {\n    messages: BaseMessage[];\n} & (StructuredResponseType extends ResponseFormatUndefined ? Record<string, never> : {\n    structuredResponse: StructuredResponseType;\n});\n/**\n * Helper type to check if a type is optional (includes undefined)\n */\ntype IsOptionalType<T> = undefined extends T ? true : false;\n/**\n * Extract non-undefined part of a union that includes undefined\n */\ntype ExtractNonUndefined<T> = T extends undefined ? never : T;\n/**\n * Helper type to check if all properties of a type are optional\n */\nexport type IsAllOptional<T> = undefined extends T ? true : IsOptionalType<T> extends true ? true : ExtractNonUndefined<T> extends Record<string, any> ? {} extends ExtractNonUndefined<T> ? true : false : IsOptionalType<T>;\n/**\n * Pregel options that are propagated to the agent\n */\ntype CreateAgentPregelOptions = \"configurable\" | \"durability\" | \"store\" | \"cache\" | \"signal\" | \"recursionLimit\" | \"maxConcurrency\" | \"timeout\";\n/**\n * Pregel stream options that are propagated to the agent\n */\ntype CreateAgentPregelStreamOptions = \"encoding\" | \"streamMode\";\n/**\n * Decide whether provided configuration requires a context\n */\nexport type InvokeConfiguration<ContextSchema extends Record<string, any>> = \n/**\n * If the context schema is a default object, `context` can be optional\n */\nContextSchema extends InteropZodDefault<any> ? BaseCallbackConfig & Partial<Pick<PregelOptions<any, any, any>, CreateAgentPregelOptions>> & {\n    context?: Partial<ContextSchema>;\n} : IsAllOptional<ContextSchema> extends true ? BaseCallbackConfig & Partial<Pick<PregelOptions<any, any, any>, CreateAgentPregelOptions>> & {\n    context?: Partial<ContextSchema>;\n} : BaseCallbackConfig & Partial<Pick<PregelOptions<any, any, any>, CreateAgentPregelOptions>> & WithMaybeContext<ContextSchema>;\nexport type StreamConfiguration<ContextSchema extends Record<string, any>, TStreamMode extends StreamMode | StreamMode[] | undefined, TEncoding extends \"text/event-stream\" | undefined> = \n/**\n * If the context schema is a default object, `context` can be optional\n */\nContextSchema extends InteropZodDefault<any> ? Partial<Pick<PregelOptions<any, any, any, TStreamMode, boolean, TEncoding>, CreateAgentPregelOptions>> & {\n    context?: Partial<ContextSchema>;\n} : IsAllOptional<ContextSchema> extends true ? Partial<Pick<PregelOptions<any, any, any, TStreamMode, boolean, TEncoding>, CreateAgentPregelOptions | CreateAgentPregelStreamOptions>> & {\n    context?: Partial<ContextSchema>;\n} : Partial<Pick<PregelOptions<any, any, any, TStreamMode, boolean, TEncoding>, CreateAgentPregelOptions | CreateAgentPregelStreamOptions>> & WithMaybeContext<ContextSchema>;\nexport {};\n//# sourceMappingURL=runtime.d.ts.map"],"mappings":"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"}

package/dist/agents/runtime.d.ts

@@ -71,9 +71,7 @@ type ExtractNonUndefined<T> = T extends undefined ? never : T;
 /**
  * Helper type to check if all properties of a type are optional
  */
-type IsAllOptional<T> =
-// If T includes undefined, then it's optional (can be omitted entirely)
-undefined extends T ? true : IsOptionalType<T> extends true ? true : ExtractNonUndefined<T> extends Record<string, any> ? {} extends ExtractNonUndefined<T> ? true : false : IsOptionalType<T>;
+type IsAllOptional<T> = undefined extends T ? true : IsOptionalType<T> extends true ? true : ExtractNonUndefined<T> extends Record<string, any> ? {} extends ExtractNonUndefined<T> ? true : false : IsOptionalType<T>;
 /**
  * Pregel options that are propagated to the agent
  */

package/dist/agents/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","names":["InteropZodOptional","InteropZodDefault","Runtime","LangGraphRuntime","PregelOptions","StreamMode","BaseMessage","BaseCallbackConfig","ResponseFormatUndefined","AgentBuiltInState","Record","IsOptionalZodObject","T","IsDefaultZodObject","WithMaybeContext","TContext","Omit","Partial","InternalAgentState","StructuredResponseType","IsOptionalType","ExtractNonUndefined","IsAllOptional","CreateAgentPregelOptions","CreateAgentPregelStreamOptions","InvokeConfiguration","ContextSchema","Pick","StreamConfiguration","TStreamMode","TEncoding"],"sources":["../../src/agents/runtime.d.ts"],"sourcesContent":["import type { InteropZodOptional } from \"@langchain/core/utils/types\";\nimport type { InteropZodDefault } from \"@langchain/core/utils/types\";\nimport type { Runtime as LangGraphRuntime, PregelOptions, StreamMode } from \"@langchain/langgraph\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport type { BaseCallbackConfig } from \"@langchain/core/callbacks/manager\";\nimport type { ResponseFormatUndefined } from \"./responses.js\";\n/**\n * Type for the agent's built-in state properties.\n */\nexport type AgentBuiltInState = {\n    /**\n     * Array of messages representing the conversation history.\n     *\n     * This includes all messages exchanged during the agent's execution:\n     * - Human messages: Input from the user\n     * - AI messages: Responses from the language model\n     * - Tool messages: Results from tool executions\n     * - System messages: System-level instructions or information\n     *\n     * Messages are accumulated throughout the agent's lifecycle and can be\n     * accessed or modified by middleware hooks during execution.\n     */\n    messages: BaseMessage[];\n    /**\n     * Structured response data returned by the agent when a `responseFormat` is configured.\n     *\n     * This property is only populated when you provide a `responseFormat` schema\n     * (as Zod or JSON schema) to the agent configuration. The agent will format\n     * its final output to match the specified schema and store it in this property.\n     *\n     * Note: The type is specified as `Record<string, unknown>` because TypeScript cannot\n     * infer the actual response format type in contexts like middleware, where the agent's\n     * generic type parameters are not accessible. You may need to cast this to your specific\n     * response type when accessing it.\n     */\n    structuredResponse?: Record<string, unknown>;\n};\n/**\n * Type helper to check if TContext is an optional Zod schema\n */\ntype IsOptionalZodObject<T> = T extends InteropZodOptional<any> ? true : false;\ntype IsDefaultZodObject<T> = T extends InteropZodDefault<any> ? true : false;\nexport type WithMaybeContext<TContext> = undefined extends TContext ? {\n    readonly context?: TContext;\n} : IsOptionalZodObject<TContext> extends true ? {\n    readonly context?: TContext;\n} : IsDefaultZodObject<TContext> extends true ? {\n    readonly context?: TContext;\n} : {\n    readonly context: TContext;\n};\n/**\n * Runtime information available to middleware (readonly).\n */\nexport type Runtime<TContext = unknown> = Partial<Omit<LangGraphRuntime<TContext>, \"context\" | \"configurable\">> & WithMaybeContext<TContext> & {\n    configurable?: {\n        thread_id?: string;\n        [key: string]: unknown;\n    };\n};\nexport type InternalAgentState<StructuredResponseType extends Record<string, unknown> | undefined = Record<string, unknown>> = {\n    messages: BaseMessage[];\n} & (StructuredResponseType extends ResponseFormatUndefined ? Record<string, never> : {\n    structuredResponse: StructuredResponseType;\n});\n/**\n * Helper type to check if a type is optional (includes undefined)\n */\ntype IsOptionalType<T> = undefined extends T ? true : false;\n/**\n * Extract non-undefined part of a union that includes undefined\n */\ntype ExtractNonUndefined<T> = T extends undefined ? never : T;\n/**\n * Helper type to check if all properties of a type are optional\n */\nexport type IsAllOptional<T> = undefined extends T ? true : IsOptionalType<T> extends true ? true : ExtractNonUndefined<T> extends Record<string, any> ? {} extends ExtractNonUndefined<T> ? true : false : IsOptionalType<T>;\n/**\n * Pregel options that are propagated to the agent\n */\ntype CreateAgentPregelOptions = \"configurable\" | \"durability\" | \"store\" | \"cache\" | \"signal\" | \"recursionLimit\" | \"maxConcurrency\" | \"timeout\";\n/**\n * Pregel stream options that are propagated to the agent\n */\ntype CreateAgentPregelStreamOptions = \"encoding\" | \"streamMode\";\n/**\n * Decide whether provided configuration requires a context\n */\nexport type InvokeConfiguration<ContextSchema extends Record<string, any>> = \n/**\n * If the context schema is a default object, `context` can be optional\n */\nContextSchema extends InteropZodDefault<any> ? BaseCallbackConfig & Partial<Pick<PregelOptions<any, any, any>, CreateAgentPregelOptions>> & {\n    context?: Partial<ContextSchema>;\n} : IsAllOptional<ContextSchema> extends true ? BaseCallbackConfig & Partial<Pick<PregelOptions<any, any, any>, CreateAgentPregelOptions>> & {\n    context?: Partial<ContextSchema>;\n} : BaseCallbackConfig & Partial<Pick<PregelOptions<any, any, any>, CreateAgentPregelOptions>> & WithMaybeContext<ContextSchema>;\nexport type StreamConfiguration<ContextSchema extends Record<string, any>, TStreamMode extends StreamMode | StreamMode[] | undefined, TEncoding extends \"text/event-stream\" | undefined> = \n/**\n * If the context schema is a default object, `context` can be optional\n */\nContextSchema extends InteropZodDefault<any> ? Partial<Pick<PregelOptions<any, any, any, TStreamMode, boolean, TEncoding>, CreateAgentPregelOptions>> & {\n    context?: Partial<ContextSchema>;\n} : IsAllOptional<ContextSchema> extends true ? Partial<Pick<PregelOptions<any, any, any, TStreamMode, boolean, TEncoding>, CreateAgentPregelOptions | CreateAgentPregelStreamOptions>> & {\n    context?: Partial<ContextSchema>;\n} : Partial<Pick<PregelOptions<any, any, any, TStreamMode, boolean, TEncoding>, CreateAgentPregelOptions | CreateAgentPregelStreamOptions>> & WithMaybeContext<ContextSchema>;\nexport {};\n//# sourceMappingURL=runtime.d.ts.map"],"mappings":"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"}

package/dist/agents/tests/utils.d.cts

@@ -22,15 +22,12 @@ interface FakeToolCallingModelFields {
   index?: number;
   structuredResponse?: any;
 }
-// Helper function to create checkpointer
-
 /**
  * Fake chat model for testing tool calling functionality
  */
 declare class FakeToolCallingModel extends BaseChatModel {
   toolCalls: ToolCall$1[][];
   toolStyle: "openai" | "anthropic";
-  // Use a shared reference object so the index persists across bindTools calls
   private indexRef;
   structuredResponse?: any;
   private tools;
@@ -46,7 +43,6 @@ declare class FakeToolCallingModel extends BaseChatModel {
       current: number;
     };
   });
-  // Getter/setter for backwards compatibility
   get index(): number;
   set index(value: number);
   _llmType(): string;