@langchain/core 0.2.18-rc.0 → 0.2.19

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

@@ -1,204 +0,0 @@
-/* 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";
-import { HumanMessage } from "../../messages/human.js";
-import { getBufferString } from "../../messages/utils.js";
-test("Test ChatModel accepts array shorthand for messages", async () => {
-    const model = new FakeChatModel({});
-    const response = await model.invoke([["human", "Hello there!"]]);
-    expect(response.content).toEqual("Hello there!");
-});
-test("Test ChatModel accepts object shorthand for messages", async () => {
-    const model = new FakeChatModel({});
-    const response = await model.invoke([
-        {
-            type: "human",
-            content: "Hello there!",
-            additional_kwargs: {},
-            example: true,
-        },
-    ]);
-    expect(response.content).toEqual("Hello there!");
-});
-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);
-});
-test("Test ChatModel can cache complex messages", async () => {
-    const model = new FakeChatModel({
-        cache: true,
-    });
-    if (!model.cache) {
-        throw new Error("Cache not enabled");
-    }
-    const contentToCache = [
-        {
-            type: "text",
-            text: "Hello there!",
-        },
-    ];
-    const humanMessage = new HumanMessage({
-        content: contentToCache,
-    });
-    const prompt = getBufferString([humanMessage]);
-    const llmKey = model._getSerializedCacheKeyParametersForCall({});
-    // Invoke model to trigger cache update
-    await model.invoke([humanMessage]);
-    const value = await model.cache.lookup(prompt, llmKey);
-    expect(value).toBeDefined();
-    if (!value)
-        return;
-    expect(value[0].text).toEqual(JSON.stringify(contentToCache, null, 2));
-    expect("message" in value[0]).toBeTruthy();
-    if (!("message" in value[0]))
-        return;
-    const cachedMsg = value[0].message;
-    expect(cachedMsg.content).toEqual(JSON.stringify(contentToCache, null, 2));
-});

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

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

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

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

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

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

@@ -1,52 +0,0 @@
-/* eslint-disable no-promise-executor-return */
-import { test } from "@jest/globals";
-import { FakeLLM, FakeStreamingLLM } from "../../utils/testing/index.js";
-import { HumanMessagePromptTemplate } from "../../prompts/chat.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);
-});
-test("Test FakeStreamingLLM works when streaming through a prompt", async () => {
-    const prompt = HumanMessagePromptTemplate.fromTemplate("hello there {name}");
-    const model = new FakeStreamingLLM({});
-    const chain = prompt.pipe(model);
-    const stream = await chain.stream({ name: "test" });
-    const chunks = [];
-    for await (const chunk of stream) {
-        chunks.push(chunk);
-    }
-    expect(chunks.length).toBeGreaterThan(1);
-    expect(chunks.join("")).toEqual("Human: hello there test");
-});

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

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

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

