@langchain/langgraph 0.0.30 → 0.0.32

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

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

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

@@ -1,198 +0,0 @@
-import { describe, expect, it } from "@jest/globals";
-import { PregelNode } from "../pregel/read.js";
-import { GraphValidationError, validateGraph } from "../pregel/validate.js";
-import { LastValue } from "../channels/last_value.js";
-describe("validateGraph", () => {
-    it("should throw an error if a node is named __interrupt__", () => {
-        // set up test
-        const nodes = {
-            __interrupt__: new PregelNode({
-                channels: [""],
-                triggers: [],
-            }),
-        };
-        const channels = {
-            "": new LastValue(),
-        };
-        // call method / assertions
-        expect(() => {
-            validateGraph({
-                nodes,
-                channels,
-                inputChannels: "",
-                outputChannels: "",
-                streamChannels: "",
-                interruptAfterNodes: [],
-                interruptBeforeNodes: [],
-            });
-        }).toThrow(GraphValidationError);
-    });
-    it("should throw an error if a node is not the correct type", () => {
-        // set up test
-        class PregelNodeSubclass extends PregelNode {
-        }
-        const nodes = {
-            channelName: new PregelNodeSubclass({
-                channels: [""],
-                triggers: [],
-            }),
-        };
-        const channels = {
-            "": new LastValue(),
-        };
-        // call method / assertions
-        expect(() => {
-            validateGraph({
-                nodes,
-                channels,
-                inputChannels: "",
-                outputChannels: "",
-                streamChannels: "",
-                interruptAfterNodes: [],
-                interruptBeforeNodes: [],
-            });
-        }).toThrow(GraphValidationError);
-    });
-    it("should throw an error if input channel is not subscribed to by any node", () => {
-        // set up test
-        const nodes = {
-            channelName1: new PregelNode({
-                channels: [""],
-                triggers: ["channelName2"],
-            }),
-        };
-        const channels = {
-            "": new LastValue(),
-        };
-        // call method / assertions
-        expect(() => {
-            validateGraph({
-                nodes,
-                channels,
-                // @ts-expect-error - testing invalid input
-                inputChannels: "channelName3",
-                outputChannels: "",
-                streamChannels: "",
-                interruptAfterNodes: [],
-                interruptBeforeNodes: [],
-            });
-        }).toThrow(GraphValidationError);
-    });
-    it("should throw an error if none of the input channels are subscribed to by any node", () => {
-        // set up test
-        const nodes = {
-            channelName1: new PregelNode({
-                channels: [""],
-                triggers: ["channelName2"],
-            }),
-        };
-        const channels = {
-            "": new LastValue(),
-        };
-        // call method / assertions
-        expect(() => {
-            validateGraph({
-                nodes,
-                channels,
-                // @ts-expect-error - testing invalid input
-                inputChannels: ["channelName3", "channelName4", "channelName5"],
-                outputChannels: "",
-                streamChannels: "",
-                interruptAfterNodes: [],
-                interruptBeforeNodes: [],
-            });
-        }).toThrow(GraphValidationError);
-    });
-    it("should throw an error if 'interrupt after' nodes not in nodes map", () => {
-        // set up test
-        const nodes = {
-            channelName1: new PregelNode({
-                channels: [""],
-                triggers: ["channelName2"],
-            }),
-        };
-        const channels = {
-            "": new LastValue(),
-        };
-        // call method / assertions
-        expect(() => {
-            validateGraph({
-                nodes,
-                channels,
-                inputChannels: [""],
-                outputChannels: "",
-                streamChannels: "",
-                interruptAfterNodes: ["channelName3"],
-                interruptBeforeNodes: [],
-            });
-        }).toThrow(GraphValidationError);
-    });
-    it("should throw an error if 'interrupt after' nodes not in nodes map", () => {
-        // set up test
-        const nodes = {
-            channelName1: new PregelNode({
-                channels: [""],
-                triggers: ["channelName2"],
-            }),
-        };
-        const channels = {
-            "": new LastValue(),
-        };
-        // call method / assertions
-        expect(() => {
-            validateGraph({
-                nodes,
-                channels,
-                inputChannels: [""],
-                outputChannels: "",
-                streamChannels: "",
-                interruptAfterNodes: [],
-                interruptBeforeNodes: ["channelName3"],
-            });
-        }).toThrow(GraphValidationError);
-    });
-    it("should thrown on missing channels", () => {
-        // set up test
-        const nodes = {
-            channelName1: new PregelNode({
-                channels: [""],
-                triggers: ["channelName2"],
-            }),
-        };
-        const channels1 = {
-            "": new LastValue(),
-            channelName2: new LastValue(),
-        };
-        // call method / assertions
-        expect(() => validateGraph({
-            nodes,
-            channels: channels1,
-            inputChannels: "channelName2",
-            // @ts-expect-error - testing invalid input
-            outputChannels: "channelName3",
-            interruptAfterNodes: [],
-            interruptBeforeNodes: [],
-        })).toThrow(GraphValidationError);
-        // call method / assertions
-        expect(() => validateGraph({
-            nodes,
-            channels: channels1,
-            // @ts-expect-error - testing invalid input
-            inputChannels: "channelName3",
-            outputChannels: "channelName2",
-            interruptAfterNodes: [],
-            interruptBeforeNodes: [],
-        })).toThrow(GraphValidationError);
-        // call method / assertions
-        expect(() => validateGraph({
-            nodes,
-            channels: channels1,
-            inputChannels: "channelName2",
-            outputChannels: "",
-            // @ts-expect-error - testing invalid input
-            streamChannels: "channelName4",
-            interruptAfterNodes: [],
-            interruptBeforeNodes: [],
-        })).toThrow(GraphValidationError);
-    });
-});

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

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

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

@@ -1,44 +0,0 @@
-import { describe, expect, it } from "@jest/globals";
-import { RunnablePassthrough } from "@langchain/core/runnables";
-import { ChannelWrite, PASSTHROUGH } from "../pregel/write.js";
-describe("ChannelWrite", () => {
-    describe("_getWriteValues", () => {
-        it("should return the expect object", async () => {
-            // set up test
-            const channelWrite = new ChannelWrite([
-                {
-                    channel: "someChannel1",
-                    value: 1,
-                    skipNone: false,
-                },
-                {
-                    channel: "someChannel2",
-                    value: PASSTHROUGH,
-                    skipNone: false,
-                    mapper: new RunnablePassthrough(),
-                },
-                {
-                    channel: "someChannel3",
-                    value: null,
-                    skipNone: true,
-                },
-                {
-                    channel: "someChannel4",
-                    value: PASSTHROUGH,
-                    skipNone: false,
-                },
-            ]);
-            const input = 2;
-            const config = {};
-            // call method / assertions
-            const writeValues = await channelWrite._getWriteValues(input, config);
-            const expectedWriteValues = {
-                someChannel1: 1,
-                someChannel2: 2,
-                // someChannel3 should be filtered out
-                someChannel4: 2, // value is set to input value since PASSTHROUGH value was specified
-            };
-            expect(writeValues).toEqual(expectedWriteValues);
-        });
-    });
-});

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

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