@langchain/langgraph 0.2.27 → 0.2.28

package/dist/pregel/loop.js

@@ -572,22 +572,9 @@ export class PregelLoop {
     async _first(inputKeys) {
         const isResuming = Object.keys(this.checkpoint.channel_versions).length !== 0 &&
             (this.config.configurable?.[CONFIG_KEY_RESUMING] !== undefined ||
-                this.input === null);
-        if (isResuming) {
-            for (const channelName of Object.keys(this.channels)) {
-                if (this.checkpoint.channel_versions[channelName] !== undefined) {
-                    const version = this.checkpoint.channel_versions[channelName];
-                    this.checkpoint.versions_seen[INTERRUPT] = {
-                        ...this.checkpoint.versions_seen[INTERRUPT],
-                        [channelName]: version,
-                    };
-                }
-            }
-            // produce values output
-            const valuesOutput = await gatherIterator(prefixGenerator(mapOutputValues(this.outputKeys, true, this.channels), "values"));
-            this._emit(valuesOutput);
-        }
-        else if (_isCommand(this.input)) {
+                this.input === null ||
+                _isCommand(this.input));
+        if (_isCommand(this.input)) {
             const writes = {};
             // group writes by task id
             for (const [tid, key, value] of mapCommand(this.input)) {
@@ -604,6 +591,20 @@ export class PregelLoop {
                 this.putWrites(tid, ws);
             }
         }
+        if (isResuming) {
+            for (const channelName of Object.keys(this.channels)) {
+                if (this.checkpoint.channel_versions[channelName] !== undefined) {
+                    const version = this.checkpoint.channel_versions[channelName];
+                    this.checkpoint.versions_seen[INTERRUPT] = {
+                        ...this.checkpoint.versions_seen[INTERRUPT],
+                        [channelName]: version,
+                    };
+                }
+            }
+            // produce values output
+            const valuesOutput = await gatherIterator(prefixGenerator(mapOutputValues(this.outputKeys, true, this.channels), "values"));
+            this._emit(valuesOutput);
+        }
         else {
             // map inputs to channel updates
             const inputWrites = await gatherIterator(mapInput(inputKeys, this.input));

package/dist/pregel/retry.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeTasksWithRetry = exports.DEFAULT_MAX_RETRIES = exports.DEFAULT_MAX_INTERVAL = exports.DEFAULT_BACKOFF_FACTOR = exports.DEFAULT_INITIAL_INTERVAL = void 0;
+const constants_js_1 = require("../constants.cjs");
 const errors_js_1 = require("../errors.cjs");
 exports.DEFAULT_INITIAL_INTERVAL = 500;
 exports.DEFAULT_BACKOFF_FACTOR = 2;
@@ -103,6 +104,28 @@ pregelTask, retryPolicy) {
         catch (e) {
             error = e;
             error.pregelTaskId = pregelTask.id;
+            if ((0, errors_js_1.isParentCommand)(error)) {
+                const ns = pregelTask.config?.configurable?.checkpoint_ns;
+                const cmd = error.command;
+                if (cmd.graph === ns) {
+                    // this command is for the current graph, handle it
+                    for (const writer of pregelTask.writers) {
+                        await writer.invoke(cmd, pregelTask.config);
+                    }
+                    break;
+                }
+                else if (cmd.graph === constants_js_1.Command.PARENT) {
+                    // this command is for the parent graph, assign it to the parent
+                    const parent_ns = ns
+                        .split(constants_js_1.CHECKPOINT_NAMESPACE_SEPARATOR)
+                        .slice(0, -1)
+                        .join(constants_js_1.CHECKPOINT_NAMESPACE_SEPARATOR);
+                    error.command = new constants_js_1.Command({
+                        ...error.command,
+                        graph: parent_ns,
+                    });
+                }
+            }
             if ((0, errors_js_1.isGraphBubbleUp)(error)) {
                 break;
             }

package/dist/pregel/retry.js

@@ -1,4 +1,5 @@
-import { getSubgraphsSeenSet, isGraphBubbleUp } from "../errors.js";
+import { CHECKPOINT_NAMESPACE_SEPARATOR, Command } from "../constants.js";
+import { getSubgraphsSeenSet, isGraphBubbleUp, isParentCommand, } from "../errors.js";
 export const DEFAULT_INITIAL_INTERVAL = 500;
 export const DEFAULT_BACKOFF_FACTOR = 2;
 export const DEFAULT_MAX_INTERVAL = 128000;
@@ -99,6 +100,28 @@ pregelTask, retryPolicy) {
         catch (e) {
             error = e;
             error.pregelTaskId = pregelTask.id;
+            if (isParentCommand(error)) {
+                const ns = pregelTask.config?.configurable?.checkpoint_ns;
+                const cmd = error.command;
+                if (cmd.graph === ns) {
+                    // this command is for the current graph, handle it
+                    for (const writer of pregelTask.writers) {
+                        await writer.invoke(cmd, pregelTask.config);
+                    }
+                    break;
+                }
+                else if (cmd.graph === Command.PARENT) {
+                    // this command is for the parent graph, assign it to the parent
+                    const parent_ns = ns
+                        .split(CHECKPOINT_NAMESPACE_SEPARATOR)
+                        .slice(0, -1)
+                        .join(CHECKPOINT_NAMESPACE_SEPARATOR);
+                    error.command = new Command({
+                        ...error.command,
+                        graph: parent_ns,
+                    });
+                }
+            }
             if (isGraphBubbleUp(error)) {
                 break;
             }

package/dist/pregel/types.d.ts

@@ -111,6 +111,7 @@ export interface PregelExecutableTask<N extends PropertyKey, C extends PropertyK
     readonly id: string;
     readonly path?: [string, ...(string | number)[]];
     readonly subgraphs?: Runnable[];
+    readonly writers: Runnable[];
 }
 export interface StateSnapshot {
     /**

package/dist/pregel/write.cjs

@@ -46,13 +46,29 @@ class ChannelWrite extends utils_js_1.RunnableCallable {
         });
         this.writes = writes;
     }
-    async _getWriteValues(input, config) {
-        const writes = this.writes
-            .filter(constants_js_1._isSend)
-            .map((packet) => {
+    async _write(input, config) {
+        const writes = this.writes.map((write) => {
+            if (_isChannelWriteEntry(write) && _isPassthrough(write.value)) {
+                return {
+                    channel: write.channel,
+                    value: input,
+                    skipNone: write.skipNone,
+                    mapper: write.mapper,
+                };
+            }
+            else {
+                return write;
+            }
+        });
+        await ChannelWrite.doWrite(config, writes);
+        return input;
+    }
+    // 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 = this.writes.filter((write) => {
+        const entries = writes.filter((write) => {
             return !(0, constants_js_1._isSend)(write);
         });
         const invalidEntry = entries.find((write) => {
@@ -62,16 +78,9 @@ class ChannelWrite extends utils_js_1.RunnableCallable {
             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;
+                ? await write.mapper.invoke(write.value, config)
+                : write.value;
             return {
                 ...write,
                 value: mappedValue,
@@ -83,18 +92,9 @@ class ChannelWrite extends utils_js_1.RunnableCallable {
                 return [write.channel, write.value];
             });
         });
-        return [...writes, ...values];
-    }
-    async _write(input, config) {
-        const values = await this._getWriteValues(input, config);
-        ChannelWrite.doWrite(config, values);
-        return input;
-    }
-    // TODO: Support requireAtLeastOneOf
-    static doWrite(config, values) {
         const write = config.configurable?.[constants_js_1.CONFIG_KEY_SEND];
         const filtered = values.filter(([_, value]) => !_isSkipWrite(value));
-        write(filtered);
+        write([...sends, ...filtered]);
     }
     static isWriter(runnable) {
         return (
@@ -107,3 +107,6 @@ class ChannelWrite extends utils_js_1.RunnableCallable {
     }
 }
 exports.ChannelWrite = ChannelWrite;
+function _isChannelWriteEntry(x) {
+    return (x !== undefined && typeof x.channel === "string");
+}

package/dist/pregel/write.d.ts

@@ -14,9 +14,8 @@ export declare const PASSTHROUGH: {
 export declare class ChannelWrite<RunInput = any> extends RunnableCallable {
     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<unknown>;
-    static doWrite(config: RunnableConfig, values: [string, unknown][]): void;
+    static doWrite(config: RunnableConfig, writes: (ChannelWriteEntry | Send)[]): Promise<void>;
     static isWriter(runnable: RunnableLike): runnable is ChannelWrite;
     static registerWriter<T extends Runnable>(runnable: T): T;
 }

package/dist/pregel/write.js

@@ -43,13 +43,29 @@ export class ChannelWrite extends RunnableCallable {
         });
         this.writes = writes;
     }
-    async _getWriteValues(input, config) {
-        const writes = this.writes
-            .filter(_isSend)
-            .map((packet) => {
+    async _write(input, config) {
+        const writes = this.writes.map((write) => {
+            if (_isChannelWriteEntry(write) && _isPassthrough(write.value)) {
+                return {
+                    channel: write.channel,
+                    value: input,
+                    skipNone: write.skipNone,
+                    mapper: write.mapper,
+                };
+            }
+            else {
+                return write;
+            }
+        });
+        await ChannelWrite.doWrite(config, writes);
+        return input;
+    }
+    // TODO: Support requireAtLeastOneOf
+    static async doWrite(config, writes) {
+        const sends = writes.filter(_isSend).map((packet) => {
             return [TASKS, packet];
         });
-        const entries = this.writes.filter((write) => {
+        const entries = writes.filter((write) => {
             return !_isSend(write);
         });
         const invalidEntry = entries.find((write) => {
@@ -59,16 +75,9 @@ export class ChannelWrite extends RunnableCallable {
             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;
+                ? await write.mapper.invoke(write.value, config)
+                : write.value;
             return {
                 ...write,
                 value: mappedValue,
@@ -80,18 +89,9 @@ export class ChannelWrite extends RunnableCallable {
                 return [write.channel, write.value];
             });
         });
-        return [...writes, ...values];
-    }
-    async _write(input, config) {
-        const values = await this._getWriteValues(input, config);
-        ChannelWrite.doWrite(config, values);
-        return input;
-    }
-    // TODO: Support requireAtLeastOneOf
-    static doWrite(config, values) {
         const write = config.configurable?.[CONFIG_KEY_SEND];
         const filtered = values.filter(([_, value]) => !_isSkipWrite(value));
-        write(filtered);
+        write([...sends, ...filtered]);
     }
     static isWriter(runnable) {
         return (
@@ -103,3 +103,6 @@ export class ChannelWrite extends RunnableCallable {
         return Object.defineProperty(runnable, IS_WRITER, { value: true });
     }
 }
+function _isChannelWriteEntry(x) {
+    return (x !== undefined && typeof x.channel === "string");
+}

package/dist/web.d.ts

@@ -4,7 +4,7 @@ export * from "./errors.js";
 export { BaseChannel, type BinaryOperator, BinaryOperatorAggregate, type AnyValue, type WaitForNames, type DynamicBarrierValue, type LastValue, type NamedBarrierValue, type Topic, } from "./channels/index.js";
 export { type AnnotationRoot as _INTERNAL_ANNOTATION_ROOT } from "./graph/index.js";
 export { type RetryPolicy } from "./pregel/utils/index.js";
-export { Send, Command, type Interrupt } from "./constants.js";
+export { Send, Command, type CommandParams, type Interrupt, } from "./constants.js";
 export { interrupt } from "./interrupt.js";
 export { MemorySaver, type Checkpoint, type CheckpointMetadata, type CheckpointTuple, copyCheckpoint, emptyCheckpoint, BaseCheckpointSaver, type Item, type GetOperation, type SearchOperation, type PutOperation, type Operation, type OperationResults, BaseStore, AsyncBatchedStore, InMemoryStore, type NameSpacePath, type NamespaceMatchType, type MatchCondition, type ListNamespacesOperation, } from "@langchain/langgraph-checkpoint";
 export * from "./managed/index.js";

package/dist/web.js

@@ -1,7 +1,7 @@
 export { END, Graph, START, StateGraph, CompiledStateGraph, MessageGraph, messagesStateReducer, Annotation, } from "./graph/index.js";
 export * from "./errors.js";
 export { BaseChannel, BinaryOperatorAggregate, } from "./channels/index.js";
-export { Send, Command } from "./constants.js";
+export { Send, Command, } from "./constants.js";
 export { interrupt } from "./interrupt.js";
 export { MemorySaver, copyCheckpoint, emptyCheckpoint, BaseCheckpointSaver, BaseStore, AsyncBatchedStore, InMemoryStore, } from "@langchain/langgraph-checkpoint";
 export * from "./managed/index.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph",
-  "version": "0.2.27",
+  "version": "0.2.28",
   "description": "LangGraph",
   "type": "module",
   "engines": {