@langchain/langgraph 0.0.11 → 0.0.13

package/dist/graph/state.js

@@ -1,11 +1,15 @@
-import { RunnableLambda, } from "@langchain/core/runnables";
 import { BinaryOperatorAggregate } from "../channels/binop.js";
-import { END, Graph } from "./graph.js";
+import { END, CompiledGraph, Graph, START } from "./graph.js";
 import { LastValue } from "../channels/last_value.js";
-import { ChannelWrite } from "../pregel/write.js";
-import { Pregel, Channel } from "../pregel/index.js";
-import { ChannelRead } from "../pregel/read.js";
-export const START = "__start__";
+import { ChannelWrite, PASSTHROUGH, SKIP_WRITE, } from "../pregel/write.js";
+import { ChannelRead, PregelNode } from "../pregel/read.js";
+import { NamedBarrierValue } from "../channels/named_barrier_value.js";
+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) {
         super();
@@ -15,128 +19,258 @@ export class StateGraph extends Graph {
             writable: true,
             value: void 0
         });
+        // TODO: this doesn't dedupe edges as in py, so worth fixing at some point
+        Object.defineProperty(this, "waitingEdges", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
         this.channels = _getChannels(fields.channels);
+        for (const c of Object.values(this.channels)) {
+            if (c.lc_graph_name === "BinaryOperatorAggregate") {
+                this.supportMultipleEdges = true;
+                break;
+            }
+        }
+    }
+    get allEdges() {
+        return new Set([
+            ...this.edges,
+            ...Array.from(this.waitingEdges).flatMap(([starts, end]) => starts.map((start) => [start, end])),
+        ]);
     }
     addNode(key, action) {
-        if (Object.keys(this.nodes).some((key) => key in this.channels)) {
+        if (key in this.channels) {
             throw new Error(`${key} is already being used as a state attribute (a.k.a. a channel), cannot also be used as a node name.`);
         }
-        super.addNode(key, action);
+        return super.addNode(key, action);
     }
-    compile(checkpointer) {
-        this.validate();
-        if (Object.keys(this.nodes).some((key) => key in this.channels)) {
-            throw new Error("Cannot use channel names as node names");
+    addEdge(startKey, endKey) {
+        if (typeof startKey === "string") {
+            return super.addEdge(startKey, endKey);
         }
+        if (this.compiled) {
+            console.warn("Adding an edge to a graph that has already been compiled. This will " +
+                "not be reflected in the compiled graph.");
+        }
+        for (const start of startKey) {
+            if (start === END) {
+                throw new Error("END cannot be a start node");
+            }
+            if (!Object.keys(this.nodes).some((node) => node === start)) {
+                throw new Error(`Need to add_node ${start} first`);
+            }
+        }
+        if (endKey === END) {
+            throw new Error("END cannot be an end node");
+        }
+        if (!Object.keys(this.nodes).some((node) => node === endKey)) {
+            throw new Error(`Need to add_node ${endKey} first`);
+        }
+        this.waitingEdges.add([startKey, endKey]);
+        return this;
+    }
+    compile({ checkpointer, interruptBefore, interruptAfter, } = {}) {
+        // validate the graph
+        this.validate([
+            ...(Array.isArray(interruptBefore) ? interruptBefore : []),
+            ...(Array.isArray(interruptAfter) ? interruptAfter : []),
+        ]);
+        // prepare output channels
         const stateKeys = Object.keys(this.channels);
-        const stateKeysRead = stateKeys.length === 1 && stateKeys[0] === "__root__"
+        const outputs = stateKeys.length === 1 && stateKeys[0] === ROOT
             ? stateKeys[0]
             : stateKeys;
-        const updateState = Array.isArray(stateKeysRead)
-            ? (nodeName, 
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            input, options) => _updateStateObject(stateKeys, nodeName, input, options)
-            : _updateStateRoot;
-        const outgoingEdges = {};
+        // create empty compiled graph
+        const compiled = new CompiledStateGraph({
+            builder: this,
+            checkpointer,
+            interruptAfter,
+            interruptBefore,
+            autoValidate: false,
+            nodes: {},
+            channels: {
+                ...this.channels,
+                [START]: new EphemeralValue(),
+            },
+            inputs: START,
+            outputs,
+            streamChannels: outputs,
+            streamMode: "updates",
+        });
+        // attach nodes, edges and branches
+        compiled.attachNode(START);
+        for (const [key, node] of Object.entries(this.nodes)) {
+            compiled.attachNode(key, node);
+        }
         for (const [start, end] of this.edges) {
-            if (!outgoingEdges[start]) {
-                outgoingEdges[start] = [];
-            }
-            outgoingEdges[start].push(end !== END ? `${end}:inbox` : END);
+            compiled.attachEdge(start, end);
         }
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const nodes = {};
-        for (const [key, node] of Object.entries(this.nodes)) {
-            nodes[key] = Channel.subscribeTo(`${key}:inbox`)
-                .pipe(node)
-                .pipe((
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            input, options) => updateState(key, input, options))
-                .pipe(Channel.writeTo(key));
-        }
-        for (const key of Object.keys(this.nodes)) {
-            const outgoing = outgoingEdges[key];
-            const edgesKey = `${key}:edges`;
-            if (outgoing || this.branches[key]) {
-                nodes[edgesKey] = Channel.subscribeTo(key, {
-                    tags: ["langsmith:hidden"],
-                }).pipe(new ChannelRead(stateKeysRead));
-            }
-            if (outgoing) {
-                nodes[edgesKey] = nodes[edgesKey].pipe(Channel.writeTo(...outgoing));
-            }
-            if (this.branches[key]) {
-                for (const branch of this.branches[key]) {
-                    nodes[edgesKey] = nodes[edgesKey].pipe(new RunnableLambda({
-                        func: (i, c) => branch.runnable(i, c),
-                    }));
-                }
+        for (const [starts, end] of this.waitingEdges) {
+            compiled.attachEdge(starts, end);
+        }
+        for (const [start, branches] of Object.entries(this.branches)) {
+            for (const [name, branch] of Object.entries(branches)) {
+                compiled.attachBranch(start, name, branch);
             }
         }
-        nodes[START] = Channel.subscribeTo(`${START}:inbox`, {
-            tags: ["langsmith:hidden"],
-        })
-            .pipe((
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        input, options) => updateState(START, input, options))
-            .pipe(Channel.writeTo(START));
-        nodes[`${START}:edges`] = Channel.subscribeTo(START, {
-            tags: ["langsmith:hidden"],
-        })
-            .pipe(new ChannelRead(stateKeysRead))
-            .pipe(Channel.writeTo(`${this.entryPoint}:inbox`));
-        return new Pregel({
-            nodes,
-            channels: this.channels,
-            input: `${START}:inbox`,
-            output: END,
-            hidden: Object.keys(this.nodes)
-                .map((node) => `${node}:inbox`)
-                .concat(START, stateKeys),
-            checkpointer,
-        });
+        return compiled.validate();
     }
 }
-function _updateStateObject(stateKeys, nodeName, 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-input, options
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-) {
-    if (!options?.config) {
-        throw new Error("Config not found when updating state.");
-    }
-    if (Object.keys(input).some((key) => !stateKeys.some((sk) => sk === key))) {
-        throw new Error(`Invalid state update from node ${nodeName}, expected object with one or more of ${stateKeys.join(", ")}, got ${Object.keys(input).join(",")}`);
+function _getChannels(schema) {
+    const channels = {};
+    for (const [name, val] of Object.entries(schema)) {
+        if (name === ROOT) {
+            channels[name] = getChannel(val);
+        }
+        else {
+            const key = name;
+            channels[name] = getChannel(val);
+        }
     }
-    ChannelWrite.doWrite(options.config, input);
-    return input;
+    return channels;
 }
-function _updateStateRoot(_nodeName, input, options) {
-    if (!options?.config) {
-        throw new Error("Config not found when updating state.");
+function getChannel(reducer) {
+    if (reducer && "reducer" in reducer && reducer.reducer) {
+        return new BinaryOperatorAggregate(reducer.reducer, reducer.default);
+    }
+    if (reducer && "value" in reducer && reducer.value) {
+        return new BinaryOperatorAggregate(reducer.value, reducer.default);
     }
-    ChannelWrite.doWrite(options.config, {
-        __root__: input,
-    });
-    return input;
+    return new LastValue();
 }
-function _getChannels(schema) {
-    if ("value" in schema && "default" in schema) {
-        if (!schema.value) {
-            throw new Error("Value is required for channels");
+export class CompiledStateGraph extends CompiledGraph {
+    attachNode(key, node) {
+        const stateKeys = Object.keys(this.builder.channels);
+        function getStateKey(key, input) {
+            if (!input) {
+                return SKIP_WRITE;
+            }
+            else if (typeof input !== "object" || Array.isArray(input)) {
+                throw new InvalidUpdateError(`Expected dict, got ${typeof input}`);
+            }
+            else {
+                return key in input ? input[key] : SKIP_WRITE;
+            }
+        }
+        // state updaters
+        const stateWriteEntries = stateKeys.map((key) => key === ROOT
+            ? { channel: key, value: PASSTHROUGH, skipNone: true }
+            : {
+                channel: key,
+                value: PASSTHROUGH,
+                mapper: new RunnableCallable({
+                    func: getStateKey.bind(null, key),
+                    trace: false,
+                    recurse: false,
+                }),
+            });
+        // add node and output channel
+        if (key === START) {
+            this.nodes[key] = new PregelNode({
+                tags: [TAG_HIDDEN],
+                triggers: [START],
+                channels: [START],
+                writers: [new ChannelWrite(stateWriteEntries, [TAG_HIDDEN])],
+            });
+        }
+        else {
+            this.channels[key] = new EphemeralValue();
+            this.nodes[key] = new PregelNode({
+                triggers: [],
+                // read state keys
+                channels: stateKeys.length === 1 && stateKeys[0] === ROOT
+                    ? stateKeys
+                    : stateKeys.reduce((acc, k) => {
+                        acc[k] = k;
+                        return acc;
+                    }, {}),
+                // publish to this channel and state keys
+                writers: [
+                    new ChannelWrite(stateWriteEntries.concat({ channel: key, value: key }), [TAG_HIDDEN]),
+                ],
+                bound: node,
+            });
         }
-        return {
-            __root__: new BinaryOperatorAggregate(schema.value, schema.default),
-        };
     }
-    const channels = {};
-    for (const [name, values] of Object.entries(schema)) {
-        if (values.value) {
-            channels[name] = new BinaryOperatorAggregate(values.value, values.default);
+    attachEdge(start, end) {
+        if (end === END) {
+            return;
+        }
+        if (Array.isArray(start)) {
+            const channelName = `join:${start.join("+")}:${end}`;
+            // register channel
+            this.channels[channelName] =
+                new NamedBarrierValue(new Set(start));
+            // subscribe to channel
+            this.nodes[end].triggers.push(channelName);
+            // publish to channel
+            for (const s of start) {
+                this.nodes[s].writers.push(new ChannelWrite([{ channel: channelName, value: s }], [TAG_HIDDEN]));
+            }
+        }
+        else if (start === START) {
+            const channelName = `start:${end}`;
+            // register channel
+            this.channels[channelName] =
+                new EphemeralValue();
+            // subscribe to channel
+            this.nodes[end].triggers.push(channelName);
+            // publish to channel
+            this.nodes[START].writers.push(new ChannelWrite([{ channel: channelName, value: START }], [TAG_HIDDEN]));
         }
         else {
-            channels[name] = new LastValue();
+            this.nodes[end].triggers.push(start);
+        }
+    }
+    attachBranch(start, name, branch) {
+        // attach branch publisher
+        this.nodes[start].writers.push(branch.compile(
+        // writer
+        (dests) => {
+            const filteredDests = dests.filter((dest) => dest !== END);
+            if (!filteredDests.length) {
+                return;
+            }
+            const writes = filteredDests.map((dest) => ({
+                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
+        (config) => ChannelRead.doRead(config, this.outputs, true)));
+        // attach branch subscribers
+        const ends = branch.ends
+            ? Object.values(branch.ends)
+            : Object.keys(this.builder.nodes).filter((n) => n !== branch.then);
+        for (const end of ends) {
+            if (end === END) {
+                continue;
+            }
+            const channelName = `branch:${start}:${name}:${end}`;
+            this.channels[channelName] =
+                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]));
+            }
         }
     }
-    return channels;
 }

package/dist/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseCheckpointSaver = exports.emptyCheckpoint = exports.MemorySaverAssertImmutable = exports.MemorySaver = exports.MessageGraph = exports.StateGraph = exports.START = exports.Graph = exports.END = void 0;
+exports.EmptyChannelError = exports.InvalidUpdateError = exports.GraphValueError = exports.GraphRecursionError = exports.BaseCheckpointSaver = exports.emptyCheckpoint = exports.MemorySaver = exports.MessageGraph = exports.StateGraph = exports.START = exports.Graph = exports.END = void 0;
 var index_js_1 = require("./graph/index.cjs");
 Object.defineProperty(exports, "END", { enumerable: true, get: function () { return index_js_1.END; } });
 Object.defineProperty(exports, "Graph", { enumerable: true, get: function () { return index_js_1.Graph; } });
@@ -9,7 +9,11 @@ Object.defineProperty(exports, "StateGraph", { enumerable: true, get: function (
 Object.defineProperty(exports, "MessageGraph", { enumerable: true, get: function () { return index_js_1.MessageGraph; } });
 var index_js_2 = require("./checkpoint/index.cjs");
 Object.defineProperty(exports, "MemorySaver", { enumerable: true, get: function () { return index_js_2.MemorySaver; } });
-Object.defineProperty(exports, "MemorySaverAssertImmutable", { enumerable: true, get: function () { return index_js_2.MemorySaverAssertImmutable; } });
 var index_js_3 = require("./checkpoint/index.cjs");
 Object.defineProperty(exports, "emptyCheckpoint", { enumerable: true, get: function () { return index_js_3.emptyCheckpoint; } });
 Object.defineProperty(exports, "BaseCheckpointSaver", { enumerable: true, get: function () { return index_js_3.BaseCheckpointSaver; } });
+var errors_js_1 = require("./errors.cjs");
+Object.defineProperty(exports, "GraphRecursionError", { enumerable: true, get: function () { return errors_js_1.GraphRecursionError; } });
+Object.defineProperty(exports, "GraphValueError", { enumerable: true, get: function () { return errors_js_1.GraphValueError; } });
+Object.defineProperty(exports, "InvalidUpdateError", { enumerable: true, get: function () { return errors_js_1.InvalidUpdateError; } });
+Object.defineProperty(exports, "EmptyChannelError", { enumerable: true, get: function () { return errors_js_1.EmptyChannelError; } });

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export { END, Graph, type StateGraphArgs, START, StateGraph, MessageGraph, } from "./graph/index.js";
-export { MemorySaver, MemorySaverAssertImmutable } from "./checkpoint/index.js";
-export { type ConfigurableFieldSpec, type Checkpoint, type CheckpointAt, emptyCheckpoint, BaseCheckpointSaver, } from "./checkpoint/index.js";
+export { MemorySaver } from "./checkpoint/index.js";
+export { type Checkpoint, emptyCheckpoint, BaseCheckpointSaver, } from "./checkpoint/index.js";
+export { GraphRecursionError, GraphValueError, InvalidUpdateError, EmptyChannelError, } from "./errors.js";

package/dist/index.js

@@ -1,3 +1,4 @@
 export { END, Graph, START, StateGraph, MessageGraph, } from "./graph/index.js";
-export { MemorySaver, MemorySaverAssertImmutable } from "./checkpoint/index.js";
+export { MemorySaver } from "./checkpoint/index.js";
 export { emptyCheckpoint, BaseCheckpointSaver, } from "./checkpoint/index.js";
+export { GraphRecursionError, GraphValueError, InvalidUpdateError, EmptyChannelError, } from "./errors.js";

package/dist/prebuilt/agent_executor.cjs

@@ -4,27 +4,7 @@ exports.createAgentExecutor = void 0;
 const tool_executor_js_1 = require("./tool_executor.cjs");
 const state_js_1 = require("../graph/state.cjs");
 const index_js_1 = require("../index.cjs");
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function _getAgentState(inputSchema) {
-    if (!inputSchema) {
-        return {
-            input: {
-                value: null,
-            },
-            agentOutcome: {
-                value: null,
-            },
-            steps: {
-                value: (x, y) => x.concat(y),
-                default: () => [],
-            },
-        };
-    }
-    else {
-        return inputSchema;
-    }
-}
-function createAgentExecutor({ agentRunnable, tools, inputSchema, }) {
+function createAgentExecutor({ agentRunnable, tools, }) {
     let toolExecutor;
     if (!Array.isArray(tools)) {
         toolExecutor = tools;
@@ -34,7 +14,6 @@ function createAgentExecutor({ agentRunnable, tools, inputSchema, }) {
             tools,
         });
     }
-    const state = _getAgentState(inputSchema);
     // Define logic that will be used to determine which conditional edge to go down
     const shouldContinue = (data) => {
         if (data.agentOutcome && "returnValues" in data.agentOutcome) {
@@ -60,16 +39,23 @@ function createAgentExecutor({ agentRunnable, tools, inputSchema, }) {
     };
     // Define a new graph
     const workflow = new state_js_1.StateGraph({
-        channels: state,
-    });
-    // Define the two nodes we will cycle between
-    workflow.addNode("agent", runAgent);
-    workflow.addNode("action", executeTools);
-    // Set the entrypoint as `agent`
-    // This means that this node is the first one called
-    workflow.setEntryPoint("agent");
-    // We now add a conditional edge
-    workflow.addConditionalEdges(
+        channels: {
+            input: null,
+            agentOutcome: null,
+            steps: {
+                reducer: (x, y) => x.concat(y),
+                default: () => [],
+            },
+        },
+    })
+        // Define the two nodes we will cycle between
+        .addNode("agent", runAgent)
+        .addNode("action", executeTools)
+        // Set the entrypoint as `agent`
+        // This means that this node is the first one called
+        .addEdge(index_js_1.START, "agent")
+        // We now add a conditional edge
+        .addConditionalEdges(
     // First, we define the start node. We use `agent`.
     // This means these are the edges taken after the `agent` node is called.
     "agent", 
@@ -86,10 +72,10 @@ function createAgentExecutor({ agentRunnable, tools, inputSchema, }) {
         continue: "action",
         // Otherwise we finish.
         end: index_js_1.END,
-    });
-    // We now add a normal edge from `tools` to `agent`.
-    // This means that after `tools` is called, `agent` node is called next.
-    workflow.addEdge("action", "agent");
+    })
+        // We now add a normal edge from `tools` to `agent`.
+        // This means that after `tools` is called, `agent` node is called next.
+        .addEdge("action", "agent");
     return workflow.compile();
 }
 exports.createAgentExecutor = createAgentExecutor;

package/dist/prebuilt/agent_executor.d.ts

@@ -3,21 +3,18 @@ import { BaseMessage } from "@langchain/core/messages";
 import { Runnable } from "@langchain/core/runnables";
 import { Tool } from "@langchain/core/tools";
 import { ToolExecutor } from "./tool_executor.js";
-import { StateGraphArgs } from "../graph/state.js";
-import { Pregel } from "../pregel/index.js";
-type Step = [AgentAction | AgentFinish, string];
-interface AgentStateBase {
+interface Step {
+    action: AgentAction | AgentFinish;
+    observation: unknown;
+}
+export interface AgentExecutorState {
     agentOutcome?: AgentAction | AgentFinish;
     steps: Array<Step>;
-}
-export interface AgentExecutorState extends AgentStateBase {
     input: string;
     chatHistory?: BaseMessage[];
 }
-type AgentChannels<T extends AgentExecutorState> = StateGraphArgs<AgentExecutorState | T>["channels"];
-export declare function createAgentExecutor<T extends AgentExecutorState>({ agentRunnable, tools, inputSchema, }: {
+export declare function createAgentExecutor({ agentRunnable, tools, }: {
     agentRunnable: Runnable;
     tools: Array<Tool> | ToolExecutor;
-    inputSchema?: AgentChannels<T>;
-}): Pregel;
+}): import("../graph/state.js").CompiledStateGraph<AgentExecutorState, Partial<AgentExecutorState>, "__start__" | "agent" | "action">;
 export {};

package/dist/prebuilt/agent_executor.js

@@ -1,27 +1,7 @@
 import { ToolExecutor } from "./tool_executor.js";
 import { StateGraph } from "../graph/state.js";
-import { END } from "../index.js";
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function _getAgentState(inputSchema) {
-    if (!inputSchema) {
-        return {
-            input: {
-                value: null,
-            },
-            agentOutcome: {
-                value: null,
-            },
-            steps: {
-                value: (x, y) => x.concat(y),
-                default: () => [],
-            },
-        };
-    }
-    else {
-        return inputSchema;
-    }
-}
-export function createAgentExecutor({ agentRunnable, tools, inputSchema, }) {
+import { END, START } from "../index.js";
+export function createAgentExecutor({ agentRunnable, tools, }) {
     let toolExecutor;
     if (!Array.isArray(tools)) {
         toolExecutor = tools;
@@ -31,7 +11,6 @@ export function createAgentExecutor({ agentRunnable, tools, inputSchema, }) {
             tools,
         });
     }
-    const state = _getAgentState(inputSchema);
     // Define logic that will be used to determine which conditional edge to go down
     const shouldContinue = (data) => {
         if (data.agentOutcome && "returnValues" in data.agentOutcome) {
@@ -57,16 +36,23 @@ export function createAgentExecutor({ agentRunnable, tools, inputSchema, }) {
     };
     // Define a new graph
     const workflow = new StateGraph({
-        channels: state,
-    });
-    // Define the two nodes we will cycle between
-    workflow.addNode("agent", runAgent);
-    workflow.addNode("action", executeTools);
-    // Set the entrypoint as `agent`
-    // This means that this node is the first one called
-    workflow.setEntryPoint("agent");
-    // We now add a conditional edge
-    workflow.addConditionalEdges(
+        channels: {
+            input: null,
+            agentOutcome: null,
+            steps: {
+                reducer: (x, y) => x.concat(y),
+                default: () => [],
+            },
+        },
+    })
+        // Define the two nodes we will cycle between
+        .addNode("agent", runAgent)
+        .addNode("action", executeTools)
+        // Set the entrypoint as `agent`
+        // This means that this node is the first one called
+        .addEdge(START, "agent")
+        // We now add a conditional edge
+        .addConditionalEdges(
     // First, we define the start node. We use `agent`.
     // This means these are the edges taken after the `agent` node is called.
     "agent", 
@@ -83,9 +69,9 @@ export function createAgentExecutor({ agentRunnable, tools, inputSchema, }) {
         continue: "action",
         // Otherwise we finish.
         end: END,
-    });
-    // We now add a normal edge from `tools` to `agent`.
-    // This means that after `tools` is called, `agent` node is called next.
-    workflow.addEdge("action", "agent");
+    })
+        // We now add a normal edge from `tools` to `agent`.
+        // This means that after `tools` is called, `agent` node is called next.
+        .addEdge("action", "agent");
     return workflow.compile();
 }

package/dist/prebuilt/chat_agent_executor.cjs

@@ -93,15 +93,15 @@ function createFunctionCallingExecutor({ model, tools, }) {
     // Define a new graph
     const workflow = new state_js_1.StateGraph({
         channels: schema,
-    });
-    // Define the two nodes we will cycle between
-    workflow.addNode("agent", new runnables_1.RunnableLambda({ func: callModel }));
-    workflow.addNode("action", new runnables_1.RunnableLambda({ func: callTool }));
-    // Set the entrypoint as `agent`
-    // This means that this node is the first one called
-    workflow.setEntryPoint("agent");
-    // We now add a conditional edge
-    workflow.addConditionalEdges(
+    })
+        // Define the two nodes we will cycle between
+        .addNode("agent", new runnables_1.RunnableLambda({ func: callModel }))
+        .addNode("action", new runnables_1.RunnableLambda({ func: callTool }))
+        // Set the entrypoint as `agent`
+        // This means that this node is the first one called
+        .addEdge(index_js_1.START, "agent")
+        // We now add a conditional edge
+        .addConditionalEdges(
     // First, we define the start node. We use `agent`.
     // This means these are the edges taken after the `agent` node is called.
     "agent", 
@@ -118,10 +118,10 @@ function createFunctionCallingExecutor({ model, tools, }) {
         continue: "action",
         // Otherwise we finish.
         end: index_js_1.END,
-    });
-    // We now add a normal edge from `tools` to `agent`.
-    // This means that after `tools` is called, `agent` node is called next.
-    workflow.addEdge("action", "agent");
+    })
+        // We now add a normal edge from `tools` to `agent`.
+        // This means that after `tools` is called, `agent` node is called next.
+        .addEdge("action", "agent");
     // Finally, we compile it!
     // This compiles it into a LangChain Runnable,
     // meaning you can use it as you would any other runnable