@langchain/langgraph 1.0.12 → 1.0.14

package/dist/prebuilt/tool_node.d.cts

@@ -0,0 +1,180 @@
+import { RunnableCallable } from "../utils.cjs";
+import { Command, END } from "../constants.cjs";
+import { MessagesAnnotation } from "../graph/messages_annotation.cjs";
+import { RunnableConfig, RunnableToolLike } from "@langchain/core/runnables";
+import { BaseMessage, ToolMessage } from "@langchain/core/messages";
+import { DynamicTool, StructuredToolInterface } from "@langchain/core/tools";
+import { ToolCall } from "@langchain/core/messages/tool";
+
+//#region src/prebuilt/tool_node.d.ts
+type ToolNodeOptions = {
+  name?: string;
+  tags?: string[];
+  handleToolErrors?: boolean;
+};
+/**
+ * A node that runs the tools requested in the last AIMessage. It can be used
+ * either in StateGraph with a "messages" key or in MessageGraph. If multiple
+ * tool calls are requested, they will be run in parallel. The output will be
+ * a list of ToolMessages, one for each tool call.
+ *
+ * @example
+ * ```ts
+ * import { ToolNode } from "@langchain/langgraph/prebuilt";
+ * import { tool } from "@langchain/core/tools";
+ * import { z } from "zod";
+ * import { AIMessage } from "@langchain/core/messages";
+ *
+ * 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[] }
+ * ```
+ *
+ * @example
+ * ```ts
+ * import {
+ *   StateGraph,
+ *   MessagesAnnotation,
+ * } from "@langchain/langgraph";
+ * import { ToolNode } from "@langchain/langgraph/prebuilt";
+ * import { tool } from "@langchain/core/tools";
+ * import { z } from "zod";
+ * import { ChatAnthropic } from "@langchain/anthropic";
+ *
+ * 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 modelWithTools = new ChatAnthropic({
+ *   model: "claude-3-haiku-20240307",
+ *   temperature: 0
+ * }).bindTools(tools);
+ *
+ * const toolNodeForGraph = new ToolNode(tools)
+ *
+ * const shouldContinue = (state: typeof MessagesAnnotation.State) => {
+ *   const { messages } = state;
+ *   const lastMessage = messages[messages.length - 1];
+ *   if ("tool_calls" in lastMessage && Array.isArray(lastMessage.tool_calls) && lastMessage.tool_calls?.length) {
+ *     return "tools";
+ *   }
+ *   return "__end__";
+ * }
+ *
+ * const callModel = async (state: typeof MessagesAnnotation.State) => {
+ *   const { messages } = state;
+ *   const response = await modelWithTools.invoke(messages);
+ *   return { messages: response };
+ * }
+ *
+ * const graph = new StateGraph(MessagesAnnotation)
+ *   .addNode("agent", callModel)
+ *   .addNode("tools", toolNodeForGraph)
+ *   .addEdge("__start__", "agent")
+ *   .addConditionalEdges("agent", shouldContinue)
+ *   .addEdge("tools", "agent")
+ *   .compile();
+ *
+ * const inputs = {
+ *   messages: [{ role: "user", content: "what is the weather in SF?" }],
+ * };
+ *
+ * const stream = await graph.stream(inputs, {
+ *   streamMode: "values",
+ * });
+ *
+ * for await (const { messages } of stream) {
+ *   console.log(messages);
+ * }
+ * // Returns the messages in the state at each step of execution
+ * ```
+ */
+declare class ToolNode<T = any> extends RunnableCallable<T, T> {
+  tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[];
+  handleToolErrors: boolean;
+  trace: boolean;
+  constructor(tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[], options?: ToolNodeOptions);
+  protected runTool(call: ToolCall, config: RunnableConfig): Promise<ToolMessage | Command>;
+  protected run(input: unknown, config: RunnableConfig): Promise<T>;
+}
+/**
+ * A conditional edge function that determines whether to route to a tools node or end the graph.
+ *
+ * This function is designed to be used as a conditional edge in a LangGraph state graph to implement
+ * the common pattern of checking if an AI message contains tool calls that need to be executed.
+ *
+ * @param state - The current state of the graph, which can be either:
+ *   - An array of `BaseMessage` objects, where the last message is checked for tool calls
+ *   - A state object conforming to `MessagesAnnotation.State`, which contains a `messages` array
+ *
+ * @returns A string indicating the next node to route to:
+ *   - `"tools"` - If the last message contains tool calls that need to be executed
+ *   - `END` - If there are no tool calls, indicating the graph should terminate
+ *
+ * @example
+ * ```typescript
+ * import { StateGraph, MessagesAnnotation, END, START } from "@langchain/langgraph";
+ * import { ToolNode, toolsCondition } from "@langchain/langgraph/prebuilt";
+ *
+ * const graph = new StateGraph(MessagesAnnotation)
+ *   .addNode("agent", agentNode)
+ *   .addNode("tools", new ToolNode([searchTool, calculatorTool]))
+ *   .addEdge(START, "agent")
+ *   .addConditionalEdges("agent", toolsCondition, ["tools", END])
+ *   .addEdge("tools", "agent")
+ *   .compile();
+ * ```
+ *
+ * @remarks
+ * The function checks the last message in the state for the presence of `tool_calls`.
+ * If the message is an `AIMessage` with one or more tool calls, it returns `"tools"`,
+ * indicating that the graph should route to a tools node (typically a `ToolNode`) to
+ * execute those tool calls. Otherwise, it returns `END` to terminate the graph execution.
+ *
+ * This is a common pattern in agentic workflows where an AI model decides whether to
+ * use tools or provide a final response.
+ */
+declare function toolsCondition(state: BaseMessage[] | typeof MessagesAnnotation.State): "tools" | typeof END;
+//#endregion
+export { ToolNode, ToolNodeOptions, toolsCondition };
+//# sourceMappingURL=tool_node.d.cts.map

