@langchain/langgraph 0.0.1

package/dist/checkpoint/index.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCheckpointSaver = exports.emptyCheckpoint = exports.MemorySaver = void 0;
+var memory_js_1 = require("./memory.cjs");
+Object.defineProperty(exports, "MemorySaver", { enumerable: true, get: function () { return memory_js_1.MemorySaver; } });
+var base_js_1 = require("./base.cjs");
+Object.defineProperty(exports, "emptyCheckpoint", { enumerable: true, get: function () { return base_js_1.emptyCheckpoint; } });
+Object.defineProperty(exports, "BaseCheckpointSaver", { enumerable: true, get: function () { return base_js_1.BaseCheckpointSaver; } });

package/dist/checkpoint/index.d.ts

@@ -0,0 +1,2 @@
+export { MemorySaver } from "./memory.js";
+export { type ConfigurableFieldSpec, type Checkpoint, type CheckpointAt, emptyCheckpoint, BaseCheckpointSaver, } from "./base.js";

package/dist/checkpoint/index.js

@@ -0,0 +1,2 @@
+export { MemorySaver } from "./memory.js";
+export { emptyCheckpoint, BaseCheckpointSaver, } from "./base.js";

package/dist/checkpoint/memory.cjs

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemorySaver = void 0;
+const base_js_1 = require("./base.cjs");
+class MemorySaver extends base_js_1.BaseCheckpointSaver {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "storage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+    }
+    get configSpecs() {
+        return [
+            {
+                id: "threadId",
+                name: "Thread ID",
+                annotation: null,
+                description: null,
+                default: null,
+                isShared: true,
+                dependencies: null,
+            },
+        ];
+    }
+    get(config) {
+        return this.storage[config.configurable?.threadId];
+    }
+    put(config, checkpoint) {
+        this.storage[config.configurable?.threadId] = checkpoint;
+    }
+}
+exports.MemorySaver = MemorySaver;

package/dist/checkpoint/memory.d.ts

@@ -0,0 +1,8 @@
+import { RunnableConfig } from "@langchain/core/runnables";
+import { BaseCheckpointSaver, Checkpoint, ConfigurableFieldSpec } from "./base.js";
+export declare class MemorySaver extends BaseCheckpointSaver {
+    storage: Record<string, Checkpoint>;
+    get configSpecs(): ConfigurableFieldSpec[];
+    get(config: RunnableConfig): Checkpoint | undefined;
+    put(config: RunnableConfig, checkpoint: Checkpoint): void;
+}

package/dist/checkpoint/memory.js

@@ -0,0 +1,31 @@
+import { BaseCheckpointSaver, } from "./base.js";
+export class MemorySaver extends BaseCheckpointSaver {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "storage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+    }
+    get configSpecs() {
+        return [
+            {
+                id: "threadId",
+                name: "Thread ID",
+                annotation: null,
+                description: null,
+                default: null,
+                isShared: true,
+                dependencies: null,
+            },
+        ];
+    }
+    get(config) {
+        return this.storage[config.configurable?.threadId];
+    }
+    put(config, checkpoint) {
+        this.storage[config.configurable?.threadId] = checkpoint;
+    }
+}

package/dist/constants.cjs

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

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const CONFIG_KEY_SEND = "__pregel_send";
+export declare const CONFIG_KEY_READ = "__pregel_read";

package/dist/constants.js

@@ -0,0 +1,2 @@
+export const CONFIG_KEY_SEND = "__pregel_send";
+export const CONFIG_KEY_READ = "__pregel_read";

