@langchain/langgraph 0.0.11 → 0.0.13

package/dist/pregel/io.cjs

@@ -1,6 +1,50 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapOutput = exports.mapInput = void 0;
+exports.single = exports.mapOutputUpdates = exports.mapOutputValues = exports.mapInput = exports.readChannels = exports.readChannel = void 0;
+const constants_js_1 = require("../constants.cjs");
+const errors_js_1 = require("../errors.cjs");
+function readChannel(channels, chan, catch_ = true, returnException = false) {
+    try {
+        return channels[chan].get();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }
+    catch (e) {
+        if (e.name === errors_js_1.EmptyChannelError.name) {
+            if (returnException) {
+                return e;
+            }
+            else if (catch_) {
+                return null;
+            }
+        }
+        throw e;
+    }
+}
+exports.readChannel = readChannel;
+function readChannels(channels, select, skipEmpty = true
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    if (Array.isArray(select)) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const values = {};
+        for (const k of select) {
+            try {
+                values[k] = readChannel(channels, k, !skipEmpty);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (e) {
+                if (e.name === errors_js_1.EmptyChannelError.name) {
+                    continue;
+                }
+            }
+        }
+        return values;
+    }
+    else {
+        return readChannel(channels, select);
+    }
+}
+exports.readChannels = readChannels;
 /**
  * Map input chunk to a sequence of pending writes in the form [channel, value].
  */
@@ -9,49 +53,92 @@ function* mapInput(inputChannels,
 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}`);
+    if (chunk) {
+        if (Array.isArray(inputChannels) &&
+            typeof chunk === "object" &&
+            !Array.isArray(chunk) &&
+            !!chunk) {
+            for (const k in chunk) {
+                if (inputChannels.includes(k)) {
+                    yield [k, chunk[k]];
+                }
             }
         }
+        else if (Array.isArray(inputChannels)) {
+            throw new Error("Input chunk must be an object when inputChannels is an array");
+        }
+        else {
+            yield [inputChannels, chunk];
+        }
     }
 }
 exports.mapInput = mapInput;
 /**
- * Map pending writes (a list of [channel, value]) to output chunk.
+ * Map pending writes (a sequence of tuples (channel, value)) to output chunk.
  */
-function mapOutput(outputChannels, 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-pendingWrites, channels
+function* mapOutputValues(outputChannels, 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();
+    if (Array.isArray(outputChannels)) {
+        if (pendingWrites.find(([chan, _]) => outputChannels.includes(chan))) {
+            yield readChannels(channels, outputChannels);
         }
     }
     else {
-        const updated = pendingWrites
-            .filter(([chan, _]) => outputChannels.includes(chan))
-            .map(([chan, _]) => chan);
-        if (updated.length > 0) {
+        if (pendingWrites.some(([chan, _]) => chan === outputChannels)) {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            return updated.reduce((acc, chan) => {
-                acc[chan] = channels[chan].get();
-                return acc;
-            }, {});
+            yield readChannel(channels, outputChannels);
+        }
+    }
+}
+exports.mapOutputValues = mapOutputValues;
+/**
+ * Map pending writes (a sequence of tuples (channel, value)) to output chunk.
+ */
+function* mapOutputUpdates(outputChannels, tasks
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    const outputTasks = tasks.filter((task) => task.config === undefined || !task.config.tags?.includes(constants_js_1.TAG_HIDDEN));
+    if (Array.isArray(outputChannels)) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const updated = {};
+        for (const task of outputTasks) {
+            if (task.writes.some(([chan, _]) => outputChannels.includes(chan))) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const nodes = {};
+                for (const [chan, value] of task.writes) {
+                    if (outputChannels.includes(chan)) {
+                        nodes[chan] = value;
+                    }
+                }
+                updated[task.name] = nodes;
+            }
+        }
+        if (Object.keys(updated).length > 0) {
+            yield updated;
+        }
+    }
+    else {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const updated = {};
+        for (const task of outputTasks) {
+            for (const [chan, value] of task.writes) {
+                if (chan === outputChannels) {
+                    updated[task.name] = value;
+                }
+            }
+        }
+        if (Object.keys(updated).length > 0) {
+            yield updated;
         }
     }
+}
+exports.mapOutputUpdates = mapOutputUpdates;
+function single(iter) {
+    // eslint-disable-next-line no-unreachable-loop
+    for (const value of iter) {
+        return value;
+    }
     return undefined;
 }
-exports.mapOutput = mapOutput;
+exports.single = single;

package/dist/pregel/io.d.ts

@@ -1,9 +1,17 @@
 import { BaseChannel } from "../channels/base.js";
+import { PregelExecutableTask } from "./types.js";
+export declare function readChannel<C extends PropertyKey>(channels: Record<C, BaseChannel>, chan: C, catch_?: boolean, returnException?: boolean): unknown | null;
+export declare function readChannels<C extends PropertyKey>(channels: Record<C, BaseChannel>, select: C | Array<C>, skipEmpty?: boolean): Record<string, any> | any;
 /**
  * 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]>;
+export declare function mapInput<C extends PropertyKey>(inputChannels: C | Array<C>, chunk?: any): Generator<[C, any]>;
 /**
- * Map pending writes (a list of [channel, value]) to output chunk.
+ * Map pending writes (a sequence of tuples (channel, value)) to output chunk.
  */
-export declare function mapOutput(outputChannels: string | Array<string>, pendingWrites: Array<[string, any]>, channels: Record<string, BaseChannel>): any | undefined;
+export declare function mapOutputValues<C extends PropertyKey>(outputChannels: C | Array<C>, pendingWrites: readonly [C, unknown][], channels: Record<C, BaseChannel>): Generator<Record<string, any>, any>;
+/**
+ * Map pending writes (a sequence of tuples (channel, value)) to output chunk.
+ */
+export declare function mapOutputUpdates<N extends PropertyKey, C extends PropertyKey>(outputChannels: C | Array<C>, tasks: readonly PregelExecutableTask<N, C>[]): Generator<Record<N, any | Record<string, any>>>;
+export declare function single<T>(iter: IterableIterator<T>): T | undefined;

package/dist/pregel/io.js

@@ -1,3 +1,45 @@
+import { TAG_HIDDEN } from "../constants.js";
+import { EmptyChannelError } from "../errors.js";
+export function readChannel(channels, chan, catch_ = true, returnException = false) {
+    try {
+        return channels[chan].get();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }
+    catch (e) {
+        if (e.name === EmptyChannelError.name) {
+            if (returnException) {
+                return e;
+            }
+            else if (catch_) {
+                return null;
+            }
+        }
+        throw e;
+    }
+}
+export function readChannels(channels, select, skipEmpty = true
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    if (Array.isArray(select)) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const values = {};
+        for (const k of select) {
+            try {
+                values[k] = readChannel(channels, k, !skipEmpty);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (e) {
+                if (e.name === EmptyChannelError.name) {
+                    continue;
+                }
+            }
+        }
+        return values;
+    }
+    else {
+        return readChannel(channels, select);
+    }
+}
 /**
  * Map input chunk to a sequence of pending writes in the form [channel, value].
  */
@@ -6,47 +48,88 @@ export function* mapInput(inputChannels,
 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}`);
