@langchain/core 0.2.18 → 0.2.20

package/dist/prompts/tests/few_shot.test.js

@@ -1,224 +0,0 @@
-import { expect, test } from "@jest/globals";
-import { FewShotChatMessagePromptTemplate, FewShotPromptTemplate, } from "../few_shot.js";
-import { ChatPromptTemplate } from "../index.js";
-import { PromptTemplate } from "../prompt.js";
-import { LengthBasedExampleSelector } from "../../example_selectors/length_based.js";
-import { AIMessage, HumanMessage } from "../../messages/index.js";
-describe("FewShotPromptTemplate", () => {
-    test("Test using partial", async () => {
-        const examplePrompt = PromptTemplate.fromTemplate("{foo}{bar}");
-        const prompt = new FewShotPromptTemplate({
-            prefix: "{foo}{bar}",
-            examples: [],
-            suffix: "",
-            templateFormat: "f-string",
-            exampleSeparator: "\n",
-            examplePrompt,
-            inputVariables: ["foo"],
-            partialVariables: { bar: "baz" },
-        });
-        expect(await prompt.format({ foo: "foo" })).toBe("foobaz\n");
-    });
-    test("Test using full partial", async () => {
-        const examplePrompt = PromptTemplate.fromTemplate("{foo}{bar}");
-        const prompt = new FewShotPromptTemplate({
-            prefix: "{foo}{bar}",
-            examples: [],
-            suffix: "",
-            templateFormat: "f-string",
-            exampleSeparator: "\n",
-            examplePrompt,
-            inputVariables: [],
-            partialVariables: { bar: "baz", foo: "boo" },
-        });
-        expect(await prompt.format({})).toBe("boobaz\n");
-    });
-    test("Test partial with string", async () => {
-        const examplePrompt = PromptTemplate.fromTemplate("{foo}{bar}");
-        const prompt = new FewShotPromptTemplate({
-            prefix: "{foo}{bar}",
-            examples: [],
-            suffix: "",
-            templateFormat: "f-string",
-            exampleSeparator: "\n",
-            examplePrompt,
-            inputVariables: ["foo", "bar"],
-        });
-        const partialPrompt = await prompt.partial({ foo: "foo" });
-        expect(await partialPrompt.format({ bar: "baz" })).toBe("foobaz\n");
-        expect(prompt.inputVariables).toEqual(["foo", "bar"]);
-    });
-    test("Test partial with function", async () => {
-        const examplePrompt = PromptTemplate.fromTemplate("{foo}{bar}");
-        const prompt = new FewShotPromptTemplate({
-            prefix: "{foo}{bar}",
-            examples: [],
-            suffix: "",
-            templateFormat: "f-string",
-            exampleSeparator: "\n",
-            examplePrompt,
-            inputVariables: ["foo", "bar"],
-        });
-        const partialPrompt = await prompt.partial({
-            foo: () => Promise.resolve("boo"),
-        });
-        expect(await partialPrompt.format({ bar: "baz" })).toBe("boobaz\n");
-    });
-    test("Test partial with function and examples", async () => {
-        const examplePrompt = PromptTemplate.fromTemplate("An example about {x}");
-        const prompt = new FewShotPromptTemplate({
-            prefix: "{foo}{bar}",
-            examples: [{ x: "foo" }, { x: "bar" }],
-            suffix: "",
-            templateFormat: "f-string",
-            exampleSeparator: "\n",
-            examplePrompt,
-            inputVariables: ["foo", "bar"],
-        });
-        const partialPrompt = await prompt.partial({
-            foo: () => Promise.resolve("boo"),
-        });
-        expect(await partialPrompt.format({ bar: "baz" })).toBe(`boobaz
-An example about foo
-An example about bar
-`);
-    });
-    test("Test partial with function and example selector", async () => {
-        const examplePrompt = PromptTemplate.fromTemplate("An example about {x}");
-        const exampleSelector = await LengthBasedExampleSelector.fromExamples([{ x: "foo" }, { x: "bar" }], { examplePrompt, maxLength: 200 });
-        const prompt = new FewShotPromptTemplate({
-            prefix: "{foo}{bar}",
-            exampleSelector,
-            suffix: "",
-            templateFormat: "f-string",
-            exampleSeparator: "\n",
-            examplePrompt,
-            inputVariables: ["foo", "bar"],
-        });
-        const partialPrompt = await prompt.partial({
-            foo: () => Promise.resolve("boo"),
-        });
-        expect(await partialPrompt.format({ bar: "baz" })).toBe(`boobaz
-An example about foo
-An example about bar
-`);
-    });
-});
-describe("FewShotChatMessagePromptTemplate", () => {
-    test("Format messages", async () => {
-        const examplePrompt = ChatPromptTemplate.fromMessages([
-            ["ai", "{ai_input_var}"],
-            ["human", "{human_input_var}"],
-        ]);
-        const examples = [
-            {
-                ai_input_var: "ai-foo",
-                human_input_var: "human-bar",
-            },
-            {
-                ai_input_var: "ai-foo2",
-                human_input_var: "human-bar2",
-            },
-        ];
-        const prompt = new FewShotChatMessagePromptTemplate({
-            examplePrompt,
-            inputVariables: ["ai_input_var", "human_input_var"],
-            examples,
-        });
-        const messages = await prompt.formatMessages({});
-        expect(messages).toEqual([
-            new AIMessage("ai-foo"),
-            new HumanMessage("human-bar"),
-            new AIMessage("ai-foo2"),
-            new HumanMessage("human-bar2"),
-        ]);
-    });
-    test("Test using partial", async () => {
-        const examplePrompt = ChatPromptTemplate.fromMessages([
-            ["ai", "{foo}{bar}"],
-        ]);
-        const prompt = new FewShotChatMessagePromptTemplate({
-            prefix: "{foo}{bar}",
-            examples: [],
-            suffix: "",
-            templateFormat: "f-string",
-            exampleSeparator: "\n",
-            examplePrompt,
-            inputVariables: ["foo"],
-            partialVariables: { bar: "baz" },
-        });
-        expect(await prompt.format({ foo: "foo" })).toBe("foobaz\n");
-    });
-    test("Test using full partial", async () => {
-        const examplePrompt = ChatPromptTemplate.fromMessages([
-            ["ai", "{foo}{bar}"],
-        ]);
-        const prompt = new FewShotChatMessagePromptTemplate({
-            prefix: "{foo}{bar}",
-            examples: [],
-            suffix: "",
-            templateFormat: "f-string",
-            exampleSeparator: "\n",
-            examplePrompt,
-            inputVariables: [],
-            partialVariables: { bar: "baz", foo: "boo" },
-        });
-        expect(await prompt.format({})).toBe("boobaz\n");
-    });
-    test("Test partial with string", async () => {
-        const examplePrompt = ChatPromptTemplate.fromMessages([
-            ["ai", "{foo}{bar}"],
-        ]);
-        const prompt = new FewShotChatMessagePromptTemplate({
-            prefix: "{foo}{bar}",
-            examples: [],
-            suffix: "",
-            templateFormat: "f-string",
-            exampleSeparator: "\n",
-            examplePrompt,
-            inputVariables: ["foo", "bar"],
-        });
-        const partialPrompt = await prompt.partial({ foo: "foo" });
-        expect(await partialPrompt.format({ bar: "baz" })).toBe("foobaz\n");
-        expect(prompt.inputVariables).toEqual(["foo", "bar"]);
-    });
-    test("Test partial with function", async () => {
-        const examplePrompt = ChatPromptTemplate.fromMessages([
-            ["ai", "{foo}{bar}"],
-        ]);
-        const prompt = new FewShotChatMessagePromptTemplate({
-            prefix: "{foo}{bar}",
-            examples: [],
-            suffix: "",
-            templateFormat: "f-string",
-            exampleSeparator: "\n",
-            examplePrompt,
-            inputVariables: ["foo", "bar"],
-        });
-        const partialPrompt = await prompt.partial({
-            foo: () => Promise.resolve("boo"),
-        });
-        expect(await partialPrompt.format({ bar: "baz" })).toBe("boobaz\n");
-    });
-    test("Test partial with function and examples", async () => {
-        const examplePrompt = ChatPromptTemplate.fromMessages([
-            ["ai", "An example about {x}"],
-        ]);
-        const prompt = new FewShotChatMessagePromptTemplate({
-            prefix: "{foo}{bar}",
-            examples: [{ x: "foo" }, { x: "bar" }],
-            suffix: "",
-            templateFormat: "f-string",
-            exampleSeparator: "\n",
-            examplePrompt,
-            inputVariables: ["foo", "bar"],
-        });
-        const partialPrompt = await prompt.partial({
-            foo: () => Promise.resolve("boo"),
-        });
-        expect(await partialPrompt.format({ bar: "baz" })).toBe(`boobaz
-An example about foo
-An example about bar
-`);
-    });
-});

