langchain 0.2.10 → 0.2.12

package/dist/util/tests/openai-stream.test.js

@@ -1,135 +0,0 @@
-import { describe, it, expect, jest } from "@jest/globals";
-import fetchAdapter from "../axios-fetch-adapter.js";
-const mockFetchForOpenAIStream = async ({ chunks, status, contentType, }) => {
-    // Mock stream response chunks.
-    const stream = new ReadableStream({
-        async start(controller) {
-            chunks.forEach((chunk) => {
-                controller.enqueue(new TextEncoder().encode(chunk));
-            });
-            controller.close();
-        },
-    });
-    // Mock Fetch API call.
-    jest.spyOn(global, "fetch").mockImplementation(async () => new Response(stream, {
-        status,
-        headers: {
-            "Content-Type": contentType,
-        },
-    }));
-    let error = null;
-    let done = false;
-    const receivedChunks = [];
-    const resp = await fetchAdapter({
-        url: "https://example.com",
-        method: "POST",
-        responseType: "stream",
-        onmessage: (event) => {
-            if (event.data?.trim?.() === "[DONE]") {
-                done = true;
-            }
-            else {
-                receivedChunks.push(JSON.parse(event.data).choices[0].delta.content ?? "");
-            }
-        },
-    }).catch((err) => {
-        error = err;
-        return null;
-    });
-    return { resp, receivedChunks, error, done };
-};
-describe("OpenAI Stream Tests", () => {
-    it("should return a 200 response chunk by chunk", async () => {
-        // When stream mode enabled, OpenAI responds with a stream of `data: {...}\n\n` chunks
-        // followed by `data: [DONE]\n\n`.
-        const { resp, receivedChunks, error, done } = await mockFetchForOpenAIStream({
-            status: 200,
-            contentType: "text/event-stream",
-            chunks: [
-                'data: {"choices":[{"delta":{"role":"assistant"},"index":0,"finish_reason":null}]}\n\n',
-                'data: {"choices":[{"delta":{"content":"Hello"},"index":0,"finish_reason":null}]}\n\n',
-                'data: {"choices":[{"delta":{"content":" World"},"index":0,"finish_reason":null}]}\n\n',
-                'data: {"choices":[{"delta":{"content":"!"},"index":0,"finish_reason":null}]}\n\n',
-                'data: {"choices":[{"delta":{},"index":0,"finish_reason":"stop"}]}\n\n',
-                "data: [DONE]\n\n",
-            ],
-        });
-        expect(error).toEqual(null);
-        expect(resp?.status).toEqual(200);
-        expect(receivedChunks).toEqual(["", "Hello", " World", "!", ""]);
-        expect(done).toBe(true);
-    });
-    it("should handle OpenAI 400 json error", async () => {
-        // OpenAI returns errors with application/json content type.
-        // Even if stream mode is enabled, the error is returned as a normal JSON body.
-        // Error information is in the `error` field.
-        const { resp, receivedChunks, error } = await mockFetchForOpenAIStream({
-            status: 400,
-            contentType: "application/json",
-            chunks: [
-                JSON.stringify({
-                    error: {},
-                }),
-            ],
-        });
-        expect(error).toEqual(null);
-        expect(resp?.status).toEqual(400);
-        expect(resp?.data).toEqual({ error: {} });
-        expect(receivedChunks).toEqual([]);
-    });
-    it("should handle 500 non-json error", async () => {
-        const { resp, receivedChunks, error } = await mockFetchForOpenAIStream({
-            status: 500,
-            contentType: "text/plain",
-            chunks: ["Some error message..."],
-        });
-        expect(error).toEqual(null);
-        expect(resp?.status).toEqual(500);
-        expect(resp?.data).toEqual("Some error message...");
-        expect(receivedChunks).toEqual([]);
-    });
-    it("should throw on 500 non-json body with json content type", async () => {
-        const { resp, receivedChunks, error } = await mockFetchForOpenAIStream({
-            status: 500,
-            contentType: "application/json",
-            chunks: ["a non-json error body"],
-        });
-        expect(resp).toEqual(null);
-        expect(error?.message).toContain("Unexpected token");
-        expect(receivedChunks).toEqual([]);
-    });
-    it("should throw the generic error if non-stream content is detected", async () => {
-        const { resp, receivedChunks, error } = await mockFetchForOpenAIStream({
-            status: 200,
-            contentType: "text/plain",
-            chunks: ["a non-stream body"],
-        });
-        expect(resp).toEqual(null);
-        expect(error?.message).toBe("Expected content-type to be text/event-stream, Actual: text/plain");
-        expect(receivedChunks).toEqual([]);
-    });
-});
-describe("Azure OpenAI Stream Tests", () => {
-    it("should return a 200 response chunk by chunk", async () => {
-        // When stream mode enabled, Azure OpenAI responds with chunks without tailing blank line.
-        // In addition, Azure sends chunks in batch.
-        const { resp, receivedChunks, error, done } = await mockFetchForOpenAIStream({
-            status: 200,
-            contentType: "text/event-stream",
-            chunks: [
-                // First batch
-                'data: {"choices":[{"delta":{"role":"assistant"},"index":0,"finish_reason":null}]}\n\n' +
-                    'data: {"choices":[{"delta":{"content":"Hello"},"index":0,"finish_reason":null}]}\n\n' +
-                    'data: {"choices":[{"delta":{"content":" World"},"index":0,"finish_reason":null}]}\n\n',
-                // Second batch
-                'data: {"choices":[{"delta":{"content":"!"},"index":0,"finish_reason":null}]}\n\n' +
-                    'data: {"choices":[{"delta":{},"index":0,"finish_reason":"stop"}]}\n\n' +
-                    "data: [DONE]\n", // no blank line
-            ],
-        });
-        expect(error).toEqual(null);
-        expect(resp?.status).toEqual(200);
-        expect(receivedChunks).toEqual(["", "Hello", " World", "!", ""]);
-        expect(done).toBe(true);
-    });
-});

