langchain 0.2.10 → 0.2.11

package/dist/smith/tests/runner_utils.int.test.js

@@ -1,234 +0,0 @@
-import { test } from "@jest/globals";
-import { ChatOpenAI } from "@langchain/openai";
-import { Client } from "langsmith";
-import { BaseChatModel } from "@langchain/core/language_models/chat_models";
-import { LLM } from "@langchain/core/language_models/llms";
-import { AIMessage, isBaseMessage, } from "@langchain/core/messages";
-import { RunnableLambda } from "@langchain/core/runnables";
-import { randomName } from "../name_generation.js";
-import { runOnDataset } from "../runner_utils.js";
-const answers = {
-    "What's the capital of California?": "Sacramento",
-    "What's the capital of Nevada?": "Carson City",
-    "What's the capital of Oregon?": "Salem",
-    "What's the capital of Washington?": "Olympia",
-};
-class FakeLLM extends LLM {
-    _llmType() {
-        return "fake";
-    }
-    async _call(prompt) {
-        return answers[prompt] || prompt;
-    }
-}
-export class FakeChatModel extends BaseChatModel {
-    _combineLLMOutput() {
-        return [];
-    }
-    _llmType() {
-        return "fake";
-    }
-    async _generate(messages, _, runManager) {
-        const text = messages[messages.length - 1].content;
-        const answer = (answers[text] || text);
-        await runManager?.handleLLMNewToken(answer);
-        const result = new AIMessage({ content: answer });
-        return {
-            generations: [
-                {
-                    message: result,
-                    text: answer,
-                },
-            ],
-            llmOutput: {},
-        };
-    }
-}
-const getScore = ({ outputs }) => outputs && Object.values(outputs).length > 0;
-const outputNotEmpty = async ({ run }, options) => {
-    const lambda = new RunnableLambda({ func: getScore });
-    const score = await lambda.invoke(run, options?.config);
-    return {
-        key: "output_not_empty",
-        score,
-        comment: "We have thoroughly checked the output and it is possibly not not empty.",
-    };
-};
-const alwaysPass = (_) => ({
-    key: "always_pass",
-    score: true,
-});
-const checkFeedbackPassed = (evalResults) => {
-    expect(evalResults.projectName).toBeDefined();
-    expect(evalResults.results).toBeDefined();
-    expect(Object.keys(evalResults.results).length).toBeGreaterThan(0);
-    for (const [, result] of Object.entries(evalResults.results)) {
-        expect(result.execution_time).toBeGreaterThan(0);
-        expect(result.run_id).toBeDefined();
-        expect(result.feedback).toBeDefined();
-        expect(result.feedback.length).toBeGreaterThan(0);
-        // eslint-disable-next-line no-loop-func
-        result.feedback.forEach((feedback) => {
-            expect(feedback.score).toBeDefined();
-            expect(feedback.score).toBeTruthy();
-        });
-    }
-};
-const kvDataset = Object.entries(answers).map(([question, answer]) => ({
-    inputs: { input: question },
-    outputs: { output: answer },
-}));
-const chatDataset = kvDataset.map((message) => ({
-    inputs: {
-        input: [
-            { type: "system", data: { content: "Hello, how are you?" } },
-            { type: "human", data: { content: message.inputs.input } },
-        ],
-    },
-    outputs: {
-        output: { type: "ai", data: { content: message.outputs.output } },
-    },
-}));
-const datasetTypes = ["kv", "llm"]; // TODO: add chat
-describe.skip.each(datasetTypes)("runner_utils %s dataset", (datasetType) => {
-    let client;
-    const datasetName = `lcjs ${datasetType} integration tests`;
-    const evalConfig = {
-        customEvaluators: [outputNotEmpty, alwaysPass],
-        evaluators: [
-            {
-                evaluatorType: "labeled_criteria",
-                criteria: "correctness",
-                feedbackKey: "labeledCorrect",
-                formatEvaluatorInputs: ({ rawInput, rawPrediction, rawReferenceOutput, }) => {
-                    let prediction;
-                    if (isBaseMessage(rawPrediction)) {
-                        if (typeof rawPrediction.content !== "string") {
-                            throw new Error("Multimodal mesages not supported.");
-                        }
-                        prediction = rawPrediction.content;
-                    }
-                    else if (typeof rawPrediction === "string") {
-                        prediction = rawPrediction;
-                    }
-                    else if (rawPrediction &&
-                        typeof rawPrediction === "object" &&
-                        "output" in rawPrediction) {
-                        prediction = rawPrediction.output;
-                    }
-                    else {
-                        throw new Error("Unsupported prediction type.");
-                    }
-                    return {
-                        input: rawInput.input,
-                        prediction,
-                        reference: rawReferenceOutput.output,
-                    };
-                },
-                llm: new ChatOpenAI({
-                    modelName: "gpt-3.5-turbo",
-                    temperature: 0,
-                    modelKwargs: { seed: 42 },
-                }),
-            },
-        ],
-    };
-    beforeAll(async () => {
-        client = new Client();
-        try {
-            await client.readDataset({ datasetName });
-        }
-        catch (e) {
-            const dataset = await client.createDataset(datasetName, {
-                dataType: datasetType,
-            });
-            const examples = datasetType === "chat" ? chatDataset : kvDataset;
-            await Promise.all(examples.map(async (example) => {
-                void client.createExample(example.inputs, example.outputs, {
-                    datasetId: dataset.id,
-                });
-            }));
-        }
-    });
-    test(`Chat model on ${datasetType} singleio dataset`, async () => {
-        const llm = new FakeChatModel({});
-        const evalResults = await runOnDataset(llm, datasetName, {
-            client,
-            evaluationConfig: evalConfig,
-            projectName: `fake-chat-model-${randomName()}`,
-            projectMetadata: { env: "integration-tests", model: "fake-chat-model" },
-        });
-        checkFeedbackPassed(evalResults);
-    });
-    test(`FakeLLM on ${datasetType} singleio dataset`, async () => {
-        const llm = new FakeLLM({});
-        const evalResults = await runOnDataset(llm, datasetName, {
-            client,
-            evaluationConfig: evalConfig,
-            projectName: `fake-llm-${randomName()}`,
-            projectMetadata: { env: "integration-tests", model: "fake-llm" },
-        });
-        checkFeedbackPassed(evalResults);
-    });
-    test(`Runnable on ${datasetType} singleio dataset`, async () => {
-        const runnable = new RunnableLambda({
-            func: (input) => ({ output: answers[input.input] }),
-        });
-        const evalResults = await runOnDataset(runnable, datasetName, {
-            client,
-            evaluationConfig: evalConfig,
-            projectName: `runnable-${randomName()}`,
-            projectMetadata: { env: "integration-tests" },
-            maxConcurrency: 5,
-        });
-        checkFeedbackPassed(evalResults);
-    });
-    test(`Runnable constructor on ${datasetType} singleio dataset`, async () => {
-        const runnable = new RunnableLambda({
-            func: (input) => ({ output: answers[input.input] }),
-        });
-        function construct() {
-            return runnable;
-        }
-        const evalResults = await runOnDataset(construct, datasetName, {
-            client,
-            evaluationConfig: evalConfig,
-            projectName: `runnable-constructor-${randomName()}`,
-            projectMetadata: { env: "integration-tests" },
-            maxConcurrency: 5,
-        });
-        checkFeedbackPassed(evalResults);
-    });
-    test(`Arb func on ${datasetType} singleio dataset`, async () => {
-        async function my_func({ input }) {
-            return { output: answers[input] };
-        }
-        const evalResults = await runOnDataset(my_func, datasetName, {
-            evaluationConfig: evalConfig,
-            client,
-            maxConcurrency: 5,
-            projectName: `arb-function-${randomName()}`,
-            projectMetadata: {
-                env: "integration-tests",
-                model: "fake-chat-in-runnable",
-            },
-        });
-        checkFeedbackPassed(evalResults);
-    });
-    test(`Arb constructor on ${datasetType} singleio dataset`, async () => {
-        async function my_func({ input }) {
-            return { output: answers[input] };
-        }
-        const evalResults = await runOnDataset(() => my_func, datasetName, {
-            evaluationConfig: evalConfig,
-            client,
-            maxConcurrency: 5,
-            projectName: `arb-constructor-function-${randomName()}`,
-            projectMetadata: {
-                env: "integration-tests",
-                model: "fake-chat-in-runnable",
-            },
-        });
-        checkFeedbackPassed(evalResults);
-    });
-});

