@langchain/langgraph 0.2.3 → 0.2.5-rc.0

package/dist/channels/base.cjs

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCheckpoint = exports.emptyChannels = exports.BaseChannel = void 0;
+exports.createCheckpoint = exports.emptyChannels = exports.BaseChannel = exports.isBaseChannel = void 0;
 const langgraph_checkpoint_1 = require("@langchain/langgraph-checkpoint");
 const errors_js_1 = require("../errors.cjs");
+function isBaseChannel(obj) {
+    return obj != null && obj.lg_is_channel === true;
+}
+exports.isBaseChannel = isBaseChannel;
 class BaseChannel {
     constructor() {
         Object.defineProperty(this, "ValueType", {
@@ -17,6 +21,13 @@ class BaseChannel {
             writable: true,
             value: void 0
         });
+        /** @ignore */
+        Object.defineProperty(this, "lg_is_channel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
     }
     /**
      * Mark the current value of the channel as consumed. By default, no-op.
@@ -29,11 +40,12 @@ class BaseChannel {
 }
 exports.BaseChannel = BaseChannel;
 function emptyChannels(channels, checkpoint) {
+    const filteredChannels = Object.fromEntries(Object.entries(channels).filter(([, value]) => isBaseChannel(value)));
     const newChannels = {};
-    for (const k in channels) {
-        if (Object.prototype.hasOwnProperty.call(channels, k)) {
+    for (const k in filteredChannels) {
+        if (Object.prototype.hasOwnProperty.call(filteredChannels, k)) {
             const channelValue = checkpoint.channel_values[k];
-            newChannels[k] = channels[k].fromCheckpoint(channelValue);
+            newChannels[k] = filteredChannels[k].fromCheckpoint(channelValue);
         }
     }
     return newChannels;

package/dist/channels/base.d.ts

@@ -1,4 +1,5 @@
 import { ReadonlyCheckpoint, Checkpoint } from "@langchain/langgraph-checkpoint";
+export declare function isBaseChannel(obj: unknown): obj is BaseChannel;
 export declare abstract class BaseChannel<ValueType = unknown, UpdateType = unknown, CheckpointType = unknown> {
     ValueType: ValueType;
     UpdateType: UpdateType;
@@ -6,6 +7,8 @@ export declare abstract class BaseChannel<ValueType = unknown, UpdateType = unkn
      * The name of the channel.
      */
     abstract lc_graph_name: string;
+    /** @ignore */
+    lg_is_channel: boolean;
     /**
      * 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.

package/dist/channels/base.js

@@ -1,5 +1,8 @@
 import { deepCopy, uuid6, } from "@langchain/langgraph-checkpoint";
 import { EmptyChannelError } from "../errors.js";
+export function isBaseChannel(obj) {
+    return obj != null && obj.lg_is_channel === true;
+}
 export class BaseChannel {
     constructor() {
         Object.defineProperty(this, "ValueType", {
@@ -14,6 +17,13 @@ export class BaseChannel {
             writable: true,
             value: void 0
         });
+        /** @ignore */
+        Object.defineProperty(this, "lg_is_channel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
     }
     /**
      * Mark the current value of the channel as consumed. By default, no-op.
@@ -25,11 +35,12 @@ export class BaseChannel {
     }
 }
 export function emptyChannels(channels, checkpoint) {
+    const filteredChannels = Object.fromEntries(Object.entries(channels).filter(([, value]) => isBaseChannel(value)));
     const newChannels = {};
-    for (const k in channels) {
-        if (Object.prototype.hasOwnProperty.call(channels, k)) {
+    for (const k in filteredChannels) {
+        if (Object.prototype.hasOwnProperty.call(filteredChannels, k)) {
             const channelValue = checkpoint.channel_values[k];
-            newChannels[k] = channels[k].fromCheckpoint(channelValue);
+            newChannels[k] = filteredChannels[k].fromCheckpoint(channelValue);
         }
     }
     return newChannels;

package/dist/constants.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._isSend = exports.Send = exports._isSendInterface = exports.CHECKPOINT_NAMESPACE_SEPARATOR = exports.RESERVED = exports.TASK_NAMESPACE = exports.TASKS = exports.TAG_HIDDEN = exports.INTERRUPT = exports.CONFIG_KEY_RESUMING = exports.CONFIG_KEY_CHECKPOINTER = exports.CONFIG_KEY_READ = exports.CONFIG_KEY_SEND = exports.ERROR = exports.INPUT = void 0;
+exports._isSend = exports.Send = exports._isSendInterface = exports.CHECKPOINT_NAMESPACE_SEPARATOR = exports.RESERVED = exports.TASK_NAMESPACE = exports.TASKS = exports.TAG_HIDDEN = exports.RECURSION_LIMIT_DEFAULT = exports.RUNTIME_PLACEHOLDER = exports.CONFIG_KEY_STORE = exports.INTERRUPT = exports.CONFIG_KEY_RESUMING = exports.CONFIG_KEY_CHECKPOINTER = exports.CONFIG_KEY_READ = exports.CONFIG_KEY_SEND = exports.ERROR = exports.INPUT = void 0;
 exports.INPUT = "__input__";
 exports.ERROR = "__error__";
 exports.CONFIG_KEY_SEND = "__pregel_send";
@@ -8,6 +8,9 @@ exports.CONFIG_KEY_READ = "__pregel_read";
 exports.CONFIG_KEY_CHECKPOINTER = "__pregel_checkpointer";
 exports.CONFIG_KEY_RESUMING = "__pregel_resuming";
 exports.INTERRUPT = "__interrupt__";
+exports.CONFIG_KEY_STORE = "__pregel_store";
+exports.RUNTIME_PLACEHOLDER = "__pregel_runtime_placeholder__";
+exports.RECURSION_LIMIT_DEFAULT = 25;
 exports.TAG_HIDDEN = "langsmith:hidden";
 exports.TASKS = "__pregel_tasks";
 exports.TASK_NAMESPACE = "6ba7b831-9dad-11d1-80b4-00c04fd430c8";

package/dist/constants.d.ts

@@ -5,6 +5,9 @@ export declare const CONFIG_KEY_READ = "__pregel_read";
 export declare const CONFIG_KEY_CHECKPOINTER = "__pregel_checkpointer";
 export declare const CONFIG_KEY_RESUMING = "__pregel_resuming";
 export declare const INTERRUPT = "__interrupt__";
+export declare const CONFIG_KEY_STORE = "__pregel_store";
+export declare const RUNTIME_PLACEHOLDER = "__pregel_runtime_placeholder__";
+export declare const RECURSION_LIMIT_DEFAULT = 25;
 export declare const TAG_HIDDEN = "langsmith:hidden";
 export declare const TASKS = "__pregel_tasks";
 export declare const TASK_NAMESPACE = "6ba7b831-9dad-11d1-80b4-00c04fd430c8";

package/dist/constants.js

@@ -5,6 +5,9 @@ export const CONFIG_KEY_READ = "__pregel_read";
 export const CONFIG_KEY_CHECKPOINTER = "__pregel_checkpointer";
 export const CONFIG_KEY_RESUMING = "__pregel_resuming";
 export const INTERRUPT = "__interrupt__";
+export const CONFIG_KEY_STORE = "__pregel_store";
+export const RUNTIME_PLACEHOLDER = "__pregel_runtime_placeholder__";
+export const RECURSION_LIMIT_DEFAULT = 25;
 export const TAG_HIDDEN = "langsmith:hidden";
 export const TASKS = "__pregel_tasks";
 export const TASK_NAMESPACE = "6ba7b831-9dad-11d1-80b4-00c04fd430c8";

package/dist/graph/annotation.cjs

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getChannel = exports.Annotation = exports.AnnotationRoot = void 0;
 const binop_js_1 = require("../channels/binop.cjs");
 const last_value_js_1 = require("../channels/last_value.cjs");
+const base_js_1 = require("../managed/base.cjs");
 /**
  * Should not be instantiated directly. See {@link Annotation}.
  * @internal
@@ -97,7 +98,10 @@ exports.AnnotationRoot = AnnotationRoot;
  * Helper function that instantiates a StateGraph state. See {@link Annotation} for usage.
  */
 exports.Annotation = function (annotation) {
-    if (annotation) {
+    if ((0, base_js_1.isConfiguredManagedValue)(annotation)) {
+        return annotation;
+    }
+    else if (annotation) {
         return getChannel(annotation);
     }
     else {

package/dist/graph/annotation.d.ts

@@ -2,6 +2,7 @@ import { RunnableLike } from "@langchain/core/runnables";
 import { BaseChannel } from "../channels/base.js";
 import { BinaryOperator, BinaryOperatorAggregate } from "../channels/binop.js";
 import { LastValue } from "../channels/last_value.js";
+import { type ConfiguredManagedValue } from "../managed/base.js";
 export type SingleReducer<ValueType, UpdateType = ValueType> = {
     reducer: BinaryOperator<ValueType, UpdateType>;
     default?: () => ValueType;
@@ -13,17 +14,17 @@ export type SingleReducer<ValueType, UpdateType = ValueType> = {
     default?: () => ValueType;
 } | null;
 export interface StateDefinition {
-    [key: string]: BaseChannel | (() => BaseChannel);
+    [key: string]: BaseChannel | (() => BaseChannel) | ConfiguredManagedValue;
 }
-type ExtractValueType<C> = C extends BaseChannel ? C["ValueType"] : C extends () => BaseChannel ? ReturnType<C>["ValueType"] : never;
-type ExtractUpdateType<C> = C extends BaseChannel ? C["UpdateType"] : C extends () => BaseChannel ? ReturnType<C>["UpdateType"] : never;
+type ExtractValueType<C> = C extends BaseChannel ? C["ValueType"] : C extends () => BaseChannel ? ReturnType<C>["ValueType"] : C extends ConfiguredManagedValue<infer V> ? V : never;
+type ExtractUpdateType<C> = C extends BaseChannel ? C["UpdateType"] : C extends () => BaseChannel ? ReturnType<C>["UpdateType"] : C extends ConfiguredManagedValue<infer V> ? V : never;
 export type StateType<SD extends StateDefinition> = {
     [key in keyof SD]: ExtractValueType<SD[key]>;
 };
 export type UpdateType<SD extends StateDefinition> = {
     [key in keyof SD]?: ExtractUpdateType<SD[key]>;
 };
-export type NodeType<SD extends StateDefinition> = RunnableLike<StateType<SD>, UpdateType<SD>>;
+export type NodeType<SD extends StateDefinition> = RunnableLike<StateType<SD>, UpdateType<SD> | Partial<StateType<SD>>>;
 /** @ignore */
 export interface AnnotationFunction {
     <ValueType>(): LastValue<ValueType>;

package/dist/graph/annotation.js

@@ -1,5 +1,6 @@
 import { BinaryOperatorAggregate } from "../channels/binop.js";
 import { LastValue } from "../channels/last_value.js";
+import { isConfiguredManagedValue, } from "../managed/base.js";
 /**
  * Should not be instantiated directly. See {@link Annotation}.
  * @internal
@@ -93,7 +94,10 @@ export class AnnotationRoot {
  * Helper function that instantiates a StateGraph state. See {@link Annotation} for usage.
  */
 export const Annotation = function (annotation) {
-    if (annotation) {
+    if (isConfiguredManagedValue(annotation)) {
+        return annotation;
+    }
+    else if (annotation) {
         return getChannel(annotation);
     }
     else {

package/dist/graph/state.cjs

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CompiledStateGraph = exports.StateGraph = void 0;
 /* eslint-disable @typescript-eslint/no-use-before-define */
 const runnables_1 = require("@langchain/core/runnables");
+const base_js_1 = require("../channels/base.cjs");
 const graph_js_1 = require("./graph.cjs");
 const write_js_1 = require("../pregel/write.cjs");
 const read_js_1 = require("../pregel/read.cjs");
@@ -12,6 +13,7 @@ const utils_js_1 = require("../utils.cjs");
 const constants_js_1 = require("../constants.cjs");
 const errors_js_1 = require("../errors.cjs");
 const annotation_js_1 = require("./annotation.cjs");
+const base_js_2 = require("../managed/base.cjs");
 const ROOT = "__root__";
 /**
  * A graph whose nodes communicate by reading and writing to a shared state.
@@ -76,7 +78,7 @@ const ROOT = "__root__";
  * ```
  */
 class StateGraph extends graph_js_1.Graph {
-    constructor(fields) {
+    constructor(fields, configSchema) {
         super();
         Object.defineProperty(this, "channels", {
             enumerable: true,
@@ -122,6 +124,13 @@ class StateGraph extends graph_js_1.Graph {
             writable: true,
             value: new Map()
         });
+        /** @internal */
+        Object.defineProperty(this, "_configSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         if (isStateGraphArgsWithInputOutputSchemas(fields)) {
             this._schemaDefinition = fields.input.spec;
             this._inputDefinition = fields.input.spec;
@@ -150,6 +159,7 @@ class StateGraph extends graph_js_1.Graph {
         this._addSchema(this._schemaDefinition);
         this._addSchema(this._inputDefinition);
         this._addSchema(this._outputDefinition);
+        this._configSchema = configSchema?.spec;
     }
     get allEdges() {
         return new Set([
@@ -173,7 +183,8 @@ class StateGraph extends graph_js_1.Graph {
             }
             if (this.channels[key] !== undefined) {
                 if (this.channels[key] !== channel) {
-                    if (channel.lc_graph_name !== "LastValue") {
+                    if (!(0, base_js_2.isConfiguredManagedValue)(channel) &&
+                        channel.lc_graph_name !== "LastValue") {
                         throw new Error(`Channel "${key}" already exists with a different type.`);
                     }
                 }
@@ -234,7 +245,7 @@ class StateGraph extends graph_js_1.Graph {
         this.waitingEdges.add([startKey, endKey]);
         return this;
     }
-    compile({ checkpointer, interruptBefore, interruptAfter, } = {}) {
+    compile({ checkpointer, store, interruptBefore, interruptAfter, } = {}) {
         // validate the graph
         this.validate([
             ...(Array.isArray(interruptBefore) ? interruptBefore : []),
@@ -248,6 +259,9 @@ class StateGraph extends graph_js_1.Graph {
         // create empty compiled graph
         const compiled = new CompiledStateGraph({
             builder: this,
+            configKeys: this._configSchema
+                ? Object.keys(this._configSchema)
+                : undefined,
             checkpointer,
             interruptAfter,
             interruptBefore,
@@ -261,6 +275,7 @@ class StateGraph extends graph_js_1.Graph {
             outputChannels,
             streamChannels,
             streamMode: "updates",
+            store,
         });
         // attach nodes, edges and branches
         compiled.attachNode(graph_js_1.START);
@@ -424,15 +439,12 @@ class CompiledStateGraph extends graph_js_1.CompiledGraph {
     }
 }
 exports.CompiledStateGraph = CompiledStateGraph;
-function isBaseChannel(obj) {
-    return obj != null && typeof obj.lc_graph_name === "string";
-}
 function isStateDefinition(obj) {
     return (typeof obj === "object" &&
         obj !== null &&
         !Array.isArray(obj) &&
         Object.keys(obj).length > 0 &&
-        Object.values(obj).every((v) => typeof v === "function" || isBaseChannel(v)));
+        Object.values(obj).every((v) => typeof v === "function" || (0, base_js_1.isBaseChannel)(v)));
 }
 function isAnnotationRoot(obj) {
     return (typeof obj === "object" &&

package/dist/graph/state.d.ts

@@ -4,6 +4,8 @@ import { BaseChannel } from "../channels/base.js";
 import { END, CompiledGraph, Graph, START, Branch, AddNodeOptions, NodeSpec } from "./graph.js";
 import { AnnotationRoot, SingleReducer, StateDefinition, StateType, UpdateType } from "./annotation.js";
 import type { RetryPolicy } from "../pregel/utils.js";
+import { BaseStore } from "../store/base.js";
+import { ManagedValueSpec } from "../managed/base.js";
 export type ChannelReducers<Channels extends object> = {
     [K in keyof Channels]: SingleReducer<Channels[K], any>;
 };
@@ -93,8 +95,8 @@ export type StateGraphArgsWithInputOutputSchemas<SD extends StateDefinition, O e
  * // }
  * ```
  */
-export declare class StateGraph<SD extends StateDefinition | unknown, S = SD extends StateDefinition ? StateType<SD> : SD, U = SD extends StateDefinition ? UpdateType<SD> : Partial<S>, N extends string = typeof START, I extends StateDefinition = SD extends StateDefinition ? SD : StateDefinition, O extends StateDefinition = SD extends StateDefinition ? SD : StateDefinition> extends Graph<N, S, U, StateGraphNodeSpec<S, U>> {
-    channels: Record<string, BaseChannel>;
+export declare class StateGraph<SD extends StateDefinition | unknown, S = SD extends StateDefinition ? StateType<SD> : SD, U = SD extends StateDefinition ? UpdateType<SD> : Partial<S>, N extends string = typeof START, I extends StateDefinition = SD extends StateDefinition ? SD : StateDefinition, O extends StateDefinition = SD extends StateDefinition ? SD : StateDefinition, C extends StateDefinition = StateDefinition> extends Graph<N, S, U, StateGraphNodeSpec<S, U>> {
+    channels: Record<string, BaseChannel | ManagedValueSpec>;
     waitingEdges: Set<[N[], N]>;
     /** @internal */
     _schemaDefinition: StateDefinition;
@@ -107,19 +109,22 @@ export declare class StateGraph<SD extends StateDefinition | unknown, S = SD ext
      * @internal
      */
     _schemaDefinitions: Map<any, any>;
-    constructor(fields: SD extends StateDefinition ? SD | AnnotationRoot<SD> | StateGraphArgs<S> | StateGraphArgsWithStateSchema<SD, I, O> | StateGraphArgsWithInputOutputSchemas<SD, O> : StateGraphArgs<S>);
+    /** @internal */
+    _configSchema: C | undefined;
+    constructor(fields: SD extends StateDefinition ? SD | AnnotationRoot<SD> | StateGraphArgs<S> | StateGraphArgsWithStateSchema<SD, I, O> | StateGraphArgsWithInputOutputSchemas<SD, O> : StateGraphArgs<S>, configSchema?: AnnotationRoot<C>);
     get allEdges(): Set<[string, string]>;
     _addSchema(stateDefinition: StateDefinition): void;
-    addNode<K extends string, NodeInput = S>(key: K, action: RunnableLike<NodeInput, U extends object ? U & Record<string, any> : U>, options?: StateGraphAddNodeOptions): StateGraph<SD, S, U, N | K, I, O>;
+    addNode<K extends string, NodeInput = S>(key: K, action: RunnableLike<NodeInput, U extends object ? U & Record<string, any> : U>, options?: StateGraphAddNodeOptions): StateGraph<SD, S, U, N | K, I, O, C>;
     addEdge(startKey: typeof START | N | N[], endKey: N | typeof END): this;
-    compile({ checkpointer, interruptBefore, interruptAfter, }?: {
+    compile({ checkpointer, store, interruptBefore, interruptAfter, }?: {
         checkpointer?: BaseCheckpointSaver;
+        store?: BaseStore;
         interruptBefore?: N[] | All;
         interruptAfter?: N[] | All;
-    }): CompiledStateGraph<S, U, N, I, O>;
+    }): CompiledStateGraph<S, U, N, I, O, C>;
 }
-export declare class CompiledStateGraph<S, U, N extends string = typeof START, I extends StateDefinition = StateDefinition, O extends StateDefinition = StateDefinition> extends CompiledGraph<N, S, U> {
-    builder: StateGraph<unknown, S, U, N, I, O>;
+export declare class CompiledStateGraph<S, U, N extends string = typeof START, I extends StateDefinition = StateDefinition, O extends StateDefinition = StateDefinition, C extends StateDefinition = StateDefinition> extends CompiledGraph<N, S, U> {
+    builder: StateGraph<unknown, S, U, N, I, O, C>;
     attachNode(key: typeof START, node?: never): void;
     attachNode(key: N, node: StateGraphNodeSpec<S, U>): void;
     attachEdge(start: N | N[] | "__start__", end: N | "__end__"): void;

package/dist/graph/state.js

@@ -1,5 +1,6 @@
 /* eslint-disable @typescript-eslint/no-use-before-define */
 import { _coerceToRunnable, } from "@langchain/core/runnables";
+import { isBaseChannel } from "../channels/base.js";
 import { END, CompiledGraph, Graph, START, } from "./graph.js";
 import { ChannelWrite, PASSTHROUGH, SKIP_WRITE, } from "../pregel/write.js";
 import { ChannelRead, PregelNode } from "../pregel/read.js";
@@ -9,6 +10,7 @@ import { RunnableCallable } from "../utils.js";
 import { _isSend, CHECKPOINT_NAMESPACE_SEPARATOR, TAG_HIDDEN, } from "../constants.js";
 import { InvalidUpdateError } from "../errors.js";
 import { getChannel, } from "./annotation.js";
+import { isConfiguredManagedValue } from "../managed/base.js";
 const ROOT = "__root__";
 /**
  * A graph whose nodes communicate by reading and writing to a shared state.
@@ -73,7 +75,7 @@ const ROOT = "__root__";
  * ```
  */
 export class StateGraph extends Graph {
-    constructor(fields) {
+    constructor(fields, configSchema) {
         super();
         Object.defineProperty(this, "channels", {
             enumerable: true,
@@ -119,6 +121,13 @@ export class StateGraph extends Graph {
             writable: true,
             value: new Map()
         });
+        /** @internal */
+        Object.defineProperty(this, "_configSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         if (isStateGraphArgsWithInputOutputSchemas(fields)) {
             this._schemaDefinition = fields.input.spec;
             this._inputDefinition = fields.input.spec;
@@ -147,6 +156,7 @@ export class StateGraph extends Graph {
         this._addSchema(this._schemaDefinition);
         this._addSchema(this._inputDefinition);
         this._addSchema(this._outputDefinition);
+        this._configSchema = configSchema?.spec;
     }
     get allEdges() {
         return new Set([
@@ -170,7 +180,8 @@ export class StateGraph extends Graph {
             }
             if (this.channels[key] !== undefined) {
                 if (this.channels[key] !== channel) {
-                    if (channel.lc_graph_name !== "LastValue") {
+                    if (!isConfiguredManagedValue(channel) &&
+                        channel.lc_graph_name !== "LastValue") {
                         throw new Error(`Channel "${key}" already exists with a different type.`);
                     }
                 }
@@ -231,7 +242,7 @@ export class StateGraph extends Graph {
         this.waitingEdges.add([startKey, endKey]);
         return this;
     }
-    compile({ checkpointer, interruptBefore, interruptAfter, } = {}) {
+    compile({ checkpointer, store, interruptBefore, interruptAfter, } = {}) {
         // validate the graph
         this.validate([
             ...(Array.isArray(interruptBefore) ? interruptBefore : []),
@@ -245,6 +256,9 @@ export class StateGraph extends Graph {
         // create empty compiled graph
         const compiled = new CompiledStateGraph({
             builder: this,
+            configKeys: this._configSchema
+                ? Object.keys(this._configSchema)
+                : undefined,
             checkpointer,
             interruptAfter,
             interruptBefore,
@@ -258,6 +272,7 @@ export class StateGraph extends Graph {
             outputChannels,
             streamChannels,
             streamMode: "updates",
+            store,
         });
         // attach nodes, edges and branches
         compiled.attachNode(START);
@@ -419,9 +434,6 @@ export class CompiledStateGraph extends CompiledGraph {
         }
     }
 }
-function isBaseChannel(obj) {
-    return obj != null && typeof obj.lc_graph_name === "string";
-}
 function isStateDefinition(obj) {
     return (typeof obj === "object" &&
         obj !== null &&

package/dist/managed/base.cjs

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isConfiguredManagedValue = exports.isManagedValue = exports.ManagedValueMapping = exports.ChannelKeyPlaceholder = exports.WritableManagedValue = exports.ManagedValue = void 0;
+const constants_js_1 = require("../constants.cjs");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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);
+    }
+}
+exports.ManagedValue = ManagedValue;
+class WritableManagedValue extends ManagedValue {
+}
+exports.WritableManagedValue = WritableManagedValue;
+exports.ChannelKeyPlaceholder = "__channel_key_placeholder__";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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] = { [constants_js_1.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] = { [constants_js_1.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 &&
+                    constants_js_1.RUNTIME_PLACEHOLDER in value) {
+                    const placeholder = value[constants_js_1.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 &&
+                        constants_js_1.RUNTIME_PLACEHOLDER in value) {
+                        const managedValue = this.get(value[constants_js_1.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;
+                    }
+                }
+            }
+        }
+    }
+}
+exports.ManagedValueMapping = ManagedValueMapping;
+function isManagedValue(value) {
+    if (typeof value === "object" && value && "lg_is_managed_value" in value) {
+        return true;
+    }
+    return false;
+}
+exports.isManagedValue = isManagedValue;
+function isConfiguredManagedValue(value) {
+    if (typeof value === "object" &&
+        value &&
+        "cls" in value &&
+        "params" in value) {
+        return true;
+    }
+    return false;
+}
+exports.isConfiguredManagedValue = isConfiguredManagedValue;

package/dist/managed/base.d.ts

@@ -0,0 +1,30 @@
+import { RunnableConfig } from "@langchain/core/runnables";
+export interface ManagedValueParams extends Record<string, any> {
+}
+export declare abstract class ManagedValue<Value = any> {
+    runtime: boolean;
+    config: RunnableConfig;
+    private _promises;
+    lg_is_managed_value: boolean;
+    constructor(config: RunnableConfig, _params?: ManagedValueParams);
+    static initialize<Value = any>(_config: RunnableConfig, _args?: any): Promise<ManagedValue<Value>>;
+    abstract call(step: number): Value;
+    promises(): Promise<unknown>;
+    protected addPromise(promise: Promise<unknown>): void;
+}
+export declare abstract class WritableManagedValue<Value = any, Update = any> extends ManagedValue<Value> {
+    abstract update(writes: Update[]): Promise<void>;
+}
+export declare const ChannelKeyPlaceholder = "__channel_key_placeholder__";
+export type ManagedValueSpec = typeof ManagedValue | ConfiguredManagedValue;
+export interface ConfiguredManagedValue<Value = any> {
+    cls: typeof ManagedValue<Value>;
+    params: ManagedValueParams;
+}
+export declare class ManagedValueMapping extends Map<string, ManagedValue<any>> {
+    constructor(entries?: Iterable<[string, ManagedValue<any>]> | null);
+    replaceRuntimeValues(step: number, values: Record<string, any> | any): void;
+    replaceRuntimePlaceholders(step: number, values: Record<string, any> | any): void;
+}
+export declare function isManagedValue(value: unknown): value is typeof ManagedValue;
+export declare function isConfiguredManagedValue(value: unknown): value is ConfiguredManagedValue;