@langchain/langgraph 0.0.22 → 0.0.24

package/README.md

@@ -46,7 +46,7 @@ And now we're ready! The graph below contains a single node called `"oracle"` th
 ```ts
 import { ChatOpenAI } from "@langchain/openai";
 import { HumanMessage, BaseMessage, } from "@langchain/core/messages";
-import { END, MessageGraph } from "@langchain/langgraph";
+import { START, END, MessageGraph } from "@langchain/langgraph";
 
 const model = new ChatOpenAI({ temperature: 0 });
 
@@ -58,7 +58,7 @@ graph.addNode("oracle", async (state: BaseMessage[]) => {
 
 graph.addEdge("oracle", END);
 
-graph.setEntryPoint("oracle");
+graph.addEdge(START, "oracle");
 
 const runnable = graph.compile();
 ```
@@ -90,7 +90,7 @@ So what did we do here? Let's break it down step by step:
 1. First, we initialize our model and a `MessageGraph`.
 2. Next, we add a single node to the graph, called `"oracle"`, which simply calls the model with the given input.
 3. We add an edge from this `"oracle"` node to the special value `END`. This means that execution will end after current node.
-4. We set `"oracle"` as the entrypoint to the graph.
+4. We set `"oracle"` as the entrypoint to the graph by adding an edge from the special `START` value to it.
 5. We compile the graph, ensuring that no more modifications to it can be made.
 
 Then, when we execute the graph:
