@langchain/langgraph 0.0.1

package/dist/pregel/index.d.ts

@@ -0,0 +1,75 @@
+import { Runnable, RunnableConfig } from "@langchain/core/runnables";
+import { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
+import { IterableReadableStream } from "@langchain/core/utils/stream";
+import { BaseChannel } from "../channels/base.js";
+import { BaseCheckpointSaver } from "../checkpoint/base.js";
+import { ChannelBatch, ChannelInvoke } from "./read.js";
+import { ChannelWrite } from "./write.js";
+export declare class GraphRecursionError extends Error {
+    constructor(message?: string);
+}
+export declare class Channel {
+    static subscribeTo(channels: string, options?: {
+        key?: string;
+        when?: (arg: any) => boolean;
+        tags?: string[];
+    }): ChannelInvoke;
+    static subscribeTo(channels: string[], options?: {
+        key?: string;
+        when?: (arg: any) => boolean;
+        tags?: string[];
+    }): ChannelInvoke;
+    static subscribeToEach(inbox: string, key?: string): ChannelBatch;
+    static writeTo(...args: any[]): ChannelWrite;
+}
+export interface PregelInterface {
+    /**
+     * @default {}
+     */
+    channels?: Record<string, BaseChannel>;
+    /**
+     * @default "output"
+     */
+    output?: string | Array<string>;
+    /**
+     * @default "input"
+     */
+    input?: string | Array<string>;
+    /**
+     * @default []
+     */
+    hidden?: Array<string>;
+    /**
+     * @default false
+     */
+    debug?: boolean;
+    /**
+     * @default []
+     */
+    interrupt?: string[];
+    nodes: Record<string, ChannelInvoke | ChannelBatch>;
+    checkpointer?: BaseCheckpointSaver;
+    stepTimeout?: number;
+}
+export interface PregelOptions extends RunnableConfig {
+    outputKeys?: string | string[];
+}
+export type PregelInputType = any;
+export type PregelOutputType = any;
+export declare class Pregel extends Runnable<PregelInputType, PregelOutputType, PregelOptions> implements PregelInterface {
+    lc_namespace: string[];
+    channels: Record<string, BaseChannel>;
+    output: string | Array<string>;
+    input: string | Array<string>;
+    hidden: Array<string>;
+    debug: boolean;
+    nodes: Record<string, ChannelInvoke | ChannelBatch>;
+    checkpointer?: BaseCheckpointSaver;
+    stepTimeout?: number;
+    interrupt: string[];
+    constructor(fields: PregelInterface);
+    _transform(input: AsyncGenerator<PregelInputType>, runManager?: CallbackManagerForChainRun, config?: RunnableConfig & Partial<Record<string, unknown>>): AsyncGenerator<PregelOutputType>;
+    invoke(input: PregelInputType, config?: PregelOptions): Promise<PregelOutputType>;
+    stream(input: PregelInputType, config?: PregelOptions): Promise<IterableReadableStream<PregelOutputType>>;
+    transform(generator: AsyncGenerator<PregelInputType>, config?: PregelOptions): AsyncGenerator<PregelOutputType>;
+}

package/dist/pregel/index.js

@@ -0,0 +1,469 @@
+/* eslint-disable no-param-reassign */
+import { Runnable, _coerceToRunnable, patchConfig, } from "@langchain/core/runnables";
+import { IterableReadableStream } from "@langchain/core/utils/stream";
+import { EmptyChannelError, createCheckpoint, emptyChannels, } from "../channels/base.js";
+import { CheckpointAt, emptyCheckpoint, } from "../checkpoint/base.js";
+import { ChannelBatch, ChannelInvoke } from "./read.js";
+import { validateGraph } from "./validate.js";
+import { ReservedChannels } from "./reserved.js";
+import { mapInput, mapOutput } from "./io.js";
+import { ChannelWrite } from "./write.js";
+import { CONFIG_KEY_READ, CONFIG_KEY_SEND } from "../constants.js";
+const DEFAULT_RECURSION_LIMIT = 25;
+export class GraphRecursionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GraphRecursionError";
+    }
+}
+function _coerceWriteValue(value) {
+    if (!Runnable.isRunnable(value) && typeof value !== "function") {
+        return _coerceToRunnable(() => value);
+    }
+    return _coerceToRunnable(value);
+}
+function isString(value) {
+    return typeof value === "string";
+}
+export class Channel {
+    static subscribeTo(channels, options) {
+        const { key, when, tags } = options ?? {};
+        if (Array.isArray(channels) && key !== undefined) {
+            throw new Error("Can't specify a key when subscribing to multiple channels");
+        }
+        let channelMappingOrString;
+        if (isString(channels)) {
+            if (key) {
+                channelMappingOrString = { [key]: channels };
+            }
+            else {
+                channelMappingOrString = channels;
+            }
+        }
+        else {
+            channelMappingOrString = Object.fromEntries(channels.map((chan) => [chan, chan]));
+        }
+        const triggers = Array.isArray(channels) ? channels : [channels];
+        return new ChannelInvoke({
+            channels: channelMappingOrString,
+            triggers,
+            when,
+            tags,
+        });
+    }
+    static subscribeToEach(inbox, key) {
+        return new ChannelBatch({
+            channel: inbox,
+            key,
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static writeTo(...args) {
+        // const channelPairs: Array<[string, WriteValue<RunInput, RunOutput>]> =
+        //   channels.map((c) => [c, undefined]);
+        // return new ChannelWrite<RunInput, RunOutput>(channelPairs);
+        const channelPairs = [];
+        if (args.length === 1 && typeof args[0] === "object") {
+            // Handle the case where named arguments are passed as an object
+            const additionalArgs = args[0];
+            Object.entries(additionalArgs).forEach(([key, value]) => {
+                channelPairs.push([key, _coerceWriteValue(value)]);
+            });
+        }
+        else {
+            args.forEach((channel) => {
+                if (typeof channel === "string") {
+                    channelPairs.push([channel, undefined]);
+                }
+                else if (typeof channel === "object") {
+                    Object.entries(channel).forEach(([key, value]) => {
+                        channelPairs.push([key, _coerceWriteValue(value)]);
+                    });
+                }
+            });
+        }
+        return new ChannelWrite(channelPairs);
+    }
+}
+export class Pregel extends Runnable {
+    constructor(fields) {
+        super();
+        // Because Pregel extends `Runnable`.
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langgraph", "pregel"]
+        });
+        Object.defineProperty(this, "channels", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "output", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "output"
+        });
+        Object.defineProperty(this, "input", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "input"
+        });
+        Object.defineProperty(this, "hidden", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "debug", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "nodes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "checkpointer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "stepTimeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "interrupt", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        this.channels = fields.channels ?? this.channels;
+        this.output = fields.output ?? this.output;
+        this.input = fields.input ?? this.input;
+        this.hidden = fields.hidden ?? this.hidden;
+        this.debug = fields.debug ?? this.debug;
+        this.nodes = fields.nodes;
+        this.checkpointer = fields.checkpointer;
+        this.stepTimeout = fields.stepTimeout;
+        this.interrupt = fields.interrupt ?? this.interrupt;
+        // Bind the method to the instance
+        this._transform = this._transform.bind(this);
+        validateGraph({
+            nodes: this.nodes,
+            channels: this.channels,
+            output: this.output,
+            input: this.input,
+            hidden: this.hidden,
+            interrupt: this.interrupt,
+        });
+    }
+    async *_transform(input, runManager, config = {}) {
+        // assign defaults
+        let outputKeys = [];
+        if (Array.isArray(config.outputKeys) ||
+            typeof config.outputKeys === "string") {
+            outputKeys = config.outputKeys;
+        }
+        else {
+            for (const chan in this.channels) {
+                if (!this.hidden.includes(chan)) {
+                    outputKeys.push(chan);
+                }
+            }
+        }
+        // copy nodes to ignore mutations during execution
+        const processes = { ...this.nodes };
+        // get checkpoint, or create an empty one
+        let checkpoint;
+        if (this.checkpointer) {
+            checkpoint = this.checkpointer.get(config);
+        }
+        checkpoint = checkpoint ?? emptyCheckpoint();
+        // create channels from checkpoint
+        const channels = emptyChannels(this.channels, checkpoint);
+        // map inputs to channel updates
+        const thisInput = this.input;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const inputPendingWrites = [];
+        for await (const c of input) {
+            for (const value of mapInput(thisInput, c)) {
+                inputPendingWrites.push(value);
+            }
+        }
+        _applyWrites(checkpoint, channels, inputPendingWrites, config, 0);
+        const read = (chan) => _readChannel(channels, chan);
+        // Similarly to Bulk Synchronous Parallel / Pregel model
+        // computation proceeds in steps, while there are channel updates
+        // channel updates from step N are only visible in step N+1
+        // channels are guaranteed to be immutable for the duration of the step,
+        // with channel updates applied only at the transition between steps
+        const recursionLimit = config.recursionLimit ?? DEFAULT_RECURSION_LIMIT;
+        for (let step = 0; step < recursionLimit + 1; step += 1) {
+            const nextTasks = _prepareNextTasks(checkpoint, processes, channels);
+            // if no more tasks, we're done
+            if (nextTasks.length === 0) {
+                break;
+            }
+            else if (step === config.recursionLimit) {
+                throw new GraphRecursionError(`Recursion limit of ${config.recursionLimit} reached without hitting a stop condition. You can increase the limit by setting the "recursionLimit" config key.`);
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const pendingWrites = [];
+            const tasksWithConfig = nextTasks.map(([proc, input, name]) => [
+                proc,
+                input,
+                patchConfig(config, {
+                    callbacks: runManager?.getChild(`graph:step:${step}`),
+                    runName: name,
+                    configurable: {
+                        ...config.configurable,
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        [CONFIG_KEY_SEND]: (items) => pendingWrites.push(...items),
+                        [CONFIG_KEY_READ]: read,
+                    },
+                }),
+            ]);
+            // execute tasks, and wait for one to fail or all to finish.
+            // each task is independent from all other concurrent tasks
+            const tasks = tasksWithConfig.map(([proc, input, updatedConfig]) => () => proc.invoke(input, updatedConfig));
+            await executeTasks(tasks, this.stepTimeout);
+            // apply writes to channels
+            _applyWrites(checkpoint, channels, pendingWrites, config, step + 1);
+            // yield current value and checkpoint view
+            const stepOutput = mapOutput(outputKeys, pendingWrites, channels);
+            if (stepOutput) {
+                yield stepOutput;
+                if (typeof outputKeys !== "string") {
+                    _applyWritesFromView(checkpoint, channels, stepOutput);
+                }
+            }
+            // save end of step checkpoint
+            if (this.checkpointer &&
+                this.checkpointer.at === CheckpointAt.END_OF_STEP) {
+                checkpoint = await createCheckpoint(checkpoint, channels);
+                this.checkpointer.put(config, checkpoint);
+            }
+            // interrupt if any channel written to is in interrupt list
+            if (pendingWrites.some(([chan]) => this.interrupt?.some((i) => i === chan))) {
+                break;
+            }
+        }
+        // save end of run checkpoint
+        if (this.checkpointer && this.checkpointer.at === CheckpointAt.END_OF_RUN) {
+            checkpoint = await createCheckpoint(checkpoint, channels);
+            this.checkpointer.put(config, checkpoint);
+        }
+    }
+    async invoke(input, config) {
+        if (!config?.outputKeys) {
+            if (!config) {
+                config = {};
+            }
+            config.outputKeys = this.output;
+        }
+        let latest;
+        for await (const chunk of await this.stream(input, config)) {
+            latest = chunk;
+        }
+        if (!latest) {
+            return undefined;
+        }
+        return latest;
+    }
+    async stream(input, config) {
+        const inputIterator = (async function* () {
+            yield input;
+        })();
+        return IterableReadableStream.fromAsyncGenerator(this.transform(inputIterator, config));
+    }
+    async *transform(generator, config) {
+        for await (const chunk of this._transformStreamWithConfig(generator, this._transform, config)) {
+            yield chunk;
+        }
+    }
+}
+function timeout(ms) {
+    return new Promise((reject) => {
+        setTimeout(reject, ms);
+    });
+}
+async function executeTasks(tasks, stepTimeout) {
+    // Wrap each task in a Promise that respects the step timeout
+    const wrappedTasks = tasks.map((task) => stepTimeout
+        ? Promise.race([
+            task(),
+            stepTimeout ? timeout(stepTimeout) : Promise.resolve(),
+        ])
+        : task());
+    // Wait for all tasks to settle
+    const results = await Promise.allSettled(wrappedTasks);
+    // Process the results
+    for (const result of results) {
+        if (result.status === "rejected") {
+            // If any task failed, cancel all pending tasks and throw the error
+            throw result.reason;
+        }
+    }
+}
+function _readChannel(channels, chan) {
+    try {
+        return channels[chan].get();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }
+    catch (e) {
+        if (e.name === EmptyChannelError.name) {
+            return null;
+        }
+        throw e;
+    }
+}
+function _applyWrites(checkpoint, channels, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+pendingWrites, config, forStep) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const pendingWritesByChannel = {};
+    // Group writes by channel
+    for (const [chan, val] of pendingWrites) {
+        for (const c in ReservedChannels) {
+            if (chan === c) {
+                throw new Error(`Can't write to reserved channel ${chan}`);
+            }
+        }
+        if (chan in pendingWritesByChannel) {
+            pendingWritesByChannel[chan].push(val);
+        }
+        else {
+            pendingWritesByChannel[chan] = [val];
+        }
+    }
+    // Update reserved channels
+    pendingWritesByChannel[ReservedChannels.isLastStep] = [
+        forStep + 1 === config.recursionLimit,
+    ];
+    const updatedChannels = new Set();
+    // Apply writes to channels
+    for (const chan in pendingWritesByChannel) {
+        if (chan in pendingWritesByChannel) {
+            const vals = pendingWritesByChannel[chan];
+            if (chan in channels) {
+                channels[chan].update(vals);
+                if (checkpoint.channelVersions[chan] === undefined) {
+                    checkpoint.channelVersions[chan] = 1;
+                }
+                else {
+                    checkpoint.channelVersions[chan] += 1;
+                }
+                updatedChannels.add(chan);
+            }
+            else {
+                console.warn(`Skipping write for channel ${chan} which has no readers`);
+            }
+        }
+    }
+    // Channels that weren't updated in this step are notified of a new step
+    for (const chan in channels) {
+        if (!updatedChannels.has(chan)) {
+            channels[chan].update([]);
+        }
+    }
+}
+function _applyWritesFromView(checkpoint, channels, values) {
+    for (const [chan, val] of Object.entries(values)) {
+        if (val === _readChannel(channels, chan)) {
+            continue;
+        }
+        if (channels[chan].lc_graph_name === "LastValue") {
+            throw new Error(`Can't modify channel ${chan} with LastValue`);
+        }
+        checkpoint.channelVersions[chan] += 1;
+        channels[chan].update([values[chan]]);
+    }
+}
+function _prepareNextTasks(checkpoint, processes, channels) {
+    const tasks = [];
+    // Check if any processes should be run in next step
+    // If so, prepare the values to be passed to them
+    for (const name in processes) {
+        if (Object.prototype.hasOwnProperty.call(processes, name)) {
+            const proc = processes[name];
+            let seen = checkpoint.versionsSeen[name];
+            if (!seen) {
+                checkpoint.versionsSeen[name] = {};
+                seen = checkpoint.versionsSeen[name];
+            }
+            if ("triggers" in proc) {
+                // If any of the channels read by this process were updated
+                if (proc.triggers.some((chan) => checkpoint.channelVersions[chan] > (seen[chan] ?? 0))) {
+                    // If all channels subscribed by this process have been initialized
+                    try {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        let val = {};
+                        if (typeof proc.channels === "string") {
+                            val[proc.channels] = _readChannel(channels, proc.channels);
+                        }
+                        else {
+                            for (const [k, chan] of Object.entries(proc.channels)) {
+                                val[k] = _readChannel(channels, chan);
+                            }
+                        }
+                        // Processes that subscribe to a single keyless channel get
+                        // the value directly, instead of a dict
+                        if (typeof proc.channels === "string") {
+                            val = val[proc.channels];
+                        }
+                        else if (Object.keys(proc.channels).length === 1 &&
+                            proc.channels[Object.keys(proc.channels)[0]] === undefined) {
+                            val = val[Object.keys(proc.channels)[0]];
+                        }
+                        // Update seen versions
+                        proc.triggers.forEach((chan) => {
+                            const version = checkpoint.channelVersions[chan];
+                            if (version !== undefined) {
+                                seen[chan] = version;
+                            }
+                        });
+                        // skip if condition is not met
+                        if (proc.when === undefined || proc.when(val)) {
+                            tasks.push([proc, val, name]);
+                        }
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    }
+                    catch (error) {
+                        if (error.name === EmptyChannelError.name) {
+                            continue;
+                        }
+                        else {
+                            throw error;
+                        }
+                    }
+                }
+            }
+            else if ("channel" in proc) {
+                // If the channel read by this process was updated
+                if (checkpoint.channelVersions[proc.channel] > (seen[proc.channel] ?? 0)) {
+                    // Here we don't catch EmptyChannelError because the channel
+                    // must be initialized if the previous `if` condition is true
+                    let val = channels[proc.channel].get();
+                    if (proc.key !== undefined) {
+                        val = [{ [proc.key]: val }];
+                    }
+                    tasks.push([proc, val, name]);
+                    seen[proc.channel] = checkpoint.channelVersions[proc.channel];
+                }
+            }
+        }
+    }
+    return tasks;
+}

