langchain 0.2.2 → 0.2.3

package/dist/agents/tests/agent.int.test.d.ts

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

package/dist/agents/tests/agent.int.test.js

@@ -0,0 +1,309 @@
+/* eslint-disable no-process-env */
+import { expect, test } from "@jest/globals";
+import { OpenAI, OpenAIEmbeddings, ChatOpenAI } from "@langchain/openai";
+import { RunnableSequence } from "@langchain/core/runnables";
+import { OutputParserException } from "@langchain/core/output_parsers";
+import { ChatMessageHistory } from "../../stores/message/in_memory.js";
+import { AgentExecutor, ZeroShotAgent } from "../index.js";
+import { SerpAPI } from "../../util/testing/tools/serpapi.js";
+import { Calculator } from "../../util/testing/tools/calculator.js";
+import { initializeAgentExecutorWithOptions } from "../initialize.js";
+import { WebBrowser } from "../../tools/webbrowser.js";
+import { BufferMemory } from "../../memory/buffer_memory.js";
+test("Pass runnable to agent executor", async () => {
+    const model = new ChatOpenAI({ temperature: 0, modelName: "gpt-3.5-turbo" });
+    const tools = [
+        new SerpAPI(undefined, {
+            location: "Austin,Texas,United States",
+            hl: "en",
+            gl: "us",
+        }),
+        new Calculator(),
+    ];
+    const prompt = ZeroShotAgent.createPrompt(tools);
+    const outputParser = ZeroShotAgent.getDefaultOutputParser();
+    const runnable = RunnableSequence.from([
+        {
+            input: (i) => i.input,
+            agent_scratchpad: (i) => i.input,
+        },
+        prompt,
+        model,
+        outputParser,
+    ]);
+    const executor = AgentExecutor.fromAgentAndTools({
+        agent: runnable,
+        tools,
+    });
+    const res = await executor.invoke({
+        input: "Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?",
+    });
+    console.log({
+        res,
+    }, "Pass runnable to agent executor");
+    expect(res.output).not.toEqual("");
+    expect(res.output).not.toEqual("Agent stopped due to max iterations.");
+});
+test("Custom output parser", async () => {
+    const model = new ChatOpenAI({ temperature: 0, modelName: "gpt-3.5-turbo" });
+    const tools = [
+        new SerpAPI(undefined, {
+            location: "Austin,Texas,United States",
+            hl: "en",
+            gl: "us",
+        }),
+        new Calculator(),
+    ];
+    const parser = (output) => {
+        const text = output.content;
+        if (typeof text !== "string") {
+            throw new Error("Cannot parse non-string output.");
+        }
+        if (text.includes("Final Answer:")) {
+            return {
+                returnValues: {
+                    output: "We did it!",
+                },
+                log: text,
+            };
+        }
+        const match = /Action:([\s\S]*?)(?:\nAction Input:([\s\S]*?))?$/.exec(text);
+        if (!match) {
+            throw new OutputParserException(`Could not parse LLM output: ${text}`);
+        }
+        return {
+            tool: match[1].trim(),
+            toolInput: match[2]
+                ? match[2].trim().replace(/^("+)(.*?)(\1)$/, "$2")
+                : "",
+            log: text,
+        };
+    };
+    const prompt = ZeroShotAgent.createPrompt(tools);
+    const runnable = RunnableSequence.from([
+        {
+            input: (i) => i.input,
+            agent_scratchpad: (i) => i.input,
+        },
+        prompt,
+        model,
+        parser,
+    ]);
+    const executor = AgentExecutor.fromAgentAndTools({
+        agent: runnable,
+        tools,
+    });
+    const res = await executor.invoke({
+        input: "Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?",
+    });
+    console.log({
+        res,
+    }, "Custom output parser");
+    expect(res.output).toEqual("We did it!");
+});
+test("Add a fallback method", async () => {
+    // Model should always fail since the model name passed does not exist.
+    const modelBase = new ChatOpenAI({
+        modelName: "fake-model",
+        temperature: 10,
+    });
+    const modelLarge = new ChatOpenAI({
+        modelName: "gpt-3.5-turbo-16k",
+        temperature: 0.6,
+    });
+    const model = modelBase.withFallbacks({
+        fallbacks: [modelLarge],
+    });
+    const prompt = ZeroShotAgent.createPrompt([]);
+    const outputParser = ZeroShotAgent.getDefaultOutputParser();
+    const runnable = RunnableSequence.from([
+        {
+            input: (i) => i.input,
+            agent_scratchpad: (i) => i.input,
+        },
+        prompt,
+        model,
+        outputParser,
+    ]);
+    const executor = AgentExecutor.fromAgentAndTools({
+        agent: runnable,
+        tools: [],
+    });
+    const res = await executor.invoke({
+        input: "Is the sky blue? Response with a concise answer",
+    });
+    console.log({
+        res,
+    }, "Pass runnable to agent executor");
+    expect(res.output).not.toEqual("");
+    expect(res.output).not.toEqual("Agent stopped due to max iterations.");
+});
+test("Run agent with an abort signal", async () => {
+    const model = new OpenAI({ temperature: 0, modelName: "text-babbage-001" });
+    const tools = [new Calculator()];
+    const executor = await initializeAgentExecutorWithOptions(tools, model, {
+        agentType: "zero-shot-react-description",
+    });
+    console.log("Loaded agent.");
+    const input = `What is 3 to the fourth power?`;
+    console.log(`Executing with input "${input}"...`);
+    const controller = new AbortController();
+    await expect(() => {
+        const result = executor.call({ input, signal: controller.signal });
+        controller.abort();
+        return result;
+    }).rejects.toThrow();
+});
+test("Run agent with incorrect api key should throw error", async () => {
+    const model = new OpenAI({
+        temperature: 0,
+        modelName: "text-babbage-001",
+        openAIApiKey: "invalid",
+    });
+    const tools = [
+        new SerpAPI(undefined, {
+            location: "Austin,Texas,United States",
+            hl: "en",
+            gl: "us",
+        }),
+        new Calculator(),
+    ];
+    const executor = await initializeAgentExecutorWithOptions(tools, model, {
+        agentType: "zero-shot-react-description",
+    });
+    console.log("Loaded agent.");
+    const input = `Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?`;
+    let error;
+    // Test that the model throws an error
+    await expect(async () => {
+        try {
+            await model.invoke(input);
+        }
+        catch (e) {
+            error = e;
+            throw e;
+        }
+    }).rejects.toThrowError();
+    // Test that the agent throws the same error
+    await expect(() => executor.call({ input })).rejects.toThrowError(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    error.message);
+}, 10000);
+test("Run tool web-browser", async () => {
+    const model = new OpenAI({ temperature: 0 });
+    const tools = [
+        new SerpAPI(process.env.SERPAPI_API_KEY, {
+            location: "Austin,Texas,United States",
+            hl: "en",
+            gl: "us",
+        }),
+        new Calculator(),
+        new WebBrowser({ model, embeddings: new OpenAIEmbeddings() }),
+    ];
+    const executor = await initializeAgentExecutorWithOptions(tools, model, {
+        agentType: "zero-shot-react-description",
+        returnIntermediateSteps: true,
+    });
+    console.log("Loaded agent.");
+    const input = `What is the word of the day on merriam webster`;
+    console.log(`Executing with input "${input}"...`);
+    const result = await executor.call({ input });
+    console.log({
+        result,
+    }, "Run tool web-browser");
+    expect(result.intermediateSteps.length).toBeGreaterThanOrEqual(1);
+    expect(result.intermediateSteps[0].action.tool).toEqual("search");
+    expect(result.intermediateSteps[1].action.tool).toEqual("web-browser");
+    expect(result.output).not.toEqual("");
+    expect(result.output).not.toEqual("Agent stopped due to max iterations.");
+});
+test("Agent can stream", async () => {
+    const model = new ChatOpenAI({
+        temperature: 0,
+        modelName: "gpt-4-1106-preview",
+        streaming: true,
+    });
+    const tools = [
+        new Calculator(),
+        new WebBrowser({ model, embeddings: new OpenAIEmbeddings() }),
+    ];
+    const executor = await initializeAgentExecutorWithOptions(tools, model, {
+        agentType: "zero-shot-react-description",
+        returnIntermediateSteps: false,
+    });
+    console.log("Loaded agent.");
+    const input = `What is the word of the day on merriam webster`;
+    console.log(`Executing with input "${input}"...`);
+    const result = await executor.stream({ input });
+    let streamIters = 0;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const finalResponse = [];
+    for await (const item of result) {
+        streamIters += 1;
+        console.log("Stream item:", item);
+        // each stream does NOT contain the previous steps,
+        // because returnIntermediateSteps is false so we
+        // push each new stream item to the array.
+        finalResponse.push(item);
+    }
+    // The last item should contain "output"
+    expect("output" in finalResponse[finalResponse.length - 1]).toBeTruthy();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const intermediateSteps = finalResponse.flatMap((item) => {
+        if ("intermediateSteps" in item) {
+            return item.intermediateSteps;
+        }
+        return [];
+    });
+    expect(streamIters).toBeGreaterThan(1);
+    const toolsUsed = intermediateSteps.map((step) => step.action.tool);
+    // the last tool used should be the web-browser
+    expect(toolsUsed?.[toolsUsed.length - 1]).toEqual("web-browser");
+});
+test("Agent can stream with chat messages", async () => {
+    const model = new ChatOpenAI({
+        temperature: 0,
+        modelName: "gpt-4-1106-preview",
+        streaming: true,
+    });
+    const tools = [
+        new Calculator(),
+        new WebBrowser({ model, embeddings: new OpenAIEmbeddings() }),
+    ];
+    const memory = new BufferMemory({
+        chatHistory: new ChatMessageHistory([]),
+        memoryKey: "chat_history",
+        inputKey: "input",
+        outputKey: "output",
+        returnMessages: true,
+    });
+    const executor = await initializeAgentExecutorWithOptions(tools, model, {
+        agentType: "chat-conversational-react-description",
+        returnIntermediateSteps: true,
+        memory,
+    });
+    console.log("Loaded agent.");
+    const input = `What is the word of the day on merriam webster, and what is the sum of all letter indices (relative to the english alphabet) in the word?`;
+    console.log(`Executing with input "${input}"...`);
+    const result = await executor.stream({ input, chat_history: [] });
+    let streamIters = 0;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let finalResponse;
+    for await (const item of result) {
+        streamIters += 1;
+        console.log("Stream item:", item);
+        // each stream contains the previous steps
+        // because returnIntermediateSteps is true),
+        // so we can overwrite on each stream.
+        finalResponse = item;
+    }
+    console.log("__finalResponse__", finalResponse);
+    expect("intermediateSteps" in finalResponse).toBeTruthy();
+    expect("output" in finalResponse).toBeTruthy();
+    expect(streamIters).toBeGreaterThan(1);
+    const toolsUsed = finalResponse.intermediateSteps.map((step) => step.action.tool);
+    // the first tool used should be web-browser, and last should be calculator.
+    // This can be flaky so if the test is failing, inspect these conditions first.
+    expect(toolsUsed?.[toolsUsed.length - 1]).toEqual("calculator");
+    expect(toolsUsed?.[0]).toEqual("web-browser");
+});

package/dist/agents/tests/chat_convo_output_parser.test.d.ts

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

package/dist/agents/tests/chat_convo_output_parser.test.js

@@ -0,0 +1,91 @@
+import { test, expect } from "@jest/globals";
+import { ChatConversationalAgentOutputParser } from "../chat_convo/outputParser.js";
+test("Can parse JSON with text in front of it", async () => {
+    const testCases = [
+        {
+            input: `Based on the information from the search, I can provide you with a query to get all the orders for the email \`example@gmail.com\`. Here's the query:\n\n\`\`\`sql\nSELECT * FROM orders\nJOIN users ON users.id = orders.user_id\nWHERE users.email = 'example@gmail.com'\n\`\`\`\n\nPlease make any necessary modifications depending on your database schema and table structures. Run this query on your database to retrieve the orders made by the specified user.\n\n\`\`\`json\n{\n  "action": "Final Answer",\n  "action_input": "To get all the orders for a user with the email \`example@gmail.com\`, you can use the following query:\\n\\n\`\`\`\\nSELECT * FROM orders\\nJOIN users ON users.id = orders.user_id\\nWHERE users.email = 'example@gmail.com'\\n\`\`\`\\n\\nPlease make any necessary modifications depending on your database schema and table structures. Run this query on your database to retrieve the orders made by the specified user."\n}\n\`\`\``,
+            output: `{\n  "action": "Final Answer",\n  "action_input": "To get all the orders for a user with the email \`example@gmail.com\`, you can use the following query:\\n\\n\`\`\`\\nSELECT * FROM orders\\nJOIN users ON users.id = orders.user_id\\nWHERE users.email = 'example@gmail.com'\\n\`\`\`\\n\\nPlease make any necessary modifications depending on your database schema and table structures. Run this query on your database to retrieve the  made by the specifsredroied user."\n}`,
+            tool: "Final Answer",
+            toolInput: "To get all the orders for a user with the email ",
+        },
+        {
+            input: 'Here is an example of a valid JSON object matching the provided spec:\n\n```json\n{\n  "action": "metabase",\n  "action_input": ["GET", "/api/table/1"]\n}\n```\n\nIn this example, the "action" key has a string value of "metabase", and the "action_input" key has an array value containing two elements: a string value of "GET" and a string value of "/api/table/1". This JSON object could be used to make a request to a Metabase API endpoint with the specified method and arguments.',
+            output: `{ "action": "metabase", "action_input": ["GET", "/api/table/1"] } `,
+            tool: "metabase",
+            toolInput: ["GET", "/api/table/1"],
+        },
+        {
+            input: '```\n{\n  "action": "metabase",\n  "action_input": ["GET", "/api/table/1"]\n}\n```',
+            output: `{ "action": "metabase", "action_input": ["GET", "/api/table/1"] } `,
+            tool: "metabase",
+            toolInput: ["GET", "/api/table/1"],
+        },
+        {
+            input: 'Here we have some boilerplate nonsense```\n{\n "action": "blogpost",\n  "action_input": "```sql\\nSELECT * FROM orders\\nJOIN users ON users.id = orders.user_id\\nWHERE users.email = \'bud\'```"\n}\n``` and at the end there is more nonsense',
+            output: '{"action":"blogpost","action_input":"```sql\\nSELECT * FROM orders\\nJOIN users ON users.id = orders.user_id\\nWHERE users.email = \'bud\'```"}',
+            tool: "blogpost",
+            toolInput: "```sql\nSELECT * FROM orders\nJOIN users ON users.id = orders.user_id\nWHERE users.email = 'bud'```",
+        },
+        {
+            input: 'Here we have some boilerplate nonsense```json\n{\n \t\r\n"action": "blogpost",\n\t\r  "action_input": "```sql\\nSELECT * FROM orders\\nJOIN users ON users.id = orders.user_id\\nWHERE users.email = \'bud\'```"\n\t\r}\n\n\n\t\r``` and at the end there is more nonsense',
+            output: '{"action":"blogpost","action_input":"```sql\\nSELECT * FROM orders\\nJOIN users ON users.id = orders.user_id\\nWHERE users.email = \'bud\'```"}',
+            tool: "blogpost",
+            toolInput: "```sql\nSELECT * FROM orders\nJOIN users ON users.id = orders.user_id\nWHERE users.email = 'bud'```",
+        },
+        {
+            input: '{\n \t\r\n"action":"Final Answer",\n\t\r  "action_input":"The tool input ```json\\n{\\"yes\\":true}\\n```"\n\t\r}',
+            output: '{"action":"Final Answer","action_input":"The tool input ```json\\n{\\"yes\\":true}\\n```"}',
+            tool: "Final Answer",
+            toolInput: 'The tool input ```json\\n{\\"yes\\":true}\\n```',
+        },
+        {
+            input: '```json\n{\n \t\r\n"action":"Final Answer",\n\t\r  "action_input":"The tool input ```json\\n{\\"yes\\":true}\\n```"\n\t\r}\n\n\n\t\r```',
+            output: '{"action":"Final Answer","action_input":"The tool input ```json\\n{\\"yes\\":true}\\n```"}',
+            tool: "Final Answer",
+            toolInput: 'The tool input ```json\\n{\\"yes\\":true}\\n```',
+        },
+        {
+            input: 'Here we have some boilerplate nonsense```json\n{\n \t\r\n"action":"Final Answer",\n\t\r  "action_input":"The tool input ```json\\n{\\"yes\\":true}\\n```"\n\t\r}\n\n\n\t\r``` and at the end there is more nonsense',
+            output: '{"action":"Final Answer","action_input":"The tool input ```json\\n{\\"yes\\":true}\\n```"}',
+            tool: "Final Answer",
+            toolInput: 'The tool input ```json\\n{\\"yes\\":true}\\n```',
+        },
+        {
+            input: 'Here we have some boilerplate nonsense```\n{\n \t\r\n"action":"Final Answer",\n\t\r  "action_input":"The tool input ```javascript\\n{\\"yes\\":true}\\n```"\n\t\r}\n\n\n\t\r``` and at the end there is more nonsense',
+            output: '{"action":"Final Answer","action_input":"The tool input ```javascript\\n{\\"yes\\":true}\\n```"}',
+            tool: "Final Answer",
+            toolInput: 'The tool input ```javascript\\n{\\"yes\\":true}\\n```',
+        },
+        {
+            input: '{\n \t\r\n"action":"Final Answer",\n\t\r  "action_input":"The tool input ```javascript\\n{\\"yes\\":true}\\n```"\n\t\r}',
+            output: '{"action":"Final Answer","action_input":"The tool input ```javascript\\n{\\"yes\\":true}\\n```"}',
+            tool: "Final Answer",
+            toolInput: 'The tool input ```javascript\\n{\\"yes\\":true}\\n```',
+        },
+        {
+            input: '{\n \t\r\n"action":"Final Answer",\n\t\r  "action_input":"this is a regular text response"\n\t\r}',
+            output: '{"action":"Final Answer","action_input":"this is a regular text response"}',
+            tool: "Final Answer",
+            toolInput: "this is a regular text response",
+        },
+    ];
+    const p = new ChatConversationalAgentOutputParser({
+        toolNames: ["blogpost", "metabase", "ToolWithJson"],
+    });
+    for (const message of testCases) {
+        const parsed = await p.parse(message.input);
+        expect(parsed).toBeDefined();
+        if (message.tool === "Final Answer") {
+            expect(parsed.returnValues).toBeDefined();
+        }
+        else {
+            expect(parsed.tool).toEqual(message.tool);
+            if (typeof message.toolInput === "object") {
+                expect(message.toolInput).toEqual(parsed.toolInput);
+            }
+            if (typeof message.toolInput === "string") {
+                expect(message.toolInput).toContain(parsed.toolInput);
+            }
+        }
+    }
+});

package/dist/agents/tests/create_openai_functions_agent.int.test.d.ts

@@ -0,0 +1,2 @@
+/** eslint-disable @typescript-eslint/no-non-null-assertion */
+export {};

package/dist/agents/tests/create_openai_functions_agent.int.test.js

@@ -0,0 +1,71 @@
+/** eslint-disable @typescript-eslint/no-non-null-assertion */
+import { test, expect } from "@jest/globals";
+import { ChatOpenAI } from "@langchain/openai";
+import { TavilySearchResults } from "../../util/testing/tools/tavily_search.js";
+import { pull } from "../../hub.js";
+import { AgentExecutor, createOpenAIFunctionsAgent } from "../index.js";
+const tools = [new TavilySearchResults({ maxResults: 1 })];
+test("createOpenAIFunctionsAgent works", async () => {
+    const prompt = await pull("hwchase17/openai-functions-agent");
+    const llm = new ChatOpenAI({
+        modelName: "gpt-3.5-turbo-1106",
+        temperature: 0,
+    });
+    const agent = await createOpenAIFunctionsAgent({
+        llm,
+        tools,
+        prompt,
+    });
+    const agentExecutor = new AgentExecutor({
+        agent,
+        tools,
+    });
+    const input = "what is LangChain?";
+    const result = await agentExecutor.invoke({
+        input,
+    });
+    console.log(result);
+    expect(result.input).toBe(input);
+    expect(typeof result.output).toBe("string");
+    // Length greater than 10 because any less than that would warrant
+    // an investigation into why such a short generation was returned.
+    expect(result.output.length).toBeGreaterThan(10);
+});
+test("createOpenAIFunctionsAgent can stream log", async () => {
+    const prompt = await pull("hwchase17/openai-functions-agent");
+    const llm = new ChatOpenAI({
+        modelName: "gpt-3.5-turbo-1106",
+        temperature: 0,
+        streaming: true,
+    });
+    const agent = await createOpenAIFunctionsAgent({
+        llm,
+        tools,
+        prompt,
+    });
+    const agentExecutor = new AgentExecutor({
+        agent,
+        tools,
+    });
+    const input = "tell me a short story.";
+    const logStream = await agentExecutor.streamLog({
+        input,
+    });
+    const chunks = [];
+    let firstChunkTime;
+    for await (const chunk of logStream) {
+        if (!firstChunkTime) {
+            firstChunkTime = new Date().getTime();
+        }
+        console.log(chunk);
+        chunks.push(chunk);
+    }
+    if (!firstChunkTime) {
+        throw new Error("firstChunkTime was not set.");
+    }
+    console.log(chunks.length);
+    console.log();
+    console.log("Time to complete after first chunk:", new Date().getTime() - firstChunkTime);
+    console.log(chunks.length);
+    expect(chunks.length).toBeGreaterThan(1);
+});

package/dist/agents/tests/create_openai_tools_agent.int.test.d.ts

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

package/dist/agents/tests/create_openai_tools_agent.int.test.js

@@ -0,0 +1,75 @@
+import { test, expect } from "@jest/globals";
+import { ChatOpenAI } from "@langchain/openai";
+import { RunnableLambda } from "@langchain/core/runnables";
+import { LangChainTracer } from "@langchain/core/tracers/tracer_langchain";
+import { AsyncLocalStorageProviderSingleton } from "@langchain/core/singletons";
+import { AsyncLocalStorage } from "async_hooks";
+import { TavilySearchResults } from "../../util/testing/tools/tavily_search.js";
+import { pull } from "../../hub.js";
+import { AgentExecutor, createOpenAIToolsAgent } from "../index.js";
+const tools = [new TavilySearchResults({ maxResults: 1 })];
+test("createOpenAIToolsAgent works", async () => {
+    const prompt = await pull("hwchase17/openai-tools-agent");
+    const llm = new ChatOpenAI({
+        modelName: "gpt-3.5-turbo-1106",
+        temperature: 0,
+    });
+    const agent = await createOpenAIToolsAgent({
+        llm,
+        tools,
+        prompt,
+    });
+    const agentExecutor = new AgentExecutor({
+        agent,
+        tools,
+    });
+    const input = "what is LangChain?";
+    const result = await agentExecutor.invoke({
+        input,
+    });
+    console.log(result);
+    expect(result.input).toBe(input);
+    expect(typeof result.output).toBe("string");
+    // Length greater than 10 because any less than that would warrant
+    // an investigation into why such a short generation was returned.
+    expect(result.output.length).toBeGreaterThan(10);
+});
+test.skip("createOpenAIToolsAgent tracing works when it is nested in a lambda", async () => {
+    AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new AsyncLocalStorage());
+    const prompt = await pull("hwchase17/openai-tools-agent");
+    const llm = new ChatOpenAI({
+        modelName: "gpt-3.5-turbo-1106",
+        temperature: 0,
+    });
+    const agent = await createOpenAIToolsAgent({
+        llm,
+        tools,
+        prompt,
+    });
+    const agentExecutor = new AgentExecutor({
+        agent,
+        tools,
+    });
+    const outer = RunnableLambda.from(async (input) => {
+        const noop = RunnableLambda.from(() => "hi").withConfig({
+            runName: "nested_testing",
+        });
+        const noopRes = await noop.invoke({ nested: "nested" });
+        console.log(noopRes);
+        const res = await agentExecutor.invoke({
+            input,
+        });
+        return res;
+    });
+    const input = "what is LangChain?";
+    const result = await outer.invoke(input, {
+        tags: ["test"],
+        callbacks: [new LangChainTracer({ projectName: "langchainjs-tracing-2" })],
+    });
+    console.log(result);
+    expect(result.input).toBe(input);
+    expect(typeof result.output).toBe("string");
+    // Length greater than 10 because any less than that would warrant
+    // an investigation into why such a short generation was returned.
+    expect(result.output.length).toBeGreaterThan(10);
+});

package/dist/agents/tests/create_react_agent.int.test.d.ts

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

package/dist/agents/tests/create_react_agent.int.test.js

@@ -0,0 +1,32 @@
+import { test, expect } from "@jest/globals";
+import { OpenAI } from "@langchain/openai";
+import { TavilySearchResults } from "../../util/testing/tools/tavily_search.js";
+import { pull } from "../../hub.js";
+import { AgentExecutor, createReactAgent } from "../index.js";
+const tools = [new TavilySearchResults({ maxResults: 1 })];
+test("createReactAgent works", async () => {
+    const prompt = await pull("hwchase17/react");
+    const llm = new OpenAI({
+        modelName: "gpt-3.5-turbo-instruct",
+        temperature: 0,
+    });
+    const agent = await createReactAgent({
+        llm,
+        tools,
+        prompt,
+    });
+    const agentExecutor = new AgentExecutor({
+        agent,
+        tools,
+    });
+    const input = "what is LangChain?";
+    const result = await agentExecutor.invoke({
+        input,
+    });
+    console.log(result);
+    expect(result.input).toBe(input);
+    expect(typeof result.output).toBe("string");
+    // Length greater than 10 because any less than that would warrant
+    // an investigation into why such a short generation was returned.
+    expect(result.output.length).toBeGreaterThan(10);
+});

package/dist/agents/tests/create_structured_chat_agent.int.test.d.ts

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

package/dist/agents/tests/create_structured_chat_agent.int.test.js

@@ -0,0 +1,32 @@
+import { test, expect } from "@jest/globals";
+import { ChatOpenAI } from "@langchain/openai";
+import { TavilySearchResults } from "../../util/testing/tools/tavily_search.js";
+import { pull } from "../../hub.js";
+import { AgentExecutor, createStructuredChatAgent } from "../index.js";
+const tools = [new TavilySearchResults({ maxResults: 1 })];
+test("createStructuredChatAgent works", async () => {
+    const prompt = await pull("hwchase17/structured-chat-agent");
+    const llm = new ChatOpenAI({
+        modelName: "gpt-3.5-turbo-1106",
+        temperature: 0,
+    });
+    const agent = await createStructuredChatAgent({
+        llm,
+        tools,
+        prompt,
+    });
+    const agentExecutor = new AgentExecutor({
+        agent,
+        tools,
+    });
+    const input = "what is LangChain?";
+    const result = await agentExecutor.invoke({
+        input,
+    });
+    console.log(result);
+    expect(result.input).toBe(input);
+    expect(typeof result.output).toBe("string");
+    // Length greater than 10 because any less than that would warrant
+    // an investigation into why such a short generation was returned.
+    expect(result.output.length).toBeGreaterThan(10);
+});

package/dist/agents/tests/create_tool_calling_agent.int.test.d.ts

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