@langchain/langgraph 0.2.0 → 0.2.1-rc.1

package/README.md

@@ -31,7 +31,7 @@ npm install @langchain/langgraph @langchain/core
 
 One of the central concepts of LangGraph is state. Each graph execution creates a state that is passed between nodes in the graph as they execute, and each node updates this internal state with its return value after it executes. The way that the graph updates its internal state is defined by either the type of graph chosen or a custom function.
 
-Let's take a look at a simple example of an agent that can use a search tool.
+Let's take a look at an example of an agent that can use a search tool.
 
 First install the required dependencies:
 
@@ -64,7 +64,8 @@ import { MemorySaver, Annotation } from "@langchain/langgraph";
 import { ToolNode } from "@langchain/langgraph/prebuilt";
 
 // Define the graph state
-const GraphState = Annotation.Root({
+// See here for more info: https://langchain-ai.github.io/langgraphjs/how-tos/define-state/
+const StateAnnotation = Annotation.Root({
   messages: Annotation<BaseMessage[]>({
     reducer: (x, y) => x.concat(y),
   })
@@ -87,8 +88,7 @@ const weatherTool = tool(async ({ query }) => {
 });
 
 const tools = [weatherTool];
-// We can extract the state typing via `GraphState.State`
-const toolNode = new ToolNode<typeof GraphState.State>(tools);
+const toolNode = new ToolNode(tools);
 
 const model = new ChatAnthropic({
   model: "claude-3-5-sonnet-20240620",
@@ -96,7 +96,8 @@ const model = new ChatAnthropic({
 }).bindTools(tools);
 
 // Define the function that determines whether to continue or not
-function shouldContinue(state: typeof GraphState.State) {
+// We can extract the state typing via `StateAnnotation.State`
+function shouldContinue(state: typeof StateAnnotation.State) {
   const messages = state.messages;
   const lastMessage = messages[messages.length - 1] as AIMessage;
 
@@ -109,7 +110,7 @@ function shouldContinue(state: typeof GraphState.State) {
 }
 
 // Define the function that calls the model
-async function callModel(state: typeof GraphState.State) {
+async function callModel(state: typeof StateAnnotation.State) {
   const messages = state.messages;
   const response = await model.invoke(messages);
 
@@ -118,7 +119,7 @@ async function callModel(state: typeof GraphState.State) {
 }
 
 // Define a new graph
-const workflow = new StateGraph(GraphState)
+const workflow = new StateGraph(StateAnnotation)
   .addNode("agent", callModel)
   .addNode("tools", toolNode)
   .addEdge("__start__", "agent")
@@ -191,7 +192,7 @@ Is there anything else you'd like to know about the weather in New York or any o
     <summary>Initialize graph with state.</summary>
 
     - We initialize the graph (`StateGraph`) by passing the state interface (`AgentState`).
-    - The `graphState` object defines how updates from each node should be merged into the graph's state.
+    - The `StateAnnotation` object defines how updates from each node should be merged into the graph's state.
    </details>
 
 3. <details>

package/dist/graph/messages_annotation.cjs

@@ -8,6 +8,36 @@ const message_js_1 = require("./message.cjs");
  * Prebuilt state annotation that combines returned messages.
  * Can handle standard messages and special modifiers like {@link RemoveMessage}
  * instances.
+ *
+ * Specifically, importing and using the prebuilt MessagesAnnotation like this:
+ *
+ * @example
+ * ```ts
+ * import { MessagesAnnotation, StateGraph } from "@langchain/langgraph";
+ *
+ * const graph = new StateGraph(MessagesAnnotation)
+ *   .addNode(...)
+ *   ...
+ * ```
+ *
+ * Is equivalent to initializing your state manually like this:
+ *
+ * @example
+ * ```ts
+ * import { BaseMessage } from "@langchain/core/messages";
+ * import { Annotation, StateGraph, messagesStateReducer } from "@langchain/langgraph";
+ *
+ * export const StateAnnotation = Annotation.Root({
+ *   messages: Annotation<BaseMessage[]>({
+ *     reducer: messagesStateReducer,
+ *     default: () => [],
+ *   }),
+ * });
+ *
+ * const graph = new StateGraph(StateAnnotation)
+ *   .addNode(...)
+ *   ...
+ * ```
  */
 exports.MessagesAnnotation = annotation_js_1.Annotation.Root({
     messages: (0, annotation_js_1.Annotation)({

package/dist/graph/messages_annotation.d.ts

@@ -4,6 +4,36 @@ import { Messages } from "./message.js";
  * Prebuilt state annotation that combines returned messages.
  * Can handle standard messages and special modifiers like {@link RemoveMessage}
  * instances.
+ *
+ * Specifically, importing and using the prebuilt MessagesAnnotation like this:
+ *
+ * @example
+ * ```ts
+ * import { MessagesAnnotation, StateGraph } from "@langchain/langgraph";
+ *
+ * const graph = new StateGraph(MessagesAnnotation)
+ *   .addNode(...)
+ *   ...
+ * ```
+ *
+ * Is equivalent to initializing your state manually like this:
+ *
+ * @example
+ * ```ts
+ * import { BaseMessage } from "@langchain/core/messages";
+ * import { Annotation, StateGraph, messagesStateReducer } from "@langchain/langgraph";
+ *
+ * export const StateAnnotation = Annotation.Root({
+ *   messages: Annotation<BaseMessage[]>({
+ *     reducer: messagesStateReducer,
+ *     default: () => [],
+ *   }),
+ * });
+ *
+ * const graph = new StateGraph(StateAnnotation)
+ *   .addNode(...)
+ *   ...
+ * ```
  */
 export declare const MessagesAnnotation: import("./annotation.js").AnnotationRoot<{
     messages: import("../web.js").BinaryOperatorAggregate<BaseMessage[], Messages>;

package/dist/graph/messages_annotation.js

@@ -5,6 +5,36 @@ import { messagesStateReducer } from "./message.js";
  * Prebuilt state annotation that combines returned messages.
  * Can handle standard messages and special modifiers like {@link RemoveMessage}
  * instances.
+ *
+ * Specifically, importing and using the prebuilt MessagesAnnotation like this:
+ *
+ * @example
+ * ```ts
+ * import { MessagesAnnotation, StateGraph } from "@langchain/langgraph";
+ *
+ * const graph = new StateGraph(MessagesAnnotation)
+ *   .addNode(...)
+ *   ...
+ * ```
+ *
+ * Is equivalent to initializing your state manually like this:
+ *
+ * @example
+ * ```ts
+ * import { BaseMessage } from "@langchain/core/messages";
+ * import { Annotation, StateGraph, messagesStateReducer } from "@langchain/langgraph";
+ *
+ * export const StateAnnotation = Annotation.Root({
+ *   messages: Annotation<BaseMessage[]>({
+ *     reducer: messagesStateReducer,
+ *     default: () => [],
+ *   }),
+ * });
+ *
+ * const graph = new StateGraph(StateAnnotation)
+ *   .addNode(...)
+ *   ...
+ * ```
  */
 export const MessagesAnnotation = Annotation.Root({
     messages: Annotation({

package/dist/prebuilt/react_agent_executor.cjs

@@ -7,18 +7,57 @@ const prompts_1 = require("@langchain/core/prompts");
 const index_js_1 = require("../graph/index.cjs");
 const tool_node_js_1 = require("./tool_node.cjs");
 /**
- * Creates a StateGraph agent that relies on a chat llm utilizing tool calling.
- * @param llm The chat llm that can utilize OpenAI-style function calling.
- * @param tools A list of tools or a ToolNode.
- * @param messageModifier An optional message modifier to apply to messages before being passed to the LLM.
+ * Creates a StateGraph agent that relies on a chat model utilizing tool calling.
+ * @param params.llm The chat model that can utilize OpenAI-style tool calling.
+ * @param params.tools A list of tools or a ToolNode.
+ * @param params.messageModifier An optional message modifier to apply to messages before being passed to the LLM.
  * Can be a SystemMessage, string, function that takes and returns a list of messages, or a Runnable.
- * @param checkpointSaver An optional checkpoint saver to persist the agent's state.
- * @param interruptBefore An optional list of node names to interrupt before running.
- * @param interruptAfter An optional list of node names to interrupt after running.
- * @returns A compiled agent as a LangChain Runnable.
+ * @param params.checkpointer An optional checkpoint saver to persist the agent's state.
+ * @param params.interruptBefore An optional list of node names to interrupt before running.
+ * @param params.interruptAfter An optional list of node names to interrupt after running.
+ * @returns A prebuilt compiled graph.
+ *
+ * @example
+ * ```ts
+ * import { ChatOpenAI } from "@langchain/openai";
+ * import { tool } from "@langchain/core/tools";
+ * import { z } from "zod";
+ * import { createReactAgent } from "@langchain/langgraph/prebuilt";
+ *
+ * const model = new ChatOpenAI({
+ *   model: "gpt-4o",
+ * });
+ *
+ * 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 agent = createReactAgent({ llm: model, tools: [getWeather] });
+ *
+ * const inputs = {
+ *   messages: [{ role: "user", content: "what is the weather in SF?" }],
+ * };
+ *
+ * const stream = await agent.stream(inputs, { streamMode: "values" });
+ *
+ * for await (const { messages } of stream) {
+ *   console.log(messages);
+ * }
+ * // Returns the messages in the state at each step of execution
+ * ```
  */
-function createReactAgent(props) {
-    const { llm, tools, messageModifier, checkpointSaver, interruptBefore, interruptAfter, } = props;
+function createReactAgent(params) {
+    const { llm, tools, messageModifier, checkpointSaver, interruptBefore, interruptAfter, } = params;
     const schema = {
         messages: {
             value: index_js_1.messagesStateReducer,

package/dist/prebuilt/react_agent_executor.d.ts

@@ -20,14 +20,53 @@ export type CreateReactAgentParams = {
     interruptAfter?: N[] | All;
 };
 /**
- * Creates a StateGraph agent that relies on a chat llm utilizing tool calling.
- * @param llm The chat llm that can utilize OpenAI-style function calling.
- * @param tools A list of tools or a ToolNode.
- * @param messageModifier An optional message modifier to apply to messages before being passed to the LLM.
+ * Creates a StateGraph agent that relies on a chat model utilizing tool calling.
+ * @param params.llm The chat model that can utilize OpenAI-style tool calling.
+ * @param params.tools A list of tools or a ToolNode.
+ * @param params.messageModifier An optional message modifier to apply to messages before being passed to the LLM.
  * Can be a SystemMessage, string, function that takes and returns a list of messages, or a Runnable.
- * @param checkpointSaver An optional checkpoint saver to persist the agent's state.
- * @param interruptBefore An optional list of node names to interrupt before running.
- * @param interruptAfter An optional list of node names to interrupt after running.
- * @returns A compiled agent as a LangChain Runnable.
+ * @param params.checkpointer An optional checkpoint saver to persist the agent's state.
+ * @param params.interruptBefore An optional list of node names to interrupt before running.
+ * @param params.interruptAfter An optional list of node names to interrupt after running.
+ * @returns A prebuilt compiled graph.
+ *
+ * @example
+ * ```ts
+ * import { ChatOpenAI } from "@langchain/openai";
+ * import { tool } from "@langchain/core/tools";
+ * import { z } from "zod";
+ * import { createReactAgent } from "@langchain/langgraph/prebuilt";
+ *
+ * const model = new ChatOpenAI({
+ *   model: "gpt-4o",
+ * });
+ *
+ * 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 agent = createReactAgent({ llm: model, tools: [getWeather] });
+ *
+ * const inputs = {
+ *   messages: [{ role: "user", content: "what is the weather in SF?" }],
+ * };
+ *
+ * const stream = await agent.stream(inputs, { streamMode: "values" });
+ *
+ * for await (const { messages } of stream) {
+ *   console.log(messages);
+ * }
+ * // Returns the messages in the state at each step of execution
+ * ```
  */
-export declare function createReactAgent(props: CreateReactAgentParams): CompiledStateGraph<AgentState, Partial<AgentState>, typeof START | "agent" | "tools">;
+export declare function createReactAgent(params: CreateReactAgentParams): CompiledStateGraph<AgentState, Partial<AgentState>, typeof START | "agent" | "tools">;

package/dist/prebuilt/react_agent_executor.js

@@ -4,18 +4,57 @@ import { ChatPromptTemplate } from "@langchain/core/prompts";
 import { END, messagesStateReducer, START, StateGraph, } from "../graph/index.js";
 import { ToolNode } from "./tool_node.js";
 /**
- * Creates a StateGraph agent that relies on a chat llm utilizing tool calling.
- * @param llm The chat llm that can utilize OpenAI-style function calling.
- * @param tools A list of tools or a ToolNode.
- * @param messageModifier An optional message modifier to apply to messages before being passed to the LLM.
+ * Creates a StateGraph agent that relies on a chat model utilizing tool calling.
+ * @param params.llm The chat model that can utilize OpenAI-style tool calling.
+ * @param params.tools A list of tools or a ToolNode.
+ * @param params.messageModifier An optional message modifier to apply to messages before being passed to the LLM.
  * Can be a SystemMessage, string, function that takes and returns a list of messages, or a Runnable.
- * @param checkpointSaver An optional checkpoint saver to persist the agent's state.
- * @param interruptBefore An optional list of node names to interrupt before running.
- * @param interruptAfter An optional list of node names to interrupt after running.
- * @returns A compiled agent as a LangChain Runnable.
+ * @param params.checkpointer An optional checkpoint saver to persist the agent's state.
+ * @param params.interruptBefore An optional list of node names to interrupt before running.
+ * @param params.interruptAfter An optional list of node names to interrupt after running.
+ * @returns A prebuilt compiled graph.
+ *
+ * @example
+ * ```ts
+ * import { ChatOpenAI } from "@langchain/openai";
+ * import { tool } from "@langchain/core/tools";
+ * import { z } from "zod";
+ * import { createReactAgent } from "@langchain/langgraph/prebuilt";
+ *
+ * const model = new ChatOpenAI({
+ *   model: "gpt-4o",
+ * });
+ *
+ * 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 agent = createReactAgent({ llm: model, tools: [getWeather] });
+ *
+ * const inputs = {
+ *   messages: [{ role: "user", content: "what is the weather in SF?" }],
+ * };
+ *
+ * const stream = await agent.stream(inputs, { streamMode: "values" });
+ *
+ * for await (const { messages } of stream) {
+ *   console.log(messages);
+ * }
+ * // Returns the messages in the state at each step of execution
+ * ```
  */
-export function createReactAgent(props) {
-    const { llm, tools, messageModifier, checkpointSaver, interruptBefore, interruptAfter, } = props;
+export function createReactAgent(params) {
+    const { llm, tools, messageModifier, checkpointSaver, interruptBefore, interruptAfter, } = params;
     const schema = {
         messages: {
             value: messagesStateReducer,

package/dist/prebuilt/tool_executor.cjs

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ToolExecutor = void 0;
 const runnables_1 = require("@langchain/core/runnables");
 const INVALID_TOOL_MSG_TEMPLATE = `{requestedToolName} is not a valid tool, try one of {availableToolNamesString}.`;
+/** @deprecated Use {@link ToolNode} instead. */
 class ToolExecutor extends runnables_1.RunnableBinding {
     constructor(fields) {
         const fieldsWithDefaults = {

package/dist/prebuilt/tool_executor.d.ts

@@ -1,5 +1,6 @@
 import { RunnableBinding, RunnableConfig, RunnableToolLike } from "@langchain/core/runnables";
 import { StructuredToolInterface } from "@langchain/core/tools";
+/** @deprecated Use {@link ToolNode} instead. */
 export interface ToolExecutorArgs {
     tools: Array<StructuredToolInterface | RunnableToolLike>;
     /**
@@ -16,6 +17,7 @@ export interface ToolInvocationInterface {
 }
 type ToolExecutorInputType = any;
 type ToolExecutorOutputType = any;
+/** @deprecated Use {@link ToolNode} instead. */
 export declare class ToolExecutor extends RunnableBinding<ToolExecutorInputType, ToolExecutorOutputType> {
     lc_graph_name: string;
     tools: Array<StructuredToolInterface | RunnableToolLike>;

package/dist/prebuilt/tool_executor.js

@@ -1,5 +1,6 @@
 import { RunnableBinding, RunnableLambda, } from "@langchain/core/runnables";
 const INVALID_TOOL_MSG_TEMPLATE = `{requestedToolName} is not a valid tool, try one of {availableToolNamesString}.`;
+/** @deprecated Use {@link ToolNode} instead. */
 export class ToolExecutor extends RunnableBinding {
     constructor(fields) {
         const fieldsWithDefaults = {

package/dist/prebuilt/tool_node.cjs

@@ -9,6 +9,117 @@ const graph_js_1 = require("../graph/graph.cjs");
  * 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
 class ToolNode extends utils_js_1.RunnableCallable {

package/dist/prebuilt/tool_node.d.ts

@@ -14,6 +14,117 @@ export type ToolNodeOptions = {
  * 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
+ * ```
  */
 export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
     tools: (StructuredToolInterface | RunnableToolLike)[];

package/dist/prebuilt/tool_node.js

@@ -6,6 +6,117 @@ import { END } from "../graph/graph.js";
  * 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
 export class ToolNode extends RunnableCallable {

package/dist/web.d.ts

@@ -1,6 +1,7 @@
 export { END, Graph, type StateGraphArgs, START, StateGraph, type CompiledStateGraph, MessageGraph, messagesStateReducer, type Messages, Annotation, type StateType, type UpdateType, type NodeType, type StateDefinition, type SingleReducer, type CompiledGraph, } from "./graph/index.js";
 export * from "./errors.js";
-export { BaseChannel, type BinaryOperator, BinaryOperatorAggregate, } from "./channels/index.js";
+export { BaseChannel, type BinaryOperator, BinaryOperatorAggregate, type AnyValue, type WaitForNames, type DynamicBarrierValue, type LastValue, type NamedBarrierValue, type Topic, } from "./channels/index.js";
+export { type AnnotationRoot as _INTERNAL_ANNOTATION_ROOT } from "./graph/index.js";
 export { type RetryPolicy } from "./pregel/utils.js";
 export { Send } from "./constants.js";
 export { MemorySaver, type Checkpoint, type CheckpointMetadata, type CheckpointTuple, copyCheckpoint, emptyCheckpoint, BaseCheckpointSaver, } from "@langchain/langgraph-checkpoint";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph",
-  "version": "0.2.0",
+  "version": "0.2.1-rc.1",
   "description": "LangGraph",
   "type": "module",
   "engines": {