package/dist/prompts/tests/pipeline.test.d.ts

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

package/dist/prompts/tests/pipeline.test.js

@@ -1,101 +0,0 @@
-import { expect, test } from "@jest/globals";
-import { PromptTemplate } from "../prompt.js";
-import { ChatPromptTemplate, HumanMessagePromptTemplate, MessagesPlaceholder, SystemMessagePromptTemplate, } from "../chat.js";
-import { PipelinePromptTemplate } from "../pipeline.js";
-test("Test pipeline input variables", async () => {
-    const prompt = new PipelinePromptTemplate({
-        pipelinePrompts: [
-            {
-                name: "bar",
-                prompt: PromptTemplate.fromTemplate("{foo}"),
-            },
-        ],
-        finalPrompt: PromptTemplate.fromTemplate("{bar}"),
-    });
-    expect(prompt.inputVariables).toEqual(["foo"]);
-});
-test("Test simple pipeline", async () => {
-    const prompt = new PipelinePromptTemplate({
-        pipelinePrompts: [
-            {
-                name: "bar",
-                prompt: PromptTemplate.fromTemplate("{foo}"),
-            },
-        ],
-        finalPrompt: PromptTemplate.fromTemplate("{bar}"),
-    });
-    expect(await prompt.format({
-        foo: "jim",
-    })).toEqual("jim");
-});
-test("Test multi variable pipeline", async () => {
-    const prompt = new PipelinePromptTemplate({
-        pipelinePrompts: [
-            {
-                name: "bar",
-                prompt: PromptTemplate.fromTemplate("{foo}"),
-            },
-        ],
-        finalPrompt: PromptTemplate.fromTemplate("okay {bar} {baz}"),
-    });
-    expect(await prompt.format({
-        foo: "jim",
-        baz: "halpert",
-    })).toEqual("okay jim halpert");
-});
-test("Test longer pipeline", async () => {
-    const prompt = new PipelinePromptTemplate({
-        pipelinePrompts: [
-            {
-                name: "bar",
-                prompt: PromptTemplate.fromTemplate("{foo}"),
-            },
-            {
-                name: "qux",
-                prompt: PromptTemplate.fromTemplate("hi {bar}"),
-            },
-        ],
-        finalPrompt: PromptTemplate.fromTemplate("okay {qux} {baz}"),
-    });
-    expect(await prompt.format({
-        foo: "pam",
-        baz: "beasley",
-    })).toEqual("okay hi pam beasley");
-});
-test("Test with .partial", async () => {
-    const prompt = new PipelinePromptTemplate({
-        pipelinePrompts: [
-            {
-                name: "bar",
-                prompt: PromptTemplate.fromTemplate("{foo}"),
-            },
-        ],
-        finalPrompt: PromptTemplate.fromTemplate("okay {bar} {baz}"),
-    });
-    const partialPrompt = await prompt.partial({
-        baz: "schrute",
-    });
-    expect(await partialPrompt.format({
-        foo: "dwight",
-    })).toEqual("okay dwight schrute");
-});
-test("Test with chat prompts", async () => {
-    const prompt = new PipelinePromptTemplate({
-        pipelinePrompts: [
-            {
-                name: "foo",
-                prompt: ChatPromptTemplate.fromMessages([
-                    HumanMessagePromptTemplate.fromTemplate(`{name} halpert`),
-                ]),
-            },
-        ],
-        finalPrompt: ChatPromptTemplate.fromMessages([
-            SystemMessagePromptTemplate.fromTemplate("What is your name?"),
-            new MessagesPlaceholder("foo"),
-        ]),
-    });
-    const formattedPromptValue = await prompt.formatPromptValue({
-        name: "pam",
-    });
-    expect(formattedPromptValue.messages[1].content).toEqual("pam halpert");
-});