package/dist/util/tests/set.test.d.ts

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

package/dist/util/tests/set.test.js

@@ -1,36 +0,0 @@
-import { test, expect } from "@jest/globals";
-import { difference, intersection, union } from "../set.js";
-test("difference", () => {
-    const set1 = new Set(["a", "b"]);
-    const set2 = new Set(["b", "c"]);
-    const resultSet = difference(set1, set2);
-    expect(resultSet).toMatchInlineSnapshot(`
-      Set {
-        "a",
-      }
-    `);
-});
-test("intersection", () => {
-    const set1 = new Set(["a", "b", "c", "d"]);
-    const set2 = new Set(["b", "c", "e"]);
-    const resultSet = intersection(set1, set2);
-    expect(resultSet).toMatchInlineSnapshot(`
-      Set {
-        "b",
-        "c",
-      }
-    `);
-});
-test("union", () => {
-    const set1 = new Set(["a", "b"]);
-    const set2 = new Set(["c", "d"]);
-    const resultSet = union(set1, set2);
-    expect(resultSet).toMatchInlineSnapshot(`
-      Set {
-        "a",
-        "b",
-        "c",
-        "d",
-      }
-    `);
-});

package/dist/util/tests/sql_utils.test.d.ts

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

package/dist/util/tests/sql_utils.test.js

@@ -1,50 +0,0 @@
-import { test, expect } from "@jest/globals";
-import { DataSource } from "typeorm";
-import { getPromptTemplateFromDataSource, verifyIgnoreTablesExistInDatabase, verifyIncludeTablesExistInDatabase, } from "../sql_utils.js";
-import { SQL_SQLITE_PROMPT } from "../../chains/sql_db/sql_db_prompt.js";
-test("Find include tables when there are there", () => {
-    const includeTables = ["user", "score"];
-    const allTables = [
-        { tableName: "plop", columns: [{ columnName: "id" }] },
-        { tableName: "score", columns: [{ columnName: "id" }] },
-        { tableName: "user", columns: [{ columnName: "id" }] },
-        { tableName: "log", columns: [{ columnName: "id" }] },
-    ];
-    expect(() => verifyIncludeTablesExistInDatabase(allTables, includeTables)).not.toThrow();
-});
-test("Throw Error when include tables are not there", () => {
-    const includeTables = ["user", "score"];
-    const allTables = [
-        { tableName: "plop", columns: [{ columnName: "id" }] },
-        { tableName: "score", columns: [{ columnName: "id" }] },
-        { tableName: "log", columns: [{ columnName: "id" }] },
-    ];
-    expect(() => verifyIncludeTablesExistInDatabase(allTables, includeTables)).toThrow();
-});
-test("Find include tables when there are there", () => {
-    const includeTables = ["user", "score"];
-    const allTables = [
-        { tableName: "user", columns: [{ columnName: "id" }] },
-        { tableName: "plop", columns: [{ columnName: "id" }] },
-        { tableName: "score", columns: [{ columnName: "id" }] },
-        { tableName: "log", columns: [{ columnName: "id" }] },
-    ];
-    expect(() => verifyIgnoreTablesExistInDatabase(allTables, includeTables)).not.toThrow();
-});
-test("Throw Error when include tables are not there", () => {
-    const includeTables = ["user", "score"];
-    const allTables = [
-        { tableName: "plop", columns: [{ columnName: "id" }] },
-        { tableName: "score", columns: [{ columnName: "id" }] },
-        { tableName: "log", columns: [{ columnName: "id" }] },
-    ];
-    expect(() => verifyIgnoreTablesExistInDatabase(allTables, includeTables)).toThrow();
-});
-test.skip("return sqlite template when the DataSource is sqlite", () => {
-    const datasource = new DataSource({
-        type: "sqlite",
-        database: "Chinook.db",
-    });
-    const promptTemplate = getPromptTemplateFromDataSource(datasource);
-    expect(promptTemplate).toEqual(SQL_SQLITE_PROMPT);
-});