package/dist/prebuilt/tool_node.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool_node.d.cts","names":["BaseMessage","ToolMessage","RunnableConfig","RunnableToolLike","DynamicTool","StructuredToolInterface","ToolCall","RunnableCallable","MessagesAnnotation","END","Command","ToolNodeOptions","ToolNode","T","Promise","toolsCondition","State"],"sources":["../../src/prebuilt/tool_node.d.ts"],"sourcesContent":["import { BaseMessage, 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 { RunnableCallable } from \"../utils.js\";\nimport { MessagesAnnotation } from \"../graph/messages_annotation.js\";\nimport { END, Command } from \"../constants.js\";\nexport type ToolNodeOptions = {\n    name?: string;\n    tags?: string[];\n    handleToolErrors?: boolean;\n};\n/**\n * A node that runs the tools requested in the last AIMessage. It can be used\n * either in StateGraph with a \"messages\" key or in MessageGraph. If multiple\n * tool calls are requested, they will be run in parallel. The output will be\n * a list of ToolMessages, one for each tool call.\n *\n * @example\n * ```ts\n * import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n * import { AIMessage } from \"@langchain/core/messages\";\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 * @example\n * ```ts\n * import {\n *   StateGraph,\n *   MessagesAnnotation,\n * } from \"@langchain/langgraph\";\n * import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n * import { ChatAnthropic } from \"@langchain/anthropic\";\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 modelWithTools = new ChatAnthropic({\n *   model: \"claude-3-haiku-20240307\",\n *   temperature: 0\n * }).bindTools(tools);\n *\n * const toolNodeForGraph = new ToolNode(tools)\n *\n * const shouldContinue = (state: typeof MessagesAnnotation.State) => {\n *   const { messages } = state;\n *   const lastMessage = messages[messages.length - 1];\n *   if (\"tool_calls\" in lastMessage && Array.isArray(lastMessage.tool_calls) && lastMessage.tool_calls?.length) {\n *     return \"tools\";\n *   }\n *   return \"__end__\";\n * }\n *\n * const callModel = async (state: typeof MessagesAnnotation.State) => {\n *   const { messages } = state;\n *   const response = await modelWithTools.invoke(messages);\n *   return { messages: response };\n * }\n *\n * const graph = new StateGraph(MessagesAnnotation)\n *   .addNode(\"agent\", callModel)\n *   .addNode(\"tools\", toolNodeForGraph)\n *   .addEdge(\"__start__\", \"agent\")\n *   .addConditionalEdges(\"agent\", shouldContinue)\n *   .addEdge(\"tools\", \"agent\")\n *   .compile();\n *\n * const inputs = {\n *   messages: [{ role: \"user\", content: \"what is the weather in SF?\" }],\n * };\n *\n * const stream = await graph.stream(inputs, {\n *   streamMode: \"values\",\n * });\n *\n * for await (const { messages } of stream) {\n *   console.log(messages);\n * }\n * // Returns the messages in the state at each step of execution\n * ```\n */\nexport declare class ToolNode<T = any> extends RunnableCallable<T, T> {\n    tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[];\n    handleToolErrors: boolean;\n    trace: boolean;\n    constructor(tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[], options?: ToolNodeOptions);\n    protected runTool(call: ToolCall, config: RunnableConfig): Promise<ToolMessage | Command>;\n    protected run(input: unknown, config: RunnableConfig): Promise<T>;\n}\n/**\n * A conditional edge function that determines whether to route to a tools node or end the graph.\n *\n * This function is designed to be used as a conditional edge in a LangGraph state graph to implement\n * the common pattern of checking if an AI message contains tool calls that need to be executed.\n *\n * @param state - The current state of the graph, which can be either:\n *   - An array of `BaseMessage` objects, where the last message is checked for tool calls\n *   - A state object conforming to `MessagesAnnotation.State`, which contains a `messages` array\n *\n * @returns A string indicating the next node to route to:\n *   - `\"tools\"` - If the last message contains tool calls that need to be executed\n *   - `END` - If there are no tool calls, indicating the graph should terminate\n *\n * @example\n * ```typescript\n * import { StateGraph, MessagesAnnotation, END, START } from \"@langchain/langgraph\";\n * import { ToolNode, toolsCondition } from \"@langchain/langgraph/prebuilt\";\n *\n * const graph = new StateGraph(MessagesAnnotation)\n *   .addNode(\"agent\", agentNode)\n *   .addNode(\"tools\", new ToolNode([searchTool, calculatorTool]))\n *   .addEdge(START, \"agent\")\n *   .addConditionalEdges(\"agent\", toolsCondition, [\"tools\", END])\n *   .addEdge(\"tools\", \"agent\")\n *   .compile();\n * ```\n *\n * @remarks\n * The function checks the last message in the state for the presence of `tool_calls`.\n * If the message is an `AIMessage` with one or more tool calls, it returns `\"tools\"`,\n * indicating that the graph should route to a tools node (typically a `ToolNode`) to\n * execute those tool calls. Otherwise, it returns `END` to terminate the graph execution.\n *\n * This is a common pattern in agentic workflows where an AI model decides whether to\n * use tools or provide a final response.\n */\nexport declare function toolsCondition(state: BaseMessage[] | typeof MessagesAnnotation.State): \"tools\" | typeof END;\n"],"mappings":";;;;;;;;;KAOYW,eAAAA;;EAAAA,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EA0HSC,gBAAQ,CAAA,EAAA,OAAA;CAAA;;;;;;;;;;;;;;;;;;;;AA6C7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA7CqBA,0BAA0BL,iBAAiBM,GAAGA;UACvDR,0BAA0BD,cAAcD;;;sBAG5BE,0BAA0BD,cAAcD,+BAA+BQ;0BACnEL,kBAAkBJ,iBAAiBY,QAAQb,cAAcS;wCAC3CR,iBAAiBY,QAAQD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuC3CE,cAAAA,QAAsBf,uBAAuBQ,kBAAAA,CAAmBQ,yBAAyBP"}

