langchain 0.3.31 → 1.0.0-alpha.2

package/dist/agents/nodes/ToolNode.d.ts

@@ -0,0 +1,98 @@
+import { AnyAnnotationRoot, PreHookAnnotation, ToAnnotationRoot } from "../annotation.js";
+import { RunnableCallable } from "../RunnableCallable.js";
+import { ToolMessage } from "@langchain/core/messages";
+import { RunnableConfig, RunnableToolLike } from "@langchain/core/runnables";
+import { DynamicTool, StructuredToolInterface } from "@langchain/core/tools";
+import { Command, Send } from "@langchain/langgraph";
+import { InteropZodObject } from "@langchain/core/utils/types";
+import { ToolCall } from "@langchain/core/messages/tool";
+
+//#region src/agents/nodes/ToolNode.d.ts
+interface ToolNodeOptions {
+  /**
+   * The name of the tool node.
+   */
+  name?: string;
+  /**
+   * The tags to add to the tool call.
+   */
+  tags?: string[];
+  /**
+   * The abort signal to cancel the tool call.
+   */
+  signal?: AbortSignal;
+  /**
+   * Whether to throw the error immediately if the tool fails or handle it by the `onToolError` function or via ToolMessage.
+   *
+   * If `true` (default):
+   *   - a tool message with the error will be returned to the LLM
+   *
+   * If `false`:
+   *   - the error will be thrown immediately
+   *
+   * If a function is provided:
+   *   - returns a custom {@link ToolMessage} as result
+   *   - throws an error otherwise
+   *
+   * @default true
+   */
+  handleToolErrors?: boolean | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined);
+}
+/**
+ * `ToolNode` is a built-in LangGraph component that handles tool calls within an agent's workflow.
+ * It works seamlessly with `createReactAgent`, offering advanced tool execution control, built
+ * in parallelism, and error handling.
+ *
+ * @example
+ * ```ts
+ * import { ToolNode, tool, AIMessage } from "langchain";
+ * import { z } from "zod";
+ *
+ * const getWeather = tool((input) => {
+ *   if (["sf", "san francisco"].includes(input.location.toLowerCase())) {
+ *     return "It's 60 degrees and foggy.";
+ *   } else {
+ *     return "It's 90 degrees and sunny.";
+ *   }
+ * }, {
+ *   name: "get_weather",
+ *   description: "Call to get the current weather.",
+ *   schema: z.object({
+ *     location: z.string().describe("Location to get the weather for."),
+ *   }),
+ * });
+ *
+ * const tools = [getWeather];
+ * const toolNode = new ToolNode(tools);
+ *
+ * const messageWithSingleToolCall = new AIMessage({
+ *   content: "",
+ *   tool_calls: [
+ *     {
+ *       name: "get_weather",
+ *       args: { location: "sf" },
+ *       id: "tool_call_id",
+ *       type: "tool_call",
+ *     }
+ *   ]
+ * })
+ *
+ * await toolNode.invoke({ messages: [messageWithSingleToolCall] });
+ * // Returns tool invocation responses as:
+ * // { messages: ToolMessage[] }
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+declare class ToolNode<StateSchema extends AnyAnnotationRoot | InteropZodObject = any, ContextSchema extends AnyAnnotationRoot | InteropZodObject = any> extends RunnableCallable<StateSchema, ContextSchema> {
+  options?: ToolNodeOptions | undefined;
+  tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[];
+  trace: boolean;
+  signal?: AbortSignal;
+  handleToolErrors: boolean | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined);
+  constructor(tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[], options?: ToolNodeOptions | undefined);
+  protected runTool(call: ToolCall, config: RunnableConfig): Promise<ToolMessage | Command>;
+  protected run(state: ToAnnotationRoot<StateSchema>["State"] & PreHookAnnotation["State"], config: RunnableConfig): Promise<ContextSchema>;
+}
+//#endregion
+export { ToolNode };
+//# sourceMappingURL=ToolNode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ToolNode.d.ts","names":["ToolMessage","RunnableConfig","RunnableToolLike","DynamicTool","StructuredToolInterface","ToolCall","InteropZodObject","Command","Send","RunnableCallable","PreHookAnnotation","AnyAnnotationRoot","ToAnnotationRoot","ToolNodeOptions","AbortSignal","ToolNode","StateSchema","ContextSchema","Promise","isSend"],"sources":["../../../src/agents/nodes/ToolNode.d.ts"],"sourcesContent":["/* eslint-disable no-instanceof/no-instanceof */\nimport { ToolMessage } from \"@langchain/core/messages\";\nimport { RunnableConfig, RunnableToolLike } from \"@langchain/core/runnables\";\nimport { DynamicTool, StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport type { InteropZodObject } from \"@langchain/core/utils/types\";\nimport { Command, Send } from \"@langchain/langgraph\";\nimport { RunnableCallable } from \"../RunnableCallable.js\";\nimport { PreHookAnnotation, AnyAnnotationRoot, ToAnnotationRoot } from \"../annotation.js\";\nexport interface ToolNodeOptions {\n    /**\n     * The name of the tool node.\n     */\n    name?: string;\n    /**\n     * The tags to add to the tool call.\n     */\n    tags?: string[];\n    /**\n     * The abort signal to cancel the tool call.\n     */\n    signal?: AbortSignal;\n    /**\n     * Whether to throw the error immediately if the tool fails or handle it by the `onToolError` function or via ToolMessage.\n     *\n     * If `true` (default):\n     *   - a tool message with the error will be returned to the LLM\n     *\n     * If `false`:\n     *   - the error will be thrown immediately\n     *\n     * If a function is provided:\n     *   - returns a custom {@link ToolMessage} as result\n     *   - throws an error otherwise\n     *\n     * @default true\n     */\n    handleToolErrors?: boolean | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined);\n}\n/**\n * `ToolNode` is a built-in LangGraph component that handles tool calls within an agent's workflow.\n * It works seamlessly with `createReactAgent`, offering advanced tool execution control, built\n * in parallelism, and error handling.\n *\n * @example\n * ```ts\n * import { ToolNode, tool, AIMessage } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   }),\n * });\n *\n * const tools = [getWeather];\n * const toolNode = new ToolNode(tools);\n *\n * const messageWithSingleToolCall = new AIMessage({\n *   content: \"\",\n *   tool_calls: [\n *     {\n *       name: \"get_weather\",\n *       args: { location: \"sf\" },\n *       id: \"tool_call_id\",\n *       type: \"tool_call\",\n *     }\n *   ]\n * })\n *\n * await toolNode.invoke({ messages: [messageWithSingleToolCall] });\n * // Returns tool invocation responses as:\n * // { messages: ToolMessage[] }\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport declare class ToolNode<StateSchema extends AnyAnnotationRoot | InteropZodObject = any, ContextSchema extends AnyAnnotationRoot | InteropZodObject = any> extends RunnableCallable<StateSchema, ContextSchema> {\n    options?: ToolNodeOptions | undefined;\n    tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[];\n    trace: boolean;\n    signal?: AbortSignal;\n    handleToolErrors: boolean | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined);\n    constructor(tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[], options?: ToolNodeOptions | undefined);\n    protected runTool(call: ToolCall, config: RunnableConfig): Promise<ToolMessage | Command>;\n    protected run(state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], config: RunnableConfig): Promise<ContextSchema>;\n}\nexport declare function isSend(x: unknown): x is Send;\n"],"mappings":";;;;;;;;;;UASiBa,eAAAA;EAAAA;;;EAYO,IAgBqCR,CAAAA,EAAAA,MAAAA;EAAQ;AAAgB;AA+CrF;EAA6B,IAAA,CAAA,EAAA,MAAA,EAAA;EAAA;;;EAAwG,MAAGC,CAAAA,EA/D3HQ,WA+D2HR;EAAgB;;;;;;;;;;;;;;;EAO5F,gBAAWN,CAAAA,EAAAA,OAAAA,GAAAA,CAAAA,CAAAA,KAAAA,EAAAA,OAAAA,EAAAA,QAAAA,EAtDVK,QAsDUL,EAAAA,GAtDGA,WAsDHA,GAAAA,SAAAA,CAAAA;;;;;;;;;;AAPiH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAnKe,6BAA6BJ,oBAAoBL,8CAA8CK,oBAAoBL,gCAAgCG,iBAAiBO,aAAaC;YACxLJ;UACFT,0BAA0BD,cAAcD;;WAEvCY;0DAC+CT,aAAaL;sBACjDI,0BAA0BD,cAAcD,+BAA+BW;0BACnER,kBAAkBJ,iBAAiBiB,QAAQlB,cAAcO;uBAC5DK,iBAAiBI,wBAAwBN,oCAAoCT,iBAAiBiB,QAAQD"}

