@langchain/langgraph 0.0.17 → 0.0.18

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,105 @@
+"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 model utilizing tool calling.
+ * @param model The chat model 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(model, tools, messageModifier, checkpointSaver, interruptBefore, interruptAfter) {
+    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 model) || typeof model.bindTools !== "function") {
+        throw new Error(`Model ${model} must define bindTools method.`);
+    }
+    const modelWithTools = model.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",
+        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,26 @@
+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";
+/**
+ * Creates a StateGraph agent that relies on a chat model utilizing tool calling.
+ * @param model The chat model 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(model: BaseChatModel, tools: ToolNode<MessagesState> | StructuredTool[], messageModifier?: SystemMessage | string | ((messages: BaseMessage[]) => BaseMessage[]) | Runnable, checkpointSaver?: BaseCheckpointSaver, interruptBefore?: N[] | All, interruptAfter?: N[] | All): CompiledStateGraph<AgentState, Partial<AgentState>, typeof START | "agent" | "tools">;

package/dist/prebuilt/react_agent_executor.js

@@ -0,0 +1,101 @@
+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 model utilizing tool calling.
+ * @param model The chat model 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(model, tools, messageModifier, checkpointSaver, interruptBefore, interruptAfter) {
+    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 model) || typeof model.bindTools !== "function") {
+        throw new Error(`Model ${model} must define bindTools method.`);
+    }
+    const modelWithTools = model.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/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(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(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,224 @@ 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, "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, new SystemMessage("You are a helpful assistant"));
+        const result = await agent.invoke({
+            messages: [],
+        });
+        console.log("RESULT THING", result);
+        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 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph",
-  "version": "0.0.17",
+  "version": "0.0.18",
   "description": "LangGraph",
   "type": "module",
   "engines": {
@@ -43,7 +43,7 @@
   "devDependencies": {
     "@jest/globals": "^29.5.0",
     "@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",