@langchain/langgraph 0.2.3 → 0.2.4

package/dist/pregel/algo.cjs

@@ -33,23 +33,49 @@ function shouldInterrupt(checkpoint, interruptNodes, tasks) {
     return anyChannelUpdated && anyTriggeredNodeInInterruptNodes;
 }
 exports.shouldInterrupt = shouldInterrupt;
-function _localRead(checkpoint, channels, task, select, fresh = false) {
-    if (fresh) {
-        const newCheckpoint = (0, base_js_1.createCheckpoint)(checkpoint, channels, -1);
-        // create a new copy of channels
-        const newChannels = (0, base_js_1.emptyChannels)(channels, newCheckpoint);
-        // Note: _applyWrites contains side effects
+function _localRead(step, checkpoint, channels, managed, task, select, fresh = false) {
+    let managedKeys = [];
+    let updated = new Set();
+    if (!Array.isArray(select)) {
+        for (const [c] of task.writes) {
+            if (c === select) {
+                updated = new Set([c]);
+                break;
+            }
+        }
+        updated = updated || new Set();
+    }
+    else {
+        managedKeys = select.filter((k) => managed.get(k));
+        select = select.filter((k) => !managed.get(k));
+        updated = new Set(select.filter((c) => task.writes.some(([key, _]) => key === c)));
+    }
+    let values;
+    if (fresh && updated.size > 0) {
+        const localChannels = Object.fromEntries(Object.entries(channels).filter(([k, _]) => updated.has(k)));
+        const newCheckpoint = (0, base_js_1.createCheckpoint)(checkpoint, localChannels, -1);
+        const newChannels = (0, base_js_1.emptyChannels)(localChannels, newCheckpoint);
         _applyWrites((0, langgraph_checkpoint_1.copyCheckpoint)(newCheckpoint), newChannels, [task]);
-        return (0, io_js_1.readChannels)(newChannels, select);
+        values = (0, io_js_1.readChannels)({ ...channels, ...newChannels }, select);
     }
     else {
-        return (0, io_js_1.readChannels)(channels, select);
+        values = (0, io_js_1.readChannels)(channels, select);
     }
+    if (managedKeys.length > 0) {
+        for (const k of managedKeys) {
+            const managedValue = managed.get(k);
+            if (managedValue) {
+                const resultOfManagedCall = managedValue.call(step);
+                values[k] = resultOfManagedCall;
+            }
+        }
+    }
+    return values;
 }
 exports._localRead = _localRead;
-function _localWrite(
+function _localWrite(step, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-commit, processes, channels, 
+commit, processes, channels, managed, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 writes) {
     for (const [chan, value] of writes) {
@@ -60,8 +86,10 @@ writes) {
             if (!(value.node in processes)) {
                 throw new errors_js_1.InvalidUpdateError(`Invalid node name ${value.node} in packet`);
             }
+            // replace any runtime values with placeholders
+            managed.replaceRuntimeValues(step, value.args);
         }
-        else if (!(chan in channels)) {
+        else if (!(chan in channels) && !managed.get(chan)) {
             console.warn(`Skipping write for channel '${chan}' which has no readers`);
         }
     }
@@ -71,6 +99,8 @@ exports._localWrite = _localWrite;
 function _applyWrites(checkpoint, channels, tasks, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 getNextVersion) {
+    // Filter out non instances of BaseChannel
+    const onlyChannels = Object.fromEntries(Object.entries(channels).filter(([_, value]) => (0, base_js_1.isBaseChannel)(value)));
     // Update seen versions
     for (const task of tasks) {
         if (checkpoint.versions_seen[task.name] === undefined) {
@@ -93,9 +123,9 @@ getNextVersion) {
         .flatMap((task) => task.triggers)
         .filter((chan) => !constants_js_1.RESERVED.includes(chan)));
     for (const chan of channelsToConsume) {
-        if (channels[chan].consume()) {
+        if (chan in onlyChannels && onlyChannels[chan].consume()) {
             if (getNextVersion !== undefined) {
-                checkpoint.channel_versions[chan] = getNextVersion(maxVersion, channels[chan]);
+                checkpoint.channel_versions[chan] = getNextVersion(maxVersion, onlyChannels[chan]);
             }
         }
     }
@@ -105,6 +135,7 @@ getNextVersion) {
     }
     // Group writes by channel
     const pendingWriteValuesByChannel = {};
+    const pendingWritesByManaged = {};
     for (const task of tasks) {
         for (const [chan, val] of task.writes) {
             if (chan === constants_js_1.TASKS) {
@@ -113,7 +144,7 @@ getNextVersion) {
                     args: val.args,
                 });
             }
-            else {
+            else if (chan in onlyChannels) {
                 if (chan in pendingWriteValuesByChannel) {
                     pendingWriteValuesByChannel[chan].push(val);
                 }
@@ -121,6 +152,14 @@ getNextVersion) {
                     pendingWriteValuesByChannel[chan] = [val];
                 }
             }
+            else {
+                if (chan in pendingWritesByManaged) {
+                    pendingWritesByManaged[chan].push(val);
+                }
+                else {
+                    pendingWritesByManaged[chan] = [val];
+                }
+            }
         }
     }
     // find the highest version of all channels
@@ -131,10 +170,10 @@ getNextVersion) {
     const updatedChannels = new Set();
     // Apply writes to channels
     for (const [chan, vals] of Object.entries(pendingWriteValuesByChannel)) {
-        if (chan in channels) {
+        if (chan in onlyChannels) {
             let updated;
             try {
-                updated = channels[chan].update(vals);
+                updated = onlyChannels[chan].update(vals);
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
             }
             catch (e) {
@@ -146,23 +185,25 @@ getNextVersion) {
                 }
             }
             if (updated && getNextVersion !== undefined) {
-                checkpoint.channel_versions[chan] = getNextVersion(maxVersion, channels[chan]);
+                checkpoint.channel_versions[chan] = getNextVersion(maxVersion, onlyChannels[chan]);
             }
             updatedChannels.add(chan);
         }
     }
     // Channels that weren't updated in this step are notified of a new step
-    for (const chan of Object.keys(channels)) {
+    for (const chan of Object.keys(onlyChannels)) {
         if (!updatedChannels.has(chan)) {
-            const updated = channels[chan].update([]);
+            const updated = onlyChannels[chan].update([]);
             if (updated && getNextVersion !== undefined) {
-                checkpoint.channel_versions[chan] = getNextVersion(maxVersion, channels[chan]);
+                checkpoint.channel_versions[chan] = getNextVersion(maxVersion, onlyChannels[chan]);
             }
         }
     }
+    // Return managed values writes to be applied externally
+    return pendingWritesByManaged;
 }
 exports._applyWrites = _applyWrites;
-function _prepareNextTasks(checkpoint, processes, channels, config, forExecution, extra) {
+function _prepareNextTasks(checkpoint, processes, channels, managed, config, forExecution, extra) {
     const parentNamespace = config.configurable?.checkpoint_ns ?? "";
     const tasks = [];
     const taskDescriptions = [];
@@ -192,6 +233,7 @@ function _prepareNextTasks(checkpoint, processes, channels, config, forExecution
             const node = proc.getNode();
             if (node !== undefined) {
                 const writes = [];
+                managed.replaceRuntimePlaceholders(step, packet.args);
                 tasks.push({
                     name: packet.node,
                     input: packet.args,
@@ -204,12 +246,13 @@ function _prepareNextTasks(checkpoint, processes, channels, config, forExecution
                         runName: packet.node,
                         callbacks: manager?.getChild(`graph:step:${step}`),
                         configurable: {
-                            [constants_js_1.CONFIG_KEY_SEND]: _localWrite.bind(undefined, (items) => writes.push(...items), processes, channels),
-                            [constants_js_1.CONFIG_KEY_READ]: _localRead.bind(undefined, checkpoint, channels, {
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            [constants_js_1.CONFIG_KEY_SEND]: (writes_) => _localWrite(step, (items) => writes.push(...items), processes, channels, managed, writes_),
+                            [constants_js_1.CONFIG_KEY_READ]: (select_, fresh_ = false) => _localRead(step, checkpoint, channels, managed, {
                                 name: packet.node,
                                 writes: writes,
                                 triggers,
-                            }),
+                            }, select_, fresh_),
                         },
                     }),
                     id: taskId,
@@ -243,7 +286,7 @@ function _prepareNextTasks(checkpoint, processes, channels, config, forExecution
             .sort();
         // If any of the channels read by this process were updated
         if (triggers.length > 0) {
-            const val = _procInput(proc, channels, forExecution);
+            const val = _procInput(step, proc, managed, channels, forExecution);
             if (val === undefined) {
                 continue;
             }
@@ -273,12 +316,13 @@ function _prepareNextTasks(checkpoint, processes, channels, config, forExecution
                             runName: name,
                             callbacks: manager?.getChild(`graph:step:${step}`),
                             configurable: {
-                                [constants_js_1.CONFIG_KEY_SEND]: _localWrite.bind(undefined, (items) => writes.push(...items), processes, channels),
-                                [constants_js_1.CONFIG_KEY_READ]: _localRead.bind(undefined, checkpoint, channels, {
+                                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                [constants_js_1.CONFIG_KEY_SEND]: (writes_) => _localWrite(step, (items) => writes.push(...items), processes, channels, managed, writes_),
+                                [constants_js_1.CONFIG_KEY_READ]: (select_, fresh_ = false) => _localRead(step, checkpoint, channels, managed, {
                                     name,
                                     writes: writes,
                                     triggers,
-                                }),
+                                }, select_, fresh_),
                                 [constants_js_1.CONFIG_KEY_CHECKPOINTER]: checkpointer,
                                 [constants_js_1.CONFIG_KEY_RESUMING]: isResuming,
                                 checkpoint_id: checkpoint.id,
@@ -298,12 +342,46 @@ function _prepareNextTasks(checkpoint, processes, channels, config, forExecution
     return forExecution ? tasks : taskDescriptions;
 }
 exports._prepareNextTasks = _prepareNextTasks;
-function _procInput(proc, channels, forExecution) {
+function _procInput(step, proc, managed, channels, forExecution) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     let val;
-    // If all trigger channels subscribed by this process are not empty
-    // then invoke the process with the values of all non-empty channels
-    if (Array.isArray(proc.channels)) {
+    if (typeof proc.channels === "object" && !Array.isArray(proc.channels)) {
+        val = {};
+        for (const [k, chan] of Object.entries(proc.channels)) {
+            if (proc.triggers.includes(chan)) {
+                try {
+                    val[k] = (0, io_js_1.readChannel)(channels, chan, false);
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                }
+                catch (e) {
+                    if (e.name === errors_js_1.EmptyChannelError.unminifiable_name) {
+                        return undefined;
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            }
+            else if (chan in channels) {
+                try {
+                    val[k] = (0, io_js_1.readChannel)(channels, chan, true);
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                }
+                catch (e) {
+                    if (e.name === errors_js_1.EmptyChannelError.unminifiable_name) {
+                        continue;
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            }
+            else {
+                val[k] = managed.get(k)?.call(step);
+            }
+        }
+    }
+    else if (Array.isArray(proc.channels)) {
         let successfulRead = false;
         for (const chan of proc.channels) {
             try {
@@ -322,24 +400,7 @@ function _procInput(proc, channels, forExecution) {
             }
         }
         if (!successfulRead) {
-            return;
-        }
-    }
-    else if (typeof proc.channels === "object") {
-        val = {};
-        for (const [k, chan] of Object.entries(proc.channels)) {
-            try {
-                val[k] = (0, io_js_1.readChannel)(channels, chan, !proc.triggers.includes(chan));
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            }
-            catch (e) {
-                if (e.name === errors_js_1.EmptyChannelError.unminifiable_name) {
-                    continue;
-                }
-                else {
-                    throw e;
-                }
-            }
+            return undefined;
         }
     }
     else {

package/dist/pregel/algo.d.ts

@@ -1,9 +1,10 @@
 import { RunnableConfig } from "@langchain/core/runnables";
 import { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
-import { All, BaseCheckpointSaver, Checkpoint, ReadonlyCheckpoint, type PendingWrite } from "@langchain/langgraph-checkpoint";
+import { All, BaseCheckpointSaver, Checkpoint, ReadonlyCheckpoint, type PendingWrite, type PendingWriteValue } from "@langchain/langgraph-checkpoint";
 import { BaseChannel } from "../channels/base.js";
 import { PregelNode } from "./read.js";
 import { PregelExecutableTask, PregelTaskDescription } from "./types.js";
+import { ManagedValueMapping } from "../managed/base.js";
 /**
  * Construct a type with a set of properties K of type T
  */
@@ -17,14 +18,14 @@ export type WritesProtocol<C = string> = {
 };
 export declare const increment: (current?: number) => number;
 export declare function shouldInterrupt<N extends PropertyKey, C extends PropertyKey>(checkpoint: Checkpoint, interruptNodes: All | N[], tasks: PregelExecutableTask<N, C>[]): boolean;
-export declare function _localRead<Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, channels: Cc, task: WritesProtocol<keyof Cc>, select: Array<keyof Cc> | keyof Cc, fresh?: boolean): Record<string, unknown> | unknown;
-export declare function _localWrite(commit: (writes: [string, any][]) => void, processes: Record<string, PregelNode>, channels: Record<string, BaseChannel>, writes: [string, any][]): void;
-export declare function _applyWrites<Cc extends Record<string, BaseChannel>>(checkpoint: Checkpoint, channels: Cc, tasks: WritesProtocol<keyof Cc>[], getNextVersion?: (version: any, channel: BaseChannel) => any): void;
+export declare function _localRead<Cc extends Record<string, BaseChannel>>(step: number, checkpoint: ReadonlyCheckpoint, channels: Cc, managed: ManagedValueMapping, task: WritesProtocol<keyof Cc>, select: Array<keyof Cc> | keyof Cc, fresh?: boolean): Record<string, unknown> | unknown;
+export declare function _localWrite(step: number, commit: (writes: [string, any][]) => any, processes: Record<string, PregelNode>, channels: Record<string, BaseChannel>, managed: ManagedValueMapping, writes: [string, any][]): void;
+export declare function _applyWrites<Cc extends Record<string, BaseChannel>>(checkpoint: Checkpoint, channels: Cc, tasks: WritesProtocol<keyof Cc>[], getNextVersion?: (version: any, channel: BaseChannel) => any): Record<string, PendingWriteValue[]>;
 export type NextTaskExtraFields = {
     step: number;
     isResuming?: boolean;
     checkpointer?: BaseCheckpointSaver;
     manager?: CallbackManagerForChainRun;
 };
-export declare function _prepareNextTasks<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, processes: Nn, channels: Cc, config: RunnableConfig, forExecution: false, extra: NextTaskExtraFields): PregelTaskDescription[];
-export declare function _prepareNextTasks<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, processes: Nn, channels: Cc, config: RunnableConfig, forExecution: true, extra: NextTaskExtraFields): PregelExecutableTask<keyof Nn, keyof Cc>[];
+export declare function _prepareNextTasks<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, processes: Nn, channels: Cc, managed: ManagedValueMapping, config: RunnableConfig, forExecution: false, extra: NextTaskExtraFields): PregelTaskDescription[];
+export declare function _prepareNextTasks<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, processes: Nn, channels: Cc, managed: ManagedValueMapping, config: RunnableConfig, forExecution: true, extra: NextTaskExtraFields): PregelExecutableTask<keyof Nn, keyof Cc>[];

package/dist/pregel/algo.js

@@ -1,7 +1,7 @@
 /* eslint-disable no-param-reassign */
 import { mergeConfigs, patchConfig, } from "@langchain/core/runnables";
 import { copyCheckpoint, uuid5, maxChannelVersion, } from "@langchain/langgraph-checkpoint";
-import { createCheckpoint, emptyChannels, } from "../channels/base.js";
+import { createCheckpoint, emptyChannels, isBaseChannel, } from "../channels/base.js";
 import { readChannel, readChannels } from "./io.js";
 import { _isSend, _isSendInterface, CHECKPOINT_NAMESPACE_SEPARATOR, CONFIG_KEY_CHECKPOINTER, CONFIG_KEY_READ, CONFIG_KEY_RESUMING, CONFIG_KEY_SEND, INTERRUPT, RESERVED, TAG_HIDDEN, TASKS, } from "../constants.js";
 import { EmptyChannelError, InvalidUpdateError } from "../errors.js";
@@ -28,22 +28,48 @@ export function shouldInterrupt(checkpoint, interruptNodes, tasks) {
         : interruptNodes.includes(task.name));
     return anyChannelUpdated && anyTriggeredNodeInInterruptNodes;
 }
-export function _localRead(checkpoint, channels, task, select, fresh = false) {
-    if (fresh) {
-        const newCheckpoint = createCheckpoint(checkpoint, channels, -1);
-        // create a new copy of channels
-        const newChannels = emptyChannels(channels, newCheckpoint);
-        // Note: _applyWrites contains side effects
+export function _localRead(step, checkpoint, channels, managed, task, select, fresh = false) {
+    let managedKeys = [];
+    let updated = new Set();
+    if (!Array.isArray(select)) {
+        for (const [c] of task.writes) {
+            if (c === select) {
+                updated = new Set([c]);
+                break;
+            }
+        }
+        updated = updated || new Set();
+    }
+    else {
+        managedKeys = select.filter((k) => managed.get(k));
+        select = select.filter((k) => !managed.get(k));
+        updated = new Set(select.filter((c) => task.writes.some(([key, _]) => key === c)));
+    }
+    let values;
+    if (fresh && updated.size > 0) {
+        const localChannels = Object.fromEntries(Object.entries(channels).filter(([k, _]) => updated.has(k)));
+        const newCheckpoint = createCheckpoint(checkpoint, localChannels, -1);
+        const newChannels = emptyChannels(localChannels, newCheckpoint);
         _applyWrites(copyCheckpoint(newCheckpoint), newChannels, [task]);
-        return readChannels(newChannels, select);
+        values = readChannels({ ...channels, ...newChannels }, select);
     }
     else {
-        return readChannels(channels, select);
+        values = readChannels(channels, select);
     }
+    if (managedKeys.length > 0) {
+        for (const k of managedKeys) {
+            const managedValue = managed.get(k);
+            if (managedValue) {
+                const resultOfManagedCall = managedValue.call(step);
+                values[k] = resultOfManagedCall;
+            }
+        }
+    }
+    return values;
 }
-export function _localWrite(
+export function _localWrite(step, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-commit, processes, channels, 
+commit, processes, channels, managed, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 writes) {
     for (const [chan, value] of writes) {
@@ -54,8 +80,10 @@ writes) {
             if (!(value.node in processes)) {
                 throw new InvalidUpdateError(`Invalid node name ${value.node} in packet`);
             }
+            // replace any runtime values with placeholders
+            managed.replaceRuntimeValues(step, value.args);
         }
-        else if (!(chan in channels)) {
+        else if (!(chan in channels) && !managed.get(chan)) {
             console.warn(`Skipping write for channel '${chan}' which has no readers`);
         }
     }
@@ -64,6 +92,8 @@ writes) {
 export function _applyWrites(checkpoint, channels, tasks, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 getNextVersion) {
+    // Filter out non instances of BaseChannel
+    const onlyChannels = Object.fromEntries(Object.entries(channels).filter(([_, value]) => isBaseChannel(value)));
     // Update seen versions
     for (const task of tasks) {
         if (checkpoint.versions_seen[task.name] === undefined) {
@@ -86,9 +116,9 @@ getNextVersion) {
         .flatMap((task) => task.triggers)
         .filter((chan) => !RESERVED.includes(chan)));
     for (const chan of channelsToConsume) {
-        if (channels[chan].consume()) {
+        if (chan in onlyChannels && onlyChannels[chan].consume()) {
             if (getNextVersion !== undefined) {
-                checkpoint.channel_versions[chan] = getNextVersion(maxVersion, channels[chan]);
+                checkpoint.channel_versions[chan] = getNextVersion(maxVersion, onlyChannels[chan]);
             }
         }
     }
@@ -98,6 +128,7 @@ getNextVersion) {
     }
     // Group writes by channel
     const pendingWriteValuesByChannel = {};
+    const pendingWritesByManaged = {};
     for (const task of tasks) {
         for (const [chan, val] of task.writes) {
             if (chan === TASKS) {
@@ -106,7 +137,7 @@ getNextVersion) {
                     args: val.args,
                 });
             }
-            else {
+            else if (chan in onlyChannels) {
                 if (chan in pendingWriteValuesByChannel) {
                     pendingWriteValuesByChannel[chan].push(val);
                 }
@@ -114,6 +145,14 @@ getNextVersion) {
                     pendingWriteValuesByChannel[chan] = [val];
                 }
             }
+            else {
+                if (chan in pendingWritesByManaged) {
+                    pendingWritesByManaged[chan].push(val);
+                }
+                else {
+                    pendingWritesByManaged[chan] = [val];
+                }
+            }
         }
     }
     // find the highest version of all channels
@@ -124,10 +163,10 @@ getNextVersion) {
     const updatedChannels = new Set();
     // Apply writes to channels
     for (const [chan, vals] of Object.entries(pendingWriteValuesByChannel)) {
-        if (chan in channels) {
+        if (chan in onlyChannels) {
             let updated;
             try {
-                updated = channels[chan].update(vals);
+                updated = onlyChannels[chan].update(vals);
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
             }
             catch (e) {
@@ -139,22 +178,24 @@ getNextVersion) {
                 }
             }
             if (updated && getNextVersion !== undefined) {
-                checkpoint.channel_versions[chan] = getNextVersion(maxVersion, channels[chan]);
+                checkpoint.channel_versions[chan] = getNextVersion(maxVersion, onlyChannels[chan]);
             }
             updatedChannels.add(chan);
         }
     }
     // Channels that weren't updated in this step are notified of a new step
-    for (const chan of Object.keys(channels)) {
+    for (const chan of Object.keys(onlyChannels)) {
         if (!updatedChannels.has(chan)) {
-            const updated = channels[chan].update([]);
+            const updated = onlyChannels[chan].update([]);
             if (updated && getNextVersion !== undefined) {
-                checkpoint.channel_versions[chan] = getNextVersion(maxVersion, channels[chan]);
+                checkpoint.channel_versions[chan] = getNextVersion(maxVersion, onlyChannels[chan]);
             }
         }
     }
+    // Return managed values writes to be applied externally
+    return pendingWritesByManaged;
 }
-export function _prepareNextTasks(checkpoint, processes, channels, config, forExecution, extra) {
+export function _prepareNextTasks(checkpoint, processes, channels, managed, config, forExecution, extra) {
     const parentNamespace = config.configurable?.checkpoint_ns ?? "";
     const tasks = [];
     const taskDescriptions = [];
@@ -184,6 +225,7 @@ export function _prepareNextTasks(checkpoint, processes, channels, config, forEx
             const node = proc.getNode();
             if (node !== undefined) {
                 const writes = [];
+                managed.replaceRuntimePlaceholders(step, packet.args);
                 tasks.push({
                     name: packet.node,
                     input: packet.args,
@@ -196,12 +238,13 @@ export function _prepareNextTasks(checkpoint, processes, channels, config, forEx
                         runName: packet.node,
                         callbacks: manager?.getChild(`graph:step:${step}`),
                         configurable: {
-                            [CONFIG_KEY_SEND]: _localWrite.bind(undefined, (items) => writes.push(...items), processes, channels),
-                            [CONFIG_KEY_READ]: _localRead.bind(undefined, checkpoint, channels, {
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            [CONFIG_KEY_SEND]: (writes_) => _localWrite(step, (items) => writes.push(...items), processes, channels, managed, writes_),
+                            [CONFIG_KEY_READ]: (select_, fresh_ = false) => _localRead(step, checkpoint, channels, managed, {
                                 name: packet.node,
                                 writes: writes,
                                 triggers,
-                            }),
+                            }, select_, fresh_),
                         },
                     }),
                     id: taskId,
@@ -235,7 +278,7 @@ export function _prepareNextTasks(checkpoint, processes, channels, config, forEx
             .sort();
         // If any of the channels read by this process were updated
         if (triggers.length > 0) {
-            const val = _procInput(proc, channels, forExecution);
+            const val = _procInput(step, proc, managed, channels, forExecution);
             if (val === undefined) {
                 continue;
             }
@@ -265,12 +308,13 @@ export function _prepareNextTasks(checkpoint, processes, channels, config, forEx
                             runName: name,
                             callbacks: manager?.getChild(`graph:step:${step}`),
                             configurable: {
-                                [CONFIG_KEY_SEND]: _localWrite.bind(undefined, (items) => writes.push(...items), processes, channels),
-                                [CONFIG_KEY_READ]: _localRead.bind(undefined, checkpoint, channels, {
+                                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                [CONFIG_KEY_SEND]: (writes_) => _localWrite(step, (items) => writes.push(...items), processes, channels, managed, writes_),
+                                [CONFIG_KEY_READ]: (select_, fresh_ = false) => _localRead(step, checkpoint, channels, managed, {
                                     name,
                                     writes: writes,
                                     triggers,
-                                }),
+                                }, select_, fresh_),
                                 [CONFIG_KEY_CHECKPOINTER]: checkpointer,
                                 [CONFIG_KEY_RESUMING]: isResuming,
                                 checkpoint_id: checkpoint.id,
@@ -289,12 +333,46 @@ export function _prepareNextTasks(checkpoint, processes, channels, config, forEx
     }
     return forExecution ? tasks : taskDescriptions;
 }
-function _procInput(proc, channels, forExecution) {
+function _procInput(step, proc, managed, channels, forExecution) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     let val;
-    // If all trigger channels subscribed by this process are not empty
-    // then invoke the process with the values of all non-empty channels
-    if (Array.isArray(proc.channels)) {
+    if (typeof proc.channels === "object" && !Array.isArray(proc.channels)) {
+        val = {};
+        for (const [k, chan] of Object.entries(proc.channels)) {
+            if (proc.triggers.includes(chan)) {
+                try {
+                    val[k] = readChannel(channels, chan, false);
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                }
+                catch (e) {
+                    if (e.name === EmptyChannelError.unminifiable_name) {
+                        return undefined;
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            }
+            else if (chan in channels) {
+                try {
+                    val[k] = readChannel(channels, chan, true);
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                }
+                catch (e) {
+                    if (e.name === EmptyChannelError.unminifiable_name) {
+                        continue;
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            }
+            else {
+                val[k] = managed.get(k)?.call(step);
+            }
+        }
+    }
+    else if (Array.isArray(proc.channels)) {
         let successfulRead = false;
         for (const chan of proc.channels) {
             try {
@@ -313,24 +391,7 @@ function _procInput(proc, channels, forExecution) {
             }
         }
         if (!successfulRead) {
-            return;
-        }
-    }
-    else if (typeof proc.channels === "object") {
-        val = {};
-        for (const [k, chan] of Object.entries(proc.channels)) {
-            try {
-                val[k] = readChannel(channels, chan, !proc.triggers.includes(chan));
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            }
-            catch (e) {
-                if (e.name === EmptyChannelError.unminifiable_name) {
-                    continue;
-                }
-                else {
-                    throw e;
-                }
-            }
+            return undefined;
         }
     }
     else {