package/dist/prompts/tests/prompt.mustache.test.d.ts

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

package/dist/prompts/tests/prompt.mustache.test.js

@@ -1,105 +0,0 @@
-import { test, expect } from "@jest/globals";
-import { PromptTemplate } from "../prompt.js";
-import { parseTemplate } from "../template.js";
-test("Single input variable.", async () => {
-    const template = "This is a {{foo}} test.";
-    const prompt = PromptTemplate.fromTemplate(template, {
-        templateFormat: "mustache",
-    });
-    const formattedPrompt = await prompt.format({ foo: "bar" });
-    expect(formattedPrompt).toBe("This is a bar test.");
-    expect(prompt.inputVariables).toEqual(["foo"]);
-});
-test("Multiple input variables.", async () => {
-    const template = "This {{bar}} is a {{foo}} test.";
-    const prompt = PromptTemplate.fromTemplate(template, {
-        templateFormat: "mustache",
-    });
-    const formattedPrompt = await prompt.format({ bar: "baz", foo: "bar" });
-    expect(formattedPrompt).toBe("This baz is a bar test.");
-    expect(prompt.inputVariables).toEqual(["bar", "foo"]);
-});
-test("Multiple input variables with repeats.", async () => {
-    const template = "This {{bar}} is a {{foo}} test {{foo}}.";
-    const prompt = PromptTemplate.fromTemplate(template, {
-        templateFormat: "mustache",
-    });
-    const formattedPrompt = await prompt.format({ bar: "baz", foo: "bar" });
-    expect(formattedPrompt).toBe("This baz is a bar test bar.");
-    expect(prompt.inputVariables).toEqual(["bar", "foo"]);
-});
-test("Ignores f-string inputs input variables with repeats.", async () => {
-    const template = "This {bar} is a {foo} test {foo}.";
-    const prompt = PromptTemplate.fromTemplate(template, {
-        templateFormat: "mustache",
-    });
-    const formattedPrompt = await prompt.format({ bar: "baz", foo: "bar" });
-    expect(formattedPrompt).toBe("This {bar} is a {foo} test {foo}.");
-    expect(prompt.inputVariables).toEqual([]);
-});
-test("Nested variables.", async () => {
-    const template = "This {{obj.bar}} is a {{obj.foo}} test {{foo.bar.baz}}. Single: {{single}}";
-    const prompt = PromptTemplate.fromTemplate(template, {
-        templateFormat: "mustache",
-    });
-    const formattedPrompt = await prompt.format({
-        obj: { bar: "foo", foo: "bar" },
-        foo: {
-            bar: {
-                baz: "baz",
-            },
-        },
-        single: "one",
-    });
-    expect(formattedPrompt).toBe("This foo is a bar test baz. Single: one");
-    expect(prompt.inputVariables).toEqual(["obj", "foo", "single"]);
-});
-test("section/context variables", async () => {
-    const template = `This{{#foo}}
-{{bar}}
-{{/foo}}is a test.`;
-    const prompt = PromptTemplate.fromTemplate(template, {
-        templateFormat: "mustache",
-    });
-    const formattedPrompt = await prompt.format({ foo: { bar: "yo" } });
-    expect(formattedPrompt).toEqual(`This
-yo
-is a test.`);
-    expect(prompt.inputVariables).toEqual(["foo"]);
-});
-test("section/context variables with repeats", async () => {
-    const template = `This{{#foo}}
-{{bar}}
-{{/foo}}is a test.`;
-    const promptWithRepeats = PromptTemplate.fromTemplate(template, {
-        templateFormat: "mustache",
-    });
-    const formattedPrompt = await promptWithRepeats.format({
-        foo: [{ bar: "yo" }, { bar: "hello" }],
-    });
-    expect(formattedPrompt).toEqual(`This
-yo
-
-hello
-is a test.`);
-    expect(promptWithRepeats.inputVariables).toEqual(["foo"]);
-});
-test("Escaped variables", async () => {
-    const template = `test: {{{text}}}`;
-    const parsed = parseTemplate(template, "mustache");
-    expect(parsed[0]).toStrictEqual({
-        type: "literal",
-        text: "test: ",
-    });
-    expect(parsed[1]).toStrictEqual({
-        type: "variable",
-        name: "text",
-    });
-    const promptTemplate = PromptTemplate.fromTemplate(template, {
-        templateFormat: "mustache",
-    });
-    const result = await promptTemplate.invoke({
-        text: `hello i have a "quote`,
-    });
-    expect(result.value).toBe(`test: hello i have a "quote`);
-});

