@langchain/openai 0.0.7 → 0.0.8

package/dist/azure/chat_models.cjs

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AzureChatOpenAI = void 0;
+const chat_models_js_1 = require("../chat_models.cjs");
+class AzureChatOpenAI extends chat_models_js_1.ChatOpenAI {
+    _llmType() {
+        return "azure_openai";
+    }
+    get lc_aliases() {
+        return {
+            openAIApiKey: "openai_api_key",
+            openAIApiVersion: "openai_api_version",
+            openAIBasePath: "openai_api_base",
+        };
+    }
+    constructor(fields) {
+        // assume the base URL does not contain "openai" nor "deployments" prefix
+        let basePath = fields?.openAIBasePath ?? "";
+        if (!basePath.endsWith("/"))
+            basePath += "/";
+        if (!basePath.endsWith("openai/deployments"))
+            basePath += "openai/deployments";
+        const newFields = fields ? { ...fields } : fields;
+        if (newFields) {
+            newFields.azureOpenAIBasePath = basePath;
+            newFields.azureOpenAIApiDeploymentName = newFields.deploymentName;
+            newFields.azureOpenAIApiKey = newFields.openAIApiKey;
+            newFields.azureOpenAIApiVersion = newFields.openAIApiVersion;
+        }
+        super(newFields);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    toJSON() {
+        const json = super.toJSON();
+        function isRecord(obj) {
+            return typeof obj === "object" && obj != null;
+        }
+        if (isRecord(json) && isRecord(json.kwargs)) {
+            delete json.kwargs.azure_openai_base_path;
+            delete json.kwargs.azure_openai_api_deployment_name;
+            delete json.kwargs.azure_openai_api_key;
+            delete json.kwargs.azure_openai_api_version;
+            delete json.kwargs.azure_open_ai_base_path;
+        }
+        return json;
+    }
+}
+exports.AzureChatOpenAI = AzureChatOpenAI;

package/dist/azure/chat_models.d.ts

@@ -0,0 +1,17 @@
+import { type ClientOptions } from "openai";
+import { type BaseChatModelParams } from "@langchain/core/language_models/chat_models";
+import { ChatOpenAI } from "../chat_models.js";
+import { AzureOpenAIInput, LegacyOpenAIInput, OpenAIChatInput } from "../types.js";
+export declare class AzureChatOpenAI extends ChatOpenAI {
+    _llmType(): string;
+    get lc_aliases(): Record<string, string>;
+    constructor(fields?: Partial<OpenAIChatInput> & Partial<AzureOpenAIInput> & {
+        openAIApiKey?: string;
+        openAIApiVersion?: string;
+        openAIBasePath?: string;
+        deploymentName?: string;
+    } & BaseChatModelParams & {
+        configuration?: ClientOptions & LegacyOpenAIInput;
+    });
+    toJSON(): any;
+}

package/dist/azure/chat_models.js

@@ -0,0 +1,44 @@
+import { ChatOpenAI } from "../chat_models.js";
+export class AzureChatOpenAI extends ChatOpenAI {
+    _llmType() {
+        return "azure_openai";
+    }
+    get lc_aliases() {
+        return {
+            openAIApiKey: "openai_api_key",
+            openAIApiVersion: "openai_api_version",
+            openAIBasePath: "openai_api_base",
+        };
+    }
+    constructor(fields) {
+        // assume the base URL does not contain "openai" nor "deployments" prefix
+        let basePath = fields?.openAIBasePath ?? "";
+        if (!basePath.endsWith("/"))
+            basePath += "/";
+        if (!basePath.endsWith("openai/deployments"))
+            basePath += "openai/deployments";
+        const newFields = fields ? { ...fields } : fields;
+        if (newFields) {
+            newFields.azureOpenAIBasePath = basePath;
+            newFields.azureOpenAIApiDeploymentName = newFields.deploymentName;
+            newFields.azureOpenAIApiKey = newFields.openAIApiKey;
+            newFields.azureOpenAIApiVersion = newFields.openAIApiVersion;
+        }
+        super(newFields);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    toJSON() {
+        const json = super.toJSON();
+        function isRecord(obj) {
+            return typeof obj === "object" && obj != null;
+        }
+        if (isRecord(json) && isRecord(json.kwargs)) {
+            delete json.kwargs.azure_openai_base_path;
+            delete json.kwargs.azure_openai_api_deployment_name;
+            delete json.kwargs.azure_openai_api_key;
+            delete json.kwargs.azure_openai_api_version;
+            delete json.kwargs.azure_open_ai_base_path;
+        }
+        return json;
+    }
+}

package/dist/azure/llms.cjs

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AzureOpenAI = void 0;
+const llms_js_1 = require("../llms.cjs");
+class AzureOpenAI extends llms_js_1.OpenAI {
+    get lc_aliases() {
+        return {
+            openAIApiKey: "openai_api_key",
+            openAIApiVersion: "openai_api_version",
+            openAIBasePath: "openai_api_base",
+        };
+    }
+    constructor(fields) {
+        // assume the base URL does not contain "openai" nor "deployments" prefix
+        let basePath = fields?.openAIBasePath ?? "";
+        if (!basePath.endsWith("/"))
+            basePath += "/";
+        if (!basePath.endsWith("openai/deployments"))
+            basePath += "openai/deployments";
+        const newFields = fields ? { ...fields } : fields;
+        if (newFields) {
+            newFields.azureOpenAIBasePath = basePath;
+            newFields.azureOpenAIApiDeploymentName = newFields.deploymentName;
+            newFields.azureOpenAIApiKey = newFields.openAIApiKey;
+            newFields.azureOpenAIApiVersion = newFields.openAIApiVersion;
+        }
+        super(newFields);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    toJSON() {
+        const json = super.toJSON();
+        function isRecord(obj) {
+            return typeof obj === "object" && obj != null;
+        }
+        if (isRecord(json) && isRecord(json.kwargs)) {
+            delete json.kwargs.azure_openai_base_path;
+            delete json.kwargs.azure_openai_api_deployment_name;
+            delete json.kwargs.azure_openai_api_key;
+            delete json.kwargs.azure_openai_api_version;
+            delete json.kwargs.azure_open_ai_base_path;
+        }
+        return json;
+    }
+}
+exports.AzureOpenAI = AzureOpenAI;

package/dist/azure/llms.d.ts

@@ -0,0 +1,16 @@
+import { type ClientOptions } from "openai";
+import { type BaseLLMParams } from "@langchain/core/language_models/llms";
+import { OpenAI } from "../llms.js";
+import type { OpenAIInput, AzureOpenAIInput, LegacyOpenAIInput } from "../types.js";
+export declare class AzureOpenAI extends OpenAI {
+    get lc_aliases(): Record<string, string>;
+    constructor(fields?: Partial<OpenAIInput> & {
+        openAIApiKey?: string;
+        openAIApiVersion?: string;
+        openAIBasePath?: string;
+        deploymentName?: string;
+    } & Partial<AzureOpenAIInput> & BaseLLMParams & {
+        configuration?: ClientOptions & LegacyOpenAIInput;
+    });
+    toJSON(): any;
+}

package/dist/azure/llms.js

@@ -0,0 +1,41 @@
+import { OpenAI } from "../llms.js";
+export class AzureOpenAI extends OpenAI {
+    get lc_aliases() {
+        return {
+            openAIApiKey: "openai_api_key",
+            openAIApiVersion: "openai_api_version",
+            openAIBasePath: "openai_api_base",
+        };
+    }
+    constructor(fields) {
+        // assume the base URL does not contain "openai" nor "deployments" prefix
+        let basePath = fields?.openAIBasePath ?? "";
+        if (!basePath.endsWith("/"))
+            basePath += "/";
+        if (!basePath.endsWith("openai/deployments"))
+            basePath += "openai/deployments";
+        const newFields = fields ? { ...fields } : fields;
+        if (newFields) {
+            newFields.azureOpenAIBasePath = basePath;
+            newFields.azureOpenAIApiDeploymentName = newFields.deploymentName;
+            newFields.azureOpenAIApiKey = newFields.openAIApiKey;
+            newFields.azureOpenAIApiVersion = newFields.openAIApiVersion;
+        }
+        super(newFields);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    toJSON() {
+        const json = super.toJSON();
+        function isRecord(obj) {
+            return typeof obj === "object" && obj != null;
+        }
+        if (isRecord(json) && isRecord(json.kwargs)) {
+            delete json.kwargs.azure_openai_base_path;
+            delete json.kwargs.azure_openai_api_deployment_name;
+            delete json.kwargs.azure_openai_api_key;
+            delete json.kwargs.azure_openai_api_version;
+            delete json.kwargs.azure_open_ai_base_path;
+        }
+        return json;
+    }
+}

package/dist/embeddings.cjs

@@ -4,7 +4,7 @@ exports.OpenAIEmbeddings = void 0;
 const openai_1 = require("openai");
 const env_1 = require("@langchain/core/utils/env");
 const embeddings_1 = require("@langchain/core/embeddings");
-const chunk_js_1 = require("./utils/chunk.cjs");
+const chunk_array_1 = require("@langchain/core/utils/chunk_array");
 const azure_js_1 = require("./utils/azure.cjs");
 const openai_js_1 = require("./utils/openai.cjs");
 /**
@@ -161,7 +161,7 @@ class OpenAIEmbeddings extends embeddings_1.Embeddings {
      * @returns Promise that resolves to a 2D array of embeddings for each document.
      */
     async embedDocuments(texts) {
-        const batches = (0, chunk_js_1.chunkArray)(this.stripNewLines ? texts.map((t) => t.replace(/\n/g, " ")) : texts, this.batchSize);
+        const batches = (0, chunk_array_1.chunkArray)(this.stripNewLines ? texts.map((t) => t.replace(/\n/g, " ")) : texts, this.batchSize);
         const batchRequests = batches.map((batch) => this.embeddingWithRetry({
             model: this.modelName,
             input: batch,

package/dist/embeddings.js

@@ -1,7 +1,7 @@
 import { OpenAI as OpenAIClient } from "openai";
 import { getEnvironmentVariable } from "@langchain/core/utils/env";
 import { Embeddings } from "@langchain/core/embeddings";
-import { chunkArray } from "./utils/chunk.js";
+import { chunkArray } from "@langchain/core/utils/chunk_array";
 import { getEndpoint } from "./utils/azure.js";
 import { wrapOpenAIClientError } from "./utils/openai.js";
 /**

package/dist/index.cjs

@@ -19,7 +19,9 @@ var openai_1 = require("openai");
 Object.defineProperty(exports, "OpenAIClient", { enumerable: true, get: function () { return openai_1.OpenAI; } });
 Object.defineProperty(exports, "toFile", { enumerable: true, get: function () { return openai_1.toFile; } });
 __exportStar(require("./chat_models.cjs"), exports);
+__exportStar(require("./azure/chat_models.cjs"), exports);
 __exportStar(require("./llms.cjs"), exports);
+__exportStar(require("./azure/llms.cjs"), exports);
 __exportStar(require("./embeddings.cjs"), exports);
 __exportStar(require("./types.cjs"), exports);
 __exportStar(require("./utils/openai.cjs"), exports);

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export { OpenAI as OpenAIClient, type ClientOptions, toFile } from "openai";
 export * from "./chat_models.js";
+export * from "./azure/chat_models.js";
 export * from "./llms.js";
+export * from "./azure/llms.js";
 export * from "./embeddings.js";
 export * from "./types.js";
 export * from "./utils/openai.js";

package/dist/index.js

@@ -1,6 +1,8 @@
 export { OpenAI as OpenAIClient, toFile } from "openai";
 export * from "./chat_models.js";
+export * from "./azure/chat_models.js";
 export * from "./llms.js";
+export * from "./azure/llms.js";
 export * from "./embeddings.js";
 export * from "./types.js";
 export * from "./utils/openai.js";

package/dist/llms.cjs

@@ -6,8 +6,8 @@ const base_1 = require("@langchain/core/language_models/base");
 const outputs_1 = require("@langchain/core/outputs");
 const env_1 = require("@langchain/core/utils/env");
 const llms_1 = require("@langchain/core/language_models/llms");
+const chunk_array_1 = require("@langchain/core/utils/chunk_array");
 const azure_js_1 = require("./utils/azure.cjs");
-const chunk_js_1 = require("./utils/chunk.cjs");
 const legacy_js_1 = require("./legacy.cjs");
 Object.defineProperty(exports, "OpenAIChat", { enumerable: true, get: function () { return legacy_js_1.OpenAIChat; } });
 const openai_js_1 = require("./utils/openai.cjs");
@@ -346,7 +346,7 @@ class OpenAI extends llms_1.BaseLLM {
      * ```
      */
     async _generate(prompts, options, runManager) {
-        const subPrompts = (0, chunk_js_1.chunkArray)(prompts, this.batchSize);
+        const subPrompts = (0, chunk_array_1.chunkArray)(prompts, this.batchSize);
         const choices = [];
         const tokenUsage = {};
         const params = this.invocationParams(options);
@@ -429,7 +429,7 @@ class OpenAI extends llms_1.BaseLLM {
                 tokenUsage.totalTokens = (tokenUsage.totalTokens ?? 0) + totalTokens;
             }
         }
-        const generations = (0, chunk_js_1.chunkArray)(choices, this.n).map((promptChoices) => promptChoices.map((choice) => ({
+        const generations = (0, chunk_array_1.chunkArray)(choices, this.n).map((promptChoices) => promptChoices.map((choice) => ({
             text: choice.text ?? "",
             generationInfo: {
                 finishReason: choice.finish_reason,

package/dist/llms.js

@@ -3,8 +3,8 @@ import { calculateMaxTokens } from "@langchain/core/language_models/base";
 import { GenerationChunk } from "@langchain/core/outputs";
 import { getEnvironmentVariable } from "@langchain/core/utils/env";
 import { BaseLLM, } from "@langchain/core/language_models/llms";
+import { chunkArray } from "@langchain/core/utils/chunk_array";
 import { getEndpoint } from "./utils/azure.js";
-import { chunkArray } from "./utils/chunk.js";
 import { OpenAIChat } from "./legacy.js";
 import { wrapOpenAIClientError } from "./utils/openai.js";
 export { OpenAIChat };

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

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

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

@@ -0,0 +1,194 @@
+import { test, expect, jest } from "@jest/globals";
+import { 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).toBeGreaterThan(1);
+});
+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();
+});

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

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

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

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

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