package/dist/prebuilt/tool_node.d.ts

@@ -0,0 +1,180 @@
+import { RunnableCallable } from "../utils.js";
+import { Command, END } from "../constants.js";
+import { MessagesAnnotation } from "../graph/messages_annotation.js";
+import { RunnableConfig, RunnableToolLike } from "@langchain/core/runnables";
+import { BaseMessage, ToolMessage } from "@langchain/core/messages";
+import { DynamicTool, StructuredToolInterface } from "@langchain/core/tools";
+import { ToolCall } from "@langchain/core/messages/tool";
+
+//#region src/prebuilt/tool_node.d.ts
+type ToolNodeOptions = {
+  name?: string;
+  tags?: string[];
+  handleToolErrors?: boolean;
+};
+/**
+ * A node that runs the tools requested in the last AIMessage. It can be used
+ * either in StateGraph with a "messages" key or in MessageGraph. If multiple
+ * tool calls are requested, they will be run in parallel. The output will be
+ * a list of ToolMessages, one for each tool call.
+ *
+ * @example
+ * ```ts
+ * import { ToolNode } from "@langchain/langgraph/prebuilt";
+ * import { tool } from "@langchain/core/tools";
+ * import { z } from "zod";
+ * import { AIMessage } from "@langchain/core/messages";
+ *
+ * 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[] }
+ * ```
+ *
+ * @example
+ * ```ts
+ * import {
+ *   StateGraph,
+ *   MessagesAnnotation,
+ * } from "@langchain/langgraph";
+ * import { ToolNode } from "@langchain/langgraph/prebuilt";
+ * import { tool } from "@langchain/core/tools";
+ * import { z } from "zod";
+ * import { ChatAnthropic } from "@langchain/anthropic";
+ *
+ * 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 modelWithTools = new ChatAnthropic({
+ *   model: "claude-3-haiku-20240307",
+ *   temperature: 0
+ * }).bindTools(tools);
+ *
+ * const toolNodeForGraph = new ToolNode(tools)
+ *
+ * const shouldContinue = (state: typeof MessagesAnnotation.State) => {
+ *   const { messages } = state;
+ *   const lastMessage = messages[messages.length - 1];
+ *   if ("tool_calls" in lastMessage && Array.isArray(lastMessage.tool_calls) && lastMessage.tool_calls?.length) {
+ *     return "tools";
+ *   }
+ *   return "__end__";
+ * }
+ *
+ * const callModel = async (state: typeof MessagesAnnotation.State) => {
+ *   const { messages } = state;
+ *   const response = await modelWithTools.invoke(messages);
+ *   return { messages: response };
+ * }
+ *
+ * const graph = new StateGraph(MessagesAnnotation)
+ *   .addNode("agent", callModel)
+ *   .addNode("tools", toolNodeForGraph)
+ *   .addEdge("__start__", "agent")
+ *   .addConditionalEdges("agent", shouldContinue)
+ *   .addEdge("tools", "agent")
+ *   .compile();
+ *
+ * const inputs = {
+ *   messages: [{ role: "user", content: "what is the weather in SF?" }],
+ * };
+ *
+ * const stream = await graph.stream(inputs, {
+ *   streamMode: "values",
+ * });
+ *
+ * for await (const { messages } of stream) {
+ *   console.log(messages);
+ * }
+ * // Returns the messages in the state at each step of execution
+ * ```
+ */
+declare class ToolNode<T = any> extends RunnableCallable<T, T> {
+  tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[];
+  handleToolErrors: boolean;
+  trace: boolean;
+  constructor(tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[], options?: ToolNodeOptions);
+  protected runTool(call: ToolCall, config: RunnableConfig): Promise<ToolMessage | Command>;
+  protected run(input: unknown, config: RunnableConfig): Promise<T>;
+}
+/**
+ * A conditional edge function that determines whether to route to a tools node or end the graph.
+ *
+ * This function is designed to be used as a conditional edge in a LangGraph state graph to implement
+ * the common pattern of checking if an AI message contains tool calls that need to be executed.
+ *
+ * @param state - The current state of the graph, which can be either:
+ *   - An array of `BaseMessage` objects, where the last message is checked for tool calls
+ *   - A state object conforming to `MessagesAnnotation.State`, which contains a `messages` array
+ *
+ * @returns A string indicating the next node to route to:
+ *   - `"tools"` - If the last message contains tool calls that need to be executed
+ *   - `END` - If there are no tool calls, indicating the graph should terminate
+ *
+ * @example
+ * ```typescript
+ * import { StateGraph, MessagesAnnotation, END, START } from "@langchain/langgraph";
+ * import { ToolNode, toolsCondition } from "@langchain/langgraph/prebuilt";
+ *
+ * const graph = new StateGraph(MessagesAnnotation)
+ *   .addNode("agent", agentNode)
+ *   .addNode("tools", new ToolNode([searchTool, calculatorTool]))
+ *   .addEdge(START, "agent")
+ *   .addConditionalEdges("agent", toolsCondition, ["tools", END])
+ *   .addEdge("tools", "agent")
+ *   .compile();
+ * ```
+ *
+ * @remarks
+ * The function checks the last message in the state for the presence of `tool_calls`.
+ * If the message is an `AIMessage` with one or more tool calls, it returns `"tools"`,
+ * indicating that the graph should route to a tools node (typically a `ToolNode`) to
+ * execute those tool calls. Otherwise, it returns `END` to terminate the graph execution.
+ *
+ * This is a common pattern in agentic workflows where an AI model decides whether to
+ * use tools or provide a final response.
+ */
+declare function toolsCondition(state: BaseMessage[] | typeof MessagesAnnotation.State): "tools" | typeof END;
+//#endregion
+export { ToolNode, ToolNodeOptions, toolsCondition };
+//# sourceMappingURL=tool_node.d.ts.map

