@langchain/langgraph 0.0.12 → 0.0.13

package/dist/checkpoint/sqlite.js

@@ -0,0 +1,163 @@
+import Database from "better-sqlite3";
+import { BaseCheckpointSaver, } from "./base.js";
+export class SqliteSaver extends BaseCheckpointSaver {
+    constructor(db, serde) {
+        super(serde);
+        Object.defineProperty(this, "db", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "isSetup", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.db = db;
+        this.isSetup = false;
+    }
+    static fromConnString(connStringOrLocalPath) {
+        return new SqliteSaver(new Database(connStringOrLocalPath));
+    }
+    setup() {
+        if (this.isSetup) {
+            return;
+        }
+        try {
+            this.db.pragma("journal_mode=WAL");
+            this.db.exec(`
+CREATE TABLE IF NOT EXISTS checkpoints (
+  thread_id TEXT NOT NULL,
+  checkpoint_id TEXT NOT NULL,
+  parent_id TEXT,
+  checkpoint BLOB,
+  metadata BLOB,
+  PRIMARY KEY (thread_id, checkpoint_id)
+);`);
+        }
+        catch (error) {
+            console.log("Error creating checkpoints table", error);
+            throw error;
+        }
+        this.isSetup = true;
+    }
+    async getTuple(config) {
+        this.setup();
+        const thread_id = config.configurable?.thread_id;
+        const checkpoint_id = config.configurable?.checkpoint_id;
+        if (checkpoint_id) {
+            try {
+                const row = this.db
+                    .prepare(`SELECT checkpoint, parent_id, metadata FROM checkpoints WHERE thread_id = ? AND checkpoint_id = ?`)
+                    .get(thread_id, checkpoint_id);
+                if (row) {
+                    return {
+                        config,
+                        checkpoint: this.serde.parse(row.checkpoint),
+                        metadata: this.serde.parse(row.metadata),
+                        parentConfig: row.parent_id
+                            ? {
+                                configurable: {
+                                    thread_id,
+                                    checkpoint_id: row.parent_id,
+                                },
+                            }
+                            : undefined,
+                    };
+                }
+            }
+            catch (error) {
+                console.log("Error retrieving checkpoint", error);
+                throw error;
+            }
+        }
+        else {
+            const row = this.db
+                .prepare(`SELECT thread_id, checkpoint_id, parent_id, checkpoint, metadata FROM checkpoints WHERE thread_id = ? ORDER BY checkpoint_id DESC LIMIT 1`)
+                .get(thread_id);
+            if (row) {
+                return {
+                    config: {
+                        configurable: {
+                            thread_id: row.thread_id,
+                            checkpoint_id: row.checkpoint_id,
+                        },
+                    },
+                    checkpoint: this.serde.parse(row.checkpoint),
+                    metadata: this.serde.parse(row.metadata),
+                    parentConfig: row.parent_id
+                        ? {
+                            configurable: {
+                                thread_id: row.thread_id,
+                                checkpoint_id: row.parent_id,
+                            },
+                        }
+                        : undefined,
+                };
+            }
+        }
+        return undefined;
+    }
+    async *list(config) {
+        this.setup();
+        const thread_id = config.configurable?.thread_id;
+        try {
+            const rows = this.db
+                .prepare(`SELECT thread_id, checkpoint_id, parent_id, checkpoint, metadata FROM checkpoints WHERE thread_id = ? ORDER BY checkpoint_id DESC`)
+                .all(thread_id);
+            if (rows) {
+                for (const row of rows) {
+                    yield {
+                        config: {
+                            configurable: {
+                                thread_id: row.thread_id,
+                                checkpoint_id: row.checkpoint_id,
+                            },
+                        },
+                        checkpoint: this.serde.parse(row.checkpoint),
+                        metadata: this.serde.parse(row.metadata),
+                        parentConfig: row.parent_id
+                            ? {
+                                configurable: {
+                                    thread_id: row.thread_id,
+                                    checkpoint_id: row.parent_id,
+                                },
+                            }
+                            : undefined,
+                    };
+                }
+            }
+        }
+        catch (error) {
+            console.log("Error listing checkpoints", error);
+            throw error;
+        }
+    }
+    async put(config, checkpoint, metadata) {
+        this.setup();
+        try {
+            const row = [
+                config.configurable?.thread_id,
+                checkpoint.id,
+                config.configurable?.checkpoint_id,
+                this.serde.stringify(checkpoint),
+                this.serde.stringify(metadata),
+            ];
+            this.db
+                .prepare(`INSERT OR REPLACE INTO checkpoints (thread_id, checkpoint_id, parent_id, checkpoint, metadata) VALUES (?, ?, ?, ?, ?)`)
+                .run(...row);
+        }
+        catch (error) {
+            console.log("Error saving checkpoint", error);
+            throw error;
+        }
+        return {
+            configurable: {
+                thread_id: config.configurable?.thread_id,
+                checkpoint_id: checkpoint.id,
+            },
+        };
+    }
+}

package/dist/constants.cjs

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONFIG_KEY_READ = exports.CONFIG_KEY_SEND = void 0;
+exports.TAG_HIDDEN = exports.INTERRUPT = exports.CONFIG_KEY_READ = exports.CONFIG_KEY_SEND = void 0;
 exports.CONFIG_KEY_SEND = "__pregel_send";
 exports.CONFIG_KEY_READ = "__pregel_read";
+exports.INTERRUPT = "__interrupt__";
+exports.TAG_HIDDEN = "langsmith:hidden";

package/dist/constants.d.ts

@@ -1,2 +1,4 @@
 export declare const CONFIG_KEY_SEND = "__pregel_send";
 export declare const CONFIG_KEY_READ = "__pregel_read";
+export declare const INTERRUPT = "__interrupt__";
+export declare const TAG_HIDDEN = "langsmith:hidden";

package/dist/constants.js

@@ -1,2 +1,4 @@
 export const CONFIG_KEY_SEND = "__pregel_send";
 export const CONFIG_KEY_READ = "__pregel_read";
+export const INTERRUPT = "__interrupt__";
+export const TAG_HIDDEN = "langsmith:hidden";

package/dist/errors.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidUpdateError = exports.EmptyChannelError = exports.GraphValueError = exports.GraphRecursionError = void 0;
+class GraphRecursionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GraphRecursionError";
+    }
+}
+exports.GraphRecursionError = GraphRecursionError;
+class GraphValueError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GraphValueError";
+    }
+}
+exports.GraphValueError = GraphValueError;
+class EmptyChannelError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "EmptyChannelError";
+    }
+}
+exports.EmptyChannelError = EmptyChannelError;
+class InvalidUpdateError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "InvalidUpdateError";
+    }
+}
+exports.InvalidUpdateError = InvalidUpdateError;

