@langchain/langgraph 0.2.45 → 0.2.47

package/dist/pregel/io.cjs

@@ -157,10 +157,15 @@ function* mapOutputValues(outputChannels, pendingWrites, channels
 exports.mapOutputValues = mapOutputValues;
 /**
  * Map pending writes (a sequence of tuples (channel, value)) to output chunk.
+ * @internal
+ *
+ * @param outputChannels - The channels to output.
+ * @param tasks - The tasks to output.
+ * @param cached - Whether the output is cached.
+ *
+ * @returns A generator that yields the output chunk (if any).
  */
-function* mapOutputUpdates(outputChannels, tasks, cached
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-) {
+function* mapOutputUpdates(outputChannels, tasks, cached) {
     const outputTasks = tasks.filter(([task, ww]) => {
         return ((task.config === undefined || !task.config.tags?.includes(constants_js_1.TAG_HIDDEN)) &&
             ww[0][0] !== constants_js_1.ERROR &&
@@ -169,47 +174,67 @@ function* mapOutputUpdates(outputChannels, tasks, cached
     if (!outputTasks.length) {
         return;
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     let updated;
     if (outputTasks.some(([task]) => task.writes.some(([chan, _]) => chan === constants_js_1.RETURN))) {
+        // TODO: probably should assert that RETURN is the only "non-special" channel (starts with "__")
         updated = outputTasks.flatMap(([task]) => task.writes
             .filter(([chan, _]) => chan === constants_js_1.RETURN)
             .map(([_, value]) => [task.name, value]));
     }
     else if (!Array.isArray(outputChannels)) {
+        // special case where graph state is a single channel (MessageGraph)
+        // probably using this in functional API, too
         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 {
-        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
-    );
+        updated = outputTasks.flatMap(([task]) => {
+            const { writes } = task;
+            const counts = {};
+            for (const [chan] of writes) {
+                if (outputChannels.includes(chan)) {
+                    counts[chan] = (counts[chan] || 0) + 1;
+                }
+            }
+            if (Object.values(counts).some((count) => count > 1)) {
+                // Multiple writes to the same channel: create separate entries
+                return writes
+                    .filter(([chan]) => outputChannels.includes(chan))
+                    .map(([chan, value]) => [task.name, { [chan]: value }]);
+            }
+            else {
+                // Single write to each channel: create a single combined entry
+                return [
+                    [
+                        task.name,
+                        Object.fromEntries(writes.filter(([chan]) => outputChannels.includes(chan))),
+                    ],
+                ];
+            }
+        });
+    }
+    const grouped = {};
     for (const [node, value] of updated) {
+        if (!(node in grouped)) {
+            grouped[node] = [];
+        }
         grouped[node].push(value);
     }
-    for (const [node, value] of Object.entries(grouped)) {
-        if (value.length === 0) {
-            delete grouped[node];
+    const flattened = {};
+    for (const node in grouped) {
+        if (grouped[node].length === 1) {
+            const [write] = grouped[node];
+            flattened[node] = write;
         }
-        else if (value.length === 1) {
-            // TODO: Fix incorrect cast here
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            grouped[node] = value[0];
+        else {
+            flattened[node] = grouped[node];
         }
     }
     if (cached) {
-        grouped["__metadata__"] = { cached };
+        flattened["__metadata__"] = { cached };
     }
-    yield grouped;
+    yield flattened;
 }
 exports.mapOutputUpdates = mapOutputUpdates;
 function single(iter) {

package/dist/pregel/io.d.ts

@@ -18,6 +18,13 @@ export declare function mapInput<C extends PropertyKey>(inputChannels: C | Array
 export declare function mapOutputValues<C extends PropertyKey>(outputChannels: C | Array<C>, pendingWrites: readonly PendingWrite<C>[] | true, channels: Record<C, BaseChannel>): Generator<Record<string, any>, any>;
 /**
  * Map pending writes (a sequence of tuples (channel, value)) to output chunk.
+ * @internal
+ *
+ * @param outputChannels - The channels to output.
+ * @param tasks - The tasks to output.
+ * @param cached - Whether the output is cached.
+ *
+ * @returns A generator that yields the output chunk (if any).
  */
-export declare function mapOutputUpdates<N extends PropertyKey, C extends PropertyKey>(outputChannels: C | Array<C>, tasks: readonly [PregelExecutableTask<N, C>, PendingWrite<C>[]][], cached?: boolean): Generator<Record<N, Record<string, any> | any>>;
+export declare function mapOutputUpdates<N extends PropertyKey, C extends PropertyKey>(outputChannels: C | Array<C>, tasks: readonly [PregelExecutableTask<N, C>, PendingWrite<C>[]][], cached?: boolean): Generator<Record<N, Record<string, unknown> | unknown>>;
 export declare function single<T>(iter: IterableIterator<T>): T | null;

package/dist/pregel/io.js

@@ -149,10 +149,15 @@ export function* mapOutputValues(outputChannels, pendingWrites, channels
 }
 /**
  * Map pending writes (a sequence of tuples (channel, value)) to output chunk.
+ * @internal
+ *
+ * @param outputChannels - The channels to output.
+ * @param tasks - The tasks to output.
+ * @param cached - Whether the output is cached.
+ *
+ * @returns A generator that yields the output chunk (if any).
  */
-export function* mapOutputUpdates(outputChannels, tasks, cached
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-) {
+export function* mapOutputUpdates(outputChannels, tasks, cached) {
     const outputTasks = tasks.filter(([task, ww]) => {
         return ((task.config === undefined || !task.config.tags?.includes(TAG_HIDDEN)) &&
             ww[0][0] !== ERROR &&
@@ -161,47 +166,67 @@ export function* mapOutputUpdates(outputChannels, tasks, cached
     if (!outputTasks.length) {
         return;
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     let updated;
     if (outputTasks.some(([task]) => task.writes.some(([chan, _]) => chan === RETURN))) {
+        // TODO: probably should assert that RETURN is the only "non-special" channel (starts with "__")
         updated = outputTasks.flatMap(([task]) => task.writes
             .filter(([chan, _]) => chan === RETURN)
             .map(([_, value]) => [task.name, value]));
     }
     else if (!Array.isArray(outputChannels)) {
+        // special case where graph state is a single channel (MessageGraph)
+        // probably using this in functional API, too
         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 {
-        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
-    );
+        updated = outputTasks.flatMap(([task]) => {
+            const { writes } = task;
+            const counts = {};
+            for (const [chan] of writes) {
+                if (outputChannels.includes(chan)) {
+                    counts[chan] = (counts[chan] || 0) + 1;
+                }
+            }
+            if (Object.values(counts).some((count) => count > 1)) {
+                // Multiple writes to the same channel: create separate entries
+                return writes
+                    .filter(([chan]) => outputChannels.includes(chan))
+                    .map(([chan, value]) => [task.name, { [chan]: value }]);
+            }
+            else {
+                // Single write to each channel: create a single combined entry
+                return [
+                    [
+                        task.name,
+                        Object.fromEntries(writes.filter(([chan]) => outputChannels.includes(chan))),
+                    ],
+                ];
+            }
+        });
+    }
+    const grouped = {};
     for (const [node, value] of updated) {
+        if (!(node in grouped)) {
+            grouped[node] = [];
+        }
         grouped[node].push(value);
     }
-    for (const [node, value] of Object.entries(grouped)) {
-        if (value.length === 0) {
-            delete grouped[node];
+    const flattened = {};
+    for (const node in grouped) {
+        if (grouped[node].length === 1) {
+            const [write] = grouped[node];
+            flattened[node] = write;
         }
-        else if (value.length === 1) {
-            // TODO: Fix incorrect cast here
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            grouped[node] = value[0];
+        else {
+            flattened[node] = grouped[node];
         }
     }
     if (cached) {
-        grouped["__metadata__"] = { cached };
+        flattened["__metadata__"] = { cached };
     }
-    yield grouped;
+    yield flattened;
 }
 export function single(iter) {
     // eslint-disable-next-line no-unreachable-loop

package/dist/pregel/loop.cjs

@@ -527,6 +527,7 @@ class PregelLoop {
         return true;
     }
     async finishAndHandleError(error) {
+        this._syncStateOnParentCommand(error);
         const suppress = this._suppressInterrupt(error);
         if (suppress || error === undefined) {
             this.output = (0, io_js_1.readChannels)(this.channels, this.outputKeys);
@@ -751,5 +752,15 @@ class PregelLoop {
             }
         }
     }
+    _syncStateOnParentCommand(error) {
+        if ((0, errors_js_1.isParentCommand)(error)) {
+            const state = Object.entries((0, io_js_1.readChannels)(this.channels, typeof this.outputKeys === "string"
+                ? [this.outputKeys]
+                : this.outputKeys));
+            const update = [...state, ...error.command._updateAsTuples()];
+            // eslint-disable-next-line no-param-reassign
+            error.command.update = update;
+        }
+    }
 }
 exports.PregelLoop = PregelLoop;

package/dist/pregel/loop.d.ts

@@ -116,5 +116,6 @@ export declare class PregelLoop {
     protected _emit(values: [StreamMode, unknown][]): void;
     protected _putCheckpoint(inputMetadata: Omit<CheckpointMetadata, "step" | "parents">): Promise<void>;
     protected _matchWrites(tasks: Record<string, PregelExecutableTask<string, string>>): void;
+    _syncStateOnParentCommand(error: unknown): void;
 }
 export {};

package/dist/pregel/loop.js

@@ -4,7 +4,7 @@ import { isCommand, CHECKPOINT_NAMESPACE_SEPARATOR, CONFIG_KEY_CHECKPOINT_MAP, C
 import { _applyWrites, _prepareNextTasks, _prepareSingleTask, increment, shouldInterrupt, } from "./algo.js";
 import { gatherIterator, gatherIteratorSync, prefixGenerator, } from "../utils.js";
 import { mapCommand, mapInput, mapOutputUpdates, mapOutputValues, readChannels, } from "./io.js";
-import { getSubgraphsSeenSet, EmptyInputError, GraphInterrupt, isGraphInterrupt, MultipleSubgraphsError, } from "../errors.js";
+import { getSubgraphsSeenSet, EmptyInputError, GraphInterrupt, isGraphInterrupt, MultipleSubgraphsError, isParentCommand, } from "../errors.js";
 import { getNewChannelVersions, patchConfigurable } from "./utils/index.js";
 import { mapDebugTasks, mapDebugCheckpoint, mapDebugTaskResults, printStepTasks, } from "./debug.js";
 import { IterableReadableWritableStream } from "./stream.js";
@@ -524,6 +524,7 @@ export class PregelLoop {
         return true;
     }
     async finishAndHandleError(error) {
+        this._syncStateOnParentCommand(error);
         const suppress = this._suppressInterrupt(error);
         if (suppress || error === undefined) {
             this.output = readChannels(this.channels, this.outputKeys);
@@ -748,4 +749,14 @@ export class PregelLoop {
             }
         }
     }
+    _syncStateOnParentCommand(error) {
+        if (isParentCommand(error)) {
+            const state = Object.entries(readChannels(this.channels, typeof this.outputKeys === "string"
+                ? [this.outputKeys]
+                : this.outputKeys));
+            const update = [...state, ...error.command._updateAsTuples()];
+            // eslint-disable-next-line no-param-reassign
+            error.command.update = update;
+        }
+    }
 }

package/dist/pregel/messages.cjs

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StreamMessagesHandler = void 0;
-const uuid_1 = require("uuid");
 const base_1 = require("@langchain/core/callbacks/base");
 const messages_1 = require("@langchain/core/messages");
 const constants_js_1 = require("../constants.cjs");
@@ -47,6 +46,12 @@ class StreamMessagesHandler extends base_1.BaseCallbackHandler {
             writable: true,
             value: {}
         });
+        Object.defineProperty(this, "stableMessageIdMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
         Object.defineProperty(this, "lc_prefer_streaming", {
             enumerable: true,
             configurable: true,
@@ -55,18 +60,26 @@ class StreamMessagesHandler extends base_1.BaseCallbackHandler {
         });
         this.streamFn = streamFn;
     }
-    _emit(meta, message, dedupe = false) {
+    _emit(meta, message, runId, dedupe = false) {
         if (dedupe &&
             message.id !== undefined &&
             this.seen[message.id] !== undefined) {
             return;
         }
-        if (message.id === undefined) {
-            const id = (0, uuid_1.v4)();
+        // For instance in ChatAnthropic, the first chunk has an message ID
+        // but the subsequent chunks do not. To avoid clients seeing two messages
+        // we rename the message ID if it's being auto-set to `run-${runId}`
+        // (see https://github.com/langchain-ai/langchainjs/pull/6646).
+        let messageId = message.id;
+        if (messageId == null || messageId === `run-${runId}`) {
+            messageId = this.stableMessageIdMap[runId] ?? messageId ?? `run-${runId}`;
+        }
+        this.stableMessageIdMap[runId] ??= messageId;
+        if (messageId !== message.id) {
             // eslint-disable-next-line no-param-reassign
-            message.id = id;
+            message.id = messageId;
             // eslint-disable-next-line no-param-reassign
-            message.lc_kwargs.id = id;
+            message.lc_kwargs.id = messageId;
         }
         this.seen[message.id] = message;
         this.streamFn([meta[0], "messages", [message, meta[1]]]);
@@ -86,12 +99,10 @@ class StreamMessagesHandler extends base_1.BaseCallbackHandler {
         this.emittedChatModelRunIds[runId] = true;
         if (this.metadatas[runId] !== undefined) {
             if (isChatGenerationChunk(chunk)) {
-                this._emit(this.metadatas[runId], chunk.message);
+                this._emit(this.metadatas[runId], chunk.message, runId);
             }
             else {
-                this._emit(this.metadatas[runId], new messages_1.AIMessageChunk({
-                    content: token,
-                }));
+                this._emit(this.metadatas[runId], new messages_1.AIMessageChunk({ content: token }), runId);
             }
         }
     }
@@ -100,11 +111,12 @@ class StreamMessagesHandler extends base_1.BaseCallbackHandler {
         if (!this.emittedChatModelRunIds[runId]) {
             const chatGeneration = output.generations?.[0]?.[0];
             if ((0, messages_1.isBaseMessage)(chatGeneration?.message)) {
-                this._emit(this.metadatas[runId], chatGeneration?.message, true);
+                this._emit(this.metadatas[runId], chatGeneration?.message, runId, true);
             }
             delete this.emittedChatModelRunIds[runId];
         }
         delete this.metadatas[runId];
+        delete this.stableMessageIdMap[runId];
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     handleLLMError(_err, runId) {
@@ -125,24 +137,24 @@ class StreamMessagesHandler extends base_1.BaseCallbackHandler {
         delete this.metadatas[runId];
         if (metadata !== undefined) {
             if ((0, messages_1.isBaseMessage)(outputs)) {
-                this._emit(metadata, outputs, true);
+                this._emit(metadata, outputs, runId, true);
             }
             else if (Array.isArray(outputs)) {
                 for (const value of outputs) {
                     if ((0, messages_1.isBaseMessage)(value)) {
-                        this._emit(metadata, value, true);
+                        this._emit(metadata, value, runId, true);
                     }
                 }
             }
             else if (outputs != null && typeof outputs === "object") {
                 for (const value of Object.values(outputs)) {
                     if ((0, messages_1.isBaseMessage)(value)) {
-                        this._emit(metadata, value, true);
+                        this._emit(metadata, value, runId, true);
                     }
                     else if (Array.isArray(value)) {
                         for (const item of value) {
                             if ((0, messages_1.isBaseMessage)(item)) {
-                                this._emit(metadata, item, true);
+                                this._emit(metadata, item, runId, true);
                             }
                         }
                     }

package/dist/pregel/messages.d.ts

@@ -15,9 +15,10 @@ export declare class StreamMessagesHandler extends BaseCallbackHandler {
     metadatas: Record<string, Meta>;
     seen: Record<string, BaseMessage>;
     emittedChatModelRunIds: Record<string, boolean>;
+    stableMessageIdMap: Record<string, string>;
     lc_prefer_streaming: boolean;
     constructor(streamFn: (streamChunk: StreamChunk) => void);
-    _emit(meta: Meta, message: BaseMessage, dedupe?: boolean): void;
+    _emit(meta: Meta, message: BaseMessage, runId: string, 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;
     handleLLMNewToken(token: string, _idx: NewTokenIndices, runId: string, _parentRunId?: string, _tags?: string[], fields?: HandleLLMNewTokenCallbackFields): void;
     handleLLMEnd(output: LLMResult, runId: string): void;

package/dist/pregel/messages.js

@@ -1,4 +1,3 @@
-import { v4 } from "uuid";
 import { BaseCallbackHandler, } from "@langchain/core/callbacks/base";
 import { AIMessageChunk, isBaseMessage, } from "@langchain/core/messages";
 import { TAG_HIDDEN, TAG_NOSTREAM } from "../constants.js";
@@ -44,6 +43,12 @@ export class StreamMessagesHandler extends BaseCallbackHandler {
             writable: true,
             value: {}
         });
+        Object.defineProperty(this, "stableMessageIdMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
         Object.defineProperty(this, "lc_prefer_streaming", {
             enumerable: true,
             configurable: true,
@@ -52,18 +57,26 @@ export class StreamMessagesHandler extends BaseCallbackHandler {
         });
         this.streamFn = streamFn;
     }
-    _emit(meta, message, dedupe = false) {
+    _emit(meta, message, runId, dedupe = false) {
         if (dedupe &&
             message.id !== undefined &&
             this.seen[message.id] !== undefined) {
             return;
         }
-        if (message.id === undefined) {
-            const id = v4();
+        // For instance in ChatAnthropic, the first chunk has an message ID
+        // but the subsequent chunks do not. To avoid clients seeing two messages
+        // we rename the message ID if it's being auto-set to `run-${runId}`
+        // (see https://github.com/langchain-ai/langchainjs/pull/6646).
+        let messageId = message.id;
+        if (messageId == null || messageId === `run-${runId}`) {
+            messageId = this.stableMessageIdMap[runId] ?? messageId ?? `run-${runId}`;
+        }
+        this.stableMessageIdMap[runId] ??= messageId;
+        if (messageId !== message.id) {
             // eslint-disable-next-line no-param-reassign
-            message.id = id;
+            message.id = messageId;
             // eslint-disable-next-line no-param-reassign
-            message.lc_kwargs.id = id;
+            message.lc_kwargs.id = messageId;
         }
         this.seen[message.id] = message;
         this.streamFn([meta[0], "messages", [message, meta[1]]]);
@@ -83,12 +96,10 @@ export class StreamMessagesHandler extends BaseCallbackHandler {
         this.emittedChatModelRunIds[runId] = true;
         if (this.metadatas[runId] !== undefined) {
             if (isChatGenerationChunk(chunk)) {
-                this._emit(this.metadatas[runId], chunk.message);
+                this._emit(this.metadatas[runId], chunk.message, runId);
             }
             else {
-                this._emit(this.metadatas[runId], new AIMessageChunk({
-                    content: token,
-                }));
+                this._emit(this.metadatas[runId], new AIMessageChunk({ content: token }), runId);
             }
         }
     }
@@ -97,11 +108,12 @@ export class StreamMessagesHandler extends BaseCallbackHandler {
         if (!this.emittedChatModelRunIds[runId]) {
             const chatGeneration = output.generations?.[0]?.[0];
             if (isBaseMessage(chatGeneration?.message)) {
-                this._emit(this.metadatas[runId], chatGeneration?.message, true);
+                this._emit(this.metadatas[runId], chatGeneration?.message, runId, true);
             }
             delete this.emittedChatModelRunIds[runId];
         }
         delete this.metadatas[runId];
+        delete this.stableMessageIdMap[runId];
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     handleLLMError(_err, runId) {
@@ -122,24 +134,24 @@ export class StreamMessagesHandler extends BaseCallbackHandler {
         delete this.metadatas[runId];
         if (metadata !== undefined) {
             if (isBaseMessage(outputs)) {
-                this._emit(metadata, outputs, true);
+                this._emit(metadata, outputs, runId, true);
             }
             else if (Array.isArray(outputs)) {
                 for (const value of outputs) {
                     if (isBaseMessage(value)) {
-                        this._emit(metadata, value, true);
+                        this._emit(metadata, value, runId, true);
                     }
                 }
             }
             else if (outputs != null && typeof outputs === "object") {
                 for (const value of Object.values(outputs)) {
                     if (isBaseMessage(value)) {
-                        this._emit(metadata, value, true);
+                        this._emit(metadata, value, runId, true);
                     }
                     else if (Array.isArray(value)) {
                         for (const item of value) {
                             if (isBaseMessage(item)) {
-                                this._emit(metadata, item, true);
+                                this._emit(metadata, item, runId, true);
                             }
                         }
                     }

package/dist/pregel/remote.cjs

@@ -41,18 +41,13 @@ const getStreamModes = (streamMode, defaultStreamMode = "updates") => {
     if (streamMode !== undefined &&
         (typeof streamMode === "string" ||
             (Array.isArray(streamMode) && streamMode.length > 0))) {
-        if (typeof streamMode === "string") {
-            updatedStreamModes.push(streamMode);
-        }
-        else {
-            reqSingle = false;
-            updatedStreamModes.push(...streamMode);
-        }
+        reqSingle = typeof streamMode === "string";
+        const mapped = Array.isArray(streamMode) ? streamMode : [streamMode];
+        updatedStreamModes.push(...mapped);
     }
     else {
         updatedStreamModes.push(defaultStreamMode);
     }
-    // TODO: Map messages to messages-tuple
     if (updatedStreamModes.includes("updates")) {
         reqUpdates = true;
     }
@@ -303,7 +298,11 @@ class RemoteGraph extends runnables_1.Runnable {
                 ...updatedStreamModes,
                 ...(streamProtocolInstance?.modes ?? new Set()),
             ]),
-        ];
+        ].map((mode) => {
+            if (mode === "messages")
+                return "messages-tuple";
+            return mode;
+        });
         let command;
         let serializedInput;
         if ((0, constants_js_1.isCommand)(input)) {

package/dist/pregel/remote.js

@@ -38,18 +38,13 @@ const getStreamModes = (streamMode, defaultStreamMode = "updates") => {
     if (streamMode !== undefined &&
         (typeof streamMode === "string" ||
             (Array.isArray(streamMode) && streamMode.length > 0))) {
-        if (typeof streamMode === "string") {
-            updatedStreamModes.push(streamMode);
-        }
-        else {
-            reqSingle = false;
-            updatedStreamModes.push(...streamMode);
-        }
+        reqSingle = typeof streamMode === "string";
+        const mapped = Array.isArray(streamMode) ? streamMode : [streamMode];
+        updatedStreamModes.push(...mapped);
     }
     else {
         updatedStreamModes.push(defaultStreamMode);
     }
-    // TODO: Map messages to messages-tuple
     if (updatedStreamModes.includes("updates")) {
         reqUpdates = true;
     }
@@ -300,7 +295,11 @@ export class RemoteGraph extends Runnable {
                 ...updatedStreamModes,
                 ...(streamProtocolInstance?.modes ?? new Set()),
             ]),
-        ];
+        ].map((mode) => {
+            if (mode === "messages")
+                return "messages-tuple";
+            return mode;
+        });
         let command;
         let serializedInput;
         if (isCommand(input)) {