@langchain/langgraph 0.2.27 → 0.2.29

package/dist/pregel/io.cjs

@@ -46,7 +46,34 @@ function readChannels(channels, select, skipEmpty = true
     }
 }
 exports.readChannels = readChannels;
+/**
+ * Map input chunk to a sequence of pending writes in the form (channel, value).
+ */
 function* mapCommand(cmd) {
+    if (cmd.graph === constants_js_1.Command.PARENT) {
+        throw new errors_js_1.InvalidUpdateError("There is no parent graph.");
+    }
+    if (cmd.goto) {
+        let sends;
+        if (Array.isArray(cmd.goto)) {
+            sends = cmd.goto;
+        }
+        else {
+            sends = [cmd.goto];
+        }
+        for (const send of sends) {
+            if ((0, constants_js_1._isSend)(send)) {
+                yield [constants_js_1.NULL_TASK_ID, constants_js_1.TASKS, send];
+            }
+            else if (typeof send === "string") {
+                yield [constants_js_1.NULL_TASK_ID, `branch:__start__:${constants_js_1.SELF}:${send}`, "__start__"];
+            }
+            else {
+                throw new Error(`In Command.send, expected Send or string, got ${typeof send}`);
+            }
+        }
+        // TODO: handle goto str for state graph
+    }
     if (cmd.resume) {
         if (typeof cmd.resume === "object" &&
             !!cmd.resume &&
@@ -60,6 +87,14 @@ function* mapCommand(cmd) {
             yield [constants_js_1.NULL_TASK_ID, constants_js_1.RESUME, cmd.resume];
         }
     }
+    if (cmd.update) {
+        if (typeof cmd.update !== "object" || !cmd.update) {
+            throw new Error("Expected cmd.update to be a dict mapping channel names to update values");
+        }
+        for (const [k, v] of Object.entries(cmd.update)) {
+            yield [constants_js_1.NULL_TASK_ID, k, v];
+        }
+    }
 }
 exports.mapCommand = mapCommand;
 /**

package/dist/pregel/io.d.ts

@@ -4,6 +4,9 @@ import type { PregelExecutableTask } from "./types.js";
 import { Command } from "../constants.js";
 export declare function readChannel<C extends PropertyKey>(channels: Record<C, BaseChannel>, chan: C, catchErrors?: boolean, returnException?: boolean): unknown | null;
 export declare function readChannels<C extends PropertyKey>(channels: Record<C, BaseChannel>, select: C | Array<C>, skipEmpty?: boolean): Record<string, any> | any;
+/**
+ * Map input chunk to a sequence of pending writes in the form (channel, value).
+ */
 export declare function mapCommand(cmd: Command): Generator<[string, string, unknown]>;
 /**
  * Map input chunk to a sequence of pending writes in the form [channel, value].

package/dist/pregel/io.js

@@ -1,6 +1,6 @@
 import { validate } from "uuid";
-import { NULL_TASK_ID, RESUME, TAG_HIDDEN } from "../constants.js";
-import { EmptyChannelError } from "../errors.js";
+import { _isSend, Command, NULL_TASK_ID, RESUME, SELF, TAG_HIDDEN, TASKS, } from "../constants.js";
+import { EmptyChannelError, InvalidUpdateError } from "../errors.js";
 export function readChannel(channels, chan, catchErrors = true, returnException = false) {
     try {
         return channels[chan].get();
@@ -41,7 +41,34 @@ export function readChannels(channels, select, skipEmpty = true
         return readChannel(channels, select);
     }
 }
+/**
+ * Map input chunk to a sequence of pending writes in the form (channel, value).
+ */
 export function* mapCommand(cmd) {
+    if (cmd.graph === Command.PARENT) {
+        throw new InvalidUpdateError("There is no parent graph.");
+    }
+    if (cmd.goto) {
+        let sends;
+        if (Array.isArray(cmd.goto)) {
+            sends = cmd.goto;
+        }
+        else {
+            sends = [cmd.goto];
+        }
+        for (const send of sends) {
+            if (_isSend(send)) {
+                yield [NULL_TASK_ID, TASKS, send];
+            }
+            else if (typeof send === "string") {
+                yield [NULL_TASK_ID, `branch:__start__:${SELF}:${send}`, "__start__"];
+            }
+            else {
+                throw new Error(`In Command.send, expected Send or string, got ${typeof send}`);
+            }
+        }
+        // TODO: handle goto str for state graph
+    }
     if (cmd.resume) {
         if (typeof cmd.resume === "object" &&
             !!cmd.resume &&
@@ -55,6 +82,14 @@ export function* mapCommand(cmd) {
             yield [NULL_TASK_ID, RESUME, cmd.resume];
         }
     }
+    if (cmd.update) {
+        if (typeof cmd.update !== "object" || !cmd.update) {
+            throw new Error("Expected cmd.update to be a dict mapping channel names to update values");
+        }
+        for (const [k, v] of Object.entries(cmd.update)) {
+            yield [NULL_TASK_ID, k, v];
+        }
+    }
 }
 /**
  * Map input chunk to a sequence of pending writes in the form [channel, value].

package/dist/pregel/loop.cjs

@@ -576,22 +576,9 @@ class PregelLoop {
     async _first(inputKeys) {
         const isResuming = Object.keys(this.checkpoint.channel_versions).length !== 0 &&
             (this.config.configurable?.[constants_js_1.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[constants_js_1.INTERRUPT] = {
-                        ...this.checkpoint.versions_seen[constants_js_1.INTERRUPT],
-                        [channelName]: version,
-                    };
-                }
-            }
-            // produce values output
-            const valuesOutput = await (0, utils_js_1.gatherIterator)((0, utils_js_1.prefixGenerator)((0, io_js_1.mapOutputValues)(this.outputKeys, true, this.channels), "values"));
-            this._emit(valuesOutput);
-        }
-        else if ((0, constants_js_1._isCommand)(this.input)) {
+                this.input === null ||
+                (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)) {
@@ -608,6 +595,20 @@ 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[constants_js_1.INTERRUPT] = {
+                        ...this.checkpoint.versions_seen[constants_js_1.INTERRUPT],
+                        [channelName]: version,
+                    };
+                }
+            }
+            // produce values output
+            const valuesOutput = await (0, utils_js_1.gatherIterator)((0, utils_js_1.prefixGenerator)((0, io_js_1.mapOutputValues)(this.outputKeys, true, this.channels), "values"));
+            this._emit(valuesOutput);
+        }
         else {
             // map inputs to channel updates
             const inputWrites = await (0, utils_js_1.gatherIterator)((0, io_js_1.mapInput)(inputKeys, this.input));

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/read.cjs

@@ -63,7 +63,7 @@ const defaultRunnableBound =
 /* #__PURE__ */ new runnables_1.RunnablePassthrough();
 class PregelNode extends runnables_1.RunnableBinding {
     constructor(fields) {
-        const { channels, triggers, mapper, writers, bound, kwargs, metadata, retryPolicy, tags, subgraphs, } = fields;
+        const { channels, triggers, mapper, writers, bound, kwargs, metadata, retryPolicy, tags, subgraphs, ends, } = fields;
         const mergedTags = [
             ...(fields.config?.tags ? fields.config.tags : []),
             ...(tags ?? []),
@@ -145,6 +145,12 @@ class PregelNode extends runnables_1.RunnableBinding {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "ends", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.channels = channels;
         this.triggers = triggers;
         this.mapper = mapper;
@@ -155,6 +161,7 @@ class PregelNode extends runnables_1.RunnableBinding {
         this.tags = mergedTags;
         this.retryPolicy = retryPolicy;
         this.subgraphs = subgraphs;
+        this.ends = ends;
     }
     getWriters() {
         const newWriters = [...this.writers];

package/dist/pregel/read.d.ts

@@ -21,6 +21,7 @@ interface PregelNodeArgs<RunInput, RunOutput> extends Partial<RunnableBindingArg
     metadata?: Record<string, unknown>;
     retryPolicy?: RetryPolicy;
     subgraphs?: Runnable[];
+    ends?: string[];
 }
 export type PregelNodeInputType = any;
 export type PregelNodeOutputType = any;
@@ -36,6 +37,7 @@ export declare class PregelNode<RunInput = PregelNodeInputType, RunOutput = Preg
     tags: string[];
     retryPolicy?: RetryPolicy;
     subgraphs?: Runnable[];
+    ends?: string[];
     constructor(fields: PregelNodeArgs<RunInput, RunOutput>);
     getWriters(): Array<Runnable>;
     getNode(): Runnable<RunInput, RunOutput> | undefined;

package/dist/pregel/read.js

@@ -59,7 +59,7 @@ const defaultRunnableBound =
 /* #__PURE__ */ new RunnablePassthrough();
 export class PregelNode extends RunnableBinding {
     constructor(fields) {
-        const { channels, triggers, mapper, writers, bound, kwargs, metadata, retryPolicy, tags, subgraphs, } = fields;
+        const { channels, triggers, mapper, writers, bound, kwargs, metadata, retryPolicy, tags, subgraphs, ends, } = fields;
         const mergedTags = [
             ...(fields.config?.tags ? fields.config.tags : []),
             ...(tags ?? []),
@@ -141,6 +141,12 @@ export class PregelNode extends RunnableBinding {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "ends", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.channels = channels;
         this.triggers = triggers;
         this.mapper = mapper;
@@ -151,6 +157,7 @@ export class PregelNode extends RunnableBinding {
         this.tags = mergedTags;
         this.retryPolicy = retryPolicy;
         this.subgraphs = subgraphs;
+        this.ends = ends;
     }
     getWriters() {
         const newWriters = [...this.writers];

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.29",
   "description": "LangGraph",
   "type": "module",
   "engines": {