+    if (chunk) {
+        if (Array.isArray(inputChannels) &&
+            typeof chunk === "object" &&
+            !Array.isArray(chunk) &&
+            !!chunk) {
+            for (const k in chunk) {
+                if (inputChannels.includes(k)) {
+                    yield [k, chunk[k]];
+                }
             }
         }
+        else if (Array.isArray(inputChannels)) {
+            throw new Error("Input chunk must be an object when inputChannels is an array");
+        }
+        else {
+            yield [inputChannels, chunk];
+        }
     }
 }
 /**
- * Map pending writes (a list of [channel, value]) to output chunk.
+ * Map pending writes (a sequence of tuples (channel, value)) to output chunk.
  */
-export function mapOutput(outputChannels, 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-pendingWrites, channels
+export function* mapOutputValues(outputChannels, 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();
+    if (Array.isArray(outputChannels)) {
+        if (pendingWrites.find(([chan, _]) => outputChannels.includes(chan))) {
+            yield readChannels(channels, outputChannels);
         }
     }
     else {
-        const updated = pendingWrites
-            .filter(([chan, _]) => outputChannels.includes(chan))
-            .map(([chan, _]) => chan);
-        if (updated.length > 0) {
+        if (pendingWrites.some(([chan, _]) => chan === outputChannels)) {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            return updated.reduce((acc, chan) => {
-                acc[chan] = channels[chan].get();
-                return acc;
-            }, {});
+            yield readChannel(channels, outputChannels);
+        }
+    }
+}
+/**
+ * Map pending writes (a sequence of tuples (channel, value)) to output chunk.
+ */
+export function* mapOutputUpdates(outputChannels, tasks
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    const outputTasks = tasks.filter((task) => task.config === undefined || !task.config.tags?.includes(TAG_HIDDEN));
+    if (Array.isArray(outputChannels)) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const updated = {};
+        for (const task of outputTasks) {
+            if (task.writes.some(([chan, _]) => outputChannels.includes(chan))) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const nodes = {};
+                for (const [chan, value] of task.writes) {
+                    if (outputChannels.includes(chan)) {
+                        nodes[chan] = value;
+                    }
+                }
+                updated[task.name] = nodes;
+            }
+        }
+        if (Object.keys(updated).length > 0) {
+            yield updated;
+        }
+    }
+    else {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const updated = {};
+        for (const task of outputTasks) {
+            for (const [chan, value] of task.writes) {
+                if (chan === outputChannels) {
+                    updated[task.name] = value;
+                }
+            }
+        }
+        if (Object.keys(updated).length > 0) {
+            yield updated;
         }
     }
+}
+export function single(iter) {
+    // eslint-disable-next-line no-unreachable-loop
+    for (const value of iter) {
+        return value;
+    }
     return undefined;
 }

package/dist/pregel/read.cjs

