@langchain/langgraph 0.0.1

package/dist/prebuilt/tool_executor.d.ts

@@ -0,0 +1,27 @@
+import { RunnableBinding, RunnableConfig } from "@langchain/core/runnables";
+import { Tool } from "@langchain/core/tools";
+export interface ToolExecutorArgs {
+    tools: Array<Tool>;
+    /**
+     * @default {INVALID_TOOL_MSG_TEMPLATE}
+     */
+    invalidToolMsgTemplate?: string;
+}
+/**
+ * Interface for invoking a tool
+ */
+export interface ToolInvocationInterface {
+    tool: string;
+    toolInput: string;
+}
+type ToolExecutorInputType = any;
+type ToolExecutorOutputType = any;
+export declare class ToolExecutor extends RunnableBinding<ToolExecutorInputType, ToolExecutorOutputType> {
+    lc_graph_name: string;
+    tools: Array<Tool>;
+    toolMap: Record<string, Tool>;
+    invalidToolMsgTemplate: string;
+    constructor(fields: ToolExecutorArgs);
+    _execute(toolInvocation: ToolInvocationInterface, _config?: RunnableConfig): Promise<string>;
+}
+export {};

package/dist/prebuilt/tool_executor.js

@@ -0,0 +1,59 @@
+import { RunnableBinding, RunnableLambda, } from "@langchain/core/runnables";
+const INVALID_TOOL_MSG_TEMPLATE = `{requestedToolName} is not a valid tool, try one of [availableToolNamesString].`;
+export class ToolExecutor extends RunnableBinding {
+    constructor(fields) {
+        const fieldsWithDefaults = {
+            invalidToolMsgTemplate: INVALID_TOOL_MSG_TEMPLATE,
+            ...fields,
+        };
+        const bound = new RunnableLambda({
+            func: async (input, options) => this._execute(input, options?.config),
+        });
+        super({
+            bound,
+            config: {},
+        });
+        Object.defineProperty(this, "lc_graph_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "ToolExecutor"
+        });
+        Object.defineProperty(this, "tools", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "toolMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "invalidToolMsgTemplate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.tools = fieldsWithDefaults.tools;
+        this.invalidToolMsgTemplate = fieldsWithDefaults.invalidToolMsgTemplate;
+        this.toolMap = this.tools.reduce((acc, tool) => {
+            acc[tool.name] = tool;
+            return acc;
+        }, {});
+    }
+    async _execute(toolInvocation, _config) {
+        if (!(toolInvocation.tool in this.toolMap)) {
+            return this.invalidToolMsgTemplate
+                .replace("{requestedToolName}", toolInvocation.tool)
+                .replace("{availableToolNamesString}", Object.keys(this.toolMap).join(", "));
+        }
+        else {
+            const tool = this.toolMap[toolInvocation.tool];
+            const output = await tool.invoke(toolInvocation.toolInput);
+            return output;
+        }
+    }
+}

