@langchain/core 0.2.0 → 0.2.1

package/dist/language_models/tests/chat_models.test.js

@@ -0,0 +1,154 @@
+/* eslint-disable no-promise-executor-return */
+import { test } from "@jest/globals";
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { FakeChatModel, FakeListChatModel } from "../../utils/testing/index.js";
+test("Test ChatModel uses callbacks", async () => {
+    const model = new FakeChatModel({});
+    let acc = "";
+    const response = await model.invoke("Hello there!", {
+        callbacks: [
+            {
+                handleLLMNewToken: (token) => {
+                    console.log(token);
+                    acc += token;
+                },
+            },
+        ],
+    });
+    expect(response.content).toEqual(acc);
+});
+test("Test ChatModel uses callbacks with a cache", async () => {
+    const model = new FakeChatModel({
+        cache: true,
+    });
+    let acc = "";
+    const response = await model.invoke("Hello there!");
+    const response2 = await model.invoke("Hello there!", {
+        callbacks: [
+            {
+                handleLLMNewToken: (token) => {
+                    console.log(token);
+                    acc += token;
+                },
+            },
+        ],
+    });
+    // If callbacks are backgrounded
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    expect(response.content).toEqual(response2.content);
+    expect(response2.content).toEqual(acc);
+});
+test("Test ChatModel legacy params withStructuredOutput", async () => {
+    const model = new FakeListChatModel({
+        responses: [`{ "test": true, "nested": { "somethingelse": "somevalue" } }`],
+    }).withStructuredOutput({
+        includeRaw: false,
+        schema: z.object({
+            test: z.boolean(),
+            nested: z.object({
+                somethingelse: z.string(),
+            }),
+        }),
+    });
+    const response = await model.invoke("Hello there!");
+    // @ts-expect-error not in run output type
+    console.log(response.notthere);
+    console.log(response.nested.somethingelse);
+    expect(response).toEqual({
+        test: true,
+        nested: { somethingelse: "somevalue" },
+    });
+});
+// test("Test ChatModel legacy params includeRaw withStructuredOutput", async () => {
+//   const model = new FakeListChatModel({
+//     responses: [`{ "test": true, "nested": { "somethingelse": "somevalue" } }`],
+//   }).withStructuredOutput({
+//     includeRaw: true,
+//     schema: z.object({
+//       test: z.boolean(),
+//       nested: z.object({
+//         somethingelse: z.string(),
+//       }),
+//     }),
+//   });
+//   const response = await model.invoke("Hello there!");
+//   // @ts-expect-error legacy
+//   console.log(response.nested);
+//   console.log(response.parsed.nested);
+// });
+test("Test ChatModel withStructuredOutput with supplied type arg", async () => {
+    const model = new FakeListChatModel({
+        responses: [`{ "test": true, "nested": { "somethingelse": "somevalue" } }`],
+    }).withStructuredOutput({
+        includeRaw: false,
+        schema: z.object({
+            test: z.boolean(),
+            nested: z.object({
+                somethingelse: z.string(),
+            }),
+        }),
+    });
+    const response = await model.invoke("Hello there!");
+    // @ts-expect-error run output type forced to something else
+    console.log(response.nested.somethingelse);
+    // No error here
+    console.log(response.forcedArg);
+    expect(response).toEqual({
+        test: true,
+        nested: { somethingelse: "somevalue" },
+    });
+});
+test("Test ChatModel withStructuredOutput new syntax", async () => {
+    const model = new FakeListChatModel({
+        responses: [`{ "test": true, "nested": { "somethingelse": "somevalue" } }`],
+    }).withStructuredOutput(z.object({
+        test: z.boolean(),
+        nested: z.object({
+            somethingelse: z.string(),
+        }),
+    }));
+    const response = await model.invoke("Hello there!");
+    // @ts-expect-error run output type forced to something else
+    console.log(response.nested.somethingelse);
+    // No error here
+    console.log(response.forcedArg);
+    expect(response).toEqual({
+        test: true,
+        nested: { somethingelse: "somevalue" },
+    });
+});
+test("Test ChatModel withStructuredOutput new syntax and JSON schema", async () => {
+    const model = new FakeListChatModel({
+        responses: [`{ "test": true, "nested": { "somethingelse": "somevalue" } }`],
+    }).withStructuredOutput(zodToJsonSchema(z.object({
+        test: z.boolean(),
+        nested: z.object({
+            somethingelse: z.string(),
+        }),
+    })));
+    const response = await model.invoke("Hello there!");
+    // No error here
+    console.log(response.nested.somethingelse);
+    // Also no error here
+    console.log(response.forcedArg);
+    expect(response).toEqual({
+        test: true,
+        nested: { somethingelse: "somevalue" },
+    });
+});
+test("Test ChatModel withStructuredOutput new syntax and includeRaw", async () => {
+    const model = new FakeListChatModel({
+        responses: [`{ "test": true, "nested": { "somethingelse": "somevalue" } }`],
+    }).withStructuredOutput(z.object({
+        test: z.boolean(),
+        nested: z.object({
+            somethingelse: z.string(),
+        }),
+    }), { includeRaw: true });
+    const response = await model.invoke("Hello there!");
+    // @ts-expect-error run output includes raw
+    console.log(response.nested.somethingelse);
+    // No error
+    console.log(response.parsed);
+});