package/dist/pregel/io.cjs

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapOutput = exports.mapInput = void 0;
+/**
+ * Map input chunk to a sequence of pending writes in the form [channel, value].
+ */
+function* mapInput(inputChannels, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+chunk
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    if (typeof inputChannels === "string") {
+        yield [inputChannels, chunk];
+    }
+    else {
+        if ((chunk && typeof chunk !== "object") || Array.isArray(chunk)) {
+            throw new Error(`Expected chunk to be an object, got ${typeof chunk}`);
+        }
+        for (const k in chunk) {
+            if (inputChannels.includes(k)) {
+                yield [k, chunk[k]];
+            }
+            else {
+                console.warn(`Input channel ${k} not found in ${inputChannels}`);
+            }
+        }
+    }
+}
+exports.mapInput = mapInput;
+/**
+ * Map pending writes (a list of [channel, value]) to output chunk.
+ */
+function mapOutput(outputChannels, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+pendingWrites, channels
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    if (typeof outputChannels === "string") {
+        if (pendingWrites.some(([chan, _]) => chan === outputChannels)) {
+            return channels[outputChannels].get();
+        }
+    }
+    else {
+        const updated = pendingWrites
+            .filter(([chan, _]) => outputChannels.includes(chan))
+            .map(([chan, _]) => chan);
+        if (updated.length > 0) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return updated.reduce((acc, chan) => {
+                acc[chan] = channels[chan].get();
+                return acc;
+            }, {});
+        }
+    }
+    return undefined;
+}
+exports.mapOutput = mapOutput;

