@langchain/langgraph 0.0.31 → 0.0.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph",
-  "version": "0.0.31",
+  "version": "0.0.32",
   "description": "LangGraph",
   "type": "module",
   "engines": {
@@ -13,40 +13,33 @@
     "url": "git@github.com:langchain-ai/langgraphjs.git"
   },
   "scripts": {
-    "build": "yarn clean && yarn build:esm && yarn build:cjs && yarn build:scripts",
-    "build:esm": "NODE_OPTIONS=--max-old-space-size=4096 rm -f src/package.json && tsc --outDir dist/",
-    "build:cjs": "NODE_OPTIONS=--max-old-space-size=4096 echo '{}' > src/package.json && tsc --outDir dist-cjs/ -p tsconfig.cjs.json && yarn move-cjs-to-dist && rm -rf dist-cjs/ src/package.json",
-    "build:watch": "yarn create-entrypoints && tsc --outDir dist/ --watch",
-    "build:scripts": "yarn create-entrypoints && yarn check-tree-shaking",
+    "build": "yarn turbo:command build:internal --filter=@langchain/langgraph",
+    "build:internal": "yarn lc_build_v2 --create-entrypoints --pre --tree-shaking",
     "lint:eslint": "NODE_OPTIONS=--max-old-space-size=4096 eslint --cache --ext .ts,.js src/",
     "lint:dpdm": "dpdm --exit-code circular:1 --no-warning --no-tree src/*.ts src/**/*.ts",
     "lint": "yarn lint:eslint && yarn lint:dpdm",
     "lint:fix": "yarn lint:eslint --fix && yarn lint:dpdm",
-    "clean": "rm -rf dist/ dist-cjs/ src/package.json && NODE_OPTIONS=--max-old-space-size=4096 yarn create-entrypoints -- --pre",
     "prepack": "yarn build",
     "test": "NODE_OPTIONS=--experimental-vm-modules jest --testPathIgnorePatterns=\\.int\\.test.ts --testTimeout 30000 --maxWorkers=50%",
     "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch --testPathIgnorePatterns=\\.int\\.test.ts",
     "test:single": "NODE_OPTIONS=--experimental-vm-modules yarn run jest --config jest.config.cjs --testTimeout 100000",
     "test:int": "NODE_OPTIONS=--experimental-vm-modules jest --testPathPattern=\\.int\\.test.ts --testTimeout 100000 --maxWorkers=50%",
     "format": "prettier --config .prettierrc --write \"src\"",
-    "format:check": "prettier --config .prettierrc --check \"src\"",
-    "move-cjs-to-dist": "yarn lc-build --config ./langchain.config.js --move-cjs-dist",
-    "create-entrypoints": "yarn lc-build --config ./langchain.config.js --create-entrypoints",
-    "check-tree-shaking": "yarn lc-build --config ./langchain.config.js --tree-shaking"
+    "format:check": "prettier --config .prettierrc --check \"src\""
   },
   "author": "LangChain",
   "license": "MIT",
   "dependencies": {
-    "@langchain/core": ">=0.2.18 <0.3.0",
+    "@langchain/core": ">=0.2.20 <0.3.0",
     "uuid": "^10.0.0",
     "zod": "^3.23.8"
   },
   "devDependencies": {
     "@jest/globals": "^29.5.0",
-    "@langchain/anthropic": "^0.2.6",
+    "@langchain/anthropic": "^0.2.12",
     "@langchain/community": "^0.2.19",
     "@langchain/openai": "^0.2.4",
-    "@langchain/scripts": "^0.0.18",
+    "@langchain/scripts": "^0.0.19",
     "@swc/core": "^1.3.90",
     "@swc/jest": "^0.2.29",
     "@tsconfig/recommended": "^1.0.3",
@@ -62,14 +55,14 @@
     "eslint": "^8.33.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-config-prettier": "^8.6.0",
-    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-no-instanceof": "^1.0.1",
     "eslint-plugin-prettier": "^4.2.1",
     "jest": "^29.5.0",
     "jest-environment-node": "^29.6.4",
     "langchain": "^0.2.10",
     "prettier": "^2.8.3",
-    "release-it": "^15.10.1",
+    "release-it": "^17.6.0",
     "rollup": "^4.5.2",
     "ts-jest": "^29.1.0",
     "tsx": "^4.7.0",

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

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

package/dist/tests/channels.test.js

@@ -1,151 +0,0 @@
-import { describe, it, expect } from "@jest/globals";
-import { AnyValue } from "../channels/any_value.js";
-import { EphemeralValue } from "../channels/ephemeral_value.js";
-import { LastValue } from "../channels/last_value.js";
-import { EmptyChannelError, InvalidUpdateError } from "../errors.js";
-import { Topic } from "../channels/topic.js";
-import { BinaryOperatorAggregate } from "../channels/binop.js";
-describe("LastValue", () => {
-    it("should handle last value correctly", () => {
-        const channel = new LastValue();
-        expect(() => {
-            channel.get();
-        }).toThrow(EmptyChannelError);
-        expect(() => {
-            channel.update([5, 6]);
-        }).toThrow(InvalidUpdateError);
-        channel.update([3]);
-        expect(channel.get()).toBe(3);
-        channel.update([4]);
-        expect(channel.get()).toBe(4);
-    });
-    it("should handle restoring from checkpoint correctly", () => {
-        // call `.update()` to add a value to the channel
-        const channel = new LastValue();
-        channel.update([100]);
-        const checkpoint = channel.checkpoint();
-        const restoredChannel = new LastValue();
-        const channel2 = restoredChannel.fromCheckpoint(checkpoint);
-        expect(channel2.get()).toBe(100);
-    });
-});
-describe("Topic", () => {
-    const channel = new Topic();
-    it("should handle updates and get operations", () => {
-        channel.update(["a", "b"]);
-        expect(channel.get()).toEqual(["a", "b"]);
-        channel.update([["c", "d"], "d"]);
-        expect(channel.get()).toEqual(["c", "d", "d"]);
-        channel.update([]);
-        expect(channel.get()).toEqual([]);
-        channel.update(["e"]);
-        expect(channel.get()).toEqual(["e"]);
-    });
-    it("should create and use a checkpoint", () => {
-        const checkpoint = channel.checkpoint();
-        const newChannel = new Topic().fromCheckpoint(checkpoint);
-        expect(newChannel.get()).toEqual(["e"]);
-    });
-});
-describe("Topic with unique: true", () => {
-    const channel = new Topic({ unique: true });
-    it("should de-dupe updates and get the last unique value", () => {
-        channel.update(["a", "b"]);
-        expect(channel.get()).toEqual(["a", "b"]);
-        channel.update(["b", ["c", "d"], "d"]);
-        expect(channel.get()).toEqual(["c", "d"]);
-        channel.update([]);
-        expect(channel.get()).toEqual([]);
-        channel.update(["e"]);
-        expect(channel.get()).toEqual(["e"]);
-    });
-    it("should de-dupe from checkpoint", () => {
-        const checkpoint = channel.checkpoint();
-        const newChannel = new Topic({ unique: true }).fromCheckpoint(checkpoint);
-        expect(newChannel.get()).toEqual(["e"]);
-        newChannel.update(["d", "f"]);
-        expect(newChannel.get()).toEqual(["f"]);
-    });
-});
-describe("Topic with accumulate: true", () => {
-    const channel = new Topic({ accumulate: true });
-    it("should accumulate updates and get operations", () => {
-        channel.update(["a", "b"]);
-        expect(channel.get()).toEqual(["a", "b"]);
-        channel.update(["b", ["c", "d"], "d"]);
-        expect(channel.get()).toEqual(["a", "b", "b", "c", "d", "d"]);
-        channel.update([]);
-        expect(channel.get()).toEqual(["a", "b", "b", "c", "d", "d"]);
-    });
-    it("should create and use a checkpoint", () => {
-        const checkpoint = channel.checkpoint();
-        const newChannel = new Topic({ accumulate: true }).fromCheckpoint(checkpoint);
-        expect(newChannel.get()).toEqual(["a", "b", "b", "c", "d", "d"]);
-        newChannel.update(["e"]);
-        expect(newChannel.get()).toEqual(["a", "b", "b", "c", "d", "d", "e"]);
-    });
-});
-describe("Topic with accumulate and unique: true", () => {
-    const channel = new Topic({ unique: true, accumulate: true });
-    it("should handle unique and accumulate updates and get operations", () => {
-        channel.update(["a", "b"]);
-        expect(channel.get()).toEqual(["a", "b"]);
-        channel.update(["b", ["c", "d"], "d"]);
-        expect(channel.get()).toEqual(["a", "b", "c", "d"]);
-        channel.update([]);
-        expect(channel.get()).toEqual(["a", "b", "c", "d"]);
-    });
-    it("should create and use a checkpoint", () => {
-        const checkpoint = channel.checkpoint();
-        const newChannel = new Topic({
-            unique: true,
-            accumulate: true,
-        }).fromCheckpoint(checkpoint);
-        expect(newChannel.get()).toEqual(["a", "b", "c", "d"]);
-        newChannel.update(["d", "e"]);
-        expect(newChannel.get()).toEqual(["a", "b", "c", "d", "e"]);
-    });
-});
-describe("BinaryOperatorAggregate", () => {
-    it("should handle binary operator aggregation correctly", () => {
-        const channel = new BinaryOperatorAggregate((a, b) => a + b, () => 0);
-        expect(channel.get()).toBe(0);
-        channel.update([1, 2, 3]);
-        expect(channel.get()).toBe(6);
-        channel.update([4]);
-        expect(channel.get()).toBe(10);
-    });
-    it("should handle checkpointing correctly", () => {
-        const channel = new BinaryOperatorAggregate((a, b) => a + b, () => 0);
-        channel.update([1, 2, 3]);
-        channel.update([4]);
-        const checkpoint = channel.checkpoint();
-        const restoredChannel = new BinaryOperatorAggregate((a, b) => a + b, () => 10);
-        const channel2 = restoredChannel.fromCheckpoint(checkpoint);
-        expect(channel2.get()).toBe(10);
-    });
-});
-describe("AnyValue", () => {
-    it("should handle any value correctly", () => {
-        const channel = new AnyValue();
-        expect(() => {
-            channel.get();
-        }).toThrow(EmptyChannelError);
-        channel.update([3]);
-        expect(channel.get()).toBe(3);
-        channel.update([4, 5]);
-        expect(channel.get()).toBe(5);
-    });
-});
-describe("EphemeralValue with gaurd: false", () => {
-    it("should handle ephemeral value correctly", () => {
-        const channel = new EphemeralValue(false);
-        expect(() => {
-            channel.get();
-        }).toThrow(EmptyChannelError);
-        channel.update([3]);
-        expect(channel.get()).toBe(3);
-        channel.update([4, 5]);
-        expect(channel.get()).toBe(5);
-    });
-});

package/dist/tests/chatbot.int.test.d.ts

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

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

@@ -1,66 +0,0 @@
-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)
-            .addEdge(START, "oracle")
-            .compile();
-        const res = await graph.invoke(new HumanMessage("What is 1 + 1?"));
-        console.log(res);
-    });
-    it("Chat use-case with tool calling", async () => {
-        const model = new ChatOpenAI({
-            temperature: 0,
-        }).bind({
-            tools: [convertToOpenAITool(new Calculator())],
-            tool_choice: "auto",
-        });
-        const router = (state) => {
-            const toolCalls = state[state.length - 1].additional_kwargs.tool_calls ?? [];
-            if (toolCalls.length) {
-                return "calculator";
-            }
-            else {
-                return "end";
-            }
-        };
-        const graph = new MessageGraph()
-            .addNode("oracle", async (state) => model.invoke(state))
-            .addNode("calculator", async (state) => {
-            const tool = new Calculator();
-            const toolCalls = state[state.length - 1].additional_kwargs.tool_calls ?? [];
-            const calculatorCall = toolCalls.find((toolCall) => toolCall.function.name === "calculator");
-            if (calculatorCall === undefined) {
-                throw new Error("No calculator input found.");
-            }
-            const result = await tool.invoke(JSON.parse(calculatorCall.function.arguments));
-            return new ToolMessage({
-                tool_call_id: calculatorCall.id,
-                content: result,
-            });
-        })
-            .addEdge("calculator", END)
-            .addEdge(START, "oracle")
-            .addConditionalEdges("oracle", router, {
-            calculator: "calculator",
-            end: END,
-        })
-            .compile();
-        const res = await graph.invoke(new HumanMessage("What is 1 + 1?"));
-        console.log(res);
-        const res2 = await graph.invoke(new HumanMessage("What is your name?"));
-        console.log(res2);
-    });
-});

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

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