package/dist/pregel/debug.cjs

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printCheckpoint = exports.printStepStart = void 0;
+const base_js_1 = require("../channels/base.cjs");
+const COLORS_MAP = {
+    blue: {
+        start: "\x1b[34m",
+        end: "\x1b[0m",
+    },
+};
+/**
+ * Wrap some text in a color for printing to the console.
+ */
+const wrap = (color, text) => `${color.start}${text}${color.end}`;
+function printStepStart(step, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+nextTasks) {
+    const nTasks = nextTasks.length;
+    console.log(`${wrap(COLORS_MAP.blue, "[pregel/step]")}`, `Starting step ${step} with ${nTasks} task${nTasks === 1 ? "" : "s"}. Next tasks:\n`, `\n${nextTasks
+        .map(([_, val, name]) => `- ${name}(${JSON.stringify(val, null, 2)})`)
+        .join("\n")}`);
+}
+exports.printStepStart = printStepStart;
+function printCheckpoint(step, channels) {
+    console.log(`${wrap(COLORS_MAP.blue, "[pregel/checkpoint]")}`, `Finishing step ${step}. Channel values:\n`, `\n${JSON.stringify(Object.fromEntries(_readChannels(channels)), null, 2)}`);
+}
+exports.printCheckpoint = printCheckpoint;
+function* _readChannels(channels
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    for (const [name, channel] of Object.entries(channels)) {
+        try {
+            yield [name, channel.get()];
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (error) {
+            if (error.name === base_js_1.EmptyChannelError.name) {
+                // Skip the channel if it's empty
+                continue;
+            }
+            else {
+                throw error; // Re-throw the error if it's not an EmptyChannelError
+            }
+        }
+    }
+}

package/dist/pregel/debug.d.ts

@@ -0,0 +1,4 @@
+import { Runnable } from "@langchain/core/runnables";
+import { BaseChannel } from "../channels/base.js";
+export declare function printStepStart(step: number, nextTasks: Array<[Runnable, any, string]>): void;
+export declare function printCheckpoint<Value>(step: number, channels: Record<string, BaseChannel<Value>>): void;

package/dist/pregel/debug.js

@@ -0,0 +1,41 @@
+import { EmptyChannelError } from "../channels/base.js";
+const COLORS_MAP = {
+    blue: {
+        start: "\x1b[34m",
+        end: "\x1b[0m",
+    },
+};
+/**
+ * Wrap some text in a color for printing to the console.
+ */
+const wrap = (color, text) => `${color.start}${text}${color.end}`;
+export function printStepStart(step, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+nextTasks) {
+    const nTasks = nextTasks.length;
+    console.log(`${wrap(COLORS_MAP.blue, "[pregel/step]")}`, `Starting step ${step} with ${nTasks} task${nTasks === 1 ? "" : "s"}. Next tasks:\n`, `\n${nextTasks
+        .map(([_, val, name]) => `- ${name}(${JSON.stringify(val, null, 2)})`)
+        .join("\n")}`);
+}
+export function printCheckpoint(step, channels) {
+    console.log(`${wrap(COLORS_MAP.blue, "[pregel/checkpoint]")}`, `Finishing step ${step}. Channel values:\n`, `\n${JSON.stringify(Object.fromEntries(_readChannels(channels)), null, 2)}`);
+}
+function* _readChannels(channels
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    for (const [name, channel] of Object.entries(channels)) {
+        try {
+            yield [name, channel.get()];
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (error) {
+            if (error.name === EmptyChannelError.name) {
+                // Skip the channel if it's empty
+                continue;
+            }
+            else {
+                throw error; // Re-throw the error if it's not an EmptyChannelError
+            }
+        }
+    }
+}

package/dist/pregel/index.cjs

@@ -0,0 +1,475 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pregel = exports.Channel = exports.GraphRecursionError = void 0;
+/* eslint-disable no-param-reassign */
+const runnables_1 = require("@langchain/core/runnables");
+const stream_1 = require("@langchain/core/utils/stream");
+const base_js_1 = require("../channels/base.cjs");
+const base_js_2 = require("../checkpoint/base.cjs");
+const read_js_1 = require("./read.cjs");
+const validate_js_1 = require("./validate.cjs");
+const reserved_js_1 = require("./reserved.cjs");
+const io_js_1 = require("./io.cjs");
+const write_js_1 = require("./write.cjs");
+const constants_js_1 = require("../constants.cjs");
+const DEFAULT_RECURSION_LIMIT = 25;
+class GraphRecursionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GraphRecursionError";
+    }
+}
+exports.GraphRecursionError = GraphRecursionError;
+function _coerceWriteValue(value) {
+    if (!runnables_1.Runnable.isRunnable(value) && typeof value !== "function") {
+        return (0, runnables_1._coerceToRunnable)(() => value);
+    }
+    return (0, runnables_1._coerceToRunnable)(value);
+}
+function isString(value) {
+    return typeof value === "string";
+}
+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 read_js_1.ChannelInvoke({
+            channels: channelMappingOrString,
+            triggers,
+            when,
+            tags,
+        });
+    }
+    static subscribeToEach(inbox, key) {
+        return new read_js_1.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 write_js_1.ChannelWrite(channelPairs);
+    }
+}
+exports.Channel = Channel;
+class Pregel extends runnables_1.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);
+        (0, validate_js_1.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 ?? (0, base_js_2.emptyCheckpoint)();
+        // create channels from checkpoint
+        const channels = (0, base_js_1.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 (0, io_js_1.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,
+                (0, runnables_1.patchConfig)(config, {
+                    callbacks: runManager?.getChild(`graph:step:${step}`),
+                    runName: name,
+                    configurable: {
+                        ...config.configurable,
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        [constants_js_1.CONFIG_KEY_SEND]: (items) => pendingWrites.push(...items),
+                        [constants_js_1.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 = (0, io_js_1.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 === base_js_2.CheckpointAt.END_OF_STEP) {
+                checkpoint = await (0, base_js_1.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 === base_js_2.CheckpointAt.END_OF_RUN) {
+            checkpoint = await (0, base_js_1.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 stream_1.IterableReadableStream.fromAsyncGenerator(this.transform(inputIterator, config));
+    }
+    async *transform(generator, config) {
+        for await (const chunk of this._transformStreamWithConfig(generator, this._transform, config)) {
+            yield chunk;
+        }
+    }
+}
+exports.Pregel = Pregel;
+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 === base_js_1.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 reserved_js_1.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[reserved_js_1.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 === base_js_1.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;
+}