package/dist/prebuilt/tool_node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool_node.d.ts","names":["BaseMessage","ToolMessage","RunnableConfig","RunnableToolLike","DynamicTool","StructuredToolInterface","ToolCall","RunnableCallable","MessagesAnnotation","END","Command","ToolNodeOptions","ToolNode","T","Promise","toolsCondition","State"],"sources":["../../src/prebuilt/tool_node.d.ts"],"sourcesContent":["import { BaseMessage, 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 { RunnableCallable } from \"../utils.js\";\nimport { MessagesAnnotation } from \"../graph/messages_annotation.js\";\nimport { END, Command } from \"../constants.js\";\nexport type ToolNodeOptions = {\n    name?: string;\n    tags?: string[];\n    handleToolErrors?: boolean;\n};\n/**\n * A node that runs the tools requested in the last AIMessage. It can be used\n * either in StateGraph with a \"messages\" key or in MessageGraph. If multiple\n * tool calls are requested, they will be run in parallel. The output will be\n * a list of ToolMessages, one for each tool call.\n *\n * @example\n * ```ts\n * import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n * import { AIMessage } from \"@langchain/core/messages\";\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 * @example\n * ```ts\n * import {\n *   StateGraph,\n *   MessagesAnnotation,\n * } from \"@langchain/langgraph\";\n * import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n * import { ChatAnthropic } from \"@langchain/anthropic\";\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 modelWithTools = new ChatAnthropic({\n *   model: \"claude-3-haiku-20240307\",\n *   temperature: 0\n * }).bindTools(tools);\n *\n * const toolNodeForGraph = new ToolNode(tools)\n *\n * const shouldContinue = (state: typeof MessagesAnnotation.State) => {\n *   const { messages } = state;\n *   const lastMessage = messages[messages.length - 1];\n *   if (\"tool_calls\" in lastMessage && Array.isArray(lastMessage.tool_calls) && lastMessage.tool_calls?.length) {\n *     return \"tools\";\n *   }\n *   return \"__end__\";\n * }\n *\n * const callModel = async (state: typeof MessagesAnnotation.State) => {\n *   const { messages } = state;\n *   const response = await modelWithTools.invoke(messages);\n *   return { messages: response };\n * }\n *\n * const graph = new StateGraph(MessagesAnnotation)\n *   .addNode(\"agent\", callModel)\n *   .addNode(\"tools\", toolNodeForGraph)\n *   .addEdge(\"__start__\", \"agent\")\n *   .addConditionalEdges(\"agent\", shouldContinue)\n *   .addEdge(\"tools\", \"agent\")\n *   .compile();\n *\n * const inputs = {\n *   messages: [{ role: \"user\", content: \"what is the weather in SF?\" }],\n * };\n *\n * const stream = await graph.stream(inputs, {\n *   streamMode: \"values\",\n * });\n *\n * for await (const { messages } of stream) {\n *   console.log(messages);\n * }\n * // Returns the messages in the state at each step of execution\n * ```\n */\nexport declare class ToolNode<T = any> extends RunnableCallable<T, T> {\n    tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[];\n    handleToolErrors: boolean;\n    trace: boolean;\n    constructor(tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[], options?: ToolNodeOptions);\n    protected runTool(call: ToolCall, config: RunnableConfig): Promise<ToolMessage | Command>;\n    protected run(input: unknown, config: RunnableConfig): Promise<T>;\n}\n/**\n * A conditional edge function that determines whether to route to a tools node or end the graph.\n *\n * This function is designed to be used as a conditional edge in a LangGraph state graph to implement\n * the common pattern of checking if an AI message contains tool calls that need to be executed.\n *\n * @param state - The current state of the graph, which can be either:\n *   - An array of `BaseMessage` objects, where the last message is checked for tool calls\n *   - A state object conforming to `MessagesAnnotation.State`, which contains a `messages` array\n *\n * @returns A string indicating the next node to route to:\n *   - `\"tools\"` - If the last message contains tool calls that need to be executed\n *   - `END` - If there are no tool calls, indicating the graph should terminate\n *\n * @example\n * ```typescript\n * import { StateGraph, MessagesAnnotation, END, START } from \"@langchain/langgraph\";\n * import { ToolNode, toolsCondition } from \"@langchain/langgraph/prebuilt\";\n *\n * const graph = new StateGraph(MessagesAnnotation)\n *   .addNode(\"agent\", agentNode)\n *   .addNode(\"tools\", new ToolNode([searchTool, calculatorTool]))\n *   .addEdge(START, \"agent\")\n *   .addConditionalEdges(\"agent\", toolsCondition, [\"tools\", END])\n *   .addEdge(\"tools\", \"agent\")\n *   .compile();\n * ```\n *\n * @remarks\n * The function checks the last message in the state for the presence of `tool_calls`.\n * If the message is an `AIMessage` with one or more tool calls, it returns `\"tools\"`,\n * indicating that the graph should route to a tools node (typically a `ToolNode`) to\n * execute those tool calls. Otherwise, it returns `END` to terminate the graph execution.\n *\n * This is a common pattern in agentic workflows where an AI model decides whether to\n * use tools or provide a final response.\n */\nexport declare function toolsCondition(state: BaseMessage[] | typeof MessagesAnnotation.State): \"tools\" | typeof END;\n"],"mappings":";;;;;;;;;KAOYW,eAAAA;;EAAAA,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EA0HSC,gBAAQ,CAAA,EAAA,OAAA;CAAA;;;;;;;;;;;;;;;;;;;;AA6C7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA7CqBA,0BAA0BL,iBAAiBM,GAAGA;UACvDR,0BAA0BD,cAAcD;;;sBAG5BE,0BAA0BD,cAAcD,+BAA+BQ;0BACnEL,kBAAkBJ,iBAAiBY,QAAQb,cAAcS;wCAC3CR,iBAAiBY,QAAQD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuC3CE,cAAAA,QAAsBf,uBAAuBQ,kBAAAA,CAAmBQ,yBAAyBP"}

