langchain 0.2.10 → 0.2.11

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

@@ -1,339 +0,0 @@
-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

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

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

@@ -1,39 +0,0 @@
-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

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

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

@@ -1,27 +0,0 @@
-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

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

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

@@ -1,89 +0,0 @@
-/* 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

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

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

@@ -1,36 +0,0 @@
-/* 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

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