package/dist/pregel/io.d.ts

@@ -0,0 +1,9 @@
+import { BaseChannel } from "../channels/base.js";
+/**
+ * Map input chunk to a sequence of pending writes in the form [channel, value].
+ */
+export declare function mapInput(inputChannels: string | Array<string>, chunk?: any): Generator<[string, any]>;
+/**
+ * Map pending writes (a list of [channel, value]) to output chunk.
+ */
+export declare function mapOutput(outputChannels: string | Array<string>, pendingWrites: Array<[string, any]>, channels: Record<string, BaseChannel>): any | undefined;

package/dist/pregel/io.js

@@ -0,0 +1,52 @@
+/**
+ * Map input chunk to a sequence of pending writes in the form [channel, value].
+ */
+export function* mapInput(inputChannels, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+chunk
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    if (typeof inputChannels === "string") {
+        yield [inputChannels, chunk];
+    }
+    else {
+        if ((chunk && typeof chunk !== "object") || Array.isArray(chunk)) {
+            throw new Error(`Expected chunk to be an object, got ${typeof chunk}`);
+        }
+        for (const k in chunk) {
+            if (inputChannels.includes(k)) {
+                yield [k, chunk[k]];
+            }
+            else {
+                console.warn(`Input channel ${k} not found in ${inputChannels}`);
+            }
+        }
+    }
+}
+/**
+ * Map pending writes (a list of [channel, value]) to output chunk.
+ */
+export function mapOutput(outputChannels, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+pendingWrites, channels
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    if (typeof outputChannels === "string") {
+        if (pendingWrites.some(([chan, _]) => chan === outputChannels)) {
+            return channels[outputChannels].get();
+        }
+    }
+    else {
+        const updated = pendingWrites
+            .filter(([chan, _]) => outputChannels.includes(chan))
+            .map(([chan, _]) => chan);
+        if (updated.length > 0) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return updated.reduce((acc, chan) => {
+                acc[chan] = channels[chan].get();
+                return acc;
+            }, {});
+        }
+    }
+    return undefined;
+}