@langchain/openai 0.0.33 → 0.1.0

package/dist/tests/azure/embeddings.int.test.js

@@ -1,67 +0,0 @@
-import { test, expect } from "@jest/globals";
-import { AzureOpenAIEmbeddings as OpenAIEmbeddings } from "../../azure/embeddings.js";
-test("Test AzureOpenAIEmbeddings.embedQuery", async () => {
-    const embeddings = new OpenAIEmbeddings();
-    const res = await embeddings.embedQuery("Hello world");
-    expect(typeof res[0]).toBe("number");
-});
-test("Test AzureOpenAIEmbeddings.embedDocuments", async () => {
-    const embeddings = new OpenAIEmbeddings();
-    const res = await embeddings.embedDocuments(["Hello world", "Bye bye"]);
-    expect(res).toHaveLength(2);
-    expect(typeof res[0][0]).toBe("number");
-    expect(typeof res[1][0]).toBe("number");
-});
-test("Test AzureOpenAIEmbeddings concurrency", async () => {
-    const embeddings = new OpenAIEmbeddings({
-        batchSize: 1,
-        maxConcurrency: 2,
-    });
-    const res = await embeddings.embedDocuments([
-        "Hello world",
-        "Bye bye",
-        "Hello world",
-        "Bye bye",
-        "Hello world",
-        "Bye bye",
-    ]);
-    expect(res).toHaveLength(6);
-    expect(res.find((embedding) => typeof embedding[0] !== "number")).toBe(undefined);
-});
-test("Test timeout error thrown from SDK", async () => {
-    await expect(async () => {
-        const model = new OpenAIEmbeddings({
-            timeout: 1,
-            maxRetries: 0,
-        });
-        await model.embedDocuments([
-            "Hello world",
-            "Bye bye",
-            "Hello world",
-            "Bye bye",
-            "Hello world",
-            "Bye bye",
-        ]);
-    }).rejects.toThrow();
-});
-test("Test AzureOpenAIEmbeddings.embedQuery with v3 and dimensions", async () => {
-    const embeddings = new OpenAIEmbeddings({
-        modelName: "text-embedding-3-small",
-        dimensions: 127,
-    });
-    const res = await embeddings.embedQuery("Hello world");
-    expect(typeof res[0]).toBe("number");
-    expect(res.length).toBe(127);
-});
-test("Test AzureOpenAIEmbeddings.embedDocuments with v3 and dimensions", async () => {
-    const embeddings = new OpenAIEmbeddings({
-        modelName: "text-embedding-3-small",
-        dimensions: 127,
-    });
-    const res = await embeddings.embedDocuments(["Hello world", "Bye bye"]);
-    expect(res).toHaveLength(2);
-    expect(typeof res[0][0]).toBe("number");
-    expect(typeof res[1][0]).toBe("number");
-    expect(res[0].length).toBe(127);
-    expect(res[1].length).toBe(127);
-});

package/dist/tests/azure/llms.int.test.d.ts

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

package/dist/tests/azure/llms.int.test.js