package/dist/errors.d.ts

@@ -0,0 +1,12 @@
+export declare class GraphRecursionError extends Error {
+    constructor(message?: string);
+}
+export declare class GraphValueError extends Error {
+    constructor(message?: string);
+}
+export declare class EmptyChannelError extends Error {
+    constructor(message?: string);
+}
+export declare class InvalidUpdateError extends Error {
+    constructor(message?: string);
+}

package/dist/errors.js

@@ -0,0 +1,24 @@
+export class GraphRecursionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GraphRecursionError";
+    }
+}
+export class GraphValueError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GraphValueError";
+    }
+}
+export class EmptyChannelError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "EmptyChannelError";
+    }
+}
+export class InvalidUpdateError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "InvalidUpdateError";
+    }
+}

package/dist/graph/graph.cjs

@@ -1,11 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Graph = exports.END = void 0;
+exports.CompiledGraph = exports.Graph = exports.Branch = exports.END = exports.START = void 0;
+/* eslint-disable @typescript-eslint/no-use-before-define */
 const runnables_1 = require("@langchain/core/runnables");
+const read_js_1 = require("../pregel/read.cjs");
 const index_js_1 = require("../pregel/index.cjs");
+const ephemeral_value_js_1 = require("../channels/ephemeral_value.cjs");
+const write_js_1 = require("../pregel/write.cjs");
+const constants_js_1 = require("../constants.cjs");
+const utils_js_1 = require("../utils.cjs");
+exports.START = "__start__";
 exports.END = "__end__";
 class Branch {
-    constructor(condition, ends) {
+    constructor(options) {
         Object.defineProperty(this, "condition", {
             enumerable: true,
             configurable: true,
@@ -18,23 +25,42 @@ class Branch {
             writable: true,
             value: void 0
         });
-        this.condition = condition;
-        this.ends = ends;
-    }
-    async runnable(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    input, options) {
-        const result = await this.condition(input, options?.config);
-        let destination;
+        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) => {
+                acc[n] = n;
+                return acc;
+            }, {})
+            : options.pathMap;
+        this.then = options.then;
+    }
+    compile(writer, reader) {
+        return write_js_1.ChannelWrite.registerWriter(new utils_js_1.RunnableCallable({
+            func: (input, config) => this._route(input, config, writer, reader),
+        }));
+    }
+    async _route(input, config, writer, reader) {
+        let result = await this.condition(reader ? reader(config) : input, config);
+        if (!Array.isArray(result)) {
+            result = [result];
+        }
+        let destinations;
         if (this.ends) {
-            destination = this.ends[result];
+            destinations = result.map((r) => this.ends[r]);
         }
         else {
-            destination = result;
+            destinations = result;
         }
-        return index_js_1.Channel.writeTo(destination !== exports.END ? `${destination}:inbox` : exports.END);
+        return writer(destinations);
     }
 }