package/dist/agents/nodes/ToolNode.js

@@ -0,0 +1,168 @@
+import { ToolInvocationError } from "../errors.js";
+import { RunnableCallable } from "../RunnableCallable.js";
+import { mergeAbortSignals } from "./utils.js";
+import { ToolMessage, isBaseMessage, isToolMessage } from "@langchain/core/messages";
+import { ToolInputParsingException } from "@langchain/core/tools";
+import { Command, Send, isCommand, isGraphInterrupt } from "@langchain/langgraph";
+
+//#region src/agents/nodes/ToolNode.ts
+const isBaseMessageArray = (input) => Array.isArray(input) && input.every(isBaseMessage);
+const isMessagesState = (input) => typeof input === "object" && input != null && "messages" in input && isBaseMessageArray(input.messages);
+const isSendInput = (input) => typeof input === "object" && input != null && "lg_tool_call" in input;
+/**
+* `ToolNode` is a built-in LangGraph component that handles tool calls within an agent's workflow.
+* It works seamlessly with `createReactAgent`, offering advanced tool execution control, built
+* in parallelism, and error handling.
+*
+* @example
+* ```ts
+* import { ToolNode, tool, AIMessage } from "langchain";
+* import { z } from "zod";
+*
+* const getWeather = tool((input) => {
+*   if (["sf", "san francisco"].includes(input.location.toLowerCase())) {
+*     return "It's 60 degrees and foggy.";
+*   } else {
+*     return "It's 90 degrees and sunny.";
+*   }
+* }, {
+*   name: "get_weather",
+*   description: "Call to get the current weather.",
+*   schema: z.object({
+*     location: z.string().describe("Location to get the weather for."),
+*   }),
+* });
+*
+* const tools = [getWeather];
+* const toolNode = new ToolNode(tools);
+*
+* const messageWithSingleToolCall = new AIMessage({
+*   content: "",
+*   tool_calls: [
+*     {
+*       name: "get_weather",
+*       args: { location: "sf" },
+*       id: "tool_call_id",
+*       type: "tool_call",
+*     }
+*   ]
+* })
+*
+* await toolNode.invoke({ messages: [messageWithSingleToolCall] });
+* // Returns tool invocation responses as:
+* // { messages: ToolMessage[] }
+* ```
+*/
+var ToolNode = class extends RunnableCallable {
+	tools;
+	trace = false;
+	signal;
+	handleToolErrors = true;
+	constructor(tools, options) {
+		const { name, tags, handleToolErrors } = options ?? {};
+		super({
+			name,
+			tags,
+			func: (state, config) => this.run(state, config)
+		});
+		this.options = options;
+		this.tools = tools;
+		this.handleToolErrors = handleToolErrors ?? this.handleToolErrors;
+		this.signal = options?.signal;
+	}
+	async runTool(call, config) {
+		const tool = this.tools.find((tool$1) => tool$1.name === call.name);
+		try {
+			if (tool === void 0) throw new Error(`Tool "${call.name}" not found.`);
+			const output = await tool.invoke({
+				...call,
+				type: "tool_call"
+			}, {
+				...config,
+				signal: mergeAbortSignals(this.signal, config.signal)
+			});
+			if (isBaseMessage(output) && output.getType() === "tool" || isCommand(output)) return output;
+			return new ToolMessage({
+				name: tool.name,
+				content: typeof output === "string" ? output : JSON.stringify(output),
+				tool_call_id: call.id
+			});
+		} catch (e) {
+			/**
+			* If tool invocation fails due to input parsing error, throw a {@link ToolInvocationError}
+			*/
+			if (e instanceof ToolInputParsingException) throw new ToolInvocationError(e, call);
+			/**
+			* throw the error if user prefers not to handle tool errors
+			*/
+			if (!this.handleToolErrors) throw e;
+			if (isGraphInterrupt(e))
+ /**
+			* {@link NodeInterrupt} errors are a breakpoint to bring a human into the loop.
+			* As such, they are not recoverable by the agent and shouldn't be fed
+			* back. Instead, re-throw these errors even when `handleToolErrors = true`.
+			*/
+			throw e;
+			/**
+			* If the signal is aborted, we want to bubble up the error to the invoke caller.
+			*/
+			if (this.signal?.aborted) throw e;
+			/**
+			* if the user provides a function, call it with the error and tool call
+			* and return the result if it is a {@link ToolMessage}
+			*/
+			if (typeof this.handleToolErrors === "function") {
+				const result = this.handleToolErrors(e, call);
+				if (result && isToolMessage(result)) return result;
+			} else if (this.handleToolErrors) return new ToolMessage({
+				name: call.name,
+				content: `Error: ${e}\n Please fix your mistakes.`,
+				tool_call_id: call.id
+			});
+			/**
+			* If the user doesn't handle the error, throw it
+			*/
+			throw e;
+		}
+	}
+	async run(state, config) {
+		let outputs;
+		if (isSendInput(state)) outputs = [await this.runTool(state.lg_tool_call, config)];
+		else {
+			let messages;
+			if (isBaseMessageArray(state)) messages = state;
+			else if (isMessagesState(state)) messages = state.messages;
+			else throw new Error("ToolNode only accepts BaseMessage[] or { messages: BaseMessage[] } as input.");
+			const toolMessageIds = new Set(messages.filter((msg) => msg.getType() === "tool").map((msg) => msg.tool_call_id));
+			let aiMessage;
+			for (let i = messages.length - 1; i >= 0; i -= 1) {
+				const message = messages[i];
+				if (message.getType() === "ai") {
+					aiMessage = message;
+					break;
+				}
+			}
+			if (aiMessage?.getType() !== "ai") throw new Error("ToolNode only accepts AIMessages as input.");
+			outputs = await Promise.all(aiMessage.tool_calls?.filter((call) => call.id == null || !toolMessageIds.has(call.id)).map((call) => this.runTool(call, config)) ?? []);
+		}
+		if (!outputs.some(isCommand)) return Array.isArray(state) ? outputs : { messages: outputs };
+		const combinedOutputs = [];
+		let parentCommand = null;
+		for (const output of outputs) if (isCommand(output)) if (output.graph === Command.PARENT && Array.isArray(output.goto) && output.goto.every((send) => isSend(send))) if (parentCommand) parentCommand.goto.push(...output.goto);
+		else parentCommand = new Command({
+			graph: Command.PARENT,
+			goto: output.goto
+		});
+		else combinedOutputs.push(output);
+		else combinedOutputs.push(Array.isArray(state) ? [output] : { messages: [output] });
+		if (parentCommand) combinedOutputs.push(parentCommand);
+		return combinedOutputs;
+	}
+};
+function isSend(x) {
+	return x instanceof Send;
+}
+
+//#endregion
+export { ToolNode };
+//# sourceMappingURL=ToolNode.js.map