package/dist/storage/tests/file_system.test.d.ts

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

package/dist/storage/tests/file_system.test.js

@@ -1,81 +0,0 @@
-/* eslint-disable no-process-env */
-import { test } from "@jest/globals";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-import { LocalFileStore } from "../file_system.js";
-describe("LocalFileStore", () => {
-    const keys = ["key1", "key2"];
-    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "file_system_store_test"));
-    const secondaryRootPath = "./file_system_store_test_secondary";
-    test("LocalFileStore can write & read values", async () => {
-        const encoder = new TextEncoder();
-        const decoder = new TextDecoder();
-        const store = await LocalFileStore.fromPath(tempDir);
-        const value1 = new Date().toISOString();
-        const value2 = new Date().toISOString() + new Date().toISOString();
-        await store.mset([
-            [keys[0], encoder.encode(value1)],
-            [keys[1], encoder.encode(value2)],
-        ]);
-        const retrievedValues = await store.mget([keys[0], keys[1]]);
-        const everyValueDefined = retrievedValues.every((v) => v !== undefined);
-        expect(everyValueDefined).toBe(true);
-        expect(retrievedValues.map((v) => decoder.decode(v))).toEqual([
-            value1,
-            value2,
-        ]);
-    });
-    test("LocalFileStore can delete values", async () => {
-        const encoder = new TextEncoder();
-        const store = await LocalFileStore.fromPath(tempDir);
-        const value1 = new Date().toISOString();
-        const value2 = new Date().toISOString() + new Date().toISOString();
-        await store.mset([
-            [keys[0], encoder.encode(value1)],
-            [keys[1], encoder.encode(value2)],
-        ]);
-        await store.mdelete(keys);
-        const retrievedValues = await store.mget([keys[0], keys[1]]);
-        const everyValueUndefined = retrievedValues.every((v) => v === undefined);
-        expect(everyValueUndefined).toBe(true);
-    });
-    test("LocalFileStore can yield keys with prefix", async () => {
-        const encoder = new TextEncoder();
-        const prefix = "prefix_";
-        const keysWithPrefix = keys.map((key) => `${prefix}${key}`);
-        const store = await LocalFileStore.fromPath(tempDir);
-        const value = new Date().toISOString();
-        await store.mset(keysWithPrefix.map((key) => [key, encoder.encode(value)]));
-        const yieldedKeys = [];
-        for await (const key of store.yieldKeys(prefix)) {
-            yieldedKeys.push(key);
-        }
-        console.log("Yielded keys:", yieldedKeys);
-        expect(yieldedKeys.sort()).toEqual(keysWithPrefix.sort());
-        // afterEach won't automatically delete these since we're applying a prefix.
-        await store.mdelete(keysWithPrefix);
-    });
-    test("LocalFileStore works with a file which does not exist", async () => {
-        const encoder = new TextEncoder();
-        const decoder = new TextDecoder();
-        const store = await LocalFileStore.fromPath(secondaryRootPath);
-        const value1 = new Date().toISOString();
-        const value2 = new Date().toISOString() + new Date().toISOString();
-        await store.mset([
-            [keys[0], encoder.encode(value1)],
-            [keys[1], encoder.encode(value2)],
-        ]);
-        const retrievedValues = await store.mget([keys[0], keys[1]]);
-        const everyValueDefined = retrievedValues.every((v) => v !== undefined);
-        expect(everyValueDefined).toBe(true);
-        console.log("retrievedValues", retrievedValues);
-        expect(retrievedValues.map((v) => {
-            if (!v) {
-                throw new Error("Value is undefined");
-            }
-            return decoder.decode(v);
-        })).toEqual([value1, value2]);
-        await fs.promises.rm(secondaryRootPath, { recursive: true, force: true });
-    });
-});

