@langchain/langgraph 0.0.1

package/dist/channels/base.d.ts

@@ -0,0 +1,46 @@
+import { Checkpoint } from "../checkpoint/index.js";
+export declare abstract class BaseChannel<Value = unknown, Update = unknown, C = unknown> {
+    /**
+     * The name of the channel.
+     */
+    abstract lc_graph_name: string;
+    /**
+     * Return a new identical channel, optionally initialized from a checkpoint.
+     *
+     * @param {C | undefined} checkpoint
+     * @param {C | undefined} initialValue
+     * @returns {this}
+     */
+    abstract empty(checkpoint?: C, initialValueFactory?: () => C): BaseChannel<Value, Update, C>;
+    /**
+     * 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
+     * @returns {void}
+     */
+    abstract update(values: Update[]): void;
+    /**
+     * Return the current value of the channel.
+     *
+     * @throws {EmptyChannelError} if the channel is empty (never updated yet).
+     * @returns {Value}
+     */
+    abstract get(): Value;
+    /**
+     * 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}
+     */
+    abstract checkpoint(): C | 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>;

package/dist/channels/base.js

@@ -0,0 +1,50 @@
+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);
+        }
+    }
+    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 },
+    };
+    for (const k in channels) {
+        if (newCheckpoint.channelValues[k] === undefined) {
+            try {
+                newCheckpoint.channelValues[k] = await channels[k].checkpoint();
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (error) {
+                if ("name" in error && error.name === EmptyChannelError.name) {
+                    // no-op
+                }
+                else {
+                    throw error; // Rethrow unexpected errors
+                }
+            }
+        }
+    }
+    return newCheckpoint;
+}

package/dist/channels/binop.cjs

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinaryOperatorAggregate = void 0;
+const index_js_1 = require("./index.cjs");
+/**
+ * Stores the result of applying a binary operator to the current value and each new value.
+ */
+class BinaryOperatorAggregate extends index_js_1.BaseChannel {
+    constructor(operator, initialValueFactory) {
+        super();
+        Object.defineProperty(this, "lc_graph_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "BinaryOperatorAggregate"
+        });
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "operator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "initialValueFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.operator = operator;
+        this.initialValueFactory = initialValueFactory;
+        this.value = initialValueFactory?.();
+    }
+    empty(_) {
+        const empty = new BinaryOperatorAggregate(this.operator, this.initialValueFactory);
+        return empty;
+    }
+    update(values) {
+        let newValues = values;
+        if (!newValues.length)
+            return;
+        if (this.value === undefined) {
+            [this.value] = newValues;
+            newValues = newValues.slice(1);
+        }
+        for (const value of newValues) {
+            if (this.value !== undefined) {
+                this.value = this.operator(this.value, value);
+            }
+        }
+    }
+    get() {
+        if (this.value === undefined) {
+            throw new index_js_1.EmptyChannelError();
+        }
+        return this.value;
+    }
+    checkpoint() {
+        if (!this.value) {
+            throw new index_js_1.EmptyChannelError();
+        }
+        return this.value;
+    }
+}
+exports.BinaryOperatorAggregate = BinaryOperatorAggregate;

package/dist/channels/binop.d.ts

@@ -0,0 +1,16 @@
+import { BaseChannel } from "./index.js";
+export type BinaryOperator<Value> = (a: Value, b: Value) => Value;
+/**
+ * Stores the result of applying a binary operator to the current value and each new value.
+ */
+export declare class BinaryOperatorAggregate<Value> extends BaseChannel<Value, Value, Value> {
+    lc_graph_name: string;
+    value: Value | undefined;
+    operator: BinaryOperator<Value>;
+    initialValueFactory?: () => Value;
+    constructor(operator: BinaryOperator<Value>, initialValueFactory?: () => Value);
+    empty(_?: Value): BinaryOperatorAggregate<Value>;
+    update(values: Value[]): void;
+    get(): Value;
+    checkpoint(): Value;
+}

package/dist/channels/binop.js