package/dist/graph/graph.cjs

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Graph = exports.END = void 0;
+const runnables_1 = require("@langchain/core/runnables");
+const index_js_1 = require("../pregel/index.cjs");
+exports.END = "__end__";
+class Branch {
+    constructor(condition, ends) {
+        Object.defineProperty(this, "condition", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ends", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.condition = condition;
+        this.ends = ends;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    runnable(input, options) {
+        const result = this.condition(input, options?.config);
+        const destination = this.ends[result];
+        return index_js_1.Channel.writeTo(destination !== exports.END ? `${destination}:inbox` : exports.END);
+    }
+}
+class Graph {
+    constructor() {
+        Object.defineProperty(this, "nodes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "edges", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "branches", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "entryPoint", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.nodes = {};
+        this.edges = new Set();
+        this.branches = {};
+    }
+    addNode(key, action) {
+        if (this.nodes[key]) {
+            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);
+    }
+    addEdge(startKey, endKey) {
+        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`);
+        }
+        // TODO: support multiple message passing
+        if (Array.from(this.edges).some(([start]) => start === startKey)) {
+            throw new Error(`Already found path for ${startKey}`);
+        }
+        this.edges.add([startKey, endKey]);
+    }
+    addConditionalEdges(startKey, condition, conditionalEdgeMapping) {
+        if (!this.nodes[startKey]) {
+            throw new Error(`Need to addNode \`${startKey}\` first`);
+        }
+        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 (!this.branches[startKey]) {
+            this.branches[startKey] = [];
+        }
+        this.branches[startKey].push(new Branch(condition, conditionalEdgeMapping));
+    }
+    setEntryPoint(key) {
+        if (!this.nodes[key]) {
+            throw new Error(`Need to addNode \`${key}\` first`);
+        }
+        this.entryPoint = key;
+    }
+    setFinishPoint(key) {
+        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);
+        });
+        const nodes = {};
+        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"],
+                });
+            }
+            if (outgoing) {
+                nodes[edgesKey] = nodes[edgesKey].pipe(index_js_1.Channel.writeTo(...outgoing));
+            }
+            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);
+                });
+            }
+        }
+        const hidden = Object.keys(this.nodes).map((node) => `${node}:inbox`);
+        if (!this.entryPoint) {
+            throw new Error("Entry point not set");
+        }
+        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)));
+        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`);
+            }
+        }
+    }
+}
+exports.Graph = Graph;

package/dist/graph/graph.d.ts

@@ -0,0 +1,30 @@
+import { Runnable, RunnableConfig, RunnableLike } from "@langchain/core/runnables";
+import { Pregel } from "../pregel/index.js";
+import { BaseCheckpointSaver } from "../checkpoint/base.js";
+export declare const END = "__end__";
+type EndsMap = {
+    [result: string]: string;
+};
+declare class Branch {
+    condition: CallableFunction;
+    ends: EndsMap;
+    constructor(condition: CallableFunction, ends: EndsMap);
+    runnable(input: any, options?: {
+        config?: RunnableConfig;
+    }): Runnable;
+}
+export declare class Graph<RunInput = any, RunOutput = any> {
+    nodes: Record<string, Runnable<RunInput, RunOutput>>;
+    edges: Set<[string, string]>;
+    branches: Record<string, Branch[]>;
+    entryPoint?: string;
+    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;
+    setEntryPoint(key: string): void;
+    setFinishPoint(key: string): void;
+    compile(checkpointer?: BaseCheckpointSaver): Pregel;
+    validate(): void;
+}
+export {};

package/dist/graph/graph.js

@@ -0,0 +1,171 @@
+import { RunnableLambda, _coerceToRunnable, } from "@langchain/core/runnables";
+import { Channel, Pregel } from "../pregel/index.js";
+export const END = "__end__";
+class Branch {
+    constructor(condition, ends) {
+        Object.defineProperty(this, "condition", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ends", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.condition = condition;
+        this.ends = ends;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    runnable(input, options) {
+        const result = this.condition(input, options?.config);
+        const destination = this.ends[result];
+        return Channel.writeTo(destination !== END ? `${destination}:inbox` : END);
+    }
+}
+export class Graph {
+    constructor() {
+        Object.defineProperty(this, "nodes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "edges", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "branches", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "entryPoint", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.nodes = {};
+        this.edges = new Set();
+        this.branches = {};
+    }
+    addNode(key, action) {
+        if (this.nodes[key]) {
+            throw new Error(`Node \`${key}\` already present.`);
+        }
+        if (key === END) {
+            throw new Error(`Node \`${key}\` is reserved.`);
+        }
+        this.nodes[key] = _coerceToRunnable(action);
+    }
+    addEdge(startKey, endKey) {
+        if (startKey === 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 !== END) {
+            throw new Error(`Need to addNode \`${endKey}\` first`);
+        }
+        // TODO: support multiple message passing
+        if (Array.from(this.edges).some(([start]) => start === startKey)) {
+            throw new Error(`Already found path for ${startKey}`);
+        }
+        this.edges.add([startKey, endKey]);
+    }
+    addConditionalEdges(startKey, condition, conditionalEdgeMapping) {
+        if (!this.nodes[startKey]) {
+            throw new Error(`Need to addNode \`${startKey}\` first`);
+        }
+        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 (!this.branches[startKey]) {
+            this.branches[startKey] = [];
+        }
+        this.branches[startKey].push(new Branch(condition, conditionalEdgeMapping));
+    }
+    setEntryPoint(key) {
+        if (!this.nodes[key]) {
+            throw new Error(`Need to addNode \`${key}\` first`);
+        }
+        this.entryPoint = key;
+    }
+    setFinishPoint(key) {
+        this.addEdge(key, END);
+    }
+    compile(checkpointer) {
+        this.validate();
+        const outgoingEdges = {};
+        this.edges.forEach(([start, end]) => {
+            if (!outgoingEdges[start]) {
+                outgoingEdges[start] = [];
+            }
+            outgoingEdges[start].push(end !== END ? `${end}:inbox` : END);
+        });
+        const nodes = {};
+        for (const [key, node] of Object.entries(this.nodes)) {
+            nodes[key] = Channel.subscribeTo(`${key}:inbox`)
+                .pipe(node)
+                .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"],
+                });
+            }
+            if (outgoing) {
+                nodes[edgesKey] = nodes[edgesKey].pipe(Channel.writeTo(...outgoing));
+            }
+            if (this.branches[key]) {
+                this.branches[key].forEach((branch) => {
+                    const runnableLambda = new RunnableLambda({
+                        func: (input) => branch.runnable(input),
+                    });
+                    nodes[edgesKey] = nodes[edgesKey].pipe(runnableLambda);
+                });
+            }
+        }
+        const hidden = Object.keys(this.nodes).map((node) => `${node}:inbox`);
+        if (!this.entryPoint) {
+            throw new Error("Entry point not set");
+        }
+        return new Pregel({
+            nodes,
+            input: `${this.entryPoint}:inbox`,
+            output: END,
+            hidden,
+            checkpointer,
+        });
+    }
+    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`);
+            }
+        }
+    }
+}

package/dist/graph/index.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateGraph = exports.START = exports.Graph = exports.END = void 0;
+var graph_js_1 = require("./graph.cjs");
+Object.defineProperty(exports, "END", { enumerable: true, get: function () { return graph_js_1.END; } });
+Object.defineProperty(exports, "Graph", { enumerable: true, get: function () { return graph_js_1.Graph; } });
+var state_js_1 = require("./state.cjs");
+Object.defineProperty(exports, "START", { enumerable: true, get: function () { return state_js_1.START; } });
+Object.defineProperty(exports, "StateGraph", { enumerable: true, get: function () { return state_js_1.StateGraph; } });

package/dist/graph/index.d.ts

@@ -0,0 +1,2 @@
+export { END, Graph } from "./graph.js";
+export { type StateGraphArgs, START, StateGraph } from "./state.js";

package/dist/graph/index.js

@@ -0,0 +1,2 @@
+export { END, Graph } from "./graph.js";
+export { START, StateGraph } from "./state.js";

package/dist/graph/state.cjs

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateGraph = exports.START = void 0;
+const runnables_1 = require("@langchain/core/runnables");
+const binop_js_1 = require("../channels/binop.cjs");
+const graph_js_1 = require("./graph.cjs");
+const last_value_js_1 = require("../channels/last_value.cjs");
+const write_js_1 = require("../pregel/write.cjs");
+const index_js_1 = require("../pregel/index.cjs");
+const read_js_1 = require("../pregel/read.cjs");
+exports.START = "__start__";
+class StateGraph extends graph_js_1.Graph {
+    constructor(fields) {
+        super();
+        Object.defineProperty(this, "channels", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.channels = _getChannels(fields.channels);
+    }
+    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 outgoingEdges = {};
+        for (const [start, end] of this.edges) {
+            if (!outgoingEdges[start]) {
+                outgoingEdges[start] = [];
+            }
+            outgoingEdges[start].push(end !== graph_js_1.END ? `${end}:inbox` : graph_js_1.END);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const nodes = {};
+        for (const [key, node] of Object.entries(this.nodes)) {
+            nodes[key] = index_js_1.Channel.subscribeTo(`${key}:inbox`)
+                .pipe(node)
+                .pipe(_updateState)
+                .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"],
+                }).pipe(new read_js_1.ChannelRead(stateKeys));
+            }
+            if (outgoing) {
+                nodes[edgesKey] = nodes[edgesKey].pipe(index_js_1.Channel.writeTo(...outgoing));
+            }
+            if (this.branches[key]) {
+                for (const branch of this.branches[key]) {
+                    nodes[edgesKey] = nodes[edgesKey].pipe(new runnables_1.RunnableLambda({
+                        func: (i, c) => branch.runnable(i, c),
+                    }));
+                }
+            }
+        }
+        nodes[exports.START] = index_js_1.Channel.subscribeTo(`${exports.START}:inbox`, {
+            tags: ["langsmith:hidden"],
+        })
+            .pipe(_updateState)
+            .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(index_js_1.Channel.writeTo(`${this.entryPoint}:inbox`));
+        return new index_js_1.Pregel({
+            nodes,
+            channels: this.channels,
+            input: `${exports.START}:inbox`,
+            output: graph_js_1.END,
+            hidden: Object.keys(this.nodes)
+                .map((node) => `${node}:inbox`)
+                .concat(exports.START, stateKeys),
+            checkpointer,
+        });
+    }
+}
+exports.StateGraph = StateGraph;
+function _updateState(
+// 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.");
+    }
+    write_js_1.ChannelWrite.doWrite(options.config, input);
+    return input;
+}
+function _getChannels(schema) {
+    const channels = {};
+    for (const [name, values] of Object.entries(schema)) {
+        if (values.value) {
+            channels[name] = new binop_js_1.BinaryOperatorAggregate(values.value, values.default);
+        }
+        else {
+            channels[name] = new last_value_js_1.LastValue();
+        }
+    }
+    return channels;
+}

package/dist/graph/state.d.ts

@@ -0,0 +1,17 @@
+import { BaseChannel } from "../channels/base.js";
+import { BinaryOperator } from "../channels/binop.js";
+import { Graph } from "./graph.js";
+import { BaseCheckpointSaver } from "../checkpoint/base.js";
+import { Pregel } from "../pregel/index.js";
+export declare const START = "__start__";
+export interface StateGraphArgs<T = any> {
+    channels: Record<string, {
+        value: BinaryOperator<T> | null;
+        default?: () => T;
+    }>;
+}
+export declare class StateGraph<T> extends Graph {
+    channels: Record<string, BaseChannel>;
+    constructor(fields: StateGraphArgs<T>);
+    compile(checkpointer?: BaseCheckpointSaver): Pregel;
+}