package/dist/tools/tests/chain.test.d.ts

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

package/dist/tools/tests/chain.test.js

@@ -1,136 +0,0 @@
-import { test, expect, jest } from "@jest/globals";
-import { LLM } from "@langchain/core/language_models/llms";
-import { PromptTemplate } from "@langchain/core/prompts";
-import { FakeEmbeddings } from "@langchain/core/utils/testing";
-import { ChainTool } from "../chain.js";
-import { LLMChain } from "../../chains/llm_chain.js";
-import { VectorDBQAChain } from "../../chains/vector_db_qa.js";
-import { MemoryVectorStore } from "../../vectorstores/memory.js";
-class FakeLLM extends LLM {
-    _llmType() {
-        return "fake";
-    }
-    async _call(prompt) {
-        return prompt;
-    }
-}
-test("chain tool with llm chain and local callback", async () => {
-    const calls = [];
-    const handleToolStart = jest.fn(() => {
-        calls.push("tool start");
-    });
-    const handleToolEnd = jest.fn(() => {
-        calls.push("tool end");
-    });
-    const handleLLMStart = jest.fn(() => {
-        calls.push("llm start");
-    });
-    const handleLLMEnd = jest.fn(() => {
-        calls.push("llm end");
-    });
-    const handleChainStart = jest.fn(() => {
-        calls.push("chain start");
-    });
-    const handleChainEnd = jest.fn(() => {
-        calls.push("chain end");
-    });
-    const chain = new LLMChain({
-        llm: new FakeLLM({}),
-        prompt: PromptTemplate.fromTemplate("hello world"),
-    });
-    const tool = new ChainTool({ chain, name: "fake", description: "fake" });
-    const result = await tool.invoke("hi", {
-        callbacks: [
-            {
-                awaitHandlers: true,
-                handleToolStart,
-                handleToolEnd,
-                handleLLMStart,
-                handleLLMEnd,
-                handleChainStart,
-                handleChainEnd,
-            },
-        ],
-    });
-    expect(result).toMatchInlineSnapshot(`"hello world"`);
-    expect(handleToolStart).toBeCalledTimes(1);
-    expect(handleToolEnd).toBeCalledTimes(1);
-    expect(handleLLMStart).toBeCalledTimes(1);
-    expect(handleLLMEnd).toBeCalledTimes(1);
-    expect(handleChainStart).toBeCalledTimes(1);
-    expect(handleChainEnd).toBeCalledTimes(1);
-    expect(calls).toMatchInlineSnapshot(`
-    [
-      "tool start",
-      "chain start",
-      "llm start",
-      "llm end",
-      "chain end",
-      "tool end",
-    ]
-  `);
-});
-test("chain tool with vectordbqa chain", async () => {
-    const calls = [];
-    const handleToolStart = jest.fn(() => {
-        calls.push("tool start");
-    });
-    const handleToolEnd = jest.fn(() => {
-        calls.push("tool end");
-    });
-    const handleLLMStart = jest.fn(() => {
-        calls.push("llm start");
-    });
-    const handleLLMEnd = jest.fn(() => {
-        calls.push("llm end");
-    });
-    const handleChainStart = jest.fn(() => {
-        calls.push("chain start");
-    });
-    const handleChainEnd = jest.fn(() => {
-        calls.push("chain end");
-    });
-    const chain = VectorDBQAChain.fromLLM(new FakeLLM({}), await MemoryVectorStore.fromExistingIndex(new FakeEmbeddings()));
-    const tool = new ChainTool({ chain, name: "fake", description: "fake" });
-    const result = await tool.invoke("hi", {
-        callbacks: [
-            {
-                awaitHandlers: true,
-                handleToolStart,
-                handleToolEnd,
-                handleLLMStart,
-                handleLLMEnd,
-                handleChainStart,
-                handleChainEnd,
-            },
-        ],
-    });
-    expect(result).toMatchInlineSnapshot(`
-    "Use the following pieces of context to answer the question at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer.
-
-
-
-    Question: hi
-    Helpful Answer:"
-  `);
-    expect(handleToolStart).toBeCalledTimes(1);
-    expect(handleToolEnd).toBeCalledTimes(1);
-    expect(handleLLMStart).toBeCalledTimes(1);
-    expect(handleLLMEnd).toBeCalledTimes(1);
-    expect(handleChainStart).toBeCalledTimes(3);
-    expect(handleChainEnd).toBeCalledTimes(3);
-    expect(calls).toMatchInlineSnapshot(`
-    [
-      "tool start",
-      "chain start",
-      "chain start",
-      "chain start",
-      "llm start",
-      "llm end",
-      "chain end",
-      "chain end",
-      "chain end",
-      "tool end",
-    ]
-  `);
-});