package/dist/prebuilt/tool_node.js

@@ -0,0 +1,246 @@
+import { isGraphInterrupt } from "../errors.js";
+import { Command, END, _isSend, isCommand } from "../constants.js";
+import { RunnableCallable } from "../utils.js";
+import { ToolMessage, isAIMessage, isBaseMessage } from "@langchain/core/messages";
+
+//#region src/prebuilt/tool_node.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;
+/**
+* A node that runs the tools requested in the last AIMessage. It can be used
+* either in StateGraph with a "messages" key or in MessageGraph. If multiple
+* tool calls are requested, they will be run in parallel. The output will be
+* a list of ToolMessages, one for each tool call.
+*
+* @example
+* ```ts
+* import { ToolNode } from "@langchain/langgraph/prebuilt";
+* import { tool } from "@langchain/core/tools";
+* import { z } from "zod";
+* import { AIMessage } from "@langchain/core/messages";
+*
+* 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[] }
+* ```
+*
+* @example
+* ```ts
+* import {
+*   StateGraph,
+*   MessagesAnnotation,
+* } from "@langchain/langgraph";
+* import { ToolNode } from "@langchain/langgraph/prebuilt";
+* import { tool } from "@langchain/core/tools";
+* import { z } from "zod";
+* import { ChatAnthropic } from "@langchain/anthropic";
+*
+* 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 modelWithTools = new ChatAnthropic({
+*   model: "claude-3-haiku-20240307",
+*   temperature: 0
+* }).bindTools(tools);
+*
+* const toolNodeForGraph = new ToolNode(tools)
+*
+* const shouldContinue = (state: typeof MessagesAnnotation.State) => {
+*   const { messages } = state;
+*   const lastMessage = messages[messages.length - 1];
+*   if ("tool_calls" in lastMessage && Array.isArray(lastMessage.tool_calls) && lastMessage.tool_calls?.length) {
+*     return "tools";
+*   }
+*   return "__end__";
+* }
+*
+* const callModel = async (state: typeof MessagesAnnotation.State) => {
+*   const { messages } = state;
+*   const response = await modelWithTools.invoke(messages);
+*   return { messages: response };
+* }
+*
+* const graph = new StateGraph(MessagesAnnotation)
+*   .addNode("agent", callModel)
+*   .addNode("tools", toolNodeForGraph)
+*   .addEdge("__start__", "agent")
+*   .addConditionalEdges("agent", shouldContinue)
+*   .addEdge("tools", "agent")
+*   .compile();
+*
+* const inputs = {
+*   messages: [{ role: "user", content: "what is the weather in SF?" }],
+* };
+*
+* const stream = await graph.stream(inputs, {
+*   streamMode: "values",
+* });
+*
+* for await (const { messages } of stream) {
+*   console.log(messages);
+* }
+* // Returns the messages in the state at each step of execution
+* ```
+*/
+var ToolNode = class extends RunnableCallable {
+	tools;
+	handleToolErrors = true;
+	trace = false;
+	constructor(tools, options) {
+		const { name, tags, handleToolErrors } = options ?? {};
+		super({
+			name,
+			tags,
+			func: (input, config) => this.run(input, config)
+		});
+		this.tools = tools;
+		this.handleToolErrors = handleToolErrors ?? this.handleToolErrors;
+	}
+	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);
+			if (isBaseMessage(output) && output.getType() === "tool" || isCommand(output)) return output;
+			return new ToolMessage({
+				status: "success",
+				name: tool.name,
+				content: typeof output === "string" ? output : JSON.stringify(output),
+				tool_call_id: call.id
+			});
+		} catch (e) {
+			if (!this.handleToolErrors) throw e;
+			if (isGraphInterrupt(e)) throw e;
+			return new ToolMessage({
+				status: "error",
+				content: `Error: ${e.message}\n Please fix your mistakes.`,
+				name: call.name,
+				tool_call_id: call.id ?? ""
+			});
+		}
+	}
+	async run(input, config) {
+		let outputs;
+		if (isSendInput(input)) outputs = [await this.runTool(input.lg_tool_call, config)];
+		else {
+			let messages;
+			if (isBaseMessageArray(input)) messages = input;
+			else if (isMessagesState(input)) messages = input.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 (isAIMessage(message)) {
+					aiMessage = message;
+					break;
+				}
+			}
+			if (aiMessage == null || !isAIMessage(aiMessage)) 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(input) ? 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(input) ? [output] : { messages: [output] });
+		if (parentCommand) combinedOutputs.push(parentCommand);
+		return combinedOutputs;
+	}
+};
+/**
+* A conditional edge function that determines whether to route to a tools node or end the graph.
+*
+* This function is designed to be used as a conditional edge in a LangGraph state graph to implement
+* the common pattern of checking if an AI message contains tool calls that need to be executed.
+*
+* @param state - The current state of the graph, which can be either:
+*   - An array of `BaseMessage` objects, where the last message is checked for tool calls
+*   - A state object conforming to `MessagesAnnotation.State`, which contains a `messages` array
+*
+* @returns A string indicating the next node to route to:
+*   - `"tools"` - If the last message contains tool calls that need to be executed
+*   - `END` - If there are no tool calls, indicating the graph should terminate
+*
+* @example
+* ```typescript
+* import { StateGraph, MessagesAnnotation, END, START } from "@langchain/langgraph";
+* import { ToolNode, toolsCondition } from "@langchain/langgraph/prebuilt";
+*
+* const graph = new StateGraph(MessagesAnnotation)
+*   .addNode("agent", agentNode)
+*   .addNode("tools", new ToolNode([searchTool, calculatorTool]))
+*   .addEdge(START, "agent")
+*   .addConditionalEdges("agent", toolsCondition, ["tools", END])
+*   .addEdge("tools", "agent")
+*   .compile();
+* ```
+*
+* @remarks
+* The function checks the last message in the state for the presence of `tool_calls`.
+* If the message is an `AIMessage` with one or more tool calls, it returns `"tools"`,
+* indicating that the graph should route to a tools node (typically a `ToolNode`) to
+* execute those tool calls. Otherwise, it returns `END` to terminate the graph execution.
+*
+* This is a common pattern in agentic workflows where an AI model decides whether to
+* use tools or provide a final response.
+*/
+function toolsCondition(state) {
+	const message = Array.isArray(state) ? state[state.length - 1] : state.messages[state.messages.length - 1];
+	if (message !== void 0 && "tool_calls" in message && (message.tool_calls?.length ?? 0) > 0) return "tools";
+	else return END;
+}
+
+//#endregion
+export { ToolNode, toolsCondition };
+//# sourceMappingURL=tool_node.js.map