@langchain/langgraph 0.0.1

package/dist/pregel/read.cjs

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelBatch = exports.ChannelInvoke = exports.ChannelRead = void 0;
+const runnables_1 = require("@langchain/core/runnables");
+const constants_js_1 = require("../constants.cjs");
+class ChannelRead extends runnables_1.RunnableLambda {
+    constructor(channel) {
+        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 ?? {});
+            },
+        });
+        Object.defineProperty(this, "lc_graph_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "ChannelRead"
+        });
+        Object.defineProperty(this, "channel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.channel = channel;
+        this.name = `ChannelRead<${channel}>`;
+    }
+    get configSpecs() {
+        return [
+            {
+                id: constants_js_1.CONFIG_KEY_READ,
+                name: constants_js_1.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
+        const read = config.configurable?.[constants_js_1.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;
+        }
+        return read(this.channel);
+    }
+}
+exports.ChannelRead = ChannelRead;
+const defaultRunnableBound = new runnables_1.RunnablePassthrough();
+class ChannelInvoke extends runnables_1.RunnableBinding {
+    constructor(fields) {
+        const { channels, triggers, when } = fields;
+        const mergedTags = [
+            ...(fields.config?.tags ? fields.config.tags : []),
+            ...(fields.tags ? fields.tags : []),
+        ];
+        super({
+            ...fields,
+            bound: fields.bound ??
+                defaultRunnableBound,
+            config: {
+                ...(fields.config ? fields.config : {}),
+                tags: mergedTags,
+            },
+        });
+        Object.defineProperty(this, "lc_graph_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "ChannelInvoke"
+        });
+        Object.defineProperty(this, "channels", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "triggers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "when", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.channels = channels;
+        this.triggers = triggers;
+        this.when = when;
+    }
+    join(channels) {
+        if (typeof this.channels !== "object") {
+            throw new Error("all channels must be named when using .join()");
+        }
+        return new ChannelInvoke({
+            channels: {
+                ...this.channels,
+                ...Object.fromEntries(channels.map((chan) => [chan, chan])),
+            },
+            triggers: this.triggers,
+            when: this.when,
+            bound: this.bound,
+            kwargs: this.kwargs,
+            config: this.config,
+        });
+    }
+    pipe(coerceable) {
+        if (this.bound === defaultRunnableBound) {
+            return new ChannelInvoke({
+                channels: this.channels,
+                triggers: this.triggers,
+                when: this.when,
+                bound: (0, runnables_1._coerceToRunnable)(coerceable),
+                config: this.config,
+                kwargs: this.kwargs,
+            });
+        }
+        else {
+            return new ChannelInvoke({
+                channels: this.channels,
+                triggers: this.triggers,
+                when: this.when,
+                bound: this.bound.pipe(coerceable),
+                config: this.config,
+                kwargs: this.kwargs,
+            });
+        }
+    }
+}
+exports.ChannelInvoke = ChannelInvoke;
+class ChannelBatch extends runnables_1.RunnableEach {
+    constructor(fields) {
+        super({
+            ...fields,
+            bound: fields.bound ?? defaultRunnableBound,
+        });
+        Object.defineProperty(this, "lc_graph_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "ChannelBatch"
+        });
+        Object.defineProperty(this, "channel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "key", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.channel = fields.channel;
+        this.key = fields.key;
+    }
+    join(channels) {
+        if (!this.key) {
+            throw new Error(`Cannot join() additional channels without a key.\nPass a key arg to Channel.subscribeToEach().`);
+        }
+        const channelsMap = {};
+        for (const chan of channels) {
+            channelsMap[chan] = new ChannelRead(chan);
+        }
+        const joiner = runnables_1.RunnablePassthrough.assign({ ...channelsMap });
+        if (this.bound === defaultRunnableBound) {
+            return new ChannelBatch({
+                channel: this.channel,
+                key: this.key,
+                bound: joiner,
+            });
+        }
+        else {
+            return new ChannelBatch({
+                channel: this.channel,
+                key: this.key,
+                bound: this.bound.pipe(joiner),
+            });
+        }
+    }
+    // @ts-expect-error @TODO: fix later
+    pipe(coerceable) {
+        if (this.bound === defaultRunnableBound) {
+            return new ChannelBatch({
+                channel: this.channel,
+                key: this.key,
+                bound: (0, runnables_1._coerceToRunnable)(coerceable),
+            });
+        }
+        else {
+            // Delegate to `or` in `this.bound`
+            return new ChannelBatch({
+                channel: this.channel,
+                key: this.key,
+                bound: this.bound.pipe(coerceable),
+            });
+        }
+    }
+}
+exports.ChannelBatch = ChannelBatch;

package/dist/pregel/read.d.ts

@@ -0,0 +1,43 @@
+import { Runnable, RunnableBinding, RunnableBindingArgs, RunnableConfig, RunnableEach, RunnableLambda, RunnableLike } from "@langchain/core/runnables";
+import { ConfigurableFieldSpec } from "../checkpoint/index.js";
+export declare class ChannelRead<RunInput = any, RunOutput = any> extends RunnableLambda<RunInput, RunOutput> {
+    lc_graph_name: string;
+    channel: string | Array<string>;
+    constructor(channel: string | Array<string>);
+    get configSpecs(): ConfigurableFieldSpec[];
+    _read(_: any, config: RunnableConfig): any;
+}
+interface ChannelInvokeArgs<RunInput, RunOutput> extends Partial<RunnableBindingArgs<RunInput, RunOutput>> {
+    channels: Record<string, string> | string;
+    triggers: Array<string>;
+    when?: (args: any) => boolean;
+    config?: RunnableConfig;
+    tags?: string[];
+}
+export type ChannelInvokeInputType = any;
+export type ChannelInvokeOutputType = any;
+export declare class ChannelInvoke<RunInput = ChannelInvokeInputType, RunOutput = ChannelInvokeOutputType> extends RunnableBinding<RunInput, RunOutput, RunnableConfig> {
+    lc_graph_name: string;
+    channels: Record<string, string> | string;
+    triggers: string[];
+    when?: (args: any) => boolean;
+    constructor(fields: ChannelInvokeArgs<RunInput, RunOutput>);
+    join(channels: Array<string>): ChannelInvoke<RunInput, RunOutput>;
+    pipe<NewRunOutput>(coerceable: RunnableLike): ChannelInvoke<RunInput, Exclude<NewRunOutput, Error>>;
+}
+interface ChannelBatchArgs {
+    channel: string;
+    key?: string;
+    bound?: Runnable;
+}
+export type ChannelBatchInputType = any;
+export type ChannelBatchOutputType = any;
+export declare class ChannelBatch extends RunnableEach<ChannelBatchInputType, ChannelBatchOutputType, RunnableConfig> {
+    lc_graph_name: string;
+    channel: string;
+    key?: string;
+    constructor(fields: ChannelBatchArgs);
+    join(channels: Array<string>): ChannelBatch;
+    pipe(coerceable: RunnableLike): ChannelBatch;
+}
+export {};

package/dist/pregel/read.js

@@ -0,0 +1,211 @@
+import { RunnableBinding, RunnableEach, RunnableLambda, RunnablePassthrough, _coerceToRunnable, } from "@langchain/core/runnables";
+import { CONFIG_KEY_READ } from "../constants.js";
+export class ChannelRead extends RunnableLambda {
+    constructor(channel) {
+        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 ?? {});
+            },
+        });
+        Object.defineProperty(this, "lc_graph_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "ChannelRead"
+        });
+        Object.defineProperty(this, "channel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.channel = channel;
+        this.name = `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
+        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;
+        }
+        return read(this.channel);
+    }
+}
+const defaultRunnableBound = new RunnablePassthrough();
+export class ChannelInvoke extends RunnableBinding {
+    constructor(fields) {
+        const { channels, triggers, when } = fields;
+        const mergedTags = [
+            ...(fields.config?.tags ? fields.config.tags : []),
+            ...(fields.tags ? fields.tags : []),
+        ];
+        super({
+            ...fields,
+            bound: fields.bound ??
+                defaultRunnableBound,
+            config: {
+                ...(fields.config ? fields.config : {}),
+                tags: mergedTags,
+            },
+        });
+        Object.defineProperty(this, "lc_graph_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "ChannelInvoke"
+        });
+        Object.defineProperty(this, "channels", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "triggers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "when", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.channels = channels;
+        this.triggers = triggers;
+        this.when = when;
+    }
+    join(channels) {
+        if (typeof this.channels !== "object") {
+            throw new Error("all channels must be named when using .join()");
+        }
+        return new ChannelInvoke({
+            channels: {
+                ...this.channels,
+                ...Object.fromEntries(channels.map((chan) => [chan, chan])),
+            },
+            triggers: this.triggers,
+            when: this.when,
+            bound: this.bound,
+            kwargs: this.kwargs,
+            config: this.config,
+        });
+    }
+    pipe(coerceable) {
+        if (this.bound === defaultRunnableBound) {
+            return new ChannelInvoke({
+                channels: this.channels,
+                triggers: this.triggers,
+                when: this.when,
+                bound: _coerceToRunnable(coerceable),
+                config: this.config,
+                kwargs: this.kwargs,
+            });
+        }
+        else {
+            return new ChannelInvoke({
+                channels: this.channels,
+                triggers: this.triggers,
+                when: this.when,
+                bound: this.bound.pipe(coerceable),
+                config: this.config,
+                kwargs: this.kwargs,
+            });
+        }
+    }
+}
+export class ChannelBatch extends RunnableEach {
+    constructor(fields) {
+        super({
+            ...fields,
+            bound: fields.bound ?? defaultRunnableBound,
+        });
+        Object.defineProperty(this, "lc_graph_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "ChannelBatch"
+        });
+        Object.defineProperty(this, "channel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "key", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.channel = fields.channel;
+        this.key = fields.key;
+    }
+    join(channels) {
+        if (!this.key) {
+            throw new Error(`Cannot join() additional channels without a key.\nPass a key arg to Channel.subscribeToEach().`);
+        }
+        const channelsMap = {};
+        for (const chan of channels) {
+            channelsMap[chan] = new ChannelRead(chan);
+        }
+        const joiner = RunnablePassthrough.assign({ ...channelsMap });
+        if (this.bound === defaultRunnableBound) {
+            return new ChannelBatch({
+                channel: this.channel,
+                key: this.key,
+                bound: joiner,
+            });
+        }
+        else {
+            return new ChannelBatch({
+                channel: this.channel,
+                key: this.key,
+                bound: this.bound.pipe(joiner),
+            });
+        }
+    }
+    // @ts-expect-error @TODO: fix later
+    pipe(coerceable) {
+        if (this.bound === defaultRunnableBound) {
+            return new ChannelBatch({
+                channel: this.channel,
+                key: this.key,
+                bound: _coerceToRunnable(coerceable),
+            });
+        }
+        else {
+            // Delegate to `or` in `this.bound`
+            return new ChannelBatch({
+                channel: this.channel,
+                key: this.key,
+                bound: this.bound.pipe(coerceable),
+            });
+        }
+    }
+}

package/dist/pregel/reserved.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReservedChannels = void 0;
+var ReservedChannels;
+(function (ReservedChannels) {
+    ReservedChannels["isLastStep"] = "isLastStep";
+})(ReservedChannels || (exports.ReservedChannels = ReservedChannels = {}));

package/dist/pregel/reserved.d.ts

@@ -0,0 +1,3 @@
+export declare enum ReservedChannels {
+    isLastStep = "isLastStep"
+}

package/dist/pregel/reserved.js

@@ -0,0 +1,4 @@
+export var ReservedChannels;
+(function (ReservedChannels) {
+    ReservedChannels["isLastStep"] = "isLastStep";
+})(ReservedChannels || (ReservedChannels = {}));

package/dist/pregel/validate.cjs

@@ -0,0 +1,90 @@
+"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;
+    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));
+            }
+        }
+        else if (node.lc_graph_name === "ChannelBatch" && "channel" in node) {
+            subscribedChannels.add(node.channel);
+        }
+        else {
+            console.error(node);
+            throw new Error(`Invalid node type: ${JSON.stringify(node, null, 2)}, expected Channel.subscribeTo() or Channel.subscribe_to_each()`);
+        }
+    }
+    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();
+        }
+    }
+    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.`);
+        }
+    }
+    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 (typeof output === "string") {
+        if (!(output in newChannels)) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            newChannels[output] = new last_value_js_1.LastValue();
+        }
+    }
+    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();
+            }
+        }
+    }
+    for (const chan in reserved_js_1.ReservedChannels) {
+        if (!(chan in newChannels)) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            newChannels[chan] = new last_value_js_1.LastValue();
+        }
+    }
+    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`);
+            }
+        }
+    }
+    else {
+        if (!(keys in channels)) {
+            throw new Error(`Key ${keys} not found in channels`);
+        }
+    }
+}
+exports.validateKeys = validateKeys;

package/dist/pregel/validate.d.ts

@@ -0,0 +1,15 @@
+import { BaseChannel } from "../channels/index.js";
+import { ChannelBatch, ChannelInvoke } from "./read.js";
+export declare function validateGraph({ nodes, channels, input, output, hidden, interrupt, }: {
+    nodes: Record<string, ChannelInvoke | ChannelBatch>;
+    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;
+}): void;

package/dist/pregel/validate.js

@@ -0,0 +1,85 @@
+import { LastValue } from "../channels/last_value.js";
+import { ReservedChannels } from "./reserved.js";
+export function validateGraph({ nodes, channels, input, output, hidden, interrupt, }) {
+    const newChannels = channels;
+    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));
+            }
+        }
+        else if (node.lc_graph_name === "ChannelBatch" && "channel" in node) {
+            subscribedChannels.add(node.channel);
+        }
+        else {
+            console.error(node);
+            throw new Error(`Invalid node type: ${JSON.stringify(node, null, 2)}, expected Channel.subscribeTo() or Channel.subscribe_to_each()`);
+        }
+    }
+    for (const chan of [...subscribedChannels]) {
+        if (!(chan in newChannels)) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            newChannels[chan] = new LastValue();
+        }
+    }
+    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.`);
+        }
+    }
+    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 (typeof output === "string") {
+        if (!(output in newChannels)) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            newChannels[output] = new LastValue();
+        }
+    }
+    else {
+        for (const chan of output) {
+            if (!(chan in newChannels)) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                newChannels[chan] = new LastValue();
+            }
+        }
+    }
+    for (const chan in ReservedChannels) {
+        if (!(chan in newChannels)) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            newChannels[chan] = new LastValue();
+        }
+    }
+    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`);
+            }
+        }
+    }
+    else {
+        if (!(keys in channels)) {
+            throw new Error(`Key ${keys} not found in channels`);
+        }
+    }
+}