+exports.Branch = Branch;
 class Graph {
     constructor() {
         Object.defineProperty(this, "nodes", {
@@ -67,6 +93,12 @@ class Graph {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "supportMultipleEdges", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         this.nodes = {};
         this.edges = new Set();
         this.branches = {};
@@ -76,126 +108,175 @@ class Graph {
             console.warn(message);
         }
     }
+    get allEdges() {
+        return this.edges;
+    }
     addNode(key, action) {
         this.warnIfCompiled(`Adding a node to a graph that has already been compiled. This will not be reflected in the compiled graph.`);
-        if (this.nodes[key]) {
+        if (key in this.nodes) {
             throw new Error(`Node \`${key}\` already present.`);
         }
         if (key === exports.END) {
             throw new Error(`Node \`${key}\` is reserved.`);
         }
         this.nodes[key] = (0, runnables_1._coerceToRunnable)(action);
+        return this;
     }
     addEdge(startKey, endKey) {
         this.warnIfCompiled(`Adding an edge to a graph that has already been compiled. This will not be reflected in the compiled graph.`);
         if (startKey === exports.END) {
             throw new Error("END cannot be a start node");
         }
-        if (!this.nodes[startKey]) {
-            throw new Error(`Need to addNode \`${startKey}\` first`);
-        }
-        if (!this.nodes[endKey] && endKey !== exports.END) {
-            throw new Error(`Need to addNode \`${endKey}\` first`);
+        if (endKey === exports.START) {
+            throw new Error("START cannot be an end node");
         }
-        // TODO: support multiple message passing
-        if (Array.from(this.edges).some(([start]) => start === startKey)) {
+        if (!this.supportMultipleEdges &&
+            Array.from(this.edges).some(([start]) => start === startKey)) {
             throw new Error(`Already found path for ${startKey}`);
         }
         this.edges.add([startKey, endKey]);
+        return this;
     }
-    addConditionalEdges(startKey, condition, conditionalEdgeMapping) {
+    addConditionalEdges(source, path, pathMap) {
+        const options = typeof source === "object" ? source : { source, path: path, pathMap };
         this.warnIfCompiled("Adding an edge to a graph that has already been compiled. This will not be reflected in the compiled graph.");
-        if (!this.nodes[startKey]) {
-            throw new Error(`Need to addNode \`${startKey}\` 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(", ")}.`);
-            }
+        // find a name for condition
+        const name = options.path.name || "condition";
+        // validate condition
+        if (this.branches[options.source] && this.branches[options.source][name]) {
+            throw new Error(`Condition \`${name}\` already present for node \`${source}\``);
         }
-        if (!this.branches[startKey]) {
-            this.branches[startKey] = [];
+        // save it
+        if (!this.branches[options.source]) {
+            this.branches[options.source] = {};
         }
-        this.branches[startKey].push(new Branch(condition, conditionalEdgeMapping));
+        this.branches[options.source][name] = new Branch(options);
+        return this;
     }
+    /**
+     * @deprecated use `addEdge(START, key)` instead
+     */
     setEntryPoint(key) {
         this.warnIfCompiled("Setting the entry point of a graph that has already been compiled. This will not be reflected in the compiled graph.");
-        if (!this.nodes[key]) {
-            throw new Error(`Need to addNode \`${key}\` first`);
-        }
-        this.entryPoint = key;
+        return this.addEdge(exports.START, key);
     }
+    /**
+     * @deprecated use `addEdge(key, END)` instead
+     */
     setFinishPoint(key) {
         this.warnIfCompiled("Setting a finish point of a graph that has already been compiled. This will not be reflected in the compiled graph.");
-        this.addEdge(key, exports.END);
-    }
-    compile(checkpointer) {
-        this.validate();
-        const outgoingEdges = {};
-        this.edges.forEach(([start, end]) => {
-            if (!outgoingEdges[start]) {
-                outgoingEdges[start] = [];
-            }
-            outgoingEdges[start].push(end !== exports.END ? `${end}:inbox` : exports.END);
+        return this.addEdge(key, exports.END);
+    }
+    compile({ checkpointer, interruptBefore, interruptAfter, } = {}) {
+        // validate the graph
+        this.validate([
+            ...(Array.isArray(interruptBefore) ? interruptBefore : []),
+            ...(Array.isArray(interruptAfter) ? interruptAfter : []),
+        ]);
+        // create empty compiled graph
+        const compiled = new CompiledGraph({
+            builder: this,
+            checkpointer,
+            interruptAfter,
+            interruptBefore,
+            autoValidate: false,
+            nodes: {},
+            channels: {
+                [exports.START]: new ephemeral_value_js_1.EphemeralValue(),
+                [exports.END]: new ephemeral_value_js_1.EphemeralValue(),
+            },
+            inputs: exports.START,
+            outputs: exports.END,
+            streamChannels: [],
+            streamMode: "values",
         });
-        const nodes = {};
+        // attach nodes, edges and branches
         for (const [key, node] of Object.entries(this.nodes)) {
-            nodes[key] = index_js_1.Channel.subscribeTo(`${key}:inbox`)
-                .pipe(node)
-                .pipe(index_js_1.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] = index_js_1.Channel.subscribeTo(key, {
-                    tags: ["langsmith:hidden"],
-                });
+            compiled.attachNode(key, node);
+        }
+        for (const [start, end] of this.edges) {
+            compiled.attachEdge(start, end);
+        }
+        for (const [start, branches] of Object.entries(this.branches)) {
+            for (const [name, branch] of Object.entries(branches)) {
+                compiled.attachBranch(start, name, branch);
             }
-            if (outgoing) {
-                nodes[edgesKey] = nodes[edgesKey].pipe(index_js_1.Channel.writeTo(...outgoing));
+        }
+        return compiled.validate();
+    }
+    validate(interrupt) {
+        // assemble sources
+        const allSources = new Set([...this.allEdges].map(([src, _]) => src));
+        for (const [start, branches] 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);
+                            }
+                        }
+                    }
+                }
             }
-            if (this.branches[key]) {
-                this.branches[key].forEach((branch) => {
-                    const runnableLambda = new runnables_1.RunnableLambda({
-                        func: (input) => branch.runnable(input),
-                    });
-                    nodes[edgesKey] = nodes[edgesKey].pipe(runnableLambda);
-                });
+        }
+        // validate sources
+        for (const node of Object.keys(this.nodes)) {
+            if (!allSources.has(node)) {
+                throw new Error(`Node \`${node}\` is a dead-end`);
             }
         }
-        const hidden = Object.keys(this.nodes).map((node) => `${node}:inbox`);
-        if (!this.entryPoint) {
-            throw new Error("Entry point not set");
+        for (const source of allSources) {
+            if (source !== exports.START && !(source in this.nodes)) {
+                throw new Error(`Found edge starting at unknown node \`${source}\``);
+            }
         }
-        return new index_js_1.Pregel({
-            nodes,
-            input: `${this.entryPoint}:inbox`,
-            output: exports.END,
-            hidden,
-            checkpointer,
-        });
-    }
-    validate() {
-        const allStarts = new Set([...this.edges].map(([src, _]) => src).concat(Object.keys(this.branches)));
+        // assemble targets
+        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);
+                    }
+                }
+                else {
+                    allTargets.add(exports.END);
+                    for (const node of Object.keys(this.nodes)) {
+                        if (node !== start && node !== branch.then) {
+                            allTargets.add(node);
+                        }
+                    }
+                }
+            }
+        }
+        // validate targets
         for (const node of Object.keys(this.nodes)) {
-            if (!allStarts.has(node)) {
-                throw new Error(`Node \`${node}\` is a dead-end`);
+            if (!allTargets.has(node)) {
+                throw new Error(`Node \`${node}\` is not reachable`);
+            }
+        }
+        for (const target of allTargets) {
+            if (target !== exports.END && !(target in this.nodes)) {
+                throw new Error(`Found edge ending at unknown node \`${target}\``);
             }
         }
-        const allEndsAreDefined = Object.values(this.branches).every((branchList) => branchList.every((branch) => branch.ends));
-        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`);
+        // validate interrupts
+        if (interrupt) {
+            for (const node of interrupt) {
+                if (!(node in this.nodes)) {
+                    throw new Error(`Interrupt node \`${node}\` is not present`);
                 }
             }
         }
@@ -203,3 +284,62 @@ class Graph {
     }
 }
 exports.Graph = Graph;
