@langchain/langgraph 0.4.7 → 1.0.0-alpha.0

package/dist/prebuilt/tool_node.d.cts

@@ -0,0 +1,151 @@
+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;
+};
+/**
+ * @deprecated `ToolNode` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.
+ * Update your import to `import { ToolNode } from "langchain";`
+ *
+ * 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
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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>;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  protected run(input: unknown, config: RunnableConfig): Promise<T>;
+}
+/**
+ * @deprecated Use new `ToolNode` from {@link https://www.npmjs.com/package/langchain langchain} package instead.
+ */
+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 * @deprecated `ToolNode` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.\n * Update your import to `import { ToolNode } from \"langchain\";`\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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\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    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    protected run(input: unknown, config: RunnableConfig): Promise<T>;\n}\n/**\n * @deprecated Use new `ToolNode` from {@link https://www.npmjs.com/package/langchain langchain} package instead.\n */\nexport declare function toolsCondition(state: BaseMessage[] | typeof MessagesAnnotation.State): \"tools\" | typeof END;\n"],"mappings":";;;;;;;;;KAOYW,eAAAA;;EAAAA,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EA8HSC,gBAAQ,CAAA,EAAA,OAAA;CAAA;;;;;;;;;;;;;;;;;;;;AAY7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAZqBA,0BAA0BL,iBAAiBM,GAAGA;UACvDR,0BAA0BD,cAAcD;;;sBAG5BE,0BAA0BD,cAAcD,+BAA+BQ;0BACnEL,kBAAkBJ,iBAAiBY,QAAQb,cAAcS;;wCAE3CR,iBAAiBY,QAAQD;;;;;iBAK3CE,cAAAA,QAAsBf,uBAAuBQ,kBAAAA,CAAmBQ,yBAAyBP"}

package/dist/prebuilt/tool_node.d.ts

@@ -1,16 +1,21 @@
-import { BaseMessage, ToolMessage } from "@langchain/core/messages";
-import { RunnableConfig, RunnableToolLike } from "@langchain/core/runnables";
-import { DynamicTool, StructuredToolInterface } from "@langchain/core/tools";
-import type { ToolCall } from "@langchain/core/messages/tool";
 import { RunnableCallable } from "../utils.js";
+import { Command, END } from "../constants.js";
 import { MessagesAnnotation } from "../graph/messages_annotation.js";
-import { END, Command } from "../constants.js";
-export type ToolNodeOptions = {
-    name?: string;
-    tags?: string[];
-    handleToolErrors?: boolean;
+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;
 };
 /**
+ * @deprecated `ToolNode` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.
+ * Update your import to `import { ToolNode } from "langchain";`
+ *
  * 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
@@ -127,12 +132,20 @@ export type ToolNodeOptions = {
  * // Returns the messages in the state at each step of execution
  * ```
  */
-export 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>;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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>;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  protected run(input: unknown, config: RunnableConfig): Promise<T>;
 }
-export declare function toolsCondition(state: BaseMessage[] | typeof MessagesAnnotation.State): "tools" | typeof END;
+/**
+ * @deprecated Use new `ToolNode` from {@link https://www.npmjs.com/package/langchain langchain} package instead.
+ */
+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 * @deprecated `ToolNode` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.\n * Update your import to `import { ToolNode } from \"langchain\";`\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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\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    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    protected run(input: unknown, config: RunnableConfig): Promise<T>;\n}\n/**\n * @deprecated Use new `ToolNode` from {@link https://www.npmjs.com/package/langchain langchain} package instead.\n */\nexport declare function toolsCondition(state: BaseMessage[] | typeof MessagesAnnotation.State): \"tools\" | typeof END;\n"],"mappings":";;;;;;;;;KAOYW,eAAAA;;EAAAA,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EA8HSC,gBAAQ,CAAA,EAAA,OAAA;CAAA;;;;;;;;;;;;;;;;;;;;AAY7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAZqBA,0BAA0BL,iBAAiBM,GAAGA;UACvDR,0BAA0BD,cAAcD;;;sBAG5BE,0BAA0BD,cAAcD,+BAA+BQ;0BACnEL,kBAAkBJ,iBAAiBY,QAAQb,cAAcS;;wCAE3CR,iBAAiBY,QAAQD;;;;;iBAK3CE,cAAAA,QAAsBf,uBAAuBQ,kBAAAA,CAAmBQ,yBAAyBP"}