package/dist/tests/checkpoints.test.js

@@ -1,178 +0,0 @@
-import { describe, it, expect } from "@jest/globals";
-import { deepCopy } from "../checkpoint/base.js";
-import { MemorySaver } from "../checkpoint/memory.js";
-import { SqliteSaver } from "../checkpoint/sqlite.js";
-import { uuid6 } from "../checkpoint/id.js";
-const checkpoint1 = {
-    v: 1,
-    id: uuid6(-1),
-    ts: "2024-04-19T17:19:07.952Z",
-    channel_values: {
-        someKey1: "someValue1",
-    },
-    channel_versions: {
-        someKey2: 1,
-    },
-    versions_seen: {
-        someKey3: {
-            someKey4: 1,
-        },
-    },
-};
-const checkpoint2 = {
-    v: 1,
-    id: uuid6(1),
-    ts: "2024-04-20T17:19:07.952Z",
-    channel_values: {
-        someKey1: "someValue2",
-    },
-    channel_versions: {
-        someKey2: 2,
-    },
-    versions_seen: {
-        someKey3: {
-            someKey4: 2,
-        },
-    },
-};
-describe("Base", () => {
-    it("should deep copy a simple object", () => {
-        const obj = { a: 1, b: { c: 2 } };
-        const copiedObj = deepCopy(obj);
-        // Check if the copied object is equal to the original object
-        expect(copiedObj).toEqual(obj);
-        // Check if the copied object is not the same object reference as the original object
-        expect(copiedObj).not.toBe(obj);
-        // Check if the nested object is also deep copied
-        expect(copiedObj.b).toEqual(obj.b);
-        expect(copiedObj.b).not.toBe(obj.b);
-    });
-    it("should deep copy an array", () => {
-        const arr = [1, 2, 3];
-        const copiedArr = deepCopy(arr);
-        // Check if the copied array is equal to the original array
-        expect(copiedArr).toEqual(arr);
-    });
-    it("should deep copy an array of objects", () => {
-        const arr = [{ a: 1 }, { b: 2 }];
-        const copiedArr = deepCopy(arr);
-        // Check if the copied array is equal to the original array
-        expect(copiedArr).toEqual(arr);
-        // Check if the copied array is not the same array reference as the original array
-        expect(copiedArr).not.toBe(arr);
-        // Check if the nested objects in the array are also deep copied
-        expect(copiedArr[0]).toEqual(arr[0]);
-        expect(copiedArr[0]).not.toBe(arr[0]);
-    });
-});
-describe("MemorySaver", () => {
-    it("should save and retrieve checkpoints correctly", async () => {
-        const memorySaver = new MemorySaver();
-        // save checkpoint
-        const runnableConfig = await memorySaver.put({ configurable: { thread_id: "1" } }, checkpoint1, { source: "update", step: -1, writes: null });
-        expect(runnableConfig).toEqual({
-            configurable: {
-                thread_id: "1",
-                checkpoint_id: checkpoint1.id,
-            },
-        });
-        // get checkpoint tuple
-        const checkpointTuple = await memorySaver.getTuple({
-            configurable: { thread_id: "1" },
-        });
-        expect(checkpointTuple?.config).toEqual({
-            configurable: {
-                thread_id: "1",
-                checkpoint_id: checkpoint1.id,
-            },
-        });
-        expect(checkpointTuple?.checkpoint).toEqual(checkpoint1);
-        // save another checkpoint
-        await memorySaver.put({ configurable: { thread_id: "1" } }, checkpoint2, {
-            source: "update",
-            step: -1,
-            writes: null,
-        });
-        // list checkpoints
-        const checkpointTupleGenerator = await memorySaver.list({
-            configurable: { thread_id: "1" },
-        });
-        const checkpointTuples = [];
-        for await (const checkpoint of checkpointTupleGenerator) {
-            checkpointTuples.push(checkpoint);
-        }
-        expect(checkpointTuples.length).toBe(2);
-        const checkpointTuple1 = checkpointTuples[0];
-        const checkpointTuple2 = checkpointTuples[1];
-        expect(checkpointTuple1.checkpoint.ts).toBe("2024-04-20T17:19:07.952Z");
-        expect(checkpointTuple2.checkpoint.ts).toBe("2024-04-19T17:19:07.952Z");
-    });
-});
-describe("SqliteSaver", () => {
-    it("should save and retrieve checkpoints correctly", async () => {
-        const sqliteSaver = SqliteSaver.fromConnString(":memory:");
-        // get undefined checkpoint
-        const undefinedCheckpoint = await sqliteSaver.getTuple({
-            configurable: { thread_id: "1" },
-        });
-        expect(undefinedCheckpoint).toBeUndefined();
-        // save first checkpoint
-        const runnableConfig = await sqliteSaver.put({ configurable: { thread_id: "1" } }, checkpoint1, { source: "update", step: -1, writes: null });
-        expect(runnableConfig).toEqual({
-            configurable: {
-                thread_id: "1",
-                checkpoint_id: checkpoint1.id,
-            },
-        });
-        // get first checkpoint tuple
-        const firstCheckpointTuple = await sqliteSaver.getTuple({
-            configurable: { thread_id: "1" },
-        });
-        expect(firstCheckpointTuple?.config).toEqual({
-            configurable: {
-                thread_id: "1",
-                checkpoint_id: checkpoint1.id,
-            },
-        });
-        expect(firstCheckpointTuple?.checkpoint).toEqual(checkpoint1);
-        expect(firstCheckpointTuple?.parentConfig).toBeUndefined();
-        // save second checkpoint
-        await sqliteSaver.put({
-            configurable: {
-                thread_id: "1",
-                checkpoint_id: "2024-04-18T17:19:07.952Z",
-            },
-        }, checkpoint2, { source: "update", step: -1, writes: null });
-        // verify that parentTs is set and retrieved correctly for second checkpoint
-        const secondCheckpointTuple = await sqliteSaver.getTuple({
-            configurable: { thread_id: "1" },
-        });
-        expect(secondCheckpointTuple?.parentConfig).toEqual({
-            configurable: {
-                thread_id: "1",
-                checkpoint_id: "2024-04-18T17:19:07.952Z",
-            },
-        });
-        // list checkpoints
-        const checkpointTupleGenerator = await sqliteSaver.list({
-            configurable: { thread_id: "1" },
-        });
-        const checkpointTuples = [];
-        for await (const checkpoint of checkpointTupleGenerator) {
-            checkpointTuples.push(checkpoint);
-        }
-        expect(checkpointTuples.length).toBe(2);
-        const checkpointTuple1 = checkpointTuples[0];
-        const checkpointTuple2 = checkpointTuples[1];
-        expect(checkpointTuple1.checkpoint.ts).toBe("2024-04-20T17:19:07.952Z");
-        expect(checkpointTuple2.checkpoint.ts).toBe("2024-04-19T17:19:07.952Z");
-    });
-});
-describe("id", () => {
-    it("should accept clockseq -1", () => {
-        const regex = /^[0-9a-f]{8}-[0-9a-f]{4}-6[0-9a-f]{3}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-        const uuid = uuid6(-1);
-        expect(uuid).toMatch(regex);
-        expect(uuid.includes("u")).toBe(false);
-    });
-});

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

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