package/dist/tools/tests/webbrowser.int.test.d.ts

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

package/dist/tools/tests/webbrowser.int.test.js

@@ -1,80 +0,0 @@
-import { test, expect, describe } from "@jest/globals";
-import { ChatOpenAI, OpenAIEmbeddings } from "@langchain/openai";
-import { WebBrowser } from "../webbrowser.js";
-import fetchAdapter from "../../util/axios-fetch-adapter.js";
-describe("webbrowser Test suite", () => {
-    test("get word of the day", async () => {
-        const model = new ChatOpenAI({ temperature: 0 });
-        const embeddings = new OpenAIEmbeddings();
-        const browser = new WebBrowser({ model, embeddings });
-        const result = await browser.call(`"https://www.merriam-webster.com/word-of-the-day","word of the day"`);
-        expect(result).toContain("Word of the Day:");
-    });
-    test("get a summary of the page when empty request with fetch adapter", async () => {
-        const model = new ChatOpenAI({ temperature: 0 });
-        const embeddings = new OpenAIEmbeddings();
-        const browser = new WebBrowser({
-            model,
-            embeddings,
-            axiosConfig: {
-                adapter: fetchAdapter,
-            },
-        });
-        const result = await browser.call(`"https://www.merriam-webster.com/word-of-the-day",""`);
-        // fuzzy, sometimes its capped and others not
-        expect(result).toMatch(/word of the day/i);
-    });
-    test("error no url", async () => {
-        const model = new ChatOpenAI({ temperature: 0 });
-        const embeddings = new OpenAIEmbeddings();
-        const browser = new WebBrowser({ model, embeddings });
-        const result = await browser.call(`"",""`);
-        expect(result).toContain("Invalid URL");
-    });
-    test("error no protocol or malformed", async () => {
-        const model = new ChatOpenAI({ temperature: 0 });
-        const embeddings = new OpenAIEmbeddings();
-        const browser = new WebBrowser({ model, embeddings });
-        const result = await browser.call(`"www.merriam-webster.com/word-of-the-day","word of the day"`);
-        expect(result).toContain("Invalid URL");
-    });
-    test("error bad site", async () => {
-        const model = new ChatOpenAI({ temperature: 0 });
-        const embeddings = new OpenAIEmbeddings();
-        const browser = new WebBrowser({ model, embeddings });
-        const result = await browser.call(`"https://www.hDjRBKoAD0EIbF29TWM4rbXDGGM5Nhy4uzNEAdDS.com","word of the day"`);
-        expect(result).toEqual("Error: getaddrinfo ENOTFOUND www.hdjrbkoad0eibf29twm4rbxdggm5nhy4uzneadds.com");
-    });
-    test.skip("get a summary of a page that detects scraping", async () => {
-        const model = new ChatOpenAI({ temperature: 0 });
-        const embeddings = new OpenAIEmbeddings();
-        const browser = new WebBrowser({ model, embeddings });
-        const result = await browser.call(`"https://www.musicgateway.com/spotify-pre-save",""`);
-        expect(result).not.toEqual("Error: http response 403");
-    });
-    // cant we figure the headers to fix this?
-    test.skip("get a summary of a page that detects scraping 2", async () => {
-        const model = new ChatOpenAI({ temperature: 0 });
-        const embeddings = new OpenAIEmbeddings();
-        const browser = new WebBrowser({ model, embeddings });
-        const result = await browser.call(`"https://parade.com/991228/marynliles/couples-goals",""`);
-        expect(result).not.toEqual("Error: http response 403");
-    });
-    test("get a summary of a page that rejects unauthorized", async () => {
-        const model = new ChatOpenAI({ temperature: 0 });
-        const embeddings = new OpenAIEmbeddings();
-        const browser = new WebBrowser({ model, embeddings });
-        const result = await browser.call(`"https://firstround.com/review/how-to-fix-the-co-founder-fights-youre-sick-of-having-lessons-from-couples-therapist-esther-perel",""`);
-        expect(result).toContain("Esther Perel");
-    });
-    // other urls that have done this too
-    // "https://wsimag.com/economy-and-politics/15473-power-and-money",
-    // "https://thriveglobal.com/stories/sleep-what-to-do-what-not-to-do",
-    test.skip("get a summary of a page that redirects too many times", async () => {
-        const model = new ChatOpenAI({ temperature: 0 });
-        const embeddings = new OpenAIEmbeddings();
-        const browser = new WebBrowser({ model, embeddings });
-        const result = await browser.call(`"https://www.healtheuropa.eu/why-mdma-must-be-reclassified-as-a-schedule-2-drug/95780",""`);
-        expect(result).toContain("Beckley Foundation");
-    });
-});