@@ -1,267 +0,0 @@
-import { test, expect } from "@jest/globals";
-import { StringPromptValue } from "@langchain/core/prompt_values";
-import { CallbackManager } from "@langchain/core/callbacks/manager";
-import { ClientSecretCredential, getBearerTokenProvider, } from "@azure/identity";
-import { getEnvironmentVariable } from "@langchain/core/utils/env";
-import { AzureOpenAI } from "../../azure/llms.js";
-test("Test Azure OpenAI invoke", async () => {
-    const model = new AzureOpenAI({
-        maxTokens: 5,
-        modelName: "gpt-3.5-turbo-instruct",
-    });
-    const res = await model.invoke("Print hello world");
-    console.log({ res });
-});
-test("Test Azure OpenAI call", async () => {
-    const model = new AzureOpenAI({
-        maxTokens: 5,
-        modelName: "gpt-3.5-turbo-instruct",
-    });
-    const res = await model.call("Print hello world", ["world"]);
-    console.log({ res });
-});
-test("Test Azure OpenAI with stop in object", async () => {
-    const model = new AzureOpenAI({
-        maxTokens: 5,
-        modelName: "gpt-3.5-turbo-instruct",
-    });
-    const res = await model.invoke("Print hello world", { stop: ["world"] });
-    console.log({ res });
-});
-test("Test Azure OpenAI with timeout in call options", async () => {
-    const model = new AzureOpenAI({
-        maxTokens: 5,
-        modelName: "gpt-3.5-turbo-instruct",
-    });
-    await expect(() => model.invoke("Print hello world", {
-        timeout: 10,
-    })).rejects.toThrow();
-}, 5000);
-test("Test Azure OpenAI with timeout in call options and node adapter", async () => {
-    const model = new AzureOpenAI({
-        maxTokens: 5,
-        modelName: "gpt-3.5-turbo-instruct",
-    });
-    await expect(() => model.invoke("Print hello world", {
-        timeout: 10,
-    })).rejects.toThrow();
-}, 5000);
-test("Test Azure OpenAI with signal in call options", async () => {
-    const model = new AzureOpenAI({
-        maxTokens: 5,
-        modelName: "gpt-3.5-turbo-instruct",
-    });
-    const controller = new AbortController();
-    await expect(() => {
-        const ret = model.invoke("Print hello world", {
-            signal: controller.signal,
-        });
-        controller.abort();
-        return ret;
-    }).rejects.toThrow();
-}, 5000);
-test("Test Azure OpenAI with signal in call options and node adapter", async () => {
-    const model = new AzureOpenAI({
-        maxTokens: 5,
-        modelName: "gpt-3.5-turbo-instruct",
-    });
-    const controller = new AbortController();
-    await expect(() => {
-        const ret = model.invoke("Print hello world", {
-            signal: controller.signal,
-        });
-        controller.abort();
-        return ret;
-    }).rejects.toThrow();
-}, 5000);
-test("Test Azure OpenAI with concurrency == 1", async () => {
-    const model = new AzureOpenAI({
-        maxTokens: 5,
-        modelName: "gpt-3.5-turbo-instruct",
-        maxConcurrency: 1,
-    });
-    const res = await Promise.all([
-        model.invoke("Print hello world"),
-        model.invoke("Print hello world"),
-    ]);
-    console.log({ res });
-});
-test("Test Azure OpenAI with maxTokens -1", async () => {
-    const model = new AzureOpenAI({
-        maxTokens: -1,
-        modelName: "gpt-3.5-turbo-instruct",
-    });
-    const res = await model.call("Print hello world", ["world"]);
-    console.log({ res });
-});
-test("Test Azure OpenAI with model name", async () => {
-    const model = new AzureOpenAI({ modelName: "gpt-3.5-turbo-instruct" });
-    expect(model).toBeInstanceOf(AzureOpenAI);
-    const res = await model.invoke("Print hello world");
-    console.log({ res });
-    expect(typeof res).toBe("string");
-});
-test("Test Azure OpenAI with versioned instruct model returns Azure OpenAI", async () => {
-    const model = new AzureOpenAI({
-        modelName: "gpt-3.5-turbo-instruct-0914",
-    });
-    expect(model).toBeInstanceOf(AzureOpenAI);
-    const res = await model.invoke("Print hello world");
-    console.log({ res });
-    expect(typeof res).toBe("string");
-});
-test("Test Azure OpenAI tokenUsage", async () => {
-    let tokenUsage = {
-        completionTokens: 0,
-        promptTokens: 0,
-        totalTokens: 0,
-    };
-    const model = new AzureOpenAI({
-        maxTokens: 5,
-        modelName: "gpt-3.5-turbo-instruct",
-        callbackManager: CallbackManager.fromHandlers({
-            async handleLLMEnd(output) {
-                tokenUsage = output.llmOutput?.tokenUsage;
-            },
-        }),
-    });
-    const res = await model.invoke("Hello");
-    console.log({ res });
-    expect(tokenUsage.promptTokens).toBe(1);
-});
-test("Test Azure OpenAI in streaming mode", async () => {
-    let nrNewTokens = 0;
-    let streamedCompletion = "";
-    const model = new AzureOpenAI({
-        maxTokens: 5,
-        modelName: "gpt-3.5-turbo-instruct",
-        streaming: true,
-        callbacks: CallbackManager.fromHandlers({
-            async handleLLMNewToken(token) {
-                nrNewTokens += 1;
-                streamedCompletion += token;
-            },
-        }),
-    });
-    const res = await model.invoke("Print hello world");
-    console.log({ res });
-    expect(nrNewTokens > 0).toBe(true);
-    expect(res).toBe(streamedCompletion);
-});
-test("Test Azure OpenAI in streaming mode with multiple prompts", async () => {
-    let nrNewTokens = 0;
-    const completions = [
-        ["", ""],
-        ["", ""],
-    ];
-    const model = new AzureOpenAI({
-        maxTokens: 5,
-        modelName: "gpt-3.5-turbo-instruct",
-        streaming: true,
-        n: 2,
-        callbacks: CallbackManager.fromHandlers({
-            async handleLLMNewToken(token, idx) {
-                nrNewTokens += 1;
-                completions[idx.prompt][idx.completion] += token;
-            },
-        }),
-    });
-    const res = await model.generate(["Print hello world", "print hello sea"]);
-    console.log(res.generations, res.generations.map((g) => g[0].generationInfo));
-    expect(nrNewTokens > 0).toBe(true);
-    expect(res.generations.length).toBe(2);
-    expect(res.generations.map((g) => g.map((gg) => gg.text))).toEqual(completions);
-});
-test("Test Azure OpenAI in streaming mode with multiple prompts", async () => {
-    let nrNewTokens = 0;
-    const completions = [[""], [""]];
-    const model = new AzureOpenAI({
-        maxTokens: 5,
-        modelName: "gpt-3.5-turbo",
-        streaming: true,
-        n: 1,
-        callbacks: CallbackManager.fromHandlers({
-            async handleLLMNewToken(token, idx) {
-                nrNewTokens += 1;
-                completions[idx.prompt][idx.completion] += token;
-            },
-        }),
-    });
-    const res = await model.generate(["Print hello world", "print hello sea"]);
-    console.log(res.generations, res.generations.map((g) => g[0].generationInfo));
-    expect(nrNewTokens > 0).toBe(true);
-    expect(res.generations.length).toBe(2);
-    expect(res.generations.map((g) => g.map((gg) => gg.text))).toEqual(completions);
-});
-test("Test Azure OpenAI prompt value", async () => {
-    const model = new AzureOpenAI({
-        maxTokens: 5,
-        modelName: "gpt-3.5-turbo-instruct",
-    });
-    const res = await model.generatePrompt([
-        new StringPromptValue("Print hello world"),
-    ]);
-    expect(res.generations.length).toBe(1);
-    for (const generation of res.generations) {
-        expect(generation.length).toBe(1);
-        for (const g of generation) {
-            console.log(g.text);
-        }
-    }
-    console.log({ res });
-});
-test("Test Azure OpenAI stream method", async () => {
-    const model = new AzureOpenAI({
-        maxTokens: 50,
-        modelName: "gpt-3.5-turbo-instruct",
-    });
-    const stream = await model.stream("Print hello world.");
-    const chunks = [];
-    for await (const chunk of stream) {
-        chunks.push(chunk);
-    }
-    expect(chunks.length).toBeGreaterThan(1);
-});
-test("Test Azure OpenAI stream method with abort", async () => {
-    await expect(async () => {
-        const model = new AzureOpenAI({
-            maxTokens: 250,
-            modelName: "gpt-3.5-turbo-instruct",
-        });
-        const stream = await model.stream("How is your day going? Be extremely verbose.", {
-            signal: AbortSignal.timeout(1000),
-        });
-        for await (const chunk of stream) {
-            console.log(chunk);
-        }
-    }).rejects.toThrow();
-});
-test("Test Azure OpenAI stream method with early break", async () => {
-    const model = new AzureOpenAI({
-        maxTokens: 50,
-        modelName: "gpt-3.5-turbo-instruct",
-    });
-    const stream = await model.stream("How is your day going? Be extremely verbose.");
-    let i = 0;
-    for await (const chunk of stream) {
-        console.log(chunk);
-        i += 1;
-        if (i > 5) {
-            break;
-        }
-    }
-});
-test("Test Azure OpenAI with bearer token credentials", async () => {
-    const tenantId = getEnvironmentVariable("AZURE_TENANT_ID") ?? "";
-    const clientId = getEnvironmentVariable("AZURE_CLIENT_ID") ?? "";
-    const clientSecret = getEnvironmentVariable("AZURE_CLIENT_SECRET") ?? "";
-    const credentials = new ClientSecretCredential(tenantId, clientId, clientSecret);
-    const azureADTokenProvider = getBearerTokenProvider(credentials, "https://cognitiveservices.azure.com/.default");
-    const model = new AzureOpenAI({
-        maxTokens: 5,
-        modelName: "davinci-002",
-        azureADTokenProvider,
-    });
-    const res = await model.invoke("Print hello world");
-    console.log({ res });
-});