@@ -1,245 +0,0 @@
-import { test, describe, it, expect } from "@jest/globals";
-import { ChatPromptTemplate } from "../../prompts/chat.js";
-import { HumanMessage, AIMessage, ToolMessage, ToolMessageChunk, AIMessageChunk, } 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);
-});
-test("Deserialisation and serialisation of messages with ID", async () => {
-    const config = {
-        importMap: { messages: { AIMessage } },
-        optionalImportEntrypoints: [],
-        optionalImportsMap: {},
-        secretsMap: {},
-    };
-    const messageId = "uuid-1234";
-    const message = new AIMessage({
-        content: "The sky is blue because...",
-        id: messageId,
-    });
-    const deserialized = await load(JSON.stringify(message), config);
-    expect(deserialized).toEqual(message);
-    expect(deserialized.id).toBe(messageId);
-});
-test("Can concat artifact (string) of ToolMessageChunk", () => {
-    const rawOutputOne = "Hello";
-    const rawOutputTwo = " world";
-    const chunk1 = new ToolMessageChunk({
-        content: "Hello",
-        tool_call_id: "1",
-        artifact: rawOutputOne,
-    });
-    const chunk2 = new ToolMessageChunk({
-        content: " world",
-        tool_call_id: "1",
-        artifact: rawOutputTwo,
-    });
-    const concated = chunk1.concat(chunk2);
-    expect(concated.artifact).toBe(`${rawOutputOne}${rawOutputTwo}`);
-});
-test("Can concat artifact (array) of ToolMessageChunk", () => {
-    const rawOutputOne = ["Hello", " world"];
-    const rawOutputTwo = ["!!"];
-    const chunk1 = new ToolMessageChunk({
-        content: "Hello",
-        tool_call_id: "1",
-        artifact: rawOutputOne,
-    });
-    const chunk2 = new ToolMessageChunk({
-        content: " world",
-        tool_call_id: "1",
-        artifact: rawOutputTwo,
-    });
-    const concated = chunk1.concat(chunk2);
-    expect(concated.artifact).toEqual(["Hello", " world", "!!"]);
-});
-test("Can concat artifact (object) of ToolMessageChunk", () => {
-    const rawOutputOne = {
-        foo: "bar",
-    };
-    const rawOutputTwo = {
-        bar: "baz",
-    };
-    const chunk1 = new ToolMessageChunk({
-        content: "Hello",
-        tool_call_id: "1",
-        artifact: rawOutputOne,
-    });
-    const chunk2 = new ToolMessageChunk({
-        content: " world",
-        tool_call_id: "1",
-        artifact: rawOutputTwo,
-    });
-    const concated = chunk1.concat(chunk2);
-    expect(concated.artifact).toEqual({
-        foo: "bar",
-        bar: "baz",
-    });
-});
-describe("Complex AIMessageChunk concat", () => {
-    it("concatenates content arrays of strings", () => {
-        expect(new AIMessageChunk({
-            content: [{ type: "text", text: "I am" }],
-            id: "ai4",
-        }).concat(new AIMessageChunk({ content: [{ type: "text", text: " indeed." }] }))).toEqual(new AIMessageChunk({
-            id: "ai4",
-            content: [
-                { type: "text", text: "I am" },
-                { type: "text", text: " indeed." },
-            ],
-        }));
-    });
-    it("concatenates mixed content arrays", () => {
-        expect(new AIMessageChunk({
-            content: [{ index: 0, type: "text", text: "I am" }],
-        }).concat(new AIMessageChunk({ content: [{ type: "text", text: " indeed." }] }))).toEqual(new AIMessageChunk({
-            content: [
-                { index: 0, type: "text", text: "I am" },
-                { type: "text", text: " indeed." },
-            ],
-        }));
-    });
-    it("merges content arrays with same index", () => {
-        expect(new AIMessageChunk({ content: [{ index: 0, text: "I am" }] }).concat(new AIMessageChunk({ content: [{ index: 0, text: " indeed." }] }))).toEqual(new AIMessageChunk({ content: [{ index: 0, text: "I am indeed." }] }));
-    });
-    it("does not merge when one chunk is missing an index", () => {
-        expect(new AIMessageChunk({ content: [{ index: 0, text: "I am" }] }).concat(new AIMessageChunk({ content: [{ text: " indeed." }] }))).toEqual(new AIMessageChunk({
-            content: [{ index: 0, text: "I am" }, { text: " indeed." }],
-        }));
-    });
-    it("does not create a holey array when there's a gap between indexes", () => {
-        expect(new AIMessageChunk({ content: [{ index: 0, text: "I am" }] }).concat(new AIMessageChunk({ content: [{ index: 2, text: " indeed." }] }))).toEqual(new AIMessageChunk({
-            content: [
-                { index: 0, text: "I am" },
-                { index: 2, text: " indeed." },
-            ],
-        }));
-    });
-    it("does not merge content arrays with separate indexes", () => {
-        expect(new AIMessageChunk({ content: [{ index: 0, text: "I am" }] }).concat(new AIMessageChunk({ content: [{ index: 1, text: " indeed." }] }))).toEqual(new AIMessageChunk({
-            content: [
-                { index: 0, text: "I am" },
-                { index: 1, text: " indeed." },
-            ],
-        }));
-    });
-    it("merges content arrays with same index and type", () => {
-        expect(new AIMessageChunk({
-            content: [{ index: 0, text: "I am", type: "text_block" }],
-        }).concat(new AIMessageChunk({
-            content: [{ index: 0, text: " indeed.", type: "text_block" }],
-        }))).toEqual(new AIMessageChunk({
-            content: [{ index: 0, text: "I am indeed.", type: "text_block" }],
-        }));
-    });
-    it("merges content arrays with same index and different types without updating type", () => {
-        expect(new AIMessageChunk({
-            content: [{ index: 0, text: "I am", type: "text_block" }],
-        }).concat(new AIMessageChunk({
-            content: [{ index: 0, text: " indeed.", type: "text_block_delta" }],
-        }))).toEqual(new AIMessageChunk({
-            content: [{ index: 0, text: "I am indeed.", type: "text_block" }],
-        }));
-    });
-    it("concatenates empty string content and merges other fields", () => {
-        expect(new AIMessageChunk({
-            content: [{ index: 0, type: "text", text: "I am" }],
-        }).concat(new AIMessageChunk({
-            content: [{ type: "text", text: "" }],
-            response_metadata: { extra: "value" },
-        }))).toEqual(new AIMessageChunk({
-            content: [{ index: 0, type: "text", text: "I am" }],
-            response_metadata: { extra: "value" },
-        }));
-    });
-});

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

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