package/dist/agents/nodes/ToolNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolNode.js","names":["input: unknown","tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[]","options?: ToolNodeOptions","call: ToolCall","config: RunnableConfig","tool","e: unknown","state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"]","outputs: (ToolMessage | Command)[]","messages: BaseMessage[]","toolMessageIds: Set<string>","aiMessage: AIMessage | undefined","combinedOutputs: (\n      | { messages: BaseMessage[] }\n      | BaseMessage[]\n      | Command\n    )[]","parentCommand: Command | null","x: unknown"],"sources":["../../../src/agents/nodes/ToolNode.ts"],"sourcesContent":["/* eslint-disable no-instanceof/no-instanceof */\nimport {\n  BaseMessage,\n  ToolMessage,\n  AIMessage,\n  isBaseMessage,\n  isToolMessage,\n} from \"@langchain/core/messages\";\nimport { RunnableConfig, RunnableToolLike } from \"@langchain/core/runnables\";\nimport {\n  DynamicTool,\n  StructuredToolInterface,\n  ToolInputParsingException,\n} from \"@langchain/core/tools\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport type { InteropZodObject } from \"@langchain/core/utils/types\";\nimport {\n  isCommand,\n  Command,\n  Send,\n  isGraphInterrupt,\n  type NodeInterrupt,\n} from \"@langchain/langgraph\";\n\nimport { RunnableCallable } from \"../RunnableCallable.js\";\nimport {\n  PreHookAnnotation,\n  AnyAnnotationRoot,\n  ToAnnotationRoot,\n} from \"../annotation.js\";\nimport { mergeAbortSignals } from \"./utils.js\";\nimport { ToolInvocationError } from \"../errors.js\";\n\nexport interface ToolNodeOptions {\n  /**\n   * The name of the tool node.\n   */\n  name?: string;\n  /**\n   * The tags to add to the tool call.\n   */\n  tags?: string[];\n  /**\n   * The abort signal to cancel the tool call.\n   */\n  signal?: AbortSignal;\n  /**\n   * Whether to throw the error immediately if the tool fails or handle it by the `onToolError` function or via ToolMessage.\n   *\n   * If `true` (default):\n   *   - a tool message with the error will be returned to the LLM\n   *\n   * If `false`:\n   *   - the error will be thrown immediately\n   *\n   * If a function is provided:\n   *   - returns a custom {@link ToolMessage} as result\n   *   - throws an error otherwise\n   *\n   * @default true\n   */\n  handleToolErrors?:\n    | boolean\n    | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined);\n}\n\nconst isBaseMessageArray = (input: unknown): input is BaseMessage[] =>\n  Array.isArray(input) && input.every(isBaseMessage);\n\nconst isMessagesState = (\n  input: unknown\n): input is { messages: BaseMessage[] } =>\n  typeof input === \"object\" &&\n  input != null &&\n  \"messages\" in input &&\n  isBaseMessageArray(input.messages);\n\nconst isSendInput = (input: unknown): input is { lg_tool_call: ToolCall } =>\n  typeof input === \"object\" && input != null && \"lg_tool_call\" in input;\n\n/**\n * `ToolNode` is a built-in LangGraph component that handles tool calls within an agent's workflow.\n * It works seamlessly with `createReactAgent`, offering advanced tool execution control, built\n * in parallelism, and error handling.\n *\n * @example\n * ```ts\n * import { ToolNode, tool, AIMessage } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   }),\n * });\n *\n * const tools = [getWeather];\n * const toolNode = new ToolNode(tools);\n *\n * const messageWithSingleToolCall = new AIMessage({\n *   content: \"\",\n *   tool_calls: [\n *     {\n *       name: \"get_weather\",\n *       args: { location: \"sf\" },\n *       id: \"tool_call_id\",\n *       type: \"tool_call\",\n *     }\n *   ]\n * })\n *\n * await toolNode.invoke({ messages: [messageWithSingleToolCall] });\n * // Returns tool invocation responses as:\n * // { messages: ToolMessage[] }\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class ToolNode<\n  StateSchema extends AnyAnnotationRoot | InteropZodObject = any,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = any\n> extends RunnableCallable<StateSchema, ContextSchema> {\n  tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[];\n\n  trace = false;\n\n  signal?: AbortSignal;\n\n  handleToolErrors:\n    | boolean\n    | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined) = true;\n\n  constructor(\n    tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[],\n    public options?: ToolNodeOptions\n  ) {\n    const { name, tags, handleToolErrors } = options ?? {};\n    super({\n      name,\n      tags,\n      func: (state, config) =>\n        this.run(\n          state as ToAnnotationRoot<StateSchema>[\"State\"] &\n            PreHookAnnotation[\"State\"],\n          config as RunnableConfig\n        ),\n    });\n    this.tools = tools;\n    this.handleToolErrors = handleToolErrors ?? this.handleToolErrors;\n    this.signal = options?.signal;\n  }\n\n  protected async runTool(\n    call: ToolCall,\n    config: RunnableConfig\n  ): Promise<ToolMessage | Command> {\n    const tool = this.tools.find((tool) => tool.name === call.name);\n    try {\n      if (tool === undefined) {\n        throw new Error(`Tool \"${call.name}\" not found.`);\n      }\n\n      const output = await tool.invoke(\n        { ...call, type: \"tool_call\" },\n        {\n          ...config,\n          signal: mergeAbortSignals(this.signal, config.signal),\n        }\n      );\n\n      if (\n        (isBaseMessage(output) && output.getType() === \"tool\") ||\n        isCommand(output)\n      ) {\n        return output as ToolMessage | Command;\n      }\n\n      return new ToolMessage({\n        name: tool.name,\n        content: typeof output === \"string\" ? output : JSON.stringify(output),\n        tool_call_id: call.id!,\n      });\n    } catch (e: unknown) {\n      /**\n       * If tool invocation fails due to input parsing error, throw a {@link ToolInvocationError}\n       */\n      if (e instanceof ToolInputParsingException) {\n        throw new ToolInvocationError(e, call);\n      }\n\n      /**\n       * throw the error if user prefers not to handle tool errors\n       */\n      if (!this.handleToolErrors) {\n        throw e;\n      }\n\n      if (isGraphInterrupt(e)) {\n        /**\n         * {@link NodeInterrupt} errors are a breakpoint to bring a human into the loop.\n         * As such, they are not recoverable by the agent and shouldn't be fed\n         * back. Instead, re-throw these errors even when `handleToolErrors = true`.\n         */\n        throw e;\n      }\n\n      /**\n       * If the signal is aborted, we want to bubble up the error to the invoke caller.\n       */\n      if (this.signal?.aborted) {\n        throw e;\n      }\n\n      /**\n       * if the user provides a function, call it with the error and tool call\n       * and return the result if it is a {@link ToolMessage}\n       */\n      if (typeof this.handleToolErrors === \"function\") {\n        const result = this.handleToolErrors(e, call);\n        if (result && isToolMessage(result)) {\n          return result;\n        }\n      } else if (this.handleToolErrors) {\n        return new ToolMessage({\n          name: call.name,\n          content: `Error: ${e}\\n Please fix your mistakes.`,\n          tool_call_id: call.id!,\n        });\n      }\n\n      /**\n       * If the user doesn't handle the error, throw it\n       */\n      throw e;\n    }\n  }\n\n  protected async run(\n    state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"],\n    config: RunnableConfig\n  ): Promise<ContextSchema> {\n    let outputs: (ToolMessage | Command)[];\n\n    if (isSendInput(state)) {\n      outputs = [await this.runTool(state.lg_tool_call, config)];\n    } else {\n      let messages: BaseMessage[];\n      if (isBaseMessageArray(state)) {\n        messages = state;\n      } else if (isMessagesState(state)) {\n        messages = state.messages;\n      } else {\n        throw new Error(\n          \"ToolNode only accepts BaseMessage[] or { messages: BaseMessage[] } as input.\"\n        );\n      }\n\n      const toolMessageIds: Set<string> = new Set(\n        messages\n          .filter((msg) => msg.getType() === \"tool\")\n          .map((msg) => (msg as ToolMessage).tool_call_id)\n      );\n\n      let aiMessage: AIMessage | undefined;\n      for (let i = messages.length - 1; i >= 0; i -= 1) {\n        const message = messages[i];\n        if (message.getType() === \"ai\") {\n          aiMessage = message;\n          break;\n        }\n      }\n\n      if (aiMessage?.getType() !== \"ai\") {\n        throw new Error(\"ToolNode only accepts AIMessages as input.\");\n      }\n\n      outputs = await Promise.all(\n        aiMessage.tool_calls\n          ?.filter((call) => call.id == null || !toolMessageIds.has(call.id))\n          .map((call) => this.runTool(call, config)) ?? []\n      );\n    }\n\n    // Preserve existing behavior for non-command tool outputs for backwards compatibility\n    if (!outputs.some(isCommand)) {\n      return (Array.isArray(state)\n        ? outputs\n        : { messages: outputs }) as unknown as ContextSchema;\n    }\n\n    // Handle mixed Command and non-Command outputs\n    const combinedOutputs: (\n      | { messages: BaseMessage[] }\n      | BaseMessage[]\n      | Command\n    )[] = [];\n    let parentCommand: Command | null = null;\n\n    for (const output of outputs) {\n      if (isCommand(output)) {\n        if (\n          output.graph === Command.PARENT &&\n          Array.isArray(output.goto) &&\n          output.goto.every((send) => isSend(send))\n        ) {\n          if (parentCommand) {\n            (parentCommand.goto as Send[]).push(...(output.goto as Send[]));\n          } else {\n            parentCommand = new Command({\n              graph: Command.PARENT,\n              goto: output.goto,\n            });\n          }\n        } else {\n          combinedOutputs.push(output);\n        }\n      } else {\n        combinedOutputs.push(\n          Array.isArray(state) ? [output] : { messages: [output] }\n        );\n      }\n    }\n\n    if (parentCommand) {\n      combinedOutputs.push(parentCommand);\n    }\n\n    return combinedOutputs as unknown as ContextSchema;\n  }\n}\n\nexport function isSend(x: unknown): x is Send {\n  // eslint-disable-next-line no-instanceof/no-instanceof\n  return x instanceof Send;\n}\n"],"mappings":"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"}

package/dist/agents/nodes/utils.cjs

@@ -0,0 +1,17 @@
+
+//#region src/agents/nodes/utils.ts
+/**
+* `config` always contains a signal from LangGraphs Pregel class.
+* To ensure we acknowledge the abort signal from the user, we merge it
+* with the signal from the ToolNode.
+*
+* @param signals - The signals to merge.
+* @returns The merged signal.
+*/
+function mergeAbortSignals(...signals) {
+	return AbortSignal.any(signals.filter((maybeSignal) => maybeSignal !== null && maybeSignal !== void 0 && typeof maybeSignal === "object" && "aborted" in maybeSignal && typeof maybeSignal.aborted === "boolean"));
+}
+
+//#endregion
+exports.mergeAbortSignals = mergeAbortSignals;
+//# sourceMappingURL=utils.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.cjs","names":[],"sources":["../../../src/agents/nodes/utils.ts"],"sourcesContent":["/**\n * TypeScript currently doesn't support types for `AbortSignal.any`\n * @see https://github.com/microsoft/TypeScript/issues/60695\n */\ndeclare const AbortSignal: {\n  any(signals: AbortSignal[]): AbortSignal;\n};\n\n/**\n * `config` always contains a signal from LangGraphs Pregel class.\n * To ensure we acknowledge the abort signal from the user, we merge it\n * with the signal from the ToolNode.\n *\n * @param signals - The signals to merge.\n * @returns The merged signal.\n */\nexport function mergeAbortSignals(\n  ...signals: (AbortSignal | undefined)[]\n): AbortSignal {\n  return AbortSignal.any(\n    signals.filter(\n      (maybeSignal): maybeSignal is AbortSignal =>\n        maybeSignal !== null &&\n        maybeSignal !== undefined &&\n        typeof maybeSignal === \"object\" &&\n        \"aborted\" in maybeSignal &&\n        typeof maybeSignal.aborted === \"boolean\"\n    )\n  );\n}\n"],"mappings":";;;;;;;;;;AAgBA,SAAgB,kBACd,GAAG,SACU;AACb,QAAO,YAAY,IACjB,QAAQ,OACN,CAAC,gBACC,gBAAgB,QAChB,gBAAgB,UAChB,OAAO,gBAAgB,YACvB,aAAa,eACb,OAAO,YAAY,YAAY,UAClC,CACF;AACF"}

package/dist/agents/nodes/utils.js

@@ -0,0 +1,16 @@
+//#region src/agents/nodes/utils.ts
+/**
+* `config` always contains a signal from LangGraphs Pregel class.
+* To ensure we acknowledge the abort signal from the user, we merge it
+* with the signal from the ToolNode.
+*
+* @param signals - The signals to merge.
+* @returns The merged signal.
+*/
+function mergeAbortSignals(...signals) {
+	return AbortSignal.any(signals.filter((maybeSignal) => maybeSignal !== null && maybeSignal !== void 0 && typeof maybeSignal === "object" && "aborted" in maybeSignal && typeof maybeSignal.aborted === "boolean"));
+}
+
+//#endregion
+export { mergeAbortSignals };
+//# sourceMappingURL=utils.js.map

package/dist/agents/nodes/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":[],"sources":["../../../src/agents/nodes/utils.ts"],"sourcesContent":["/**\n * TypeScript currently doesn't support types for `AbortSignal.any`\n * @see https://github.com/microsoft/TypeScript/issues/60695\n */\ndeclare const AbortSignal: {\n  any(signals: AbortSignal[]): AbortSignal;\n};\n\n/**\n * `config` always contains a signal from LangGraphs Pregel class.\n * To ensure we acknowledge the abort signal from the user, we merge it\n * with the signal from the ToolNode.\n *\n * @param signals - The signals to merge.\n * @returns The merged signal.\n */\nexport function mergeAbortSignals(\n  ...signals: (AbortSignal | undefined)[]\n): AbortSignal {\n  return AbortSignal.any(\n    signals.filter(\n      (maybeSignal): maybeSignal is AbortSignal =>\n        maybeSignal !== null &&\n        maybeSignal !== undefined &&\n        typeof maybeSignal === \"object\" &&\n        \"aborted\" in maybeSignal &&\n        typeof maybeSignal.aborted === \"boolean\"\n    )\n  );\n}\n"],"mappings":";;;;;;;;;AAgBA,SAAgB,kBACd,GAAG,SACU;AACb,QAAO,YAAY,IACjB,QAAQ,OACN,CAAC,gBACC,gBAAgB,QAChB,gBAAgB,UAChB,OAAO,gBAAgB,YACvB,aAAa,eACb,OAAO,YAAY,YAAY,UAClC,CACF;AACF"}

package/dist/agents/responses.cjs

@@ -0,0 +1,167 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_errors = require('./errors.cjs');
+const __langchain_core_utils_types = require_rolldown_runtime.__toESM(require("@langchain/core/utils/types"));
+const __langchain_core_utils_json_schema = require_rolldown_runtime.__toESM(require("@langchain/core/utils/json_schema"));
+
+//#region src/agents/responses.ts
+/**
+* This is a global counter for generating unique names for tools.
+*/
+let bindingIdentifier = 0;
+/**
+* Information for tracking structured output tool metadata.
+* This contains all necessary information to handle structured responses generated
+* via tool calls, including the original schema, its type classification, and the
+* corresponding tool implementation used by the tools strategy.
+*/
+var ToolStrategy = class ToolStrategy {
+	constructor(schema, tool, options) {
+		this.schema = schema;
+		this.tool = tool;
+		this.options = options;
+	}
+	get name() {
+		return this.tool.function.name;
+	}
+	static fromSchema(schema, options, outputOptions) {
+		/**
+		* It is required for tools to have a name so we can map the tool call to the correct tool
+		* when parsing the response.
+		*/
+		function getFunctionName(name) {
+			return name ?? options?.name ?? `extract-${++bindingIdentifier}`;
+		}
+		if ((0, __langchain_core_utils_types.isInteropZodSchema)(schema)) {
+			const asJsonSchema$1 = (0, __langchain_core_utils_json_schema.toJsonSchema)(schema);
+			const tool$1 = {
+				type: "function",
+				function: {
+					name: getFunctionName(),
+					strict: options?.strict,
+					description: options?.description ?? asJsonSchema$1.description ?? "Tool for extracting structured output from the model's response.",
+					parameters: asJsonSchema$1
+				}
+			};
+			return new ToolStrategy(asJsonSchema$1, tool$1, outputOptions);
+		}
+		let functionDefinition;
+		if (typeof schema.name === "string" && typeof schema.parameters === "object" && schema.parameters != null) functionDefinition = schema;
+		else functionDefinition = {
+			name: getFunctionName(schema.title),
+			description: schema.description ?? "",
+			parameters: schema
+		};
+		const asJsonSchema = (0, __langchain_core_utils_json_schema.toJsonSchema)(schema);
+		const tool = {
+			type: "function",
+			name: getFunctionName(),
+			function: functionDefinition
+		};
+		return new ToolStrategy(asJsonSchema, tool, outputOptions);
+	}
+	/**
+	* Parse tool arguments according to the schema.
+	*
+	* @throws {StructuredOutputParsingError} if the response is not valid
+	* @param toolArgs - The arguments from the tool call
+	* @returns The parsed response according to the schema type
+	*/
+	parse(toolArgs) {
+		const validator = new __langchain_core_utils_json_schema.Validator(this.schema);
+		const result = validator.validate(toolArgs);
+		if (!result.valid) throw new require_errors.StructuredOutputParsingError(this.name, result.errors.map((e) => e.error));
+		return toolArgs;
+	}
+};
+var ProviderStrategy = class ProviderStrategy {
+	_schemaType;
+	constructor(schema) {
+		this.schema = schema;
+	}
+	static fromSchema(schema) {
+		const asJsonSchema = (0, __langchain_core_utils_json_schema.toJsonSchema)(schema);
+		return new ProviderStrategy(asJsonSchema);
+	}
+	/**
+	* Parse tool arguments according to the schema. If the response is not valid, return undefined.
+	*
+	* @param toolArgs - The arguments from the tool call
+	* @returns The parsed response according to the schema type
+	*/
+	parse(response) {
+		/**
+		* return if the response doesn't contain valid content
+		*/
+		if (typeof response.content !== "string" || response.content === "") return;
+		try {
+			const content = JSON.parse(response.content);
+			const validator = new __langchain_core_utils_json_schema.Validator(this.schema);
+			const result = validator.validate(content);
+			if (!result.valid) return;
+			return content;
+		} catch (error) {}
+	}
+};
+/**
+* Handle user input for `responseFormat` parameter of `CreateReactAgentParams`.
+* This function defines the default behavior for the `responseFormat` parameter, which is:
+*
+* - if value is a Zod schema, default to structured output via tool calling
+* - if value is a JSON schema, default to structured output via tool calling
+* - if value is a custom response format, return it as is
+* - if value is an array, ensure all array elements are instance of `ToolStrategy`
+* @param responseFormat
+* @returns
+*/
+function transformResponseFormat(responseFormat, options) {
+	if (!responseFormat) return [];
+	if (typeof responseFormat === "object" && responseFormat !== null && "__responseFormatUndefined" in responseFormat) return [];
+	/**
+	* If users provide an array, it should only contain raw schemas (Zod or JSON schema),
+	* not ToolStrategy or ProviderStrategy instances.
+	*/
+	if (Array.isArray(responseFormat)) {
+		/**
+		* if every entry is a ToolStrategy or ProviderStrategy instance, return the array as is
+		*/
+		if (responseFormat.every((item) => item instanceof ToolStrategy || item instanceof ProviderStrategy)) return responseFormat;
+		/**
+		* Check if all items are Zod schemas
+		*/
+		if (responseFormat.every((item) => (0, __langchain_core_utils_types.isInteropZodObject)(item))) return responseFormat.map((item) => ToolStrategy.fromSchema(item, void 0, options));
+		/**
+		* Check if all items are plain objects (JSON schema)
+		*/
+		if (responseFormat.every((item) => typeof item === "object" && item !== null && !(0, __langchain_core_utils_types.isInteropZodObject)(item))) return responseFormat.map((item) => ToolStrategy.fromSchema(item, void 0, options));
+		throw new Error("Invalid response format: list contains mixed types.\nAll items must be either InteropZodObject or plain JSON schema objects.");
+	}
+	if ((0, __langchain_core_utils_types.isInteropZodObject)(responseFormat)) return [ToolStrategy.fromSchema(responseFormat, void 0, options)];
+	if (responseFormat instanceof ToolStrategy || responseFormat instanceof ProviderStrategy) return [responseFormat];
+	/**
+	* Handle plain object (JSON schema)
+	*/
+	if (typeof responseFormat === "object" && responseFormat !== null && "properties" in responseFormat) return [ToolStrategy.fromSchema(responseFormat, void 0, options)];
+	throw new Error(`Invalid response format: ${String(responseFormat)}`);
+}
+/**
+* Define how to transform the response format from a tool call.
+*
+* @param responseFormat - The response format to transform
+* @param options - The options to use for the transformation
+* @param options.handleError - Whether to handle errors from the tool call
+* @returns The transformed response format
+*/
+function toolStrategy(responseFormat, options) {
+	return transformResponseFormat(responseFormat, options);
+}
+function providerStrategy(responseFormat) {
+	return ProviderStrategy.fromSchema(responseFormat);
+}
+
+//#endregion
+exports.ProviderStrategy = ProviderStrategy;
+exports.ToolStrategy = ToolStrategy;
+exports.providerStrategy = providerStrategy;
+exports.toolStrategy = toolStrategy;
+exports.transformResponseFormat = transformResponseFormat;
+//# sourceMappingURL=responses.cjs.map

package/dist/agents/responses.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"responses.cjs","names":["schema: Record<string, unknown>","tool: {\n      type: \"function\";\n      function: FunctionDefinition;\n    }","options?: ToolStrategyOptions","schema: InteropZodObject | Record<string, unknown>","options?: {\n      name?: string;\n      description?: string;\n      strict?: boolean;\n    }","outputOptions?: ToolStrategyOptions","name?: string","asJsonSchema","tool","functionDefinition: FunctionDefinition","toolArgs: Record<string, unknown>","Validator","StructuredOutputParsingError","schema: InteropZodType<T> | Record<string, unknown>","response: AIMessage","responseFormat?:\n    | InteropZodType<any>\n    | InteropZodType<any>[]\n    | JsonSchemaFormat\n    | JsonSchemaFormat[]\n    | ResponseFormat\n    | ToolStrategy<any>[]\n    | ResponseFormatUndefined","responseFormat:\n    | InteropZodType<any>\n    | InteropZodType<any>[]\n    | JsonSchemaFormat\n    | JsonSchemaFormat[]","responseFormat: InteropZodType<any> | JsonSchemaFormat"],"sources":["../../src/agents/responses.ts"],"sourcesContent":["/* eslint-disable no-instanceof/no-instanceof */\nimport {\n  InteropZodObject,\n  isInteropZodSchema,\n  InteropZodType,\n  isInteropZodObject,\n} from \"@langchain/core/utils/types\";\nimport { type AIMessage } from \"@langchain/core/messages\";\nimport { toJsonSchema, Validator } from \"@langchain/core/utils/json_schema\";\nimport { type FunctionDefinition } from \"@langchain/core/language_models/base\";\n\nimport {\n  StructuredOutputParsingError,\n  MultipleStructuredOutputsError,\n} from \"./errors.js\";\n\n/**\n * This is a global counter for generating unique names for tools.\n */\nlet bindingIdentifier = 0;\n\n/**\n * Information for tracking structured output tool metadata.\n * This contains all necessary information to handle structured responses generated\n * via tool calls, including the original schema, its type classification, and the\n * corresponding tool implementation used by the tools strategy.\n */\nexport class ToolStrategy<_T = unknown> {\n  private constructor(\n    /**\n     * The original JSON Schema provided for structured output\n     */\n    public readonly schema: Record<string, unknown>,\n\n    /**\n     * The tool that will be used to parse the tool call arguments.\n     */\n    public readonly tool: {\n      type: \"function\";\n      function: FunctionDefinition;\n    },\n\n    /**\n     * The options to use for the tool output.\n     */\n    public readonly options?: ToolStrategyOptions\n  ) {}\n\n  get name() {\n    return this.tool.function.name;\n  }\n\n  static fromSchema<S extends InteropZodObject>(\n    schema: S,\n    options?: {\n      name?: string;\n      description?: string;\n      strict?: boolean;\n    },\n    outputOptions?: ToolStrategyOptions\n  ): ToolStrategy<S extends InteropZodType<infer U> ? U : unknown>;\n\n  static fromSchema(\n    schema: Record<string, unknown>,\n    options?: {\n      name?: string;\n      description?: string;\n      strict?: boolean;\n    },\n    outputOptions?: ToolStrategyOptions\n  ): ToolStrategy<Record<string, unknown>>;\n\n  static fromSchema(\n    schema: InteropZodObject | Record<string, unknown>,\n    options?: {\n      name?: string;\n      description?: string;\n      strict?: boolean;\n    },\n    outputOptions?: ToolStrategyOptions\n  ): ToolStrategy<any> {\n    /**\n     * It is required for tools to have a name so we can map the tool call to the correct tool\n     * when parsing the response.\n     */\n    function getFunctionName(name?: string) {\n      return name ?? options?.name ?? `extract-${++bindingIdentifier}`;\n    }\n\n    if (isInteropZodSchema(schema)) {\n      const asJsonSchema = toJsonSchema(schema);\n      const tool = {\n        type: \"function\" as const,\n        function: {\n          name: getFunctionName(),\n          strict: options?.strict,\n          description:\n            options?.description ??\n            asJsonSchema.description ??\n            \"Tool for extracting structured output from the model's response.\",\n          parameters: asJsonSchema,\n        },\n      };\n      return new ToolStrategy(asJsonSchema, tool, outputOptions);\n    }\n\n    let functionDefinition: FunctionDefinition;\n    if (\n      typeof schema.name === \"string\" &&\n      typeof schema.parameters === \"object\" &&\n      schema.parameters != null\n    ) {\n      functionDefinition = schema as unknown as FunctionDefinition;\n    } else {\n      functionDefinition = {\n        name: getFunctionName(schema.title as string),\n        description: (schema.description as string) ?? \"\",\n        parameters: schema,\n      };\n    }\n    const asJsonSchema = toJsonSchema(schema);\n    const tool = {\n      type: \"function\" as const,\n      name: getFunctionName(),\n      function: functionDefinition,\n    };\n    return new ToolStrategy(asJsonSchema, tool, outputOptions);\n  }\n\n  /**\n   * Parse tool arguments according to the schema.\n   *\n   * @throws {StructuredOutputParsingError} if the response is not valid\n   * @param toolArgs - The arguments from the tool call\n   * @returns The parsed response according to the schema type\n   */\n  parse(toolArgs: Record<string, unknown>): Record<string, unknown> {\n    const validator = new Validator(this.schema);\n    const result = validator.validate(toolArgs);\n    if (!result.valid) {\n      throw new StructuredOutputParsingError(\n        this.name,\n        result.errors.map((e) => e.error)\n      );\n    }\n    return toolArgs;\n  }\n}\n\nexport class ProviderStrategy<T = unknown> {\n  // @ts-expect-error - _schemaType is used only for type inference\n  private _schemaType?: T;\n\n  private constructor(public readonly schema: Record<string, unknown>) {}\n\n  static fromSchema<T>(schema: InteropZodType<T>): ProviderStrategy<T>;\n\n  static fromSchema(\n    schema: Record<string, unknown>\n  ): ProviderStrategy<Record<string, unknown>>;\n\n  static fromSchema<T = unknown>(\n    schema: InteropZodType<T> | Record<string, unknown>\n  ): ProviderStrategy<T> | ProviderStrategy<Record<string, unknown>> {\n    const asJsonSchema = toJsonSchema(schema);\n    return new ProviderStrategy(asJsonSchema) as\n      | ProviderStrategy<T>\n      | ProviderStrategy<Record<string, unknown>>;\n  }\n\n  /**\n   * Parse tool arguments according to the schema. If the response is not valid, return undefined.\n   *\n   * @param toolArgs - The arguments from the tool call\n   * @returns The parsed response according to the schema type\n   */\n  parse(response: AIMessage) {\n    /**\n     * return if the response doesn't contain valid content\n     */\n    if (typeof response.content !== \"string\" || response.content === \"\") {\n      return;\n    }\n\n    try {\n      const content = JSON.parse(response.content);\n      const validator = new Validator(this.schema);\n      const result = validator.validate(content);\n      if (!result.valid) {\n        return;\n      }\n\n      return content;\n    } catch (error) {\n      // no-op\n    }\n  }\n}\n\nexport type ResponseFormat = ToolStrategy<any> | ProviderStrategy<any>;\n\n/**\n * Handle user input for `responseFormat` parameter of `CreateReactAgentParams`.\n * This function defines the default behavior for the `responseFormat` parameter, which is:\n *\n * - if value is a Zod schema, default to structured output via tool calling\n * - if value is a JSON schema, default to structured output via tool calling\n * - if value is a custom response format, return it as is\n * - if value is an array, ensure all array elements are instance of `ToolStrategy`\n * @param responseFormat\n * @returns\n */\nexport function transformResponseFormat(\n  responseFormat?:\n    | InteropZodType<any>\n    | InteropZodType<any>[]\n    | JsonSchemaFormat\n    | JsonSchemaFormat[]\n    | ResponseFormat\n    | ToolStrategy<any>[]\n    | ResponseFormatUndefined,\n  options?: ToolStrategyOptions\n): ResponseFormat[] {\n  if (!responseFormat) {\n    return [];\n  }\n\n  // Handle ResponseFormatUndefined case\n  if (\n    typeof responseFormat === \"object\" &&\n    responseFormat !== null &&\n    \"__responseFormatUndefined\" in responseFormat\n  ) {\n    return [];\n  }\n\n  /**\n   * If users provide an array, it should only contain raw schemas (Zod or JSON schema),\n   * not ToolStrategy or ProviderStrategy instances.\n   */\n  if (Array.isArray(responseFormat)) {\n    /**\n     * if every entry is a ToolStrategy or ProviderStrategy instance, return the array as is\n     */\n    if (\n      responseFormat.every(\n        (item) =>\n          item instanceof ToolStrategy || item instanceof ProviderStrategy\n      )\n    ) {\n      return responseFormat as unknown as ResponseFormat[];\n    }\n\n    /**\n     * Check if all items are Zod schemas\n     */\n    if (responseFormat.every((item) => isInteropZodObject(item))) {\n      return responseFormat.map((item) =>\n        ToolStrategy.fromSchema(item as InteropZodObject, undefined, options)\n      );\n    }\n\n    /**\n     * Check if all items are plain objects (JSON schema)\n     */\n    if (\n      responseFormat.every(\n        (item) =>\n          typeof item === \"object\" && item !== null && !isInteropZodObject(item)\n      )\n    ) {\n      return responseFormat.map((item) =>\n        ToolStrategy.fromSchema(item as JsonSchemaFormat, undefined, options)\n      );\n    }\n\n    throw new Error(\n      `Invalid response format: list contains mixed types.\\n` +\n        `All items must be either InteropZodObject or plain JSON schema objects.`\n    );\n  }\n\n  if (isInteropZodObject(responseFormat)) {\n    return [ToolStrategy.fromSchema(responseFormat, undefined, options)];\n  }\n\n  if (\n    responseFormat instanceof ToolStrategy ||\n    responseFormat instanceof ProviderStrategy\n  ) {\n    return [responseFormat];\n  }\n\n  /**\n   * Handle plain object (JSON schema)\n   */\n  if (\n    typeof responseFormat === \"object\" &&\n    responseFormat !== null &&\n    \"properties\" in responseFormat\n  ) {\n    return [\n      ToolStrategy.fromSchema(\n        responseFormat as JsonSchemaFormat,\n        undefined,\n        options\n      ),\n    ];\n  }\n\n  throw new Error(`Invalid response format: ${String(responseFormat)}`);\n}\n\n/**\n * Branded type for ToolStrategy arrays that preserves type information\n */\nexport interface TypedToolStrategy<T = unknown>\n  extends Array<ToolStrategy<any>> {\n  _schemaType?: T;\n}\nexport type ToolStrategyError =\n  | StructuredOutputParsingError\n  | MultipleStructuredOutputsError;\nexport interface ToolStrategyOptions {\n  /**\n   * Handle errors from the structured output tool call. Using tools to generate structured output\n   * can cause errors, e.g. if:\n   * - you provide multiple structured output schemas and the model calls multiple structured output tools\n   * - if the structured output generated by the tool call doesn't match provided schema\n   *\n   * This property allows to handle these errors in different ways:\n   * - `true` - retry the tool call\n   * - `false` - throw an error\n   * - `string` - retry the tool call with the provided message\n   * - `(error: ToolStrategyError) => Promise<string> | string` - retry with the provided message or throw the error\n   */\n  handleError?:\n    | boolean\n    | string\n    | ((error: ToolStrategyError) => Promise<string> | string);\n}\n\nexport function toolStrategy<T extends InteropZodType<any>>(\n  responseFormat: T,\n  options?: ToolStrategyOptions\n): TypedToolStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport function toolStrategy<T extends readonly InteropZodType<any>[]>(\n  responseFormat: T,\n  options?: ToolStrategyOptions\n): TypedToolStrategy<\n  { [K in keyof T]: T[K] extends InteropZodType<infer U> ? U : never }[number]\n>;\nexport function toolStrategy(\n  responseFormat: JsonSchemaFormat,\n  options?: ToolStrategyOptions\n): TypedToolStrategy<Record<string, unknown>>;\nexport function toolStrategy(\n  responseFormat: JsonSchemaFormat[],\n  options?: ToolStrategyOptions\n): TypedToolStrategy<Record<string, unknown>>;\n\n/**\n * Define how to transform the response format from a tool call.\n *\n * @param responseFormat - The response format to transform\n * @param options - The options to use for the transformation\n * @param options.handleError - Whether to handle errors from the tool call\n * @returns The transformed response format\n */\nexport function toolStrategy(\n  responseFormat:\n    | InteropZodType<any>\n    | InteropZodType<any>[]\n    | JsonSchemaFormat\n    | JsonSchemaFormat[],\n  options?: ToolStrategyOptions\n): TypedToolStrategy {\n  return transformResponseFormat(responseFormat, options) as TypedToolStrategy;\n}\n\nexport function providerStrategy<T extends InteropZodType<any>>(\n  responseFormat: T\n): ProviderStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport function providerStrategy(\n  responseFormat: JsonSchemaFormat\n): ProviderStrategy<Record<string, unknown>>;\nexport function providerStrategy(\n  responseFormat: InteropZodType<any> | JsonSchemaFormat\n): ProviderStrategy<any> {\n  return ProviderStrategy.fromSchema(\n    responseFormat as any\n  ) as ProviderStrategy<any>;\n}\n\n/**\n * Special type to indicate that no response format is provided.\n * When this type is used, the structuredResponse property should not be present in the result.\n */\nexport type ResponseFormatUndefined = {\n  __responseFormatUndefined: true;\n};\n\n/**\n * Type representing a JSON Schema object format.\n * This is a strict type that excludes ToolStrategy and ProviderStrategy instances.\n */\nexport type JsonSchemaFormat = {\n  type:\n    | \"null\"\n    | \"boolean\"\n    | \"object\"\n    | \"array\"\n    | \"number\"\n    | \"string\"\n    | \"integer\";\n  properties?: Record<string, unknown>;\n  required?: string[];\n  additionalProperties?: boolean;\n  [key: string]: unknown;\n} & {\n  // Brand to ensure this is not a ToolStrategy or ProviderStrategy\n  __brand?: never;\n};\n"],"mappings":";;;;;;;;;AAmBA,IAAI,oBAAoB;;;;;;;AAQxB,IAAa,eAAb,MAAa,aAA2B;CACtC,AAAQ,YAIUA,QAKAC,MAQAC,SAChB;EAdgB;EAKA;EAQA;CACd;CAEJ,IAAI,OAAO;AACT,SAAO,KAAK,KAAK,SAAS;CAC3B;CAsBD,OAAO,WACLC,QACAC,SAKAC,eACmB;;;;;EAKnB,SAAS,gBAAgBC,MAAe;AACtC,UAAO,QAAQ,SAAS,QAAQ,CAAC,QAAQ,EAAE,EAAE,mBAAmB;EACjE;AAED,2DAAuB,OAAO,EAAE;GAC9B,MAAMC,sEAA4B,OAAO;GACzC,MAAMC,SAAO;IACX,MAAM;IACN,UAAU;KACR,MAAM,iBAAiB;KACvB,QAAQ,SAAS;KACjB,aACE,SAAS,eACTD,eAAa,eACb;KACF,YAAYA;IACb;GACF;AACD,UAAO,IAAI,aAAaA,gBAAcC,QAAM;EAC7C;EAED,IAAIC;AACJ,MACE,OAAO,OAAO,SAAS,YACvB,OAAO,OAAO,eAAe,YAC7B,OAAO,cAAc,MAErB,qBAAqB;OAErB,qBAAqB;GACnB,MAAM,gBAAgB,OAAO,MAAgB;GAC7C,aAAc,OAAO,eAA0B;GAC/C,YAAY;EACb;EAEH,MAAM,oEAA4B,OAAO;EACzC,MAAM,OAAO;GACX,MAAM;GACN,MAAM,iBAAiB;GACvB,UAAU;EACX;AACD,SAAO,IAAI,aAAa,cAAc,MAAM;CAC7C;;;;;;;;CASD,MAAMC,UAA4D;EAChE,MAAM,YAAY,IAAIC,6CAAU,KAAK;EACrC,MAAM,SAAS,UAAU,SAAS,SAAS;AAC3C,MAAI,CAAC,OAAO,MACV,OAAM,IAAIC,4CACR,KAAK,MACL,OAAO,OAAO,IAAI,CAAC,MAAM,EAAE,MAAM;AAGrC,SAAO;CACR;AACF;AAED,IAAa,mBAAb,MAAa,iBAA8B;CAEzC,AAAQ;CAER,AAAQ,YAA4BZ,QAAiC;EAAjC;CAAmC;CAQvE,OAAO,WACLa,QACiE;EACjE,MAAM,oEAA4B,OAAO;AACzC,SAAO,IAAI,iBAAiB;CAG7B;;;;;;;CAQD,MAAMC,UAAqB;;;;AAIzB,MAAI,OAAO,SAAS,YAAY,YAAY,SAAS,YAAY,GAC/D;AAGF,MAAI;GACF,MAAM,UAAU,KAAK,MAAM,SAAS,QAAQ;GAC5C,MAAM,YAAY,IAAIH,6CAAU,KAAK;GACrC,MAAM,SAAS,UAAU,SAAS,QAAQ;AAC1C,OAAI,CAAC,OAAO,MACV;AAGF,UAAO;EACR,SAAQ,OAAO,CAEf;CACF;AACF;;;;;;;;;;;;AAeD,SAAgB,wBACdI,gBAQAb,SACkB;AAClB,KAAI,CAAC,eACH,QAAO,CAAE;AAIX,KACE,OAAO,mBAAmB,YAC1B,mBAAmB,QACnB,+BAA+B,eAE/B,QAAO,CAAE;;;;;AAOX,KAAI,MAAM,QAAQ,eAAe,EAAE;;;;AAIjC,MACE,eAAe,MACb,CAAC,SACC,gBAAgB,gBAAgB,gBAAgB,iBACnD,CAED,QAAO;;;;AAMT,MAAI,eAAe,MAAM,CAAC,8DAA4B,KAAK,CAAC,CAC1D,QAAO,eAAe,IAAI,CAAC,SACzB,aAAa,WAAW,MAA0B,QAAW,QAAQ,CACtE;;;;AAMH,MACE,eAAe,MACb,CAAC,SACC,OAAO,SAAS,YAAY,SAAS,QAAQ,sDAAoB,KAAK,CACzE,CAED,QAAO,eAAe,IAAI,CAAC,SACzB,aAAa,WAAW,MAA0B,QAAW,QAAQ,CACtE;AAGH,QAAM,IAAI,MACR;CAGH;AAED,0DAAuB,eAAe,CACpC,QAAO,CAAC,aAAa,WAAW,gBAAgB,QAAW,QAAQ,AAAC;AAGtE,KACE,0BAA0B,gBAC1B,0BAA0B,iBAE1B,QAAO,CAAC,cAAe;;;;AAMzB,KACE,OAAO,mBAAmB,YAC1B,mBAAmB,QACnB,gBAAgB,eAEhB,QAAO,CACL,aAAa,WACX,gBACA,QACA,QACD,AACF;AAGH,OAAM,IAAI,MAAM,CAAC,yBAAyB,EAAE,OAAO,eAAe,EAAE;AACrE;;;;;;;;;AA0DD,SAAgB,aACdc,gBAKAd,SACmB;AACnB,QAAO,wBAAwB,gBAAgB,QAAQ;AACxD;AAQD,SAAgB,iBACde,gBACuB;AACvB,QAAO,iBAAiB,WACtB,eACD;AACF"}