@langchain/langgraph 0.0.12 → 0.0.13

package/dist/channels/any_value.cjs

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnyValue = void 0;
+const errors_js_1 = require("../errors.cjs");
+const index_js_1 = require("./index.cjs");
+/**
+ * Stores the last value received, assumes that if multiple values are received, they are all equal.
+ *
+ * Note: Unlike 'LastValue' if multiple nodes write to this channel in a single step, the values
+ * will be continuously overwritten.
+ */
+class AnyValue extends index_js_1.BaseChannel {
+    constructor() {
+        super();
+        Object.defineProperty(this, "lc_graph_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "AnyValue"
+        });
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.value = undefined;
+    }
+    fromCheckpoint(checkpoint) {
+        const empty = new AnyValue();
+        if (checkpoint) {
+            empty.value = checkpoint;
+        }
+        return empty;
+    }
+    update(values) {
+        if (values.length === 0) {
+            this.value = undefined;
+            return;
+        }
+        // eslint-disable-next-line prefer-destructuring
+        this.value = values[values.length - 1];
+    }
+    get() {
+        if (this.value === undefined) {
+            throw new errors_js_1.EmptyChannelError();
+        }
+        return this.value;
+    }
+    checkpoint() {
+        if (this.value === undefined) {
+            throw new errors_js_1.EmptyChannelError();
+        }
+        return this.value;
+    }
+}
+exports.AnyValue = AnyValue;

package/dist/channels/any_value.d.ts

@@ -0,0 +1,16 @@
+import { BaseChannel } from "./index.js";
+/**
+ * Stores the last value received, assumes that if multiple values are received, they are all equal.
+ *
+ * Note: Unlike 'LastValue' if multiple nodes write to this channel in a single step, the values
+ * will be continuously overwritten.
+ */
+export declare class AnyValue<Value> extends BaseChannel<Value, Value, Value> {
+    lc_graph_name: string;
+    value: Value | undefined;
+    constructor();
+    fromCheckpoint(checkpoint?: Value): this;
+    update(values: Value[]): void;
+    get(): Value;
+    checkpoint(): Value;
+}

package/dist/channels/any_value.js

@@ -0,0 +1,53 @@
+import { EmptyChannelError } from "../errors.js";
+import { BaseChannel } from "./index.js";
+/**
+ * Stores the last value received, assumes that if multiple values are received, they are all equal.
+ *
+ * Note: Unlike 'LastValue' if multiple nodes write to this channel in a single step, the values
+ * will be continuously overwritten.
+ */
+export class AnyValue extends BaseChannel {
+    constructor() {
+        super();
+        Object.defineProperty(this, "lc_graph_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "AnyValue"
+        });
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.value = undefined;
+    }
+    fromCheckpoint(checkpoint) {
+        const empty = new AnyValue();
+        if (checkpoint) {
+            empty.value = checkpoint;
+        }
+        return empty;
+    }
+    update(values) {
+        if (values.length === 0) {
+            this.value = undefined;
+            return;
+        }
+        // eslint-disable-next-line prefer-destructuring
+        this.value = values[values.length - 1];
+    }
+    get() {
+        if (this.value === undefined) {
+            throw new EmptyChannelError();
+        }
+        return this.value;
+    }
+    checkpoint() {
+        if (this.value === undefined) {
+            throw new EmptyChannelError();
+        }
+        return this.value;
+    }
+}

package/dist/channels/base.cjs

@@ -1,49 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCheckpoint = exports.emptyChannels = exports.InvalidUpdateError = exports.EmptyChannelError = exports.BaseChannel = void 0;
+exports.createCheckpoint = exports.emptyChannels = exports.BaseChannel = void 0;
+const base_js_1 = require("../checkpoint/base.cjs");
+const id_js_1 = require("../checkpoint/id.cjs");
+const errors_js_1 = require("../errors.cjs");
 class BaseChannel {
 }
 exports.BaseChannel = BaseChannel;
-class EmptyChannelError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "EmptyChannelError";
-    }
-}
-exports.EmptyChannelError = EmptyChannelError;
-class InvalidUpdateError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "InvalidUpdateError";
-    }
-}
-exports.InvalidUpdateError = InvalidUpdateError;
 function emptyChannels(channels, checkpoint) {
     const newChannels = {};
     for (const k in channels) {
         if (Object.prototype.hasOwnProperty.call(channels, k)) {
-            const channelValue = checkpoint.channelValues[k];
-            newChannels[k] = channels[k].empty(channelValue);
+            const channelValue = checkpoint.channel_values[k];
+            newChannels[k] = channels[k].fromCheckpoint(channelValue);
         }
     }
     return newChannels;
 }
 exports.emptyChannels = emptyChannels;