@@ -0,0 +1,66 @@
+import { BaseChannel, EmptyChannelError } from "./index.js";
+/**
+ * Stores the result of applying a binary operator to the current value and each new value.
+ */
+export class BinaryOperatorAggregate extends BaseChannel {
+    constructor(operator, initialValueFactory) {
+        super();
+        Object.defineProperty(this, "lc_graph_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "BinaryOperatorAggregate"
+        });
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "operator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "initialValueFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.operator = operator;
+        this.initialValueFactory = initialValueFactory;
+        this.value = initialValueFactory?.();
+    }
+    empty(_) {
+        const empty = new BinaryOperatorAggregate(this.operator, this.initialValueFactory);
+        return empty;
+    }
+    update(values) {
+        let newValues = values;
+        if (!newValues.length)
+            return;
+        if (this.value === undefined) {
+            [this.value] = newValues;
+            newValues = newValues.slice(1);
+        }
+        for (const value of newValues) {
+            if (this.value !== undefined) {
+                this.value = this.operator(this.value, value);
+            }
+        }
+    }
+    get() {
+        if (this.value === undefined) {
+            throw new EmptyChannelError();
+        }
+        return this.value;
+    }
+    checkpoint() {
+        if (!this.value) {
+            throw new EmptyChannelError();
+        }
+        return this.value;
+    }
+}

package/dist/channels/index.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.empty = exports.createCheckpoint = exports.InvalidUpdateError = exports.EmptyChannelError = exports.BaseChannel = void 0;
+var base_js_1 = require("./base.cjs");
+Object.defineProperty(exports, "BaseChannel", { enumerable: true, get: function () { return base_js_1.BaseChannel; } });
+Object.defineProperty(exports, "EmptyChannelError", { enumerable: true, get: function () { return base_js_1.EmptyChannelError; } });
+Object.defineProperty(exports, "InvalidUpdateError", { enumerable: true, get: function () { return base_js_1.InvalidUpdateError; } });
+Object.defineProperty(exports, "createCheckpoint", { enumerable: true, get: function () { return base_js_1.createCheckpoint; } });
+Object.defineProperty(exports, "empty", { enumerable: true, get: function () { return base_js_1.emptyChannels; } });

package/dist/channels/index.d.ts

@@ -0,0 +1 @@
+export { BaseChannel, EmptyChannelError, InvalidUpdateError, createCheckpoint, emptyChannels as empty, } from "./base.js";

package/dist/channels/index.js

@@ -0,0 +1 @@
+export { BaseChannel, EmptyChannelError, InvalidUpdateError, createCheckpoint, emptyChannels as empty, } from "./base.js";

package/dist/channels/last_value.cjs

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LastValue = void 0;
+const index_js_1 = require("./index.cjs");
+/**
+ * Stores the last value received, can receive at most one value per step.
+ */
+class LastValue extends index_js_1.BaseChannel {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "lc_graph_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "LastValue"
+        });
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+    }
+    empty(checkpoint) {
+        const empty = new LastValue();
+        if (checkpoint) {
+            empty.value = checkpoint;
+        }
+        return empty;
+    }
+    update(values) {
+        if (values.length === 0) {
+            return;
+        }
+        if (values.length !== 1) {
+            throw new index_js_1.InvalidUpdateError();
+        }
+        [this.value] = values;
+    }
+    get() {
+        if (this.value === undefined) {
+            throw new index_js_1.EmptyChannelError();
+        }
+        return this.value;
+    }
+    checkpoint() {
+        if (this.value === undefined) {
+            throw new index_js_1.EmptyChannelError();
+        }
+        return this.value;
+    }
+}
+exports.LastValue = LastValue;

package/dist/channels/last_value.d.ts

@@ -0,0 +1,12 @@
+import { BaseChannel } from "./index.js";
+/**
+ * Stores the last value received, can receive at most one value per step.
+ */
+export declare class LastValue<Value> extends BaseChannel<Value, Value, Value> {
+    lc_graph_name: string;
+    value?: Value;
+    empty(checkpoint?: Value): LastValue<Value>;
+    update(values: Value[]): void;
+    get(): Value;
+    checkpoint(): Value;
+}

