@langchain/langgraph 0.0.10 → 0.0.12

package/dist/checkpoint/base.js

@@ -7,6 +7,15 @@ export function emptyCheckpoint() {
         versionsSeen: {},
     };
 }
+export function copyCheckpoint(checkpoint) {
+    return {
+        v: checkpoint.v,
+        ts: checkpoint.ts,
+        channelValues: { ...checkpoint.channelValues },
+        channelVersions: { ...checkpoint.channelVersions },
+        versionsSeen: { ...checkpoint.versionsSeen },
+    };
+}
 export class BaseCheckpointSaver {
     constructor() {
         Object.defineProperty(this, "at", {

package/dist/checkpoint/index.cjs

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseCheckpointSaver = exports.emptyCheckpoint = exports.MemorySaver = void 0;
+exports.BaseCheckpointSaver = exports.emptyCheckpoint = exports.MemorySaverAssertImmutable = exports.MemorySaver = void 0;
 var memory_js_1 = require("./memory.cjs");
 Object.defineProperty(exports, "MemorySaver", { enumerable: true, get: function () { return memory_js_1.MemorySaver; } });
+Object.defineProperty(exports, "MemorySaverAssertImmutable", { enumerable: true, get: function () { return memory_js_1.MemorySaverAssertImmutable; } });
 var base_js_1 = require("./base.cjs");
 Object.defineProperty(exports, "emptyCheckpoint", { enumerable: true, get: function () { return base_js_1.emptyCheckpoint; } });
 Object.defineProperty(exports, "BaseCheckpointSaver", { enumerable: true, get: function () { return base_js_1.BaseCheckpointSaver; } });

package/dist/checkpoint/index.d.ts

@@ -1,2 +1,2 @@
-export { MemorySaver } from "./memory.js";
+export { MemorySaver, MemorySaverAssertImmutable } from "./memory.js";
 export { type ConfigurableFieldSpec, type Checkpoint, type CheckpointAt, emptyCheckpoint, BaseCheckpointSaver, } from "./base.js";

package/dist/checkpoint/index.js

@@ -1,2 +1,2 @@
-export { MemorySaver } from "./memory.js";
+export { MemorySaver, MemorySaverAssertImmutable } from "./memory.js";
 export { emptyCheckpoint, BaseCheckpointSaver, } from "./base.js";

package/dist/checkpoint/memory.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemorySaver = void 0;
+exports.MemorySaverAssertImmutable = exports.MemorySaver = void 0;
 const base_js_1 = require("./base.cjs");
 class MemorySaver extends base_js_1.BaseCheckpointSaver {
     constructor() {
@@ -33,3 +33,33 @@ class MemorySaver extends base_js_1.BaseCheckpointSaver {
     }
 }
 exports.MemorySaver = MemorySaver;
+class MemorySaverAssertImmutable extends MemorySaver {
+    constructor() {
+        super();
+        Object.defineProperty(this, "storageForCopies", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        this.storageForCopies = {};
+        this.at = "end_of_step" /* CheckpointAt.END_OF_STEP */;
+    }
+    put(config, checkpoint) {
+        const threadId = config.configurable?.threadId;
+        if (!this.storageForCopies[threadId]) {
+            this.storageForCopies[threadId] = {};
+        }
+        // assert checkpoint hasn't been modified since last written
+        const saved = super.get(config);
+        if (saved) {
+            const savedTs = saved.ts;
+            if (this.storageForCopies[threadId][savedTs]) {
+                console.assert(this.storageForCopies[threadId][savedTs] === saved, "Checkpoint has been modified");
+            }
+        }
+        this.storageForCopies[threadId][checkpoint.ts] = (0, base_js_1.copyCheckpoint)(checkpoint);
+        return super.put(config, checkpoint);
+    }
+}
+exports.MemorySaverAssertImmutable = MemorySaverAssertImmutable;

package/dist/checkpoint/memory.d.ts

@@ -6,3 +6,8 @@ export declare class MemorySaver extends BaseCheckpointSaver {
     get(config: RunnableConfig): Checkpoint | undefined;
     put(config: RunnableConfig, checkpoint: Checkpoint): void;
 }
+export declare class MemorySaverAssertImmutable extends MemorySaver {
+    storageForCopies: Record<string, Record<string, Checkpoint>>;
+    constructor();
+    put(config: RunnableConfig, checkpoint: Checkpoint): void;
+}

package/dist/checkpoint/memory.js

@@ -1,4 +1,4 @@
-import { BaseCheckpointSaver, } from "./base.js";
+import { BaseCheckpointSaver, copyCheckpoint, } from "./base.js";
 export class MemorySaver extends BaseCheckpointSaver {
     constructor() {
         super(...arguments);
@@ -29,3 +29,32 @@ export class MemorySaver extends BaseCheckpointSaver {
         this.storage[config.configurable?.threadId] = checkpoint;
     }
 }
+export class MemorySaverAssertImmutable extends MemorySaver {
+    constructor() {
+        super();
+        Object.defineProperty(this, "storageForCopies", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        this.storageForCopies = {};
+        this.at = "end_of_step" /* CheckpointAt.END_OF_STEP */;
+    }
+    put(config, checkpoint) {
+        const threadId = config.configurable?.threadId;
+        if (!this.storageForCopies[threadId]) {
+            this.storageForCopies[threadId] = {};
+        }
+        // assert checkpoint hasn't been modified since last written
+        const saved = super.get(config);
+        if (saved) {
+            const savedTs = saved.ts;
+            if (this.storageForCopies[threadId][savedTs]) {
+                console.assert(this.storageForCopies[threadId][savedTs] === saved, "Checkpoint has been modified");
+            }
+        }
+        this.storageForCopies[threadId][checkpoint.ts] = copyCheckpoint(checkpoint);
+        return super.put(config, checkpoint);
+    }
+}

package/dist/graph/graph.cjs

@@ -21,9 +21,10 @@ class Branch {
         this.condition = condition;
         this.ends = ends;
     }
+    async runnable(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    runnable(input, options) {
-        const result = this.condition(input, options?.config);
+    input, options) {
+        const result = await this.condition(input, options?.config);
         let destination;
         if (this.ends) {
             destination = this.ends[result];
@@ -107,9 +108,6 @@ class Graph {
         if (!this.nodes[startKey]) {
             throw new Error(`Need to addNode \`${startKey}\` first`);
         }
-        if (condition.constructor.name === "AsyncFunction") {
-            throw new Error("Condition cannot be an async function");
-        }
         if (conditionalEdgeMapping) {
             const mappingValues = Array.from(Object.values(conditionalEdgeMapping));
             const nodesValues = Object.keys(this.nodes);

package/dist/graph/graph.d.ts

@@ -11,7 +11,7 @@ declare class Branch {
     constructor(condition: CallableFunction, ends?: EndsMap);
     runnable(input: any, options?: {
         config?: RunnableConfig;
-    }): Runnable;
+    }): Promise<Runnable>;
 }
 export declare class Graph<RunInput = any, RunOutput = any> {
     nodes: Record<string, Runnable<RunInput, RunOutput>>;

package/dist/graph/graph.js

@@ -18,9 +18,10 @@ class Branch {
         this.condition = condition;
         this.ends = ends;
     }
+    async runnable(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    runnable(input, options) {
-        const result = this.condition(input, options?.config);
+    input, options) {
+        const result = await this.condition(input, options?.config);
         let destination;
         if (this.ends) {
             destination = this.ends[result];
@@ -104,9 +105,6 @@ export class Graph {
         if (!this.nodes[startKey]) {
             throw new Error(`Need to addNode \`${startKey}\` first`);
         }
-        if (condition.constructor.name === "AsyncFunction") {
-            throw new Error("Condition cannot be an async function");
-        }
         if (conditionalEdgeMapping) {
             const mappingValues = Array.from(Object.values(conditionalEdgeMapping));
             const nodesValues = Object.keys(this.nodes);

package/dist/index.cjs

@@ -1,9 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageGraph = exports.StateGraph = exports.START = exports.Graph = exports.END = void 0;
+exports.BaseCheckpointSaver = exports.emptyCheckpoint = exports.MemorySaverAssertImmutable = exports.MemorySaver = exports.MessageGraph = exports.StateGraph = exports.START = exports.Graph = exports.END = void 0;
 var index_js_1 = require("./graph/index.cjs");
 Object.defineProperty(exports, "END", { enumerable: true, get: function () { return index_js_1.END; } });
 Object.defineProperty(exports, "Graph", { enumerable: true, get: function () { return index_js_1.Graph; } });
 Object.defineProperty(exports, "START", { enumerable: true, get: function () { return index_js_1.START; } });
 Object.defineProperty(exports, "StateGraph", { enumerable: true, get: function () { return index_js_1.StateGraph; } });
 Object.defineProperty(exports, "MessageGraph", { enumerable: true, get: function () { return index_js_1.MessageGraph; } });
+var index_js_2 = require("./checkpoint/index.cjs");
+Object.defineProperty(exports, "MemorySaver", { enumerable: true, get: function () { return index_js_2.MemorySaver; } });
+Object.defineProperty(exports, "MemorySaverAssertImmutable", { enumerable: true, get: function () { return index_js_2.MemorySaverAssertImmutable; } });
+var index_js_3 = require("./checkpoint/index.cjs");
+Object.defineProperty(exports, "emptyCheckpoint", { enumerable: true, get: function () { return index_js_3.emptyCheckpoint; } });
+Object.defineProperty(exports, "BaseCheckpointSaver", { enumerable: true, get: function () { return index_js_3.BaseCheckpointSaver; } });

package/dist/index.d.ts

@@ -1 +1,3 @@
 export { END, Graph, type StateGraphArgs, START, StateGraph, MessageGraph, } from "./graph/index.js";
+export { MemorySaver, MemorySaverAssertImmutable } from "./checkpoint/index.js";
+export { type ConfigurableFieldSpec, type Checkpoint, type CheckpointAt, emptyCheckpoint, BaseCheckpointSaver, } from "./checkpoint/index.js";

package/dist/index.js

@@ -1 +1,3 @@
 export { END, Graph, START, StateGraph, MessageGraph, } from "./graph/index.js";
+export { MemorySaver, MemorySaverAssertImmutable } from "./checkpoint/index.js";
+export { emptyCheckpoint, BaseCheckpointSaver, } from "./checkpoint/index.js";

package/dist/prebuilt/tool_executor.cjs

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ToolExecutor = void 0;
 const runnables_1 = require("@langchain/core/runnables");
-const INVALID_TOOL_MSG_TEMPLATE = `{requestedToolName} is not a valid tool, try one of [availableToolNamesString].`;
+const INVALID_TOOL_MSG_TEMPLATE = `{requestedToolName} is not a valid tool, try one of {availableToolNamesString}.`;
 class ToolExecutor extends runnables_1.RunnableBinding {
     constructor(fields) {
         const fieldsWithDefaults = {

package/dist/prebuilt/tool_executor.js

@@ -1,5 +1,5 @@
 import { RunnableBinding, RunnableLambda, } from "@langchain/core/runnables";
-const INVALID_TOOL_MSG_TEMPLATE = `{requestedToolName} is not a valid tool, try one of [availableToolNamesString].`;
+const INVALID_TOOL_MSG_TEMPLATE = `{requestedToolName} is not a valid tool, try one of {availableToolNamesString}.`;
 export class ToolExecutor extends RunnableBinding {
     constructor(fields) {
         const fieldsWithDefaults = {

package/dist/pregel/index.cjs

@@ -56,12 +56,6 @@ class Channel {
             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>]> =
@@ -405,72 +399,54 @@ 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;
-                        }
+    for (const [name, proc] of Object.entries(processes)) {
+        let seen = checkpoint.versionsSeen[name];
+        if (!seen) {
+            checkpoint.versionsSeen[name] = {};
+            seen = checkpoint.versionsSeen[name];
+        }
+        // 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);
                     }
                 }
-            }
-            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 }];
+                // 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]);
-                    seen[proc.channel] = checkpoint.channelVersions[proc.channel];
+                }
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (error) {
+                if (error.name === base_js_1.EmptyChannelError.name) {
+                    continue;
+                }
+                else {
+                    throw error;
                 }
             }
         }

package/dist/pregel/index.d.ts

@@ -3,7 +3,7 @@ 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 { ChannelInvoke } from "./read.js";
 import { ChannelWrite } from "./write.js";
 export declare class GraphRecursionError extends Error {
     constructor(message?: string);
@@ -19,7 +19,6 @@ export declare class Channel {
         when?: (arg: any) => boolean;
         tags?: string[];
     }): ChannelInvoke;
-    static subscribeToEach(inbox: string, key?: string): ChannelBatch;
     static writeTo(...args: any[]): ChannelWrite;
 }
 export interface PregelInterface {
@@ -47,7 +46,7 @@ export interface PregelInterface {
      * @default []
      */
     interrupt?: string[];
-    nodes: Record<string, ChannelInvoke | ChannelBatch>;
+    nodes: Record<string, ChannelInvoke>;
     checkpointer?: BaseCheckpointSaver;
     stepTimeout?: number;
 }
@@ -64,7 +63,7 @@ export declare class Pregel extends Runnable<PregelInputType, PregelOutputType,
     input: string | Array<string>;
     hidden: Array<string>;
     debug: boolean;
-    nodes: Record<string, ChannelInvoke | ChannelBatch>;
+    nodes: Record<string, ChannelInvoke>;
     checkpointer?: BaseCheckpointSaver;
     stepTimeout?: number;
     interrupt: string[];

package/dist/pregel/index.js

@@ -3,7 +3,7 @@ import { Runnable, _coerceToRunnable, ensureConfig, patchConfig, } from "@langch
 import { IterableReadableStream } from "@langchain/core/utils/stream";
 import { EmptyChannelError, createCheckpoint, emptyChannels, } from "../channels/base.js";
 import { emptyCheckpoint, } from "../checkpoint/base.js";
-import { ChannelBatch, ChannelInvoke } from "./read.js";
+import { ChannelInvoke } from "./read.js";
 import { validateGraph } from "./validate.js";
 import { ReservedChannelsMap } from "./reserved.js";
 import { mapInput, mapOutput } from "./io.js";
@@ -52,12 +52,6 @@ export class Channel {
             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>]> =
@@ -399,72 +393,54 @@ 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;
-                        }
+    for (const [name, proc] of Object.entries(processes)) {
+        let seen = checkpoint.versionsSeen[name];
+        if (!seen) {
+            checkpoint.versionsSeen[name] = {};
+            seen = checkpoint.versionsSeen[name];
+        }
+        // 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);
                     }
                 }
-            }
-            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 }];
+                // 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]);
-                    seen[proc.channel] = checkpoint.channelVersions[proc.channel];
+                }
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (error) {
+                if (error.name === EmptyChannelError.name) {
+                    continue;
+                }
+                else {
+                    throw error;
                 }
             }
         }

package/dist/pregel/read.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChannelBatch = exports.ChannelInvoke = exports.ChannelRead = void 0;
+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 {
@@ -144,74 +144,3 @@ class ChannelInvoke extends runnables_1.RunnableBinding {
     }
 }
 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

@@ -1,4 +1,4 @@
-import { Runnable, RunnableBinding, RunnableBindingArgs, RunnableConfig, RunnableEach, RunnableLambda, RunnableLike } from "@langchain/core/runnables";
+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> {
     lc_graph_name: string;
@@ -25,19 +25,4 @@ export declare class ChannelInvoke<RunInput = ChannelInvokeInputType, 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 {};