@langchain/langgraph 0.2.16 → 0.2.18-rc.0

package/dist/graph/graph.cjs

@@ -13,6 +13,7 @@ const write_js_1 = require("../pregel/write.cjs");
 const constants_js_1 = require("../constants.cjs");
 const utils_js_1 = require("../utils.cjs");
 const errors_js_1 = require("../errors.cjs");
+const subgraph_js_1 = require("../pregel/utils/subgraph.cjs");
 /** Special reserved node name denoting the start of a graph. */
 exports.START = "__start__";
 /** Special reserved node name denoting the end of a graph. */
@@ -41,6 +42,7 @@ class Branch {
     }
     compile(writer, reader) {
         return write_js_1.ChannelWrite.registerWriter(new utils_js_1.RunnableCallable({
+            trace: false,
             func: async (input, config) => {
                 try {
                     return await this._route(input, config, writer, reader);
@@ -140,11 +142,13 @@ class Graph {
         if (key === exports.END) {
             throw new Error(`Node \`${key}\` is reserved.`);
         }
+        const runnable = (0, runnables_1._coerceToRunnable)(
+        // Account for arbitrary state due to Send API
+        action);
         this.nodes[key] = {
-            runnable: (0, runnables_1._coerceToRunnable)(
-            // Account for arbitrary state due to Send API
-            action),
+            runnable,
             metadata: options?.metadata,
+            subgraphs: (0, subgraph_js_1.isPregelLike)(runnable) ? [runnable] : options?.subgraphs,
         };
         return this;
     }
@@ -300,6 +304,7 @@ class CompiledGraph extends index_js_1.Pregel {
             channels: [],
             triggers: [],
             metadata: node.metadata,
+            subgraphs: node.subgraphs,
         })
             .pipe(node.runnable)
             .pipe(new write_js_1.ChannelWrite([{ channel: key, value: write_js_1.PASSTHROUGH }], [constants_js_1.TAG_HIDDEN]));

package/dist/graph/graph.d.ts

@@ -28,9 +28,11 @@ export declare class Branch<IO, N extends string, CallOptions extends LangGraphR
 export type NodeSpec<RunInput, RunOutput> = {
     runnable: Runnable<RunInput, RunOutput>;
     metadata?: Record<string, unknown>;
+    subgraphs?: Pregel<any, any>[];
 };
 export type AddNodeOptions = {
     metadata?: Record<string, unknown>;
+    subgraphs?: Pregel<any, any>[];
 };
 export declare class Graph<N extends string = typeof END, RunInput = any, RunOutput = any, NodeSpecType extends NodeSpec<RunInput, RunOutput> = NodeSpec<RunInput, RunOutput>, C extends StateDefinition = StateDefinition> {
     nodes: Record<N, NodeSpecType>;

package/dist/graph/graph.js

@@ -10,6 +10,7 @@ import { ChannelWrite, PASSTHROUGH } from "../pregel/write.js";
 import { _isSend, CHECKPOINT_NAMESPACE_END, CHECKPOINT_NAMESPACE_SEPARATOR, TAG_HIDDEN, } from "../constants.js";
 import { gatherIteratorSync, RunnableCallable } from "../utils.js";
 import { InvalidUpdateError, NodeInterrupt } from "../errors.js";
+import { isPregelLike } from "../pregel/utils/subgraph.js";
 /** Special reserved node name denoting the start of a graph. */
 export const START = "__start__";
 /** Special reserved node name denoting the end of a graph. */
@@ -38,6 +39,7 @@ export class Branch {
     }
     compile(writer, reader) {
         return ChannelWrite.registerWriter(new RunnableCallable({
+            trace: false,
             func: async (input, config) => {
                 try {
                     return await this._route(input, config, writer, reader);
@@ -136,11 +138,13 @@ export class Graph {
         if (key === END) {
             throw new Error(`Node \`${key}\` is reserved.`);
         }
+        const runnable = _coerceToRunnable(
+        // Account for arbitrary state due to Send API
+        action);
         this.nodes[key] = {
-            runnable: _coerceToRunnable(
-            // Account for arbitrary state due to Send API
-            action),
+            runnable,
             metadata: options?.metadata,
+            subgraphs: isPregelLike(runnable) ? [runnable] : options?.subgraphs,
         };
         return this;
     }
@@ -295,6 +299,7 @@ export class CompiledGraph extends Pregel {
             channels: [],
             triggers: [],
             metadata: node.metadata,
+            subgraphs: node.subgraphs,
         })
             .pipe(node.runnable)
             .pipe(new ChannelWrite([{ channel: key, value: PASSTHROUGH }], [TAG_HIDDEN]));

package/dist/graph/state.cjs

@@ -14,6 +14,7 @@ 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 subgraph_js_1 = require("../pregel/utils/subgraph.cjs");
 const ROOT = "__root__";
 /**
  * A graph whose nodes communicate by reading and writing to a shared state.
@@ -216,11 +217,29 @@ class StateGraph extends graph_js_1.Graph {
         if (options?.input !== undefined) {
             this._addSchema(options.input.spec);
         }
+        let runnable;
+        if (runnables_1.Runnable.isRunnable(action)) {
+            runnable = action;
+        }
+        else if (typeof action === "function") {
+            runnable = new utils_js_1.RunnableCallable({
+                func: action,
+                name: key,
+                trace: false,
+            });
+        }
+        else {
+            runnable = (0, runnables_1._coerceToRunnable)(action);
+        }
         const nodeSpec = {
-            runnable: (0, runnables_1._coerceToRunnable)(action),
+            runnable: runnable,
             retryPolicy: options?.retryPolicy,
             metadata: options?.metadata,
             input: options?.input?.spec ?? this._schemaDefinition,
+            subgraphs: (0, subgraph_js_1.isPregelLike)(runnable)
+                ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    [runnable]
+                : options?.subgraphs,
         };
         this.nodes[key] = nodeSpec;
         return this;
@@ -377,6 +396,7 @@ class CompiledStateGraph extends graph_js_1.CompiledGraph {
                 bound: node?.runnable,
                 metadata: node?.metadata,
                 retryPolicy: node?.retryPolicy,
+                subgraphs: node?.subgraphs,
             });
         }
     }

package/dist/graph/state.js

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-use-before-define */
-import { _coerceToRunnable, } from "@langchain/core/runnables";
+import { _coerceToRunnable, Runnable, } 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";
@@ -11,6 +11,7 @@ import { _isSend, CHECKPOINT_NAMESPACE_END, CHECKPOINT_NAMESPACE_SEPARATOR, TAG_
 import { InvalidUpdateError } from "../errors.js";
 import { getChannel, } from "./annotation.js";
 import { isConfiguredManagedValue } from "../managed/base.js";
+import { isPregelLike } from "../pregel/utils/subgraph.js";
 const ROOT = "__root__";
 /**
  * A graph whose nodes communicate by reading and writing to a shared state.
@@ -213,11 +214,29 @@ export class StateGraph extends Graph {
         if (options?.input !== undefined) {
             this._addSchema(options.input.spec);
         }
+        let runnable;
+        if (Runnable.isRunnable(action)) {
+            runnable = action;
+        }
+        else if (typeof action === "function") {
+            runnable = new RunnableCallable({
+                func: action,
+                name: key,
+                trace: false,
+            });
+        }
+        else {
+            runnable = _coerceToRunnable(action);
+        }
         const nodeSpec = {
-            runnable: _coerceToRunnable(action),
+            runnable: runnable,
             retryPolicy: options?.retryPolicy,
             metadata: options?.metadata,
             input: options?.input?.spec ?? this._schemaDefinition,
+            subgraphs: isPregelLike(runnable)
+                ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    [runnable]
+                : options?.subgraphs,
         };
         this.nodes[key] = nodeSpec;
         return this;
@@ -373,6 +392,7 @@ export class CompiledStateGraph extends CompiledGraph {
                 bound: node?.runnable,
                 metadata: node?.metadata,
                 retryPolicy: node?.retryPolicy,
+                subgraphs: node?.subgraphs,
             });
         }
     }

package/dist/prebuilt/index.d.ts

@@ -2,4 +2,4 @@ export { type AgentExecutorState, createAgentExecutor, } from "./agent_executor.
 export { type FunctionCallingExecutorState, createFunctionCallingExecutor, } from "./chat_agent_executor.js";
 export { type AgentState, createReactAgent } from "./react_agent_executor.js";
 export { type ToolExecutorArgs, type ToolInvocationInterface, ToolExecutor, } from "./tool_executor.js";
-export { ToolNode, toolsCondition } from "./tool_node.js";
+export { ToolNode, toolsCondition, type ToolNodeOptions } from "./tool_node.js";

package/dist/prebuilt/react_agent_executor.cjs

@@ -95,7 +95,7 @@ function createReactAgent(params) {
     const workflow = new index_js_1.StateGraph({
         channels: schema,
     })
-        .addNode("agent", runnables_1.RunnableLambda.from(callModel).withConfig({ runName: "agent" }))
+        .addNode("agent", callModel)
         .addNode("tools", new tool_node_js_1.ToolNode(toolClasses))
         .addEdge(index_js_1.START, "agent")
         .addConditionalEdges("agent", shouldContinue, {

package/dist/prebuilt/react_agent_executor.js

@@ -92,7 +92,7 @@ export function createReactAgent(params) {
     const workflow = new StateGraph({
         channels: schema,
     })
-        .addNode("agent", RunnableLambda.from(callModel).withConfig({ runName: "agent" }))
+        .addNode("agent", callModel)
         .addNode("tools", new ToolNode(toolClasses))
         .addEdge(START, "agent")
         .addConditionalEdges("agent", shouldContinue, {

package/dist/prebuilt/tool_node.cjs

@@ -138,6 +138,12 @@ class ToolNode extends utils_js_1.RunnableCallable {
             writable: true,
             value: true
         });
+        Object.defineProperty(this, "trace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         this.tools = tools;
         this.handleToolErrors = handleToolErrors ?? this.handleToolErrors;
     }

package/dist/prebuilt/tool_node.d.ts

@@ -1,5 +1,5 @@
 import { BaseMessage } from "@langchain/core/messages";
-import { RunnableToolLike } from "@langchain/core/runnables";
+import { RunnableConfig, RunnableToolLike } from "@langchain/core/runnables";
 import { StructuredToolInterface } from "@langchain/core/tools";
 import { RunnableCallable } from "../utils.js";
 import { END } from "../graph/graph.js";
@@ -129,7 +129,8 @@ export type ToolNodeOptions = {
 export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
     tools: (StructuredToolInterface | RunnableToolLike)[];
     handleToolErrors: boolean;
+    trace: boolean;
     constructor(tools: (StructuredToolInterface | RunnableToolLike)[], options?: ToolNodeOptions);
-    private run;
+    protected run(input: any, config: RunnableConfig): Promise<T>;
 }
 export declare function toolsCondition(state: BaseMessage[] | typeof MessagesAnnotation.State): "tools" | typeof END;

package/dist/prebuilt/tool_node.js

@@ -135,6 +135,12 @@ export class ToolNode extends RunnableCallable {
             writable: true,
             value: true
         });
+        Object.defineProperty(this, "trace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         this.tools = tools;
         this.handleToolErrors = handleToolErrors ?? this.handleToolErrors;
     }

package/dist/pregel/algo.cjs

@@ -275,6 +275,7 @@ function _prepareSingleTask(taskPath, checkpoint, processes, channels, managed,
                     name: packet.node,
                     input: packet.args,
                     proc: node,
+                    subgraphs: proc.subgraphs,
                     writes,
                     config: (0, runnables_1.patchConfig)((0, runnables_1.mergeConfigs)(config, {
                         metadata,
@@ -371,6 +372,7 @@ function _prepareSingleTask(taskPath, checkpoint, processes, channels, managed,
                         name,
                         input: val,
                         proc: node,
+                        subgraphs: proc.subgraphs,
                         writes,
                         config: (0, runnables_1.patchConfig)((0, runnables_1.mergeConfigs)(config, {
                             metadata,

package/dist/pregel/algo.js

@@ -266,6 +266,7 @@ export function _prepareSingleTask(taskPath, checkpoint, processes, channels, ma
                     name: packet.node,
                     input: packet.args,
                     proc: node,
+                    subgraphs: proc.subgraphs,
                     writes,
                     config: patchConfig(mergeConfigs(config, {
                         metadata,
@@ -362,6 +363,7 @@ export function _prepareSingleTask(taskPath, checkpoint, processes, channels, ma
                         name,
                         input: val,
                         proc: node,
+                        subgraphs: proc.subgraphs,
                         writes,
                         config: patchConfig(mergeConfigs(config, {
                             metadata,

package/dist/pregel/debug.cjs

@@ -127,7 +127,8 @@ function* mapDebugCheckpoint(step, config, channels, streamChannels, metadata, t
     const parentNs = config.configurable?.checkpoint_ns;
     const taskStates = {};
     for (const task of tasks) {
-        if (!(0, subgraph_js_1.findSubgraphPregel)(task.proc))
+        const candidates = task.subgraphs?.length ? task.subgraphs : [task.proc];
+        if (!candidates.find(subgraph_js_1.findSubgraphPregel))
             continue;
         let taskNs = `${task.name}:${task.id}`;
         if (parentNs)

package/dist/pregel/debug.js

@@ -121,7 +121,8 @@ export function* mapDebugCheckpoint(step, config, channels, streamChannels, meta
     const parentNs = config.configurable?.checkpoint_ns;
     const taskStates = {};
     for (const task of tasks) {
-        if (!findSubgraphPregel(task.proc))
+        const candidates = task.subgraphs?.length ? task.subgraphs : [task.proc];
+        if (!candidates.find(findSubgraphPregel))
             continue;
         let taskNs = `${task.name}:${task.id}`;
         if (parentNs)

package/dist/pregel/index.cjs

@@ -255,26 +255,28 @@ class Pregel extends runnables_1.Runnable {
                     continue;
                 }
             }
-            const graph = (0, subgraph_js_1.findSubgraphPregel)(node.bound);
-            // if found, yield recursively
-            if (graph !== undefined) {
-                if (name === namespace) {
-                    yield [name, graph];
-                    return;
-                }
-                if (namespace === undefined) {
-                    yield [name, graph];
-                }
-                if (recurse) {
-                    let newNamespace = namespace;
-                    if (namespace !== undefined) {
-                        newNamespace = namespace.slice(name.length + 1);
+            const candidates = node.subgraphs?.length ? node.subgraphs : [node.bound];
+            for (const candidate of candidates) {
+                const graph = (0, subgraph_js_1.findSubgraphPregel)(candidate);
+                if (graph !== undefined) {
+                    if (name === namespace) {
+                        yield [name, graph];
+                        return;
                     }
-                    for (const [subgraphName, subgraph] of graph.getSubgraphs(newNamespace, recurse)) {
-                        yield [
-                            `${name}${constants_js_1.CHECKPOINT_NAMESPACE_SEPARATOR}${subgraphName}`,
-                            subgraph,
-                        ];
+                    if (namespace === undefined) {
+                        yield [name, graph];
+                    }
+                    if (recurse) {
+                        let newNamespace = namespace;
+                        if (namespace !== undefined) {
+                            newNamespace = namespace.slice(name.length + 1);
+                        }
+                        for (const [subgraphName, subgraph] of graph.getSubgraphs(newNamespace, recurse)) {
+                            yield [
+                                `${name}${constants_js_1.CHECKPOINT_NAMESPACE_SEPARATOR}${subgraphName}`,
+                                subgraph,
+                            ];
+                        }
                     }
                 }
             }
@@ -522,9 +524,10 @@ class Pregel extends runnables_1.Runnable {
         const task = {
             name: asNode,
             input: values,
-            proc: 
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            writers.length > 1 ? runnables_1.RunnableSequence.from(writers) : writers[0],
+            proc: writers.length > 1
+                ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    runnables_1.RunnableSequence.from(writers, { omitSequenceTags: true })
+                : writers[0],
             writes: [],
             triggers: [constants_js_1.INTERRUPT],
             id: (0, langgraph_checkpoint_1.uuid5)(constants_js_1.INTERRUPT, checkpoint.id),

package/dist/pregel/index.js

@@ -248,26 +248,28 @@ export class Pregel extends Runnable {
                     continue;
                 }
             }
-            const graph = findSubgraphPregel(node.bound);
-            // if found, yield recursively
-            if (graph !== undefined) {
-                if (name === namespace) {
-                    yield [name, graph];
-                    return;
-                }
-                if (namespace === undefined) {
-                    yield [name, graph];
-                }
-                if (recurse) {
-                    let newNamespace = namespace;
-                    if (namespace !== undefined) {
-                        newNamespace = namespace.slice(name.length + 1);
+            const candidates = node.subgraphs?.length ? node.subgraphs : [node.bound];
+            for (const candidate of candidates) {
+                const graph = findSubgraphPregel(candidate);
+                if (graph !== undefined) {
+                    if (name === namespace) {
+                        yield [name, graph];
+                        return;
                     }
-                    for (const [subgraphName, subgraph] of graph.getSubgraphs(newNamespace, recurse)) {
-                        yield [
-                            `${name}${CHECKPOINT_NAMESPACE_SEPARATOR}${subgraphName}`,
-                            subgraph,
-                        ];
+                    if (namespace === undefined) {
+                        yield [name, graph];
+                    }
+                    if (recurse) {
+                        let newNamespace = namespace;
+                        if (namespace !== undefined) {
+                            newNamespace = namespace.slice(name.length + 1);
+                        }
+                        for (const [subgraphName, subgraph] of graph.getSubgraphs(newNamespace, recurse)) {
+                            yield [
+                                `${name}${CHECKPOINT_NAMESPACE_SEPARATOR}${subgraphName}`,
+                                subgraph,
+                            ];
+                        }
                     }
                 }
             }
@@ -515,9 +517,10 @@ export class Pregel extends Runnable {
         const task = {
             name: asNode,
             input: values,
-            proc: 
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            writers.length > 1 ? RunnableSequence.from(writers) : writers[0],
+            proc: writers.length > 1
+                ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    RunnableSequence.from(writers, { omitSequenceTags: true })
+                : writers[0],
             writes: [],
             triggers: [INTERRUPT],
             id: uuid5(INTERRUPT, checkpoint.id),

package/dist/pregel/read.cjs

@@ -63,7 +63,7 @@ const defaultRunnableBound =
 /* #__PURE__ */ new runnables_1.RunnablePassthrough();
 class PregelNode extends runnables_1.RunnableBinding {
     constructor(fields) {
-        const { channels, triggers, mapper, writers, bound, kwargs, metadata, retryPolicy, tags, } = fields;
+        const { channels, triggers, mapper, writers, bound, kwargs, metadata, retryPolicy, tags, subgraphs, } = fields;
         const mergedTags = [
             ...(fields.config?.tags ? fields.config.tags : []),
             ...(tags ?? []),
@@ -139,6 +139,12 @@ class PregelNode extends runnables_1.RunnableBinding {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "subgraphs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.channels = channels;
         this.triggers = triggers;
         this.mapper = mapper;
@@ -148,6 +154,7 @@ class PregelNode extends runnables_1.RunnableBinding {
         this.metadata = metadata ?? this.metadata;
         this.tags = mergedTags;
         this.retryPolicy = retryPolicy;
+        this.subgraphs = subgraphs;
     }
     getWriters() {
         const newWriters = [...this.writers];
@@ -178,6 +185,7 @@ class PregelNode extends runnables_1.RunnableBinding {
                 first: writers[0],
                 middle: writers.slice(1, writers.length - 1),
                 last: writers[writers.length - 1],
+                omitSequenceTags: true,
             });
         }
         else if (writers.length > 0) {
@@ -185,6 +193,7 @@ class PregelNode extends runnables_1.RunnableBinding {
                 first: this.bound,
                 middle: writers.slice(0, writers.length - 1),
                 last: writers[writers.length - 1],
+                omitSequenceTags: true,
             });
         }
         else {

package/dist/pregel/read.d.ts

@@ -20,6 +20,7 @@ interface PregelNodeArgs<RunInput, RunOutput> extends Partial<RunnableBindingArg
     config?: RunnableConfig;
     metadata?: Record<string, unknown>;
     retryPolicy?: RetryPolicy;
+    subgraphs?: Runnable[];
 }
 export type PregelNodeInputType = any;
 export type PregelNodeOutputType = any;
@@ -34,6 +35,7 @@ export declare class PregelNode<RunInput = PregelNodeInputType, RunOutput = Preg
     metadata: Record<string, unknown>;
     tags: string[];
     retryPolicy?: RetryPolicy;
+    subgraphs?: Runnable[];
     constructor(fields: PregelNodeArgs<RunInput, RunOutput>);
     getWriters(): Array<Runnable>;
     getNode(): Runnable<RunInput, RunOutput> | undefined;

package/dist/pregel/read.js

@@ -59,7 +59,7 @@ const defaultRunnableBound =
 /* #__PURE__ */ new RunnablePassthrough();
 export class PregelNode extends RunnableBinding {
     constructor(fields) {
-        const { channels, triggers, mapper, writers, bound, kwargs, metadata, retryPolicy, tags, } = fields;
+        const { channels, triggers, mapper, writers, bound, kwargs, metadata, retryPolicy, tags, subgraphs, } = fields;
         const mergedTags = [
             ...(fields.config?.tags ? fields.config.tags : []),
             ...(tags ?? []),
@@ -135,6 +135,12 @@ export class PregelNode extends RunnableBinding {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "subgraphs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.channels = channels;
         this.triggers = triggers;
         this.mapper = mapper;
@@ -144,6 +150,7 @@ export class PregelNode extends RunnableBinding {
         this.metadata = metadata ?? this.metadata;
         this.tags = mergedTags;
         this.retryPolicy = retryPolicy;
+        this.subgraphs = subgraphs;
     }
     getWriters() {
         const newWriters = [...this.writers];
@@ -174,6 +181,7 @@ export class PregelNode extends RunnableBinding {
                 first: writers[0],
                 middle: writers.slice(1, writers.length - 1),
                 last: writers[writers.length - 1],
+                omitSequenceTags: true,
             });
         }
         else if (writers.length > 0) {
@@ -181,6 +189,7 @@ export class PregelNode extends RunnableBinding {
                 first: this.bound,
                 middle: writers.slice(0, writers.length - 1),
                 last: writers[writers.length - 1],
+                omitSequenceTags: true,
             });
         }
         else {

package/dist/pregel/types.d.ts

@@ -71,6 +71,7 @@ export interface PregelExecutableTask<N extends PropertyKey, C extends PropertyK
     readonly retry_policy?: RetryPolicy;
     readonly id: string;
     readonly path?: [string, ...(string | number)[]];
+    readonly subgraphs?: Runnable[];
 }
 export interface StateSnapshot {
     /**

package/dist/pregel/utils/subgraph.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findSubgraphPregel = void 0;
+exports.findSubgraphPregel = exports.isPregelLike = void 0;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function isRunnableSequence(x) {
     return "steps" in x && Array.isArray(x.steps);
@@ -15,6 +15,7 @@ x
         "outputChannels" &&
         x.outputChannels !== undefined);
 }
+exports.isPregelLike = isPregelLike;
 function findSubgraphPregel(candidate
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ) {

package/dist/pregel/utils/subgraph.d.ts

@@ -1,3 +1,4 @@
-import { Runnable } from "@langchain/core/runnables";
+import { Runnable, RunnableLike } from "@langchain/core/runnables";
 import type { PregelInterface } from "../types.js";
+export declare function isPregelLike(x: PregelInterface<any, any> | RunnableLike<any, any, any>): x is PregelInterface<any, any>;
 export declare function findSubgraphPregel(candidate: Runnable): PregelInterface<any, any> | undefined;

package/dist/pregel/utils/subgraph.js

@@ -2,7 +2,7 @@
 function isRunnableSequence(x) {
     return "steps" in x && Array.isArray(x.steps);
 }
-function isPregelLike(
+export function isPregelLike(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 x
 // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/pregel/write.cjs

@@ -88,6 +88,7 @@ class ChannelWrite extends utils_js_1.RunnableCallable {
     async _write(input, config) {
         const values = await this._getWriteValues(input, config);
         ChannelWrite.doWrite(config, values);
+        return input;
     }
     // TODO: Support requireAtLeastOneOf
     static doWrite(config, values) {

package/dist/pregel/write.d.ts

@@ -15,9 +15,9 @@ export declare class ChannelWrite<RunInput = any> extends RunnableCallable {
     writes: Array<ChannelWriteEntry | Send>;
     constructor(writes: Array<ChannelWriteEntry | Send>, tags?: string[]);
     _getWriteValues(input: unknown, config: RunnableConfig): Promise<[string, unknown][]>;
-    _write(input: unknown, config: RunnableConfig): Promise<void>;
+    _write(input: unknown, config: RunnableConfig): Promise<unknown>;
     static doWrite(config: RunnableConfig, values: [string, unknown][]): void;
-    static isWriter(runnable: RunnableLike): boolean;
+    static isWriter(runnable: RunnableLike): runnable is ChannelWrite;
     static registerWriter<T extends Runnable>(runnable: T): T;
 }
 export interface ChannelWriteEntry {

package/dist/pregel/write.js

@@ -85,6 +85,7 @@ export class ChannelWrite extends RunnableCallable {
     async _write(input, config) {
         const values = await this._getWriteValues(input, config);
         ChannelWrite.doWrite(config, values);
+        return input;
     }
     // TODO: Support requireAtLeastOneOf
     static doWrite(config, values) {

package/dist/utils.cjs

@@ -74,14 +74,15 @@ class RunnableCallable extends runnables_1.Runnable {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let returnValue;
         const config = (0, config_js_1.ensureLangGraphConfig)(options);
+        const mergedConfig = (0, runnables_1.mergeConfigs)(this.config, config);
         if (this.trace) {
-            returnValue = await this._callWithConfig(this._tracedInvoke, input, (0, runnables_1.mergeConfigs)(this.config, config));
+            returnValue = await this._callWithConfig(this._tracedInvoke, input, mergedConfig);
         }
         else {
-            returnValue = await this.func(input, (0, runnables_1.mergeConfigs)(this.config, config));
+            returnValue = await singletons_1.AsyncLocalStorageProviderSingleton.runWithConfig(mergedConfig, async () => this.func(input, mergedConfig));
         }
         if (runnables_1.Runnable.isRunnable(returnValue) && this.recurse) {
-            return await returnValue.invoke(input, config);
+            return await singletons_1.AsyncLocalStorageProviderSingleton.runWithConfig(mergedConfig, async () => returnValue.invoke(input, mergedConfig));
         }
         return returnValue;
     }

package/dist/utils.js

@@ -71,14 +71,15 @@ export class RunnableCallable extends Runnable {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let returnValue;
         const config = ensureLangGraphConfig(options);
+        const mergedConfig = mergeConfigs(this.config, config);
         if (this.trace) {
-            returnValue = await this._callWithConfig(this._tracedInvoke, input, mergeConfigs(this.config, config));
+            returnValue = await this._callWithConfig(this._tracedInvoke, input, mergedConfig);
         }
         else {
-            returnValue = await this.func(input, mergeConfigs(this.config, config));
+            returnValue = await AsyncLocalStorageProviderSingleton.runWithConfig(mergedConfig, async () => this.func(input, mergedConfig));
         }
         if (Runnable.isRunnable(returnValue) && this.recurse) {
-            return await returnValue.invoke(input, config);
+            return await AsyncLocalStorageProviderSingleton.runWithConfig(mergedConfig, async () => returnValue.invoke(input, mergedConfig));
         }
         return returnValue;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph",
-  "version": "0.2.16",
+  "version": "0.2.18-rc.0",
   "description": "LangGraph",
   "type": "module",
   "engines": {
@@ -43,7 +43,7 @@
     "@jest/globals": "^29.5.0",
     "@langchain/anthropic": "^0.3.0",
     "@langchain/community": "^0.3.0",
-    "@langchain/core": "^0.3.10",
+    "@langchain/core": "^0.3.14",
     "@langchain/langgraph-checkpoint-postgres": "workspace:*",
     "@langchain/langgraph-checkpoint-sqlite": "workspace:*",
     "@langchain/openai": "^0.3.0",