langchain 0.2.2 → 0.2.3

package/dist/output_parsers/tests/expression.test.js

@@ -0,0 +1,339 @@
+import { test } from "@jest/globals";
+import { ExpressionParser } from "../expression.js";
+const correctExps = [
+    { type: "call_expression", funcCall: "hello", args: [] },
+    {
+        type: "call_expression",
+        funcCall: "hello",
+        args: [{ type: "string_literal", value: "world" }],
+    },
+    {
+        type: "call_expression",
+        funcCall: "hello",
+        args: [
+            { type: "string_literal", value: "world" },
+            { type: "string_literal", value: "hello" },
+        ],
+    },
+    {
+        type: "call_expression",
+        funcCall: "hello",
+        args: [
+            { type: "string_literal", value: "world" },
+            { type: "string_literal", value: "hello" },
+            {
+                type: "array_literal",
+                values: [
+                    { type: "string_literal", value: "hello" },
+                    { type: "string_literal", value: "world" },
+                    { type: "numeric_literal", value: 1 },
+                    { type: "numeric_literal", value: 2.1 },
+                    { type: "numeric_literal", value: 3 },
+                ],
+            },
+        ],
+    },
+    {
+        type: "call_expression",
+        funcCall: "hello",
+        args: [
+            { type: "string_literal", value: "world" },
+            { type: "string_literal", value: "hello" },
+            {
+                type: "array_literal",
+                values: [
+                    { type: "string_literal", value: "hello" },
+                    { type: "string_literal", value: "world" },
+                    { type: "numeric_literal", value: 1 },
+                    { type: "numeric_literal", value: 2.1 },
+                    { type: "numeric_literal", value: 3 },
+                ],
+            },
+            {
+                type: "object_literal",
+                values: [
+                    {
+                        type: "property_assignment",
+                        identifier: "hello",
+                        value: { type: "string_literal", value: "world" },
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        type: "call_expression",
+        funcCall: "hello",
+        args: [
+            { type: "string_literal", value: "world" },
+            { type: "string_literal", value: "hello" },
+            {
+                type: "array_literal",
+                values: [
+                    { type: "string_literal", value: "hello" },
+                    { type: "string_literal", value: "world" },
+                    { type: "numeric_literal", value: 1 },
+                    { type: "numeric_literal", value: 2.1 },
+                    { type: "numeric_literal", value: 3 },
+                ],
+            },
+            {
+                type: "object_literal",
+                values: [
+                    {
+                        type: "property_assignment",
+                        identifier: "hello",
+                        value: { type: "string_literal", value: "world" },
+                    },
+                ],
+            },
+            { type: "numeric_literal", value: 1 },
+            { type: "numeric_literal", value: 2.1 },
+            { type: "numeric_literal", value: 3 },
+        ],
+    },
+    {
+        type: "call_expression",
+        funcCall: "hello",
+        args: [
+            { type: "string_literal", value: "world" },
+            { type: "string_literal", value: "hello" },
+            {
+                type: "array_literal",
+                values: [
+                    { type: "string_literal", value: "hello" },
+                    { type: "string_literal", value: "world" },
+                    { type: "numeric_literal", value: 1 },
+                    { type: "numeric_literal", value: 2.1 },
+                    { type: "numeric_literal", value: 3 },
+                ],
+            },
+            {
+                type: "object_literal",
+                values: [
+                    {
+                        type: "property_assignment",
+                        identifier: "hello",
+                        value: { type: "string_literal", value: "world" },
+                    },
+                ],
+            },
+            { type: "numeric_literal", value: 1 },
+            { type: "numeric_literal", value: 2.1 },
+            { type: "numeric_literal", value: 3 },
+            {
+                type: "call_expression",
+                funcCall: "world",
+                args: [
+                    { type: "string_literal", value: "hello" },
+                    { type: "string_literal", value: "world" },
+                    {
+                        type: "array_literal",
+                        values: [
+                            {
+                                type: "object_literal",
+                                values: [
+                                    {
+                                        type: "property_assignment",
+                                        identifier: "hello",
+                                        value: { type: "string_literal", value: "world" },
+                                    },
+                                ],
+                            },
+                            {
+                                type: "object_literal",
+                                values: [
+                                    {
+                                        type: "property_assignment",
+                                        identifier: "hello",
+                                        value: {
+                                            type: "call_expression",
+                                            funcCall: "hello",
+                                            args: [{ type: "string_literal", value: "world" }],
+                                        },
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        type: "call_expression",
+        funcCall: {
+            type: "member_expression",
+            identifier: "hello",
+            property: "world",
+        },
+        args: [
+            { type: "string_literal", value: "hello" },
+            { type: "string_literal", value: "world" },
+            {
+                type: "array_literal",
+                values: [
+                    { type: "string_literal", value: "hello" },
+                    { type: "string_literal", value: "world" },
+                ],
+            },
+            {
+                type: "object_literal",
+                values: [
+                    {
+                        type: "property_assignment",
+                        identifier: "hello",
+                        value: { type: "string_literal", value: "world" },
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        type: "call_expression",
+        funcCall: {
+            type: "member_expression",
+            identifier: "hello",
+            property: "world",
+        },
+        args: [
+            { type: "string_literal", value: "hello" },
+            { type: "string_literal", value: "world" },
+            {
+                type: "array_literal",
+                values: [
+                    { type: "string_literal", value: "hello" },
+                    { type: "string_literal", value: "world" },
+                ],
+            },
+        ],
+    },
+    {
+        type: "call_expression",
+        funcCall: "a",
+        args: [
+            { type: "identifier", value: "b" },
+            {
+                type: "call_expression",
+                funcCall: "c",
+                args: [
+                    { type: "identifier", value: "d" },
+                    { type: "identifier", value: "e" },
+                    {
+                        type: "array_literal",
+                        values: [
+                            { type: "identifier", value: "f" },
+                            { type: "identifier", value: "g" },
+                        ],
+                    },
+                    {
+                        type: "object_literal",
+                        values: [
+                            {
+                                type: "property_assignment",
+                                identifier: "h",
+                                value: { type: "identifier", value: "i" },
+                            },
+                        ],
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        type: "call_expression",
+        funcCall: "and",
+        args: [
+            {
+                type: "call_expression",
+                funcCall: "in",
+                args: [
+                    { type: "string_literal", value: "a" },
+                    {
+                        type: "array_literal",
+                        values: [
+                            { type: "string_literal", value: "a" },
+                            { type: "string_literal", value: "b" },
+                            { type: "string_literal", value: "c" },
+                        ],
+                    },
+                ],
+            },
+            {
+                type: "call_expression",
+                funcCall: "eq",
+                args: [
+                    { type: "string_literal", value: "a" },
+                    { type: "string_literal", value: "b" },
+                ],
+            },
+        ],
+    },
+    {
+        type: "call_expression",
+        funcCall: "with",
+        args: [
+            {
+                type: "call_expression",
+                funcCall: "const",
+                args: [
+                    { type: "string_literal", value: "a" },
+                    {
+                        type: "array_literal",
+                        values: [
+                            { type: "string_literal", value: "a" },
+                            { type: "string_literal", value: "b" },
+                            { type: "string_literal", value: "c" },
+                        ],
+                    },
+                ],
+            },
+            {
+                type: "call_expression",
+                funcCall: "eq",
+                args: [
+                    { type: "string_literal", value: "a" },
+                    { type: "string_literal", value: "b" },
+                    { type: "boolean_literal", value: true },
+                ],
+            },
+        ],
+    },
+];
+test("ExpressionParser multiple expressions test", async () => {
+    const parser = new ExpressionParser();
+    await parser.ensureParser();
+    const expressions = [
+        `hello()`,
+        `hello("world")`,
+        `hello("world", "hello")`,
+        `hello("world", "hello", ["hello", "world", 1, 2.1, 3])`,
+        `hello("world", "hello", ["hello", "world", 1, 2.1, 3], { hello: "world" })`,
+        `hello("world", "hello", ["hello", "world", 1, 2.1, 3], { hello: "world" }, 1, 2.1, 3)`,
+        `hello("world", "hello", ["hello", "world", 1, 2.1, 3], { hello: "world" }, 1, 2.1, 3, world("hello", "world", [{hello: "world"}, {"hello": hello("world")}]))`,
+        `hello.world("hello", "world", ["hello", "world"], {"hello": "world"})`,
+        `hello["world"]("hello", "world", ["hello", "world"])`,
+        `a(b, c(d, e, [f, g], {h: i}))`,
+        `and(in("a", ["a", "b", "c"]), eq("a", "b"))`,
+        `with(const("a", ["a", "b", "c"]), eq("a", "b", true))`,
+    ];
+    const badExpressions = [
+        `hello(`,
+        `hello("world", ["hello", "world", 1, 2, 3 { hello: "world" })`,
+        `hello("world", ["hello, "world", { hello: "world" )`,
+        `l:::"""(}))))++===/...`,
+    ];
+    const parsedPromise = expressions.map((expression) => parser.parse(expression));
+    const badExpressionsPromise = badExpressions.map((expression) => parser.parse(expression).catch(() => "bad"));
+    await Promise.allSettled(badExpressionsPromise).then((errors) => {
+        errors.forEach((err) => {
+            if (err.status === "fulfilled") {
+                expect(err.value).toBe("bad");
+            }
+        });
+    });
+    const parsed = await Promise.all(parsedPromise);
+    parsed.forEach((expression, index) => {
+        expect(expression).toMatchObject(correctExps[index]);
+    });
+});

package/dist/output_parsers/tests/http_response.test.d.ts

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

package/dist/output_parsers/tests/http_response.test.js

@@ -0,0 +1,39 @@
+import { FakeStreamingLLM } from "@langchain/core/utils/testing";
+import { HttpResponseOutputParser } from "../http_response.js";
+test("text/plain stream", async () => {
+    const llm = new FakeStreamingLLM({});
+    const stream = await llm
+        .pipe(new HttpResponseOutputParser())
+        .stream("Hi there!");
+    const chunks = [];
+    const decoder = new TextDecoder();
+    for await (const chunk of stream) {
+        chunks.push(decoder.decode(chunk));
+    }
+    expect(chunks.length).toEqual("Hi there!".length);
+    expect(chunks.join("")).toEqual("Hi there!");
+});
+test("text/event-stream stream", async () => {
+    const llm = new FakeStreamingLLM({});
+    const stream = await llm
+        .pipe(new HttpResponseOutputParser({ contentType: "text/event-stream" }))
+        .stream("Hi there!");
+    const chunks = [];
+    const decoder = new TextDecoder();
+    for await (const chunk of stream) {
+        chunks.push(decoder.decode(chunk));
+    }
+    expect(chunks.length).toEqual("Hi there!".length + 1);
+    expect(chunks).toEqual([
+        `event: data\ndata: "H"\n\n`,
+        `event: data\ndata: "i"\n\n`,
+        `event: data\ndata: " "\n\n`,
+        `event: data\ndata: "t"\n\n`,
+        `event: data\ndata: "h"\n\n`,
+        `event: data\ndata: "e"\n\n`,
+        `event: data\ndata: "r"\n\n`,
+        `event: data\ndata: "e"\n\n`,
+        `event: data\ndata: "!"\n\n`,
+        `event: end\n\n`,
+    ]);
+});

package/dist/output_parsers/tests/list.test.d.ts

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

package/dist/output_parsers/tests/list.test.js

@@ -0,0 +1,27 @@
+import { test, expect } from "@jest/globals";
+import { OutputParserException, CommaSeparatedListOutputParser, CustomListOutputParser, } from "@langchain/core/output_parsers";
+test("CommaSeparatedListOutputParser", async () => {
+    const parser = new CommaSeparatedListOutputParser();
+    expect(await parser.parse("hello, bye")).toEqual(["hello", "bye"]);
+    expect(await parser.parse("hello,bye")).toEqual(["hello", "bye"]);
+    expect(await parser.parse("hello")).toEqual(["hello"]);
+});
+test("CustomListOutputParser", async () => {
+    const parser1 = new CustomListOutputParser({ length: 3, separator: ";" });
+    expect(await parser1.parse("a; b;c")).toEqual(["a", "b", "c"]);
+    await expect(() => parser1.parse("a; b c")).rejects.toThrow(OutputParserException);
+    await expect(() => parser1.parse("a; b; c; d")).rejects.toThrow(OutputParserException);
+    const parser2 = new CustomListOutputParser({ separator: "\n" });
+    expect(await parser2.parse("a\nb\nc\nd")).toEqual(["a", "b", "c", "d"]);
+    const parser3 = new CustomListOutputParser({ length: 8 });
+    expect(await parser3.parse("a,b,c,d,e,f,g,h")).toEqual([
+        "a",
+        "b",
+        "c",
+        "d",
+        "e",
+        "f",
+        "g",
+        "h",
+    ]);
+});

package/dist/output_parsers/tests/openai_functions.int.test.d.ts

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

package/dist/output_parsers/tests/openai_functions.int.test.js

@@ -0,0 +1,89 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { expect, test } from "@jest/globals";
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { applyPatch } from "@langchain/core/utils/json_patch";
+import { ChatOpenAI } from "@langchain/openai";
+import { ChatPromptTemplate } from "@langchain/core/prompts";
+import { JsonOutputFunctionsParser } from "../openai_functions.js";
+import { HttpResponseOutputParser } from "../http_response.js";
+const schema = z.object({
+    setup: z.string().describe("The setup for the joke"),
+    punchline: z.string().describe("The punchline to the joke"),
+});
+const modelParams = {
+    functions: [
+        {
+            name: "joke",
+            description: "A joke",
+            parameters: zodToJsonSchema(schema),
+        },
+    ],
+    function_call: { name: "joke" },
+};
+test("Streaming JSON patch", async () => {
+    const prompt = ChatPromptTemplate.fromTemplate(`tell me a long joke about {foo}`);
+    const model = new ChatOpenAI({
+        temperature: 0,
+    }).bind(modelParams);
+    const parser = new JsonOutputFunctionsParser({ diff: true });
+    const chain = prompt.pipe(model).pipe(parser);
+    const stream = await chain.stream({
+        foo: "bears",
+    });
+    const chunks = [];
+    let aggregate = {};
+    for await (const chunk of stream) {
+        console.log(chunk);
+        chunks.push(chunk);
+        aggregate = applyPatch(aggregate, chunk).newDocument;
+    }
+    expect(chunks.length).toBeGreaterThan(1);
+    console.log(aggregate);
+    expect(aggregate.setup.length).toBeGreaterThan(1);
+    expect(aggregate.punchline.length).toBeGreaterThan(1);
+});
+test("Streaming JSON patch with an event stream output parser", async () => {
+    const prompt = ChatPromptTemplate.fromTemplate(`tell me a long joke about {foo}`);
+    const model = new ChatOpenAI({
+        temperature: 0,
+    }).bind(modelParams);
+    const jsonParser = new JsonOutputFunctionsParser({ diff: true });
+    const parser = new HttpResponseOutputParser({
+        outputParser: jsonParser,
+        contentType: "text/event-stream",
+    });
+    const chain = prompt.pipe(model).pipe(parser);
+    const stream = await chain.stream({
+        foo: "bears",
+    });
+    const chunks = [];
+    const decoder = new TextDecoder();
+    for await (const chunk of stream) {
+        console.log(decoder.decode(chunk));
+        chunks.push(chunk);
+    }
+    expect(chunks.length).toBeGreaterThan(1);
+});
+test("Streaming aggregated JSON", async () => {
+    const prompt = ChatPromptTemplate.fromTemplate(`tell me a long joke about {foo}`);
+    const model = new ChatOpenAI({
+        temperature: 0,
+    }).bind(modelParams);
+    const parser = new JsonOutputFunctionsParser();
+    const chain = prompt.pipe(model).pipe(parser);
+    const stream = await chain.stream({
+        foo: "bears",
+    });
+    const chunks = [];
+    let aggregate = {};
+    for await (const chunk of stream) {
+        console.log(chunk);
+        chunks.push(chunk);
+        aggregate = chunk;
+    }
+    expect(chunks.length).toBeGreaterThan(1);
+    console.log(aggregate);
+    expect(aggregate.setup.length).toBeGreaterThan(1);
+    expect(aggregate.punchline.length).toBeGreaterThan(1);
+});

package/dist/output_parsers/tests/openai_tools.int.test.d.ts

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

package/dist/output_parsers/tests/openai_tools.int.test.js

@@ -0,0 +1,36 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { expect, test } from "@jest/globals";
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { ChatOpenAI } from "@langchain/openai";
+import { ChatPromptTemplate } from "@langchain/core/prompts";
+import { JsonOutputToolsParser } from "../openai_tools.js";
+const schema = z.object({
+    setup: z.string().describe("The setup for the joke"),
+    punchline: z.string().describe("The punchline to the joke"),
+});
+test("Extraction", async () => {
+    const prompt = ChatPromptTemplate.fromTemplate(`tell me two jokes about {foo}`);
+    const model = new ChatOpenAI({
+        modelName: "gpt-3.5-turbo-1106",
+        temperature: 0,
+    }).bind({
+        tools: [
+            {
+                type: "function",
+                function: {
+                    name: "joke",
+                    description: "A joke",
+                    parameters: zodToJsonSchema(schema),
+                },
+            },
+        ],
+    });
+    const parser = new JsonOutputToolsParser();
+    const chain = prompt.pipe(model).pipe(parser);
+    const res = await chain.invoke({
+        foo: "bears",
+    });
+    console.log(res);
+    expect(res.length).toBe(2);
+});

package/dist/output_parsers/tests/structured.int.test.d.ts

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