@@ -185,7 +185,7 @@ graph.addNode("calculator", async (state: BaseMessage[]) => {
 
 graph.addEdge("calculator", END);
 
-graph.setEntryPoint("oracle");
+graph.addEdge(START, "oracle");
 ```
 
 Now let's think - what do we want to have happen?
@@ -477,7 +477,7 @@ const callTool = async (
 We can now put it all together and define the graph!
 
 ```typescript
-import { StateGraph, END } from "@langchain/langgraph";
+import { StateGraph, START, END } from "@langchain/langgraph";
 import { RunnableLambda } from "@langchain/core/runnables";
 
 // Define a new graph
@@ -491,7 +491,7 @@ workflow.addNode("action", callTool);
 
 // Set the entrypoint as `agent`
 // This means that this node is the first one called
-workflow.setEntryPoint("agent");
+workflow.addEdge(START, "agent");
 
 // We now add a conditional edge
 workflow.addConditionalEdges(
@@ -723,31 +723,14 @@ This takes three arguments:
 - `condition`: A function to call to decide what to do next. The input will be the output of the start node. It should return a string that is present in `conditionalEdgeMapping` and represents the edge to take.
 - `conditionalEdgeMapping`: A mapping of string to string. The keys should be strings that may be returned by `condition`. The values should be the downstream node to call if that condition is returned.
 
-### `.setEntryPoint`
+### `START`
 
 ```typescript
-setEntryPoint(key: string): void
+import { START } from "@langchain/langgraph";
 ```
 
-The entrypoint to the graph.
-This is the node that is first called.
-It only takes one argument:
-
-- `key`: The name of the node that should be called first.
-
-### `.setFinishPoint`
-
-```typescript
-setFinishPoint(key: string): void
-```
-
-This is the exit point of the graph.
-When this node is called, the results will be the final result from the graph.
-It only has one argument:
-
-- `key`: The name of the node that, when called, will return the results of calling it as the final output
-
-Note: This does not need to be called if at any point you previously created an edge (conditional or normal) to `END`
+This is a special node representing the start of the graph.
+This means that anything with an edge from this node will be the entrypoint of the graph.
 
 ### `END`
 
@@ -827,7 +810,7 @@ workflow.addNode("agent", agent);
 workflow.addNode("tools", executeTools);
 
 // We now set the entry point to be this first agent
-workflow.setEntryPoint("firstAgent");
+workflow.addEdge(START, "firstAgent");
 
 // We define the same edges as before
 workflow.addConditionalEdges("agent", shouldContinue, {

package/dist/graph/graph.d.ts

@@ -19,7 +19,7 @@ export declare class Branch<IO, N extends string> {
     compile(writer: (dests: string[]) => Runnable | undefined, reader?: (config: RunnableConfig) => IO): RunnableCallable<unknown, unknown>;
     _route(input: IO, config: RunnableConfig, writer: (dests: string[]) => Runnable | undefined, reader?: (config: RunnableConfig) => IO): Promise<Runnable | undefined>;
 }
-export declare class Graph<const N extends string = typeof END, RunInput = any, RunOutput = any> {
+export declare class Graph<N extends string = typeof END, RunInput = any, RunOutput = any> {
     nodes: Record<N, Runnable<RunInput, RunOutput>>;
     edges: Set<[N | typeof START, N | typeof END]>;
     branches: Record<string, Record<string, Branch<RunInput, N>>>;

package/dist/graph/state.d.ts

@@ -24,7 +24,7 @@ export interface StateGraphArgs<Channels extends object | unknown> {
         __root__: Channels;
     }>;
 }
-export declare class StateGraph<const State extends object | unknown, const Update extends object | unknown = Partial<State>, const N extends string = typeof START> extends Graph<N, State, Update> {
+export declare class StateGraph<State extends object | unknown, Update extends object | unknown = Partial<State>, N extends string = typeof START> extends Graph<N, State, Update> {
     channels: Record<string, BaseChannel>;
     waitingEdges: Set<[N[], N]>;
     constructor(fields: StateGraphArgs<State>);
@@ -37,7 +37,7 @@ export declare class StateGraph<const State extends object | unknown, const Upda
         interruptAfter?: N[] | All;
     }): CompiledStateGraph<State, Update, N>;
 }
-export declare class CompiledStateGraph<const State extends object | unknown, const Update extends object | unknown = Partial<State>, const N extends string = typeof START> extends CompiledGraph<N, State, Update> {
+export declare class CompiledStateGraph<State extends object | unknown, Update extends object | unknown = Partial<State>, N extends string = typeof START> extends CompiledGraph<N, State, Update> {
     builder: StateGraph<State, Update, N>;
     attachNode(key: typeof START, node?: never): void;
     attachNode(key: N, node: Runnable<State, Update, RunnableConfig>): void;

package/dist/index.cjs

@@ -1,20 +1,20 @@
 "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 });
-exports.EmptyChannelError = exports.InvalidUpdateError = exports.GraphValueError = exports.GraphRecursionError = exports.BaseCheckpointSaver = exports.emptyCheckpoint = exports.copyCheckpoint = exports.MemorySaver = exports.MessageGraph = exports.StateGraph = exports.START = exports.Graph = exports.END = void 0;
-var index_js_1 = require("./graph/index.cjs");
-Object.defineProperty(exports, "END", { enumerable: true, get: function () { return index_js_1.END; } });
-Object.defineProperty(exports, "Graph", { enumerable: true, get: function () { return index_js_1.Graph; } });
-Object.defineProperty(exports, "START", { enumerable: true, get: function () { return index_js_1.START; } });
-Object.defineProperty(exports, "StateGraph", { enumerable: true, get: function () { return index_js_1.StateGraph; } });
-Object.defineProperty(exports, "MessageGraph", { enumerable: true, get: function () { return index_js_1.MessageGraph; } });
-var memory_js_1 = require("./checkpoint/memory.cjs");
-Object.defineProperty(exports, "MemorySaver", { enumerable: true, get: function () { return memory_js_1.MemorySaver; } });
-var base_js_1 = require("./checkpoint/base.cjs");
-Object.defineProperty(exports, "copyCheckpoint", { enumerable: true, get: function () { return base_js_1.copyCheckpoint; } });
-Object.defineProperty(exports, "emptyCheckpoint", { enumerable: true, get: function () { return base_js_1.emptyCheckpoint; } });
-Object.defineProperty(exports, "BaseCheckpointSaver", { enumerable: true, get: function () { return base_js_1.BaseCheckpointSaver; } });
-var errors_js_1 = require("./errors.cjs");
-Object.defineProperty(exports, "GraphRecursionError", { enumerable: true, get: function () { return errors_js_1.GraphRecursionError; } });
-Object.defineProperty(exports, "GraphValueError", { enumerable: true, get: function () { return errors_js_1.GraphValueError; } });
-Object.defineProperty(exports, "InvalidUpdateError", { enumerable: true, get: function () { return errors_js_1.InvalidUpdateError; } });
-Object.defineProperty(exports, "EmptyChannelError", { enumerable: true, get: function () { return errors_js_1.EmptyChannelError; } });
+const async_local_storage_js_1 = require("./setup/async_local_storage.cjs");
+// Initialize global async local storage instance for tracing
+/* #__PURE__ */ (0, async_local_storage_js_1.initializeAsyncLocalStorageSingleton)();
+__exportStar(require("./web.cjs"), exports);

package/dist/index.d.ts

@@ -1,4 +1 @@
-export { END, Graph, type StateGraphArgs, START, StateGraph, type CompiledStateGraph, MessageGraph, } from "./graph/index.js";
-export { MemorySaver } from "./checkpoint/memory.js";
-export { type Checkpoint, type CheckpointMetadata, copyCheckpoint, emptyCheckpoint, BaseCheckpointSaver, } from "./checkpoint/base.js";
-export { GraphRecursionError, GraphValueError, InvalidUpdateError, EmptyChannelError, } from "./errors.js";
+export * from "./web.js";

package/dist/index.js

@@ -1,4 +1,4 @@
-export { END, Graph, START, StateGraph, MessageGraph, } from "./graph/index.js";
-export { MemorySaver } from "./checkpoint/memory.js";
-export { copyCheckpoint, emptyCheckpoint, BaseCheckpointSaver, } from "./checkpoint/base.js";
-export { GraphRecursionError, GraphValueError, InvalidUpdateError, EmptyChannelError, } from "./errors.js";
+import { initializeAsyncLocalStorageSingleton } from "./setup/async_local_storage.js";
+// Initialize global async local storage instance for tracing
+/* #__PURE__ */ initializeAsyncLocalStorageSingleton();
+export * from "./web.js";

package/dist/prebuilt/agent_executor.cjs

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAgentExecutor = void 0;
 const tool_executor_js_1 = require("./tool_executor.cjs");
 const state_js_1 = require("../graph/state.cjs");
-const index_js_1 = require("../index.cjs");
+const index_js_1 = require("../graph/index.cjs");
 function createAgentExecutor({ agentRunnable, tools, }) {
     let toolExecutor;
     if (!Array.isArray(tools)) {

package/dist/prebuilt/agent_executor.d.ts

@@ -16,5 +16,5 @@ export interface AgentExecutorState {
 export declare function createAgentExecutor({ agentRunnable, tools, }: {
     agentRunnable: Runnable;
     tools: Array<Tool> | ToolExecutor;
-}): import("../index.js").CompiledStateGraph<AgentExecutorState, Partial<AgentExecutorState>, "__start__" | "agent" | "action">;
+}): import("../graph/state.js").CompiledStateGraph<AgentExecutorState, Partial<AgentExecutorState>, "__start__" | "agent" | "action">;
 export {};

package/dist/prebuilt/agent_executor.js

@@ -1,6 +1,6 @@
 import { ToolExecutor } from "./tool_executor.js";
 import { StateGraph } from "../graph/state.js";
-import { END, START } from "../index.js";
+import { END, START } from "../graph/index.js";
 export function createAgentExecutor({ agentRunnable, tools, }) {
     let toolExecutor;
     if (!Array.isArray(tools)) {

package/dist/prebuilt/chat_agent_executor.cjs

@@ -6,7 +6,7 @@ const messages_1 = require("@langchain/core/messages");
 const runnables_1 = require("@langchain/core/runnables");
 const tool_executor_js_1 = require("./tool_executor.cjs");
 const state_js_1 = require("../graph/state.cjs");
-const index_js_1 = require("../index.cjs");
+const index_js_1 = require("../graph/index.cjs");
 function createFunctionCallingExecutor({ model, tools, }) {
     let toolExecutor;
     let toolClasses;
@@ -26,7 +26,6 @@ function createFunctionCallingExecutor({ model, tools, }) {
     const toolsAsOpenAIFunctions = toolClasses.map((tool) => (0, function_calling_1.convertToOpenAIFunction)(tool));
     const newModel = model.bind({
         functions: toolsAsOpenAIFunctions,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
     });
     // Define the function that determines whether to continue or not
     const shouldContinue = (state) => {

package/dist/prebuilt/chat_agent_executor.d.ts

@@ -2,7 +2,7 @@ import { StructuredTool } from "@langchain/core/tools";
 import { BaseMessage } from "@langchain/core/messages";
 import { ToolExecutor } from "./tool_executor.js";
 import { CompiledStateGraph } from "../graph/state.js";
-import { START } from "../index.js";
+import { START } from "../graph/index.js";
 export type FunctionCallingExecutorState = {
     messages: Array<BaseMessage>;
 };

package/dist/prebuilt/chat_agent_executor.js

@@ -3,7 +3,7 @@ import { FunctionMessage } from "@langchain/core/messages";
 import { RunnableLambda } from "@langchain/core/runnables";
 import { ToolExecutor } from "./tool_executor.js";
 import { StateGraph, } from "../graph/state.js";
-import { END, START } from "../index.js";
+import { END, START } from "../graph/index.js";
 export function createFunctionCallingExecutor({ model, tools, }) {
     let toolExecutor;
     let toolClasses;
@@ -23,7 +23,6 @@ export function createFunctionCallingExecutor({ model, tools, }) {
     const toolsAsOpenAIFunctions = toolClasses.map((tool) => convertToOpenAIFunction(tool));
     const newModel = model.bind({
         functions: toolsAsOpenAIFunctions,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
     });
     // Define the function that determines whether to continue or not
     const shouldContinue = (state) => {

package/dist/prebuilt/react_agent_executor.cjs

@@ -48,15 +48,15 @@ function createReactAgent(props) {
             return "continue";
         }
     };
-    const callModel = async (state) => {
+    const callModel = async (state, config) => {
         const { messages } = state;
         // TODO: Auto-promote streaming.
-        return { messages: [await modelRunnable.invoke(messages)] };
+        return { messages: [await modelRunnable.invoke(messages, config)] };
     };
     const workflow = new index_js_1.StateGraph({
         channels: schema,
     })
-        .addNode("agent", new runnables_1.RunnableLambda({ func: callModel }).withConfig({ runName: "agent" }))
+        .addNode("agent", runnables_1.RunnableLambda.from(callModel).withConfig({ runName: "agent" }))
         .addNode("tools", new tool_node_js_1.ToolNode(toolClasses))
         .addEdge(index_js_1.START, "agent")
         .addConditionalEdges("agent", shouldContinue, {
@@ -75,9 +75,9 @@ function _createModelWrapper(modelWithTools, messageModifier) {
     if (!messageModifier) {
         return modelWithTools;
     }
-    const endict = new runnables_1.RunnableLambda({
-        func: (messages) => ({ messages }),
-    });
+    const endict = runnables_1.RunnableLambda.from((messages) => ({
+        messages,
+    }));
     if (typeof messageModifier === "string") {
         const systemMessage = new messages_1.SystemMessage(messageModifier);
         const prompt = prompts_1.ChatPromptTemplate.fromMessages([
@@ -87,7 +87,7 @@ function _createModelWrapper(modelWithTools, messageModifier) {
         return endict.pipe(prompt).pipe(modelWithTools);
     }
     if (typeof messageModifier === "function") {
-        const lambda = new runnables_1.RunnableLambda({ func: messageModifier }).withConfig({
+        const lambda = runnables_1.RunnableLambda.from(messageModifier).withConfig({
             runName: "message_modifier",
         });
         return lambda.pipe(modelWithTools);

package/dist/prebuilt/react_agent_executor.js

@@ -45,15 +45,15 @@ export function createReactAgent(props) {
             return "continue";
         }
     };
-    const callModel = async (state) => {
+    const callModel = async (state, config) => {
         const { messages } = state;
         // TODO: Auto-promote streaming.
-        return { messages: [await modelRunnable.invoke(messages)] };
+        return { messages: [await modelRunnable.invoke(messages, config)] };
     };
     const workflow = new StateGraph({
         channels: schema,
     })
-        .addNode("agent", new RunnableLambda({ func: callModel }).withConfig({ runName: "agent" }))
+        .addNode("agent", RunnableLambda.from(callModel).withConfig({ runName: "agent" }))
         .addNode("tools", new ToolNode(toolClasses))
         .addEdge(START, "agent")
         .addConditionalEdges("agent", shouldContinue, {
@@ -71,9 +71,9 @@ function _createModelWrapper(modelWithTools, messageModifier) {
     if (!messageModifier) {
         return modelWithTools;
     }
-    const endict = new RunnableLambda({
-        func: (messages) => ({ messages }),
-    });
+    const endict = RunnableLambda.from((messages) => ({
+        messages,
+    }));
     if (typeof messageModifier === "string") {
         const systemMessage = new SystemMessage(messageModifier);
         const prompt = ChatPromptTemplate.fromMessages([
@@ -83,7 +83,7 @@ function _createModelWrapper(modelWithTools, messageModifier) {
         return endict.pipe(prompt).pipe(modelWithTools);
     }
     if (typeof messageModifier === "function") {
-        const lambda = new RunnableLambda({ func: messageModifier }).withConfig({
+        const lambda = RunnableLambda.from(messageModifier).withConfig({
             runName: "message_modifier",
         });
         return lambda.pipe(modelWithTools);

package/dist/prebuilt/tool_executor.cjs

@@ -9,9 +9,7 @@ class ToolExecutor extends runnables_1.RunnableBinding {
             invalidToolMsgTemplate: INVALID_TOOL_MSG_TEMPLATE,
             ...fields,
         };
-        const bound = new runnables_1.RunnableLambda({
-            func: async (input, options) => this._execute(input, options?.config),
-        });
+        const bound = runnables_1.RunnableLambda.from(async (input, config) => this._execute(input, config));
         super({
             bound,
             config: {},

package/dist/prebuilt/tool_executor.js

@@ -6,9 +6,7 @@ export class ToolExecutor extends RunnableBinding {
             invalidToolMsgTemplate: INVALID_TOOL_MSG_TEMPLATE,
             ...fields,
         };
-        const bound = new RunnableLambda({
-            func: async (input, options) => this._execute(input, options?.config),
-        });
+        const bound = RunnableLambda.from(async (input, config) => this._execute(input, config));
         super({
             bound,
             config: {},

package/dist/pregel/index.cjs

@@ -11,7 +11,6 @@ const validate_js_1 = require("./validate.cjs");
 const io_js_1 = require("./io.cjs");
 const write_js_1 = require("./write.cjs");
 const constants_js_1 = require("../constants.cjs");
-const async_local_storage_js_1 = require("../setup/async_local_storage.cjs");
 const errors_js_1 = require("../errors.cjs");
 const DEFAULT_LOOP_LIMIT = 25;
 function isString(value) {
@@ -157,8 +156,6 @@ class Pregel extends runnables_1.Runnable {
             writable: true,
             value: void 0
         });
-        // Initialize global async local storage instance for tracing
-        (0, async_local_storage_js_1.initializeAsyncLocalStorageSingleton)();
         this.nodes = fields.nodes;
         this.channels = fields.channels;
         this.autoValidate = fields.autoValidate ?? this.autoValidate;

package/dist/pregel/index.d.ts

@@ -66,7 +66,7 @@ export interface PregelOptions<Nn extends StrRecord<string, PregelNode>, Cc exte
 }
 export type PregelInputType = any;
 export type PregelOutputType = any;
-export declare class Pregel<const Nn extends StrRecord<string, PregelNode>, const Cc extends StrRecord<string, BaseChannel>> extends Runnable<PregelInputType, PregelOutputType, PregelOptions<Nn, Cc>> implements PregelInterface<Nn, Cc> {
+export declare class Pregel<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>> extends Runnable<PregelInputType, PregelOutputType, PregelOptions<Nn, Cc>> implements PregelInterface<Nn, Cc> {
     static lc_name(): string;
     lc_namespace: string[];
     nodes: Nn;

package/dist/pregel/index.js

@@ -8,7 +8,6 @@ import { validateGraph, validateKeys } from "./validate.js";
 import { mapInput, mapOutputUpdates, mapOutputValues, readChannel, readChannels, single, } from "./io.js";
 import { ChannelWrite, PASSTHROUGH } from "./write.js";
 import { CONFIG_KEY_READ, CONFIG_KEY_SEND, INTERRUPT, TAG_HIDDEN, } from "../constants.js";
-import { initializeAsyncLocalStorageSingleton } from "../setup/async_local_storage.js";
 import { EmptyChannelError, GraphRecursionError, GraphValueError, InvalidUpdateError, } from "../errors.js";
 const DEFAULT_LOOP_LIMIT = 25;
 function isString(value) {
@@ -153,8 +152,6 @@ export class Pregel extends Runnable {
             writable: true,
             value: void 0
         });
-        // Initialize global async local storage instance for tracing
-        initializeAsyncLocalStorageSingleton();
         this.nodes = fields.nodes;
         this.channels = fields.channels;
         this.autoValidate = fields.autoValidate ?? this.autoValidate;

package/dist/tests/chatbot.int.test.js

@@ -1,16 +1,21 @@
-import { describe, it } from "@jest/globals";
+import { beforeAll, describe, it } from "@jest/globals";
 import { ChatOpenAI } from "@langchain/openai";
 import { HumanMessage, ToolMessage, } from "@langchain/core/messages";
 import { Calculator } from "@langchain/community/tools/calculator";
 import { convertToOpenAITool } from "@langchain/core/utils/function_calling";
 import { END, MessageGraph, START } from "../index.js";
+import { initializeAsyncLocalStorageSingleton } from "../setup/async_local_storage.js";
 describe("Chatbot", () => {
+    beforeAll(() => {
+        // Will occur naturally if user imports from main `@langchain/langgraph` endpoint.
+        initializeAsyncLocalStorageSingleton();
+    });
     it("Simple chat use-case", async () => {
         const model = new ChatOpenAI({ temperature: 0 });
         const graph = new MessageGraph()
             .addNode("oracle", async (state) => model.invoke(state))
             .addEdge("oracle", END)
-            .setEntryPoint("oracle")
+            .addEdge(START, "oracle")
             .compile();
         const res = await graph.invoke(new HumanMessage("What is 1 + 1?"));
         console.log(res);

package/dist/tests/prebuilt.int.test.js

@@ -4,12 +4,15 @@ import { Tool } from "@langchain/core/tools";
 import { ChatOpenAI } from "@langchain/openai";
 import { HumanMessage } from "@langchain/core/messages";
 import { createReactAgent, createFunctionCallingExecutor, } from "../prebuilt/index.js";
+import { initializeAsyncLocalStorageSingleton } from "../setup/async_local_storage.js";
 // Tracing slows down the tests
 beforeAll(() => {
-    process.env.LANGCHAIN_TRACING_V2 = "false";
-    process.env.LANGCHAIN_ENDPOINT = "";
-    process.env.LANGCHAIN_API_KEY = "";
-    process.env.LANGCHAIN_PROJECT = "";
+    // process.env.LANGCHAIN_TRACING_V2 = "false";
+    // process.env.LANGCHAIN_ENDPOINT = "";
+    // process.env.LANGCHAIN_API_KEY = "";
+    // process.env.LANGCHAIN_PROJECT = "";
+    // Will occur naturally if user imports from main `@langchain/langgraph` endpoint.
+    initializeAsyncLocalStorageSingleton();
 });
 describe("createFunctionCallingExecutor", () => {
     it("can call a function", async () => {

package/dist/tests/prebuilt.test.d.ts

@@ -1,20 +1 @@
-import { Tool } from "@langchain/core/tools";
-import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
-import { BaseChatModel } from "@langchain/core/language_models/chat_models";
-import { BaseLLMParams } from "@langchain/core/language_models/llms";
-import { BaseMessage } from "@langchain/core/messages";
-import { ChatResult } from "@langchain/core/outputs";
-export declare class FakeToolCallingChatModel extends BaseChatModel {
-    sleep?: number;
-    responses?: BaseMessage[];
-    thrownErrorString?: string;
-    idx: number;
-    constructor(fields: {
-        sleep?: number;
-        responses?: BaseMessage[];
-        thrownErrorString?: string;
-    } & BaseLLMParams);
-    _llmType(): string;
-    _generate(messages: BaseMessage[], _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
-    bindTools(_: Tool[]): FakeToolCallingChatModel;
-}
+export {};

package/dist/tests/prebuilt.test.js

@@ -3,10 +3,10 @@ import { beforeAll, describe, expect, it } from "@jest/globals";
 import { PromptTemplate } from "@langchain/core/prompts";
 import { StructuredTool, Tool } from "@langchain/core/tools";
 import { FakeStreamingLLM } from "@langchain/core/utils/testing";
-import { BaseChatModel } from "@langchain/core/language_models/chat_models";
 import { AIMessage, HumanMessage, SystemMessage, ToolMessage, } from "@langchain/core/messages";
 import { RunnableLambda } from "@langchain/core/runnables";
 import { z } from "zod";
+import { FakeToolCallingChatModel } from "./utils.js";
 import { createAgentExecutor, createReactAgent } from "../prebuilt/index.js";
 // Tracing slows down the tests
 beforeAll(() => {
@@ -197,65 +197,6 @@ describe("PreBuilt", () => {
         ]);
     });
 });
-export class FakeToolCallingChatModel extends BaseChatModel {
-    constructor(fields) {
-        super(fields);
-        Object.defineProperty(this, "sleep", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 50
-        });
-        Object.defineProperty(this, "responses", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "thrownErrorString", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "idx", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.sleep = fields.sleep ?? this.sleep;
-        this.responses = fields.responses;
-        this.thrownErrorString = fields.thrownErrorString;
-        this.idx = 0;
-    }
-    _llmType() {
-        return "fake";
-    }
-    async _generate(messages, _options, _runManager) {
-        if (this.thrownErrorString) {
-            throw new Error(this.thrownErrorString);
-        }
-        const msg = this.responses?.[this.idx] ?? messages[this.idx];
-        const generation = {
-            generations: [
-                {
-                    text: "",
-                    message: msg,
-                },
-            ],
-        };
-        this.idx += 1;
-        return generation;
-    }
-    bindTools(_) {
-        return new FakeToolCallingChatModel({
-            sleep: this.sleep,
-            responses: this.responses,
-            thrownErrorString: this.thrownErrorString,
-        });
-    }
-}
 describe("createReactAgent", () => {
     const searchSchema = z.object({
         query: z.string().describe("The query to search for."),

package/dist/tests/pregel.io.test.js

@@ -269,7 +269,7 @@ describe("mapOutputUpdates", () => {
                 input: null,
                 proc: new RunnablePassthrough(),
                 // @ts-expect-error invalid write
-                writes: [["someOutputChannelNameThatDoesntMatch", 3]], // this task should be filtered out
+                writes: [["someOutputChannelNameThatDoesntMatch", 3]],
                 config: undefined,
             },
         ];

package/dist/tests/pregel.test.js

@@ -155,21 +155,21 @@ describe("Pregel", () => {
             });
             // call method / assertions
             const expectedDefaults1 = [
-                false, // debug
-                "values", // stream mode
-                "outputKey", // input keys
-                ["inputKey", "outputKey", "channel3"], // output keys,
+                false,
+                "values",
+                "outputKey",
+                ["inputKey", "outputKey", "channel3"],
                 {},
-                ["one"], // interrupt before
+                ["one"],
                 ["one"], // interrupt after
             ];
             const expectedDefaults2 = [
-                true, // debug
-                "updates", // stream mode
-                "inputKey", // input keys
-                "outputKey", // output keys
+                true,
+                "updates",
+                "inputKey",
+                "outputKey",
                 { tags: ["hello"] },
-                "*", // interrupt before
+                "*",
                 ["one"], // interrupt after
             ];
             expect(pregel._defaults(config1)).toEqual(expectedDefaults1);
@@ -290,7 +290,7 @@ describe("_shouldInterrupt", () => {
         // call method / assertions
         expect(_shouldInterrupt(checkpoint, interruptNodes, snapshotChannels, [
             {
-                name: "node2", // node2 is not in interrupt nodes
+                name: "node2",
                 input: undefined,
                 proc: new RunnablePassthrough(),
                 writes: [],

package/dist/tests/pregel.write.test.js

@@ -34,7 +34,7 @@ describe("ChannelWrite", () => {
             const writeValues = await channelWrite._getWriteValues(input, config);
             const expectedWriteValues = {
                 someChannel1: 1,
-                someChannel2: 2, // value is set to input value since PASSTHROUGH value was specified (with mapper)
+                someChannel2: 2,
                 // someChannel3 should be filtered out
                 someChannel4: 2, // value is set to input value since PASSTHROUGH value was specified
             };

package/dist/tests/tracing.int.test.js

@@ -12,9 +12,10 @@ import { JsonOutputFunctionsParser, JsonOutputToolsParser, } from "langchain/out
 import { createOpenAIFnRunnable } from "langchain/chains/openai_functions";
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { z } from "zod";
-import { StateGraph, END } from "../index.js";
 import { ToolExecutor } from "../prebuilt/tool_executor.js";
 import { createAgentExecutor } from "../prebuilt/agent_executor.js";
+// Import from main `@langchain/langgraph` endpoint to turn on automatic config passing
+import { StateGraph, END, START } from "../index.js";
 test.skip("Can invoke with tracing", async () => {
     const tools = [new TavilySearchResults({ maxResults: 1 })];
     // Get the prompt to use - you can modify this!
@@ -72,7 +73,7 @@ test.skip("Can invoke with tracing", async () => {
         .addNode("action", new RunnableLambda({ func: executeTools }))
         // Set the entrypoint as `agent`
         // This means that this node is the first one called
-        .setEntryPoint("agent")
+        .addEdge(START, "agent")
         // We now add a conditional edge
         .addConditionalEdges(
     // First, we define the start node. We use `agent`.
@@ -187,7 +188,7 @@ test.skip("Can nest an agent executor", async () => {
         // Or end work if done
         FINISH: END,
     })
-        .setEntryPoint("supervisor");
+        .addEdge(START, "supervisor");
     const graph = workflow.compile();
     const streamResults = graph.stream({
         messages: [
@@ -286,7 +287,7 @@ test.skip("Can nest a graph within a graph", async () => {
         researcher: "researcher",
         FINISH: END,
     })
-        .setEntryPoint("supervisor");
+        .addEdge(START, "supervisor");
     const graph = workflow.compile();
     const streamResults = graph.stream({
         messages: [
@@ -424,7 +425,7 @@ Only add steps to the plan that still NEED to be done. Do not return previously
         .addNode("agent", executeStep)
         // Add a replan node
         .addNode("replan", replanStep)
-        .setEntryPoint("planner")
+        .addEdge(START, "planner")
         // From plan we go to agent
         .addEdge("planner", "agent")
         // From agent, we replan

package/dist/tests/tracing.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/tracing.test.js

@@ -0,0 +1,266 @@
+import { expect, it } from "@jest/globals";
+import { AIMessage, HumanMessage } from "@langchain/core/messages";
+import { FakeToolCallingChatModel } from "./utils.js";
+// Import from main `@langchain/langgraph` endpoint to turn on automatic config passing
+import { END, START, StateGraph } from "../index.js";
+it("should pass config through if importing from the primary entrypoint", async () => {
+    const stateGraph = new StateGraph({
+        channels: { messages: null },
+    });
+    const graph = stateGraph
+        .addNode("testnode", async (_) => {
+        const model = new FakeToolCallingChatModel({
+            responses: [new AIMessage("hey!")],
+        }).withConfig({ runName: "model_call" });
+        // Don't explicitly pass config here
+        const res = await model.invoke("hello!");
+        return { messages: [res] };
+    })
+        .addEdge(START, "testnode")
+        .addConditionalEdges("testnode", async (_state) => {
+        const model = new FakeToolCallingChatModel({
+            responses: [new AIMessage("hey!")],
+        }).withConfig({ runName: "conditional_edge_call" });
+        await model.invoke("testing but should be traced");
+        return END;
+    })
+        .compile();
+    const eventStream = graph.streamEvents({ messages: [] }, { version: "v2" });
+    const events = [];
+    for await (const event of eventStream) {
+        events.push(event);
+    }
+    expect(events).toEqual([
+        {
+            event: "on_chain_start",
+            data: {
+                input: {
+                    messages: [],
+                },
+            },
+            name: "LangGraph",
+            tags: [],
+            run_id: expect.any(String),
+            metadata: {},
+        },
+        {
+            event: "on_chain_start",
+            data: {
+                input: {
+                    messages: [],
+                },
+            },
+            name: "__start__",
+            tags: ["graph:step:0", "langsmith:hidden"],
+            run_id: expect.any(String),
+            metadata: {},
+        },
+        {
+            event: "on_chain_end",
+            data: {
+                output: { output: undefined },
+                input: {
+                    messages: [],
+                },
+            },
+            run_id: expect.any(String),
+            name: "__start__",
+            tags: ["graph:step:0", "langsmith:hidden"],
+            metadata: {},
+        },
+        {
+            event: "on_chain_start",
+            data: {
+                input: {
+                    messages: [],
+                },
+            },
+            name: "testnode",
+            tags: ["graph:step:1"],
+            run_id: expect.any(String),
+            metadata: {},
+        },
+        {
+            event: "on_chain_start",
+            data: {
+                input: {
+                    messages: [],
+                },
+            },
+            name: "RunnableLambda",
+            tags: ["seq:step:1"],
+            run_id: expect.any(String),
+            metadata: {},
+        },
+        {
+            event: "on_chat_model_start",
+            data: {
+                input: {
+                    messages: [[new HumanMessage("hello!")]],
+                },
+            },
+            name: "model_call",
+            tags: [],
+            run_id: expect.any(String),
+            metadata: {
+                ls_model_type: "chat",
+                ls_stop: undefined,
+            },
+        },
+        {
+            event: "on_chat_model_end",
+            data: {
+                output: new AIMessage("hey!"),
+                input: {
+                    messages: [[new HumanMessage("hello!")]],
+                },
+            },
+            run_id: expect.any(String),
+            name: "model_call",
+            tags: [],
+            metadata: {
+                ls_model_type: "chat",
+                ls_stop: undefined,
+            },
+        },
+        {
+            event: "on_chain_end",
+            data: {
+                output: {
+                    messages: [new AIMessage("hey!")],
+                },
+                input: {
+                    messages: [],
+                },
+            },
+            run_id: expect.any(String),
+            name: "RunnableLambda",
+            tags: ["seq:step:1"],
+            metadata: {},
+        },
+        {
+            event: "on_chain_start",
+            data: {
+                input: {
+                    messages: [new AIMessage("hey!")],
+                },
+            },
+            name: "ChannelWrite<messages,testnode>",
+            tags: ["seq:step:2", "langsmith:hidden"],
+            run_id: expect.any(String),
+            metadata: {},
+        },
+        {
+            event: "on_chain_end",
+            data: {
+                output: { output: undefined },
+                input: {
+                    messages: [new AIMessage("hey!")],
+                },
+            },
+            run_id: expect.any(String),
+            name: "ChannelWrite<messages,testnode>",
+            tags: ["seq:step:2", "langsmith:hidden"],
+            metadata: {},
+        },
+        {
+            event: "on_chain_start",
+            data: {
+                input: {
+                    input: undefined,
+                },
+            },
+            name: "func",
+            tags: ["seq:step:3"],
+            run_id: expect.any(String),
+            metadata: {},
+        },
+        {
+            event: "on_chat_model_start",
+            data: {
+                input: {
+                    messages: [[new HumanMessage("testing but should be traced")]],
+                },
+            },
+            name: "conditional_edge_call",
+            tags: [],
+            run_id: expect.any(String),
+            metadata: {
+                ls_model_type: "chat",
+                ls_stop: undefined,
+            },
+        },
+        {
+            event: "on_chat_model_end",
+            data: {
+                output: new AIMessage("hey!"),
+                input: {
+                    messages: [[new HumanMessage("testing but should be traced")]],
+                },
+            },
+            run_id: expect.any(String),
+            name: "conditional_edge_call",
+            tags: [],
+            metadata: {
+                ls_model_type: "chat",
+                ls_stop: undefined,
+            },
+        },
+        {
+            event: "on_chain_end",
+            data: {
+                output: {
+                    output: undefined,
+                },
+                input: {
+                    input: undefined,
+                },
+            },
+            run_id: expect.any(String),
+            name: "func",
+            tags: ["seq:step:3"],
+            metadata: {},
+        },
+        {
+            event: "on_chain_end",
+            data: {
+                output: { output: undefined },
+                input: {
+                    messages: [],
+                },
+            },
+            run_id: expect.any(String),
+            name: "testnode",
+            tags: ["graph:step:1"],
+            metadata: {},
+        },
+        {
+            event: "on_chain_stream",
+            run_id: expect.any(String),
+            name: "LangGraph",
+            tags: [],
+            metadata: {},
+            data: {
+                chunk: {
+                    testnode: {
+                        messages: [new AIMessage("hey!")],
+                    },
+                },
+            },
+        },
+        {
+            event: "on_chain_end",
+            data: {
+                output: {
+                    testnode: {
+                        messages: [new AIMessage("hey!")],
+                    },
+                },
+            },
+            run_id: expect.any(String),
+            name: "LangGraph",
+            tags: [],
+            metadata: {},
+        },
+    ]);
+});

package/dist/tests/utils.d.ts

@@ -3,6 +3,7 @@ import { BaseChatModel, BaseChatModelParams } from "@langchain/core/language_mod
 import { BaseMessage } from "@langchain/core/messages";
 import { ChatResult } from "@langchain/core/outputs";
 import { RunnableConfig } from "@langchain/core/runnables";
+import { Tool } from "@langchain/core/tools";
 import { MemorySaver } from "../checkpoint/memory.js";
 import { Checkpoint, CheckpointMetadata } from "../checkpoint/base.js";
 export interface FakeChatModelArgs extends BaseChatModelParams {
@@ -15,6 +16,20 @@ export declare class FakeChatModel extends BaseChatModel {
     _llmType(): string;
     _generate(messages: BaseMessage[], options?: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
 }
+export declare class FakeToolCallingChatModel extends BaseChatModel {
+    sleep?: number;
+    responses?: BaseMessage[];
+    thrownErrorString?: string;
+    idx: number;
+    constructor(fields: {
+        sleep?: number;
+        responses?: BaseMessage[];
+        thrownErrorString?: string;
+    } & BaseChatModelParams);
+    _llmType(): string;
+    _generate(messages: BaseMessage[], _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+    bindTools(_: Tool[]): FakeToolCallingChatModel;
+}
 export declare class MemorySaverAssertImmutable extends MemorySaver {
     storageForCopies: Record<string, Record<string, string>>;
     constructor();

package/dist/tests/utils.js

@@ -44,6 +44,65 @@ export class FakeChatModel extends BaseChatModel {
         };
     }
 }
+export class FakeToolCallingChatModel extends BaseChatModel {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "sleep", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 50
+        });
+        Object.defineProperty(this, "responses", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "thrownErrorString", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "idx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.sleep = fields.sleep ?? this.sleep;
+        this.responses = fields.responses;
+        this.thrownErrorString = fields.thrownErrorString;
+        this.idx = 0;
+    }
+    _llmType() {
+        return "fake";
+    }
+    async _generate(messages, _options, _runManager) {
+        if (this.thrownErrorString) {
+            throw new Error(this.thrownErrorString);
+        }
+        const msg = this.responses?.[this.idx] ?? messages[this.idx];
+        const generation = {
+            generations: [
+                {
+                    text: "",
+                    message: msg,
+                },
+            ],
+        };
+        this.idx += 1;
+        return generation;
+    }
+    bindTools(_) {
+        return new FakeToolCallingChatModel({
+            sleep: this.sleep,
+            responses: this.responses,
+            thrownErrorString: this.thrownErrorString,
+        });
+    }
+}
 export class MemorySaverAssertImmutable extends MemorySaver {
     constructor() {
         super();

package/dist/utils.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RunnableCallable = void 0;
 const runnables_1 = require("@langchain/core/runnables");
+const singletons_1 = require("@langchain/core/singletons");
 class RunnableCallable extends runnables_1.Runnable {
     constructor(fields) {
         super();
@@ -48,24 +49,36 @@ class RunnableCallable extends runnables_1.Runnable {
         this.trace = fields.trace ?? this.trace;
         this.recurse = fields.recurse ?? this.recurse;
     }
+    async _tracedInvoke(input, config, runManager) {
+        return new Promise((resolve, reject) => {
+            const childConfig = (0, runnables_1.patchConfig)(config, {
+                callbacks: runManager?.getChild(),
+            });
+            void singletons_1.AsyncLocalStorageProviderSingleton.getInstance().run(childConfig, async () => {
+                try {
+                    const output = await this.func(input, childConfig);
+                    resolve(output);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        });
+    }
     async invoke(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     input, options
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ) {
-        if (this.func === undefined) {
-            return this.invoke(input, options);
-        }
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let returnValue;
         if (this.trace) {
-            returnValue = await this._callWithConfig(this.func, input, (0, runnables_1.mergeConfigs)(this.config, options));
+            returnValue = await this._callWithConfig(this._tracedInvoke, input, (0, runnables_1.mergeConfigs)(this.config, options));
         }
         else {
             returnValue = await this.func(input, (0, runnables_1.mergeConfigs)(this.config, options));
         }
-        // eslint-disable-next-line no-instanceof/no-instanceof
-        if (returnValue instanceof runnables_1.Runnable && this.recurse) {
+        if (runnables_1.Runnable.isRunnable(returnValue) && this.recurse) {
             return await returnValue.invoke(input, options);
         }
         return returnValue;

package/dist/utils.d.ts

@@ -1,3 +1,4 @@
+import { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
 import { Runnable, RunnableConfig } from "@langchain/core/runnables";
 export interface RunnableCallableArgs extends Partial<any> {
     name?: string;
@@ -14,5 +15,6 @@ export declare class RunnableCallable<I = unknown, O = unknown> extends Runnable
     trace: boolean;
     recurse: boolean;
     constructor(fields: RunnableCallableArgs);
+    protected _tracedInvoke(input: I, config?: Partial<RunnableConfig>, runManager?: CallbackManagerForChainRun): Promise<O>;
     invoke(input: any, options?: Partial<RunnableConfig> | undefined): Promise<any>;
 }

package/dist/utils.js

@@ -1,4 +1,5 @@
-import { mergeConfigs, Runnable, } from "@langchain/core/runnables";
+import { mergeConfigs, patchConfig, Runnable, } from "@langchain/core/runnables";
+import { AsyncLocalStorageProviderSingleton } from "@langchain/core/singletons";
 export class RunnableCallable extends Runnable {
     constructor(fields) {
         super();
@@ -45,24 +46,36 @@ export class RunnableCallable extends Runnable {
         this.trace = fields.trace ?? this.trace;
         this.recurse = fields.recurse ?? this.recurse;
     }
+    async _tracedInvoke(input, config, runManager) {
+        return new Promise((resolve, reject) => {
+            const childConfig = patchConfig(config, {
+                callbacks: runManager?.getChild(),
+            });
+            void AsyncLocalStorageProviderSingleton.getInstance().run(childConfig, async () => {
+                try {
+                    const output = await this.func(input, childConfig);
+                    resolve(output);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        });
+    }
     async invoke(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     input, options
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ) {
-        if (this.func === undefined) {
-            return this.invoke(input, options);
-        }
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let returnValue;
         if (this.trace) {
-            returnValue = await this._callWithConfig(this.func, input, mergeConfigs(this.config, options));
+            returnValue = await this._callWithConfig(this._tracedInvoke, input, mergeConfigs(this.config, options));
         }
         else {
             returnValue = await this.func(input, mergeConfigs(this.config, options));
         }
-        // eslint-disable-next-line no-instanceof/no-instanceof
-        if (returnValue instanceof Runnable && this.recurse) {
+        if (Runnable.isRunnable(returnValue) && this.recurse) {
             return await returnValue.invoke(input, options);
         }
         return returnValue;

package/dist/web.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmptyChannelError = exports.InvalidUpdateError = exports.GraphValueError = exports.GraphRecursionError = exports.BaseCheckpointSaver = exports.emptyCheckpoint = exports.copyCheckpoint = exports.MemorySaver = exports.MessageGraph = exports.StateGraph = exports.START = exports.Graph = exports.END = void 0;
+var index_js_1 = require("./graph/index.cjs");
+Object.defineProperty(exports, "END", { enumerable: true, get: function () { return index_js_1.END; } });
+Object.defineProperty(exports, "Graph", { enumerable: true, get: function () { return index_js_1.Graph; } });
+Object.defineProperty(exports, "START", { enumerable: true, get: function () { return index_js_1.START; } });
+Object.defineProperty(exports, "StateGraph", { enumerable: true, get: function () { return index_js_1.StateGraph; } });
+Object.defineProperty(exports, "MessageGraph", { enumerable: true, get: function () { return index_js_1.MessageGraph; } });
+var memory_js_1 = require("./checkpoint/memory.cjs");
+Object.defineProperty(exports, "MemorySaver", { enumerable: true, get: function () { return memory_js_1.MemorySaver; } });
+var base_js_1 = require("./checkpoint/base.cjs");
+Object.defineProperty(exports, "copyCheckpoint", { enumerable: true, get: function () { return base_js_1.copyCheckpoint; } });
+Object.defineProperty(exports, "emptyCheckpoint", { enumerable: true, get: function () { return base_js_1.emptyCheckpoint; } });
+Object.defineProperty(exports, "BaseCheckpointSaver", { enumerable: true, get: function () { return base_js_1.BaseCheckpointSaver; } });
+var errors_js_1 = require("./errors.cjs");
+Object.defineProperty(exports, "GraphRecursionError", { enumerable: true, get: function () { return errors_js_1.GraphRecursionError; } });
+Object.defineProperty(exports, "GraphValueError", { enumerable: true, get: function () { return errors_js_1.GraphValueError; } });
+Object.defineProperty(exports, "InvalidUpdateError", { enumerable: true, get: function () { return errors_js_1.InvalidUpdateError; } });
+Object.defineProperty(exports, "EmptyChannelError", { enumerable: true, get: function () { return errors_js_1.EmptyChannelError; } });

package/dist/web.d.ts

@@ -0,0 +1,4 @@
+export { END, Graph, type StateGraphArgs, START, StateGraph, type CompiledStateGraph, MessageGraph, } from "./graph/index.js";
+export { MemorySaver } from "./checkpoint/memory.js";
+export { type Checkpoint, type CheckpointMetadata, copyCheckpoint, emptyCheckpoint, BaseCheckpointSaver, } from "./checkpoint/base.js";
+export { GraphRecursionError, GraphValueError, InvalidUpdateError, EmptyChannelError, } from "./errors.js";

package/dist/web.js

@@ -0,0 +1,4 @@
+export { END, Graph, START, StateGraph, MessageGraph, } from "./graph/index.js";
+export { MemorySaver } from "./checkpoint/memory.js";
+export { copyCheckpoint, emptyCheckpoint, BaseCheckpointSaver, } from "./checkpoint/base.js";
+export { GraphRecursionError, GraphValueError, InvalidUpdateError, EmptyChannelError, } from "./errors.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "description": "LangGraph",
   "type": "module",
   "engines": {
@@ -70,7 +70,7 @@
     "rollup": "^4.5.2",
     "ts-jest": "^29.1.0",
     "tsx": "^4.7.0",
-    "typescript": "^5.4.5",
+    "typescript": "^4.9.5 || ^5.4.5",
     "zod": "^3.22.4",
     "zod-to-json-schema": "^3.22.4"
   },
@@ -96,6 +96,15 @@
       "import": "./index.js",
       "require": "./index.cjs"
     },
+    "./web": {
+      "types": {
+        "import": "./web.d.ts",
+        "require": "./web.d.cts",
+        "default": "./web.d.ts"
+      },
+      "import": "./web.js",
+      "require": "./web.cjs"
+    },
     "./pregel": {
       "types": {
         "import": "./pregel.d.ts",
@@ -131,6 +140,10 @@
     "index.js",
     "index.d.ts",
     "index.d.cts",
+    "web.cjs",
+    "web.js",
+    "web.d.ts",
+    "web.d.cts",
     "pregel.cjs",
     "pregel.js",
     "pregel.d.ts",

package/web.cjs

@@ -0,0 +1 @@
+module.exports = require('./dist/web.cjs');

package/web.d.cts

@@ -0,0 +1 @@
+export * from './dist/web.js'

package/web.d.ts

@@ -0,0 +1 @@
+export * from './dist/web.js'

package/web.js

@@ -0,0 +1 @@
+export * from './dist/web.js'