package/dist/tests/diagrams.test.js

@@ -1,25 +0,0 @@
-import { test, expect } from "@jest/globals";
-import { createReactAgent } from "../prebuilt/index.js";
-import { FakeSearchTool, FakeToolCallingChatModel } from "./utils.js";
-test("prebuilt agent", async () => {
-    // Define the tools for the agent to use
-    const tools = [new FakeSearchTool()];
-    const model = new FakeToolCallingChatModel({});
-    const app = createReactAgent({ llm: model, tools });
-    const graph = app.getGraph();
-    const mermaid = graph.drawMermaid();
-    expect(mermaid).toEqual(`%%{init: {'flowchart': {'curve': 'linear'}}}%%
-graph TD;
-\t__start__[__start__]:::startclass;
-\t__end__[__end__]:::endclass;
-\tagent([agent]):::otherclass;
-\ttools([tools]):::otherclass;
-\t__start__ --> agent;
-\ttools --> agent;
-\tagent -. continue .-> tools;
-\tagent -.-> __end__;
-\tclassDef startclass fill:#ffdfba;
-\tclassDef endclass fill:#baffc9;
-\tclassDef otherclass fill:#fad7de;
-`);
-});

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

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

package/dist/tests/graph.test.js

@@ -1,33 +0,0 @@
-import { describe, it, expect } from "@jest/globals";
-import { StateGraph } from "../graph/state.js";
-import { END, START } from "../web.js";
-describe("State", () => {
-    it("should validate a new node key correctly ", () => {
-        const stateGraph = new StateGraph({
-            channels: { existingStateAttributeKey: null },
-        });
-        expect(() => {
-            stateGraph.addNode("existingStateAttributeKey", (_) => ({}));
-        }).toThrow("existingStateAttributeKey");
-        expect(() => {
-            stateGraph.addNode("newNodeKey", (_) => ({}));
-        }).not.toThrow();
-    });
-    it("should allow reducers with different argument types", async () => {
-        const stateGraph = new StateGraph({
-            channels: {
-                testval: {
-                    reducer: (left, right) => right ? left.concat([right.toString()]) : left,
-                },
-            },
-        });
-        const graph = stateGraph
-            .addNode("testnode", (_) => ({ testval: "hi!" }))
-            .addEdge(START, "testnode")
-            .addEdge("testnode", END)
-            .compile();
-        expect(await graph.invoke({ testval: ["hello"] })).toEqual({
-            testval: ["hello", "hi!"],
-        });
-    });
-});

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

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