@langchain/langgraph 0.0.30 → 0.0.32

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

@@ -1,207 +0,0 @@
-/* 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 { RunnableLambda } from "@langchain/core/runnables";
-import { z } from "zod";
-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 = "";
-    // Will occur naturally if user imports from main `@langchain/langgraph` endpoint.
-    initializeAsyncLocalStorageSingleton();
-});
-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?")],
-        });
-        // 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?")],
-        }, { streamMode: "values" });
-        const fullResponse = [];
-        for await (const item of stream) {
-            fullResponse.push(item);
-        }
-        // human -> agent -> action -> agent
-        expect(fullResponse.length).toEqual(4);
-        const endState = fullResponse[fullResponse.length - 1];
-        // 1 human, 2 llm calls, 1 function call.
-        expect(endState.messages.length).toEqual(4);
-        const functionCall = endState.messages.find((message) => message._getType() === "function");
-        expect(functionCall.content).toBe(weatherResponse);
-    });
-    it("can accept RunnableToolLike tools", async () => {
-        const weatherResponse = `Not too cold, not too hot 😎`;
-        const model = new ChatOpenAI();
-        const sfWeatherTool = RunnableLambda.from(async (_) => weatherResponse);
-        const tools = [
-            sfWeatherTool.asTool({
-                name: "current_weather",
-                description: "Get the current weather report for San Francisco, CA",
-                schema: z.object({
-                    location: z.string(),
-                }),
-            }),
-        ];
-        const functionsAgentExecutor = createFunctionCallingExecutor({
-            model,
-            tools,
-        });
-        const response = await functionsAgentExecutor.invoke({
-            messages: [new HumanMessage("What's the weather like in SF?")],
-        });
-        // 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);
-    });
-});
-describe("createReactAgent", () => {
-    it("can call a tool", 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 reactAgent = createReactAgent({ llm: model, tools });
-        const response = await reactAgent.invoke({
-            messages: [new HumanMessage("What's the weather like in SF?")],
-        });
-        // It needs at least one human message and one AI message.
-        expect(response.messages.length > 1).toBe(true);
-        const lastMessage = response.messages[response.messages.length - 1];
-        expect(lastMessage._getType()).toBe("ai");
-        expect(lastMessage.content.toLowerCase()).toContain("not too cold");
-    });
-    it("can stream a tool call", 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 reactAgent = createReactAgent({ llm: model, tools });
-        const stream = await reactAgent.stream({
-            messages: [new HumanMessage("What's the weather like in SF?")],
-        }, { streamMode: "values" });
-        const fullResponse = [];
-        for await (const item of stream) {
-            fullResponse.push(item);
-        }
-        // human -> agent -> action -> agent
-        expect(fullResponse.length).toEqual(4);
-        const endState = fullResponse[fullResponse.length - 1];
-        // 1 human, 2 ai, 1 tool.
-        expect(endState.messages.length).toEqual(4);
-        const lastMessage = endState.messages[endState.messages.length - 1];
-        expect(lastMessage._getType()).toBe("ai");
-        expect(lastMessage.content.toLowerCase()).toContain("not too cold");
-    });
-});

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

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

package/dist/tests/prebuilt.test.js

@@ -1,427 +0,0 @@
-/* eslint-disable no-process-env */
-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 { AIMessage, HumanMessage, SystemMessage, ToolMessage, } from "@langchain/core/messages";
-import { z } from "zod";
-import { RunnableLambda } from "@langchain/core/runnables";
-import { FakeToolCallingChatModel } from "./utils.js";
-import { ToolNode, createAgentExecutor, createReactAgent, } 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 = "";
-});
-const searchSchema = z.object({
-    query: z.string().describe("The query to search for."),
-});
-class SearchAPI extends StructuredTool {
-    constructor() {
-        super(...arguments);
-        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."
-        });
-        Object.defineProperty(this, "schema", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: searchSchema
-        });
-    }
-    async _call(input) {
-        return `result for ${input?.query}`;
-    }
-}
-class SearchAPIWithArtifact extends StructuredTool {
-    constructor() {
-        super(...arguments);
-        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."
-        });
-        Object.defineProperty(this, "schema", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: searchSchema
-        });
-        Object.defineProperty(this, "responseFormat", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "content_and_artifact"
-        });
-    }
-    async _call(_) {
-        return ["some response format", Buffer.from("123")];
-    }
-}
-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",
-                        },
-                    },
-                },
-            },
-        ]);
-    });
-});
-describe("createReactAgent", () => {
-    const tools = [new SearchAPI()];
-    it("Can use string message modifier", async () => {
-        const llm = new FakeToolCallingChatModel({
-            responses: [
-                new AIMessage({
-                    content: "result1",
-                    tool_calls: [
-                        { name: "search_api", id: "tool_abcd123", args: { query: "foo" } },
-                    ],
-                }),
-                new AIMessage("result2"),
-            ],
-        });
-        const agent = createReactAgent({
-            llm,
-            tools,
-            messageModifier: "You are a helpful assistant",
-        });
-        const result = await agent.invoke({
-            messages: [new HumanMessage("Hello Input!")],
-        });
-        expect(result.messages).toEqual([
-            new HumanMessage("Hello Input!"),
-            new AIMessage({
-                content: "result1",
-                tool_calls: [
-                    { name: "search_api", id: "tool_abcd123", args: { query: "foo" } },
-                ],
-            }),
-            new ToolMessage({
-                name: "search_api",
-                content: "result for foo",
-                tool_call_id: "tool_abcd123",
-            }),
-            new AIMessage("result2"),
-        ]);
-    });
-    it("Can use SystemMessage message modifier", async () => {
-        const llm = new FakeToolCallingChatModel({
-            responses: [
-                new AIMessage({
-                    content: "result1",
-                    tool_calls: [
-                        { name: "search_api", id: "tool_abcd123", args: { query: "foo" } },
-                    ],
-                }),
-                new AIMessage("result2"),
-            ],
-        });
-        const agent = createReactAgent({
-            llm,
-            tools,
-            messageModifier: new SystemMessage("You are a helpful assistant"),
-        });
-        const result = await agent.invoke({
-            messages: [],
-        });
-        expect(result.messages).toEqual([
-            new AIMessage({
-                content: "result1",
-                tool_calls: [
-                    { name: "search_api", id: "tool_abcd123", args: { query: "foo" } },
-                ],
-            }),
-            new ToolMessage({
-                name: "search_api",
-                content: "result for foo",
-                tool_call_id: "tool_abcd123",
-            }),
-            new AIMessage("result2"),
-        ]);
-    });
-    it("Works with tools that return content_and_artifact response format", async () => {
-        const llm = new FakeToolCallingChatModel({
-            responses: [
-                new AIMessage({
-                    content: "result1",
-                    tool_calls: [
-                        { name: "search_api", id: "tool_abcd123", args: { query: "foo" } },
-                    ],
-                }),
-                new AIMessage("result2"),
-            ],
-        });
-        const agent = createReactAgent({
-            llm,
-            tools: [new SearchAPIWithArtifact()],
-            messageModifier: "You are a helpful assistant",
-        });
-        const result = await agent.invoke({
-            messages: [new HumanMessage("Hello Input!")],
-        });
-        expect(result.messages).toEqual([
-            new HumanMessage("Hello Input!"),
-            new AIMessage({
-                content: "result1",
-                tool_calls: [
-                    { name: "search_api", id: "tool_abcd123", args: { query: "foo" } },
-                ],
-            }),
-            new ToolMessage({
-                name: "search_api",
-                content: "some response format",
-                tool_call_id: "tool_abcd123",
-                artifact: Buffer.from("123"),
-            }),
-            new AIMessage("result2"),
-        ]);
-    });
-    it("Can accept RunnableToolLike", async () => {
-        const llm = new FakeToolCallingChatModel({
-            responses: [
-                new AIMessage({
-                    content: "result1",
-                    tool_calls: [
-                        { name: "search_api", id: "tool_abcd123", args: { query: "foo" } },
-                    ],
-                }),
-                new AIMessage("result2"),
-            ],
-        });
-        // Instead of re-implementing the tool, wrap it in a RunnableLambda and
-        // call `asTool` to create a RunnableToolLike.
-        const searchApiTool = new SearchAPI();
-        const runnableToolLikeTool = RunnableLambda.from(async (input, config) => searchApiTool.invoke(input, config)).asTool({
-            name: searchApiTool.name,
-            description: searchApiTool.description,
-            schema: searchApiTool.schema,
-        });
-        const agent = createReactAgent({
-            llm,
-            tools: [runnableToolLikeTool],
-            messageModifier: "You are a helpful assistant",
-        });
-        const result = await agent.invoke({
-            messages: [new HumanMessage("Hello Input!")],
-        });
-        expect(result.messages).toEqual([
-            new HumanMessage("Hello Input!"),
-            new AIMessage({
-                content: "result1",
-                tool_calls: [
-                    { name: "search_api", id: "tool_abcd123", args: { query: "foo" } },
-                ],
-            }),
-            new ToolMessage({
-                name: "search_api",
-                content: "result for foo",
-                tool_call_id: "tool_abcd123",
-            }),
-            new AIMessage("result2"),
-        ]);
-    });
-});
-describe("ToolNode", () => {
-    it("Should support graceful error handling", async () => {
-        const toolNode = new ToolNode([new SearchAPI()]);
-        const res = await toolNode.invoke([
-            new AIMessage({
-                content: "",
-                tool_calls: [{ name: "badtool", args: {}, id: "testid" }],
-            }),
-        ]);
-        expect(res[0].content).toEqual(`Error: Tool "badtool" not found.\n Please fix your mistakes.`);
-    });
-});

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

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