package/dist/tests/chat_models-extended.int.test.d.ts

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

package/dist/tests/chat_models-extended.int.test.js

@@ -1,259 +0,0 @@
-import { test, expect, jest } from "@jest/globals";
-import { AIMessage, HumanMessage, ToolMessage } from "@langchain/core/messages";
-import { InMemoryCache } from "@langchain/core/caches";
-import { ChatOpenAI } from "../chat_models.js";
-test("Test ChatOpenAI JSON mode", async () => {
-    const chat = new ChatOpenAI({
-        modelName: "gpt-3.5-turbo-1106",
-        maxTokens: 128,
-    }).bind({
-        response_format: {
-            type: "json_object",
-        },
-    });
-    const message = new HumanMessage("Hello!");
-    const res = await chat.invoke([["system", "Only return JSON"], message]);
-    console.log(JSON.stringify(res));
-});
-test("Test ChatOpenAI seed", async () => {
-    const chat = new ChatOpenAI({
-        modelName: "gpt-3.5-turbo-1106",
-        maxTokens: 128,
-        temperature: 1,
-    }).bind({
-        seed: 123454930394983,
-    });
-    const message = new HumanMessage("Say something random!");
-    const res = await chat.invoke([message]);
-    console.log(JSON.stringify(res));
-    const res2 = await chat.invoke([message]);
-    expect(res).toEqual(res2);
-});
-test("Test ChatOpenAI tool calling", async () => {
-    const chat = new ChatOpenAI({
-        modelName: "gpt-3.5-turbo-1106",
-        maxTokens: 128,
-    }).bind({
-        tools: [
-            {
-                type: "function",
-                function: {
-                    name: "get_current_weather",
-                    description: "Get the current weather in a given location",
-                    parameters: {
-                        type: "object",
-                        properties: {
-                            location: {
-                                type: "string",
-                                description: "The city and state, e.g. San Francisco, CA",
-                            },
-                            unit: { type: "string", enum: ["celsius", "fahrenheit"] },
-                        },
-                        required: ["location"],
-                    },
-                },
-            },
-        ],
-        tool_choice: "auto",
-    });
-    const res = await chat.invoke([
-        ["human", "What's the weather like in San Francisco, Tokyo, and Paris?"],
-    ]);
-    console.log(JSON.stringify(res));
-    expect(res.additional_kwargs.tool_calls?.length).toEqual(3);
-    expect(res.tool_calls?.[0].args).toEqual(JSON.parse(res.additional_kwargs.tool_calls?.[0].function.arguments ?? "{}"));
-    expect(res.tool_calls?.[1].args).toEqual(JSON.parse(res.additional_kwargs.tool_calls?.[1].function.arguments ?? "{}"));
-    expect(res.tool_calls?.[2].args).toEqual(JSON.parse(res.additional_kwargs.tool_calls?.[2].function.arguments ?? "{}"));
-});
-test("Test ChatOpenAI streaming logprobs", async () => {
-    const model = new ChatOpenAI({
-        maxTokens: 50,
-        modelName: "gpt-3.5-turbo",
-        streaming: true,
-        logprobs: true,
-    });
-    const res = await model.invoke("Print hello world.");
-    console.log(res.response_metadata.logprobs.content);
-    expect(res.response_metadata.logprobs.content.length).toBeGreaterThan(0);
-});
-test("Test ChatOpenAI tool calling with ToolMessages", async () => {
-    function getCurrentWeather(location) {
-        if (location.toLowerCase().includes("tokyo")) {
-            return JSON.stringify({ location, temperature: "10", unit: "celsius" });
-        }
-        else if (location.toLowerCase().includes("san francisco")) {
-            return JSON.stringify({
-                location,
-                temperature: "72",
-                unit: "fahrenheit",
-            });
-        }
-        else {
-            return JSON.stringify({ location, temperature: "22", unit: "celsius" });
-        }
-    }
-    const chat = new ChatOpenAI({
-        modelName: "gpt-3.5-turbo-1106",
-        maxTokens: 128,
-    }).bind({
-        tools: [
-            {
-                type: "function",
-                function: {
-                    name: "get_current_weather",
-                    description: "Get the current weather in a given location",
-                    parameters: {
-                        type: "object",
-                        properties: {
-                            location: {
-                                type: "string",
-                                description: "The city and state, e.g. San Francisco, CA",
-                            },
-                            unit: { type: "string", enum: ["celsius", "fahrenheit"] },
-                        },
-                        required: ["location"],
-                    },
-                },
-            },
-        ],
-        tool_choice: "auto",
-    });
-    const res = await chat.invoke([
-        ["human", "What's the weather like in San Francisco, Tokyo, and Paris?"],
-    ]);
-    console.log(JSON.stringify(res));
-    expect(res.additional_kwargs.tool_calls?.length).toBeGreaterThan(1);
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const toolMessages = res.additional_kwargs.tool_calls.map((toolCall) => new ToolMessage({
-        tool_call_id: toolCall.id,
-        name: toolCall.function.name,
-        content: getCurrentWeather(JSON.parse(toolCall.function.arguments).location),
-    }));
-    const finalResponse = await chat.invoke([
-        ["human", "What's the weather like in San Francisco, Tokyo, and Paris?"],
-        res,
-        ...toolMessages,
-    ]);
-    console.log(finalResponse);
-});
-test("Test ChatOpenAI tool calling with streaming", async () => {
-    const chat = new ChatOpenAI({
-        modelName: "gpt-3.5-turbo-1106",
-        maxTokens: 256,
-    }).bind({
-        tools: [
-            {
-                type: "function",
-                function: {
-                    name: "get_current_weather",
-                    description: "Get the current weather in a given location",
-                    parameters: {
-                        type: "object",
-                        properties: {
-                            location: {
-                                type: "string",
-                                description: "The city and state, e.g. San Francisco, CA",
-                            },
-                            unit: { type: "string", enum: ["celsius", "fahrenheit"] },
-                        },
-                        required: ["location"],
-                    },
-                },
-            },
-        ],
-        tool_choice: "auto",
-    });
-    const stream = await chat.stream([
-        ["human", "What's the weather like in San Francisco, Tokyo, and Paris?"],
-    ]);
-    let finalChunk;
-    const chunks = [];
-    for await (const chunk of stream) {
-        console.log(chunk.additional_kwargs.tool_calls);
-        chunks.push(chunk);
-        if (!finalChunk) {
-            finalChunk = chunk;
-        }
-        else {
-            finalChunk = finalChunk.concat(chunk);
-        }
-    }
-    expect(chunks.length).toBeGreaterThan(1);
-    console.log(finalChunk?.additional_kwargs.tool_calls);
-    expect(finalChunk?.additional_kwargs.tool_calls?.length).toBeGreaterThan(1);
-});
-test("ChatOpenAI in JSON mode can cache generations", async () => {
-    const memoryCache = new InMemoryCache();
-    const lookupSpy = jest.spyOn(memoryCache, "lookup");
-    const updateSpy = jest.spyOn(memoryCache, "update");
-    const chat = new ChatOpenAI({
-        modelName: "gpt-3.5-turbo-1106",
-        temperature: 1,
-        cache: memoryCache,
-    }).bind({
-        response_format: {
-            type: "json_object",
-        },
-    });
-    const message = new HumanMessage("Respond with a JSON object containing arbitrary fields.");
-    const res = await chat.invoke([message]);
-    console.log(res);
-    const res2 = await chat.invoke([message]);
-    console.log(res2);
-    expect(res).toEqual(res2);
-    expect(lookupSpy).toHaveBeenCalledTimes(2);
-    expect(updateSpy).toHaveBeenCalledTimes(1);
-    lookupSpy.mockRestore();
-    updateSpy.mockRestore();
-});
-test("Few shotting with tool calls", async () => {
-    const chat = new ChatOpenAI({
-        modelName: "gpt-3.5-turbo-1106",
-        temperature: 1,
-    }).bind({
-        tools: [
-            {
-                type: "function",
-                function: {
-                    name: "get_current_weather",
-                    description: "Get the current weather in a given location",
-                    parameters: {
-                        type: "object",
-                        properties: {
-                            location: {
-                                type: "string",
-                                description: "The city and state, e.g. San Francisco, CA",
-                            },
-                            unit: { type: "string", enum: ["celsius", "fahrenheit"] },
-                        },
-                        required: ["location"],
-                    },
-                },
-            },
-        ],
-        tool_choice: "auto",
-    });
-    const res = await chat.invoke([
-        new HumanMessage("What is the weather in SF?"),
-        new AIMessage({
-            content: "",
-            tool_calls: [
-                {
-                    id: "12345",
-                    name: "get_current_weather",
-                    args: {
-                        location: "SF",
-                    },
-                },
-            ],
-        }),
-        new ToolMessage({
-            tool_call_id: "12345",
-            content: "It is currently 24 degrees with hail in SF.",
-        }),
-        new AIMessage("It is currently 24 degrees in SF with hail in SF."),
-        new HumanMessage("What did you say the weather was?"),
-    ]);
-    console.log(res);
-    expect(res.content).toContain("24");
-});

