@langchain/core 0.2.0 → 0.2.1

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

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

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

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

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

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

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

@@ -0,0 +1,85 @@
+import { test, expect } from "@jest/globals";
+import { PromptTemplate } from "../prompt.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"]);
+});

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,24 @@
+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();
+    });
+});