@langchain/langgraph 0.0.11 → 0.0.13

package/dist/pregel/read.js

@@ -1,15 +1,14 @@
-import { RunnableBinding, RunnableLambda, RunnablePassthrough, _coerceToRunnable, } from "@langchain/core/runnables";
+import { RunnableBinding, RunnablePassthrough, RunnableSequence, _coerceToRunnable, } from "@langchain/core/runnables";
 import { CONFIG_KEY_READ } from "../constants.js";
-export class ChannelRead extends RunnableLambda {
-    constructor(channel) {
+import { ChannelWrite } from "./write.js";
+import { RunnableCallable } from "../utils.js";
+export class ChannelRead extends RunnableCallable {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(channel, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    mapper, fresh = false) {
         super({
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            func: (input, options) => {
-                if ("config" in options) {
-                    return this._read(input, options.config);
-                }
-                return this._read(input, options ?? {});
-            },
+            func: (_, config) => ChannelRead.doRead(config, this.channel, this.fresh, this.mapper),
         });
         Object.defineProperty(this, "lc_graph_name", {
             enumerable: true,
@@ -23,41 +22,44 @@ export class ChannelRead extends RunnableLambda {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "fresh", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "mapper", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.fresh = fresh;
+        this.mapper = mapper;
         this.channel = channel;
-        this.name = `ChannelRead<${channel}>`;
+        this.name = Array.isArray(channel)
+            ? `ChannelRead<${channel.join(",")}>`
+            : `ChannelRead<${channel}>`;
     }
-    get configSpecs() {
-        return [
-            {
-                id: CONFIG_KEY_READ,
-                name: CONFIG_KEY_READ,
-                description: null,
-                default: null,
-                // TODO FIX THIS
-                annotation: "Callable[[BaseChannel], Any]",
-                isShared: true,
-                dependencies: null,
-            },
-        ];
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    _read(_, config) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static doRead(config, channel, fresh, mapper) {
         const read = config.configurable?.[CONFIG_KEY_READ];
         if (!read) {
             throw new Error(`Runnable ${this} is not configured with a read function. Make sure to call in the context of a Pregel process`);
         }
-        if (Array.isArray(this.channel)) {
-            const results = Object.fromEntries(this.channel.map((chan) => [chan, read(chan)]));
-            return results;
+        if (mapper) {
+            return mapper(read(channel, fresh));
+        }
+        else {
+            return read(channel, fresh);
         }
-        return read(this.channel);
     }
 }
-const defaultRunnableBound = /* #__PURE__ */ new RunnablePassthrough();
-export class ChannelInvoke extends RunnableBinding {
+const defaultRunnableBound = 
+/* #__PURE__ */ new RunnablePassthrough();
+export class PregelNode extends RunnableBinding {
     constructor(fields) {
-        const { channels, triggers, when } = fields;
+        const { channels, triggers, mapper, writers, bound, kwargs } = fields;
         const mergedTags = [
             ...(fields.config?.tags ? fields.config.tags : []),
             ...(fields.tags ? fields.tags : []),
@@ -75,7 +77,7 @@ export class ChannelInvoke extends RunnableBinding {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: "ChannelInvoke"
+            value: "PregelNode"
         });
         Object.defineProperty(this, "channels", {
             enumerable: true,
@@ -90,48 +92,126 @@ export class ChannelInvoke extends RunnableBinding {
             value: []
         });
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        Object.defineProperty(this, "when", {
+        Object.defineProperty(this, "mapper", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "writers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "bound", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: defaultRunnableBound
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "kwargs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
         this.channels = channels;
         this.triggers = triggers;
-        this.when = when;
+        this.mapper = mapper;
+        this.writers = writers ?? this.writers;
+        this.bound = bound ?? this.bound;
+        this.kwargs = kwargs ?? this.kwargs;
+    }
+    getWriters() {
+        const newWriters = [...this.writers];
+        while (newWriters.length > 1 &&
+            // eslint-disable-next-line no-instanceof/no-instanceof
+            newWriters[newWriters.length - 1] instanceof ChannelWrite &&
+            // eslint-disable-next-line no-instanceof/no-instanceof
+            newWriters[newWriters.length - 2] instanceof ChannelWrite) {
+            // we can combine writes if they are consecutive
+            newWriters[newWriters.length - 2].writes.push(...newWriters[newWriters.length - 1].writes);
+            newWriters.pop();
+        }
+        return newWriters;
+    }
+    getNode() {
+        const writers = this.getWriters();
+        if (this.bound === defaultRunnableBound && writers.length === 0) {
+            return undefined;
+        }
+        else if (this.bound === defaultRunnableBound && writers.length === 1) {
+            return writers[0];
+        }
+        else if (this.bound === defaultRunnableBound) {
+            return new RunnableSequence({
+                first: writers[0],
+                middle: writers.slice(1, writers.length - 1),
+                last: writers[writers.length - 1],
+            });
+        }
+        else if (writers.length > 0) {
+            return new RunnableSequence({
+                first: this.bound,
+                middle: writers.slice(0, writers.length - 1),
+                last: writers[writers.length - 1],
+            });
+        }
+        else {
+            return this.bound;
+        }
     }
     join(channels) {
+        if (!Array.isArray(channels)) {
+            throw new Error("channels must be a list");
+        }
         if (typeof this.channels !== "object") {
             throw new Error("all channels must be named when using .join()");
         }
-        return new ChannelInvoke({
+        return new PregelNode({
             channels: {
                 ...this.channels,
                 ...Object.fromEntries(channels.map((chan) => [chan, chan])),
             },
             triggers: this.triggers,
-            when: this.when,
+            mapper: this.mapper,
+            writers: this.writers,
             bound: this.bound,
             kwargs: this.kwargs,
             config: this.config,
         });
     }
     pipe(coerceable) {
-        if (this.bound === defaultRunnableBound) {
-            return new ChannelInvoke({
+        if (ChannelWrite.isWriter(coerceable)) {
+            return new PregelNode({
+                channels: this.channels,
+                triggers: this.triggers,
+                mapper: this.mapper,
+                writers: [...this.writers, coerceable],
+                bound: this.bound,
+                config: this.config,
+                kwargs: this.kwargs,
+            });
+        }
+        else if (this.bound === defaultRunnableBound) {
+            return new PregelNode({
                 channels: this.channels,
                 triggers: this.triggers,
-                when: this.when,
+                mapper: this.mapper,
+                writers: this.writers,
                 bound: _coerceToRunnable(coerceable),
                 config: this.config,
                 kwargs: this.kwargs,
             });
         }
         else {
-            return new ChannelInvoke({
+            return new PregelNode({
                 channels: this.channels,
                 triggers: this.triggers,
-                when: this.when,
+                mapper: this.mapper,
+                writers: this.writers,
                 bound: this.bound.pipe(coerceable),
                 config: this.config,
                 kwargs: this.kwargs,

package/dist/pregel/types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/pregel/types.d.ts

@@ -0,0 +1,32 @@
+import { Runnable, RunnableConfig } from "@langchain/core/runnables";
+export interface PregelTaskDescription {
+    readonly name: string;
+    readonly input: unknown;
+}
+export interface PregelExecutableTask<N extends PropertyKey, C extends PropertyKey> {
+    readonly name: N;
+    readonly input: unknown;
+    readonly proc: Runnable;
+    readonly writes: Array<[C, unknown]>;
+    readonly config: RunnableConfig | undefined;
+}
+export interface StateSnapshot {
+    /**
+     * Current values of channels
+     */
+    readonly values: Record<string, any> | any;
+    /**
+     * Nodes to execute in the next step, if any
+     */
+    readonly next: Array<string>;
+    /**
+     * Config used to fetch this snapshot
+     */
+    readonly config: RunnableConfig;
+    /**
+     * Config used to fetch the parent snapshot, if any
+     * @default undefined
+     */
+    readonly parentConfig?: RunnableConfig | undefined;
+}
+export type All = "*";

package/dist/pregel/types.js

@@ -0,0 +1 @@
+export {};

package/dist/pregel/validate.cjs

@@ -1,86 +1,93 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateKeys = exports.validateGraph = void 0;
-const last_value_js_1 = require("../channels/last_value.cjs");
-const reserved_js_1 = require("./reserved.cjs");
-function validateGraph({ nodes, channels, input, output, hidden, interrupt, }) {
-    const newChannels = channels;
+exports.validateKeys = exports.validateGraph = exports.GraphValidationError = void 0;
+const constants_js_1 = require("../constants.cjs");
+const read_js_1 = require("./read.cjs");
+class GraphValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GraphValidationError";
+    }
+}
+exports.GraphValidationError = GraphValidationError;
+function validateGraph({ nodes, channels, inputChannels, outputChannels, streamChannels, interruptAfterNodes, interruptBeforeNodes, }) {
+    if (!channels) {
+        throw new GraphValidationError("Channels not provided");
+    }
     const subscribedChannels = new Set();
-    for (const node of Object.values(nodes)) {
-        if (node.lc_graph_name === "ChannelInvoke" && "channels" in node) {
-            if (typeof node.channels === "string") {
-                subscribedChannels.add(node.channels);
-            }
-            else {
-                Object.values(node.channels).map((channel) => subscribedChannels.add(channel));
-            }
+    const allOutputChannels = new Set();
+    for (const [name, node] of Object.entries(nodes)) {
+        if (name === constants_js_1.INTERRUPT) {
+            throw new GraphValidationError(`"Node name ${constants_js_1.INTERRUPT} is reserved"`);
+        }
+        if (node.constructor === read_js_1.PregelNode) {
+            node.triggers.forEach((trigger) => subscribedChannels.add(trigger));
         }
         else {
-            console.error(node);
-            throw new Error(`Invalid node type: ${JSON.stringify(node, null, 2)}, expected Channel.subscribeTo()`);
+            throw new GraphValidationError(`Invalid node type ${typeof node}, expected PregelNode`);
         }
     }
-    for (const chan of [...subscribedChannels]) {
-        if (!(chan in newChannels)) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            newChannels[chan] = new last_value_js_1.LastValue();
+    // side effect: update channels
+    for (const chan of subscribedChannels) {
+        if (!(chan in channels)) {
+            throw new GraphValidationError(`Subcribed channel '${String(chan)}' not in channels`);
         }
     }
-    if (typeof input === "string") {
-        if (!(input in newChannels)) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            newChannels[input] = new last_value_js_1.LastValue();
-        }
-        if (!subscribedChannels.has(input)) {
-            throw new Error(`Input channel ${input} is not subscribed to by any node.`);
+    if (!Array.isArray(inputChannels)) {
+        if (!subscribedChannels.has(inputChannels)) {
+            throw new GraphValidationError(`Input channel ${String(inputChannels)} is not subscribed to by any node`);
         }
     }
     else {
-        for (const chan of input) {
-            if (!(chan in newChannels)) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                newChannels[chan] = new last_value_js_1.LastValue();
-            }
-        }
-        if (input.every((chan) => !subscribedChannels.has(chan))) {
-            throw new Error(`None of the input channels ${input} are subscribed to by any node`);
+        if (inputChannels.every((channel) => !subscribedChannels.has(channel))) {
+            throw new GraphValidationError(`None of the input channels ${inputChannels} are subscribed to by any node`);
         }
     }
-    if (typeof output === "string") {
-        if (!(output in newChannels)) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            newChannels[output] = new last_value_js_1.LastValue();
-        }
+    if (!Array.isArray(outputChannels)) {
+        allOutputChannels.add(outputChannels);
     }
     else {
-        for (const chan of output) {
-            if (!(chan in newChannels)) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                newChannels[chan] = new last_value_js_1.LastValue();
+        outputChannels.forEach((chan) => allOutputChannels.add(chan));
+    }
+    if (streamChannels && !Array.isArray(streamChannels)) {
+        allOutputChannels.add(streamChannels);
+    }
+    else if (Array.isArray(streamChannels)) {
+        streamChannels.forEach((chan) => allOutputChannels.add(chan));
+    }
+    for (const chan of allOutputChannels) {
+        if (!(chan in channels)) {
+            throw new GraphValidationError(`Output channel '${String(chan)}' not in channels`);
+        }
+    }
+    // validate interrupt before/after
+    if (interruptAfterNodes && interruptAfterNodes !== "*") {
+        for (const node of interruptAfterNodes) {
+            if (!(node in nodes)) {
+                throw new GraphValidationError(`Node ${String(node)} not in nodes`);
             }
         }
     }
-    for (const chan in reserved_js_1.ReservedChannelsMap) {
-        if (!(chan in newChannels)) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            newChannels[chan] = new last_value_js_1.LastValue();
+    if (interruptBeforeNodes && interruptBeforeNodes !== "*") {
+        for (const node of interruptBeforeNodes) {
+            if (!(node in nodes)) {
+                throw new GraphValidationError(`Node ${String(node)} not in nodes`);
+            }
         }
     }
-    validateKeys(hidden, newChannels);
-    validateKeys(interrupt, newChannels);
 }
 exports.validateGraph = validateGraph;
 function validateKeys(keys, channels) {
     if (Array.isArray(keys)) {
         for (const key of keys) {
             if (!(key in channels)) {
-                throw new Error(`Key ${key} not found in channels`);
+                throw new Error(`Key ${String(key)} not found in channels`);
             }
         }
     }
     else {
         if (!(keys in channels)) {
-            throw new Error(`Key ${keys} not found in channels`);
+            throw new Error(`Key ${String(keys)} not found in channels`);
         }
     }
 }

package/dist/pregel/validate.d.ts

@@ -1,15 +1,16 @@
 import { BaseChannel } from "../channels/index.js";
-import { ChannelInvoke } from "./read.js";
-export declare function validateGraph({ nodes, channels, input, output, hidden, interrupt, }: {
-    nodes: Record<string, ChannelInvoke>;
-    channels: {
-        [key: string]: BaseChannel;
-    };
-    input: string | Array<string>;
-    output: string | Array<string>;
-    hidden: Array<string>;
-    interrupt: Array<string>;
-}): void;
-export declare function validateKeys(keys: string | Array<string>, channels: {
-    [key: string]: BaseChannel;
+import { PregelNode } from "./read.js";
+import { All } from "./types.js";
+export declare class GraphValidationError extends Error {
+    constructor(message?: string);
+}
+export declare function validateGraph<Nn extends Record<string, PregelNode>, Cc extends Record<string, BaseChannel>>({ nodes, channels, inputChannels, outputChannels, streamChannels, interruptAfterNodes, interruptBeforeNodes, }: {
+    nodes: Nn;
+    channels: Cc;
+    inputChannels: keyof Cc | Array<keyof Cc>;
+    outputChannels: keyof Cc | Array<keyof Cc>;
+    streamChannels?: keyof Cc | Array<keyof Cc>;
+    interruptAfterNodes?: Array<keyof Nn> | All;
+    interruptBeforeNodes?: Array<keyof Nn> | All;
 }): void;
+export declare function validateKeys<Cc extends Record<string, BaseChannel>>(keys: keyof Cc | Array<keyof Cc>, channels: Cc): void;

package/dist/pregel/validate.js

@@ -1,82 +1,88 @@
-import { LastValue } from "../channels/last_value.js";
-import { ReservedChannelsMap } from "./reserved.js";
-export function validateGraph({ nodes, channels, input, output, hidden, interrupt, }) {
-    const newChannels = channels;
+import { INTERRUPT } from "../constants.js";
+import { PregelNode } from "./read.js";
+export class GraphValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GraphValidationError";
+    }
+}
+export function validateGraph({ nodes, channels, inputChannels, outputChannels, streamChannels, interruptAfterNodes, interruptBeforeNodes, }) {
+    if (!channels) {
+        throw new GraphValidationError("Channels not provided");
+    }
     const subscribedChannels = new Set();
-    for (const node of Object.values(nodes)) {
-        if (node.lc_graph_name === "ChannelInvoke" && "channels" in node) {
-            if (typeof node.channels === "string") {
-                subscribedChannels.add(node.channels);
-            }
-            else {
-                Object.values(node.channels).map((channel) => subscribedChannels.add(channel));
-            }
+    const allOutputChannels = new Set();
+    for (const [name, node] of Object.entries(nodes)) {
+        if (name === INTERRUPT) {
+            throw new GraphValidationError(`"Node name ${INTERRUPT} is reserved"`);
+        }
+        if (node.constructor === PregelNode) {
+            node.triggers.forEach((trigger) => subscribedChannels.add(trigger));
         }
         else {
-            console.error(node);
-            throw new Error(`Invalid node type: ${JSON.stringify(node, null, 2)}, expected Channel.subscribeTo()`);
+            throw new GraphValidationError(`Invalid node type ${typeof node}, expected PregelNode`);
         }
     }
-    for (const chan of [...subscribedChannels]) {
-        if (!(chan in newChannels)) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            newChannels[chan] = new LastValue();
+    // side effect: update channels
+    for (const chan of subscribedChannels) {
+        if (!(chan in channels)) {
+            throw new GraphValidationError(`Subcribed channel '${String(chan)}' not in channels`);
         }
     }
-    if (typeof input === "string") {
-        if (!(input in newChannels)) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            newChannels[input] = new LastValue();
-        }
-        if (!subscribedChannels.has(input)) {
-            throw new Error(`Input channel ${input} is not subscribed to by any node.`);
+    if (!Array.isArray(inputChannels)) {
+        if (!subscribedChannels.has(inputChannels)) {
+            throw new GraphValidationError(`Input channel ${String(inputChannels)} is not subscribed to by any node`);
         }
     }
     else {
-        for (const chan of input) {
-            if (!(chan in newChannels)) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                newChannels[chan] = new LastValue();
-            }
-        }
-        if (input.every((chan) => !subscribedChannels.has(chan))) {
-            throw new Error(`None of the input channels ${input} are subscribed to by any node`);
+        if (inputChannels.every((channel) => !subscribedChannels.has(channel))) {
+            throw new GraphValidationError(`None of the input channels ${inputChannels} are subscribed to by any node`);
         }
     }
-    if (typeof output === "string") {
-        if (!(output in newChannels)) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            newChannels[output] = new LastValue();
-        }
+    if (!Array.isArray(outputChannels)) {
+        allOutputChannels.add(outputChannels);
     }
     else {
-        for (const chan of output) {
-            if (!(chan in newChannels)) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                newChannels[chan] = new LastValue();
+        outputChannels.forEach((chan) => allOutputChannels.add(chan));
+    }
+    if (streamChannels && !Array.isArray(streamChannels)) {
+        allOutputChannels.add(streamChannels);
+    }
+    else if (Array.isArray(streamChannels)) {
+        streamChannels.forEach((chan) => allOutputChannels.add(chan));
+    }
+    for (const chan of allOutputChannels) {
+        if (!(chan in channels)) {
+            throw new GraphValidationError(`Output channel '${String(chan)}' not in channels`);
+        }
+    }
+    // validate interrupt before/after
+    if (interruptAfterNodes && interruptAfterNodes !== "*") {
+        for (const node of interruptAfterNodes) {
+            if (!(node in nodes)) {
+                throw new GraphValidationError(`Node ${String(node)} not in nodes`);
             }
         }
     }
-    for (const chan in ReservedChannelsMap) {
-        if (!(chan in newChannels)) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            newChannels[chan] = new LastValue();
+    if (interruptBeforeNodes && interruptBeforeNodes !== "*") {
+        for (const node of interruptBeforeNodes) {
+            if (!(node in nodes)) {
+                throw new GraphValidationError(`Node ${String(node)} not in nodes`);
+            }
         }
     }
-    validateKeys(hidden, newChannels);
-    validateKeys(interrupt, newChannels);
 }
 export function validateKeys(keys, channels) {
     if (Array.isArray(keys)) {
         for (const key of keys) {
             if (!(key in channels)) {
-                throw new Error(`Key ${key} not found in channels`);
+                throw new Error(`Key ${String(key)} not found in channels`);
             }
         }
     }
     else {
         if (!(keys in channels)) {
-            throw new Error(`Key ${keys} not found in channels`);
+            throw new Error(`Key ${String(keys)} not found in channels`);
         }
     }
 }