@langchain/langgraph 0.1.0-rc.0 → 0.1.0

package/dist/prebuilt/react_agent_executor.d.ts

@@ -2,9 +2,9 @@ import { BaseChatModel } from "@langchain/core/language_models/chat_models";
 import { BaseMessage, SystemMessage } from "@langchain/core/messages";
 import { Runnable, RunnableToolLike } from "@langchain/core/runnables";
 import { StructuredToolInterface } from "@langchain/core/tools";
-import { BaseCheckpointSaver } from "../checkpoint/base.js";
+import { BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
 import { START } from "../graph/index.js";
-import { MessagesState } from "../graph/message.js";
+import { MessagesAnnotation } from "../graph/messages_annotation.js";
 import { CompiledStateGraph } from "../graph/state.js";
 import { All } from "../pregel/types.js";
 import { ToolNode } from "./tool_node.js";
@@ -14,7 +14,7 @@ export interface AgentState {
 export type N = typeof START | "agent" | "tools";
 export type CreateReactAgentParams = {
     llm: BaseChatModel;
-    tools: ToolNode<MessagesState> | (StructuredToolInterface | RunnableToolLike)[];
+    tools: ToolNode<typeof MessagesAnnotation.State> | (StructuredToolInterface | RunnableToolLike)[];
     messageModifier?: SystemMessage | string | ((messages: BaseMessage[]) => BaseMessage[]) | ((messages: BaseMessage[]) => Promise<BaseMessage[]>) | Runnable;
     checkpointSaver?: BaseCheckpointSaver;
     interruptBefore?: N[] | All;

package/dist/prebuilt/tool_node.d.ts

@@ -3,13 +3,13 @@ import { RunnableToolLike } from "@langchain/core/runnables";
 import { StructuredToolInterface } from "@langchain/core/tools";
 import { RunnableCallable } from "../utils.js";
 import { END } from "../graph/graph.js";
-import { MessagesState } from "../graph/message.js";
+import { MessagesAnnotation } from "../graph/messages_annotation.js";
 export type ToolNodeOptions = {
     name?: string;
     tags?: string[];
     handleToolErrors?: boolean;
 };
-export declare class ToolNode<T extends BaseMessage[] | MessagesState> extends RunnableCallable<T, T> {
+export declare class ToolNode<T extends BaseMessage[] | typeof MessagesAnnotation.State> extends RunnableCallable<T, T> {
     /**
     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
@@ -21,4 +21,4 @@ export declare class ToolNode<T extends BaseMessage[] | MessagesState> extends R
     constructor(tools: (StructuredToolInterface | RunnableToolLike)[], options?: ToolNodeOptions);
     private run;
 }
-export declare function toolsCondition(state: BaseMessage[] | MessagesState): "tools" | typeof END;
+export declare function toolsCondition(state: BaseMessage[] | typeof MessagesAnnotation.State): "tools" | typeof END;

package/dist/pregel/algo.cjs

@@ -3,17 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports._prepareNextTasks = exports._applyWrites = exports._localWrite = exports._localRead = exports.shouldInterrupt = exports.executeTasks = exports.increment = void 0;
 /* eslint-disable no-param-reassign */
 const runnables_1 = require("@langchain/core/runnables");
+const langgraph_checkpoint_1 = require("@langchain/langgraph-checkpoint");
 const base_js_1 = require("../channels/base.cjs");
-const base_js_2 = require("../checkpoint/base.cjs");
 const io_js_1 = require("./io.cjs");
 const constants_js_1 = require("../constants.cjs");
 const errors_js_1 = require("../errors.cjs");
-const id_js_1 = require("../checkpoint/id.cjs");
+const utils_js_1 = require("./utils.cjs");
 const increment = (current) => {
     return current !== undefined ? current + 1 : 1;
 };
 exports.increment = increment;
-async function executeTasks(tasks, stepTimeout, signal) {
+async function* executeTasks(tasks, stepTimeout, signal
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
     if (stepTimeout && signal) {
         if ("any" in AbortSignal) {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -29,19 +31,26 @@ async function executeTasks(tasks, stepTimeout, signal) {
     // Abort if signal is aborted
     signal?.throwIfAborted();
     // Start all tasks
-    const started = tasks.map((task) => task());
+    const executingTasks = Object.fromEntries(Object.entries(tasks).map(([taskId, task]) => {
+        return [taskId, task()];
+    }));
     let listener;
-    // Wait for all tasks to settle
-    // If any tasks fail, or signal is aborted, the promise will reject
-    await Promise.all(signal
-        ? [
-            ...started,
-            new Promise((_resolve, reject) => {
-                listener = () => reject(new Error("Abort"));
-                signal?.addEventListener("abort", listener);
-            }).finally(() => signal?.removeEventListener("abort", listener)),
-        ]
-        : started);
+    const signalPromise = new Promise((_resolve, reject) => {
+        listener = () => reject(new Error("Abort"));
+        signal?.addEventListener("abort", listener);
+    }).finally(() => signal?.removeEventListener("abort", listener));
+    while (Object.keys(executingTasks).length > 0) {
+        const { task, error } = await Promise.race([
+            ...Object.values(executingTasks),
+            signalPromise,
+        ]);
+        if (error !== undefined) {
+            // TODO: don't stop others if exception is interrupt
+            throw error;
+        }
+        yield task;
+        delete executingTasks[task.id];
+    }
 }
 exports.executeTasks = executeTasks;
 function shouldInterrupt(checkpoint, interruptNodes, tasks) {
@@ -54,7 +63,7 @@ function shouldInterrupt(checkpoint, interruptNodes, tasks) {
     else if (versionType === "string") {
         nullVersion = "";
     }
-    const seen = checkpoint.versions_seen[constants_js_1.INTERRUPT] || {};
+    const seen = checkpoint.versions_seen[constants_js_1.INTERRUPT] ?? {};
     const anyChannelUpdated = Object.entries(checkpoint.channel_versions).some(([chan, version]) => {
         return version > (seen[chan] ?? nullVersion);
     });
@@ -70,7 +79,7 @@ function _localRead(checkpoint, channels, task, select, fresh = false) {
         // create a new copy of channels
         const newChannels = (0, base_js_1.emptyChannels)(channels, newCheckpoint);
         // Note: _applyWrites contains side effects
-        _applyWrites((0, base_js_2.copyCheckpoint)(newCheckpoint), newChannels, [task]);
+        _applyWrites((0, langgraph_checkpoint_1.copyCheckpoint)(newCheckpoint), newChannels, [task]);
         return (0, io_js_1.readChannels)(newChannels, select);
     }
     else {
@@ -181,9 +190,6 @@ getNextVersion) {
             }
             updatedChannels.add(chan);
         }
-        else {
-            console.warn(`Skipping write for channel ${chan} which has no readers`);
-        }
     }
     // Channels that weren't updated in this step are notified of a new step
     for (const chan of Object.keys(channels)) {
@@ -198,7 +204,6 @@ getNextVersion) {
 exports._applyWrites = _applyWrites;
 function _prepareNextTasks(checkpoint, processes, channels, config, forExecution, extra) {
     const parentNamespace = config.configurable?.checkpoint_ns ?? "";
-    const newCheckpoint = (0, base_js_2.copyCheckpoint)(checkpoint);
     const tasks = [];
     const taskDescriptions = [];
     const { step, isResuming = false, checkpointer, manager } = extra;
@@ -212,16 +217,16 @@ function _prepareNextTasks(checkpoint, processes, channels, config, forExecution
             continue;
         }
         const triggers = [constants_js_1.TASKS];
-        const metadata = {
+        const metadata = (0, utils_js_1._getIdMetadata)({
             langgraph_step: step,
             langgraph_node: packet.node,
             langgraph_triggers: triggers,
-            langgraph_task_idx: tasks.length,
-        };
+            langgraph_task_idx: forExecution ? tasks.length : taskDescriptions.length,
+        });
         const checkpointNamespace = parentNamespace === ""
             ? packet.node
             : `${parentNamespace}${constants_js_1.CHECKPOINT_NAMESPACE_SEPARATOR}${packet.node}`;
-        const taskId = (0, id_js_1.uuid5)(JSON.stringify([checkpointNamespace, metadata]), checkpoint.id);
+        const taskId = (0, langgraph_checkpoint_1.uuid5)(JSON.stringify([checkpointNamespace, metadata]), checkpoint.id);
         if (forExecution) {
             const proc = processes[packet.node];
             const node = proc.getNode();
@@ -257,94 +262,43 @@ function _prepareNextTasks(checkpoint, processes, channels, config, forExecution
     }
     // Check if any processes should be run in next step
     // If so, prepare the values to be passed to them
+    const nullVersion = (0, utils_js_1.getNullChannelVersion)(checkpoint.channel_versions);
+    if (nullVersion === undefined) {
+        return forExecution ? tasks : taskDescriptions;
+    }
     for (const [name, proc] of Object.entries(processes)) {
-        const updatedChannels = proc.triggers
+        const seen = checkpoint.versions_seen[name] ?? {};
+        const triggers = proc.triggers
             .filter((chan) => {
-            try {
-                (0, io_js_1.readChannel)(channels, chan, false);
-                return true;
-            }
-            catch (e) {
-                return false;
-            }
+            const result = (0, io_js_1.readChannel)(channels, chan, false, true);
+            const isEmptyChannelError = 
+            // eslint-disable-next-line no-instanceof/no-instanceof
+            result instanceof Error &&
+                result.name === errors_js_1.EmptyChannelError.unminifiable_name;
+            return (!isEmptyChannelError &&
+                (checkpoint.channel_versions[chan] ?? nullVersion) >
+                    (seen[chan] ?? nullVersion));
         })
-            .filter((chan) => (0, base_js_2.getChannelVersion)(newCheckpoint, chan) >
-            (0, base_js_2.getVersionSeen)(newCheckpoint, name, chan));
-        const hasUpdatedChannels = updatedChannels.length > 0;
+            .sort();
         // If any of the channels read by this process were updated
-        if (hasUpdatedChannels) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            let val;
-            // If all trigger channels subscribed by this process are not empty
-            // then invoke the process with the values of all non-empty channels
-            if (Array.isArray(proc.channels)) {
-                let emptyChannels = 0;
-                for (const chan of proc.channels) {
-                    try {
-                        val = (0, io_js_1.readChannel)(channels, chan, false);
-                        break;
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    }
-                    catch (e) {
-                        if (e.name === errors_js_1.EmptyChannelError.unminifiable_name) {
-                            emptyChannels += 1;
-                            continue;
-                        }
-                        else {
-                            throw e;
-                        }
-                    }
-                }
-                if (emptyChannels === proc.channels.length) {
-                    continue;
-                }
-            }
-            else if (typeof proc.channels === "object") {
-                val = {};
-                try {
-                    for (const [k, chan] of Object.entries(proc.channels)) {
-                        val[k] = (0, io_js_1.readChannel)(channels, chan, !proc.triggers.includes(chan));
-                    }
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                }
-                catch (e) {
-                    if (e.name === errors_js_1.EmptyChannelError.unminifiable_name) {
-                        continue;
-                    }
-                    else {
-                        throw e;
-                    }
-                }
-            }
-            else {
-                throw new Error(`Invalid channels type, expected list or dict, got ${proc.channels}`);
-            }
-            // If the process has a mapper, apply it to the value
-            if (proc.mapper !== undefined) {
-                val = proc.mapper(val);
+        if (triggers.length > 0) {
+            const val = _procInput(proc, channels, forExecution);
+            if (val === undefined) {
+                continue;
             }
-            const metadata = {
+            const metadata = (0, utils_js_1._getIdMetadata)({
                 langgraph_step: step,
                 langgraph_node: name,
-                langgraph_triggers: proc.triggers,
-                langgraph_task_idx: tasks.length,
-            };
+                langgraph_triggers: triggers,
+                langgraph_task_idx: forExecution
+                    ? tasks.length
+                    : taskDescriptions.length,
+            });
             const checkpointNamespace = parentNamespace === ""
                 ? name
                 : `${parentNamespace}${constants_js_1.CHECKPOINT_NAMESPACE_SEPARATOR}${name}`;
-            const taskId = (0, id_js_1.uuid5)(JSON.stringify([checkpointNamespace, metadata]), checkpoint.id);
+            const taskId = (0, langgraph_checkpoint_1.uuid5)(JSON.stringify([checkpointNamespace, metadata]), checkpoint.id);
             if (forExecution) {
-                // Update seen versions
-                if (!newCheckpoint.versions_seen[name]) {
-                    newCheckpoint.versions_seen[name] = {};
-                }
-                proc.triggers.forEach((chan) => {
-                    const version = newCheckpoint.channel_versions[chan];
-                    if (version !== undefined) {
-                        // side effect: updates newCheckpoint
-                        newCheckpoint.versions_seen[name][chan] = version;
-                    }
-                });
                 const node = proc.getNode();
                 if (node !== undefined) {
                     const writes = [];
@@ -353,7 +307,7 @@ function _prepareNextTasks(checkpoint, processes, channels, config, forExecution
                         input: val,
                         proc: node,
                         writes,
-                        triggers: proc.triggers,
+                        triggers,
                         config: (0, runnables_1.patchConfig)((0, runnables_1.mergeConfigs)(config, proc.config, { metadata }), {
                             runName: name,
                             callbacks: manager?.getChild(`graph:step:${step}`),
@@ -362,7 +316,7 @@ function _prepareNextTasks(checkpoint, processes, channels, config, forExecution
                                 [constants_js_1.CONFIG_KEY_READ]: _localRead.bind(undefined, checkpoint, channels, {
                                     name,
                                     writes: writes,
-                                    triggers: proc.triggers,
+                                    triggers,
                                 }),
                                 [constants_js_1.CONFIG_KEY_CHECKPOINTER]: checkpointer,
                                 [constants_js_1.CONFIG_KEY_RESUMING]: isResuming,
@@ -379,6 +333,59 @@ function _prepareNextTasks(checkpoint, processes, channels, config, forExecution
             }
         }
     }
-    return [newCheckpoint, forExecution ? tasks : taskDescriptions];
+    return forExecution ? tasks : taskDescriptions;
 }
 exports._prepareNextTasks = _prepareNextTasks;
+function _procInput(proc, channels, forExecution) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let val;
+    // If all trigger channels subscribed by this process are not empty
+    // then invoke the process with the values of all non-empty channels
+    if (Array.isArray(proc.channels)) {
+        let successfulRead = false;
+        for (const chan of proc.channels) {
+            try {
+                val = (0, io_js_1.readChannel)(channels, chan, false);
+                successfulRead = true;
+                break;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (e) {
+                if (e.name === errors_js_1.EmptyChannelError.unminifiable_name) {
+                    continue;
+                }
+                else {
+                    throw e;
+                }
+            }
+        }
+        if (!successfulRead) {
+            return;
+        }
+    }
+    else if (typeof proc.channels === "object") {
+        val = {};
+        try {
+            for (const [k, chan] of Object.entries(proc.channels)) {
+                val[k] = (0, io_js_1.readChannel)(channels, chan, !proc.triggers.includes(chan));
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (e) {
+            if (e.name === errors_js_1.EmptyChannelError.unminifiable_name) {
+                return;
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    else {
+        throw new Error(`Invalid channels type, expected list or dict, got ${proc.channels}`);
+    }
+    // If the process has a mapper, apply it to the value
+    if (forExecution && proc.mapper !== undefined) {
+        val = proc.mapper(val);
+    }
+    return val;
+}

package/dist/pregel/algo.d.ts

@@ -1,10 +1,9 @@
 import { RunnableConfig } from "@langchain/core/runnables";
 import { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
+import { BaseCheckpointSaver, Checkpoint, ReadonlyCheckpoint, type PendingWrite } from "@langchain/langgraph-checkpoint";
 import { BaseChannel } from "../channels/base.js";
-import { BaseCheckpointSaver, Checkpoint, ReadonlyCheckpoint } from "../checkpoint/base.js";
 import { PregelNode } from "./read.js";
 import { All, PregelExecutableTask, PregelTaskDescription } from "./types.js";
-import { PendingWrite } from "../checkpoint/types.js";
 /**
  * Construct a type with a set of properties K of type T
  */
@@ -17,7 +16,11 @@ export type WritesProtocol<C = string> = {
     triggers: string[];
 };
 export declare const increment: (current?: number) => number;
-export declare function executeTasks<RunOutput>(tasks: Array<() => Promise<RunOutput | Error | void>>, stepTimeout?: number, signal?: AbortSignal): Promise<void>;
+export declare function executeTasks(tasks: Record<string, () => Promise<{
+    task: PregelExecutableTask<any, any>;
+    result: any;
+    error: Error;
+}>>, stepTimeout?: number, signal?: AbortSignal): AsyncGenerator<PregelExecutableTask<any, any>>;
 export declare function shouldInterrupt<N extends PropertyKey, C extends PropertyKey>(checkpoint: Checkpoint, interruptNodes: All | N[], tasks: PregelExecutableTask<N, C>[]): boolean;
 export declare function _localRead<Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, channels: Cc, task: WritesProtocol<keyof Cc>, select: Array<keyof Cc> | keyof Cc, fresh?: boolean): Record<string, unknown> | unknown;
 export declare function _localWrite(commit: (writes: [string, any][]) => void, processes: Record<string, PregelNode>, channels: Record<string, BaseChannel>, writes: [string, any][]): void;
@@ -28,5 +31,5 @@ export type NextTaskExtraFields = {
     checkpointer?: BaseCheckpointSaver;
     manager?: CallbackManagerForChainRun;
 };
-export declare function _prepareNextTasks<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, processes: Nn, channels: Cc, config: RunnableConfig, forExecution: false, extra: NextTaskExtraFields): [Checkpoint, Array<PregelTaskDescription>];
-export declare function _prepareNextTasks<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, processes: Nn, channels: Cc, config: RunnableConfig, forExecution: true, extra: NextTaskExtraFields): [Checkpoint, Array<PregelExecutableTask<keyof Nn, keyof Cc>>];
+export declare function _prepareNextTasks<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, processes: Nn, channels: Cc, config: RunnableConfig, forExecution: false, extra: NextTaskExtraFields): PregelTaskDescription[];
+export declare function _prepareNextTasks<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, processes: Nn, channels: Cc, config: RunnableConfig, forExecution: true, extra: NextTaskExtraFields): PregelExecutableTask<keyof Nn, keyof Cc>[];