package/dist/tools/tests/webbrowser.test.d.ts

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

package/dist/tools/tests/webbrowser.test.js

@@ -1,21 +0,0 @@
-import { test, expect, describe } from "@jest/globals";
-import { readFileSync } from "fs";
-import { getText, parseInputs } from "../webbrowser.js";
-describe("webbrowser Test suite", () => {
-    const html = readFileSync("./src/tools/fixtures/wordoftheday.html", "utf8");
-    test("parse html to text and links", async () => {
-        const baseUrl = "https://www.merriam-webster.com/word-of-the-day";
-        const text = getText(html, baseUrl, false);
-        expect(text).toContain("Word of the Day: Foible");
-    });
-    test("parseInputs", () => {
-        expect(parseInputs(`"https://www.merriam-webster.com/word-of-the-day",""`)).toEqual(["https://www.merriam-webster.com/word-of-the-day", ""]);
-        expect(parseInputs(`"https://www.merriam-webster.com/word-of-the-day","word of the day"`)).toEqual([
-            "https://www.merriam-webster.com/word-of-the-day",
-            "word of the day",
-        ]);
-        expect(parseInputs(`"https://www.merriam-webster.com/word-of-the-day","`)).toEqual(["https://www.merriam-webster.com/word-of-the-day", ""]);
-        expect(parseInputs(`"https://www.merriam-webster.com/word-of-the-day",`)).toEqual(["https://www.merriam-webster.com/word-of-the-day", ""]);
-        expect(parseInputs(`"https://www.merriam-webster.com/word-of-the-day"`)).toEqual(["https://www.merriam-webster.com/word-of-the-day", undefined]);
-    });
-});

