@langchain/langgraph 0.0.11 → 0.0.13

package/dist/tests/checkpoints.test.js

@@ -0,0 +1,190 @@
+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 { convert1to6, 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 });
+        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,
+        });
+        // 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 });
+        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 });
+        // 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 convert uuid1 to uuid6", () => {
+        const regex = /^[0-9a-f]{8}-[0-9a-f]{4}-6[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+        // [UUIDv1, UUIDv6]
+        const cases = [
+            [
+                "5714f720-1268-11e7-a24b-96d95aa38c32",
+                "1e712685-714f-6720-a24b-96d95aa38c32",
+            ],
+            [
+                "68f820c0-1268-11e7-a24b-671acd892c6a",
+                "1e712686-8f82-60c0-a24b-671acd892c6a",
+            ],
+        ];
+        cases.forEach(([v1, v6]) => {
+            const converted = convert1to6(v1);
+            expect(converted).toBe(v6);
+            expect(converted).toMatch(regex);
+        });
+    });
+});

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

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

package/dist/tests/graph.test.js

@@ -0,0 +1,15 @@
+import { describe, it, expect } from "@jest/globals";
+import { StateGraph } from "../graph/state.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();
+    });
+});

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

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

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

@@ -0,0 +1,101 @@
+/* eslint-disable no-process-env */
+import { it, beforeAll, describe, expect } from "@jest/globals";
+import { Tool } from "@langchain/core/tools";
+import { ChatOpenAI } from "@langchain/openai";
+import { HumanMessage } from "@langchain/core/messages";
+import { END } from "../index.js";
+import { createFunctionCallingExecutor } from "../prebuilt/index.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 = "";
+});
+describe("createFunctionCallingExecutor", () => {
+    it("can call a function", async () => {
+        const weatherResponse = `Not too cold, not too hot 😎`;
+        const model = new ChatOpenAI();
+        class SanFranciscoWeatherTool extends Tool {
+            constructor() {
+                super();
+                Object.defineProperty(this, "name", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: "current_weather"
+                });
+                Object.defineProperty(this, "description", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: "Get the current weather report for San Francisco, CA"
+                });
+            }
+            async _call(_) {
+                return weatherResponse;
+            }
+        }
+        const tools = [new SanFranciscoWeatherTool()];
+        const functionsAgentExecutor = createFunctionCallingExecutor({
+            model,
+            tools,
+        });
+        const response = await functionsAgentExecutor.invoke({
+            messages: [new HumanMessage("What's the weather like in SF?")],
+        });
+        console.log(response);
+        // It needs at least one human message, one AI and one function message.
+        expect(response.messages.length > 3).toBe(true);
+        const firstFunctionMessage = response.messages.find((message) => message._getType() === "function");
+        expect(firstFunctionMessage).toBeDefined();
+        expect(firstFunctionMessage?.content).toBe(weatherResponse);
+    });
+    it("can stream a function", async () => {
+        const weatherResponse = `Not too cold, not too hot 😎`;
+        const model = new ChatOpenAI({
+            streaming: true,
+        });
+        class SanFranciscoWeatherTool extends Tool {
+            constructor() {
+                super();
+                Object.defineProperty(this, "name", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: "current_weather"
+                });
+                Object.defineProperty(this, "description", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: "Get the current weather report for San Francisco, CA"
+                });
+            }
+            async _call(_) {
+                return weatherResponse;
+            }
+        }
+        const tools = [new SanFranciscoWeatherTool()];
+        const functionsAgentExecutor = createFunctionCallingExecutor({
+            model,
+            tools,
+        });
+        const stream = await functionsAgentExecutor.stream({
+            messages: [new HumanMessage("What's the weather like in SF?")],
+        });
+        const fullResponse = [];
+        for await (const item of stream) {
+            console.log(item);
+            console.log("-----\n");
+            fullResponse.push(item);
+        }
+        // Needs at least 3 llm calls, plus one `__end__` call.
+        expect(fullResponse.length >= 4).toBe(true);
+        const endMessage = fullResponse[fullResponse.length - 1];
+        expect(END in endMessage).toBe(true);
+        expect(endMessage[END].messages.length > 0).toBe(true);
+        const functionCall = endMessage[END].messages.find((message) => message._getType() === "function");
+        expect(functionCall.content).toBe(weatherResponse);
+    });
+});

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

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

package/dist/tests/prebuilt.test.js