+class CompiledGraph extends index_js_1.Pregel {
+    constructor({ builder, ...rest }) {
+        super(rest);
+        Object.defineProperty(this, "builder", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.builder = builder;
+    }
+    attachNode(key, node) {
+        this.channels[key] = new ephemeral_value_js_1.EphemeralValue();
+        this.nodes[key] = new read_js_1.PregelNode({
+            channels: [],
+            triggers: [],
+        })
+            .pipe(node)
+            .pipe(new write_js_1.ChannelWrite([{ channel: key, value: write_js_1.PASSTHROUGH }], [constants_js_1.TAG_HIDDEN]));
+        this.streamChannels.push(key);
+    }
+    attachEdge(start, end) {
+        if (end === exports.END) {
+            if (start === exports.START) {
+                throw new Error("Cannot have an edge from START to END");
+            }
+            this.nodes[start].writers.push(new write_js_1.ChannelWrite([{ channel: exports.END, value: write_js_1.PASSTHROUGH }], [constants_js_1.TAG_HIDDEN]));
+        }
+        else {
+            this.nodes[end].triggers.push(start);
+            this.nodes[end].channels.push(start);
+        }
+    }
+    attachBranch(start, name, branch) {
+        // add hidden start node
+        if (start === exports.START && this.nodes[exports.START]) {
+            this.nodes[exports.START] = index_js_1.Channel.subscribeTo(exports.START, { tags: [constants_js_1.TAG_HIDDEN] });
+        }
+        // attach branch writer
+        this.nodes[start].pipe(branch.compile((dests) => {
+            const channels = dests.map((dest) => dest === exports.END ? exports.END : `branch:${start}:${name}:${dest}`);
+            return new write_js_1.ChannelWrite(channels.map((channel) => ({ channel, value: write_js_1.PASSTHROUGH })), [constants_js_1.TAG_HIDDEN]);
+        }));
+        // attach branch readers
+        const ends = branch.ends
+            ? Object.values(branch.ends)
+            : Object.keys(this.nodes);
+        for (const end of ends) {
+            if (end !== exports.END) {
+                const channelName = `branch:${start}:${name}:${end}`;
+                this.channels[channelName] =
+                    new ephemeral_value_js_1.EphemeralValue();
+                this.nodes[end].triggers.push(channelName);
+                this.nodes[end].channels.push(channelName);
+            }
+        }
+    }
+}
+exports.CompiledGraph = CompiledGraph;