@langchain/langgraph 0.0.17 → 0.0.19

package/dist/checkpoint/base.d.ts

@@ -13,7 +13,7 @@ export interface CheckpointMetadata {
      * -1 for the first "input" checkpoint.
      * 0 for the first "loop" checkpoint.
      * ... for the nth checkpoint afterwards. */
-    writes?: Record<string, unknown>;
+    writes: Record<string, unknown> | null;
 }
 export interface Checkpoint<N extends string = string, C extends string = string> {
     /**

package/dist/graph/graph.cjs

@@ -25,12 +25,6 @@ class Branch {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "then", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         this.condition = options.path;
         this.ends = Array.isArray(options.pathMap)
             ? options.pathMap.reduce((acc, n) => {
@@ -38,7 +32,6 @@ class Branch {
                 return acc;
             }, {})
             : options.pathMap;
-        this.then = options.then;
     }
     compile(writer, reader) {
         return write_js_1.ChannelWrite.registerWriter(new utils_js_1.RunnableCallable({
@@ -57,6 +50,9 @@ class Branch {
         else {
             destinations = result;
         }
+        if (destinations.some((dest) => !dest)) {
+            throw new Error("Branch condition returned unknown or null destination");
+        }
         return writer(destinations);
     }
 }
@@ -207,26 +203,8 @@ class Graph {
     validate(interrupt) {
         // assemble sources
         const allSources = new Set([...this.allEdges].map(([src, _]) => src));
-        for (const [start, branches] of Object.entries(this.branches)) {
+        for (const [start] of Object.entries(this.branches)) {
             allSources.add(start);
-            for (const branch of Object.values(branches)) {
-                if (branch.then) {
-                    if (branch.ends) {
-                        for (const end of Object.values(branch.ends)) {
-                            if (end !== exports.END) {
-                                allSources.add(end);
-                            }
-                        }
-                    }
-                    else {
-                        for (const node of Object.keys(this.nodes)) {
-                            if (node !== start) {
-                                allSources.add(node);
-                            }
-                        }
-                    }
-                }
-            }
         }
         // validate sources
         for (const node of Object.keys(this.nodes)) {
@@ -243,9 +221,6 @@ class Graph {
         const allTargets = new Set([...this.allEdges].map(([_, target]) => target));
         for (const [start, branches] of Object.entries(this.branches)) {
             for (const branch of Object.values(branches)) {
-                if (branch.then) {
-                    allTargets.add(branch.then);
-                }
                 if (branch.ends) {
                     for (const end of Object.values(branch.ends)) {
                         allTargets.add(end);
@@ -254,7 +229,7 @@ class Graph {
                 else {
                     allTargets.add(exports.END);
                     for (const node of Object.keys(this.nodes)) {
-                        if (node !== start && node !== branch.then) {
+                        if (node !== start) {
                             allTargets.add(node);
                         }
                     }

package/dist/graph/graph.d.ts

@@ -11,12 +11,10 @@ export interface BranchOptions<IO, N extends string> {
     source: N;
     path: Branch<IO, N>["condition"];
     pathMap?: Record<string, N | typeof END> | N[];
-    then?: N | typeof END;
 }
 export declare class Branch<IO, N extends string> {
     condition: (input: IO, config?: RunnableConfig) => string | string[] | Promise<string> | Promise<string[]>;
     ends?: Record<string, N | typeof END>;
-    then?: BranchOptions<IO, N>["then"];
     constructor(options: Omit<BranchOptions<IO, N>, "source">);
     compile(writer: (dests: string[]) => Runnable | undefined, reader?: (config: RunnableConfig) => IO): RunnableCallable<unknown, unknown>;
     _route(input: IO, config: RunnableConfig, writer: (dests: string[]) => Runnable | undefined, reader?: (config: RunnableConfig) => IO): Promise<Runnable | undefined>;

package/dist/graph/graph.js

@@ -22,12 +22,6 @@ export class Branch {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "then", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         this.condition = options.path;
         this.ends = Array.isArray(options.pathMap)
             ? options.pathMap.reduce((acc, n) => {
@@ -35,7 +29,6 @@ export class Branch {
                 return acc;
             }, {})
             : options.pathMap;
-        this.then = options.then;
     }
     compile(writer, reader) {
         return ChannelWrite.registerWriter(new RunnableCallable({
@@ -54,6 +47,9 @@ export class Branch {
         else {
             destinations = result;
         }
+        if (destinations.some((dest) => !dest)) {
+            throw new Error("Branch condition returned unknown or null destination");
+        }
         return writer(destinations);
     }
 }
@@ -203,26 +199,8 @@ export class Graph {
     validate(interrupt) {
         // assemble sources
         const allSources = new Set([...this.allEdges].map(([src, _]) => src));
-        for (const [start, branches] of Object.entries(this.branches)) {
+        for (const [start] of Object.entries(this.branches)) {
             allSources.add(start);
-            for (const branch of Object.values(branches)) {
-                if (branch.then) {
-                    if (branch.ends) {
-                        for (const end of Object.values(branch.ends)) {
-                            if (end !== END) {
-                                allSources.add(end);
-                            }
-                        }
-                    }
-                    else {
-                        for (const node of Object.keys(this.nodes)) {
-                            if (node !== start) {
-                                allSources.add(node);
-                            }
-                        }
-                    }
-                }
-            }
         }
         // validate sources
         for (const node of Object.keys(this.nodes)) {
@@ -239,9 +217,6 @@ export class Graph {
         const allTargets = new Set([...this.allEdges].map(([_, target]) => target));
         for (const [start, branches] of Object.entries(this.branches)) {
             for (const branch of Object.values(branches)) {
-                if (branch.then) {
-                    allTargets.add(branch.then);
-                }
                 if (branch.ends) {
                     for (const end of Object.values(branch.ends)) {
                         allTargets.add(end);
@@ -250,7 +225,7 @@ export class Graph {
                 else {
                     allTargets.add(END);
                     for (const node of Object.keys(this.nodes)) {
-                        if (node !== start && node !== branch.then) {
+                        if (node !== start) {
                             allTargets.add(node);
                         }
                     }

package/dist/graph/state.cjs

@@ -11,7 +11,6 @@ const ephemeral_value_js_1 = require("../channels/ephemeral_value.cjs");
 const utils_js_1 = require("../utils.cjs");
 const constants_js_1 = require("../constants.cjs");
 const errors_js_1 = require("../errors.cjs");
-const dynamic_barrier_value_js_1 = require("../channels/dynamic_barrier_value.cjs");
 const ROOT = "__root__";
 class StateGraph extends graph_js_1.Graph {
     constructor(fields) {
@@ -241,12 +240,6 @@ class CompiledStateGraph extends graph_js_1.CompiledGraph {
                 channel: `branch:${start}:${name}:${dest}`,
                 value: start,
             }));
-            if (branch.then && branch.then !== graph_js_1.END) {
-                writes.push({
-                    channel: `branch:${start}:${name}:then`,
-                    value: { __names: filteredDests },
-                });
-            }
             return new write_js_1.ChannelWrite(writes, [constants_js_1.TAG_HIDDEN]);
         }, 
         // reader
@@ -254,7 +247,7 @@ class CompiledStateGraph extends graph_js_1.CompiledGraph {
         // attach branch subscribers
         const ends = branch.ends
             ? Object.values(branch.ends)
-            : Object.keys(this.builder.nodes).filter((n) => n !== branch.then);
+            : Object.keys(this.builder.nodes);
         for (const end of ends) {
             if (end === graph_js_1.END) {
                 continue;
@@ -264,18 +257,6 @@ class CompiledStateGraph extends graph_js_1.CompiledGraph {
                 new ephemeral_value_js_1.EphemeralValue();
             this.nodes[end].triggers.push(channelName);
         }
-        if (branch.then && branch.then !== graph_js_1.END) {
-            const channelName = `branch:${start}:${name}:then`;
-            this.channels[channelName] =
-                new dynamic_barrier_value_js_1.DynamicBarrierValue();
-            this.nodes[branch.then].triggers.push(channelName);
-            for (const end of ends) {
-                if (end === graph_js_1.END) {
-                    continue;
-                }
-                this.nodes[end].writers.push(new write_js_1.ChannelWrite([{ channel: channelName, value: end }], [constants_js_1.TAG_HIDDEN]));
-            }
-        }
     }
 }
 exports.CompiledStateGraph = CompiledStateGraph;

package/dist/graph/state.js

@@ -8,7 +8,6 @@ import { EphemeralValue } from "../channels/ephemeral_value.js";
 import { RunnableCallable } from "../utils.js";
 import { TAG_HIDDEN } from "../constants.js";
 import { InvalidUpdateError } from "../errors.js";
-import { DynamicBarrierValue } from "../channels/dynamic_barrier_value.js";
 const ROOT = "__root__";
 export class StateGraph extends Graph {
     constructor(fields) {
@@ -237,12 +236,6 @@ export class CompiledStateGraph extends CompiledGraph {
                 channel: `branch:${start}:${name}:${dest}`,
                 value: start,
             }));
-            if (branch.then && branch.then !== END) {
-                writes.push({
-                    channel: `branch:${start}:${name}:then`,
-                    value: { __names: filteredDests },
-                });
-            }
             return new ChannelWrite(writes, [TAG_HIDDEN]);
         }, 
         // reader
@@ -250,7 +243,7 @@ export class CompiledStateGraph extends CompiledGraph {
         // attach branch subscribers
         const ends = branch.ends
             ? Object.values(branch.ends)
-            : Object.keys(this.builder.nodes).filter((n) => n !== branch.then);
+            : Object.keys(this.builder.nodes);
         for (const end of ends) {
             if (end === END) {
                 continue;
@@ -260,17 +253,5 @@ export class CompiledStateGraph extends CompiledGraph {
                 new EphemeralValue();
             this.nodes[end].triggers.push(channelName);
         }
-        if (branch.then && branch.then !== END) {
-            const channelName = `branch:${start}:${name}:then`;
-            this.channels[channelName] =
-                new DynamicBarrierValue();
-            this.nodes[branch.then].triggers.push(channelName);
-            for (const end of ends) {
-                if (end === END) {
-                    continue;
-                }
-                this.nodes[end].writers.push(new ChannelWrite([{ channel: channelName, value: end }], [TAG_HIDDEN]));
-            }
-        }
     }
 }

package/dist/prebuilt/index.cjs

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toolsCondition = exports.ToolNode = exports.ToolExecutor = exports.createFunctionCallingExecutor = exports.createAgentExecutor = void 0;
+exports.toolsCondition = exports.ToolNode = exports.ToolExecutor = exports.createReactAgent = exports.createFunctionCallingExecutor = exports.createAgentExecutor = void 0;
 var agent_executor_js_1 = require("./agent_executor.cjs");
 Object.defineProperty(exports, "createAgentExecutor", { enumerable: true, get: function () { return agent_executor_js_1.createAgentExecutor; } });
 var chat_agent_executor_js_1 = require("./chat_agent_executor.cjs");
 Object.defineProperty(exports, "createFunctionCallingExecutor", { enumerable: true, get: function () { return chat_agent_executor_js_1.createFunctionCallingExecutor; } });
+var react_agent_executor_js_1 = require("./react_agent_executor.cjs");
+Object.defineProperty(exports, "createReactAgent", { enumerable: true, get: function () { return react_agent_executor_js_1.createReactAgent; } });
 var tool_executor_js_1 = require("./tool_executor.cjs");
 Object.defineProperty(exports, "ToolExecutor", { enumerable: true, get: function () { return tool_executor_js_1.ToolExecutor; } });
 var tool_node_js_1 = require("./tool_node.cjs");

package/dist/prebuilt/index.d.ts

@@ -1,4 +1,5 @@
 export { type AgentExecutorState, createAgentExecutor, } from "./agent_executor.js";
 export { type FunctionCallingExecutorState, createFunctionCallingExecutor, } from "./chat_agent_executor.js";
+export { type AgentState, createReactAgent } from "./react_agent_executor.js";
 export { type ToolExecutorArgs, type ToolInvocationInterface, ToolExecutor, } from "./tool_executor.js";
 export { ToolNode, toolsCondition } from "./tool_node.js";

package/dist/prebuilt/index.js

@@ -1,4 +1,5 @@
 export { createAgentExecutor, } from "./agent_executor.js";
 export { createFunctionCallingExecutor, } from "./chat_agent_executor.js";
+export { createReactAgent } from "./react_agent_executor.js";
 export { ToolExecutor, } from "./tool_executor.js";
 export { ToolNode, toolsCondition } from "./tool_node.js";

package/dist/prebuilt/react_agent_executor.cjs

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReactAgent = void 0;
+const messages_1 = require("@langchain/core/messages");
+const runnables_1 = require("@langchain/core/runnables");
+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.
+ * 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.
+ */
+function createReactAgent(props) {
+    const { llm, tools, messageModifier, checkpointSaver, interruptBefore, interruptAfter, } = props;
+    const schema = {
+        messages: {
+            value: (left, right) => left.concat(right),
+            default: () => [],
+        },
+    };
+    let toolClasses;
+    if (!Array.isArray(tools)) {
+        toolClasses = tools.tools;
+    }
+    else {
+        toolClasses = tools;
+    }
+    if (!("bindTools" in llm) || typeof llm.bindTools !== "function") {
+        throw new Error(`llm ${llm} must define bindTools method.`);
+    }
+    const modelWithTools = llm.bindTools(toolClasses);
+    const modelRunnable = _createModelWrapper(modelWithTools, messageModifier);
+    const shouldContinue = (state) => {
+        const { messages } = state;
+        const lastMessage = messages[messages.length - 1];
+        if ((0, messages_1.isAIMessage)(lastMessage) &&
+            (!lastMessage.tool_calls || lastMessage.tool_calls.length === 0)) {
+            return index_js_1.END;
+        }
+        else {
+            return "continue";
+        }
+    };
+    const callModel = async (state) => {
+        const { messages } = state;
+        // TODO: Auto-promote streaming.
+        return { messages: [await modelRunnable.invoke(messages)] };
+    };
+    const workflow = new index_js_1.StateGraph({
+        channels: schema,
+    })
+        .addNode("agent", new runnables_1.RunnableLambda({ func: callModel }).withConfig({ runName: "agent" }))
+        .addNode("tools", new tool_node_js_1.ToolNode(toolClasses))
+        .addEdge(index_js_1.START, "agent")
+        .addConditionalEdges("agent", shouldContinue, {
+        continue: "tools",
+        [index_js_1.END]: index_js_1.END,
+    })
+        .addEdge("tools", "agent");
+    return workflow.compile({
+        checkpointer: checkpointSaver,
+        interruptBefore,
+        interruptAfter,
+    });
+}
+exports.createReactAgent = createReactAgent;
+function _createModelWrapper(modelWithTools, messageModifier) {
+    if (!messageModifier) {
+        return modelWithTools;
+    }
+    const endict = new runnables_1.RunnableLambda({
+        func: (messages) => ({ messages }),
+    });
+    if (typeof messageModifier === "string") {
+        const systemMessage = new messages_1.SystemMessage(messageModifier);
+        const prompt = prompts_1.ChatPromptTemplate.fromMessages([
+            systemMessage,
+            ["placeholder", "{messages}"],
+        ]);
+        return endict.pipe(prompt).pipe(modelWithTools);
+    }
+    if (typeof messageModifier === "function") {
+        const lambda = new runnables_1.RunnableLambda({ func: messageModifier }).withConfig({
+            runName: "message_modifier",
+        });
+        return lambda.pipe(modelWithTools);
+    }
+    if (runnables_1.Runnable.isRunnable(messageModifier)) {
+        return messageModifier.pipe(modelWithTools);
+    }
+    if (messageModifier._getType() === "system") {
+        const prompt = prompts_1.ChatPromptTemplate.fromMessages([
+            messageModifier,
+            ["placeholder", "{messages}"],
+        ]);
+        return endict.pipe(prompt).pipe(modelWithTools);
+    }
+    throw new Error(`Unsupported message modifier type: ${typeof messageModifier}`);
+}

package/dist/prebuilt/react_agent_executor.d.ts

@@ -0,0 +1,34 @@
+import { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import { BaseMessage, SystemMessage } from "@langchain/core/messages";
+import { Runnable } from "@langchain/core/runnables";
+import { StructuredTool } from "@langchain/core/tools";
+import { BaseCheckpointSaver } from "../checkpoint/base.js";
+import { START } from "../graph/index.js";
+import { MessagesState } from "../graph/message.js";
+import { CompiledStateGraph } from "../graph/state.js";
+import { All } from "../pregel/types.js";
+import { ToolNode } from "./tool_node.js";
+export interface AgentState {
+    messages: BaseMessage[];
+}
+export type N = typeof START | "agent" | "tools";
+export type CreateReactAgentParams = {
+    llm: BaseChatModel;
+    tools: ToolNode<MessagesState> | StructuredTool[];
+    messageModifier?: SystemMessage | string | ((messages: BaseMessage[]) => BaseMessage[]) | ((messages: BaseMessage[]) => Promise<BaseMessage[]>) | Runnable;
+    checkpointSaver?: BaseCheckpointSaver;
+    interruptBefore?: N[] | All;
+    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.
+ * 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.
+ */
+export declare function createReactAgent(props: CreateReactAgentParams): CompiledStateGraph<AgentState, Partial<AgentState>, typeof START | "agent" | "tools">;

package/dist/prebuilt/react_agent_executor.js

@@ -0,0 +1,102 @@
+import { isAIMessage, SystemMessage, } from "@langchain/core/messages";
+import { Runnable, RunnableLambda, } from "@langchain/core/runnables";
+import { ChatPromptTemplate } from "@langchain/core/prompts";
+import { END, 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.
+ * 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.
+ */
+export function createReactAgent(props) {
+    const { llm, tools, messageModifier, checkpointSaver, interruptBefore, interruptAfter, } = props;
+    const schema = {
+        messages: {
+            value: (left, right) => left.concat(right),
+            default: () => [],
+        },
+    };
+    let toolClasses;
+    if (!Array.isArray(tools)) {
+        toolClasses = tools.tools;
+    }
+    else {
+        toolClasses = tools;
+    }
+    if (!("bindTools" in llm) || typeof llm.bindTools !== "function") {
+        throw new Error(`llm ${llm} must define bindTools method.`);
+    }
+    const modelWithTools = llm.bindTools(toolClasses);
+    const modelRunnable = _createModelWrapper(modelWithTools, messageModifier);
+    const shouldContinue = (state) => {
+        const { messages } = state;
+        const lastMessage = messages[messages.length - 1];
+        if (isAIMessage(lastMessage) &&
+            (!lastMessage.tool_calls || lastMessage.tool_calls.length === 0)) {
+            return END;
+        }
+        else {
+            return "continue";
+        }
+    };
+    const callModel = async (state) => {
+        const { messages } = state;
+        // TODO: Auto-promote streaming.
+        return { messages: [await modelRunnable.invoke(messages)] };
+    };
+    const workflow = new StateGraph({
+        channels: schema,
+    })
+        .addNode("agent", new RunnableLambda({ func: callModel }).withConfig({ runName: "agent" }))
+        .addNode("tools", new ToolNode(toolClasses))
+        .addEdge(START, "agent")
+        .addConditionalEdges("agent", shouldContinue, {
+        continue: "tools",
+        [END]: END,
+    })
+        .addEdge("tools", "agent");
+    return workflow.compile({
+        checkpointer: checkpointSaver,
+        interruptBefore,
+        interruptAfter,
+    });
+}
+function _createModelWrapper(modelWithTools, messageModifier) {
+    if (!messageModifier) {
+        return modelWithTools;
+    }
+    const endict = new RunnableLambda({
+        func: (messages) => ({ messages }),
+    });
+    if (typeof messageModifier === "string") {
+        const systemMessage = new SystemMessage(messageModifier);
+        const prompt = ChatPromptTemplate.fromMessages([
+            systemMessage,
+            ["placeholder", "{messages}"],
+        ]);
+        return endict.pipe(prompt).pipe(modelWithTools);
+    }
+    if (typeof messageModifier === "function") {
+        const lambda = new RunnableLambda({ func: messageModifier }).withConfig({
+            runName: "message_modifier",
+        });
+        return lambda.pipe(modelWithTools);
+    }
+    if (Runnable.isRunnable(messageModifier)) {
+        return messageModifier.pipe(modelWithTools);
+    }
+    if (messageModifier._getType() === "system") {
+        const prompt = ChatPromptTemplate.fromMessages([
+            messageModifier,
+            ["placeholder", "{messages}"],
+        ]);
+        return endict.pipe(prompt).pipe(modelWithTools);
+    }
+    throw new Error(`Unsupported message modifier type: ${typeof messageModifier}`);
+}

package/dist/prebuilt/tool_node.d.ts

@@ -1,17 +1,17 @@
 import { BaseMessage } from "@langchain/core/messages";
-import { Tool } from "@langchain/core/tools";
+import { StructuredTool } from "@langchain/core/tools";
 import { RunnableCallable } from "../utils.js";
 import { END } from "../graph/graph.js";
 import { MessagesState } from "../graph/message.js";
-export declare class ToolNode extends RunnableCallable<BaseMessage[] | MessagesState, BaseMessage[] | MessagesState> {
+export declare class ToolNode<T extends BaseMessage[] | MessagesState> extends RunnableCallable<T, T> {
     /**
     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.
     */
-    tools: Tool[];
-    constructor(tools: Tool[], name?: string, tags?: string[]);
+    tools: StructuredTool[];
+    constructor(tools: StructuredTool[], name?: string, tags?: string[]);
     private run;
 }
 export declare function toolsCondition(state: BaseMessage[] | MessagesState): "tools" | typeof END;

package/dist/pregel/index.cjs

@@ -480,7 +480,7 @@ class Pregel extends runnables_1.Runnable {
                     bg.push(this.checkpointer.put(checkpointConfig, checkpoint, {
                         source: "loop",
                         step,
-                        writes: (0, io_js_1.single)(streamMode === "values"
+                        writes: (0, io_js_1.single)(this.streamMode === "values"
                             ? (0, io_js_1.mapOutputValues)(outputKeys, pendingWrites, channels)
                             : (0, io_js_1.mapOutputUpdates)(outputKeys, nextTasks)),
                     }));

package/dist/pregel/index.js

@@ -476,7 +476,7 @@ export class Pregel extends Runnable {
                     bg.push(this.checkpointer.put(checkpointConfig, checkpoint, {
                         source: "loop",
                         step,
-                        writes: single(streamMode === "values"
+                        writes: single(this.streamMode === "values"
                             ? mapOutputValues(outputKeys, pendingWrites, channels)
                             : mapOutputUpdates(outputKeys, nextTasks)),
                     }));

package/dist/pregel/io.cjs

@@ -138,6 +138,6 @@ function single(iter) {
     for (const value of iter) {
         return value;
     }
-    return undefined;
+    return null;
 }
 exports.single = single;

package/dist/pregel/io.d.ts

@@ -14,4 +14,4 @@ export declare function mapOutputValues<C extends PropertyKey>(outputChannels: C
  * Map pending writes (a sequence of tuples (channel, value)) to output chunk.
  */
 export declare function mapOutputUpdates<N extends PropertyKey, C extends PropertyKey>(outputChannels: C | Array<C>, tasks: readonly PregelExecutableTask<N, C>[]): Generator<Record<N, any | Record<string, any>>>;
-export declare function single<T>(iter: IterableIterator<T>): T | undefined;
+export declare function single<T>(iter: IterableIterator<T>): T | null;

package/dist/pregel/io.js

@@ -130,5 +130,5 @@ export function single(iter) {
     for (const value of iter) {
         return value;
     }
-    return undefined;
+    return null;
 }

package/dist/tests/checkpoints.test.js

@@ -69,7 +69,7 @@ describe("MemorySaver", () => {
     it("should save and retrieve checkpoints correctly", async () => {
         const memorySaver = new MemorySaver();
         // save checkpoint
-        const runnableConfig = await memorySaver.put({ configurable: { thread_id: "1" } }, checkpoint1, { source: "update", step: -1 });
+        const runnableConfig = await memorySaver.put({ configurable: { thread_id: "1" } }, checkpoint1, { source: "update", step: -1, writes: null });
         expect(runnableConfig).toEqual({
             configurable: {
                 thread_id: "1",
@@ -91,6 +91,7 @@ describe("MemorySaver", () => {
         await memorySaver.put({ configurable: { thread_id: "1" } }, checkpoint2, {
             source: "update",
             step: -1,
+            writes: null,
         });
         // list checkpoints
         const checkpointTupleGenerator = await memorySaver.list({
@@ -116,7 +117,7 @@ describe("SqliteSaver", () => {
         });
         expect(undefinedCheckpoint).toBeUndefined();
         // save first checkpoint
-        const runnableConfig = await sqliteSaver.put({ configurable: { thread_id: "1" } }, checkpoint1, { source: "update", step: -1 });
+        const runnableConfig = await sqliteSaver.put({ configurable: { thread_id: "1" } }, checkpoint1, { source: "update", step: -1, writes: null });
         expect(runnableConfig).toEqual({
             configurable: {
                 thread_id: "1",
@@ -141,7 +142,7 @@ describe("SqliteSaver", () => {
                 thread_id: "1",
                 checkpoint_id: "2024-04-18T17:19:07.952Z",
             },
-        }, checkpoint2, { source: "update", step: -1 });
+        }, checkpoint2, { source: "update", step: -1, writes: null });
         // verify that parentTs is set and retrieved correctly for second checkpoint
         const secondCheckpointTuple = await sqliteSaver.getTuple({
             configurable: { thread_id: "1" },

package/dist/tests/prebuilt.int.test.js

@@ -3,8 +3,7 @@ import { it, beforeAll, describe, expect } from "@jest/globals";
 import { Tool } from "@langchain/core/tools";
 import { ChatOpenAI } from "@langchain/openai";
 import { HumanMessage } from "@langchain/core/messages";
-import { END } from "../index.js";
-import { createFunctionCallingExecutor } from "../prebuilt/index.js";
+import { createReactAgent, createFunctionCallingExecutor, } from "../prebuilt/index.js";
 // Tracing slows down the tests
 beforeAll(() => {
     process.env.LANGCHAIN_TRACING_V2 = "false";
@@ -44,7 +43,6 @@ describe("createFunctionCallingExecutor", () => {
         const response = await functionsAgentExecutor.invoke({
             messages: [new HumanMessage("What's the weather like in SF?")],
         });
-        console.log(response);
         // It needs at least one human message, one AI and one function message.
         expect(response.messages.length > 3).toBe(true);
         const firstFunctionMessage = response.messages.find((message) => message._getType() === "function");
@@ -83,19 +81,96 @@ describe("createFunctionCallingExecutor", () => {
         });
         const stream = await functionsAgentExecutor.stream({
             messages: [new HumanMessage("What's the weather like in SF?")],
-        });
+        }, { streamMode: "values" });
         const fullResponse = [];
         for await (const item of stream) {
-            console.log(item);
-            console.log("-----\n");
             fullResponse.push(item);
         }
-        // Needs at least 3 llm calls, plus one `__end__` call.
-        expect(fullResponse.length >= 4).toBe(true);
-        const endMessage = fullResponse[fullResponse.length - 1];
-        expect(END in endMessage).toBe(true);
-        expect(endMessage[END].messages.length > 0).toBe(true);
-        const functionCall = endMessage[END].messages.find((message) => message._getType() === "function");
+        // human -> agent -> action -> agent
+        expect(fullResponse.length).toEqual(4);
+        const endState = fullResponse[fullResponse.length - 1];
+        // 1 human, 2 llm calls, 1 function call.
+        expect(endState.messages.length).toEqual(4);
+        const functionCall = endState.messages.find((message) => message._getType() === "function");
         expect(functionCall.content).toBe(weatherResponse);
     });
 });
+describe("createReactAgent", () => {
+    it("can call a tool", async () => {
+        const weatherResponse = `Not too cold, not too hot 😎`;
+        const model = new ChatOpenAI();
+        class SanFranciscoWeatherTool extends Tool {
+            constructor() {
+                super();
+                Object.defineProperty(this, "name", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: "current_weather"
+                });
+                Object.defineProperty(this, "description", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: "Get the current weather report for San Francisco, CA"
+                });
+            }
+            async _call(_) {
+                return weatherResponse;
+            }
+        }
+        const tools = [new SanFranciscoWeatherTool()];
+        const reactAgent = createReactAgent({ llm: model, tools });
+        const response = await reactAgent.invoke({
+            messages: [new HumanMessage("What's the weather like in SF?")],
+        });
+        // It needs at least one human message and one AI message.
+        expect(response.messages.length > 1).toBe(true);
+        const lastMessage = response.messages[response.messages.length - 1];
+        expect(lastMessage._getType()).toBe("ai");
+        expect(lastMessage.content.toLowerCase()).toContain("not too cold");
+    });
+    it("can stream a tool call", async () => {
+        const weatherResponse = `Not too cold, not too hot 😎`;
+        const model = new ChatOpenAI({
+            streaming: true,
+        });
+        class SanFranciscoWeatherTool extends Tool {
+            constructor() {
+                super();
+                Object.defineProperty(this, "name", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: "current_weather"
+                });
+                Object.defineProperty(this, "description", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: "Get the current weather report for San Francisco, CA"
+                });
+            }
+            async _call(_) {
+                return weatherResponse;
+            }
+        }
+        const tools = [new SanFranciscoWeatherTool()];
+        const reactAgent = createReactAgent({ llm: model, tools });
+        const stream = await reactAgent.stream({
+            messages: [new HumanMessage("What's the weather like in SF?")],
+        }, { streamMode: "values" });
+        const fullResponse = [];
+        for await (const item of stream) {
+            fullResponse.push(item);
+        }
+        // human -> agent -> action -> agent
+        expect(fullResponse.length).toEqual(4);
+        const endState = fullResponse[fullResponse.length - 1];
+        // 1 human, 2 ai, 1 tool.
+        expect(endState.messages.length).toEqual(4);
+        const lastMessage = endState.messages[endState.messages.length - 1];
+        expect(lastMessage._getType()).toBe("ai");
+        expect(lastMessage.content.toLowerCase()).toContain("not too cold");
+    });
+});

package/dist/tests/prebuilt.test.d.ts

@@ -1 +1,20 @@
-export {};
+import { Tool } from "@langchain/core/tools";
+import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
+import { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import { BaseLLMParams } from "@langchain/core/language_models/llms";
+import { BaseMessage } from "@langchain/core/messages";
+import { ChatResult } from "@langchain/core/outputs";
+export declare class FakeToolCallingChatModel extends BaseChatModel {
+    sleep?: number;
+    responses?: BaseMessage[];
+    thrownErrorString?: string;
+    idx: number;
+    constructor(fields: {
+        sleep?: number;
+        responses?: BaseMessage[];
+        thrownErrorString?: string;
+    } & BaseLLMParams);
+    _llmType(): string;
+    _generate(messages: BaseMessage[], _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+    bindTools(_: Tool[]): FakeToolCallingChatModel;
+}

package/dist/tests/prebuilt.test.js

@@ -1,9 +1,13 @@
 /* eslint-disable no-process-env */
-import { it, expect, beforeAll, describe } from "@jest/globals";
+import { beforeAll, describe, expect, it } from "@jest/globals";
 import { PromptTemplate } from "@langchain/core/prompts";
+import { StructuredTool, Tool } from "@langchain/core/tools";
 import { FakeStreamingLLM } from "@langchain/core/utils/testing";
-import { Tool } from "@langchain/core/tools";
-import { createAgentExecutor } from "../prebuilt/index.js";
+import { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import { AIMessage, HumanMessage, SystemMessage, ToolMessage, } from "@langchain/core/messages";
+import { RunnableLambda } from "@langchain/core/runnables";
+import { z } from "zod";
+import { createAgentExecutor, createReactAgent } from "../prebuilt/index.js";
 // Tracing slows down the tests
 beforeAll(() => {
     process.env.LANGCHAIN_TRACING_V2 = "false";
@@ -193,3 +197,261 @@ describe("PreBuilt", () => {
         ]);
     });
 });
+export class FakeToolCallingChatModel extends BaseChatModel {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "sleep", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 50
+        });
+        Object.defineProperty(this, "responses", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "thrownErrorString", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "idx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.sleep = fields.sleep ?? this.sleep;
+        this.responses = fields.responses;
+        this.thrownErrorString = fields.thrownErrorString;
+        this.idx = 0;
+    }
+    _llmType() {
+        return "fake";
+    }
+    async _generate(messages, _options, _runManager) {
+        if (this.thrownErrorString) {
+            throw new Error(this.thrownErrorString);
+        }
+        const msg = this.responses?.[this.idx] ?? messages[this.idx];
+        const generation = {
+            generations: [
+                {
+                    text: "",
+                    message: msg,
+                },
+            ],
+        };
+        this.idx += 1;
+        return generation;
+    }
+    bindTools(_) {
+        return new FakeToolCallingChatModel({
+            sleep: this.sleep,
+            responses: this.responses,
+            thrownErrorString: this.thrownErrorString,
+        });
+    }
+}
+describe("createReactAgent", () => {
+    const searchSchema = z.object({
+        query: z.string().describe("The query to search for."),
+    });
+    class SearchAPI extends StructuredTool {
+        constructor() {
+            super(...arguments);
+            Object.defineProperty(this, "name", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: "search_api"
+            });
+            Object.defineProperty(this, "description", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: "A simple API that returns the input string."
+            });
+            Object.defineProperty(this, "schema", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: searchSchema
+            });
+        }
+        async _call(input) {
+            return `result for ${input?.query}`;
+        }
+    }
+    const tools = [new SearchAPI()];
+    it("Can use string message modifier", async () => {
+        const llm = new FakeToolCallingChatModel({
+            responses: [
+                new AIMessage({
+                    content: "result1",
+                    tool_calls: [
+                        { name: "search_api", id: "tool_abcd123", args: { query: "foo" } },
+                    ],
+                }),
+                new AIMessage("result2"),
+            ],
+        });
+        const agent = createReactAgent({
+            llm,
+            tools,
+            messageModifier: "You are a helpful assistant",
+        });
+        const result = await agent.invoke({
+            messages: [new HumanMessage("Hello Input!")],
+        });
+        expect(result.messages).toEqual([
+            new HumanMessage("Hello Input!"),
+            new AIMessage({
+                content: "result1",
+                tool_calls: [
+                    { name: "search_api", id: "tool_abcd123", args: { query: "foo" } },
+                ],
+            }),
+            new ToolMessage({
+                name: "search_api",
+                content: "result for foo",
+                tool_call_id: "tool_abcd123",
+            }),
+            new AIMessage("result2"),
+        ]);
+    });
+    it("Can use SystemMessage message modifier", async () => {
+        const llm = new FakeToolCallingChatModel({
+            responses: [
+                new AIMessage({
+                    content: "result1",
+                    tool_calls: [
+                        { name: "search_api", id: "tool_abcd123", args: { query: "foo" } },
+                    ],
+                }),
+                new AIMessage("result2"),
+            ],
+        });
+        const agent = createReactAgent({
+            llm,
+            tools,
+            messageModifier: new SystemMessage("You are a helpful assistant"),
+        });
+        const result = await agent.invoke({
+            messages: [],
+        });
+        expect(result.messages).toEqual([
+            new AIMessage({
+                content: "result1",
+                tool_calls: [
+                    { name: "search_api", id: "tool_abcd123", args: { query: "foo" } },
+                ],
+            }),
+            new ToolMessage({
+                name: "search_api",
+                content: "result for foo",
+                tool_call_id: "tool_abcd123",
+            }),
+            new AIMessage("result2"),
+        ]);
+    });
+    it("Can use custom function message modifier", async () => {
+        const aiM1 = new AIMessage({
+            content: "result1",
+            tool_calls: [
+                { name: "search_api", id: "tool_abcd123", args: { query: "foo" } },
+            ],
+        });
+        const aiM2 = new AIMessage("result2");
+        const llm = new FakeToolCallingChatModel({
+            responses: [aiM1, aiM2],
+        });
+        const messageModifier = (messages) => [
+            new SystemMessage("You are a helpful assistant"),
+            ...messages,
+        ];
+        const agent = createReactAgent({ llm, tools, messageModifier });
+        const result = await agent.invoke({
+            messages: [new HumanMessage("Hello Input!")],
+        });
+        expect(result.messages).toEqual([
+            new HumanMessage("Hello Input!"),
+            aiM1,
+            new ToolMessage({
+                name: "search_api",
+                content: "result for foo",
+                tool_call_id: "tool_abcd123",
+            }),
+            aiM2,
+        ]);
+    });
+    it("Can use async custom function message modifier", async () => {
+        const aiM1 = new AIMessage({
+            content: "result1",
+            tool_calls: [
+                { name: "search_api", id: "tool_abcd123", args: { query: "foo" } },
+            ],
+        });
+        const aiM2 = new AIMessage("result2");
+        const llm = new FakeToolCallingChatModel({
+            responses: [aiM1, aiM2],
+        });
+        const messageModifier = async (messages) => [
+            new SystemMessage("You are a helpful assistant"),
+            ...messages,
+        ];
+        const agent = createReactAgent({ llm, tools, messageModifier });
+        const result = await agent.invoke({
+            messages: [new HumanMessage("Hello Input!")],
+        });
+        expect(result.messages).toEqual([
+            new HumanMessage("Hello Input!"),
+            aiM1,
+            new ToolMessage({
+                name: "search_api",
+                content: "result for foo",
+                tool_call_id: "tool_abcd123",
+            }),
+            aiM2,
+        ]);
+    });
+    it("Can use RunnableLambda message modifier", async () => {
+        const aiM1 = new AIMessage({
+            content: "result1",
+            tool_calls: [
+                { name: "search_api", id: "tool_abcd123", args: { query: "foo" } },
+            ],
+        });
+        const aiM2 = new AIMessage("result2");
+        const llm = new FakeToolCallingChatModel({
+            responses: [aiM1, aiM2],
+        });
+        const messageModifier = new RunnableLambda({
+            func: (messages) => [
+                new SystemMessage("You are a helpful assistant"),
+                ...messages,
+            ],
+        });
+        const agent = createReactAgent({ llm, tools, messageModifier });
+        const result = await agent.invoke({
+            messages: [
+                new HumanMessage("Hello Input!"),
+                new HumanMessage("Another Input!"),
+            ],
+        });
+        expect(result.messages).toEqual([
+            new HumanMessage("Hello Input!"),
+            new HumanMessage("Another Input!"),
+            aiM1,
+            new ToolMessage({
+                name: "search_api",
+                content: "result for foo",
+                tool_call_id: "tool_abcd123",
+            }),
+            aiM2,
+        ]);
+    });
+});

package/dist/tests/pregel.test.js

@@ -1777,8 +1777,9 @@ it("StateGraph start branch then end", async () => {
         .addConditionalEdges({
         source: START,
         path: (state) => state.market === "DE" ? "tool_two_slow" : "tool_two_fast",
-        then: END,
-    });
+    })
+        .addEdge("tool_two_fast", END)
+        .addEdge("tool_two_slow", END);
     const toolTwo = toolTwoBuilder.compile();
     expect(await toolTwo.invoke({ my_key: "value", market: "DE" })).toEqual({
         my_key: "value slow",
@@ -1793,71 +1794,41 @@ it("StateGraph start branch then end", async () => {
         interruptBefore: ["tool_two_fast", "tool_two_slow"],
     });
     await expect(() => toolTwoWithCheckpointer.invoke({ my_key: "value", market: "DE" })).rejects.toThrowError("thread_id");
-    // const thread1 = { configurable: { thread_id: "1" } }
-    // expect(toolTwoWithCheckpointer.invoke({ my_key: "value", market: "DE" }, thread1)).toEqual({ my_key: "value", market: "DE" })
-    // expect(toolTwoWithCheckpointer.getState(thread1)).toEqual({
-    //   values: { my_key: "value", market: "DE" },
-    //   next: ["tool_two_slow"],
-    //   config: toolTwoWithCheckpointer.checkpointer.getTuple(thread1).config,
-    //   metadata: { source: "loop", step: 0, writes: null },
-    //   parentConfig: [...toolTwoWithCheckpointer.checkpointer.list(thread1, { limit: 2 })].pop().config
-    // })
-    // expect(toolTwoWithCheckpointer.invoke(null, thread1, { debug: 1 })).toEqual({ my_key: "value slow", market: "DE" })
-    // expect(toolTwoWithCheckpointer.getState(thread1)).toEqual({
-    //   values: { my_key
-    //     : "value slow", market: "DE" },
-    //   next: [],
-    //   config: (await toolTwoWithCheckpointer.checkpointer!.getTuple(thread1))!.config,
-    //   metadata: { source: "loop", step: 1, writes: { tool_two_slow: { my_key: " slow" } } },
-    //   parentConfig: [...toolTwoWithCheckpointer.checkpointer!.list(thread1, { limit: 2 })].pop().config
-});
-/**
- * def test_branch_then_node(snapshot: SnapshotAssertion) -> None:
-    class State(TypedDict):
-        my_key: Annotated[str, operator.add]
-        market: str
-
-    # this graph is invalid because there is no path to "finish"
-    invalid_graph = StateGraph(State)
-    invalid_graph.set_entry_point("prepare")
-    invalid_graph.set_finish_point("finish")
-    invalid_graph.add_conditional_edges(
-        source="prepare",
-        path=lambda s: "tool_two_slow" if s["market"] == "DE" else "tool_two_fast",
-        path_map=["tool_two_slow", "tool_two_fast"],
-    )
-    invalid_graph.add_node("prepare", lambda s: {"my_key": " prepared"})
-    invalid_graph.add_node("tool_two_slow", lambda s: {"my_key": " slow"})
-    invalid_graph.add_node("tool_two_fast", lambda s: {"my_key": " fast"})
-    invalid_graph.add_node("finish", lambda s: {"my_key": " finished"})
-    with pytest.raises(ValueError):
-        invalid_graph.compile()
-
-    tool_two_graph = StateGraph(State)
-    tool_two_graph.set_entry_point("prepare")
-    tool_two_graph.set_finish_point("finish")
-    tool_two_graph.add_conditional_edges(
-        source="prepare",
-        path=lambda s: "tool_two_slow" if s["market"] == "DE" else "tool_two_fast",
-        then="finish",
-    )
-    tool_two_graph.add_node("prepare", lambda s: {"my_key": " prepared"})
-    tool_two_graph.add_node("tool_two_slow", lambda s: {"my_key": " slow"})
-    tool_two_graph.add_node("tool_two_fast", lambda s: {"my_key": " fast"})
-    tool_two_graph.add_node("finish", lambda s: {"my_key": " finished"})
-    tool_two = tool_two_graph.compile()
-    assert tool_two.get_graph().draw_mermaid(with_styles=False) == snapshot
-    assert tool_two.get_graph().draw_mermaid() == snapshot
-
-    assert tool_two.invoke({"my_key": "value", "market": "DE"}, debug=1) == {
-        "my_key": "value prepared slow finished",
-        "market": "DE",
-    }
-    assert tool_two.invoke({"my_key": "value", "market": "US"}) == {
-        "my_key": "value prepared fast finished",
-        "market": "US",
+    async function last(iter) {
+        // eslint-disable-next-line no-undef-init
+        let value = undefined;
+        for await (value of iter) {
+            // do nothing
+        }
+        return value;
     }
- */
+    const thread1 = { configurable: { thread_id: "1" } };
+    expect(await toolTwoWithCheckpointer.invoke({ my_key: "value", market: "DE" }, thread1)).toEqual({ my_key: "value", market: "DE" });
+    expect(await toolTwoWithCheckpointer.getState(thread1)).toEqual({
+        values: { my_key: "value", market: "DE" },
+        next: ["tool_two_slow"],
+        config: (await toolTwoWithCheckpointer.checkpointer.getTuple(thread1))
+            .config,
+        metadata: { source: "loop", step: 0, writes: null },
+        parentConfig: (await last(toolTwoWithCheckpointer.checkpointer.list(thread1, 2))).config,
+    });
+    expect(await toolTwoWithCheckpointer.invoke(null, thread1)).toEqual({
+        my_key: "value slow",
+        market: "DE",
+    });
+    expect(await toolTwoWithCheckpointer.getState(thread1)).toEqual({
+        values: { my_key: "value slow", market: "DE" },
+        next: [],
+        config: (await toolTwoWithCheckpointer.checkpointer.getTuple(thread1))
+            .config,
+        metadata: {
+            source: "loop",
+            step: 1,
+            writes: { tool_two_slow: { my_key: " slow" } },
+        },
+        parentConfig: (await last(toolTwoWithCheckpointer.checkpointer.list(thread1, 2))).config,
+    });
+});
 it("StateGraph branch then node", async () => {
     const invalidBuilder = new StateGraph({
         channels: {
@@ -1891,8 +1862,9 @@ it("StateGraph branch then node", async () => {
         .addConditionalEdges({
         source: "prepare",
         path: (state) => state.market === "DE" ? "tool_two_slow" : "tool_two_fast",
-        then: "finish",
     })
+        .addEdge("tool_two_fast", "finish")
+        .addEdge("tool_two_slow", "finish")
         .addEdge("finish", END);
     const tool = toolBuilder.compile();
     expect(await tool.invoke({ my_key: "value", market: "DE" })).toEqual({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "description": "LangGraph",
   "type": "module",
   "engines": {
@@ -42,8 +42,9 @@
   },
   "devDependencies": {
     "@jest/globals": "^29.5.0",
+    "@langchain/anthropic": "^0.1.21",
     "@langchain/community": "^0.0.43",
-    "@langchain/openai": "^0.0.23",
+    "@langchain/openai": "latest",
     "@langchain/scripts": "^0.0.13",
     "@swc/core": "^1.3.90",
     "@swc/jest": "^0.2.29",