package/dist/language_models/tests/count_tokens.test.d.ts

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

package/dist/language_models/tests/count_tokens.test.js

@@ -0,0 +1,19 @@
+import { test, expect } from "@jest/globals";
+import { calculateMaxTokens, getModelContextSize } from "../base.js";
+test("properly calculates correct max tokens", async () => {
+    expect(await calculateMaxTokens({ prompt: "", modelName: "gpt-3.5-turbo-16k" })).toBe(16384);
+    expect(await calculateMaxTokens({
+        prompt: "",
+        modelName: "gpt-3.5-turbo-16k-0613",
+    })).toBe(16384);
+    expect(await calculateMaxTokens({ prompt: "", modelName: "gpt-3.5-turbo" })).toBe(4096);
+    expect(await calculateMaxTokens({ prompt: "", modelName: "gpt-4" })).toBe(8192);
+    expect(await calculateMaxTokens({ prompt: "", modelName: "gpt-4-32k" })).toBe(32768);
+});
+test("properly gets model context size", async () => {
+    expect(await getModelContextSize("gpt-3.5-turbo-16k")).toBe(16384);
+    expect(await getModelContextSize("gpt-3.5-turbo-16k-0613")).toBe(16384);
+    expect(await getModelContextSize("gpt-3.5-turbo")).toBe(4096);
+    expect(await getModelContextSize("gpt-4")).toBe(8192);
+    expect(await getModelContextSize("gpt-4-32k")).toBe(32768);
+});

package/dist/language_models/tests/llms.test.d.ts

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

package/dist/language_models/tests/llms.test.js

@@ -0,0 +1,39 @@
+/* eslint-disable no-promise-executor-return */
+import { test } from "@jest/globals";
+import { FakeLLM } from "../../utils/testing/index.js";
+test("Test FakeLLM uses callbacks", async () => {
+    const model = new FakeLLM({});
+    let acc = "";
+    const response = await model.invoke("Hello there!", {
+        callbacks: [
+            {
+                handleLLMNewToken: (token) => {
+                    console.log(token);
+                    acc += token;
+                },
+            },
+        ],
+    });
+    expect(response).toEqual(acc);
+});
+test("Test FakeLLM uses callbacks with a cache", async () => {
+    const model = new FakeLLM({
+        cache: true,
+    });
+    let acc = "";
+    const response = await model.invoke("Hello there!");
+    const response2 = await model.invoke("Hello there!", {
+        callbacks: [
+            {
+                handleLLMNewToken: (token) => {
+                    console.log(token);
+                    acc += token;
+                },
+            },
+        ],
+    });
+    // If callbacks are backgrounded
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    expect(response).toEqual(response2);
+    expect(response2).toEqual(acc);
+});

package/dist/messages/tests/base_message.test.d.ts

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

package/dist/messages/tests/base_message.test.js