package/dist/util/tests/async_caller.int.test.d.ts

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

package/dist/util/tests/async_caller.int.test.js

@@ -1,34 +0,0 @@
-import { test, expect } from "@jest/globals";
-import { OpenAI } from "@langchain/openai";
-import { AsyncCaller } from "@langchain/core/utils/async_caller";
-test("AsyncCaller.call passes on arguments and returns return value", async () => {
-    const caller = new AsyncCaller({});
-    const callable = () => fetch("https://langchain.com/");
-    const resultDirect = await callable();
-    const resultWrapped = await caller.call(callable);
-    expect(resultDirect.status).toEqual(200);
-    expect(resultWrapped.status).toEqual(200);
-});
-test("AsyncCaller doesn't retry on axios error 401", async () => {
-    const llm = new OpenAI({ openAIApiKey: "invalid" });
-    await expect(() => llm.call("test")).rejects.toThrowError();
-}, 5000);
-test("AsyncCaller doesn't retry on timeout", async () => {
-    const caller = new AsyncCaller({});
-    const callable = () => fetch("https://langchain.com/?sleep=1000", {
-        signal: AbortSignal.timeout(10),
-    });
-    await expect(() => caller.call(callable)).rejects.toThrowError("TimeoutError: The operation was aborted due to timeout");
-}, 5000);
-test("AsyncCaller doesn't retry on signal abort", async () => {
-    const controller = new AbortController();
-    const caller = new AsyncCaller({});
-    const callable = () => {
-        const ret = fetch("https://langchain.com/?sleep=1000", {
-            signal: controller.signal,
-        });
-        controller.abort();
-        return ret;
-    };
-    await expect(() => caller.call(callable)).rejects.toThrowError("AbortError: This operation was aborted");
-}, 5000);

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

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

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

