@langchain/langgraph 0.2.32 → 0.2.34

package/dist/graph/state.js

@@ -2,12 +2,12 @@
 import { _coerceToRunnable, Runnable, } from "@langchain/core/runnables";
 import { isBaseChannel } from "../channels/base.js";
 import { END, CompiledGraph, Graph, START, Branch, } from "./graph.js";
-import { ChannelWrite, PASSTHROUGH, SKIP_WRITE, } from "../pregel/write.js";
+import { ChannelWrite, PASSTHROUGH, } from "../pregel/write.js";
 import { ChannelRead, PregelNode } from "../pregel/read.js";
 import { NamedBarrierValue } from "../channels/named_barrier_value.js";
 import { EphemeralValue } from "../channels/ephemeral_value.js";
 import { RunnableCallable } from "../utils.js";
-import { _isCommand, _isSend, CHECKPOINT_NAMESPACE_END, CHECKPOINT_NAMESPACE_SEPARATOR, Command, SELF, TAG_HIDDEN, } from "../constants.js";
+import { isCommand, _isSend, CHECKPOINT_NAMESPACE_END, CHECKPOINT_NAMESPACE_SEPARATOR, Command, SELF, TAG_HIDDEN, } from "../constants.js";
 import { InvalidUpdateError, ParentCommand } from "../errors.js";
 import { getChannel, } from "./annotation.js";
 import { isConfiguredManagedValue } from "../managed/base.js";
