@langchain/langgraph 0.0.3 → 0.0.4

package/dist/graph/graph.cjs

@@ -24,7 +24,13 @@ class Branch {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     runnable(input, options) {
         const result = this.condition(input, options?.config);
-        const destination = this.ends[result];
+        let destination;
+        if (this.ends) {
+            destination = this.ends[result];
+        }
+        else {
+            destination = result;
+        }
         return index_js_1.Channel.writeTo(destination !== exports.END ? `${destination}:inbox` : exports.END);
     }
 }
@@ -90,9 +96,13 @@ class Graph {
         if (condition.constructor.name === "AsyncFunction") {
             throw new Error("Condition cannot be an async function");
         }
-        for (const destination of Object.values(conditionalEdgeMapping)) {
-            if (!this.nodes[destination] && destination !== exports.END) {
-                throw new Error(`Need to addNode \`${destination}\` first`);
+        if (conditionalEdgeMapping) {
+            const mappingValues = Array.from(Object.values(conditionalEdgeMapping));
+            const nodesValues = Object.keys(this.nodes);
+            const endExcluded = mappingValues.filter((value) => value !== exports.END);
+            const difference = endExcluded.filter((value) => !nodesValues.some((nv) => nv === value));
+            if (difference.length > 0) {
+                throw new Error(`Missing nodes which are in conditional edge mapping.\nMapping contains possible destinations: ${mappingValues.join(", ")}.\nPossible nodes are ${nodesValues.join(", ")}.`);
             }
         }
         if (!this.branches[startKey]) {
@@ -158,18 +168,23 @@ class Graph {
     }
     validate() {
         const allStarts = new Set([...this.edges].map(([src, _]) => src).concat(Object.keys(this.branches)));
-        const allEnds = new Set([...this.edges]
-            .map(([_, end]) => end)
-            .concat(...Object.values(this.branches).flatMap((branchList) => branchList.flatMap((branch) => Object.values(branch.ends))))
-            .concat(this.entryPoint ? [this.entryPoint] : []));
         for (const node of Object.keys(this.nodes)) {
-            if (!allEnds.has(node)) {
-                throw new Error(`Node \`${node}\` is not reachable`);
-            }
             if (!allStarts.has(node)) {
                 throw new Error(`Node \`${node}\` is a dead-end`);
             }
         }
+        const allEndsAreDefined = Object.values(this.branches).every((branchList) => branchList.every((branch) => branch.ends !== null));
+        if (allEndsAreDefined) {
+            const allEnds = new Set([...this.edges]
+                .map(([_, end]) => end)
+                .concat(...Object.values(this.branches).flatMap((branchList) => branchList.flatMap((branch) => Object.values(branch.ends ?? {}))))
+                .concat(this.entryPoint ? [this.entryPoint] : []));
+            for (const node of Object.keys(this.nodes)) {
+                if (!allEnds.has(node)) {
+                    throw new Error(`Node \`${node}\` is not reachable`);
+                }
+            }
+        }
     }
 }
 exports.Graph = Graph;

package/dist/graph/graph.d.ts

@@ -7,8 +7,8 @@ type EndsMap = {
 };
 declare class Branch {
     condition: CallableFunction;
-    ends: EndsMap;
-    constructor(condition: CallableFunction, ends: EndsMap);
+    ends?: EndsMap;
+    constructor(condition: CallableFunction, ends?: EndsMap);
     runnable(input: any, options?: {
         config?: RunnableConfig;
     }): Runnable;
@@ -21,7 +21,7 @@ export declare class Graph<RunInput = any, RunOutput = any> {
     constructor();
     addNode(key: string, action: RunnableLike<RunInput, RunOutput>): void;
     addEdge(startKey: string, endKey: string): void;
-    addConditionalEdges(startKey: string, condition: CallableFunction, conditionalEdgeMapping: Record<string, string>): void;
+    addConditionalEdges(startKey: string, condition: CallableFunction, conditionalEdgeMapping?: Record<string, string>): void;
     setEntryPoint(key: string): void;
     setFinishPoint(key: string): void;
     compile(checkpointer?: BaseCheckpointSaver): Pregel;

package/dist/graph/graph.js

@@ -21,7 +21,13 @@ class Branch {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     runnable(input, options) {
         const result = this.condition(input, options?.config);
-        const destination = this.ends[result];
+        let destination;
+        if (this.ends) {
+            destination = this.ends[result];
+        }
+        else {
+            destination = result;
+        }
         return Channel.writeTo(destination !== END ? `${destination}:inbox` : END);
     }
 }
@@ -87,9 +93,13 @@ export class Graph {
         if (condition.constructor.name === "AsyncFunction") {
             throw new Error("Condition cannot be an async function");
         }
-        for (const destination of Object.values(conditionalEdgeMapping)) {
-            if (!this.nodes[destination] && destination !== END) {
-                throw new Error(`Need to addNode \`${destination}\` first`);
+        if (conditionalEdgeMapping) {
+            const mappingValues = Array.from(Object.values(conditionalEdgeMapping));
+            const nodesValues = Object.keys(this.nodes);
+            const endExcluded = mappingValues.filter((value) => value !== END);
+            const difference = endExcluded.filter((value) => !nodesValues.some((nv) => nv === value));
+            if (difference.length > 0) {
+                throw new Error(`Missing nodes which are in conditional edge mapping.\nMapping contains possible destinations: ${mappingValues.join(", ")}.\nPossible nodes are ${nodesValues.join(", ")}.`);
             }
         }
         if (!this.branches[startKey]) {
@@ -155,17 +165,22 @@ export class Graph {
     }
     validate() {
         const allStarts = new Set([...this.edges].map(([src, _]) => src).concat(Object.keys(this.branches)));
-        const allEnds = new Set([...this.edges]
-            .map(([_, end]) => end)
-            .concat(...Object.values(this.branches).flatMap((branchList) => branchList.flatMap((branch) => Object.values(branch.ends))))
-            .concat(this.entryPoint ? [this.entryPoint] : []));
         for (const node of Object.keys(this.nodes)) {
-            if (!allEnds.has(node)) {
-                throw new Error(`Node \`${node}\` is not reachable`);
-            }
             if (!allStarts.has(node)) {
                 throw new Error(`Node \`${node}\` is a dead-end`);
             }
         }
+        const allEndsAreDefined = Object.values(this.branches).every((branchList) => branchList.every((branch) => branch.ends !== null));
+        if (allEndsAreDefined) {
+            const allEnds = new Set([...this.edges]
+                .map(([_, end]) => end)
+                .concat(...Object.values(this.branches).flatMap((branchList) => branchList.flatMap((branch) => Object.values(branch.ends ?? {}))))
+                .concat(this.entryPoint ? [this.entryPoint] : []));
+            for (const node of Object.keys(this.nodes)) {
+                if (!allEnds.has(node)) {
+                    throw new Error(`Node \`${node}\` is not reachable`);
+                }
+            }
+        }
     }
 }

package/dist/graph/message.cjs

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageGraph = void 0;
+const state_js_1 = require("./state.cjs");
+function addMessages(left, right) {
+    const leftArray = Array.isArray(left) ? left : [left];
+    const rightArray = Array.isArray(right) ? right : [right];
+    return [...leftArray, ...rightArray];
+}
+class MessageGraph extends state_js_1.StateGraph {
+    constructor() {
+        super({
+            channels: {
+                value: (a, b) => addMessages(a, b),
+                default: () => [],
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            },
+        });
+    }
+}
+exports.MessageGraph = MessageGraph;

package/dist/graph/message.d.ts

@@ -0,0 +1,7 @@
+import { BaseMessage } from "@langchain/core/messages";
+import { StateGraph } from "./state.js";
+type Messages = Array<BaseMessage> | BaseMessage;
+export declare class MessageGraph<T extends Messages> extends StateGraph<T> {
+    constructor();
+}
+export {};

package/dist/graph/message.js

@@ -0,0 +1,17 @@
+import { StateGraph } from "./state.js";
+function addMessages(left, right) {
+    const leftArray = Array.isArray(left) ? left : [left];
+    const rightArray = Array.isArray(right) ? right : [right];
+    return [...leftArray, ...rightArray];
+}
+export class MessageGraph extends StateGraph {
+    constructor() {
+        super({
+            channels: {
+                value: (a, b) => addMessages(a, b),
+                default: () => [],
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            },
+        });
+    }
+}

package/dist/graph/state.cjs

@@ -20,12 +20,26 @@ class StateGraph extends graph_js_1.Graph {
         });
         this.channels = _getChannels(fields.channels);
     }
+    addNode(key, action) {
+        if (Object.keys(this.nodes).some((key) => 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);
+    }
     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");
         }
         const stateKeys = Object.keys(this.channels);
+        const stateKeysRead = 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 = {};
         for (const [start, end] of this.edges) {
             if (!outgoingEdges[start]) {
@@ -38,7 +52,9 @@ class StateGraph extends graph_js_1.Graph {
         for (const [key, node] of Object.entries(this.nodes)) {
             nodes[key] = index_js_1.Channel.subscribeTo(`${key}:inbox`)
                 .pipe(node)
-                .pipe(_updateState)
+                .pipe((
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            input, options) => updateState(key, input, options))
                 .pipe(index_js_1.Channel.writeTo(key));
         }
         for (const key of Object.keys(this.nodes)) {
@@ -47,7 +63,7 @@ class StateGraph extends graph_js_1.Graph {
             if (outgoing || this.branches[key]) {
                 nodes[edgesKey] = index_js_1.Channel.subscribeTo(key, {
                     tags: ["langsmith:hidden"],
-                }).pipe(new read_js_1.ChannelRead(stateKeys));
+                }).pipe(new read_js_1.ChannelRead(stateKeysRead));
             }
             if (outgoing) {
                 nodes[edgesKey] = nodes[edgesKey].pipe(index_js_1.Channel.writeTo(...outgoing));
@@ -63,12 +79,14 @@ class StateGraph extends graph_js_1.Graph {
         nodes[exports.START] = index_js_1.Channel.subscribeTo(`${exports.START}:inbox`, {
             tags: ["langsmith:hidden"],
         })
-            .pipe(_updateState)
+            .pipe((
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        input, options) => updateState(exports.START, input, options))
             .pipe(index_js_1.Channel.writeTo(exports.START));
         nodes[`${exports.START}:edges`] = index_js_1.Channel.subscribeTo(exports.START, {
             tags: ["langsmith:hidden"],
         })
-            .pipe(new read_js_1.ChannelRead(stateKeys))
+            .pipe(new read_js_1.ChannelRead(stateKeysRead))
             .pipe(index_js_1.Channel.writeTo(`${this.entryPoint}:inbox`));
         return new index_js_1.Pregel({
             nodes,
@@ -83,7 +101,7 @@ class StateGraph extends graph_js_1.Graph {
     }
 }
 exports.StateGraph = StateGraph;
-function _updateState(
+function _updateStateObject(stateKeys, nodeName, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 input, options
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -91,10 +109,30 @@ input, options
     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(",")}`);
+    }
     write_js_1.ChannelWrite.doWrite(options.config, input);
     return input;
 }
+function _updateStateRoot(_nodeName, input, options) {
+    if (!options?.config) {
+        throw new Error("Config not found when updating state.");
+    }
+    write_js_1.ChannelWrite.doWrite(options.config, {
+        __root__: input,
+    });
+    return input;
+}
 function _getChannels(schema) {
+    if ("value" in schema && "default" in schema) {
+        if (!schema.value) {
+            throw new Error("Value is required for channels");
+        }
+        return {
+            __root__: new binop_js_1.BinaryOperatorAggregate(schema.value, schema.default),
+        };
+    }
     const channels = {};
     for (const [name, values] of Object.entries(schema)) {
         if (values.value) {

package/dist/graph/state.d.ts

@@ -1,3 +1,4 @@
+import { RunnableLike } from "@langchain/core/runnables";
 import { BaseChannel } from "../channels/base.js";
 import { BinaryOperator } from "../channels/binop.js";
 import { Graph } from "./graph.js";
@@ -10,10 +11,14 @@ export interface StateGraphArgs<Channels extends Record<string, any>> {
             value: BinaryOperator<Channels[K]> | null;
             default?: () => Channels[K];
         };
+    } | {
+        value: BinaryOperator<unknown> | null;
+        default?: () => unknown;
     };
 }
 export declare class StateGraph<Channels extends Record<string, any>> extends Graph<Channels> {
     channels: Record<string, BaseChannel>;
     constructor(fields: StateGraphArgs<Channels>);
+    addNode(key: string, action: RunnableLike): void;
     compile(checkpointer?: BaseCheckpointSaver): Pregel;
 }

package/dist/graph/state.js

@@ -1,4 +1,4 @@
-import { RunnableLambda } from "@langchain/core/runnables";
+import { RunnableLambda, } from "@langchain/core/runnables";
 import { BinaryOperatorAggregate } from "../channels/binop.js";
 import { END, Graph } from "./graph.js";
 import { LastValue } from "../channels/last_value.js";
@@ -17,12 +17,26 @@ export class StateGraph extends Graph {
         });
         this.channels = _getChannels(fields.channels);
     }
+    addNode(key, action) {
+        if (Object.keys(this.nodes).some((key) => 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);
+    }
     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");
         }
         const stateKeys = Object.keys(this.channels);
+        const stateKeysRead = 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 = {};
         for (const [start, end] of this.edges) {
             if (!outgoingEdges[start]) {
@@ -35,7 +49,9 @@ export class StateGraph extends Graph {
         for (const [key, node] of Object.entries(this.nodes)) {
             nodes[key] = Channel.subscribeTo(`${key}:inbox`)
                 .pipe(node)
-                .pipe(_updateState)
+                .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)) {
@@ -44,7 +60,7 @@ export class StateGraph extends Graph {
             if (outgoing || this.branches[key]) {
                 nodes[edgesKey] = Channel.subscribeTo(key, {
                     tags: ["langsmith:hidden"],
-                }).pipe(new ChannelRead(stateKeys));
+                }).pipe(new ChannelRead(stateKeysRead));
             }
             if (outgoing) {
                 nodes[edgesKey] = nodes[edgesKey].pipe(Channel.writeTo(...outgoing));
@@ -60,12 +76,14 @@ export class StateGraph extends Graph {
         nodes[START] = Channel.subscribeTo(`${START}:inbox`, {
             tags: ["langsmith:hidden"],
         })
-            .pipe(_updateState)
+            .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(stateKeys))
+            .pipe(new ChannelRead(stateKeysRead))
             .pipe(Channel.writeTo(`${this.entryPoint}:inbox`));
         return new Pregel({
             nodes,
@@ -79,7 +97,7 @@ export class StateGraph extends Graph {
         });
     }
 }
-function _updateState(
+function _updateStateObject(stateKeys, nodeName, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 input, options
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -87,10 +105,30 @@ input, options
     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(",")}`);
+    }
     ChannelWrite.doWrite(options.config, input);
     return input;
 }
+function _updateStateRoot(_nodeName, input, options) {
+    if (!options?.config) {
+        throw new Error("Config not found when updating state.");
+    }
+    ChannelWrite.doWrite(options.config, {
+        __root__: input,
+    });
+    return input;
+}
 function _getChannels(schema) {
+    if ("value" in schema && "default" in schema) {
+        if (!schema.value) {
+            throw new Error("Value is required for channels");
+        }
+        return {
+            __root__: new BinaryOperatorAggregate(schema.value, schema.default),
+        };
+    }
     const channels = {};
     for (const [name, values] of Object.entries(schema)) {
         if (values.value) {

package/dist/prebuilt/chat_agent_executor.d.ts

@@ -1,4 +1,4 @@
-import { Tool } from "@langchain/core/tools";
+import { StructuredTool } from "@langchain/core/tools";
 import { BaseMessage } from "@langchain/core/messages";
 import { ToolExecutor } from "./tool_executor.js";
 export type FunctionCallingExecutorState = {
@@ -6,5 +6,5 @@ export type FunctionCallingExecutorState = {
 };
 export declare function createFunctionCallingExecutor<Model extends object>({ model, tools, }: {
     model: Model;
-    tools: Array<Tool> | ToolExecutor;
+    tools: Array<StructuredTool> | ToolExecutor;
 }): import("../pregel/index.js").Pregel;

package/dist/prebuilt/tool_executor.d.ts

@@ -1,7 +1,7 @@
 import { RunnableBinding, RunnableConfig } from "@langchain/core/runnables";
-import { Tool } from "@langchain/core/tools";
+import { StructuredTool } from "@langchain/core/tools";
 export interface ToolExecutorArgs {
-    tools: Array<Tool>;
+    tools: Array<StructuredTool>;
     /**
      * @default {INVALID_TOOL_MSG_TEMPLATE}
      */
@@ -18,8 +18,8 @@ type ToolExecutorInputType = any;
 type ToolExecutorOutputType = any;
 export declare class ToolExecutor extends RunnableBinding<ToolExecutorInputType, ToolExecutorOutputType> {
     lc_graph_name: string;
-    tools: Array<Tool>;
-    toolMap: Record<string, Tool>;
+    tools: Array<StructuredTool>;
+    toolMap: Record<string, StructuredTool>;
     invalidToolMsgTemplate: string;
     constructor(fields: ToolExecutorArgs);
     _execute(toolInvocation: ToolInvocationInterface, config?: RunnableConfig): Promise<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "LangGraph",
   "type": "module",
   "engines": {