@@ -1,42 +0,0 @@
-import { getEndpoint } from "@langchain/openai";
-describe("getEndpoint", () => {
-    it("should return the correct endpoint with azureOpenAIBasePath and azureOpenAIApiDeploymentName", () => {
-        const config = {
-            azureOpenAIApiKey: "API-KEY",
-            azureOpenAIApiDeploymentName: "deploymentName",
-            azureOpenAIBasePath: "https://westeurope.api.cognitive.microsoft.com/openai/deployments",
-        };
-        const result = getEndpoint(config);
-        expect(result).toBe("https://westeurope.api.cognitive.microsoft.com/openai/deployments/deploymentName");
-    });
-    it("should return the correct endpoint with azureOpenAIApiKey, azureOpenAIApiInstanceName, and azureOpenAIApiDeploymentName", () => {
-        const config = {
-            azureOpenAIApiKey: "key",
-            azureOpenAIApiInstanceName: "instanceName",
-            azureOpenAIApiDeploymentName: "deploymentName",
-        };
-        const result = getEndpoint(config);
-        expect(result).toBe("https://instanceName.openai.azure.com/openai/deployments/deploymentName");
-    });
-    it("should throw error when azureOpenAIApiInstanceName is missing with azureOpenAIApiKey", () => {
-        const config = {
-            azureOpenAIApiKey: "key",
-            azureOpenAIApiDeploymentName: "deploymentName",
-        };
-        expect(() => getEndpoint(config)).toThrowError("azureOpenAIApiInstanceName is required when using azureOpenAIApiKey");
-    });
-    it("should throw error when azureOpenAIApiDeploymentName is missing with azureOpenAIApiKey", () => {
-        const config = {
-            azureOpenAIApiKey: "key",
-            azureOpenAIApiInstanceName: "instanceName",
-        };
-        expect(() => getEndpoint(config)).toThrowError("azureOpenAIApiDeploymentName is a required parameter when using azureOpenAIApiKey");
-    });
-    it("should return the custom basePath when neither azureOpenAIBasePath nor azureOpenAIApiKey is provided", () => {
-        const config = {
-            baseURL: "https://basepath.com",
-        };
-        const result = getEndpoint(config);
-        expect(result).toBe("https://basepath.com");
-    });
-});

package/dist/util/tests/openai-stream.test.d.ts

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