@langchain/langgraph 0.2.3 → 0.2.4

package/dist/managed/base.js

@@ -0,0 +1,155 @@
+import { RUNTIME_PLACEHOLDER } from "../constants.js";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class ManagedValue {
+    constructor(config, _params) {
+        Object.defineProperty(this, "runtime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_promises", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "lg_is_managed_value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        this.config = config;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static async initialize(_config, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _args) {
+        throw new Error("Not implemented");
+    }
+    async promises() {
+        return Promise.all(this._promises);
+    }
+    addPromise(promise) {
+        this._promises.push(promise);
+    }
+}
+export class WritableManagedValue extends ManagedValue {
+}
+export const ChannelKeyPlaceholder = "__channel_key_placeholder__";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class ManagedValueMapping extends Map {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(entries) {
+        super(entries ? Array.from(entries) : undefined);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    replaceRuntimeValues(step, values) {
+        if (this.size === 0 || !values) {
+            return;
+        }
+        if (Array.from(this.values()).every((mv) => !mv.runtime)) {
+            return;
+        }
+        if (typeof values === "object" && !Array.isArray(values)) {
+            for (const [key, value] of Object.entries(values)) {
+                for (const [chan, mv] of this.entries()) {
+                    if (mv.runtime && mv.call(step) === value) {
+                        // eslint-disable-next-line no-param-reassign
+                        values[key] = { [RUNTIME_PLACEHOLDER]: chan };
+                    }
+                }
+            }
+        }
+        else if (typeof values === "object" && "constructor" in values) {
+            for (const key of Object.getOwnPropertyNames(Object.getPrototypeOf(values))) {
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const value = values[key];
+                    for (const [chan, mv] of this.entries()) {
+                        if (mv.runtime && mv.call(step) === value) {
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any, no-param-reassign
+                            values[key] = { [RUNTIME_PLACEHOLDER]: chan };
+                        }
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                }
+                catch (error) {
+                    // Ignore if TypeError
+                    if (error.name !== TypeError.name) {
+                        throw error;
+                    }
+                }
+            }
+        }
+    }
+    replaceRuntimePlaceholders(step, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    values) {
+        if (this.size === 0 || !values) {
+            return;
+        }
+        if (Array.from(this.values()).every((mv) => !mv.runtime)) {
+            return;
+        }
+        if (typeof values === "object" && !Array.isArray(values)) {
+            for (const [key, value] of Object.entries(values)) {
+                if (typeof value === "object" &&
+                    value !== null &&
+                    RUNTIME_PLACEHOLDER in value) {
+                    const placeholder = value[RUNTIME_PLACEHOLDER];
+                    if (typeof placeholder === "string") {
+                        // eslint-disable-next-line no-param-reassign
+                        values[key] = this.get(placeholder)?.call(step);
+                    }
+                }
+            }
+        }
+        else if (typeof values === "object" && "constructor" in values) {
+            for (const key of Object.getOwnPropertyNames(Object.getPrototypeOf(values))) {
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const value = values[key];
+                    if (typeof value === "object" &&
+                        value !== null &&
+                        RUNTIME_PLACEHOLDER in value) {
+                        const managedValue = this.get(value[RUNTIME_PLACEHOLDER]);
+                        if (managedValue) {
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any, no-param-reassign
+                            values[key] = managedValue.call(step);
+                        }
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                }
+                catch (error) {
+                    // Ignore if TypeError
+                    if (error.name !== TypeError.name) {
+                        throw error;
+                    }
+                }
+            }
+        }
+    }
+}
+export function isManagedValue(value) {
+    if (typeof value === "object" && value && "lg_is_managed_value" in value) {
+        return true;
+    }
+    return false;
+}
+export function isConfiguredManagedValue(value) {
+    if (typeof value === "object" &&
+        value &&
+        "cls" in value &&
+        "params" in value) {
+        return true;
+    }
+    return false;
+}

package/dist/managed/index.cjs

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./base.cjs"), exports);
+__exportStar(require("./is_last_step.cjs"), exports);
+__exportStar(require("./shared_value.cjs"), exports);

package/dist/managed/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./base.js";
+export * from "./is_last_step.js";
+export * from "./shared_value.js";

package/dist/managed/index.js

@@ -0,0 +1,3 @@
+export * from "./base.js";
+export * from "./is_last_step.js";
+export * from "./shared_value.js";

package/dist/managed/is_last_step.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsLastStepManager = void 0;
+const constants_js_1 = require("../constants.cjs");
+const base_js_1 = require("./base.cjs");
+class IsLastStepManager extends base_js_1.ManagedValue {
+    call(step) {
+        return step === (this.config.recursionLimit ?? constants_js_1.RECURSION_LIMIT_DEFAULT) - 1;
+    }
+}
+exports.IsLastStepManager = IsLastStepManager;

package/dist/managed/is_last_step.d.ts

@@ -0,0 +1,4 @@
+import { ManagedValue } from "./base.js";
+export declare class IsLastStepManager extends ManagedValue<boolean> {
+    call(step: number): boolean;
+}

package/dist/managed/is_last_step.js

@@ -0,0 +1,7 @@
+import { RECURSION_LIMIT_DEFAULT } from "../constants.js";
+import { ManagedValue } from "./base.js";
+export class IsLastStepManager extends ManagedValue {
+    call(step) {
+        return step === (this.config.recursionLimit ?? RECURSION_LIMIT_DEFAULT) - 1;
+    }
+}

package/dist/managed/shared_value.cjs

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedValue = void 0;
+const base_js_1 = require("./base.cjs");
+const constants_js_1 = require("../constants.cjs");
+const errors_js_1 = require("../errors.cjs");
+class SharedValue extends base_js_1.WritableManagedValue {
+    constructor(config, params) {
+        super(config, params);
+        Object.defineProperty(this, "scope", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "store", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        this.scope = params.scope;
+        this.store = config.configurable?.[constants_js_1.CONFIG_KEY_STORE] || null;
+        if (!this.store) {
+            this.ns = null;
+        }
+        else if (config.configurable?.[this.scope]) {
+            const scopeValue = config.configurable[this.scope];
+            const scopedValueString = typeof scopeValue === "string"
+                ? scopeValue
+                : JSON.stringify(scopeValue);
+            this.ns = `scoped:${this.scope}:${params.key}:${scopedValueString}`;
+        }
+        else {
+            throw new Error(`Scope ${this.scope} for shared state key not in config.configurable`);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static async initialize(config, args) {
+        const instance = new this(config, args);
+        await instance.loadStore();
+        return instance;
+    }
+    static on(scope) {
+        return {
+            cls: SharedValue,
+            params: {
+                scope,
+                key: base_js_1.ChannelKeyPlaceholder,
+            },
+        };
+    }
+    call(_step) {
+        return { ...this.value };
+    }
+    processUpdate(values) {
+        const writes = [];
+        for (const vv of values) {
+            for (const [k, v] of Object.entries(vv)) {
+                if (v === null) {
+                    if (k in this.value) {
+                        delete this.value[k];
+                        if (this.ns) {
+                            writes.push([this.ns, k, null]);
+                        }
+                    }
+                }
+                else if (typeof v !== "object" || v === null) {
+                    throw new errors_js_1.InvalidUpdateError("Received a non-object value");
+                }
+                else {
+                    this.value[k] = v;
+                    if (this.ns) {
+                        writes.push([this.ns, k, v]);
+                    }
+                }
+            }
+        }
+        return writes;
+    }
+    async update(values) {
+        if (!this.store) {
+            this.processUpdate(values);
+        }
+        else {
+            await this.store.put(this.processUpdate(values));
+        }
+    }
+    async loadStore() {
+        if (this.store && this.ns) {
+            const saved = await this.store.list([this.ns]);
+            this.value = saved[this.ns] || {};
+        }
+        return false;
+    }
+}
+exports.SharedValue = SharedValue;

package/dist/managed/shared_value.d.ts

@@ -0,0 +1,23 @@
+import { RunnableConfig } from "@langchain/core/runnables";
+import { BaseStore, type Values } from "../store/base.js";
+import { ConfiguredManagedValue, ManagedValue, ManagedValueParams, WritableManagedValue } from "./base.js";
+type Value = Record<string, Values>;
+type Update = Record<string, Values | null>;
+export interface SharedValueParams extends ManagedValueParams {
+    scope: string;
+    key: string;
+}
+export declare class SharedValue extends WritableManagedValue<Value, Update> {
+    scope: string;
+    store: BaseStore | null;
+    ns: string | null;
+    value: Value;
+    constructor(config: RunnableConfig, params: SharedValueParams);
+    static initialize<Value = any>(config: RunnableConfig, args: SharedValueParams): Promise<ManagedValue<Value>>;
+    static on(scope: string): ConfiguredManagedValue<Value>;
+    call(_step: number): Value;
+    private processUpdate;
+    update(values: Update[]): Promise<void>;
+    private loadStore;
+}
+export {};

package/dist/managed/shared_value.js

@@ -0,0 +1,105 @@
+import { ChannelKeyPlaceholder, WritableManagedValue, } from "./base.js";
+import { CONFIG_KEY_STORE } from "../constants.js";
+import { InvalidUpdateError } from "../errors.js";
+export class SharedValue extends WritableManagedValue {
+    constructor(config, params) {
+        super(config, params);
+        Object.defineProperty(this, "scope", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "store", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        this.scope = params.scope;
+        this.store = config.configurable?.[CONFIG_KEY_STORE] || null;
+        if (!this.store) {
+            this.ns = null;
+        }
+        else if (config.configurable?.[this.scope]) {
+            const scopeValue = config.configurable[this.scope];
+            const scopedValueString = typeof scopeValue === "string"
+                ? scopeValue
+                : JSON.stringify(scopeValue);
+            this.ns = `scoped:${this.scope}:${params.key}:${scopedValueString}`;
+        }
+        else {
+            throw new Error(`Scope ${this.scope} for shared state key not in config.configurable`);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static async initialize(config, args) {
+        const instance = new this(config, args);
+        await instance.loadStore();
+        return instance;
+    }
+    static on(scope) {
+        return {
+            cls: SharedValue,
+            params: {
+                scope,
+                key: ChannelKeyPlaceholder,
+            },
+        };
+    }
+    call(_step) {
+        return { ...this.value };
+    }
+    processUpdate(values) {
+        const writes = [];
+        for (const vv of values) {
+            for (const [k, v] of Object.entries(vv)) {
+                if (v === null) {
+                    if (k in this.value) {
+                        delete this.value[k];
+                        if (this.ns) {
+                            writes.push([this.ns, k, null]);
+                        }
+                    }
+                }
+                else if (typeof v !== "object" || v === null) {
+                    throw new InvalidUpdateError("Received a non-object value");
+                }
+                else {
+                    this.value[k] = v;
+                    if (this.ns) {
+                        writes.push([this.ns, k, v]);
+                    }
+                }
+            }
+        }
+        return writes;
+    }
+    async update(values) {
+        if (!this.store) {
+            this.processUpdate(values);
+        }
+        else {
+            await this.store.put(this.processUpdate(values));
+        }
+    }
+    async loadStore() {
+        if (this.store && this.ns) {
+            const saved = await this.store.list([this.ns]);
+            this.value = saved[this.ns] || {};
+        }
+        return false;
+    }
+}