@@ -0,0 +1,97 @@
+import { test } from "@jest/globals";
+import { ChatPromptTemplate } from "../../prompts/chat.js";
+import { HumanMessage, AIMessage, ToolMessage } from "../index.js";
+import { load } from "../../load/index.js";
+test("Test ChatPromptTemplate can format OpenAI content image messages", async () => {
+    const message = new HumanMessage({
+        content: [
+            {
+                type: "image_url",
+                image_url: {
+                    url: `data:image/jpeg;base64,{image_string}`,
+                },
+            },
+        ],
+    });
+    const prompt = ChatPromptTemplate.fromMessages([
+        message,
+        ["ai", "Will this format with multiple messages?: {yes_or_no}"],
+    ]);
+    const formatted = await prompt.invoke({
+        image_string: "base_64_encoded_string",
+        yes_or_no: "YES!",
+    });
+    expect(formatted.messages[0].content[0]).toEqual({
+        type: "image_url",
+        image_url: {
+            url: "data:image/jpeg;base64,base_64_encoded_string",
+        },
+    });
+    expect(formatted.messages[1].content).toEqual("Will this format with multiple messages?: YES!");
+});
+test("Test ChatPromptTemplate can format OpenAI content image messages", async () => {
+    const message = new HumanMessage({
+        content: [
+            {
+                type: "image_url",
+                image_url: {
+                    url: `data:image/jpeg;base64,{image_string}`,
+                },
+            },
+        ],
+    });
+    const prompt = ChatPromptTemplate.fromMessages([
+        message,
+        ["ai", "Will this format with multiple messages?: {yes_or_no}"],
+    ]);
+    const formatted = await prompt.invoke({
+        image_string: "base_64_encoded_string",
+        yes_or_no: "YES!",
+    });
+    expect(formatted.messages[0].content[0]).toEqual({
+        type: "image_url",
+        image_url: {
+            url: "data:image/jpeg;base64,base_64_encoded_string",
+        },
+    });
+    expect(formatted.messages[1].content).toEqual("Will this format with multiple messages?: YES!");
+});
+test("Deserialisation and serialisation of additional_kwargs and tool_call_id", async () => {
+    const config = {
+        importMap: { messages: { AIMessage } },
+        optionalImportEntrypoints: [],
+        optionalImportsMap: {},
+        secretsMap: {},
+    };
+    const message = new AIMessage({
+        content: "",
+        additional_kwargs: {
+            tool_calls: [
+                {
+                    id: "call_tXJNP1S6LHT5tLfaNHCbYCtH",
+                    type: "function",
+                    function: {
+                        name: "Weather",
+                        arguments: '{\n  "location": "Prague"\n}',
+                    },
+                },
+            ],
+        },
+    });
+    const deserialized = await load(JSON.stringify(message), config);
+    expect(deserialized).toEqual(message);
+});
+test("Deserialisation and serialisation of tool_call_id", async () => {
+    const config = {
+        importMap: { messages: { ToolMessage } },
+        optionalImportEntrypoints: [],
+        optionalImportsMap: {},
+        secretsMap: {},
+    };
+    const message = new ToolMessage({
+        content: '{"value": 32}',
+        tool_call_id: "call_tXJNP1S6LHT5tLfaNHCbYCtH",
+    });
+    const deserialized = await load(JSON.stringify(message), config);
+    expect(deserialized).toEqual(message);
+});

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

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

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

@@ -0,0 +1,81 @@
+import { test } from "@jest/globals";
+import { z } from "zod";
+import { JsonOutputKeyToolsParser } from "../json_output_tools_parsers.js";
+import { AIMessage } from "../../../messages/index.js";
+import { OutputParserException } from "../../base.js";
+test("JSONOutputKeyToolsParser invoke", async () => {
+    const outputParser = new JsonOutputKeyToolsParser({
+        keyName: "testing",
+        returnSingle: true,
+    });
+    const result = await outputParser.invoke(new AIMessage({
+        content: "",
+        additional_kwargs: {
+            tool_calls: [
+                {
+                    id: "test",
+                    type: "function",
+                    function: {
+                        name: "testing",
+                        arguments: JSON.stringify({ testKey: 9 }),
+                    },
+                },
+            ],
+        },
+    }));
+    expect(result).toEqual({ testKey: 9 });
+});
+test("JSONOutputKeyToolsParser with a passed schema throws", async () => {
+    const outputParser = new JsonOutputKeyToolsParser({
+        keyName: "testing",
+        returnSingle: true,
+        zodSchema: z.object({
+            testKey: z.string(),
+        }),
+    });
+    try {
+        await outputParser.invoke(new AIMessage({
+            content: "",
+            additional_kwargs: {
+                tool_calls: [
+                    {
+                        id: "test",
+                        type: "function",
+                        function: {
+                            name: "testing",
+                            arguments: JSON.stringify({ testKey: 9 }),
+                        },
+                    },
+                ],
+            },
+        }));
+    }
+    catch (e) {
+        expect(e).toBeInstanceOf(OutputParserException);
+    }
+});
+test("JSONOutputKeyToolsParser can validate a proper input", async () => {
+    const outputParser = new JsonOutputKeyToolsParser({
+        keyName: "testing",
+        returnSingle: true,
+        zodSchema: z.object({
+            testKey: z.string(),
+        }),
+    });
+    const result = await outputParser.invoke(new AIMessage({
+        content: "",
+        additional_kwargs: {
+            tool_calls: [
+                {
+                    id: "test",
+                    type: "function",
+                    function: {
+                        name: "testing",
+                        arguments: JSON.stringify({ testKey: "testval" }),
+                    },
+                },
+            ],
+        },
+    }));
+    expect(result).toEqual({ testKey: "testval" });
+});

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

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