@langchain/openai 0.0.28 → 0.0.29

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

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

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

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

@@ -0,0 +1,267 @@
+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/types.d.ts

@@ -158,4 +158,9 @@ export declare interface AzureOpenAIInput {
      * will be result in the endpoint URL: https://westeurope.api.cognitive.microsoft.com/openai/deployments/{DeploymentName}/
      */
     azureOpenAIBasePath?: string;
+    /**
+     * A function that returns an access token for Microsoft Entra (formerly known as Azure Active Directory),
+     * which will be invoked on every request.
+     */
+    azureADTokenProvider?: () => Promise<string>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/openai",
-  "version": "0.0.28",
+  "version": "0.0.29",
   "description": "OpenAI integrations for LangChain.js",
   "type": "module",
   "engines": {
@@ -41,11 +41,12 @@
   "dependencies": {
     "@langchain/core": "~0.1.56",
     "js-tiktoken": "^1.0.7",
-    "openai": "^4.32.1",
+    "openai": "^4.41.1",
     "zod": "^3.22.4",
     "zod-to-json-schema": "^3.22.3"
   },
   "devDependencies": {
+    "@azure/identity": "^4.2.0",
     "@jest/globals": "^29.5.0",
     "@langchain/scripts": "~0.0",
     "@swc/core": "^1.3.90",