package/dist/prompts/tests/prompt.test.d.ts

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

package/dist/prompts/tests/prompt.test.js

@@ -1,78 +0,0 @@
-import { expect, test } from "@jest/globals";
-import { PromptTemplate } from "../prompt.js";
-test("Test using partial", async () => {
-    const prompt = new PromptTemplate({
-        template: "{foo}{bar}",
-        inputVariables: ["foo"],
-        partialVariables: { bar: "baz" },
-    });
-    expect(await prompt.format({ foo: "foo" })).toBe("foobaz");
-});
-test("Test using partial with an extra variable", async () => {
-    const prompt = new PromptTemplate({
-        template: "{foo}{bar}",
-        inputVariables: ["foo"],
-        partialVariables: { bar: "baz" },
-    });
-    expect(await prompt.format({ foo: "foo", unused: "nada" })).toBe("foobaz");
-});
-test("Test fromTemplate", async () => {
-    const prompt = PromptTemplate.fromTemplate("{foo}{bar}");
-    expect((await prompt.invoke({ foo: "foo", bar: "baz", unused: "eee" })).value).toBe("foobaz");
-});
-test("Test fromTemplate with escaped strings", async () => {
-    const prompt = PromptTemplate.fromTemplate("{{foo}}{{bar}}");
-    expect(await prompt.format({ unused: "eee" })).toBe("{foo}{bar}");
-});
-test("Test fromTemplate with type parameter", async () => {
-    const prompt = PromptTemplate.fromTemplate("test");
-    // @ts-expect-error TS compiler should flag
-    expect(await prompt.format({ unused: "eee" })).toBe("test");
-});
-test("Test fromTemplate with missing variable should raise compiler error", async () => {
-    const prompt = PromptTemplate.fromTemplate("{foo}");
-    await expect(async () => {
-        // @ts-expect-error TS compiler should flag missing variable
-        await prompt.format({ unused: "eee" });
-    }).rejects.toThrow();
-    await expect(async () => {
-        // @ts-expect-error TS compiler should flag missing variable
-        await prompt.invoke({ unused: "eee" });
-    }).rejects.toThrow();
-});
-test("Test fromTemplate with extra variable should work", async () => {
-    const prompt = PromptTemplate.fromTemplate("{foo}");
-    expect(await prompt.format({ foo: "test", unused: "eee" })).toBe("test");
-    expect((await prompt.invoke({ foo: "test", unused: "eee" })).value).toBe("test");
-});
-test("Test using full partial", async () => {
-    const prompt = new PromptTemplate({
-        template: "{foo}{bar}",
-        inputVariables: [],
-        partialVariables: { bar: "baz", foo: "boo" },
-    });
-    expect(await prompt.format({})).toBe("boobaz");
-});
-test("Test partial", async () => {
-    const prompt = new PromptTemplate({
-        template: "{foo}{bar}",
-        inputVariables: ["foo", "bar"],
-    });
-    expect(prompt.inputVariables).toEqual(["foo", "bar"]);
-    const partialPrompt = await prompt.partial({ foo: "foo" });
-    // original prompt is not modified
-    expect(prompt.inputVariables).toEqual(["foo", "bar"]);
-    // partial prompt has only remaining variables
-    expect(partialPrompt.inputVariables).toEqual(["bar"]);
-    expect(await partialPrompt.format({ bar: "baz" })).toBe("foobaz");
-});
-test("Test partial with function", async () => {
-    const prompt = new PromptTemplate({
-        template: "{foo}{bar}",
-        inputVariables: ["foo", "bar"],
-    });
-    const partialPrompt = await prompt.partial({
-        foo: () => Promise.resolve("boo"),
-    });
-    expect(await partialPrompt.format({ bar: "baz" })).toBe("boobaz");
-});