package/dist/channels/last_value.js

@@ -0,0 +1,49 @@
+import { BaseChannel, EmptyChannelError, InvalidUpdateError } from "./index.js";
+/**
+ * Stores the last value received, can receive at most one value per step.
+ */
+export class LastValue extends BaseChannel {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "lc_graph_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "LastValue"
+        });
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+    }
+    empty(checkpoint) {
+        const empty = new LastValue();
+        if (checkpoint) {
+            empty.value = checkpoint;
+        }
+        return empty;
+    }
+    update(values) {
+        if (values.length === 0) {
+            return;
+        }
+        if (values.length !== 1) {
+            throw new InvalidUpdateError();
+        }
+        [this.value] = values;
+    }
+    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/topic.cjs

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Topic = void 0;
+const base_js_1 = require("./base.cjs");
+function* flatten(values) {
+    for (const value of values) {
+        if (Array.isArray(value)) {
+            yield* value;
+        }
+        else {
+            yield value;
+        }
+    }
+}
+class Topic extends base_js_1.BaseChannel {
+    constructor(fields) {
+        super();
+        Object.defineProperty(this, "lc_graph_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "Topic"
+        });
+        Object.defineProperty(this, "unique", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "accumulate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "seen", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "values", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.unique = fields?.unique ?? this.unique;
+        this.accumulate = fields?.accumulate ?? this.accumulate;
+        // State
+        this.seen = new Set();
+        this.values = [];
+    }
+    empty(checkpoint) {
+        const empty = new Topic({
+            unique: this.unique,
+            accumulate: this.accumulate,
+        });
+        if (checkpoint) {
+            [empty.seen, empty.values] = checkpoint;
+        }
+        return empty;
+    }
+    update(values) {
+        if (!this.accumulate) {
+            this.values = [];
+        }
+        const flatValues = flatten(values);
+        if (flatValues) {
+            if (this.unique) {
+                for (const value of flatValues) {
+                    if (!this.seen.has(value)) {
+                        this.seen.add(value);
+                        this.values.push(value);
+                    }
+                }
+            }
+            else {
+                this.values.push(...flatValues);
+            }
+        }
+    }
+    get() {
+        return this.values;
+    }
+    checkpoint() {
+        return [this.seen, this.values];
+    }
+}
+exports.Topic = Topic;

package/dist/channels/topic.d.ts

@@ -0,0 +1,19 @@
+import { BaseChannel } from "./base.js";
+export declare class Topic<Value> extends BaseChannel<Array<Value>, Value | Value[], [
+    Set<Value>,
+    Value[]
+]> {
+    lc_graph_name: string;
+    unique: boolean;
+    accumulate: boolean;
+    seen: Set<Value>;
+    values: Value[];
+    constructor(fields?: {
+        unique?: boolean;
+        accumulate?: boolean;
+    });
+    empty(checkpoint?: [Set<Value>, Value[]]): Topic<Value>;
+    update(values: Array<Value | Value[]>): void;
+    get(): Array<Value>;
+    checkpoint(): [Set<Value>, Array<Value>];
+}

package/dist/channels/topic.js

@@ -0,0 +1,86 @@
+import { BaseChannel } from "./base.js";
+function* flatten(values) {
+    for (const value of values) {
+        if (Array.isArray(value)) {
+            yield* value;
+        }
+        else {
+            yield value;
+        }
+    }
+}
+export class Topic extends BaseChannel {
+    constructor(fields) {
+        super();
+        Object.defineProperty(this, "lc_graph_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "Topic"
+        });
+        Object.defineProperty(this, "unique", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "accumulate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "seen", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "values", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.unique = fields?.unique ?? this.unique;
+        this.accumulate = fields?.accumulate ?? this.accumulate;
+        // State
+        this.seen = new Set();
+        this.values = [];
+    }
+    empty(checkpoint) {
+        const empty = new Topic({
+            unique: this.unique,
+            accumulate: this.accumulate,
+        });
+        if (checkpoint) {
+            [empty.seen, empty.values] = checkpoint;
+        }
+        return empty;
+    }
+    update(values) {
+        if (!this.accumulate) {
+            this.values = [];
+        }
+        const flatValues = flatten(values);
+        if (flatValues) {
+            if (this.unique) {
+                for (const value of flatValues) {
+                    if (!this.seen.has(value)) {
+                        this.seen.add(value);
+                        this.values.push(value);
+                    }
+                }
+            }
+            else {
+                this.values.push(...flatValues);
+            }
+        }
+    }
+    get() {
+        return this.values;
+    }
+    checkpoint() {
+        return [this.seen, this.values];
+    }
+}