package/dist/vectorstores/tests/memory.test.d.ts

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

package/dist/vectorstores/tests/memory.test.js

@@ -1,78 +0,0 @@
-import { test, expect } from "@jest/globals";
-import { Document } from "@langchain/core/documents";
-import { SyntheticEmbeddings } from "@langchain/core/utils/testing";
-import { similarity } from "ml-distance";
-import { MemoryVectorStore } from "../memory.js";
-test("MemoryVectorStore with external ids", async () => {
-    const embeddings = new SyntheticEmbeddings({
-        vectorSize: 1536,
-    });
-    const store = new MemoryVectorStore(embeddings);
-    expect(store).toBeDefined();
-    await store.addDocuments([
-        { pageContent: "hello", metadata: { a: 1 } },
-        { pageContent: "hi", metadata: { a: 1 } },
-        { pageContent: "bye", metadata: { a: 1 } },
-        { pageContent: "what's this", metadata: { a: 1 } },
-    ]);
-    const results = await store.similaritySearch("hello", 1);
-    expect(results).toHaveLength(1);
-    expect(results).toEqual([
-        new Document({ metadata: { a: 1 }, pageContent: "hello" }),
-    ]);
-});
-test("MemoryVectorStore as retriever can filter metadata", async () => {
-    const embeddings = new SyntheticEmbeddings({
-        vectorSize: 1536,
-    });
-    const store = new MemoryVectorStore(embeddings);
-    const filterFunc = (doc) => {
-        const { metadata } = doc;
-        if (metadata.namespace <= 2) {
-            return true;
-        }
-        return false;
-    };
-    const retriever = store.asRetriever({
-        k: 2,
-        filter: filterFunc,
-    });
-    expect(retriever).toBeDefined();
-    await retriever.addDocuments([
-        { pageContent: "hello", metadata: { namespace: 1 } },
-        { pageContent: "hello", metadata: { namespace: 2 } },
-        { pageContent: "hello", metadata: { namespace: 3 } },
-        { pageContent: "hello", metadata: { namespace: 4 } },
-    ]);
-    const results = await retriever.getRelevantDocuments("hello");
-    expect(results).toHaveLength(2);
-    expect(results).toEqual([
-        new Document({ metadata: { namespace: 1 }, pageContent: "hello" }),
-        new Document({ metadata: { namespace: 2 }, pageContent: "hello" }),
-    ]);
-});
-test("MemoryVectorStore with custom similarity", async () => {
-    const embeddings = new SyntheticEmbeddings({
-        vectorSize: 1536,
-    });
-    let similarityCalled = false;
-    let similarityCalledCount = 0;
-    const store = new MemoryVectorStore(embeddings, {
-        similarity: (a, b) => {
-            similarityCalledCount += 1;
-            similarityCalled = true;
-            return similarity.cosine(a, b);
-        },
-    });
-    expect(store).toBeDefined();
-    await store.addDocuments([
-        { pageContent: "hello", metadata: { a: 1 } },
-        { pageContent: "hi", metadata: { a: 1 } },
-        { pageContent: "bye", metadata: { a: 1 } },
-        { pageContent: "what's this", metadata: { a: 1 } },
-    ]);
-    const results = await store.similaritySearch("hello", 3);
-    expect(similarityCalled).toBe(true);
-    expect(similarityCalledCount).toBe(4);
-    expect(results).toHaveLength(3);
-});