@@ -1,18 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChannelInvoke = exports.ChannelRead = void 0;
+exports.PregelNode = 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) {
+const write_js_1 = require("./write.cjs");
+const utils_js_1 = require("../utils.cjs");
+class ChannelRead extends utils_js_1.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,
@@ -26,42 +25,45 @@ class ChannelRead extends runnables_1.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: 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
+    static doRead(config, channel, fresh, mapper) {
         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;
+        if (mapper) {
+            return mapper(read(channel, fresh));
+        }
+        else {
+            return read(channel, fresh);
         }
-        return read(this.channel);
     }
 }
 exports.ChannelRead = ChannelRead;
-const defaultRunnableBound = /* #__PURE__ */ new runnables_1.RunnablePassthrough();
-class ChannelInvoke extends runnables_1.RunnableBinding {
+const defaultRunnableBound = 
+/* #__PURE__ */ new runnables_1.RunnablePassthrough();
+class PregelNode extends runnables_1.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 : []),
@@ -79,7 +81,7 @@ class ChannelInvoke extends runnables_1.RunnableBinding {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: "ChannelInvoke"
+            value: "PregelNode"
         });
         Object.defineProperty(this, "channels", {
             enumerable: true,
@@ -94,48 +96,126 @@ class ChannelInvoke extends runnables_1.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 write_js_1.ChannelWrite &&
+            // eslint-disable-next-line no-instanceof/no-instanceof
+            newWriters[newWriters.length - 2] instanceof write_js_1.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 runnables_1.RunnableSequence({
+                first: writers[0],
+                middle: writers.slice(1, writers.length - 1),
+                last: writers[writers.length - 1],
+            });
+        }
+        else if (writers.length > 0) {
+            return new runnables_1.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 (write_js_1.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: (0, runnables_1._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,
@@ -143,4 +223,4 @@ class ChannelInvoke extends runnables_1.RunnableBinding {
         }
     }
 }
-exports.ChannelInvoke = ChannelInvoke;
+exports.PregelNode = PregelNode;

package/dist/pregel/read.d.ts

@@ -1,28 +1,37 @@
-import { RunnableBinding, RunnableBindingArgs, RunnableConfig, RunnableLambda, RunnableLike } from "@langchain/core/runnables";
-import { ConfigurableFieldSpec } from "../checkpoint/index.js";
-export declare class ChannelRead<RunInput = any, RunOutput = any> extends RunnableLambda<RunInput, RunOutput> {
+import { Runnable, RunnableBinding, RunnableBindingArgs, RunnableConfig, RunnableLike } from "@langchain/core/runnables";
+import { RunnableCallable } from "../utils.js";
+export declare class ChannelRead<RunInput = any> extends RunnableCallable {
     lc_graph_name: string;
     channel: string | Array<string>;
-    constructor(channel: string | Array<string>);
-    get configSpecs(): ConfigurableFieldSpec[];
-    _read(_: any, config: RunnableConfig): any;
+    fresh: boolean;
+    mapper?: (args: any) => any;
+    constructor(channel: string | Array<string>, mapper?: (args: any) => any, fresh?: boolean);
+    static doRead<T = unknown>(config: RunnableConfig, channel: string | Array<string>, fresh: boolean, mapper?: (args: unknown) => unknown): T;
 }
-interface ChannelInvokeArgs<RunInput, RunOutput> extends Partial<RunnableBindingArgs<RunInput, RunOutput>> {
-    channels: Record<string, string> | string;
+interface PregelNodeArgs<RunInput, RunOutput> extends Partial<RunnableBindingArgs<RunInput, RunOutput>> {
+    channels: Record<string, string> | string[];
     triggers: Array<string>;
-    when?: (args: any) => boolean;
-    config?: RunnableConfig;
+    mapper?: (args: any) => any;
+    writers?: Runnable<RunOutput, unknown>[];
     tags?: string[];
+    bound?: Runnable<RunInput, RunOutput>;
+    kwargs?: Record<string, any>;
+    config?: RunnableConfig;
 }
-export type ChannelInvokeInputType = any;
-export type ChannelInvokeOutputType = any;
-export declare class ChannelInvoke<RunInput = ChannelInvokeInputType, RunOutput = ChannelInvokeOutputType> extends RunnableBinding<RunInput, RunOutput, RunnableConfig> {
+export type PregelNodeInputType = any;
+export type PregelNodeOutputType = any;
+export declare class PregelNode<RunInput = PregelNodeInputType, RunOutput = PregelNodeOutputType> extends RunnableBinding<RunInput, RunOutput, RunnableConfig> {
     lc_graph_name: string;
-    channels: Record<string, string> | 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>>;
+    mapper?: (args: any) => any;
+    writers: Runnable[];
+    bound: Runnable<RunInput, RunOutput>;
+    kwargs: Record<string, any>;
+    constructor(fields: PregelNodeArgs<RunInput, RunOutput>);
+    getWriters(): Array<Runnable>;
+    getNode(): Runnable<RunInput, RunOutput> | undefined;
+    join(channels: Array<string>): PregelNode<RunInput, RunOutput>;
+    pipe<NewRunOutput>(coerceable: RunnableLike): PregelNode<RunInput, Exclude<NewRunOutput, Error>>;
 }
 export {};