package/dist/prompts/tests/structured.test.d.ts

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

package/dist/prompts/tests/structured.test.js

@@ -1,37 +0,0 @@
-import { RunnableLambda } from "../../runnables/base.js";
-import { FakeListChatModel } from "../../utils/testing/index.js";
-import { StructuredPrompt } from "../structured.js";
-import { load } from "../../load/index.js";
-class FakeStructuredChatModel extends FakeListChatModel {
-    withStructuredOutput(_params, _config) {
-        if (!_config?.includeRaw) {
-            if (typeof _params === "object") {
-                const func = RunnableLambda.from((_) => _params);
-                return func;
-            }
-        }
-        throw new Error("Invalid schema");
-    }
-}
-test("Test format", async () => {
-    const schema = {
-        name: "yo",
-        description: "a structured output",
-        parameters: {
-            name: { type: "string" },
-            value: { type: "integer" },
-        },
-    };
-    const prompt = StructuredPrompt.fromMessagesAndSchema([["human", "I'm very structured, how about you?"]], schema);
-    const model = new FakeStructuredChatModel({ responses: [] });
-    const chain = prompt.pipe(model);
-    await chain.invoke({});
-    await expect(chain.invoke({})).resolves.toEqual(schema);
-    const revived = await load(JSON.stringify(prompt));
-    expect(JSON.stringify(prompt)).toEqual('{"lc":1,"type":"constructor","id":["langchain_core","prompts","structured","StructuredPrompt"],"kwargs":{"schema_":{"name":"yo","description":"a structured output","parameters":{"name":{"type":"string"},"value":{"type":"integer"}}},"input_variables":[],"messages":[{"lc":1,"type":"constructor","id":["langchain_core","prompts","chat","HumanMessagePromptTemplate"],"kwargs":{"prompt":{"lc":1,"type":"constructor","id":["langchain_core","prompts","prompt","PromptTemplate"],"kwargs":{"input_variables":[],"template_format":"f-string","template":"I\'m very structured, how about you?","schema":{"name":"yo","description":"a structured output","parameters":{"name":{"type":"string"},"value":{"type":"integer"}}}}}}}]}}');
-    const revivedChain = revived.pipe(model);
-    await expect(revivedChain.invoke({})).resolves.toEqual(schema);
-    const boundModel = model.bind({ runName: "boundModel" });
-    const chainWithBoundModel = prompt.pipe(boundModel);
-    await expect(chainWithBoundModel.invoke({})).resolves.toEqual(schema);
-});

package/dist/prompts/tests/template.test.d.ts

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

package/dist/prompts/tests/template.test.js

@@ -1,24 +0,0 @@
-import { expect, test, describe } from "@jest/globals";
-import { interpolateFString } from "../template.js";
-describe.each([
-    ["{foo}", { foo: "bar" }, "bar"],
-    ["pre{foo}post", { foo: "bar" }, "prebarpost"],
-    ["{{pre{foo}post}}", { foo: "bar" }, "{prebarpost}"],
-    ["text", {}, "text"],
-    ["}}{{", {}, "}{"],
-    ["{first}_{second}", { first: "foo", second: "bar" }, "foo_bar"],
-])("Valid f-string", (template, variables, result) => {
-    test(`Interpolation works: ${template}`, () => {
-        expect(interpolateFString(template, variables)).toBe(result);
-    });
-});
-describe.each([
-    ["{", {}],
-    ["}", {}],
-    ["{foo", {}],
-    ["foo}", {}],
-])("Invalid f-string", (template, variables) => {
-    test(`Interpolation throws: ${template}`, () => {
-        expect(() => interpolateFString(template, variables)).toThrow();
-    });
-});

package/dist/runnables/tests/runnable.test.d.ts

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