@langchain/langgraph 0.0.33 → 0.0.34

package/dist/pregel/index.js

@@ -7,7 +7,7 @@ import { PregelNode } from "./read.js";
 import { validateGraph, validateKeys } from "./validate.js";
 import { mapInput, mapOutputUpdates, mapOutputValues, readChannel, readChannels, single, } from "./io.js";
 import { ChannelWrite, PASSTHROUGH } from "./write.js";
-import { CONFIG_KEY_READ, CONFIG_KEY_SEND, INTERRUPT, TAG_HIDDEN, TASKS, } from "../constants.js";
+import { _isSend, _isSendInterface, CONFIG_KEY_READ, CONFIG_KEY_SEND, INTERRUPT, TAG_HIDDEN, TASKS, } from "../constants.js";
 import { EmptyChannelError, GraphRecursionError, GraphValueError, InvalidUpdateError, } from "../errors.js";
 const DEFAULT_LOOP_LIMIT = 25;
 function isString(value) {
@@ -209,7 +209,7 @@ export class Pregel extends Runnable {
         const checkpoint = saved ? saved.checkpoint : emptyCheckpoint();
         const channels = emptyChannels(this.channels, checkpoint);
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const [_, nextTasks] = _prepareNextTasks(checkpoint, this.nodes, channels, false);
+        const [_, nextTasks] = _prepareNextTasks(checkpoint, this.nodes, channels, false, { step: -1 });
         return {
             values: readChannels(channels, this.streamChannelsAsIs),
             next: nextTasks.map((task) => task.name),
@@ -226,7 +226,7 @@ export class Pregel extends Runnable {
         for await (const saved of this.checkpointer.list(config, limit, before)) {
             const channels = emptyChannels(this.channels, saved.checkpoint);
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const [_, nextTasks] = _prepareNextTasks(saved.checkpoint, this.nodes, channels, false);
+            const [_, nextTasks] = _prepareNextTasks(saved.checkpoint, this.nodes, channels, false, { step: -1 });
             yield {
                 values: readChannels(channels, this.streamChannelsAsIs),
                 next: nextTasks.map((task) => task.name),
@@ -376,7 +376,7 @@ export class Pregel extends Runnable {
             }
             if (inputPendingWrites.length) {
                 // discard any unfinished tasks from previous checkpoint
-                const discarded = _prepareNextTasks(checkpoint, processes, channels, true);
+                const discarded = _prepareNextTasks(checkpoint, processes, channels, true, { step: -1 });
                 checkpoint = discarded[0]; // eslint-disable-line prefer-destructuring
                 // apply input writes
                 _applyWrites(checkpoint, channels, inputPendingWrites);
@@ -415,7 +415,7 @@ export class Pregel extends Runnable {
             // with channel updates applied only at the transition between steps
             const stop = start + (config.recursionLimit ?? DEFAULT_LOOP_LIMIT);
             for (let step = start; step < stop + 1; step += 1) {
-                const [nextCheckpoint, nextTasks] = _prepareNextTasks(checkpoint, processes, channels, true);
+                const [nextCheckpoint, nextTasks] = _prepareNextTasks(checkpoint, processes, channels, true, { step });
                 // if no more tasks, we're done
                 if (nextTasks.length === 0 && step === start) {
                     throw new GraphValueError(`No tasks to run in graph.`);
@@ -474,7 +474,10 @@ export class Pregel extends Runnable {
                     yield* mapOutputValues(outputKeys, pendingWrites, channels);
                 }
                 else if (streamMode === "updates") {
-                    yield* mapOutputUpdates(outputKeys, nextTasks);
+                    // TODO: Refactor
+                    for await (const task of nextTasks) {
+                        yield* mapOutputUpdates(outputKeys, [task]);
+                    }
                 }
                 // save end of step checkpoint
                 if (this.checkpointer) {
@@ -580,15 +583,46 @@ export function _localRead(checkpoint, channels, writes, select, fresh = false)
         return readChannels(channels, select);
     }
 }
+export function _localWrite(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+commit, processes, channels, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+writes) {
+    for (const [chan, value] of writes) {
+        if (chan === TASKS) {
+            if (!_isSend(value)) {
+                throw new InvalidUpdateError(`Invalid packet type, expected SendProtocol, got ${JSON.stringify(value)}`);
+            }
+            if (!(value.node in processes)) {
+                throw new InvalidUpdateError(`Invalid node name ${value.node} in packet`);
+            }
+        }
+        else if (!(chan in channels)) {
+            console.warn(`Skipping write for channel '${chan}' which has no readers`);
+        }
+    }
+    commit(writes);
+}
 export function _applyWrites(checkpoint, channels, pendingWrites) {
+    if (checkpoint.pending_sends) {
+        checkpoint.pending_sends = [];
+    }
     const pendingWritesByChannel = {};
     // Group writes by channel
     for (const [chan, val] of pendingWrites) {
-        if (chan in pendingWritesByChannel) {
-            pendingWritesByChannel[chan].push(val);
+        if (chan === TASKS) {
+            checkpoint.pending_sends.push({
+                node: val.node,
+                args: val.args,
+            });
         }
         else {
-            pendingWritesByChannel[chan] = [val];
+            if (chan in pendingWritesByChannel) {
+                pendingWritesByChannel[chan].push(val);
+            }
+            else {
+                pendingWritesByChannel[chan] = [val];
+            }
         }
     }
     // find the highest version of all channels
@@ -607,7 +641,7 @@ export function _applyWrites(checkpoint, channels, pendingWrites) {
             }
             catch (e) {
                 if (e.name === InvalidUpdateError.unminifiable_name) {
-                    throw new InvalidUpdateError(`Invalid update for channel ${chan}. Values: ${vals}`);
+                    throw new InvalidUpdateError(`Invalid update for channel ${chan}. Values: ${vals}\n\nError: ${e.message}`);
                 }
             }
             // side effect: update checkpoint channel versions
@@ -626,15 +660,60 @@ export function _applyWrites(checkpoint, channels, pendingWrites) {
         }
     }
 }
-export function _prepareNextTasks(checkpoint, processes, channels, forExecution) {
+export function _prepareNextTasks(checkpoint, processes, channels, forExecution, extra) {
     const newCheckpoint = copyCheckpoint(checkpoint);
     const tasks = [];
     const taskDescriptions = [];
+    for (const packet of checkpoint.pending_sends) {
+        if (!_isSendInterface(packet)) {
+            console.warn(`Ignoring invalid packet ${JSON.stringify(packet)} in pending sends.`);
+            continue;
+        }
+        if (!(packet.node in processes)) {
+            console.warn(`Ignoring unknown node name ${packet.node} in pending sends.`);
+            continue;
+        }
+        if (forExecution) {
+            const proc = processes[packet.node];
+            const node = proc.getNode();
+            if (node !== undefined) {
+                const triggers = [TASKS];
+                const metadata = {
+                    langgraph_step: extra.step,
+                    langgraph_node: packet.node,
+                    langgraph_triggers: triggers,
+                    langgraph_task_idx: tasks.length,
+                };
+                const writes = [];
+                tasks.push({
+                    name: packet.node,
+                    input: packet.args,
+                    proc: node,
+                    writes,
+                    config: patchConfig(mergeConfigs(proc.config, processes[packet.node].config, {
+                        metadata,
+                    }), {
+                        runName: packet.node,
+                        // callbacks:
+                        configurable: {
+                            [CONFIG_KEY_SEND]: _localWrite.bind(undefined, (items) => writes.push(...items), processes, channels),
+                            [CONFIG_KEY_READ]: _localRead.bind(undefined, checkpoint, channels, writes),
+                        },
+                    }),
+                });
+            }
+        }
+        else {
+            taskDescriptions.push({
+                name: packet.node,
+                input: packet.args,
+            });
+        }
+    }
     // Check if any processes should be run in next step
     // If so, prepare the values to be passed to them
     for (const [name, proc] of Object.entries(processes)) {
-        // If any of the channels read by this process were updated
-        if (proc.triggers
+        const hasUpdatedChannels = proc.triggers
             .filter((chan) => {
             try {
                 readChannel(channels, chan, false);
@@ -645,7 +724,9 @@ export function _prepareNextTasks(checkpoint, processes, channels, forExecution)
             }
         })
             .some((chan) => getChannelVersion(newCheckpoint, chan) >
-            getVersionSeen(newCheckpoint, name, chan))) {
+            getVersionSeen(newCheckpoint, name, chan));
+        // If any of the channels read by this process were updated
+        if (hasUpdatedChannels) {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             let val;
             // If all trigger channels subscribed by this process are not empty
@@ -710,12 +791,25 @@ export function _prepareNextTasks(checkpoint, processes, channels, forExecution)
                 });
                 const node = proc.getNode();
                 if (node !== undefined) {
+                    const metadata = {
+                        langgraph_step: extra.step,
+                        langgraph_node: name,
+                        langgraph_triggers: proc.triggers,
+                        langgraph_task_idx: tasks.length,
+                    };
+                    const writes = [];
                     tasks.push({
                         name,
                         input: val,
                         proc: node,
-                        writes: [],
-                        config: proc.config,
+                        writes,
+                        config: patchConfig(mergeConfigs(proc.config, { metadata }), {
+                            runName: name,
+                            configurable: {
+                                [CONFIG_KEY_SEND]: _localWrite.bind(undefined, (items) => writes.push(...items), processes, channels),
+                                [CONFIG_KEY_READ]: _localRead.bind(undefined, checkpoint, channels, writes),
+                            },
+                        }),
                     });
                 }
             }

package/dist/pregel/io.cjs

@@ -98,39 +98,42 @@ 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;
-        }
+    if (!outputTasks.length) {
+        return;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let updated;
+    if (!Array.isArray(outputChannels)) {
+        updated = outputTasks.flatMap((task) => task.writes
+            .filter(([chan, _]) => chan === outputChannels)
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            .map(([_, value]) => [task.name, value]));
     }
     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;
-                }
-            }
+        updated = outputTasks
+            .filter((task) => task.writes.some(([chan]) => outputChannels.includes(chan)))
+            .map((task) => [
+            task.name,
+            Object.fromEntries(task.writes.filter(([chan]) => outputChannels.includes(chan))),
+        ]);
+    }
+    const grouped = Object.fromEntries(outputTasks.map((t) => [t.name, []])
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    );
+    for (const [node, value] of updated) {
+        grouped[node].push(value);
+    }
+    for (const [node, value] of Object.entries(grouped)) {
+        if (value.length === 0) {
+            delete grouped[node];
         }
-        if (Object.keys(updated).length > 0) {
-            yield updated;
+        else if (value.length === 1) {
+            // TODO: Fix incorrect cast here
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            grouped[node] = value[0];
         }
     }
+    yield grouped;
 }
 exports.mapOutputUpdates = mapOutputUpdates;
 function single(iter) {

package/dist/pregel/io.d.ts

@@ -13,5 +13,5 @@ export declare function mapOutputValues<C extends PropertyKey>(outputChannels: C
 /**
  * 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 mapOutputUpdates<N extends PropertyKey, C extends PropertyKey>(outputChannels: C | Array<C>, tasks: readonly PregelExecutableTask<N, C>[]): Generator<Record<N, Record<string, any> | Record<string, any>[]>>;
 export declare function single<T>(iter: IterableIterator<T>): T | null;

package/dist/pregel/io.js

@@ -91,39 +91,42 @@ 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;
-        }
+    if (!outputTasks.length) {
+        return;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let updated;
+    if (!Array.isArray(outputChannels)) {
+        updated = outputTasks.flatMap((task) => task.writes
+            .filter(([chan, _]) => chan === outputChannels)
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            .map(([_, value]) => [task.name, value]));
     }
     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;
-                }
-            }
+        updated = outputTasks
+            .filter((task) => task.writes.some(([chan]) => outputChannels.includes(chan)))
+            .map((task) => [
+            task.name,
+            Object.fromEntries(task.writes.filter(([chan]) => outputChannels.includes(chan))),
+        ]);
+    }
+    const grouped = Object.fromEntries(outputTasks.map((t) => [t.name, []])
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    );
+    for (const [node, value] of updated) {
+        grouped[node].push(value);
+    }
+    for (const [node, value] of Object.entries(grouped)) {
+        if (value.length === 0) {
+            delete grouped[node];
         }
-        if (Object.keys(updated).length > 0) {
-            yield updated;
+        else if (value.length === 1) {
+            // TODO: Fix incorrect cast here
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            grouped[node] = value[0];
         }
     }
+    yield grouped;
 }
 export function single(iter) {
     // eslint-disable-next-line no-unreachable-loop

package/dist/pregel/read.cjs

@@ -136,7 +136,10 @@ class PregelNode extends runnables_1.RunnableBinding {
             // 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);
+            // careful to not modify the original writers list or ChannelWrite
+            const endWriters = newWriters.slice(-2);
+            const combinedWrites = endWriters[0].writes.concat(endWriters[1].writes);
+            newWriters[newWriters.length - 2] = new write_js_1.ChannelWrite(combinedWrites, endWriters[0].config?.tags);
             newWriters.pop();
         }
         return newWriters;

package/dist/pregel/read.js

@@ -132,7 +132,10 @@ export class PregelNode extends RunnableBinding {
             // eslint-disable-next-line no-instanceof/no-instanceof
             newWriters[newWriters.length - 2] instanceof ChannelWrite) {
             // we can combine writes if they are consecutive
-            newWriters[newWriters.length - 2].writes.push(...newWriters[newWriters.length - 1].writes);
+            // careful to not modify the original writers list or ChannelWrite
+            const endWriters = newWriters.slice(-2);
+            const combinedWrites = endWriters[0].writes.concat(endWriters[1].writes);
+            newWriters[newWriters.length - 2] = new ChannelWrite(combinedWrites, endWriters[0].config?.tags);
             newWriters.pop();
         }
         return newWriters;

package/dist/pregel/write.cjs

@@ -3,8 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChannelWrite = exports.PASSTHROUGH = exports.SKIP_WRITE = void 0;
 const constants_js_1 = require("../constants.cjs");
 const utils_js_1 = require("../utils.cjs");
-exports.SKIP_WRITE = {};
-exports.PASSTHROUGH = {};
+const errors_js_1 = require("../errors.cjs");
+exports.SKIP_WRITE = {
+    [Symbol.for("LG_SKIP_WRITE")]: true,
+};
+function _isSkipWrite(x) {
+    return (typeof x === "object" &&
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        x?.[Symbol.for("LG_SKIP_WRITE")] !== undefined);
+}
+exports.PASSTHROUGH = {
+    [Symbol.for("LG_PASSTHROUGH")]: true,
+};
+function _isPassthrough(x) {
+    return (typeof x === "object" &&
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        x?.[Symbol.for("LG_PASSTHROUGH")] !== undefined);
+}
 const IS_WRITER = Symbol("IS_WRITER");
 /**
  * Mapping of write channels to Runnables that return the value to be written,
@@ -13,7 +28,9 @@ const IS_WRITER = Symbol("IS_WRITER");
 class ChannelWrite extends utils_js_1.RunnableCallable {
     constructor(writes, tags) {
         const name = `ChannelWrite<${writes
-            .map(({ channel }) => channel)
+            .map((packet) => {
+            return (0, constants_js_1._isSend)(packet) ? packet.node : packet.channel;
+        })
             .join(",")}>`;
         super({
             ...{ writes, name, tags },
@@ -28,34 +45,53 @@ class ChannelWrite extends utils_js_1.RunnableCallable {
         this.writes = writes;
     }
     async _getWriteValues(input, config) {
-        return Promise.all(this.writes
-            .map((write) => ({
-            channel: write.channel,
-            value: write.value === exports.PASSTHROUGH ? input : write.value,
-            skipNone: write.skipNone,
-            mapper: write.mapper,
-        }))
-            .map(async (write) => ({
-            channel: write.channel,
-            value: write.mapper
-                ? await write.mapper.invoke(write.value, config)
-                : write.value,
-            skipNone: write.skipNone,
-            mapper: write.mapper,
-        }))).then((writes) => writes
-            .filter((write) => !write.skipNone || write.value !== null)
-            .reduce((acc, write) => {
-            acc[write.channel] = write.value;
-            return acc;
-        }, {}));
+        const writes = this.writes
+            .filter(constants_js_1._isSend)
+            .map((packet) => {
+            return [constants_js_1.TASKS, packet];
+        });
+        const entries = this.writes.filter((write) => {
+            return !(0, constants_js_1._isSend)(write);
+        });
+        const invalidEntry = entries.find((write) => {
+            return write.channel === constants_js_1.TASKS;
+        });
+        if (invalidEntry) {
+            throw new errors_js_1.InvalidUpdateError(`Cannot write to the reserved channel ${constants_js_1.TASKS}`);
+        }
+        const values = await Promise.all(entries.map(async (write) => {
+            let value;
+            if (_isPassthrough(write.value)) {
+                value = input;
+            }
+            else {
+                value = write.value;
+            }
+            const mappedValue = write.mapper
+                ? await write.mapper.invoke(value, config)
+                : value;
+            return {
+                ...write,
+                value: mappedValue,
+            };
+        })).then((writes) => {
+            return writes
+                .filter((write) => !write.skipNone || write.value !== null)
+                .map((write) => {
+                return [write.channel, write.value];
+            });
+        });
+        return [...writes, ...values];
     }
     async _write(input, config) {
         const values = await this._getWriteValues(input, config);
         ChannelWrite.doWrite(config, values);
     }
+    // TODO: Support requireAtLeastOneOf
     static doWrite(config, values) {
         const write = config.configurable?.[constants_js_1.CONFIG_KEY_SEND];
-        write(Object.entries(values).filter(([_channel, value]) => value !== exports.SKIP_WRITE));
+        const filtered = values.filter(([_, value]) => !_isSkipWrite(value));
+        write(filtered);
     }
     static isWriter(runnable) {
         return (

package/dist/pregel/write.d.ts

@@ -1,17 +1,22 @@
 import { Runnable, RunnableConfig, RunnableLike } from "@langchain/core/runnables";
+import { Send } from "../constants.js";
 import { RunnableCallable } from "../utils.js";
-export declare const SKIP_WRITE: {};
-export declare const PASSTHROUGH: {};
+export declare const SKIP_WRITE: {
+    [x: symbol]: boolean;
+};
+export declare const PASSTHROUGH: {
+    [x: symbol]: boolean;
+};
 /**
  * Mapping of write channels to Runnables that return the value to be written,
  * or None to skip writing.
  */
 export declare class ChannelWrite<RunInput = any> extends RunnableCallable {
-    writes: Array<ChannelWriteEntry>;
-    constructor(writes: Array<ChannelWriteEntry>, tags?: string[]);
-    _getWriteValues(input: unknown, config: RunnableConfig): Promise<Record<string, unknown>>;
+    writes: Array<ChannelWriteEntry | Send>;
+    constructor(writes: Array<ChannelWriteEntry | Send>, tags?: string[]);
+    _getWriteValues(input: unknown, config: RunnableConfig): Promise<[string, unknown][]>;
     _write(input: unknown, config: RunnableConfig): Promise<void>;
-    static doWrite(config: RunnableConfig, values: Record<string, unknown>): void;
+    static doWrite(config: RunnableConfig, values: [string, unknown][]): void;
     static isWriter(runnable: RunnableLike): boolean;
     static registerWriter<T extends Runnable>(runnable: T): T;
 }

package/dist/pregel/write.js

@@ -1,7 +1,22 @@
-import { CONFIG_KEY_SEND } from "../constants.js";
+import { _isSend, CONFIG_KEY_SEND, TASKS } from "../constants.js";
 import { RunnableCallable } from "../utils.js";
-export const SKIP_WRITE = {};
-export const PASSTHROUGH = {};
+import { InvalidUpdateError } from "../errors.js";
+export const SKIP_WRITE = {
+    [Symbol.for("LG_SKIP_WRITE")]: true,
+};
+function _isSkipWrite(x) {
+    return (typeof x === "object" &&
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        x?.[Symbol.for("LG_SKIP_WRITE")] !== undefined);
+}
+export const PASSTHROUGH = {
+    [Symbol.for("LG_PASSTHROUGH")]: true,
+};
+function _isPassthrough(x) {
+    return (typeof x === "object" &&
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        x?.[Symbol.for("LG_PASSTHROUGH")] !== undefined);
+}
 const IS_WRITER = Symbol("IS_WRITER");
 /**
  * Mapping of write channels to Runnables that return the value to be written,
@@ -10,7 +25,9 @@ const IS_WRITER = Symbol("IS_WRITER");
 export class ChannelWrite extends RunnableCallable {
     constructor(writes, tags) {
         const name = `ChannelWrite<${writes
-            .map(({ channel }) => channel)
+            .map((packet) => {
+            return _isSend(packet) ? packet.node : packet.channel;
+        })
             .join(",")}>`;
         super({
             ...{ writes, name, tags },
@@ -25,34 +42,53 @@ export class ChannelWrite extends RunnableCallable {
         this.writes = writes;
     }
     async _getWriteValues(input, config) {
-        return Promise.all(this.writes
-            .map((write) => ({
-            channel: write.channel,
-            value: write.value === PASSTHROUGH ? input : write.value,
-            skipNone: write.skipNone,
-            mapper: write.mapper,
-        }))
-            .map(async (write) => ({
-            channel: write.channel,
-            value: write.mapper
-                ? await write.mapper.invoke(write.value, config)
-                : write.value,
-            skipNone: write.skipNone,
-            mapper: write.mapper,
-        }))).then((writes) => writes
-            .filter((write) => !write.skipNone || write.value !== null)
-            .reduce((acc, write) => {
-            acc[write.channel] = write.value;
-            return acc;
-        }, {}));
+        const writes = this.writes
+            .filter(_isSend)
+            .map((packet) => {
+            return [TASKS, packet];
+        });
+        const entries = this.writes.filter((write) => {
+            return !_isSend(write);
+        });
+        const invalidEntry = entries.find((write) => {
+            return write.channel === TASKS;
+        });
+        if (invalidEntry) {
+            throw new InvalidUpdateError(`Cannot write to the reserved channel ${TASKS}`);
+        }
+        const values = await Promise.all(entries.map(async (write) => {
+            let value;
+            if (_isPassthrough(write.value)) {
+                value = input;
+            }
+            else {
+                value = write.value;
+            }
+            const mappedValue = write.mapper
+                ? await write.mapper.invoke(value, config)
+                : value;
+            return {
+                ...write,
+                value: mappedValue,
+            };
+        })).then((writes) => {
+            return writes
+                .filter((write) => !write.skipNone || write.value !== null)
+                .map((write) => {
+                return [write.channel, write.value];
+            });
+        });
+        return [...writes, ...values];
     }
     async _write(input, config) {
         const values = await this._getWriteValues(input, config);
         ChannelWrite.doWrite(config, values);
     }
+    // TODO: Support requireAtLeastOneOf
     static doWrite(config, values) {
         const write = config.configurable?.[CONFIG_KEY_SEND];
-        write(Object.entries(values).filter(([_channel, value]) => value !== SKIP_WRITE));
+        const filtered = values.filter(([_, value]) => !_isSkipWrite(value));
+        write(filtered);
     }
     static isWriter(runnable) {
         return (