package/dist/tests/chat_models-vision.int.test.d.ts

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

package/dist/tests/chat_models-vision.int.test.js

@@ -1,51 +0,0 @@
-import { test } from "@jest/globals";
-import { HumanMessage } from "@langchain/core/messages";
-import * as fs from "node:fs/promises";
-import { fileURLToPath } from "node:url";
-import * as path from "node:path";
-import { ChatOpenAI } from "../chat_models.js";
-test("Test ChatOpenAI with a file", async () => {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = path.dirname(__filename);
-    const imageData = await fs.readFile(path.join(__dirname, "/data/hotdog.jpg"));
-    const chat = new ChatOpenAI({
-        modelName: "gpt-4-vision-preview",
-        maxTokens: 1024,
-    });
-    const message = new HumanMessage({
-        content: [
-            {
-                type: "text",
-                text: "What's in this image?",
-            },
-            {
-                type: "image_url",
-                image_url: {
-                    url: `data:image/jpeg;base64,${imageData.toString("base64")}`,
-                },
-            },
-        ],
-    });
-    const res = await chat.invoke([message]);
-    console.log({ res });
-});
-test("Test ChatOpenAI with a URL", async () => {
-    const chat = new ChatOpenAI({
-        modelName: "gpt-4-vision-preview",
-        maxTokens: 1024,
-    });
-    const message = new HumanMessage({
-        content: [
-            {
-                type: "text",
-                text: "What does this image say?",
-            },
-            {
-                type: "image_url",
-                image_url: "https://www.freecodecamp.org/news/content/images/2023/05/Screenshot-2023-05-29-at-5.40.38-PM.png",
-            },
-        ],
-    });
-    const res = await chat.invoke([message]);
-    console.log({ res });
-});

package/dist/tests/chat_models.int.test.d.ts

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