package/dist/checkpoint/base.cjs

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCheckpointSaver = exports.CheckpointAt = exports.emptyCheckpoint = void 0;
+function emptyCheckpoint() {
+    return {
+        v: 1,
+        ts: new Date().toISOString(),
+        channelValues: {},
+        channelVersions: {},
+        versionsSeen: {},
+    };
+}
+exports.emptyCheckpoint = emptyCheckpoint;
+var CheckpointAt;
+(function (CheckpointAt) {
+    CheckpointAt["END_OF_STEP"] = "end_of_step";
+    CheckpointAt["END_OF_RUN"] = "end_of_run";
+})(CheckpointAt || (exports.CheckpointAt = CheckpointAt = {}));
+class BaseCheckpointSaver {
+    constructor() {
+        Object.defineProperty(this, "at", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: CheckpointAt.END_OF_RUN
+        });
+    }
+    get configSpecs() {
+        return [];
+    }
+}
+exports.BaseCheckpointSaver = BaseCheckpointSaver;

package/dist/checkpoint/base.d.ts

@@ -0,0 +1,47 @@
+import { RunnableConfig } from "@langchain/core/runnables";
+/** A field that can be configured by the user. It is a specification of a field. */
+export interface ConfigurableFieldSpec {
+    id: string;
+    annotation: any;
+    name: string | null;
+    description: string | null;
+    default: any;
+    /**
+     * @default false
+     */
+    isShared?: boolean;
+    dependencies: Array<string> | null;
+}
+export interface Checkpoint {
+    /**
+     * Version number
+     */
+    v: number;
+    /**
+     * Timestamp {new Date().toISOString()}
+     */
+    ts: string;
+    /**
+     * @default {}
+     */
+    channelValues: Record<string, any>;
+    /**
+     * @default {}
+     */
+    channelVersions: Record<string, number>;
+    /**
+     * @default {}
+     */
+    versionsSeen: Record<string, Record<string, number>>;
+}
+export declare function emptyCheckpoint(): Checkpoint;
+export declare enum CheckpointAt {
+    END_OF_STEP = "end_of_step",
+    END_OF_RUN = "end_of_run"
+}
+export declare abstract class BaseCheckpointSaver {
+    at: CheckpointAt;
+    get configSpecs(): Array<ConfigurableFieldSpec>;
+    abstract get(config: RunnableConfig): Checkpoint | undefined;
+    abstract put(config: RunnableConfig, checkpoint: Checkpoint): void;
+}

package/dist/checkpoint/base.js

@@ -0,0 +1,27 @@
+export function emptyCheckpoint() {
+    return {
+        v: 1,
+        ts: new Date().toISOString(),
+        channelValues: {},
+        channelVersions: {},
+        versionsSeen: {},
+    };
+}
+export var CheckpointAt;
+(function (CheckpointAt) {
+    CheckpointAt["END_OF_STEP"] = "end_of_step";
+    CheckpointAt["END_OF_RUN"] = "end_of_run";
+})(CheckpointAt || (CheckpointAt = {}));
+export class BaseCheckpointSaver {
+    constructor() {
+        Object.defineProperty(this, "at", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: CheckpointAt.END_OF_RUN
+        });
+    }
+    get configSpecs() {
+        return [];
+    }
+}