-async function createCheckpoint(checkpoint, channels) {
-    const newCheckpoint = {
-        v: 1,
-        ts: new Date().toISOString(),
-        channelValues: { ...checkpoint.channelValues },
-        channelVersions: { ...checkpoint.channelVersions },
-        versionsSeen: { ...checkpoint.versionsSeen },
-    };
+function createCheckpoint(checkpoint, channels, step) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const values = {};
     for (const k of Object.keys(channels)) {
         try {
-            newCheckpoint.channelValues[k] = await channels[k].checkpoint();
+            values[k] = channels[k].checkpoint();
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
         catch (error) {
-            if (error.name === EmptyChannelError.name) {
+            if (error.name === errors_js_1.EmptyChannelError.name) {
                 // no-op
             }
             else {
@@ -51,6 +35,13 @@ async function createCheckpoint(checkpoint, channels) {
             }
         }
     }
-    return newCheckpoint;
+    return {
+        v: 1,
+        id: (0, id_js_1.uuid6)(step),
+        ts: new Date().toISOString(),
+        channel_values: values,
+        channel_versions: { ...checkpoint.channel_versions },
+        versions_seen: (0, base_js_1.deepCopy)(checkpoint.versions_seen),
+    };
 }
 exports.createCheckpoint = createCheckpoint;

package/dist/channels/base.d.ts

@@ -1,6 +1,6 @@
+import { ReadonlyCheckpoint } from "../checkpoint/base.js";
 import { Checkpoint } from "../checkpoint/index.js";
-export declare abstract class BaseChannel<Value = unknown, Update = unknown, // Expected type of the parameter `update` is called with.
-C = unknown> {
+export declare abstract class BaseChannel<ValueType = unknown, UpdateType = unknown, CheckpointType = unknown> {
     /**
      * The name of the channel.
      */
@@ -9,40 +9,34 @@ C = unknown> {
      * Return a new identical channel, optionally initialized from a checkpoint.
      * Can be thought of as a "restoration" from a checkpoint which is a "snapshot" of the channel's state.
      *
-     * @param {C | undefined} checkpoint
-     * @param {C | undefined} initialValue
+     * @param {CheckpointType | undefined} checkpoint
+     * @param {CheckpointType | undefined} initialValue
      * @returns {this}
      */
-    abstract empty(checkpoint?: C, initialValueFactory?: () => C): BaseChannel<Value, Update, C>;
+    abstract fromCheckpoint(checkpoint?: CheckpointType): this;
     /**
      * Update the channel's value with the given sequence of updates.
      * The order of the updates in the sequence is arbitrary.
      *
      * @throws {InvalidUpdateError} if the sequence of updates is invalid.
-     * @param {Array<Update>} values
+     * @param {Array<UpdateType>} values
      * @returns {void}
      */
-    abstract update(values: Update[]): void;
+    abstract update(values: UpdateType[]): void;
     /**
      * Return the current value of the channel.
      *
      * @throws {EmptyChannelError} if the channel is empty (never updated yet).
-     * @returns {Value}
+     * @returns {ValueType}
      */
-    abstract get(): Value;
+    abstract get(): ValueType;
     /**
      * Return a string representation of the channel's current state.
      *
      * @throws {EmptyChannelError} if the channel is empty (never updated yet), or doesn't support checkpoints.
-     * @returns {C | undefined}
+     * @returns {CheckpointType | undefined}
      */
-    abstract checkpoint(): C | undefined;
+    abstract checkpoint(): CheckpointType | undefined;
 }
-export declare class EmptyChannelError extends Error {
-    constructor(message?: string);
-}
-export declare class InvalidUpdateError extends Error {
-    constructor(message?: string);
-}
-export declare function emptyChannels(channels: Record<string, BaseChannel>, checkpoint: Checkpoint): Record<string, BaseChannel>;
-export declare function createCheckpoint<Value>(checkpoint: Checkpoint, channels: Record<string, BaseChannel<Value>>): Promise<Checkpoint>;
+export declare function emptyChannels<Cc extends Record<string, BaseChannel>>(channels: Cc, checkpoint: ReadonlyCheckpoint): Cc;
+export declare function createCheckpoint<ValueType>(checkpoint: ReadonlyCheckpoint, channels: Record<string, BaseChannel<ValueType>>, step: number): Checkpoint;

package/dist/channels/base.js

@@ -1,38 +1,24 @@
+import { deepCopy } from "../checkpoint/base.js";
+import { uuid6 } from "../checkpoint/id.js";
+import { EmptyChannelError } from "../errors.js";
 export class BaseChannel {
 }
-export class EmptyChannelError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "EmptyChannelError";
-    }
-}
-export class InvalidUpdateError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "InvalidUpdateError";
-    }
-}
 export function emptyChannels(channels, checkpoint) {
     const newChannels = {};
     for (const k in channels) {
         if (Object.prototype.hasOwnProperty.call(channels, k)) {
-            const channelValue = checkpoint.channelValues[k];
-            newChannels[k] = channels[k].empty(channelValue);
+            const channelValue = checkpoint.channel_values[k];
+            newChannels[k] = channels[k].fromCheckpoint(channelValue);
         }
     }
     return newChannels;
 }
-export async function createCheckpoint(checkpoint, channels) {
-    const newCheckpoint = {
-        v: 1,
-        ts: new Date().toISOString(),
-        channelValues: { ...checkpoint.channelValues },
-        channelVersions: { ...checkpoint.channelVersions },
-        versionsSeen: { ...checkpoint.versionsSeen },
-    };
+export function createCheckpoint(checkpoint, channels, step) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const values = {};
     for (const k of Object.keys(channels)) {
         try {
-            newCheckpoint.channelValues[k] = await channels[k].checkpoint();
+            values[k] = channels[k].checkpoint();
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
         catch (error) {
@@ -44,5 +30,12 @@ export async function createCheckpoint(checkpoint, channels) {
             }
         }
     }
-    return newCheckpoint;
+    return {
+        v: 1,
+        id: uuid6(step),
+        ts: new Date().toISOString(),
+        channel_values: values,
+        channel_versions: { ...checkpoint.channel_versions },
+        versions_seen: deepCopy(checkpoint.versions_seen),
+    };
 }

package/dist/channels/binop.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BinaryOperatorAggregate = void 0;
+const errors_js_1 = require("../errors.cjs");
 const index_js_1 = require("./index.cjs");
 /**
  * Stores the result of applying a binary operator to the current value and each new value.
@@ -36,7 +37,7 @@ class BinaryOperatorAggregate extends index_js_1.BaseChannel {
         this.initialValueFactory = initialValueFactory;
         this.value = initialValueFactory?.();
     }
-    empty(checkpoint) {
+    fromCheckpoint(checkpoint) {
         const empty = new BinaryOperatorAggregate(this.operator, this.initialValueFactory);
         if (checkpoint) {
             empty.value = checkpoint;
@@ -59,13 +60,13 @@ class BinaryOperatorAggregate extends index_js_1.BaseChannel {
     }
     get() {
         if (this.value === undefined) {
-            throw new index_js_1.EmptyChannelError();
+            throw new errors_js_1.EmptyChannelError();
         }
         return this.value;
     }
     checkpoint() {
         if (this.value === undefined) {
-            throw new index_js_1.EmptyChannelError();
+            throw new errors_js_1.EmptyChannelError();
         }
         return this.value;
     }

package/dist/channels/binop.d.ts

@@ -9,7 +9,7 @@ export declare class BinaryOperatorAggregate<Value> extends BaseChannel<Value, V
     operator: BinaryOperator<Value>;
     initialValueFactory?: () => Value;
     constructor(operator: BinaryOperator<Value>, initialValueFactory?: () => Value);
-    empty(checkpoint?: Value): BinaryOperatorAggregate<Value>;
+    fromCheckpoint(checkpoint?: Value): this;
     update(values: Value[]): void;
     get(): Value;
     checkpoint(): Value;

package/dist/channels/binop.js

@@ -1,4 +1,5 @@
-import { BaseChannel, EmptyChannelError } from "./index.js";
+import { EmptyChannelError } from "../errors.js";
+import { BaseChannel } from "./index.js";
 /**
  * Stores the result of applying a binary operator to the current value and each new value.
  */
@@ -33,7 +34,7 @@ export class BinaryOperatorAggregate extends BaseChannel {
         this.initialValueFactory = initialValueFactory;
         this.value = initialValueFactory?.();
     }
-    empty(checkpoint) {
+    fromCheckpoint(checkpoint) {
         const empty = new BinaryOperatorAggregate(this.operator, this.initialValueFactory);
         if (checkpoint) {
             empty.value = checkpoint;

package/dist/channels/dynamic_barrier_value.cjs

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicBarrierValue = void 0;
+const errors_js_1 = require("../errors.cjs");
+const index_js_1 = require("./index.cjs");
+const named_barrier_value_js_1 = require("./named_barrier_value.cjs");
+/**
+  A channel that switches between two states
+
+    - in the "priming" state it can't be read from.
+        - if it receives a WaitForNames update, it switches to the "waiting" state.
+    - in the "waiting" state it collects named values until all are received.
+        - once all named values are received, it can be read once, and it switches
+          back to the "priming" state.
+ */
+class DynamicBarrierValue extends index_js_1.BaseChannel {
+    constructor() {
+        super();
+        Object.defineProperty(this, "lc_graph_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "DynamicBarrierValue"
+        });
+        Object.defineProperty(this, "names", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // Names of nodes that we want to wait for.
+        Object.defineProperty(this, "seen", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.names = undefined;
+        this.seen = new Set();
+    }
+    fromCheckpoint(checkpoint) {
+        const empty = new DynamicBarrierValue();
+        if (checkpoint) {
+            empty.names = new Set(checkpoint[0]);
+            empty.seen = new Set(checkpoint[1]);
+        }
+        return empty;
+    }
+    update(values) {
+        // switch to priming state after reading it once
+        if (this.names && (0, named_barrier_value_js_1.areSetsEqual)(this.names, this.seen)) {
+            this.seen = new Set();
+            this.names = undefined;
+        }
+        const newNames = values.filter((v) => typeof v === "object" &&
+            !!v &&
+            "__names" in v &&
+            Object.keys(v).join(",") === "__names" &&
+            Array.isArray(v.__names));
+        if (newNames.length > 1) {
+            throw new errors_js_1.InvalidUpdateError(`Expected at most one WaitForNames object, got ${newNames.length}`);
+        }
+        else if (newNames.length === 1) {
+            this.names = new Set(newNames[0].__names);
+        }
+        else if (this.names) {
+            for (const value of values) {
+                if (this.names.has(value)) {
+                    this.seen.add(value);
+                }
+                else {
+                    throw new errors_js_1.InvalidUpdateError(`Value ${value} not in names ${this.names}`);
+                }
+            }
+        }
+    }
+    // If we have not yet seen all the node names we want to wait for,
+    // throw an error to prevent continuing.
+    get() {
+        if (!this.names || !(0, named_barrier_value_js_1.areSetsEqual)(this.names, this.seen)) {
+            throw new errors_js_1.EmptyChannelError();
+        }
+        return undefined;
+    }
+    checkpoint() {
+        return [this.names ? [...this.names] : undefined, [...this.seen]];
+    }
+}
+exports.DynamicBarrierValue = DynamicBarrierValue;

package/dist/channels/dynamic_barrier_value.d.ts

@@ -0,0 +1,26 @@
+import { BaseChannel } from "./index.js";
+export interface WaitForNames<Value> {
+    __names: Value[];
+}
+/**
+  A channel that switches between two states
+
+    - in the "priming" state it can't be read from.
+        - if it receives a WaitForNames update, it switches to the "waiting" state.
+    - in the "waiting" state it collects named values until all are received.
+        - once all named values are received, it can be read once, and it switches
+          back to the "priming" state.
+ */
+export declare class DynamicBarrierValue<Value> extends BaseChannel<void, Value | WaitForNames<Value>, [
+    Value[] | undefined,
+    Value[]
+]> {
+    lc_graph_name: string;
+    names?: Set<Value>;
+    seen: Set<Value>;
+    constructor();
+    fromCheckpoint(checkpoint?: [Value[] | undefined, Value[]]): this;
+    update(values: (Value | WaitForNames<Value>)[]): void;
+    get(): void;
+    checkpoint(): [Value[] | undefined, Value[]];
+}

package/dist/channels/dynamic_barrier_value.js

@@ -0,0 +1,84 @@
+import { EmptyChannelError, InvalidUpdateError } from "../errors.js";
+import { BaseChannel } from "./index.js";
+import { areSetsEqual } from "./named_barrier_value.js";
+/**
+  A channel that switches between two states
+
+    - in the "priming" state it can't be read from.
+        - if it receives a WaitForNames update, it switches to the "waiting" state.
+    - in the "waiting" state it collects named values until all are received.
+        - once all named values are received, it can be read once, and it switches
+          back to the "priming" state.
+ */
+export class DynamicBarrierValue extends BaseChannel {
+    constructor() {
+        super();
+        Object.defineProperty(this, "lc_graph_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "DynamicBarrierValue"
+        });
+        Object.defineProperty(this, "names", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // Names of nodes that we want to wait for.
+        Object.defineProperty(this, "seen", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.names = undefined;
+        this.seen = new Set();
+    }
+    fromCheckpoint(checkpoint) {
+        const empty = new DynamicBarrierValue();
+        if (checkpoint) {
+            empty.names = new Set(checkpoint[0]);
+            empty.seen = new Set(checkpoint[1]);
+        }
+        return empty;
+    }
+    update(values) {
+        // switch to priming state after reading it once
+        if (this.names && areSetsEqual(this.names, this.seen)) {
+            this.seen = new Set();
+            this.names = undefined;
+        }
+        const newNames = values.filter((v) => typeof v === "object" &&
+            !!v &&
+            "__names" in v &&
+            Object.keys(v).join(",") === "__names" &&
+            Array.isArray(v.__names));
+        if (newNames.length > 1) {
+            throw new InvalidUpdateError(`Expected at most one WaitForNames object, got ${newNames.length}`);
+        }
+        else if (newNames.length === 1) {
+            this.names = new Set(newNames[0].__names);
+        }
+        else if (this.names) {
+            for (const value of values) {
+                if (this.names.has(value)) {
+                    this.seen.add(value);
+                }
+                else {
+                    throw new InvalidUpdateError(`Value ${value} not in names ${this.names}`);
+                }
+            }
+        }
+    }
+    // If we have not yet seen all the node names we want to wait for,
+    // throw an error to prevent continuing.
+    get() {
+        if (!this.names || !areSetsEqual(this.names, this.seen)) {
+            throw new EmptyChannelError();
+        }
+        return undefined;
+    }
+    checkpoint() {
+        return [this.names ? [...this.names] : undefined, [...this.seen]];
+    }
+}

package/dist/channels/ephemeral_value.cjs

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EphemeralValue = void 0;
+const errors_js_1 = require("../errors.cjs");
+const index_js_1 = require("./index.cjs");
+/**
+ * Stores the value received in the step immediately preceding, clears after.
+ */
+class EphemeralValue extends index_js_1.BaseChannel {
+    constructor(guard = true) {
+        super();
+        Object.defineProperty(this, "lc_graph_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "EphemeralValue"
+        });
+        Object.defineProperty(this, "guard", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.guard = guard;
+    }
+    fromCheckpoint(checkpoint) {
+        const empty = new EphemeralValue();
+        if (checkpoint) {
+            empty.value = checkpoint;
+        }
+        return empty;
+    }
+    update(values) {
+        if (values.length === 0) {
+            // If there are no updates for this specific channel at the end of the step, wipe it.
+            this.value = undefined;
+            return;
+        }
+        if (values.length !== 1 && this.guard) {
+            throw new errors_js_1.InvalidUpdateError("EphemeralValue can only receive one value per step.");
+        }
+        // eslint-disable-next-line prefer-destructuring
+        this.value = values[values.length - 1];
+    }
+    get() {
+        if (this.value === undefined) {
+            throw new errors_js_1.EmptyChannelError();
+        }
+        return this.value;
+    }
+    checkpoint() {
+        if (this.value === undefined) {
+            throw new errors_js_1.EmptyChannelError();
+        }
+        return this.value;
+    }
+}
+exports.EphemeralValue = EphemeralValue;

package/dist/channels/ephemeral_value.d.ts

@@ -0,0 +1,14 @@
+import { BaseChannel } from "./index.js";
+/**
+ * Stores the value received in the step immediately preceding, clears after.
+ */
+export declare class EphemeralValue<Value> extends BaseChannel<Value, Value, Value> {
+    lc_graph_name: string;
+    guard: boolean;
+    value?: Value;
+    constructor(guard?: boolean);
+    fromCheckpoint(checkpoint?: Value): this;
+    update(values: Value[]): void;
+    get(): Value;
+    checkpoint(): Value;
+}