@@ -0,0 +1,195 @@
+/* eslint-disable no-process-env */
+import { it, expect, beforeAll, describe } from "@jest/globals";
+import { PromptTemplate } from "@langchain/core/prompts";
+import { FakeStreamingLLM } from "@langchain/core/utils/testing";
+import { Tool } from "@langchain/core/tools";
+import { createAgentExecutor } from "../prebuilt/index.js";
+// Tracing slows down the tests
+beforeAll(() => {
+    process.env.LANGCHAIN_TRACING_V2 = "false";
+    process.env.LANGCHAIN_ENDPOINT = "";
+    process.env.LANGCHAIN_ENDPOINT = "";
+    process.env.LANGCHAIN_API_KEY = "";
+    process.env.LANGCHAIN_PROJECT = "";
+});
+describe("PreBuilt", () => {
+    class SearchAPI extends Tool {
+        constructor() {
+            super();
+            Object.defineProperty(this, "name", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: "search_api"
+            });
+            Object.defineProperty(this, "description", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: "A simple API that returns the input string."
+            });
+        }
+        async _call(query) {
+            return `result for ${query}`;
+        }
+    }
+    const tools = [new SearchAPI()];
+    it("Can invoke createAgentExecutor", async () => {
+        const prompt = PromptTemplate.fromTemplate("Hello!");
+        const llm = new FakeStreamingLLM({
+            responses: [
+                "tool:search_api:query",
+                "tool:search_api:another",
+                "finish:answer",
+            ],
+        });
+        const agentParser = (input) => {
+            if (input.startsWith("finish")) {
+                const answer = input.split(":")[1];
+                return {
+                    returnValues: { answer },
+                    log: input,
+                };
+            }
+            const [, toolName, toolInput] = input.split(":");
+            return {
+                tool: toolName,
+                toolInput,
+                log: input,
+            };
+        };
+        const agent = prompt.pipe(llm).pipe(agentParser);
+        const agentExecutor = createAgentExecutor({
+            agentRunnable: agent,
+            tools,
+        });
+        const result = await agentExecutor.invoke({
+            input: "what is the weather in sf?",
+        });
+        expect(result).toEqual({
+            input: "what is the weather in sf?",
+            agentOutcome: {
+                returnValues: {
+                    answer: "answer",
+                },
+                log: "finish:answer",
+            },
+            steps: [
+                {
+                    action: {
+                        tool: "search_api",
+                        toolInput: "query",
+                        log: "tool:search_api:query",
+                    },
+                    observation: "result for query",
+                },
+                {
+                    action: {
+                        tool: "search_api",
+                        toolInput: "another",
+                        log: "tool:search_api:another",
+                    },
+                    observation: "result for another",
+                },
+            ],
+        });
+    });
+    it("Can stream createAgentExecutor", async () => {
+        const prompt = PromptTemplate.fromTemplate("Hello!");
+        const llm = new FakeStreamingLLM({
+            responses: [
+                "tool:search_api:query",
+                "tool:search_api:another",
+                "finish:answer",
+            ],
+        });
+        const agentParser = (input) => {
+            if (input.startsWith("finish")) {
+                const answer = input.split(":")[1];
+                return {
+                    returnValues: { answer },
+                    log: input,
+                };
+            }
+            const [, toolName, toolInput] = input.split(":");
+            return {
+                tool: toolName,
+                toolInput,
+                log: input,
+            };
+        };
+        const agent = prompt.pipe(llm).pipe(agentParser);
+        const agentExecutor = createAgentExecutor({
+            agentRunnable: agent,
+            tools,
+        });
+        const stream = agentExecutor.stream({
+            input: "what is the weather in sf?",
+        });
+        const fullResponse = [];
+        for await (const item of await stream) {
+            fullResponse.push(item);
+        }
+        expect(fullResponse.length > 3).toBe(true);
+        const allAgentMessages = fullResponse.filter((res) => "agent" in res);
+        expect(allAgentMessages.length >= 3).toBe(true);
+        expect(fullResponse).toEqual([
+            {
+                agent: {
+                    agentOutcome: {
+                        log: "tool:search_api:query",
+                        tool: "search_api",
+                        toolInput: "query",
+                    },
+                },
+            },
+            {
+                action: {
+                    steps: [
+                        {
+                            action: {
+                                log: "tool:search_api:query",
+                                tool: "search_api",
+                                toolInput: "query",
+                            },
+                            observation: "result for query",
+                        },
+                    ],
+                },
+            },
+            {
+                agent: {
+                    agentOutcome: {
+                        log: "tool:search_api:another",
+                        tool: "search_api",
+                        toolInput: "another",
+                    },
+                },
+            },
+            {
+                action: {
+                    steps: [
+                        {
+                            action: {
+                                log: "tool:search_api:another",
+                                tool: "search_api",
+                                toolInput: "another",
+                            },
+                            observation: "result for another",
+                        },
+                    ],
+                },
+            },
+            {
+                agent: {
+                    agentOutcome: {
+                        log: "finish:answer",
+                        returnValues: {
+                            answer: "answer",
+                        },
+                    },
+                },
+            },
+        ]);
+    });
+});

package/dist/tests/pregel.io.test.d.ts

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