langchain 1.2.13 → 1.2.15

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # langchain
 
+## 1.2.15
+
+### Patch Changes
+
+- [#9891](https://github.com/langchain-ai/langchainjs/pull/9891) [`983b212`](https://github.com/langchain-ai/langchainjs/commit/983b2123eeaa32011b7021643ba8c37698dfe2be) Thanks [@christian-bromann](https://github.com/christian-bromann)! - fix(langchain): support StateSchema in middleware pipeline
+
+## 1.2.14
+
+### Patch Changes
+
+- [#9870](https://github.com/langchain-ai/langchainjs/pull/9870) [`070b4d1`](https://github.com/langchain-ai/langchainjs/commit/070b4d14121ee5d1f24c8ad980cd4548f39f19eb) Thanks [@maahir30](https://github.com/maahir30)! - fix(langchain): StateSchema handling in AgentNode middleware
+  - Added `toPartialZodObject` helper that correctly handles both Zod objects and LangGraph's StateSchema when parsing middleware state in AgentNode .
+
 ## 1.2.13
 
 ### Patch Changes

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

@@ -1 +1 @@
-{"version":3,"file":"hitl.d.cts","names":["__types_js7","z","ToolCall","InferInteropZodInput","AgentBuiltInState","Runtime","DescriptionFunctionSchema","Record","ZodTypeDef","ZodType","ZodUnknown","ZodTuple","ZodString","ZodPromise","ZodUnion","ZodFunction","DescriptionFactory","infer","DecisionType","ZodEnum","InterruptOnConfigSchema","ZodArray","ZodOptional","ZodAny","ZodRecord","ZodTypeAny","Promise","ZodObject","InterruptOnConfig","input","Action","ActionRequest","ReviewConfig","HITLRequest","ApproveDecision","EditDecision","RejectDecision","Decision","HITLResponse","contextSchema","ZodBoolean","ZodDefault","HumanInTheLoopMiddlewareConfig","humanInTheLoopMiddleware","NonNullable","_langchain_core_tools0","ServerTool","ClientTool","AgentMiddleware"],"sources":["../../../src/agents/middleware/hitl.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { ToolCall } from \"@langchain/core/messages\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\nimport type { AgentBuiltInState, Runtime } from \"../runtime.js\";\ndeclare const DescriptionFunctionSchema: z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>;\n/**\n * Function type that dynamically generates a description for a tool call approval request.\n *\n * @param toolCall - The tool call being reviewed\n * @param state - The current agent state\n * @param runtime - The agent runtime context\n * @returns A string description or Promise that resolves to a string description\n *\n * @example\n * ```typescript\n * import { type DescriptionFactory, type ToolCall } from \"langchain\";\n *\n * const descriptionFactory: DescriptionFactory = (toolCall, state, runtime) => {\n *   return `Please review: ${toolCall.name}(${JSON.stringify(toolCall.args)})`;\n * };\n * ```\n */\nexport type DescriptionFactory = z.infer<typeof DescriptionFunctionSchema>;\ndeclare const DecisionType: z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>;\nexport type DecisionType = z.infer<typeof DecisionType>;\ndeclare const InterruptOnConfigSchema: z.ZodObject<{\n    /**\n     * The decisions that are allowed for this action.\n     */\n    allowedDecisions: z.ZodArray<z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>, \"many\">;\n    /**\n     * The description attached to the request for human input.\n     * Can be either:\n     * - A static string describing the approval request\n     * - A callable that dynamically generates the description based on agent state,\n     *   runtime, and tool call information\n     *\n     * @example\n     * Static string description\n     * ```typescript\n     * import type { InterruptOnConfig } from \"langchain\";\n     *\n     * const config: InterruptOnConfig = {\n     *   allowedDecisions: [\"approve\", \"reject\"],\n     *   description: \"Please review this tool execution\"\n     * };\n     * ```\n     *\n     * @example\n     * Dynamic callable description\n     * ```typescript\n     * import type {\n     *   AgentBuiltInState,\n     *   Runtime,\n     *   DescriptionFactory,\n     *   ToolCall,\n     *   InterruptOnConfig\n     * } from \"langchain\";\n     *\n     * const formatToolDescription: DescriptionFactory = (\n     *   toolCall: ToolCall,\n     *   state: AgentBuiltInState,\n     *   runtime: Runtime<unknown>\n     * ) => {\n     *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n     * };\n     *\n     * const config: InterruptOnConfig = {\n     *   allowedDecisions: [\"approve\", \"edit\"],\n     *   description: formatToolDescription\n     * };\n     * ```\n     */\n    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;\n    /**\n     * JSON schema for the arguments associated with the action, if edits are allowed.\n     */\n    argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;\n}, \"strip\", z.ZodTypeAny, {\n    allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n    description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n    argsSchema?: Record<string, any> | undefined;\n}, {\n    allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n    description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n    argsSchema?: Record<string, any> | undefined;\n}>;\nexport type InterruptOnConfig = z.input<typeof InterruptOnConfigSchema>;\n/**\n * Represents an action with a name and arguments.\n */\nexport interface Action {\n    /**\n     * The type or name of action being requested (e.g., \"add_numbers\").\n     */\n    name: string;\n    /**\n     * Key-value pairs of arguments needed for the action (e.g., {\"a\": 1, \"b\": 2}).\n     */\n    args: Record<string, any>;\n}\n/**\n * Represents an action request with a name, arguments, and description.\n */\nexport interface ActionRequest {\n    /**\n     * The name of the action being requested.\n     */\n    name: string;\n    /**\n     * Key-value pairs of arguments needed for the action (e.g., {\"a\": 1, \"b\": 2}).\n     */\n    args: Record<string, any>;\n    /**\n     * The description of the action to be reviewed.\n     */\n    description?: string;\n}\n/**\n * Policy for reviewing a HITL request.\n */\nexport interface ReviewConfig {\n    /**\n     * Name of the action associated with this review configuration.\n     */\n    actionName: string;\n    /**\n     * The decisions that are allowed for this request.\n     */\n    allowedDecisions: DecisionType[];\n    /**\n     * JSON schema for the arguments associated with the action, if edits are allowed.\n     */\n    argsSchema?: Record<string, any>;\n}\n/**\n * Request for human feedback on a sequence of actions requested by a model.\n *\n * @example\n * ```ts\n * const hitlRequest: HITLRequest = {\n *   actionRequests: [\n *     { name: \"send_email\", args: { to: \"user@example.com\", subject: \"Hello\" } }\n *   ],\n *   reviewConfigs: [\n *     {\n *       actionName: \"send_email\",\n *       allowedDecisions: [\"approve\", \"edit\", \"reject\"],\n *       description: \"Please review the email before sending\"\n *     }\n *   ]\n * };\n * const response = interrupt(hitlRequest);\n * ```\n */\nexport interface HITLRequest {\n    /**\n     * A list of agent actions for human review.\n     */\n    actionRequests: ActionRequest[];\n    /**\n     * Review configuration for all possible actions.\n     */\n    reviewConfigs: ReviewConfig[];\n}\n/**\n * Response when a human approves the action.\n */\nexport interface ApproveDecision {\n    type: \"approve\";\n}\n/**\n * Response when a human edits the action.\n */\nexport interface EditDecision {\n    type: \"edit\";\n    /**\n     * Edited action for the agent to perform.\n     * Ex: for a tool call, a human reviewer can edit the tool name and args.\n     */\n    editedAction: Action;\n}\n/**\n * Response when a human rejects the action.\n */\nexport interface RejectDecision {\n    type: \"reject\";\n    /**\n     * The message sent to the model explaining why the action was rejected.\n     */\n    message?: string;\n}\n/**\n * Union of all possible decision types.\n */\nexport type Decision = ApproveDecision | EditDecision | RejectDecision;\n/**\n * Response payload for a HITLRequest.\n */\nexport interface HITLResponse {\n    /**\n     * The decisions made by the human.\n     */\n    decisions: Decision[];\n}\ndeclare const contextSchema: z.ZodObject<{\n    /**\n     * Mapping of tool name to allowed reviewer responses.\n     * If a tool doesn't have an entry, it's auto-approved by default.\n     *\n     * - `true` -> pause for approval and allow approve/edit/reject decisions\n     * - `false` -> auto-approve (no human review)\n     * - `InterruptOnConfig` -> explicitly specify which decisions are allowed for this tool\n     */\n    interruptOn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{\n        /**\n         * The decisions that are allowed for this action.\n         */\n        allowedDecisions: z.ZodArray<z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>, \"many\">;\n        /**\n         * The description attached to the request for human input.\n         * Can be either:\n         * - A static string describing the approval request\n         * - A callable that dynamically generates the description based on agent state,\n         *   runtime, and tool call information\n         *\n         * @example\n         * Static string description\n         * ```typescript\n         * import type { InterruptOnConfig } from \"langchain\";\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"reject\"],\n         *   description: \"Please review this tool execution\"\n         * };\n         * ```\n         *\n         * @example\n         * Dynamic callable description\n         * ```typescript\n         * import type {\n         *   AgentBuiltInState,\n         *   Runtime,\n         *   DescriptionFactory,\n         *   ToolCall,\n         *   InterruptOnConfig\n         * } from \"langchain\";\n         *\n         * const formatToolDescription: DescriptionFactory = (\n         *   toolCall: ToolCall,\n         *   state: AgentBuiltInState,\n         *   runtime: Runtime<unknown>\n         * ) => {\n         *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n         * };\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"edit\"],\n         *   description: formatToolDescription\n         * };\n         * ```\n         */\n        description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;\n        /**\n         * JSON schema for the arguments associated with the action, if edits are allowed.\n         */\n        argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;\n    }, \"strip\", z.ZodTypeAny, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }>]>>>;\n    /**\n     * Prefix used when constructing human-facing approval messages.\n     * Provides context about the tool call being reviewed; does not change the underlying action.\n     *\n     * Note: This prefix is only applied for tools that do not provide a custom\n     * `description` via their {@link InterruptOnConfig}. If a tool specifies a custom\n     * `description`, that per-tool text is used and this prefix is ignored.\n     */\n    descriptionPrefix: z.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix: string;\n}, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix?: string | undefined;\n}>;\nexport type HumanInTheLoopMiddlewareConfig = InferInteropZodInput<typeof contextSchema>;\n/**\n * Creates a Human-in-the-Loop (HITL) middleware for tool approval and oversight.\n *\n * This middleware intercepts tool calls made by an AI agent and provides human oversight\n * capabilities before execution. It enables selective approval workflows where certain tools\n * require human intervention while others can execute automatically.\n *\n * A invocation result that has been interrupted by the middleware will have a `__interrupt__`\n * property that contains the interrupt request.\n *\n * ```ts\n * import { type HITLRequest, type HITLResponse } from \"langchain\";\n * import { type Interrupt } from \"langchain\";\n *\n * const result = await agent.invoke(request);\n * const interruptRequest = result.__interrupt__?.[0] as Interrupt<HITLRequest>;\n *\n * // Examine the action requests and review configs\n * const actionRequests = interruptRequest.value.actionRequests;\n * const reviewConfigs = interruptRequest.value.reviewConfigs;\n *\n * // Create decisions for each action\n * const resume: HITLResponse = {\n *   decisions: actionRequests.map((action, i) => {\n *     if (action.name === \"calculator\") {\n *       return { type: \"approve\" };\n *     } else if (action.name === \"write_file\") {\n *       return {\n *         type: \"edit\",\n *         editedAction: { name: \"write_file\", args: { filename: \"safe.txt\", content: \"Safe content\" } }\n *       };\n *     }\n *     return { type: \"reject\", message: \"Action not allowed\" };\n *   })\n * };\n *\n * // Resume with decisions\n * await agent.invoke(new Command({ resume }), config);\n * ```\n *\n * ## Features\n *\n * - **Selective Tool Approval**: Configure which tools require human approval\n * - **Multiple Decision Types**: Approve, edit, or reject tool calls\n * - **Asynchronous Workflow**: Uses LangGraph's interrupt mechanism for non-blocking approval\n * - **Custom Approval Messages**: Provide context-specific descriptions for approval requests\n *\n * ## Decision Types\n *\n * When a tool requires approval, the human operator can respond with:\n * - `approve`: Execute the tool with original arguments\n * - `edit`: Modify the tool name and/or arguments before execution\n * - `reject`: Provide a manual response instead of executing the tool\n *\n * @param options - Configuration options for the middleware\n * @param options.interruptOn - Per-tool configuration mapping tool names to their settings\n * @param options.interruptOn[toolName].allowedDecisions - Array of decision types allowed for this tool (e.g., [\"approve\", \"edit\", \"reject\"])\n * @param options.interruptOn[toolName].description - Custom approval message for the tool. Can be either a static string or a callable that dynamically generates the description based on agent state, runtime, and tool call information\n * @param options.interruptOn[toolName].argsSchema - JSON schema for the arguments associated with the action, if edits are allowed\n * @param options.descriptionPrefix - Default prefix for approval messages (default: \"Tool execution requires approval\"). Only used for tools that do not define a custom `description` in their InterruptOnConfig.\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @example\n * Basic usage with selective tool approval\n * ```typescript\n * import { humanInTheLoopMiddleware } from \"langchain\";\n * import { createAgent } from \"langchain\";\n *\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     // Interrupt write_file tool and allow edits or approvals\n *     \"write_file\": {\n *       allowedDecisions: [\"approve\", \"edit\"],\n *       description: \"⚠️ File write operation requires approval\"\n *     },\n *     // Auto-approve read_file tool\n *     \"read_file\": false\n *   }\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4\",\n *   tools: [writeFileTool, readFileTool],\n *   middleware: [hitlMiddleware]\n * });\n * ```\n *\n * @example\n * Handling approval requests\n * ```typescript\n * import { type HITLRequest, type HITLResponse, type Interrupt } from \"langchain\";\n * import { Command } from \"@langchain/langgraph\";\n *\n * // Initial agent invocation\n * const result = await agent.invoke({\n *   messages: [new HumanMessage(\"Write 'Hello' to output.txt\")]\n * }, config);\n *\n * // Check if agent is paused for approval\n * if (result.__interrupt__) {\n *   const interruptRequest = result.__interrupt__?.[0] as Interrupt<HITLRequest>;\n *\n *   // Show tool call details to user\n *   console.log(\"Actions:\", interruptRequest.value.actionRequests);\n *   console.log(\"Review configs:\", interruptRequest.value.reviewConfigs);\n *\n *   // Resume with approval\n *   const resume: HITLResponse = {\n *     decisions: [{ type: \"approve\" }]\n *   };\n *   await agent.invoke(\n *     new Command({ resume }),\n *     config\n *   );\n * }\n * ```\n *\n * @example\n * Different decision types\n * ```typescript\n * import { type HITLResponse } from \"langchain\";\n *\n * // Approve the tool call as-is\n * const resume: HITLResponse = {\n *   decisions: [{ type: \"approve\" }]\n * };\n *\n * // Edit the tool arguments\n * const resume: HITLResponse = {\n *   decisions: [{\n *     type: \"edit\",\n *     editedAction: { name: \"write_file\", args: { filename: \"safe.txt\", content: \"Modified\" } }\n *   }]\n * };\n *\n * // Reject with feedback\n * const resume: HITLResponse = {\n *   decisions: [{\n *     type: \"reject\",\n *     message: \"File operation not allowed in demo mode\"\n *   }]\n * };\n * ```\n *\n * @example\n * Production use case with database operations\n * ```typescript\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     \"execute_sql\": {\n *       allowedDecisions: [\"approve\", \"edit\", \"reject\"],\n *       description: \"🚨 SQL query requires DBA approval\\nPlease review for safety and performance\"\n *     },\n *     \"read_schema\": false,  // Reading metadata is safe\n *     \"delete_records\": {\n *       allowedDecisions: [\"approve\", \"reject\"],\n *       description: \"⛔ DESTRUCTIVE OPERATION - Requires manager approval\"\n *     }\n *   },\n *   descriptionPrefix: \"Database operation pending approval\"\n * });\n * ```\n *\n * @example\n * Using dynamic callable descriptions\n * ```typescript\n * import { type DescriptionFactory, type ToolCall } from \"langchain\";\n * import type { AgentBuiltInState, Runtime } from \"langchain/agents\";\n *\n * // Define a dynamic description factory\n * const formatToolDescription: DescriptionFactory = (\n *   toolCall: ToolCall,\n *   state: AgentBuiltInState,\n *   runtime: Runtime<unknown>\n * ) => {\n *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n * };\n *\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     \"write_file\": {\n *       allowedDecisions: [\"approve\", \"edit\"],\n *       // Use dynamic description that can access tool call, state, and runtime\n *       description: formatToolDescription\n *     },\n *     // Or use an inline function\n *     \"send_email\": {\n *       allowedDecisions: [\"approve\", \"reject\"],\n *       description: (toolCall, state, runtime) => {\n *         const { to, subject } = toolCall.args;\n *         return `Email to ${to}\\nSubject: ${subject}\\n\\nRequires approval before sending`;\n *       }\n *     }\n *   }\n * });\n * ```\n *\n * @remarks\n * - Tool calls are processed in the order they appear in the AI message\n * - Auto-approved tools execute immediately without interruption\n * - Multiple tools requiring approval are bundled into a single interrupt request\n * - The middleware operates in the `afterModel` phase, intercepting before tool execution\n * - Requires a checkpointer to maintain state across interruptions\n *\n * @see {@link createAgent} for agent creation\n * @see {@link Command} for resuming interrupted execution\n * @public\n */\nexport declare function humanInTheLoopMiddleware(options: NonNullable<HumanInTheLoopMiddlewareConfig>): import(\"./types.js\").AgentMiddleware<undefined, z.ZodObject<{\n    /**\n     * Mapping of tool name to allowed reviewer responses.\n     * If a tool doesn't have an entry, it's auto-approved by default.\n     *\n     * - `true` -> pause for approval and allow approve/edit/reject decisions\n     * - `false` -> auto-approve (no human review)\n     * - `InterruptOnConfig` -> explicitly specify which decisions are allowed for this tool\n     */\n    interruptOn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{\n        /**\n         * The decisions that are allowed for this action.\n         */\n        allowedDecisions: z.ZodArray<z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>, \"many\">;\n        /**\n         * The description attached to the request for human input.\n         * Can be either:\n         * - A static string describing the approval request\n         * - A callable that dynamically generates the description based on agent state,\n         *   runtime, and tool call information\n         *\n         * @example\n         * Static string description\n         * ```typescript\n         * import type { InterruptOnConfig } from \"langchain\";\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"reject\"],\n         *   description: \"Please review this tool execution\"\n         * };\n         * ```\n         *\n         * @example\n         * Dynamic callable description\n         * ```typescript\n         * import type {\n         *   AgentBuiltInState,\n         *   Runtime,\n         *   DescriptionFactory,\n         *   ToolCall,\n         *   InterruptOnConfig\n         * } from \"langchain\";\n         *\n         * const formatToolDescription: DescriptionFactory = (\n         *   toolCall: ToolCall,\n         *   state: AgentBuiltInState,\n         *   runtime: Runtime<unknown>\n         * ) => {\n         *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n         * };\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"edit\"],\n         *   description: formatToolDescription\n         * };\n         * ```\n         */\n        description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;\n        /**\n         * JSON schema for the arguments associated with the action, if edits are allowed.\n         */\n        argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;\n    }, \"strip\", z.ZodTypeAny, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }>]>>>;\n    /**\n     * Prefix used when constructing human-facing approval messages.\n     * Provides context about the tool call being reviewed; does not change the underlying action.\n     *\n     * Note: This prefix is only applied for tools that do not provide a custom\n     * `description` via their {@link InterruptOnConfig}. If a tool specifies a custom\n     * `description`, that per-tool text is used and this prefix is ignored.\n     */\n    descriptionPrefix: z.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix: string;\n}, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix?: string | undefined;\n}>, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix: string;\n}, readonly (import(\"@langchain/core/tools\").ServerTool | import(\"@langchain/core/tools\").ClientTool)[]>;\nexport {};\n//# sourceMappingURL=hitl.d.ts.map"],"mappings":"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"}
+{"version":3,"file":"hitl.d.cts","names":["__types_js7","z","ToolCall","InferInteropZodInput","AgentBuiltInState","Runtime","DescriptionFunctionSchema","Record","ZodTypeDef","ZodType","ZodUnknown","ZodTuple","ZodString","ZodPromise","ZodUnion","ZodFunction","DescriptionFactory","infer","DecisionType","ZodEnum","InterruptOnConfigSchema","ZodArray","ZodOptional","ZodAny","ZodRecord","ZodTypeAny","Promise","ZodObject","InterruptOnConfig","input","Action","ActionRequest","ReviewConfig","HITLRequest","ApproveDecision","EditDecision","RejectDecision","Decision","HITLResponse","contextSchema","ZodBoolean","ZodDefault","HumanInTheLoopMiddlewareConfig","humanInTheLoopMiddleware","NonNullable","_langchain_core_tools0","ServerTool","ClientTool","AgentMiddleware"],"sources":["../../../src/agents/middleware/hitl.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { ToolCall } from \"@langchain/core/messages\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\nimport type { AgentBuiltInState, Runtime } from \"../runtime.js\";\ndeclare const DescriptionFunctionSchema: z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>;\n/**\n * Function type that dynamically generates a description for a tool call approval request.\n *\n * @param toolCall - The tool call being reviewed\n * @param state - The current agent state\n * @param runtime - The agent runtime context\n * @returns A string description or Promise that resolves to a string description\n *\n * @example\n * ```typescript\n * import { type DescriptionFactory, type ToolCall } from \"langchain\";\n *\n * const descriptionFactory: DescriptionFactory = (toolCall, state, runtime) => {\n *   return `Please review: ${toolCall.name}(${JSON.stringify(toolCall.args)})`;\n * };\n * ```\n */\nexport type DescriptionFactory = z.infer<typeof DescriptionFunctionSchema>;\ndeclare const DecisionType: z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>;\nexport type DecisionType = z.infer<typeof DecisionType>;\ndeclare const InterruptOnConfigSchema: z.ZodObject<{\n    /**\n     * The decisions that are allowed for this action.\n     */\n    allowedDecisions: z.ZodArray<z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>, \"many\">;\n    /**\n     * The description attached to the request for human input.\n     * Can be either:\n     * - A static string describing the approval request\n     * - A callable that dynamically generates the description based on agent state,\n     *   runtime, and tool call information\n     *\n     * @example\n     * Static string description\n     * ```typescript\n     * import type { InterruptOnConfig } from \"langchain\";\n     *\n     * const config: InterruptOnConfig = {\n     *   allowedDecisions: [\"approve\", \"reject\"],\n     *   description: \"Please review this tool execution\"\n     * };\n     * ```\n     *\n     * @example\n     * Dynamic callable description\n     * ```typescript\n     * import type {\n     *   AgentBuiltInState,\n     *   Runtime,\n     *   DescriptionFactory,\n     *   ToolCall,\n     *   InterruptOnConfig\n     * } from \"langchain\";\n     *\n     * const formatToolDescription: DescriptionFactory = (\n     *   toolCall: ToolCall,\n     *   state: AgentBuiltInState,\n     *   runtime: Runtime<unknown>\n     * ) => {\n     *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n     * };\n     *\n     * const config: InterruptOnConfig = {\n     *   allowedDecisions: [\"approve\", \"edit\"],\n     *   description: formatToolDescription\n     * };\n     * ```\n     */\n    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;\n    /**\n     * JSON schema for the arguments associated with the action, if edits are allowed.\n     */\n    argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;\n}, \"strip\", z.ZodTypeAny, {\n    allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n    description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n    argsSchema?: Record<string, any> | undefined;\n}, {\n    allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n    description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n    argsSchema?: Record<string, any> | undefined;\n}>;\nexport type InterruptOnConfig = z.input<typeof InterruptOnConfigSchema>;\n/**\n * Represents an action with a name and arguments.\n */\nexport interface Action {\n    /**\n     * The type or name of action being requested (e.g., \"add_numbers\").\n     */\n    name: string;\n    /**\n     * Key-value pairs of arguments needed for the action (e.g., {\"a\": 1, \"b\": 2}).\n     */\n    args: Record<string, any>;\n}\n/**\n * Represents an action request with a name, arguments, and description.\n */\nexport interface ActionRequest {\n    /**\n     * The name of the action being requested.\n     */\n    name: string;\n    /**\n     * Key-value pairs of arguments needed for the action (e.g., {\"a\": 1, \"b\": 2}).\n     */\n    args: Record<string, any>;\n    /**\n     * The description of the action to be reviewed.\n     */\n    description?: string;\n}\n/**\n * Policy for reviewing a HITL request.\n */\nexport interface ReviewConfig {\n    /**\n     * Name of the action associated with this review configuration.\n     */\n    actionName: string;\n    /**\n     * The decisions that are allowed for this request.\n     */\n    allowedDecisions: DecisionType[];\n    /**\n     * JSON schema for the arguments associated with the action, if edits are allowed.\n     */\n    argsSchema?: Record<string, any>;\n}\n/**\n * Request for human feedback on a sequence of actions requested by a model.\n *\n * @example\n * ```ts\n * const hitlRequest: HITLRequest = {\n *   actionRequests: [\n *     { name: \"send_email\", args: { to: \"user@example.com\", subject: \"Hello\" } }\n *   ],\n *   reviewConfigs: [\n *     {\n *       actionName: \"send_email\",\n *       allowedDecisions: [\"approve\", \"edit\", \"reject\"],\n *       description: \"Please review the email before sending\"\n *     }\n *   ]\n * };\n * const response = interrupt(hitlRequest);\n * ```\n */\nexport interface HITLRequest {\n    /**\n     * A list of agent actions for human review.\n     */\n    actionRequests: ActionRequest[];\n    /**\n     * Review configuration for all possible actions.\n     */\n    reviewConfigs: ReviewConfig[];\n}\n/**\n * Response when a human approves the action.\n */\nexport interface ApproveDecision {\n    type: \"approve\";\n}\n/**\n * Response when a human edits the action.\n */\nexport interface EditDecision {\n    type: \"edit\";\n    /**\n     * Edited action for the agent to perform.\n     * Ex: for a tool call, a human reviewer can edit the tool name and args.\n     */\n    editedAction: Action;\n}\n/**\n * Response when a human rejects the action.\n */\nexport interface RejectDecision {\n    type: \"reject\";\n    /**\n     * The message sent to the model explaining why the action was rejected.\n     */\n    message?: string;\n}\n/**\n * Union of all possible decision types.\n */\nexport type Decision = ApproveDecision | EditDecision | RejectDecision;\n/**\n * Response payload for a HITLRequest.\n */\nexport interface HITLResponse {\n    /**\n     * The decisions made by the human.\n     */\n    decisions: Decision[];\n}\ndeclare const contextSchema: z.ZodObject<{\n    /**\n     * Mapping of tool name to allowed reviewer responses.\n     * If a tool doesn't have an entry, it's auto-approved by default.\n     *\n     * - `true` -> pause for approval and allow approve/edit/reject decisions\n     * - `false` -> auto-approve (no human review)\n     * - `InterruptOnConfig` -> explicitly specify which decisions are allowed for this tool\n     */\n    interruptOn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{\n        /**\n         * The decisions that are allowed for this action.\n         */\n        allowedDecisions: z.ZodArray<z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>, \"many\">;\n        /**\n         * The description attached to the request for human input.\n         * Can be either:\n         * - A static string describing the approval request\n         * - A callable that dynamically generates the description based on agent state,\n         *   runtime, and tool call information\n         *\n         * @example\n         * Static string description\n         * ```typescript\n         * import type { InterruptOnConfig } from \"langchain\";\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"reject\"],\n         *   description: \"Please review this tool execution\"\n         * };\n         * ```\n         *\n         * @example\n         * Dynamic callable description\n         * ```typescript\n         * import type {\n         *   AgentBuiltInState,\n         *   Runtime,\n         *   DescriptionFactory,\n         *   ToolCall,\n         *   InterruptOnConfig\n         * } from \"langchain\";\n         *\n         * const formatToolDescription: DescriptionFactory = (\n         *   toolCall: ToolCall,\n         *   state: AgentBuiltInState,\n         *   runtime: Runtime<unknown>\n         * ) => {\n         *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n         * };\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"edit\"],\n         *   description: formatToolDescription\n         * };\n         * ```\n         */\n        description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;\n        /**\n         * JSON schema for the arguments associated with the action, if edits are allowed.\n         */\n        argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;\n    }, \"strip\", z.ZodTypeAny, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }>]>>>;\n    /**\n     * Prefix used when constructing human-facing approval messages.\n     * Provides context about the tool call being reviewed; does not change the underlying action.\n     *\n     * Note: This prefix is only applied for tools that do not provide a custom\n     * `description` via their {@link InterruptOnConfig}. If a tool specifies a custom\n     * `description`, that per-tool text is used and this prefix is ignored.\n     */\n    descriptionPrefix: z.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix: string;\n}, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix?: string | undefined;\n}>;\nexport type HumanInTheLoopMiddlewareConfig = InferInteropZodInput<typeof contextSchema>;\n/**\n * Creates a Human-in-the-Loop (HITL) middleware for tool approval and oversight.\n *\n * This middleware intercepts tool calls made by an AI agent and provides human oversight\n * capabilities before execution. It enables selective approval workflows where certain tools\n * require human intervention while others can execute automatically.\n *\n * A invocation result that has been interrupted by the middleware will have a `__interrupt__`\n * property that contains the interrupt request.\n *\n * ```ts\n * import { type HITLRequest, type HITLResponse } from \"langchain\";\n * import { type Interrupt } from \"langchain\";\n *\n * const result = await agent.invoke(request);\n * const interruptRequest = result.__interrupt__?.[0] as Interrupt<HITLRequest>;\n *\n * // Examine the action requests and review configs\n * const actionRequests = interruptRequest.value.actionRequests;\n * const reviewConfigs = interruptRequest.value.reviewConfigs;\n *\n * // Create decisions for each action\n * const resume: HITLResponse = {\n *   decisions: actionRequests.map((action, i) => {\n *     if (action.name === \"calculator\") {\n *       return { type: \"approve\" };\n *     } else if (action.name === \"write_file\") {\n *       return {\n *         type: \"edit\",\n *         editedAction: { name: \"write_file\", args: { filename: \"safe.txt\", content: \"Safe content\" } }\n *       };\n *     }\n *     return { type: \"reject\", message: \"Action not allowed\" };\n *   })\n * };\n *\n * // Resume with decisions\n * await agent.invoke(new Command({ resume }), config);\n * ```\n *\n * ## Features\n *\n * - **Selective Tool Approval**: Configure which tools require human approval\n * - **Multiple Decision Types**: Approve, edit, or reject tool calls\n * - **Asynchronous Workflow**: Uses LangGraph's interrupt mechanism for non-blocking approval\n * - **Custom Approval Messages**: Provide context-specific descriptions for approval requests\n *\n * ## Decision Types\n *\n * When a tool requires approval, the human operator can respond with:\n * - `approve`: Execute the tool with original arguments\n * - `edit`: Modify the tool name and/or arguments before execution\n * - `reject`: Provide a manual response instead of executing the tool\n *\n * @param options - Configuration options for the middleware\n * @param options.interruptOn - Per-tool configuration mapping tool names to their settings\n * @param options.interruptOn[toolName].allowedDecisions - Array of decision types allowed for this tool (e.g., [\"approve\", \"edit\", \"reject\"])\n * @param options.interruptOn[toolName].description - Custom approval message for the tool. Can be either a static string or a callable that dynamically generates the description based on agent state, runtime, and tool call information\n * @param options.interruptOn[toolName].argsSchema - JSON schema for the arguments associated with the action, if edits are allowed\n * @param options.descriptionPrefix - Default prefix for approval messages (default: \"Tool execution requires approval\"). Only used for tools that do not define a custom `description` in their InterruptOnConfig.\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @example\n * Basic usage with selective tool approval\n * ```typescript\n * import { humanInTheLoopMiddleware } from \"langchain\";\n * import { createAgent } from \"langchain\";\n *\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     // Interrupt write_file tool and allow edits or approvals\n *     \"write_file\": {\n *       allowedDecisions: [\"approve\", \"edit\"],\n *       description: \"⚠️ File write operation requires approval\"\n *     },\n *     // Auto-approve read_file tool\n *     \"read_file\": false\n *   }\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4\",\n *   tools: [writeFileTool, readFileTool],\n *   middleware: [hitlMiddleware]\n * });\n * ```\n *\n * @example\n * Handling approval requests\n * ```typescript\n * import { type HITLRequest, type HITLResponse, type Interrupt } from \"langchain\";\n * import { Command } from \"@langchain/langgraph\";\n *\n * // Initial agent invocation\n * const result = await agent.invoke({\n *   messages: [new HumanMessage(\"Write 'Hello' to output.txt\")]\n * }, config);\n *\n * // Check if agent is paused for approval\n * if (result.__interrupt__) {\n *   const interruptRequest = result.__interrupt__?.[0] as Interrupt<HITLRequest>;\n *\n *   // Show tool call details to user\n *   console.log(\"Actions:\", interruptRequest.value.actionRequests);\n *   console.log(\"Review configs:\", interruptRequest.value.reviewConfigs);\n *\n *   // Resume with approval\n *   const resume: HITLResponse = {\n *     decisions: [{ type: \"approve\" }]\n *   };\n *   await agent.invoke(\n *     new Command({ resume }),\n *     config\n *   );\n * }\n * ```\n *\n * @example\n * Different decision types\n * ```typescript\n * import { type HITLResponse } from \"langchain\";\n *\n * // Approve the tool call as-is\n * const resume: HITLResponse = {\n *   decisions: [{ type: \"approve\" }]\n * };\n *\n * // Edit the tool arguments\n * const resume: HITLResponse = {\n *   decisions: [{\n *     type: \"edit\",\n *     editedAction: { name: \"write_file\", args: { filename: \"safe.txt\", content: \"Modified\" } }\n *   }]\n * };\n *\n * // Reject with feedback\n * const resume: HITLResponse = {\n *   decisions: [{\n *     type: \"reject\",\n *     message: \"File operation not allowed in demo mode\"\n *   }]\n * };\n * ```\n *\n * @example\n * Production use case with database operations\n * ```typescript\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     \"execute_sql\": {\n *       allowedDecisions: [\"approve\", \"edit\", \"reject\"],\n *       description: \"🚨 SQL query requires DBA approval\\nPlease review for safety and performance\"\n *     },\n *     \"read_schema\": false,  // Reading metadata is safe\n *     \"delete_records\": {\n *       allowedDecisions: [\"approve\", \"reject\"],\n *       description: \"⛔ DESTRUCTIVE OPERATION - Requires manager approval\"\n *     }\n *   },\n *   descriptionPrefix: \"Database operation pending approval\"\n * });\n * ```\n *\n * @example\n * Using dynamic callable descriptions\n * ```typescript\n * import { type DescriptionFactory, type ToolCall } from \"langchain\";\n * import type { AgentBuiltInState, Runtime } from \"langchain/agents\";\n *\n * // Define a dynamic description factory\n * const formatToolDescription: DescriptionFactory = (\n *   toolCall: ToolCall,\n *   state: AgentBuiltInState,\n *   runtime: Runtime<unknown>\n * ) => {\n *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n * };\n *\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     \"write_file\": {\n *       allowedDecisions: [\"approve\", \"edit\"],\n *       // Use dynamic description that can access tool call, state, and runtime\n *       description: formatToolDescription\n *     },\n *     // Or use an inline function\n *     \"send_email\": {\n *       allowedDecisions: [\"approve\", \"reject\"],\n *       description: (toolCall, state, runtime) => {\n *         const { to, subject } = toolCall.args;\n *         return `Email to ${to}\\nSubject: ${subject}\\n\\nRequires approval before sending`;\n *       }\n *     }\n *   }\n * });\n * ```\n *\n * @remarks\n * - Tool calls are processed in the order they appear in the AI message\n * - Auto-approved tools execute immediately without interruption\n * - Multiple tools requiring approval are bundled into a single interrupt request\n * - The middleware operates in the `afterModel` phase, intercepting before tool execution\n * - Requires a checkpointer to maintain state across interruptions\n *\n * @see {@link createAgent} for agent creation\n * @see {@link Command} for resuming interrupted execution\n * @public\n */\nexport declare function humanInTheLoopMiddleware(options: NonNullable<HumanInTheLoopMiddlewareConfig>): import(\"./types.js\").AgentMiddleware<undefined, z.ZodObject<{\n    /**\n     * Mapping of tool name to allowed reviewer responses.\n     * If a tool doesn't have an entry, it's auto-approved by default.\n     *\n     * - `true` -> pause for approval and allow approve/edit/reject decisions\n     * - `false` -> auto-approve (no human review)\n     * - `InterruptOnConfig` -> explicitly specify which decisions are allowed for this tool\n     */\n    interruptOn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{\n        /**\n         * The decisions that are allowed for this action.\n         */\n        allowedDecisions: z.ZodArray<z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>, \"many\">;\n        /**\n         * The description attached to the request for human input.\n         * Can be either:\n         * - A static string describing the approval request\n         * - A callable that dynamically generates the description based on agent state,\n         *   runtime, and tool call information\n         *\n         * @example\n         * Static string description\n         * ```typescript\n         * import type { InterruptOnConfig } from \"langchain\";\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"reject\"],\n         *   description: \"Please review this tool execution\"\n         * };\n         * ```\n         *\n         * @example\n         * Dynamic callable description\n         * ```typescript\n         * import type {\n         *   AgentBuiltInState,\n         *   Runtime,\n         *   DescriptionFactory,\n         *   ToolCall,\n         *   InterruptOnConfig\n         * } from \"langchain\";\n         *\n         * const formatToolDescription: DescriptionFactory = (\n         *   toolCall: ToolCall,\n         *   state: AgentBuiltInState,\n         *   runtime: Runtime<unknown>\n         * ) => {\n         *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n         * };\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"edit\"],\n         *   description: formatToolDescription\n         * };\n         * ```\n         */\n        description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;\n        /**\n         * JSON schema for the arguments associated with the action, if edits are allowed.\n         */\n        argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;\n    }, \"strip\", z.ZodTypeAny, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }>]>>>;\n    /**\n     * Prefix used when constructing human-facing approval messages.\n     * Provides context about the tool call being reviewed; does not change the underlying action.\n     *\n     * Note: This prefix is only applied for tools that do not provide a custom\n     * `description` via their {@link InterruptOnConfig}. If a tool specifies a custom\n     * `description`, that per-tool text is used and this prefix is ignored.\n     */\n    descriptionPrefix: z.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix: string;\n}, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix?: string | undefined;\n}>, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix: string;\n}, readonly (import(\"@langchain/core/tools\").ServerTool | import(\"@langchain/core/tools\").ClientTool)[]>;\nexport {};\n//# sourceMappingURL=hitl.d.ts.map"],"mappings":"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"}

package/dist/agents/nodes/AgentNode.cjs

@@ -193,7 +193,7 @@ var AgentNode = class extends require_RunnableCallable.RunnableCallable {
 					const requestWithStateAndRuntime = {
 						...request,
 						state: {
-							...middleware.stateSchema ? (0, __langchain_core_utils_types.interopParse)((0, __langchain_core_utils_types.interopZodObjectPartial)(middleware.stateSchema), state) : {},
+							...middleware.stateSchema ? (0, __langchain_core_utils_types.interopParse)(require_utils$1.toPartialZodObject(middleware.stateSchema), state) : {},
 							...currentGetState(),
 							messages: state.messages
 						},

package/dist/agents/nodes/AgentNode.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"AgentNode.cjs","names":["response: unknown","AIMessage","RunnableCallable","options: AgentNodeOptions<StructuredResponseFormat, ContextSchema>","#run","#options","#systemMessage","model: string | LanguageModelLike","transformResponseFormat","ProviderStrategy","ToolStrategy","state: InternalAgentState<StructuredResponseFormat>","config: RunnableConfig","ToolMessage","#invokeModel","Command","#areMoreStepsNeeded","initChatModel","options: {\n      lastMessage?: string;\n    }","#deriveModel","request: ModelRequest","validateLLMHasNoBoundTools","#getResponseFormat","#bindTools","#currentSystemMessage","mergeAbortSignals","#handleMultipleStructuredOutputs","#handleSingleStructuredOutput","wrappedHandler: (\n      request: ModelRequest<\n        InternalAgentState<StructuredResponseFormat>,\n        unknown\n      >\n    ) => Promise<InternalModelResponse<StructuredResponseFormat>>","request: ModelRequest<\n            InternalAgentState<StructuredResponseFormat>,\n            unknown\n          >","runtime: Runtime<unknown>","requestWithStateAndRuntime: ModelRequest<\n            InternalAgentState<StructuredResponseFormat>,\n            unknown\n          >","req: ModelRequest<\n              InternalAgentState<StructuredResponseFormat>,\n              unknown\n            >","isClientTool","SystemMessage","MiddlewareError","initialRequest: ModelRequest<\n      InternalAgentState<StructuredResponseFormat>,\n      unknown\n    >","response: AIMessage","toolCalls: ToolCall[]","responseFormat: ToolResponseFormat","MultipleStructuredOutputsError","#handleToolStrategyError","toolCall: ToolCall","lastMessage?: string","error: ToolStrategyError","response: BaseMessage","hasToolCalls","model: LanguageModelLike","preparedOptions: ModelRequest | undefined","structuredResponseFormat: ResponseFormat | undefined","options: Partial<BaseChatModelCallOptions>","bindTools","withAgentName"],"sources":["../../../src/agents/nodes/AgentNode.ts"],"sourcesContent":["/* eslint-disable no-instanceof/no-instanceof */\nimport { Runnable, RunnableConfig } from \"@langchain/core/runnables\";\nimport {\n  BaseMessage,\n  AIMessage,\n  ToolMessage,\n  SystemMessage,\n} from \"@langchain/core/messages\";\nimport { Command, type LangGraphRunnableConfig } from \"@langchain/langgraph\";\nimport { type LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { type BaseChatModelCallOptions } from \"@langchain/core/language_models/chat_models\";\nimport {\n  InteropZodObject,\n  getSchemaDescription,\n  interopParse,\n  interopZodObjectPartial,\n} from \"@langchain/core/utils/types\";\nimport { raceWithSignal } from \"@langchain/core/runnables\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport type { ClientTool, ServerTool } from \"@langchain/core/tools\";\n\nimport { initChatModel } from \"../../chat_models/universal.js\";\nimport { MultipleStructuredOutputsError, MiddlewareError } from \"../errors.js\";\nimport { RunnableCallable } from \"../RunnableCallable.js\";\nimport {\n  bindTools,\n  validateLLMHasNoBoundTools,\n  hasToolCalls,\n  isClientTool,\n} from \"../utils.js\";\nimport { mergeAbortSignals } from \"../nodes/utils.js\";\nimport { CreateAgentParams } from \"../types.js\";\nimport type { InternalAgentState, Runtime } from \"../runtime.js\";\nimport type {\n  AgentMiddleware,\n  AnyAnnotationRoot,\n  WrapModelCallHandler,\n} from \"../middleware/types.js\";\nimport type { ModelRequest } from \"./types.js\";\nimport { withAgentName } from \"../withAgentName.js\";\nimport {\n  ToolStrategy,\n  ProviderStrategy,\n  transformResponseFormat,\n  ToolStrategyError,\n} from \"../responses.js\";\n\ntype ResponseHandlerResult<StructuredResponseFormat> =\n  | {\n      structuredResponse: StructuredResponseFormat;\n      messages: BaseMessage[];\n    }\n  | Promise<Command>;\n\n/**\n * Wrap the base handler with middleware wrapModelCall hooks\n * Middleware are composed so the first middleware is the outermost wrapper\n * Example: [auth, retry, cache] means auth wraps retry wraps cache wraps baseHandler\n */\ntype InternalModelResponse<StructuredResponseFormat> =\n  | AIMessage\n  | ResponseHandlerResult<StructuredResponseFormat>;\n\n/**\n * Check if the response is an internal model response.\n * @param response - The response to check.\n * @returns True if the response is an internal model response, false otherwise.\n */\nfunction isInternalModelResponse<StructuredResponseFormat>(\n  response: unknown\n): response is InternalModelResponse<StructuredResponseFormat> {\n  return (\n    AIMessage.isInstance(response) ||\n    (typeof response === \"object\" &&\n      response !== null &&\n      \"structuredResponse\" in response &&\n      \"messages\" in response)\n  );\n}\n\n/**\n * The name of the agent node in the state graph.\n */\nexport const AGENT_NODE_NAME = \"model_request\";\n\nexport interface AgentNodeOptions<\n  StructuredResponseFormat extends Record<string, unknown> = Record<\n    string,\n    unknown\n  >,\n  StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot,\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n> extends Pick<\n    CreateAgentParams<StructuredResponseFormat, StateSchema, ContextSchema>,\n    \"model\" | \"includeAgentName\" | \"name\" | \"responseFormat\" | \"middleware\"\n  > {\n  toolClasses: (ClientTool | ServerTool)[];\n  shouldReturnDirect: Set<string>;\n  signal?: AbortSignal;\n  systemMessage: SystemMessage;\n  wrapModelCallHookMiddleware?: [\n    AgentMiddleware,\n    () => Record<string, unknown>,\n  ][];\n}\n\ninterface NativeResponseFormat {\n  type: \"native\";\n  strategy: ProviderStrategy;\n}\n\ninterface ToolResponseFormat {\n  type: \"tool\";\n  tools: Record<string, ToolStrategy>;\n}\n\ntype ResponseFormat = NativeResponseFormat | ToolResponseFormat;\n\nexport class AgentNode<\n  StructuredResponseFormat extends Record<string, unknown> = Record<\n    string,\n    unknown\n  >,\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n> extends RunnableCallable<\n  InternalAgentState<StructuredResponseFormat>,\n  | (\n      | { messages: BaseMessage[] }\n      | { structuredResponse: StructuredResponseFormat }\n    )\n  | Command\n> {\n  #options: AgentNodeOptions<StructuredResponseFormat, ContextSchema>;\n  #systemMessage: SystemMessage;\n  #currentSystemMessage: SystemMessage;\n\n  constructor(\n    options: AgentNodeOptions<StructuredResponseFormat, ContextSchema>\n  ) {\n    super({\n      name: options.name ?? \"model\",\n      func: (input, config) => this.#run(input, config as RunnableConfig),\n    });\n\n    this.#options = options;\n    this.#systemMessage = options.systemMessage;\n  }\n\n  /**\n   * Returns response format primtivies based on given model and response format provided by the user.\n   *\n   * If the user selects a tool output:\n   * - return a record of tools to extract structured output from the model's response\n   *\n   * if the the user selects a native schema output or if the model supports JSON schema output:\n   * - return a provider strategy to extract structured output from the model's response\n   *\n   * @param model - The model to get the response format for.\n   * @returns The response format.\n   */\n  #getResponseFormat(\n    model: string | LanguageModelLike\n  ): ResponseFormat | undefined {\n    if (!this.#options.responseFormat) {\n      return undefined;\n    }\n\n    const strategies = transformResponseFormat(\n      this.#options.responseFormat,\n      undefined,\n      model\n    );\n\n    /**\n     * we either define a list of provider strategies or a list of tool strategies\n     */\n    const isProviderStrategy = strategies.every(\n      (format) => format instanceof ProviderStrategy\n    );\n\n    /**\n     * Populate a list of structured tool info.\n     */\n    if (!isProviderStrategy) {\n      return {\n        type: \"tool\",\n        tools: (\n          strategies.filter(\n            (format) => format instanceof ToolStrategy\n          ) as ToolStrategy[]\n        ).reduce(\n          (acc, format) => {\n            acc[format.name] = format;\n            return acc;\n          },\n          {} as Record<string, ToolStrategy>\n        ),\n      };\n    }\n\n    return {\n      type: \"native\",\n      /**\n       * there can only be one provider strategy\n       */\n      strategy: strategies[0] as ProviderStrategy,\n    };\n  }\n\n  async #run(\n    state: InternalAgentState<StructuredResponseFormat>,\n    config: RunnableConfig\n  ) {\n    /**\n     * Check if we just executed a returnDirect tool\n     * If so, we should generate structured response (if needed) and stop\n     */\n    const lastMessage = state.messages.at(-1);\n    if (\n      lastMessage &&\n      ToolMessage.isInstance(lastMessage) &&\n      lastMessage.name &&\n      this.#options.shouldReturnDirect.has(lastMessage.name)\n    ) {\n      /**\n       * return directly without invoking the model again\n       */\n      return { messages: [] };\n    }\n\n    const response = await this.#invokeModel(state, config);\n\n    /**\n     * if we were able to generate a structured response, return it\n     */\n    if (\"structuredResponse\" in response) {\n      return {\n        messages: [...state.messages, ...(response.messages || [])],\n        structuredResponse: response.structuredResponse,\n      };\n    }\n\n    /**\n     * if we need to direct the agent to the model, return the update\n     */\n    if (response instanceof Command) {\n      return response;\n    }\n\n    response.name = this.name;\n    response.lc_kwargs.name = this.name;\n\n    if (this.#areMoreStepsNeeded(state, response)) {\n      return {\n        messages: [\n          new AIMessage({\n            content: \"Sorry, need more steps to process this request.\",\n            name: this.name,\n            id: response.id,\n          }),\n        ],\n      };\n    }\n\n    return { messages: [response] };\n  }\n\n  /**\n   * Derive the model from the options.\n   * @param state - The state of the agent.\n   * @param config - The config of the agent.\n   * @returns The model.\n   */\n  #deriveModel() {\n    if (typeof this.#options.model === \"string\") {\n      return initChatModel(this.#options.model);\n    }\n\n    if (this.#options.model) {\n      return this.#options.model;\n    }\n\n    throw new Error(\"No model option was provided, either via `model` option.\");\n  }\n\n  async #invokeModel(\n    state: InternalAgentState<StructuredResponseFormat>,\n    config: RunnableConfig,\n    options: {\n      lastMessage?: string;\n    } = {}\n  ): Promise<AIMessage | ResponseHandlerResult<StructuredResponseFormat>> {\n    const model = await this.#deriveModel();\n    const lgConfig = config as LangGraphRunnableConfig;\n\n    /**\n     * Create the base handler that performs the actual model invocation\n     */\n    const baseHandler = async (\n      request: ModelRequest\n    ): Promise<AIMessage | ResponseHandlerResult<StructuredResponseFormat>> => {\n      /**\n       * Check if the LLM already has bound tools and throw if it does.\n       */\n      validateLLMHasNoBoundTools(request.model);\n\n      const structuredResponseFormat = this.#getResponseFormat(request.model);\n      const modelWithTools = await this.#bindTools(\n        request.model,\n        request,\n        structuredResponseFormat\n      );\n\n      /**\n       * prepend the system message to the messages if it is not empty\n       */\n      const messages = [\n        ...(this.#currentSystemMessage.text === \"\"\n          ? []\n          : [this.#currentSystemMessage]),\n        ...request.messages,\n      ];\n\n      const signal = mergeAbortSignals(this.#options.signal, config.signal);\n      const response = (await raceWithSignal(\n        modelWithTools.invoke(messages, {\n          ...config,\n          signal,\n        }),\n        signal\n      )) as AIMessage;\n\n      /**\n       * if the user requests a native schema output, try to parse the response\n       * and return the structured response if it is valid\n       */\n      if (structuredResponseFormat?.type === \"native\") {\n        const structuredResponse =\n          structuredResponseFormat.strategy.parse(response);\n        if (structuredResponse) {\n          return { structuredResponse, messages: [response] };\n        }\n\n        return response;\n      }\n\n      if (!structuredResponseFormat || !response.tool_calls) {\n        return response;\n      }\n\n      const toolCalls = response.tool_calls.filter(\n        (call) => call.name in structuredResponseFormat.tools\n      );\n\n      /**\n       * if there were not structured tool calls, we can return the response\n       */\n      if (toolCalls.length === 0) {\n        return response;\n      }\n\n      /**\n       * if there were multiple structured tool calls, we should throw an error as this\n       * scenario is not defined/supported.\n       */\n      if (toolCalls.length > 1) {\n        return this.#handleMultipleStructuredOutputs(\n          response,\n          toolCalls,\n          structuredResponseFormat\n        );\n      }\n\n      const toolStrategy = structuredResponseFormat.tools[toolCalls[0].name];\n      const toolMessageContent = toolStrategy?.options?.toolMessageContent;\n      return this.#handleSingleStructuredOutput(\n        response,\n        toolCalls[0],\n        structuredResponseFormat,\n        toolMessageContent ?? options.lastMessage\n      );\n    };\n\n    const wrapperMiddleware = this.#options.wrapModelCallHookMiddleware ?? [];\n    let wrappedHandler: (\n      request: ModelRequest<\n        InternalAgentState<StructuredResponseFormat>,\n        unknown\n      >\n    ) => Promise<InternalModelResponse<StructuredResponseFormat>> = baseHandler;\n\n    /**\n     * Build composed handler from last to first so first middleware becomes outermost\n     */\n    for (let i = wrapperMiddleware.length - 1; i >= 0; i--) {\n      const [middleware, getMiddlewareState] = wrapperMiddleware[i];\n      if (middleware.wrapModelCall) {\n        const innerHandler = wrappedHandler;\n        const currentMiddleware = middleware;\n        const currentGetState = getMiddlewareState;\n\n        wrappedHandler = async (\n          request: ModelRequest<\n            InternalAgentState<StructuredResponseFormat>,\n            unknown\n          >\n        ): Promise<InternalModelResponse<StructuredResponseFormat>> => {\n          /**\n           * Merge context with default context of middleware\n           */\n          const context = currentMiddleware.contextSchema\n            ? interopParse(\n                currentMiddleware.contextSchema,\n                lgConfig?.context || {}\n              )\n            : lgConfig?.context;\n\n          /**\n           * Create runtime\n           */\n          const runtime: Runtime<unknown> = Object.freeze({\n            context,\n            writer: lgConfig.writer,\n            interrupt: lgConfig.interrupt,\n            signal: lgConfig.signal,\n          });\n\n          /**\n           * Create the request with state and runtime\n           */\n          const requestWithStateAndRuntime: ModelRequest<\n            InternalAgentState<StructuredResponseFormat>,\n            unknown\n          > = {\n            ...request,\n            state: {\n              ...(middleware.stateSchema\n                ? interopParse(\n                    interopZodObjectPartial(middleware.stateSchema),\n                    state\n                  )\n                : {}),\n              ...currentGetState(),\n              messages: state.messages,\n            } as InternalAgentState<StructuredResponseFormat>,\n            runtime,\n          };\n\n          /**\n           * Create handler that validates tools and calls the inner handler\n           */\n          const handlerWithValidation = async (\n            req: ModelRequest<\n              InternalAgentState<StructuredResponseFormat>,\n              unknown\n            >\n          ): Promise<InternalModelResponse<StructuredResponseFormat>> => {\n            /**\n             * Verify that the user didn't add any new tools.\n             * We can't allow this as the ToolNode is already initiated with given tools.\n             */\n            const modifiedTools = req.tools ?? [];\n            const newTools = modifiedTools.filter(\n              (tool) =>\n                isClientTool(tool) &&\n                !this.#options.toolClasses.some((t) => t.name === tool.name)\n            );\n            if (newTools.length > 0) {\n              throw new Error(\n                `You have added a new tool in \"wrapModelCall\" hook of middleware \"${\n                  currentMiddleware.name\n                }\": ${newTools\n                  .map((tool) => tool.name)\n                  .join(\", \")}. This is not supported.`\n              );\n            }\n\n            /**\n             * Verify that user has not added or modified a tool with the same name.\n             * We can't allow this as the ToolNode is already initiated with given tools.\n             */\n            const invalidTools = modifiedTools.filter(\n              (tool) =>\n                isClientTool(tool) &&\n                this.#options.toolClasses.every((t) => t !== tool)\n            );\n            if (invalidTools.length > 0) {\n              throw new Error(\n                `You have modified a tool in \"wrapModelCall\" hook of middleware \"${\n                  currentMiddleware.name\n                }\": ${invalidTools\n                  .map((tool) => tool.name)\n                  .join(\", \")}. This is not supported.`\n              );\n            }\n\n            let normalizedReq = req;\n            const hasSystemPromptChanged =\n              req.systemPrompt !== this.#currentSystemMessage.text;\n            const hasSystemMessageChanged =\n              req.systemMessage !== this.#currentSystemMessage;\n            if (hasSystemPromptChanged && hasSystemMessageChanged) {\n              throw new Error(\n                \"Cannot change both systemPrompt and systemMessage in the same request.\"\n              );\n            }\n\n            /**\n             * Check if systemPrompt is a string was changed, if so create a new SystemMessage\n             */\n            if (hasSystemPromptChanged) {\n              this.#currentSystemMessage = new SystemMessage({\n                content: [{ type: \"text\", text: req.systemPrompt }],\n              });\n              normalizedReq = {\n                ...req,\n                systemPrompt: this.#currentSystemMessage.text,\n                systemMessage: this.#currentSystemMessage,\n              };\n            }\n            /**\n             * If the systemMessage was changed, update the current system message\n             */\n            if (hasSystemMessageChanged) {\n              this.#currentSystemMessage = new SystemMessage({\n                ...req.systemMessage,\n              });\n              normalizedReq = {\n                ...req,\n                systemPrompt: this.#currentSystemMessage.text,\n                systemMessage: this.#currentSystemMessage,\n              };\n            }\n\n            return innerHandler(normalizedReq);\n          };\n\n          // Call middleware's wrapModelCall with the validation handler\n          if (!currentMiddleware.wrapModelCall) {\n            return handlerWithValidation(requestWithStateAndRuntime);\n          }\n\n          try {\n            const middlewareResponse = await currentMiddleware.wrapModelCall(\n              requestWithStateAndRuntime,\n              handlerWithValidation as WrapModelCallHandler\n            );\n\n            /**\n             * Validate that this specific middleware returned a valid AIMessage\n             */\n            if (!isInternalModelResponse(middlewareResponse)) {\n              throw new Error(\n                `Invalid response from \"wrapModelCall\" in middleware \"${\n                  currentMiddleware.name\n                }\": expected AIMessage, got ${typeof middlewareResponse}`\n              );\n            }\n\n            return middlewareResponse;\n          } catch (error) {\n            throw MiddlewareError.wrap(error, currentMiddleware.name);\n          }\n        };\n      }\n    }\n\n    /**\n     * Execute the wrapped handler with the initial request\n     * Reset current system prompt to initial state and convert to string using .text getter\n     * for backwards compatibility with ModelRequest\n     */\n    this.#currentSystemMessage = this.#systemMessage;\n    const initialRequest: ModelRequest<\n      InternalAgentState<StructuredResponseFormat>,\n      unknown\n    > = {\n      model,\n      systemPrompt: this.#currentSystemMessage?.text,\n      systemMessage: this.#currentSystemMessage,\n      messages: state.messages,\n      tools: this.#options.toolClasses,\n      state,\n      runtime: Object.freeze({\n        context: lgConfig?.context,\n        writer: lgConfig.writer,\n        interrupt: lgConfig.interrupt,\n        signal: lgConfig.signal,\n      }) as Runtime<unknown>,\n    };\n\n    return wrappedHandler(initialRequest);\n  }\n\n  /**\n   * If the model returns multiple structured outputs, we need to handle it.\n   * @param response - The response from the model\n   * @param toolCalls - The tool calls that were made\n   * @returns The response from the model\n   */\n  #handleMultipleStructuredOutputs(\n    response: AIMessage,\n    toolCalls: ToolCall[],\n    responseFormat: ToolResponseFormat\n  ): Promise<Command> {\n    const multipleStructuredOutputsError = new MultipleStructuredOutputsError(\n      toolCalls.map((call) => call.name)\n    );\n\n    return this.#handleToolStrategyError(\n      multipleStructuredOutputsError,\n      response,\n      toolCalls[0],\n      responseFormat\n    );\n  }\n\n  /**\n   * If the model returns a single structured output, we need to handle it.\n   * @param toolCall - The tool call that was made\n   * @returns The structured response and a message to the LLM if needed\n   */\n  #handleSingleStructuredOutput(\n    response: AIMessage,\n    toolCall: ToolCall,\n    responseFormat: ToolResponseFormat,\n    lastMessage?: string\n  ): ResponseHandlerResult<StructuredResponseFormat> {\n    const tool = responseFormat.tools[toolCall.name];\n\n    try {\n      const structuredResponse = tool.parse(\n        toolCall.args\n      ) as StructuredResponseFormat;\n\n      return {\n        structuredResponse,\n        messages: [\n          response,\n          new ToolMessage({\n            tool_call_id: toolCall.id ?? \"\",\n            content: JSON.stringify(structuredResponse),\n            name: toolCall.name,\n          }),\n          new AIMessage(\n            lastMessage ??\n              `Returning structured response: ${JSON.stringify(\n                structuredResponse\n              )}`\n          ),\n        ],\n      };\n    } catch (error) {\n      return this.#handleToolStrategyError(\n        error as ToolStrategyError,\n        response,\n        toolCall,\n        responseFormat\n      );\n    }\n  }\n\n  async #handleToolStrategyError(\n    error: ToolStrategyError,\n    response: AIMessage,\n    toolCall: ToolCall,\n    responseFormat: ToolResponseFormat\n  ): Promise<Command> {\n    /**\n     * Using the `errorHandler` option of the first `ToolStrategy` entry is sufficient here.\n     * There is technically only one `ToolStrategy` entry in `structuredToolInfo` if the user\n     * uses `toolStrategy` to define the response format. If the user applies a list of json\n     * schema objects, these will be transformed into multiple `ToolStrategy` entries but all\n     * with the same `handleError` option.\n     */\n    const errorHandler = Object.values(responseFormat.tools).at(0)?.options\n      ?.handleError;\n\n    const toolCallId = toolCall.id;\n    if (!toolCallId) {\n      throw new Error(\n        \"Tool call ID is required to handle tool output errors. Please provide a tool call ID.\"\n      );\n    }\n\n    /**\n     * Default behavior: retry if `errorHandler` is undefined or truthy.\n     * Only throw if explicitly set to `false`.\n     */\n    if (errorHandler === false) {\n      throw error;\n    }\n\n    /**\n     * retry if:\n     */\n    if (\n      /**\n       * if the user has provided truthy value as the `errorHandler`, return a new AIMessage\n       * with the error message and retry the tool call.\n       */\n      errorHandler === undefined ||\n      (typeof errorHandler === \"boolean\" && errorHandler) ||\n      /**\n       * if `errorHandler` is an array and contains MultipleStructuredOutputsError\n       */\n      (Array.isArray(errorHandler) &&\n        errorHandler.some((h) => h instanceof MultipleStructuredOutputsError))\n    ) {\n      return new Command({\n        update: {\n          messages: [\n            response,\n            new ToolMessage({\n              content: error.message,\n              tool_call_id: toolCallId,\n            }),\n          ],\n        },\n        goto: AGENT_NODE_NAME,\n      });\n    }\n\n    /**\n     * if `errorHandler` is a string, retry the tool call with given string\n     */\n    if (typeof errorHandler === \"string\") {\n      return new Command({\n        update: {\n          messages: [\n            response,\n            new ToolMessage({\n              content: errorHandler,\n              tool_call_id: toolCallId,\n            }),\n          ],\n        },\n        goto: AGENT_NODE_NAME,\n      });\n    }\n\n    /**\n     * if `errorHandler` is a function, retry the tool call with the function\n     */\n    if (typeof errorHandler === \"function\") {\n      const content = await errorHandler(error);\n      if (typeof content !== \"string\") {\n        throw new Error(\"Error handler must return a string.\");\n      }\n\n      return new Command({\n        update: {\n          messages: [\n            response,\n            new ToolMessage({\n              content,\n              tool_call_id: toolCallId,\n            }),\n          ],\n        },\n        goto: AGENT_NODE_NAME,\n      });\n    }\n\n    /**\n     * Default: retry if we reach here\n     */\n    return new Command({\n      update: {\n        messages: [\n          response,\n          new ToolMessage({\n            content: error.message,\n            tool_call_id: toolCallId,\n          }),\n        ],\n      },\n      goto: AGENT_NODE_NAME,\n    });\n  }\n\n  #areMoreStepsNeeded(\n    state: InternalAgentState<StructuredResponseFormat>,\n    response: BaseMessage\n  ): boolean {\n    const allToolsReturnDirect =\n      AIMessage.isInstance(response) &&\n      response.tool_calls?.every((call) =>\n        this.#options.shouldReturnDirect.has(call.name)\n      );\n    const remainingSteps =\n      \"remainingSteps\" in state ? (state.remainingSteps as number) : undefined;\n    return Boolean(\n      remainingSteps &&\n        ((remainingSteps < 1 && allToolsReturnDirect) ||\n          (remainingSteps < 2 && hasToolCalls(state.messages.at(-1))))\n    );\n  }\n\n  async #bindTools(\n    model: LanguageModelLike,\n    preparedOptions: ModelRequest | undefined,\n    structuredResponseFormat: ResponseFormat | undefined\n  ): Promise<Runnable> {\n    const options: Partial<BaseChatModelCallOptions> = {};\n    const structuredTools = Object.values(\n      structuredResponseFormat && \"tools\" in structuredResponseFormat\n        ? structuredResponseFormat.tools\n        : {}\n    );\n\n    /**\n     * Use tools from preparedOptions if provided, otherwise use default tools\n     */\n    const allTools = [\n      ...(preparedOptions?.tools ?? this.#options.toolClasses),\n      ...structuredTools.map((toolStrategy) => toolStrategy.tool),\n    ];\n\n    /**\n     * If there are structured tools, we need to set the tool choice to \"any\"\n     * so that the model can choose to use a structured tool or not.\n     */\n    const toolChoice =\n      preparedOptions?.toolChoice ||\n      (structuredTools.length > 0 ? \"any\" : undefined);\n\n    /**\n     * check if the user requests a native schema output\n     */\n    if (structuredResponseFormat?.type === \"native\") {\n      const resolvedStrict =\n        preparedOptions?.modelSettings?.strict ??\n        structuredResponseFormat?.strategy?.strict ??\n        true;\n\n      const jsonSchemaParams = {\n        name: structuredResponseFormat.strategy.schema?.name ?? \"extract\",\n        description: getSchemaDescription(\n          structuredResponseFormat.strategy.schema\n        ),\n        schema: structuredResponseFormat.strategy.schema,\n        strict: resolvedStrict,\n      };\n\n      Object.assign(options, {\n        response_format: {\n          type: \"json_schema\",\n          json_schema: jsonSchemaParams,\n        },\n        output_format: {\n          type: \"json_schema\",\n          schema: structuredResponseFormat.strategy.schema,\n        },\n        headers: {\n          \"anthropic-beta\": \"structured-outputs-2025-11-13\",\n        },\n        ls_structured_output_format: {\n          kwargs: { method: \"json_schema\" },\n          schema: structuredResponseFormat.strategy.schema,\n        },\n        strict: resolvedStrict,\n      });\n    }\n\n    /**\n     * Bind tools to the model if they are not already bound.\n     */\n    const modelWithTools = await bindTools(model, allTools, {\n      ...options,\n      ...preparedOptions?.modelSettings,\n      tool_choice: toolChoice,\n    });\n\n    /**\n     * Create a model runnable with the prompt and agent name\n     * Use current SystemMessage state (which may have been modified by middleware)\n     */\n    const modelRunnable =\n      this.#options.includeAgentName === \"inline\"\n        ? withAgentName(modelWithTools, this.#options.includeAgentName)\n        : modelWithTools;\n\n    return modelRunnable;\n  }\n\n  getState(): {\n    messages: BaseMessage[];\n  } {\n    const state = super.getState();\n    const origState = state && !(state instanceof Command) ? state : {};\n\n    return {\n      messages: [],\n      ...origState,\n    };\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"AgentNode.cjs","names":["response: unknown","AIMessage","RunnableCallable","options: AgentNodeOptions<StructuredResponseFormat, ContextSchema>","#run","#options","#systemMessage","model: string | LanguageModelLike","transformResponseFormat","ProviderStrategy","ToolStrategy","state: InternalAgentState<StructuredResponseFormat>","config: RunnableConfig","ToolMessage","#invokeModel","Command","#areMoreStepsNeeded","initChatModel","options: {\n      lastMessage?: string;\n    }","#deriveModel","request: ModelRequest","validateLLMHasNoBoundTools","#getResponseFormat","#bindTools","#currentSystemMessage","mergeAbortSignals","#handleMultipleStructuredOutputs","#handleSingleStructuredOutput","wrappedHandler: (\n      request: ModelRequest<\n        InternalAgentState<StructuredResponseFormat>,\n        unknown\n      >\n    ) => Promise<InternalModelResponse<StructuredResponseFormat>>","request: ModelRequest<\n            InternalAgentState<StructuredResponseFormat>,\n            unknown\n          >","runtime: Runtime<unknown>","requestWithStateAndRuntime: ModelRequest<\n            InternalAgentState<StructuredResponseFormat>,\n            unknown\n          >","toPartialZodObject","req: ModelRequest<\n              InternalAgentState<StructuredResponseFormat>,\n              unknown\n            >","isClientTool","SystemMessage","MiddlewareError","initialRequest: ModelRequest<\n      InternalAgentState<StructuredResponseFormat>,\n      unknown\n    >","response: AIMessage","toolCalls: ToolCall[]","responseFormat: ToolResponseFormat","MultipleStructuredOutputsError","#handleToolStrategyError","toolCall: ToolCall","lastMessage?: string","error: ToolStrategyError","response: BaseMessage","hasToolCalls","model: LanguageModelLike","preparedOptions: ModelRequest | undefined","structuredResponseFormat: ResponseFormat | undefined","options: Partial<BaseChatModelCallOptions>","bindTools","withAgentName"],"sources":["../../../src/agents/nodes/AgentNode.ts"],"sourcesContent":["/* eslint-disable no-instanceof/no-instanceof */\nimport { Runnable, RunnableConfig } from \"@langchain/core/runnables\";\nimport {\n  BaseMessage,\n  AIMessage,\n  ToolMessage,\n  SystemMessage,\n} from \"@langchain/core/messages\";\nimport { Command, type LangGraphRunnableConfig } from \"@langchain/langgraph\";\nimport { type LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { type BaseChatModelCallOptions } from \"@langchain/core/language_models/chat_models\";\nimport {\n  InteropZodObject,\n  getSchemaDescription,\n  interopParse,\n} from \"@langchain/core/utils/types\";\nimport { raceWithSignal } from \"@langchain/core/runnables\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport type { ClientTool, ServerTool } from \"@langchain/core/tools\";\n\nimport { initChatModel } from \"../../chat_models/universal.js\";\nimport { MultipleStructuredOutputsError, MiddlewareError } from \"../errors.js\";\nimport { RunnableCallable } from \"../RunnableCallable.js\";\nimport {\n  bindTools,\n  validateLLMHasNoBoundTools,\n  hasToolCalls,\n  isClientTool,\n} from \"../utils.js\";\nimport { mergeAbortSignals, toPartialZodObject } from \"../nodes/utils.js\";\nimport { CreateAgentParams } from \"../types.js\";\nimport type { InternalAgentState, Runtime } from \"../runtime.js\";\nimport type {\n  AgentMiddleware,\n  AnyAnnotationRoot,\n  WrapModelCallHandler,\n} from \"../middleware/types.js\";\nimport type { ModelRequest } from \"./types.js\";\nimport { withAgentName } from \"../withAgentName.js\";\nimport {\n  ToolStrategy,\n  ProviderStrategy,\n  transformResponseFormat,\n  ToolStrategyError,\n} from \"../responses.js\";\n\ntype ResponseHandlerResult<StructuredResponseFormat> =\n  | {\n      structuredResponse: StructuredResponseFormat;\n      messages: BaseMessage[];\n    }\n  | Promise<Command>;\n\n/**\n * Wrap the base handler with middleware wrapModelCall hooks\n * Middleware are composed so the first middleware is the outermost wrapper\n * Example: [auth, retry, cache] means auth wraps retry wraps cache wraps baseHandler\n */\ntype InternalModelResponse<StructuredResponseFormat> =\n  | AIMessage\n  | ResponseHandlerResult<StructuredResponseFormat>;\n\n/**\n * Check if the response is an internal model response.\n * @param response - The response to check.\n * @returns True if the response is an internal model response, false otherwise.\n */\nfunction isInternalModelResponse<StructuredResponseFormat>(\n  response: unknown\n): response is InternalModelResponse<StructuredResponseFormat> {\n  return (\n    AIMessage.isInstance(response) ||\n    (typeof response === \"object\" &&\n      response !== null &&\n      \"structuredResponse\" in response &&\n      \"messages\" in response)\n  );\n}\n\n/**\n * The name of the agent node in the state graph.\n */\nexport const AGENT_NODE_NAME = \"model_request\";\n\nexport interface AgentNodeOptions<\n  StructuredResponseFormat extends Record<string, unknown> = Record<\n    string,\n    unknown\n  >,\n  StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot,\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n> extends Pick<\n    CreateAgentParams<StructuredResponseFormat, StateSchema, ContextSchema>,\n    \"model\" | \"includeAgentName\" | \"name\" | \"responseFormat\" | \"middleware\"\n  > {\n  toolClasses: (ClientTool | ServerTool)[];\n  shouldReturnDirect: Set<string>;\n  signal?: AbortSignal;\n  systemMessage: SystemMessage;\n  wrapModelCallHookMiddleware?: [\n    AgentMiddleware,\n    () => Record<string, unknown>,\n  ][];\n}\n\ninterface NativeResponseFormat {\n  type: \"native\";\n  strategy: ProviderStrategy;\n}\n\ninterface ToolResponseFormat {\n  type: \"tool\";\n  tools: Record<string, ToolStrategy>;\n}\n\ntype ResponseFormat = NativeResponseFormat | ToolResponseFormat;\n\nexport class AgentNode<\n  StructuredResponseFormat extends Record<string, unknown> = Record<\n    string,\n    unknown\n  >,\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n> extends RunnableCallable<\n  InternalAgentState<StructuredResponseFormat>,\n  | (\n      | { messages: BaseMessage[] }\n      | { structuredResponse: StructuredResponseFormat }\n    )\n  | Command\n> {\n  #options: AgentNodeOptions<StructuredResponseFormat, ContextSchema>;\n  #systemMessage: SystemMessage;\n  #currentSystemMessage: SystemMessage;\n\n  constructor(\n    options: AgentNodeOptions<StructuredResponseFormat, ContextSchema>\n  ) {\n    super({\n      name: options.name ?? \"model\",\n      func: (input, config) => this.#run(input, config as RunnableConfig),\n    });\n\n    this.#options = options;\n    this.#systemMessage = options.systemMessage;\n  }\n\n  /**\n   * Returns response format primtivies based on given model and response format provided by the user.\n   *\n   * If the user selects a tool output:\n   * - return a record of tools to extract structured output from the model's response\n   *\n   * if the the user selects a native schema output or if the model supports JSON schema output:\n   * - return a provider strategy to extract structured output from the model's response\n   *\n   * @param model - The model to get the response format for.\n   * @returns The response format.\n   */\n  #getResponseFormat(\n    model: string | LanguageModelLike\n  ): ResponseFormat | undefined {\n    if (!this.#options.responseFormat) {\n      return undefined;\n    }\n\n    const strategies = transformResponseFormat(\n      this.#options.responseFormat,\n      undefined,\n      model\n    );\n\n    /**\n     * we either define a list of provider strategies or a list of tool strategies\n     */\n    const isProviderStrategy = strategies.every(\n      (format) => format instanceof ProviderStrategy\n    );\n\n    /**\n     * Populate a list of structured tool info.\n     */\n    if (!isProviderStrategy) {\n      return {\n        type: \"tool\",\n        tools: (\n          strategies.filter(\n            (format) => format instanceof ToolStrategy\n          ) as ToolStrategy[]\n        ).reduce(\n          (acc, format) => {\n            acc[format.name] = format;\n            return acc;\n          },\n          {} as Record<string, ToolStrategy>\n        ),\n      };\n    }\n\n    return {\n      type: \"native\",\n      /**\n       * there can only be one provider strategy\n       */\n      strategy: strategies[0] as ProviderStrategy,\n    };\n  }\n\n  async #run(\n    state: InternalAgentState<StructuredResponseFormat>,\n    config: RunnableConfig\n  ) {\n    /**\n     * Check if we just executed a returnDirect tool\n     * If so, we should generate structured response (if needed) and stop\n     */\n    const lastMessage = state.messages.at(-1);\n    if (\n      lastMessage &&\n      ToolMessage.isInstance(lastMessage) &&\n      lastMessage.name &&\n      this.#options.shouldReturnDirect.has(lastMessage.name)\n    ) {\n      /**\n       * return directly without invoking the model again\n       */\n      return { messages: [] };\n    }\n\n    const response = await this.#invokeModel(state, config);\n\n    /**\n     * if we were able to generate a structured response, return it\n     */\n    if (\"structuredResponse\" in response) {\n      return {\n        messages: [...state.messages, ...(response.messages || [])],\n        structuredResponse: response.structuredResponse,\n      };\n    }\n\n    /**\n     * if we need to direct the agent to the model, return the update\n     */\n    if (response instanceof Command) {\n      return response;\n    }\n\n    response.name = this.name;\n    response.lc_kwargs.name = this.name;\n\n    if (this.#areMoreStepsNeeded(state, response)) {\n      return {\n        messages: [\n          new AIMessage({\n            content: \"Sorry, need more steps to process this request.\",\n            name: this.name,\n            id: response.id,\n          }),\n        ],\n      };\n    }\n\n    return { messages: [response] };\n  }\n\n  /**\n   * Derive the model from the options.\n   * @param state - The state of the agent.\n   * @param config - The config of the agent.\n   * @returns The model.\n   */\n  #deriveModel() {\n    if (typeof this.#options.model === \"string\") {\n      return initChatModel(this.#options.model);\n    }\n\n    if (this.#options.model) {\n      return this.#options.model;\n    }\n\n    throw new Error(\"No model option was provided, either via `model` option.\");\n  }\n\n  async #invokeModel(\n    state: InternalAgentState<StructuredResponseFormat>,\n    config: RunnableConfig,\n    options: {\n      lastMessage?: string;\n    } = {}\n  ): Promise<AIMessage | ResponseHandlerResult<StructuredResponseFormat>> {\n    const model = await this.#deriveModel();\n    const lgConfig = config as LangGraphRunnableConfig;\n\n    /**\n     * Create the base handler that performs the actual model invocation\n     */\n    const baseHandler = async (\n      request: ModelRequest\n    ): Promise<AIMessage | ResponseHandlerResult<StructuredResponseFormat>> => {\n      /**\n       * Check if the LLM already has bound tools and throw if it does.\n       */\n      validateLLMHasNoBoundTools(request.model);\n\n      const structuredResponseFormat = this.#getResponseFormat(request.model);\n      const modelWithTools = await this.#bindTools(\n        request.model,\n        request,\n        structuredResponseFormat\n      );\n\n      /**\n       * prepend the system message to the messages if it is not empty\n       */\n      const messages = [\n        ...(this.#currentSystemMessage.text === \"\"\n          ? []\n          : [this.#currentSystemMessage]),\n        ...request.messages,\n      ];\n\n      const signal = mergeAbortSignals(this.#options.signal, config.signal);\n      const response = (await raceWithSignal(\n        modelWithTools.invoke(messages, {\n          ...config,\n          signal,\n        }),\n        signal\n      )) as AIMessage;\n\n      /**\n       * if the user requests a native schema output, try to parse the response\n       * and return the structured response if it is valid\n       */\n      if (structuredResponseFormat?.type === \"native\") {\n        const structuredResponse =\n          structuredResponseFormat.strategy.parse(response);\n        if (structuredResponse) {\n          return { structuredResponse, messages: [response] };\n        }\n\n        return response;\n      }\n\n      if (!structuredResponseFormat || !response.tool_calls) {\n        return response;\n      }\n\n      const toolCalls = response.tool_calls.filter(\n        (call) => call.name in structuredResponseFormat.tools\n      );\n\n      /**\n       * if there were not structured tool calls, we can return the response\n       */\n      if (toolCalls.length === 0) {\n        return response;\n      }\n\n      /**\n       * if there were multiple structured tool calls, we should throw an error as this\n       * scenario is not defined/supported.\n       */\n      if (toolCalls.length > 1) {\n        return this.#handleMultipleStructuredOutputs(\n          response,\n          toolCalls,\n          structuredResponseFormat\n        );\n      }\n\n      const toolStrategy = structuredResponseFormat.tools[toolCalls[0].name];\n      const toolMessageContent = toolStrategy?.options?.toolMessageContent;\n      return this.#handleSingleStructuredOutput(\n        response,\n        toolCalls[0],\n        structuredResponseFormat,\n        toolMessageContent ?? options.lastMessage\n      );\n    };\n\n    const wrapperMiddleware = this.#options.wrapModelCallHookMiddleware ?? [];\n    let wrappedHandler: (\n      request: ModelRequest<\n        InternalAgentState<StructuredResponseFormat>,\n        unknown\n      >\n    ) => Promise<InternalModelResponse<StructuredResponseFormat>> = baseHandler;\n\n    /**\n     * Build composed handler from last to first so first middleware becomes outermost\n     */\n    for (let i = wrapperMiddleware.length - 1; i >= 0; i--) {\n      const [middleware, getMiddlewareState] = wrapperMiddleware[i];\n      if (middleware.wrapModelCall) {\n        const innerHandler = wrappedHandler;\n        const currentMiddleware = middleware;\n        const currentGetState = getMiddlewareState;\n\n        wrappedHandler = async (\n          request: ModelRequest<\n            InternalAgentState<StructuredResponseFormat>,\n            unknown\n          >\n        ): Promise<InternalModelResponse<StructuredResponseFormat>> => {\n          /**\n           * Merge context with default context of middleware\n           */\n          const context = currentMiddleware.contextSchema\n            ? interopParse(\n                currentMiddleware.contextSchema,\n                lgConfig?.context || {}\n              )\n            : lgConfig?.context;\n\n          /**\n           * Create runtime\n           */\n          const runtime: Runtime<unknown> = Object.freeze({\n            context,\n            writer: lgConfig.writer,\n            interrupt: lgConfig.interrupt,\n            signal: lgConfig.signal,\n          });\n\n          /**\n           * Create the request with state and runtime\n           */\n          const requestWithStateAndRuntime: ModelRequest<\n            InternalAgentState<StructuredResponseFormat>,\n            unknown\n          > = {\n            ...request,\n            state: {\n              ...(middleware.stateSchema\n                ? interopParse(\n                    toPartialZodObject(middleware.stateSchema),\n                    state\n                  )\n                : {}),\n              ...currentGetState(),\n              messages: state.messages,\n            } as InternalAgentState<StructuredResponseFormat>,\n            runtime,\n          };\n\n          /**\n           * Create handler that validates tools and calls the inner handler\n           */\n          const handlerWithValidation = async (\n            req: ModelRequest<\n              InternalAgentState<StructuredResponseFormat>,\n              unknown\n            >\n          ): Promise<InternalModelResponse<StructuredResponseFormat>> => {\n            /**\n             * Verify that the user didn't add any new tools.\n             * We can't allow this as the ToolNode is already initiated with given tools.\n             */\n            const modifiedTools = req.tools ?? [];\n            const newTools = modifiedTools.filter(\n              (tool) =>\n                isClientTool(tool) &&\n                !this.#options.toolClasses.some((t) => t.name === tool.name)\n            );\n            if (newTools.length > 0) {\n              throw new Error(\n                `You have added a new tool in \"wrapModelCall\" hook of middleware \"${\n                  currentMiddleware.name\n                }\": ${newTools\n                  .map((tool) => tool.name)\n                  .join(\", \")}. This is not supported.`\n              );\n            }\n\n            /**\n             * Verify that user has not added or modified a tool with the same name.\n             * We can't allow this as the ToolNode is already initiated with given tools.\n             */\n            const invalidTools = modifiedTools.filter(\n              (tool) =>\n                isClientTool(tool) &&\n                this.#options.toolClasses.every((t) => t !== tool)\n            );\n            if (invalidTools.length > 0) {\n              throw new Error(\n                `You have modified a tool in \"wrapModelCall\" hook of middleware \"${\n                  currentMiddleware.name\n                }\": ${invalidTools\n                  .map((tool) => tool.name)\n                  .join(\", \")}. This is not supported.`\n              );\n            }\n\n            let normalizedReq = req;\n            const hasSystemPromptChanged =\n              req.systemPrompt !== this.#currentSystemMessage.text;\n            const hasSystemMessageChanged =\n              req.systemMessage !== this.#currentSystemMessage;\n            if (hasSystemPromptChanged && hasSystemMessageChanged) {\n              throw new Error(\n                \"Cannot change both systemPrompt and systemMessage in the same request.\"\n              );\n            }\n\n            /**\n             * Check if systemPrompt is a string was changed, if so create a new SystemMessage\n             */\n            if (hasSystemPromptChanged) {\n              this.#currentSystemMessage = new SystemMessage({\n                content: [{ type: \"text\", text: req.systemPrompt }],\n              });\n              normalizedReq = {\n                ...req,\n                systemPrompt: this.#currentSystemMessage.text,\n                systemMessage: this.#currentSystemMessage,\n              };\n            }\n            /**\n             * If the systemMessage was changed, update the current system message\n             */\n            if (hasSystemMessageChanged) {\n              this.#currentSystemMessage = new SystemMessage({\n                ...req.systemMessage,\n              });\n              normalizedReq = {\n                ...req,\n                systemPrompt: this.#currentSystemMessage.text,\n                systemMessage: this.#currentSystemMessage,\n              };\n            }\n\n            return innerHandler(normalizedReq);\n          };\n\n          // Call middleware's wrapModelCall with the validation handler\n          if (!currentMiddleware.wrapModelCall) {\n            return handlerWithValidation(requestWithStateAndRuntime);\n          }\n\n          try {\n            const middlewareResponse = await currentMiddleware.wrapModelCall(\n              requestWithStateAndRuntime,\n              handlerWithValidation as WrapModelCallHandler\n            );\n\n            /**\n             * Validate that this specific middleware returned a valid AIMessage\n             */\n            if (!isInternalModelResponse(middlewareResponse)) {\n              throw new Error(\n                `Invalid response from \"wrapModelCall\" in middleware \"${\n                  currentMiddleware.name\n                }\": expected AIMessage, got ${typeof middlewareResponse}`\n              );\n            }\n\n            return middlewareResponse;\n          } catch (error) {\n            throw MiddlewareError.wrap(error, currentMiddleware.name);\n          }\n        };\n      }\n    }\n\n    /**\n     * Execute the wrapped handler with the initial request\n     * Reset current system prompt to initial state and convert to string using .text getter\n     * for backwards compatibility with ModelRequest\n     */\n    this.#currentSystemMessage = this.#systemMessage;\n    const initialRequest: ModelRequest<\n      InternalAgentState<StructuredResponseFormat>,\n      unknown\n    > = {\n      model,\n      systemPrompt: this.#currentSystemMessage?.text,\n      systemMessage: this.#currentSystemMessage,\n      messages: state.messages,\n      tools: this.#options.toolClasses,\n      state,\n      runtime: Object.freeze({\n        context: lgConfig?.context,\n        writer: lgConfig.writer,\n        interrupt: lgConfig.interrupt,\n        signal: lgConfig.signal,\n      }) as Runtime<unknown>,\n    };\n\n    return wrappedHandler(initialRequest);\n  }\n\n  /**\n   * If the model returns multiple structured outputs, we need to handle it.\n   * @param response - The response from the model\n   * @param toolCalls - The tool calls that were made\n   * @returns The response from the model\n   */\n  #handleMultipleStructuredOutputs(\n    response: AIMessage,\n    toolCalls: ToolCall[],\n    responseFormat: ToolResponseFormat\n  ): Promise<Command> {\n    const multipleStructuredOutputsError = new MultipleStructuredOutputsError(\n      toolCalls.map((call) => call.name)\n    );\n\n    return this.#handleToolStrategyError(\n      multipleStructuredOutputsError,\n      response,\n      toolCalls[0],\n      responseFormat\n    );\n  }\n\n  /**\n   * If the model returns a single structured output, we need to handle it.\n   * @param toolCall - The tool call that was made\n   * @returns The structured response and a message to the LLM if needed\n   */\n  #handleSingleStructuredOutput(\n    response: AIMessage,\n    toolCall: ToolCall,\n    responseFormat: ToolResponseFormat,\n    lastMessage?: string\n  ): ResponseHandlerResult<StructuredResponseFormat> {\n    const tool = responseFormat.tools[toolCall.name];\n\n    try {\n      const structuredResponse = tool.parse(\n        toolCall.args\n      ) as StructuredResponseFormat;\n\n      return {\n        structuredResponse,\n        messages: [\n          response,\n          new ToolMessage({\n            tool_call_id: toolCall.id ?? \"\",\n            content: JSON.stringify(structuredResponse),\n            name: toolCall.name,\n          }),\n          new AIMessage(\n            lastMessage ??\n              `Returning structured response: ${JSON.stringify(\n                structuredResponse\n              )}`\n          ),\n        ],\n      };\n    } catch (error) {\n      return this.#handleToolStrategyError(\n        error as ToolStrategyError,\n        response,\n        toolCall,\n        responseFormat\n      );\n    }\n  }\n\n  async #handleToolStrategyError(\n    error: ToolStrategyError,\n    response: AIMessage,\n    toolCall: ToolCall,\n    responseFormat: ToolResponseFormat\n  ): Promise<Command> {\n    /**\n     * Using the `errorHandler` option of the first `ToolStrategy` entry is sufficient here.\n     * There is technically only one `ToolStrategy` entry in `structuredToolInfo` if the user\n     * uses `toolStrategy` to define the response format. If the user applies a list of json\n     * schema objects, these will be transformed into multiple `ToolStrategy` entries but all\n     * with the same `handleError` option.\n     */\n    const errorHandler = Object.values(responseFormat.tools).at(0)?.options\n      ?.handleError;\n\n    const toolCallId = toolCall.id;\n    if (!toolCallId) {\n      throw new Error(\n        \"Tool call ID is required to handle tool output errors. Please provide a tool call ID.\"\n      );\n    }\n\n    /**\n     * Default behavior: retry if `errorHandler` is undefined or truthy.\n     * Only throw if explicitly set to `false`.\n     */\n    if (errorHandler === false) {\n      throw error;\n    }\n\n    /**\n     * retry if:\n     */\n    if (\n      /**\n       * if the user has provided truthy value as the `errorHandler`, return a new AIMessage\n       * with the error message and retry the tool call.\n       */\n      errorHandler === undefined ||\n      (typeof errorHandler === \"boolean\" && errorHandler) ||\n      /**\n       * if `errorHandler` is an array and contains MultipleStructuredOutputsError\n       */\n      (Array.isArray(errorHandler) &&\n        errorHandler.some((h) => h instanceof MultipleStructuredOutputsError))\n    ) {\n      return new Command({\n        update: {\n          messages: [\n            response,\n            new ToolMessage({\n              content: error.message,\n              tool_call_id: toolCallId,\n            }),\n          ],\n        },\n        goto: AGENT_NODE_NAME,\n      });\n    }\n\n    /**\n     * if `errorHandler` is a string, retry the tool call with given string\n     */\n    if (typeof errorHandler === \"string\") {\n      return new Command({\n        update: {\n          messages: [\n            response,\n            new ToolMessage({\n              content: errorHandler,\n              tool_call_id: toolCallId,\n            }),\n          ],\n        },\n        goto: AGENT_NODE_NAME,\n      });\n    }\n\n    /**\n     * if `errorHandler` is a function, retry the tool call with the function\n     */\n    if (typeof errorHandler === \"function\") {\n      const content = await errorHandler(error);\n      if (typeof content !== \"string\") {\n        throw new Error(\"Error handler must return a string.\");\n      }\n\n      return new Command({\n        update: {\n          messages: [\n            response,\n            new ToolMessage({\n              content,\n              tool_call_id: toolCallId,\n            }),\n          ],\n        },\n        goto: AGENT_NODE_NAME,\n      });\n    }\n\n    /**\n     * Default: retry if we reach here\n     */\n    return new Command({\n      update: {\n        messages: [\n          response,\n          new ToolMessage({\n            content: error.message,\n            tool_call_id: toolCallId,\n          }),\n        ],\n      },\n      goto: AGENT_NODE_NAME,\n    });\n  }\n\n  #areMoreStepsNeeded(\n    state: InternalAgentState<StructuredResponseFormat>,\n    response: BaseMessage\n  ): boolean {\n    const allToolsReturnDirect =\n      AIMessage.isInstance(response) &&\n      response.tool_calls?.every((call) =>\n        this.#options.shouldReturnDirect.has(call.name)\n      );\n    const remainingSteps =\n      \"remainingSteps\" in state ? (state.remainingSteps as number) : undefined;\n    return Boolean(\n      remainingSteps &&\n        ((remainingSteps < 1 && allToolsReturnDirect) ||\n          (remainingSteps < 2 && hasToolCalls(state.messages.at(-1))))\n    );\n  }\n\n  async #bindTools(\n    model: LanguageModelLike,\n    preparedOptions: ModelRequest | undefined,\n    structuredResponseFormat: ResponseFormat | undefined\n  ): Promise<Runnable> {\n    const options: Partial<BaseChatModelCallOptions> = {};\n    const structuredTools = Object.values(\n      structuredResponseFormat && \"tools\" in structuredResponseFormat\n        ? structuredResponseFormat.tools\n        : {}\n    );\n\n    /**\n     * Use tools from preparedOptions if provided, otherwise use default tools\n     */\n    const allTools = [\n      ...(preparedOptions?.tools ?? this.#options.toolClasses),\n      ...structuredTools.map((toolStrategy) => toolStrategy.tool),\n    ];\n\n    /**\n     * If there are structured tools, we need to set the tool choice to \"any\"\n     * so that the model can choose to use a structured tool or not.\n     */\n    const toolChoice =\n      preparedOptions?.toolChoice ||\n      (structuredTools.length > 0 ? \"any\" : undefined);\n\n    /**\n     * check if the user requests a native schema output\n     */\n    if (structuredResponseFormat?.type === \"native\") {\n      const resolvedStrict =\n        preparedOptions?.modelSettings?.strict ??\n        structuredResponseFormat?.strategy?.strict ??\n        true;\n\n      const jsonSchemaParams = {\n        name: structuredResponseFormat.strategy.schema?.name ?? \"extract\",\n        description: getSchemaDescription(\n          structuredResponseFormat.strategy.schema\n        ),\n        schema: structuredResponseFormat.strategy.schema,\n        strict: resolvedStrict,\n      };\n\n      Object.assign(options, {\n        response_format: {\n          type: \"json_schema\",\n          json_schema: jsonSchemaParams,\n        },\n        output_format: {\n          type: \"json_schema\",\n          schema: structuredResponseFormat.strategy.schema,\n        },\n        headers: {\n          \"anthropic-beta\": \"structured-outputs-2025-11-13\",\n        },\n        ls_structured_output_format: {\n          kwargs: { method: \"json_schema\" },\n          schema: structuredResponseFormat.strategy.schema,\n        },\n        strict: resolvedStrict,\n      });\n    }\n\n    /**\n     * Bind tools to the model if they are not already bound.\n     */\n    const modelWithTools = await bindTools(model, allTools, {\n      ...options,\n      ...preparedOptions?.modelSettings,\n      tool_choice: toolChoice,\n    });\n\n    /**\n     * Create a model runnable with the prompt and agent name\n     * Use current SystemMessage state (which may have been modified by middleware)\n     */\n    const modelRunnable =\n      this.#options.includeAgentName === \"inline\"\n        ? withAgentName(modelWithTools, this.#options.includeAgentName)\n        : modelWithTools;\n\n    return modelRunnable;\n  }\n\n  getState(): {\n    messages: BaseMessage[];\n  } {\n    const state = super.getState();\n    const origState = state && !(state instanceof Command) ? state : {};\n\n    return {\n      messages: [],\n      ...origState,\n    };\n  }\n}\n"],"mappings":"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"}

package/dist/agents/nodes/AgentNode.js

@@ -2,13 +2,13 @@ import { initChatModel } from "../../chat_models/universal.js";
 import { MiddlewareError, MultipleStructuredOutputsError } from "../errors.js";
 import { bindTools, hasToolCalls, isClientTool, validateLLMHasNoBoundTools } from "../utils.js";
 import { RunnableCallable } from "../RunnableCallable.js";
-import { mergeAbortSignals } from "./utils.js";
+import { mergeAbortSignals, toPartialZodObject } from "./utils.js";
 import { withAgentName } from "../withAgentName.js";
 import { ProviderStrategy, ToolStrategy, transformResponseFormat } from "../responses.js";
 import { AIMessage, SystemMessage, ToolMessage } from "@langchain/core/messages";
 import { raceWithSignal } from "@langchain/core/runnables";
 import { Command } from "@langchain/langgraph";
-import { getSchemaDescription, interopParse, interopZodObjectPartial } from "@langchain/core/utils/types";
+import { getSchemaDescription, interopParse } from "@langchain/core/utils/types";
 
 //#region src/agents/nodes/AgentNode.ts
 /**
@@ -192,7 +192,7 @@ var AgentNode = class extends RunnableCallable {
 					const requestWithStateAndRuntime = {
 						...request,
 						state: {
-							...middleware.stateSchema ? interopParse(interopZodObjectPartial(middleware.stateSchema), state) : {},
+							...middleware.stateSchema ? interopParse(toPartialZodObject(middleware.stateSchema), state) : {},
 							...currentGetState(),
 							messages: state.messages
 						},