@@ -343,59 +343,101 @@ function _getChannels(schema) {
  */
 export class CompiledStateGraph extends CompiledGraph {
     attachNode(key, node) {
-        const stateKeys = Object.keys(this.builder.channels);
+        let outputKeys;
+        if (key === START) {
+            // Get input schema keys excluding managed values
+            outputKeys = Object.entries(this.builder._schemaDefinitions.get(this.builder._inputDefinition))
+                .filter(([_, v]) => !isConfiguredManagedValue(v))
+                .map(([k]) => k);
+        }
+        else {
+            outputKeys = Object.keys(this.builder.channels);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         function _getRoot(input) {
-            if (_isCommand(input)) {
+            if (isCommand(input)) {
                 if (input.graph === Command.PARENT) {
-                    return SKIP_WRITE;
+                    return null;
+                }
+                return input._updateAsTuples();
+            }
+            else if (Array.isArray(input) &&
+                input.length > 0 &&
+                input.some((i) => isCommand(i))) {
+                const updates = [];
+                for (const i of input) {
+                    if (isCommand(i)) {
+                        if (i.graph === Command.PARENT) {
+                            continue;
+                        }
+                        updates.push(...i._updateAsTuples());
+                    }
+                    else {
+                        updates.push([ROOT, i]);
+                    }
                 }
-                return input.update;
+                return updates;
             }
-            return input;
+            else if (input != null) {
+                return [[ROOT, input]];
+            }
+            return null;
         }
         // to avoid name collision below
         const nodeKey = key;
-        function getStateKey(key, input) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        function _getUpdates(input) {
             if (!input) {
-                return SKIP_WRITE;
+                return null;
             }
-            else if (_isCommand(input)) {
+            else if (isCommand(input)) {
                 if (input.graph === Command.PARENT) {
-                    return SKIP_WRITE;
+                    return null;
                 }
-                return getStateKey(key, input.update);
+                return input._updateAsTuples();
             }
-            else if (typeof input !== "object" || Array.isArray(input)) {
+            else if (Array.isArray(input) &&
+                input.length > 0 &&
+                input.some(isCommand)) {
+                const updates = [];
+                for (const item of input) {
+                    if (isCommand(item)) {
+                        if (item.graph === Command.PARENT) {
+                            continue;
+                        }
+                        updates.push(...item._updateAsTuples());
+                    }
+                    else {
+                        const itemUpdates = _getUpdates(item);
+                        if (itemUpdates) {
+                            updates.push(...(itemUpdates ?? []));
+                        }
+                    }
+                }
+                return updates;
+            }
+            else if (typeof input === "object" && !Array.isArray(input)) {
+                return Object.entries(input).filter(([k]) => outputKeys.includes(k));
+            }
+            else {
                 const typeofInput = Array.isArray(input) ? "array" : typeof input;
                 throw new InvalidUpdateError(`Expected node "${nodeKey.toString()}" to return an object, received ${typeofInput}`, {
                     lc_error_code: "INVALID_GRAPH_NODE_RETURN_VALUE",
                 });
             }
-            else {
-                return key in input ? input[key] : SKIP_WRITE;
-            }
         }
-        // state updaters
-        const stateWriteEntries = stateKeys.map((key) => key === ROOT
-            ? {
-                channel: key,
+        const stateWriteEntries = [
+            {
                 value: PASSTHROUGH,
-                skipNone: true,
                 mapper: new RunnableCallable({
-                    func: _getRoot,
+                    func: outputKeys.length && outputKeys[0] === ROOT
+                        ? _getRoot
+                        : _getUpdates,
                     trace: false,
                     recurse: false,
                 }),
-            }
-            : {
-                channel: key,
-                value: PASSTHROUGH,
-                mapper: new RunnableCallable({
-                    func: getStateKey.bind(null, key),
-                    trace: false,
-                    recurse: false,
-                }),
-            });
+            },
+        ];
         // add node and output channel
         if (key === START) {
             this.nodes[key] = new PregelNode({
@@ -536,7 +578,7 @@ function _controlBranch(value) {
     if (_isSend(value)) {
         return [value];
     }
-    if (!_isCommand(value)) {
+    if (!isCommand(value)) {
         return [];
     }
     if (value.graph === Command.PARENT) {

package/dist/prebuilt/react_agent_executor.cjs

@@ -108,7 +108,7 @@ function _getModelPreprocessingRunnable(stateModifier, messageModifier) {
  * ```
  */
 function createReactAgent(params) {
-    const { llm, tools, messageModifier, stateModifier, checkpointSaver, interruptBefore, interruptAfter, store, } = params;
+    const { llm, tools, messageModifier, stateModifier, stateSchema, checkpointSaver, interruptBefore, interruptAfter, store, } = params;
     let toolClasses;
     if (!Array.isArray(tools)) {
         toolClasses = tools.tools;
@@ -138,7 +138,7 @@ function createReactAgent(params) {
         // TODO: Auto-promote streaming.
         return { messages: [await modelRunnable.invoke(state, config)] };
     };
-    const workflow = new index_js_1.StateGraph(messages_annotation_js_1.MessagesAnnotation)
+    const workflow = new index_js_1.StateGraph(stateSchema ?? messages_annotation_js_1.MessagesAnnotation)
         .addNode("agent", callModel)
         .addNode("tools", new tool_node_js_1.ToolNode(toolClasses))
         .addEdge(index_js_1.START, "agent")

package/dist/prebuilt/react_agent_executor.d.ts

@@ -3,7 +3,7 @@ import { BaseMessage, BaseMessageLike, SystemMessage } from "@langchain/core/mes
 import { Runnable, RunnableToolLike } from "@langchain/core/runnables";
 import { StructuredToolInterface } from "@langchain/core/tools";
 import { All, BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
-import { START, CompiledStateGraph } from "../graph/index.js";
+import { START, CompiledStateGraph, AnnotationRoot } from "../graph/index.js";
 import { MessagesAnnotation } from "../graph/messages_annotation.js";
 import { ToolNode } from "./tool_node.js";
 import { LangGraphRunnableConfig } from "../pregel/runnable_types.js";
@@ -14,11 +14,11 @@ export type N = typeof START | "agent" | "tools";
 export type StateModifier = SystemMessage | string | ((state: typeof MessagesAnnotation.State, config: LangGraphRunnableConfig) => BaseMessageLike[]) | ((state: typeof MessagesAnnotation.State, config: LangGraphRunnableConfig) => Promise<BaseMessageLike[]>) | Runnable;
 /** @deprecated Use StateModifier instead. */
 export type MessageModifier = SystemMessage | string | ((messages: BaseMessage[]) => BaseMessage[]) | ((messages: BaseMessage[]) => Promise<BaseMessage[]>) | Runnable;
-export type CreateReactAgentParams = {
+export type CreateReactAgentParams<A extends AnnotationRoot<any> = AnnotationRoot<any>> = {
     /** The chat model that can utilize OpenAI-style tool calling. */
     llm: BaseChatModel;
     /** A list of tools or a ToolNode. */
-    tools: ToolNode<typeof MessagesAnnotation.State> | (StructuredToolInterface | RunnableToolLike)[];
+    tools: ToolNode | (StructuredToolInterface | RunnableToolLike)[];
     /**
      * @deprecated
      * Use stateModifier instead. stateModifier works the same as
@@ -73,6 +73,7 @@ export type CreateReactAgentParams = {
      * - Runnable: This runnable should take in full graph state and the output is then passed to the language model.
      */
     stateModifier?: StateModifier;
+    stateSchema?: A;
     /** An optional checkpoint saver to persist the agent's state. */
     checkpointSaver?: BaseCheckpointSaver;
     /** An optional list of node names to interrupt before running. */
@@ -123,4 +124,4 @@ export type CreateReactAgentParams = {
  * // Returns the messages in the state at each step of execution
  * ```
  */
-export declare function createReactAgent(params: CreateReactAgentParams): CompiledStateGraph<(typeof MessagesAnnotation)["State"], (typeof MessagesAnnotation)["Update"], typeof START | "agent" | "tools">;
+export declare function createReactAgent<A extends AnnotationRoot<any> = AnnotationRoot<any>>(params: CreateReactAgentParams<A>): CompiledStateGraph<(typeof MessagesAnnotation)["State"], (typeof MessagesAnnotation)["Update"], typeof START | "agent" | "tools", typeof MessagesAnnotation.spec & A["spec"], typeof MessagesAnnotation.spec & A["spec"]>;

package/dist/prebuilt/react_agent_executor.js

@@ -1,6 +1,6 @@
 import { isAIMessage, isBaseMessage, SystemMessage, } from "@langchain/core/messages";
 import { Runnable, RunnableLambda, } from "@langchain/core/runnables";
-import { END, START, StateGraph } from "../graph/index.js";
+import { END, START, StateGraph, } from "../graph/index.js";
 import { MessagesAnnotation } from "../graph/messages_annotation.js";
 import { ToolNode } from "./tool_node.js";
 function _convertMessageModifierToStateModifier(messageModifier) {
@@ -105,7 +105,7 @@ function _getModelPreprocessingRunnable(stateModifier, messageModifier) {
  * ```
  */
 export function createReactAgent(params) {
-    const { llm, tools, messageModifier, stateModifier, checkpointSaver, interruptBefore, interruptAfter, store, } = params;
+    const { llm, tools, messageModifier, stateModifier, stateSchema, checkpointSaver, interruptBefore, interruptAfter, store, } = params;
     let toolClasses;
     if (!Array.isArray(tools)) {
         toolClasses = tools.tools;
@@ -135,7 +135,7 @@ export function createReactAgent(params) {
         // TODO: Auto-promote streaming.
         return { messages: [await modelRunnable.invoke(state, config)] };
     };
-    const workflow = new StateGraph(MessagesAnnotation)
+    const workflow = new StateGraph(stateSchema ?? MessagesAnnotation)
         .addNode("agent", callModel)
         .addNode("tools", new ToolNode(toolClasses))
         .addEdge(START, "agent")

package/dist/prebuilt/tool_node.cjs

@@ -5,6 +5,7 @@ const messages_1 = require("@langchain/core/messages");
 const utils_js_1 = require("../utils.cjs");
 const graph_js_1 = require("../graph/graph.cjs");
 const errors_js_1 = require("../errors.cjs");
+const constants_js_1 = require("../constants.cjs");
 /**
  * A node that runs the tools requested in the last AIMessage. It can be used
  * either in StateGraph with a "messages" key or in MessageGraph. If multiple
@@ -163,7 +164,8 @@ class ToolNode extends utils_js_1.RunnableCallable {
                     throw new Error(`Tool "${call.name}" not found.`);
                 }
                 const output = await tool.invoke({ ...call, type: "tool_call" }, config);
-                if ((0, messages_1.isBaseMessage)(output) && output._getType() === "tool") {
+                if (((0, messages_1.isBaseMessage)(output) && output._getType() === "tool") ||
+                    (0, constants_js_1.isCommand)(output)) {
                     return output;
                 }
                 else {
@@ -192,7 +194,18 @@ class ToolNode extends utils_js_1.RunnableCallable {
                 });
             }
         }) ?? []);
-        return (Array.isArray(input) ? outputs : { messages: outputs });
+        // Preserve existing behavior for non-command tool outputs for backwards compatibility
+        if (!outputs.some(constants_js_1.isCommand)) {
+            return (Array.isArray(input) ? outputs : { messages: outputs });
+        }
+        // Handle mixed Command and non-Command outputs
+        const combinedOutputs = outputs.map((output) => {
+            if ((0, constants_js_1.isCommand)(output)) {
+                return output;
+            }
+            return Array.isArray(input) ? [output] : { messages: [output] };
+        });
+        return combinedOutputs;
     }
 }
 exports.ToolNode = ToolNode;

package/dist/prebuilt/tool_node.js

@@ -2,6 +2,7 @@ import { ToolMessage, isBaseMessage, } from "@langchain/core/messages";
 import { RunnableCallable } from "../utils.js";
 import { END } from "../graph/graph.js";
 import { isGraphInterrupt } from "../errors.js";
+import { isCommand } from "../constants.js";
 /**
  * A node that runs the tools requested in the last AIMessage. It can be used
  * either in StateGraph with a "messages" key or in MessageGraph. If multiple
@@ -160,7 +161,8 @@ export class ToolNode extends RunnableCallable {
                     throw new Error(`Tool "${call.name}" not found.`);
                 }
                 const output = await tool.invoke({ ...call, type: "tool_call" }, config);
-                if (isBaseMessage(output) && output._getType() === "tool") {
+                if ((isBaseMessage(output) && output._getType() === "tool") ||
+                    isCommand(output)) {
                     return output;
                 }
                 else {
@@ -189,7 +191,18 @@ export class ToolNode extends RunnableCallable {
                 });
             }
         }) ?? []);
-        return (Array.isArray(input) ? outputs : { messages: outputs });
+        // Preserve existing behavior for non-command tool outputs for backwards compatibility
+        if (!outputs.some(isCommand)) {
+            return (Array.isArray(input) ? outputs : { messages: outputs });
+        }
+        // Handle mixed Command and non-Command outputs
+        const combinedOutputs = outputs.map((output) => {
+            if (isCommand(output)) {
+                return output;
+            }
+            return Array.isArray(input) ? [output] : { messages: [output] };
+        });
+        return combinedOutputs;
     }
 }
 export function toolsCondition(state) {

package/dist/pregel/loop.cjs

@@ -587,8 +587,8 @@ class PregelLoop {
         const isResuming = Object.keys(this.checkpoint.channel_versions).length !== 0 &&
             (this.config.configurable?.[constants_js_1.CONFIG_KEY_RESUMING] !== undefined ||
                 this.input === null ||
-                (0, constants_js_1._isCommand)(this.input));
-        if ((0, constants_js_1._isCommand)(this.input)) {
+                (0, constants_js_1.isCommand)(this.input));
+        if ((0, constants_js_1.isCommand)(this.input)) {
             const writes = {};
             // group writes by task id
             for (const [tid, key, value] of (0, io_js_1.mapCommand)(this.input, this.checkpointPendingWrites)) {

package/dist/pregel/loop.js

@@ -1,7 +1,7 @@
 import { IterableReadableStream } from "@langchain/core/utils/stream";
 import { copyCheckpoint, emptyCheckpoint, AsyncBatchedStore, WRITES_IDX_MAP, } from "@langchain/langgraph-checkpoint";
 import { createCheckpoint, emptyChannels, } from "../channels/base.js";
-import { _isCommand, CHECKPOINT_NAMESPACE_SEPARATOR, CONFIG_KEY_CHECKPOINT_MAP, CONFIG_KEY_READ, CONFIG_KEY_RESUMING, CONFIG_KEY_STREAM, ERROR, INPUT, INTERRUPT, NULL_TASK_ID, RESUME, TAG_HIDDEN, } from "../constants.js";
+import { isCommand, CHECKPOINT_NAMESPACE_SEPARATOR, CONFIG_KEY_CHECKPOINT_MAP, CONFIG_KEY_READ, CONFIG_KEY_RESUMING, CONFIG_KEY_STREAM, ERROR, INPUT, INTERRUPT, NULL_TASK_ID, RESUME, TAG_HIDDEN, } from "../constants.js";
 import { _applyWrites, _prepareNextTasks, increment, shouldInterrupt, } from "./algo.js";
 import { gatherIterator, gatherIteratorSync, prefixGenerator, } from "../utils.js";
 import { mapCommand, mapInput, mapOutputUpdates, mapOutputValues, readChannels, } from "./io.js";
@@ -583,8 +583,8 @@ export class PregelLoop {
         const isResuming = Object.keys(this.checkpoint.channel_versions).length !== 0 &&
             (this.config.configurable?.[CONFIG_KEY_RESUMING] !== undefined ||
                 this.input === null ||
-                _isCommand(this.input));
-        if (_isCommand(this.input)) {
+                isCommand(this.input));
+        if (isCommand(this.input)) {
             const writes = {};
             // group writes by task id
             for (const [tid, key, value] of mapCommand(this.input, this.checkpointPendingWrites)) {

package/dist/pregel/messages.cjs

@@ -12,6 +12,8 @@ function isChatGenerationChunk(x) {
  * A callback handler that implements stream_mode=messages.
  * Collects messages from (1) chat model stream events and (2) node outputs.
  */
+// TODO: Make this import and explicitly implement the
+// CallbackHandlerPrefersStreaming interface once we drop support for core 0.2
 class StreamMessagesHandler extends base_1.BaseCallbackHandler {
     constructor(streamFn) {
         super();
@@ -45,6 +47,12 @@ class StreamMessagesHandler extends base_1.BaseCallbackHandler {
             writable: true,
             value: {}
         });
+        Object.defineProperty(this, "lc_prefer_streaming", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
         this.streamFn = streamFn;
     }
     _emit(meta, message, dedupe = false) {

package/dist/pregel/messages.d.ts

@@ -15,6 +15,7 @@ export declare class StreamMessagesHandler extends BaseCallbackHandler {
     metadatas: Record<string, Meta>;
     seen: Record<string, BaseMessage>;
     emittedChatModelRunIds: Record<string, boolean>;
+    lc_prefer_streaming: boolean;
     constructor(streamFn: (streamChunk: StreamChunk) => void);
     _emit(meta: Meta, message: BaseMessage, dedupe?: boolean): void;
     handleChatModelStart(_llm: Serialized, _messages: BaseMessage[][], runId: string, _parentRunId?: string, _extraParams?: Record<string, unknown>, tags?: string[], metadata?: Record<string, unknown>, name?: string): void;

package/dist/pregel/messages.js

@@ -9,6 +9,8 @@ function isChatGenerationChunk(x) {
  * A callback handler that implements stream_mode=messages.
  * Collects messages from (1) chat model stream events and (2) node outputs.
  */
+// TODO: Make this import and explicitly implement the
+// CallbackHandlerPrefersStreaming interface once we drop support for core 0.2
 export class StreamMessagesHandler extends BaseCallbackHandler {
     constructor(streamFn) {
         super();
@@ -42,6 +44,12 @@ export class StreamMessagesHandler extends BaseCallbackHandler {
             writable: true,
             value: {}
         });
+        Object.defineProperty(this, "lc_prefer_streaming", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
         this.streamFn = streamFn;
     }
     _emit(meta, message, dedupe = false) {

package/dist/pregel/write.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChannelWrite = exports.PASSTHROUGH = exports.SKIP_WRITE = void 0;
+const runnables_1 = require("@langchain/core/runnables");
 const constants_js_1 = require("../constants.cjs");
 const utils_js_1 = require("../utils.cjs");
 const errors_js_1 = require("../errors.cjs");
@@ -29,7 +30,13 @@ class ChannelWrite extends utils_js_1.RunnableCallable {
     constructor(writes, tags) {
         const name = `ChannelWrite<${writes
             .map((packet) => {
-            return (0, constants_js_1._isSend)(packet) ? packet.node : packet.channel;
+            if ((0, constants_js_1._isSend)(packet)) {
+                return packet.node;
+            }
+            else if ("channel" in packet) {
+                return packet.channel;
+            }
+            return "...";
         })
             .join(",")}>`;
         super({
@@ -48,7 +55,13 @@ class ChannelWrite extends utils_js_1.RunnableCallable {
     }
     async _write(input, config) {
         const writes = this.writes.map((write) => {
-            if (_isChannelWriteEntry(write) && _isPassthrough(write.value)) {
+            if (_isChannelWriteTupleEntry(write) && _isPassthrough(write.value)) {
+                return {
+                    mapper: write.mapper,
+                    value: input,
+                };
+            }
+            else if (_isChannelWriteEntry(write) && _isPassthrough(write.value)) {
                 return {
                     channel: write.channel,
                     value: input,
@@ -65,36 +78,52 @@ class ChannelWrite extends utils_js_1.RunnableCallable {
     }
     // TODO: Support requireAtLeastOneOf
     static async doWrite(config, writes) {
-        const sends = writes.filter(constants_js_1._isSend).map((packet) => {
-            return [constants_js_1.TASKS, packet];
-        });
-        const entries = 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}`);
+        // validate
+        for (const w of writes) {
+            if (_isChannelWriteEntry(w)) {
+                if (w.channel === constants_js_1.TASKS) {
+                    throw new errors_js_1.InvalidUpdateError("Cannot write to the reserved channel TASKS");
+                }
+                if (_isPassthrough(w.value)) {
+                    throw new errors_js_1.InvalidUpdateError("PASSTHROUGH value must be replaced");
+                }
+            }
+            if (_isChannelWriteTupleEntry(w)) {
+                if (_isPassthrough(w.value)) {
+                    throw new errors_js_1.InvalidUpdateError("PASSTHROUGH value must be replaced");
+                }
+            }
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const writeEntries = [];
+        for (const w of writes) {
+            if ((0, constants_js_1._isSend)(w)) {
+                writeEntries.push([constants_js_1.TASKS, w]);
+            }
+            else if (_isChannelWriteTupleEntry(w)) {
+                const mappedResult = await w.mapper.invoke(w.value, config);
+                if (mappedResult != null && mappedResult.length > 0) {
+                    writeEntries.push(...mappedResult);
+                }
+            }
+            else if (_isChannelWriteEntry(w)) {
+                const mappedValue = w.mapper !== undefined
+                    ? await w.mapper.invoke(w.value, config)
+                    : w.value;
+                if (_isSkipWrite(mappedValue)) {
+                    continue;
+                }
+                if (w.skipNone && mappedValue === undefined) {
+                    continue;
+                }
+                writeEntries.push([w.channel, mappedValue]);
+            }
+            else {
+                throw new Error(`Invalid write entry: ${JSON.stringify(w)}`);
+            }
         }
-        const values = await Promise.all(entries.map(async (write) => {
-            const mappedValue = write.mapper
-                ? await write.mapper.invoke(write.value, config)
-                : write.value;
-            return {
-                ...write,
-                value: mappedValue,
-            };
-        })).then((writes) => {
-            return writes
-                .filter((write) => !write.skipNone || write.value !== null)
-                .map((write) => {
-                return [write.channel, write.value];
-            });
-        });
         const write = config.configurable?.[constants_js_1.CONFIG_KEY_SEND];
-        const filtered = values.filter(([_, value]) => !_isSkipWrite(value));
-        write([...sends, ...filtered]);
+        write(writeEntries);
     }
     static isWriter(runnable) {
         return (
@@ -110,3 +139,8 @@ exports.ChannelWrite = ChannelWrite;
 function _isChannelWriteEntry(x) {
     return (x !== undefined && typeof x.channel === "string");
 }
+function _isChannelWriteTupleEntry(x) {
+    return (x !== undefined &&
+        !_isChannelWriteEntry(x) &&
+        runnables_1.Runnable.isRunnable(x.mapper));
+}

package/dist/pregel/write.d.ts

@@ -12,10 +12,10 @@ export declare const PASSTHROUGH: {
  * or None to skip writing.
  */
 export declare class ChannelWrite<RunInput = any> extends RunnableCallable {
-    writes: Array<ChannelWriteEntry | Send>;
-    constructor(writes: Array<ChannelWriteEntry | Send>, tags?: string[]);
+    writes: Array<ChannelWriteEntry | ChannelWriteTupleEntry | Send>;
+    constructor(writes: Array<ChannelWriteEntry | ChannelWriteTupleEntry | Send>, tags?: string[]);
     _write(input: unknown, config: RunnableConfig): Promise<unknown>;
-    static doWrite(config: RunnableConfig, writes: (ChannelWriteEntry | Send)[]): Promise<void>;
+    static doWrite(config: RunnableConfig, writes: (ChannelWriteEntry | ChannelWriteTupleEntry | Send)[]): Promise<void>;
     static isWriter(runnable: RunnableLike): runnable is ChannelWrite;
     static registerWriter<T extends Runnable>(runnable: T): T;
 }
@@ -25,3 +25,7 @@ export interface ChannelWriteEntry {
     skipNone?: boolean;
     mapper?: Runnable;
 }
+export interface ChannelWriteTupleEntry {
+    value: unknown;
+    mapper: Runnable<any, [string, any][]>;
+}