langchain 0.2.2 → 0.2.3-rc.0

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

@@ -0,0 +1,71 @@
+import { test, expect } from "@jest/globals";
+import { ChatOpenAI } from "@langchain/openai";
+import { ChatPromptTemplate } from "@langchain/core/prompts";
+import { TavilySearchResults } from "../../util/testing/tools/tavily_search.js";
+import { AgentExecutor, createToolCallingAgent } from "../index.js";
+const tools = [new TavilySearchResults({ maxResults: 1 })];
+test("createToolCallingAgent works", async () => {
+    const prompt = ChatPromptTemplate.fromMessages([
+        ["system", "You are a helpful assistant"],
+        ["placeholder", "{chat_history}"],
+        ["human", "{input}"],
+        ["placeholder", "{agent_scratchpad}"],
+    ]);
+    const llm = new ChatOpenAI({
+        modelName: "gpt-4-turbo",
+        temperature: 0,
+    });
+    const agent = await createToolCallingAgent({
+        llm,
+        tools,
+        prompt,
+    });
+    const agentExecutor = new AgentExecutor({
+        agent,
+        tools,
+    });
+    const input = "what is the current weather in SF?";
+    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("createToolCallingAgent stream events works", async () => {
+    const prompt = ChatPromptTemplate.fromMessages([
+        ["system", "You are a helpful assistant"],
+        ["placeholder", "{chat_history}"],
+        ["human", "{input}"],
+        ["placeholder", "{agent_scratchpad}"],
+    ]);
+    const llm = new ChatOpenAI({
+        modelName: "gpt-4o",
+        temperature: 0,
+    });
+    const agent = await createToolCallingAgent({
+        llm,
+        tools,
+        prompt,
+    });
+    const agentExecutor = new AgentExecutor({
+        agent,
+        tools,
+    });
+    const input = "what is the current weather in SF?";
+    const eventStream = agentExecutor.streamEvents({
+        input,
+    }, {
+        version: "v2",
+    });
+    for await (const event of eventStream) {
+        const eventType = event.event;
+        console.log("Event type: ", eventType);
+        if (eventType === "on_chat_model_stream") {
+            console.log("Content: ", event.data);
+        }
+    }
+});

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

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

package/dist/agents/tests/create_xml_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, createXmlAgent } from "../index.js";
+const tools = [new TavilySearchResults({ maxResults: 1 })];
+test("createXmlAgent works", async () => {
+    const prompt = await pull("hwchase17/xml-agent-convo");
+    const llm = new ChatOpenAI({
+        modelName: "gpt-4-turbo",
+        temperature: 0,
+    });
+    const agent = await createXmlAgent({
+        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/json.test.d.ts

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

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

@@ -0,0 +1,74 @@
+import { test, expect } from "@jest/globals";
+import { JsonListKeysTool, JsonSpec, JsonGetValueTool, } from "../../tools/json.js";
+test("JsonListKeysTool", async () => {
+    const jsonSpec = new JsonSpec({
+        foo: "bar",
+        baz: { test: { foo: [1, 2, 3], qux: [{ x: 1, y: 2, z: 3 }, { a: 1 }] } },
+    });
+    const jsonListKeysTool = new JsonListKeysTool(jsonSpec);
+    expect(await jsonListKeysTool.invoke("")).toBe("foo, baz");
+    expect(await jsonListKeysTool.invoke("/foo")).toContain("not a dictionary");
+    expect(await jsonListKeysTool.invoke("/baz")).toBe("test");
+    expect(await jsonListKeysTool.invoke("/baz/test")).toBe("foo, qux");
+    expect(await jsonListKeysTool.invoke("/baz/test/foo")).toContain("not a dictionary");
+    expect(await jsonListKeysTool.invoke("/baz/test/foo/0")).toContain("not a dictionary");
+    expect(await jsonListKeysTool.invoke("/baz/test/qux")).toContain("not a dictionary");
+    expect(await jsonListKeysTool.invoke("/baz/test/qux/0")).toBe("x, y, z");
+    expect(await jsonListKeysTool.invoke("/baz/test/qux/1")).toBe("a");
+    expect(await jsonListKeysTool.invoke("/bar")).toContain("not a dictionary");
+});
+test("JsonListKeysTool, paths containing escaped characters", async () => {
+    const jsonSpec = new JsonSpec({
+        paths: {
+            "a~b": 1,
+            "a/b": 2,
+            "a~/b": 3,
+            "a//~b": 4,
+        },
+    });
+    const jsonListKeyTool = new JsonListKeysTool(jsonSpec);
+    expect(await jsonListKeyTool.invoke("/paths")).toBe("a~0b, a~1b, a~0~1b, a~1~1~0b");
+});
+test("JsonGetValueTool", async () => {
+    const jsonSpec = new JsonSpec({
+        foo: "bar",
+        baz: { test: { foo: [1, 2, 3], qux: [{ x: 1, y: 2, z: 3 }, { a: 1 }] } },
+    });
+    const jsonGetValueTool = new JsonGetValueTool(jsonSpec);
+    expect(await jsonGetValueTool.invoke("")).toBe(`{"foo":"bar","baz":{"test":{"foo":[1,2,3],"qux":[{"x":1,"y":2,"z":3},{"a":1}]}}}`);
+    expect(await jsonGetValueTool.invoke("/foo")).toBe("bar");
+    expect(await jsonGetValueTool.invoke("/baz")).toBe(`{"test":{"foo":[1,2,3],"qux":[{"x":1,"y":2,"z":3},{"a":1}]}}`);
+    expect(await jsonGetValueTool.invoke("/baz/test")).toBe(`{"foo":[1,2,3],"qux":[{"x":1,"y":2,"z":3},{"a":1}]}`);
+    expect(await jsonGetValueTool.invoke("/baz/test/foo")).toBe("[1,2,3]");
+    expect(await jsonGetValueTool.invoke("/baz/test/foo/0")).toBe("1");
+    expect(await jsonGetValueTool.invoke("/baz/test/qux")).toBe(`[{"x":1,"y":2,"z":3},{"a":1}]`);
+    expect(await jsonGetValueTool.invoke("/baz/test/qux/0")).toBe(`{"x":1,"y":2,"z":3}`);
+    expect(await jsonGetValueTool.invoke("/baz/test/qux/0/x")).toBe("1");
+    expect(await jsonGetValueTool.invoke("/baz/test/qux/1")).toBe(`{"a":1}`);
+    expect(await jsonGetValueTool.invoke("/bar")).toContain(`null`);
+});
+test("JsonGetValueTool, large values", async () => {
+    const jsonSpec = new JsonSpec({ foo: "bar", baz: { test: { foo: [1, 2, 3, 4] } } }, 5);
+    const jsonGetValueTool = new JsonGetValueTool(jsonSpec);
+    expect(await jsonGetValueTool.invoke("")).toContain("large dictionary");
+    expect(await jsonGetValueTool.invoke("/foo")).toBe("bar");
+    expect(await jsonGetValueTool.invoke("/baz")).toContain("large dictionary");
+    expect(await jsonGetValueTool.invoke("/baz/test")).toContain("large dictionary");
+    expect(await jsonGetValueTool.invoke("/baz/test/foo")).toBe("[1,2,...");
+    expect(await jsonGetValueTool.invoke("/baz/test/foo/0")).toBe("1");
+});
+test("JsonGetValueTool, paths containing escaped characters", async () => {
+    const jsonSpec = new JsonSpec({
+        paths: {
+            "~IDSGenericFXCrossRate": 1,
+            "/IDSGenericFXCrossRate": 2,
+            "~/IDSGenericFXCrossRate": 3,
+            "/~IDSGenericFXCrossRate": 4,
+        },
+    });
+    const jsonGetValueTool = new JsonGetValueTool(jsonSpec);
+    expect(await jsonGetValueTool.invoke("/paths/~0IDSGenericFXCrossRate")).toBe("1");
+    expect(await jsonGetValueTool.invoke("/paths/~1IDSGenericFXCrossRate")).toBe("2");
+    expect(await jsonGetValueTool.invoke("/paths/~0~1IDSGenericFXCrossRate")).toBe("3");
+    expect(await jsonGetValueTool.invoke("/paths/~1~0IDSGenericFXCrossRate")).toBe("4");
+});

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

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

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

@@ -0,0 +1,44 @@
+import { ReActSingleInputOutputParser } from "../react/output_parser.js";
+test("ReActSingleInputOutputParser identifies final answer", async () => {
+    const finalAnswerText = `Observation: 2.169459462491557
+  Thought: I now know the final answer
+  Final Answer: Harry Styles, Olivia Wilde's boyfriend, is 29 years old and his age raised to the 0.23 power is 2.169459462491557.`;
+    const outputParser = new ReActSingleInputOutputParser({
+        toolNames: [],
+    });
+    const parsedOutput = await outputParser.parse(finalAnswerText);
+    console.log(parsedOutput);
+    expect(parsedOutput).toHaveProperty("returnValues");
+    expect("returnValues" in parsedOutput && parsedOutput.returnValues.output).toEqual("Harry Styles, Olivia Wilde's boyfriend, is 29 years old and his age raised to the 0.23 power is 2.169459462491557.");
+});
+test("ReActSingleInputOutputParser identifies agent actions", async () => {
+    const finalAnswerText = `Observation: 29 years
+  Thought: I need to calculate 29 raised to the 0.23 power
+  Action: calculator
+  Action Input: 29^0.23`;
+    const outputParser = new ReActSingleInputOutputParser({
+        toolNames: [],
+    });
+    const parsedOutput = await outputParser.parse(finalAnswerText);
+    console.log(parsedOutput);
+    expect(parsedOutput).toHaveProperty("toolInput");
+    expect(parsedOutput).toHaveProperty("tool");
+});
+test("ReActSingleInputOutputParser throws if no agent finish/action is passed", async () => {
+    const finalAnswerText = `Who is Harry Styles' girlfriend?`;
+    const outputParser = new ReActSingleInputOutputParser({
+        toolNames: [],
+    });
+    await expect(outputParser.parse(finalAnswerText)).rejects.toThrow();
+});
+test("ReActSingleInputOutputParser throws if agent finish and action are passed", async () => {
+    const finalAnswerText = `Observation: 29 years
+  Thought: I need to calculate 29 raised to the 0.23 power
+  Action: calculator
+  Action Input: 29^0.23
+  Final Answer: Harry Styles, Olivia Wilde's boyfriend, is 29 years old and his age raised to the 0.23 power is 2.169459462491557.`;
+    const outputParser = new ReActSingleInputOutputParser({
+        toolNames: [],
+    });
+    await expect(outputParser.parse(finalAnswerText)).rejects.toThrow();
+});

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

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

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

@@ -0,0 +1,104 @@
+/* eslint-disable no-process-env */
+import { test } from "@jest/globals";
+import { ChatOpenAI } from "@langchain/openai";
+import { ChatPromptTemplate, MessagesPlaceholder, } from "@langchain/core/prompts";
+import { AIMessage, FunctionMessage, } from "@langchain/core/messages";
+import { convertToOpenAIFunction } from "@langchain/core/utils/function_calling";
+import { RunnableSequence } from "@langchain/core/runnables";
+import { AgentExecutor } from "../executor.js";
+import { SerpAPI } from "../../util/testing/tools/serpapi.js";
+import { Calculator } from "../../util/testing/tools/calculator.js";
+import { OpenAIFunctionsAgentOutputParser } from "../openai/output_parser.js";
+test("Runnable variant", async () => {
+    const tools = [new Calculator(), new SerpAPI()];
+    const model = new ChatOpenAI({ modelName: "gpt-4", temperature: 0 });
+    const prompt = ChatPromptTemplate.fromMessages([
+        ["ai", "You are a helpful assistant"],
+        ["human", "{input}"],
+        new MessagesPlaceholder("agent_scratchpad"),
+    ]);
+    const modelWithTools = model.bind({
+        functions: [...tools.map((tool) => convertToOpenAIFunction(tool))],
+    });
+    const formatAgentSteps = (steps) => steps.flatMap(({ action, observation }) => {
+        if ("messageLog" in action && action.messageLog !== undefined) {
+            const log = action.messageLog;
+            return log.concat(new FunctionMessage(observation, action.tool));
+        }
+        else {
+            return [new AIMessage(action.log)];
+        }
+    });
+    const runnableAgent = RunnableSequence.from([
+        {
+            input: (i) => i.input,
+            agent_scratchpad: (i) => formatAgentSteps(i.steps),
+        },
+        prompt,
+        modelWithTools,
+        new OpenAIFunctionsAgentOutputParser(),
+    ]);
+    const executor = AgentExecutor.fromAgentAndTools({
+        agent: runnableAgent,
+        tools,
+    });
+    console.log("Loaded agent executor");
+    const query = "What is the weather in New York?";
+    console.log(`Calling agent executor with query: ${query}`);
+    const result = await executor.invoke({
+        input: query,
+    });
+    console.log(result);
+});
+test("Runnable variant executor astream log", async () => {
+    const tools = [new Calculator(), new SerpAPI()];
+    const model = new ChatOpenAI({
+        modelName: "gpt-4",
+        temperature: 0,
+        streaming: true,
+    });
+    const prompt = ChatPromptTemplate.fromMessages([
+        ["ai", "You are a helpful assistant"],
+        ["human", "{input}"],
+        new MessagesPlaceholder("agent_scratchpad"),
+    ]);
+    const modelWithTools = model.bind({
+        functions: [...tools.map((tool) => convertToOpenAIFunction(tool))],
+    });
+    const formatAgentSteps = (steps) => steps.flatMap(({ action, observation }) => {
+        if ("messageLog" in action && action.messageLog !== undefined) {
+            const log = action.messageLog;
+            return log.concat(new FunctionMessage(observation, action.tool));
+        }
+        else {
+            return [new AIMessage(action.log)];
+        }
+    });
+    const runnableAgent = RunnableSequence.from([
+        {
+            input: (i) => i.input,
+            agent_scratchpad: (i) => formatAgentSteps(i.steps),
+        },
+        prompt,
+        modelWithTools,
+        new OpenAIFunctionsAgentOutputParser(),
+    ]);
+    const executor = AgentExecutor.fromAgentAndTools({
+        agent: runnableAgent,
+        tools,
+    });
+    console.log("Loaded agent executor");
+    const query = "What is the weather in New York?";
+    console.log(`Calling agent executor with query: ${query}`);
+    const stream = await executor.streamLog({
+        input: query,
+    });
+    let hasSeenLLMLogPatch = false;
+    for await (const chunk of stream) {
+        console.log(JSON.stringify(chunk));
+        if (chunk.ops[0].path.includes("ChatOpenAI")) {
+            hasSeenLLMLogPatch = true;
+        }
+    }
+    expect(hasSeenLLMLogPatch).toBe(true);
+});

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

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

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

@@ -0,0 +1,133 @@
+/* eslint-disable no-process-env */
+import { test, expect, beforeEach, afterEach } from "@jest/globals";
+import { DataSource } from "typeorm";
+import { InfoSqlTool, QuerySqlTool, ListTablesSqlTool, QueryCheckerTool, } from "../../tools/sql.js";
+import { SqlDatabase } from "../../sql_db.js";
+const previousEnv = process.env;
+let db;
+beforeEach(async () => {
+    const datasource = new DataSource({
+        type: "sqlite",
+        database: ":memory:",
+        synchronize: true,
+    });
+    await datasource.initialize();
+    await datasource.query(`
+        CREATE TABLE products (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, price INTEGER);
+    `);
+    await datasource.query(`
+        INSERT INTO products (name, price) VALUES ('Apple', 100);
+    `);
+    await datasource.query(`
+        INSERT INTO products (name, price) VALUES ('Banana', 200);
+    `);
+    await datasource.query(`
+        INSERT INTO products (name, price) VALUES ('Orange', 300);
+    `);
+    await datasource.query(`
+        CREATE TABLE users (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, age INTEGER);
+    `);
+    await datasource.query(`
+        INSERT INTO users (name, age) VALUES ('Alice', 20);
+    `);
+    await datasource.query(`
+        INSERT INTO users (name, age) VALUES ('Bob', 21);
+    `);
+    await datasource.query(`
+        INSERT INTO users (name, age) VALUES ('Charlie', 22);
+    `);
+    db = await SqlDatabase.fromDataSourceParams({
+        appDataSource: datasource,
+    });
+    process.env = { ...previousEnv, OPENAI_API_KEY: "test" };
+});
+afterEach(async () => {
+    process.env = previousEnv;
+    await db.appDataSource.destroy();
+});
+test.skip("QuerySqlTool", async () => {
+    const querySqlTool = new QuerySqlTool(db);
+    const result = await querySqlTool.invoke("SELECT * FROM users");
+    expect(result).toBe(`[{"id":1,"name":"Alice","age":20},{"id":2,"name":"Bob","age":21},{"id":3,"name":"Charlie","age":22}]`);
+});
+test.skip("QuerySqlTool with error", async () => {
+    const querySqlTool = new QuerySqlTool(db);
+    const result = await querySqlTool.invoke("SELECT * FROM userss");
+    expect(result).toBe(`QueryFailedError: SQLITE_ERROR: no such table: userss`);
+});
+test.skip("InfoSqlTool", async () => {
+    const infoSqlTool = new InfoSqlTool(db);
+    const result = await infoSqlTool.invoke("users, products");
+    const expectStr = `
+CREATE TABLE products (
+id INTEGER , name TEXT , price INTEGER ) 
+SELECT * FROM "products" LIMIT 3;
+ id name price
+ 1 Apple 100
+ 2 Banana 200
+ 3 Orange 300
+CREATE TABLE users (
+id INTEGER , name TEXT , age INTEGER ) 
+SELECT * FROM "users" LIMIT 3;
+ id name age
+ 1 Alice 20
+ 2 Bob 21
+ 3 Charlie 22`;
+    expect(result.trim()).toBe(expectStr.trim());
+});
+test.skip("InfoSqlTool with customDescription", async () => {
+    db.customDescription = {
+        products: "Custom Description for Products Table",
+        users: "Custom Description for Users Table",
+        userss: "Should not appear",
+    };
+    const infoSqlTool = new InfoSqlTool(db);
+    const result = await infoSqlTool.invoke("users, products");
+    const expectStr = `
+Custom Description for Products Table
+CREATE TABLE products (
+id INTEGER , name TEXT , price INTEGER ) 
+SELECT * FROM "products" LIMIT 3;
+ id name price
+ 1 Apple 100
+ 2 Banana 200
+ 3 Orange 300
+Custom Description for Users Table
+CREATE TABLE users (
+id INTEGER , name TEXT , age INTEGER ) 
+SELECT * FROM "users" LIMIT 3;
+ id name age
+ 1 Alice 20
+ 2 Bob 21
+ 3 Charlie 22`;
+    expect(result.trim()).toBe(expectStr.trim());
+});
+test.skip("InfoSqlTool with error", async () => {
+    const infoSqlTool = new InfoSqlTool(db);
+    const result = await infoSqlTool.invoke("userss, products");
+    expect(result).toBe(`Error: Wrong target table name: the table userss was not found in the database`);
+});
+test.skip("ListTablesSqlTool", async () => {
+    const listSqlTool = new ListTablesSqlTool(db);
+    const result = await listSqlTool.invoke("");
+    expect(result).toBe(`products, users`);
+});
+test.skip("QueryCheckerTool", async () => {
+    const queryCheckerTool = new QueryCheckerTool();
+    expect(queryCheckerTool.llmChain).not.toBeNull();
+    expect(queryCheckerTool.llmChain.inputKeys).toEqual(["query"]);
+});
+test.skip("ListTablesSqlTool with include tables", async () => {
+    const includesTables = ["users"];
+    db.includesTables = includesTables;
+    const listSqlTool = new ListTablesSqlTool(db);
+    const result = await listSqlTool.invoke("");
+    expect(result).toBe("users");
+});
+test.skip("ListTablesSqlTool with ignore tables", async () => {
+    const ignoreTables = ["products"];
+    db.ignoreTables = ignoreTables;
+    const listSqlTool = new ListTablesSqlTool(db);
+    const result = await listSqlTool.invoke("");
+    expect(result).toBe("users");
+});

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

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

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

@@ -0,0 +1,35 @@
+import { test, expect } from "@jest/globals";
+import { StructuredChatOutputParser } from "../structured_chat/outputParser.js";
+test("Can parse JSON with text in front of it", async () => {
+    const testCases = [
+        {
+            input: 'Here we have some boilerplate nonsense```json\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'```",
+        },
+    ];
+    const p = new StructuredChatOutputParser({ toolNames: ["blogpost"] });
+    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/structured_chat_output_parser_with_retries.int.test.d.ts

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

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

@@ -0,0 +1,44 @@
+import { test, expect } from "@jest/globals";
+import { ChatOpenAI } from "@langchain/openai";
+import { StructuredChatOutputParserWithRetries } from "../structured_chat/outputParser.js";
+test("Can parse JSON with text in front of it", async () => {
+    const testCases = [
+        {
+            input: 'Here we have an invalid format (missing markdown block) that the parser should retry and fix: {\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',
+            tool: "blogpost",
+            toolInput: "```sql\nSELECT * FROM orders\nJOIN users ON users.id = orders.user_id\nWHERE users.email = 'bud'```",
+        },
+        {
+            input: 'Here we have an invalid format (missing markdown block) with a structured tool that the parser should retry and fix: {\n \t\r\n"action": "blogpost",\n\t\r  "action_input": {"query": "SELECT * FROM orders\\nJOIN users ON users.id = orders.user_id\\nWHERE users.email = $1",\n\t"parameters": ["bud"]\n\t}\n\t\r}\n\n\n\t\r and at the end there is more nonsense',
+            tool: "blogpost",
+            toolInput: {
+                query: "SELECT * FROM orders\nJOIN users ON users.id = orders.user_id\nWHERE users.email = $1",
+                parameters: ["bud"],
+            },
+        },
+        {
+            input: `I don't know the answer.`,
+            tool: "Final Answer",
+            toolInput: "I don't know the answer.",
+        },
+    ];
+    const p = StructuredChatOutputParserWithRetries.fromLLM(new ChatOpenAI({ temperature: 0, modelName: "gpt-3.5-turbo" }), {
+        toolNames: ["blogpost"],
+    });
+    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/structured_output_runnables.int.test.d.ts

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