@langchain/openai 0.0.11 → 0.0.13

package/dist/chat_models.cjs

@@ -6,6 +6,7 @@ const messages_1 = require("@langchain/core/messages");
 const outputs_1 = require("@langchain/core/outputs");
 const env_1 = require("@langchain/core/utils/env");
 const chat_models_1 = require("@langchain/core/language_models/chat_models");
+const function_calling_1 = require("@langchain/core/utils/function_calling");
 const azure_js_1 = require("./utils/azure.cjs");
 const openai_js_1 = require("./utils/openai.cjs");
 const openai_format_fndef_js_1 = require("./utils/openai-format-fndef.cjs");
@@ -420,7 +421,7 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
             functions: options?.functions,
             function_call: options?.function_call,
             tools: isStructuredToolArray(options?.tools)
-                ? options?.tools.map(openai_js_1.formatToOpenAITool)
+                ? options?.tools.map(function_calling_1.convertToOpenAITool)
                 : options?.tools,
             tool_choice: options?.tool_choice,
             response_format: options?.response_format,

package/dist/chat_models.js

@@ -3,8 +3,9 @@ import { AIMessage, AIMessageChunk, ChatMessage, ChatMessageChunk, FunctionMessa
 import { ChatGenerationChunk, } from "@langchain/core/outputs";
 import { getEnvironmentVariable } from "@langchain/core/utils/env";
 import { BaseChatModel, } from "@langchain/core/language_models/chat_models";
+import { convertToOpenAITool } from "@langchain/core/utils/function_calling";
 import { getEndpoint } from "./utils/azure.js";
-import { wrapOpenAIClientError, formatToOpenAITool } from "./utils/openai.js";
+import { wrapOpenAIClientError } from "./utils/openai.js";
 import { formatFunctionDefinitions, } from "./utils/openai-format-fndef.js";
 function extractGenericMessageCustomRole(message) {
     if (message.role !== "system" &&
@@ -416,7 +417,7 @@ export class ChatOpenAI extends BaseChatModel {
             functions: options?.functions,
             function_call: options?.function_call,
             tools: isStructuredToolArray(options?.tools)
-                ? options?.tools.map(formatToOpenAITool)
+                ? options?.tools.map(convertToOpenAITool)
                 : options?.tools,
             tool_choice: options?.tool_choice,
             response_format: options?.response_format,

package/dist/embeddings.cjs

@@ -45,6 +45,16 @@ class OpenAIEmbeddings extends embeddings_1.Embeddings {
             writable: true,
             value: true
         });
+        /**
+         * The number of dimensions the resulting output embeddings should have.
+         * Only supported in `text-embedding-3` and later models.
+         */
+        Object.defineProperty(this, "dimensions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "timeout", {
             enumerable: true,
             configurable: true,
@@ -126,6 +136,7 @@ class OpenAIEmbeddings extends embeddings_1.Embeddings {
         this.stripNewLines =
             fieldsWithDefaults?.stripNewLines ?? this.stripNewLines;
         this.timeout = fieldsWithDefaults?.timeout;
+        this.dimensions = fieldsWithDefaults?.dimensions;
         this.azureOpenAIApiVersion = azureApiVersion;
         this.azureOpenAIApiKey = azureApiKey;
         this.azureOpenAIApiInstanceName = azureApiInstanceName;
@@ -162,10 +173,16 @@ class OpenAIEmbeddings extends embeddings_1.Embeddings {
      */
     async embedDocuments(texts) {
         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,
-        }));
+        const batchRequests = batches.map((batch) => {
+            const params = {
+                model: this.modelName,
+                input: batch,
+            };
+            if (this.dimensions) {
+                params.dimensions = this.dimensions;
+            }
+            return this.embeddingWithRetry(params);
+        });
         const batchResponses = await Promise.all(batchRequests);
         const embeddings = [];
         for (let i = 0; i < batchResponses.length; i += 1) {
@@ -184,10 +201,14 @@ class OpenAIEmbeddings extends embeddings_1.Embeddings {
      * @returns Promise that resolves to an embedding for the document.
      */
     async embedQuery(text) {
-        const { data } = await this.embeddingWithRetry({
+        const params = {
             model: this.modelName,
             input: this.stripNewLines ? text.replace(/\n/g, " ") : text,
-        });
+        };
+        if (this.dimensions) {
+            params.dimensions = this.dimensions;
+        }
+        const { data } = await this.embeddingWithRetry(params);
         return data[0].embedding;
     }
     /**

package/dist/embeddings.d.ts

@@ -8,6 +8,11 @@ import { AzureOpenAIInput, LegacyOpenAIInput } from "./types.js";
 export interface OpenAIEmbeddingsParams extends EmbeddingsParams {
     /** Model name to use */
     modelName: string;
+    /**
+     * The number of dimensions the resulting output embeddings should have.
+     * Only supported in `text-embedding-3` and later models.
+     */
+    dimensions?: number;
     /**
      * Timeout to use when making requests to OpenAI.
      */
@@ -43,6 +48,11 @@ export declare class OpenAIEmbeddings extends Embeddings implements OpenAIEmbedd
     modelName: string;
     batchSize: number;
     stripNewLines: boolean;
+    /**
+     * The number of dimensions the resulting output embeddings should have.
+     * Only supported in `text-embedding-3` and later models.
+     */
+    dimensions?: number;
     timeout?: number;
     azureOpenAIApiVersion?: string;
     azureOpenAIApiKey?: string;

package/dist/embeddings.js

@@ -42,6 +42,16 @@ export class OpenAIEmbeddings extends Embeddings {
             writable: true,
             value: true
         });
+        /**
+         * The number of dimensions the resulting output embeddings should have.
+         * Only supported in `text-embedding-3` and later models.
+         */
+        Object.defineProperty(this, "dimensions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "timeout", {
             enumerable: true,
             configurable: true,
@@ -123,6 +133,7 @@ export class OpenAIEmbeddings extends Embeddings {
         this.stripNewLines =
             fieldsWithDefaults?.stripNewLines ?? this.stripNewLines;
         this.timeout = fieldsWithDefaults?.timeout;
+        this.dimensions = fieldsWithDefaults?.dimensions;
         this.azureOpenAIApiVersion = azureApiVersion;
         this.azureOpenAIApiKey = azureApiKey;
         this.azureOpenAIApiInstanceName = azureApiInstanceName;
@@ -159,10 +170,16 @@ export class OpenAIEmbeddings extends Embeddings {
      */
     async embedDocuments(texts) {
         const batches = 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,
-        }));
+        const batchRequests = batches.map((batch) => {
+            const params = {
+                model: this.modelName,
+                input: batch,
+            };
+            if (this.dimensions) {
+                params.dimensions = this.dimensions;
+            }
+            return this.embeddingWithRetry(params);
+        });
         const batchResponses = await Promise.all(batchRequests);
         const embeddings = [];
         for (let i = 0; i < batchResponses.length; i += 1) {
@@ -181,10 +198,14 @@ export class OpenAIEmbeddings extends Embeddings {
      * @returns Promise that resolves to an embedding for the document.
      */
     async embedQuery(text) {
-        const { data } = await this.embeddingWithRetry({
+        const params = {
             model: this.modelName,
             input: this.stripNewLines ? text.replace(/\n/g, " ") : text,
-        });
+        };
+        if (this.dimensions) {
+            params.dimensions = this.dimensions;
+        }
+        const { data } = await this.embeddingWithRetry(params);
         return data[0].embedding;
     }
     /**

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

@@ -60,3 +60,24 @@ test("Test OpenAI embeddings with an invalid org throws", async () => {
         ]);
     }).rejects.toThrow();
 });
+test("Test OpenAIEmbeddings.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 OpenAIEmbeddings.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/utils/openai.cjs

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatToOpenAIAssistantTool = exports.formatToOpenAITool = exports.formatToOpenAIFunction = exports.wrapOpenAIClientError = void 0;
 const openai_1 = require("openai");
 const zod_to_json_schema_1 = require("zod-to-json-schema");
+const function_calling_1 = require("@langchain/core/utils/function_calling");
+Object.defineProperty(exports, "formatToOpenAIFunction", { enumerable: true, get: function () { return function_calling_1.convertToOpenAIFunction; } });
+Object.defineProperty(exports, "formatToOpenAITool", { enumerable: true, get: function () { return function_calling_1.convertToOpenAITool; } });
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function wrapOpenAIClientError(e) {
     let error;
@@ -20,32 +23,6 @@ function wrapOpenAIClientError(e) {
     return error;
 }
 exports.wrapOpenAIClientError = wrapOpenAIClientError;
-/**
- * Formats a `StructuredTool` instance into a format that is compatible
- * with OpenAI's ChatCompletionFunctions. It uses the `zodToJsonSchema`
- * function to convert the schema of the `StructuredTool` into a JSON
- * schema, which is then used as the parameters for the OpenAI function.
- */
-function formatToOpenAIFunction(tool) {
-    return {
-        name: tool.name,
-        description: tool.description,
-        parameters: (0, zod_to_json_schema_1.zodToJsonSchema)(tool.schema),
-    };
-}
-exports.formatToOpenAIFunction = formatToOpenAIFunction;
-function formatToOpenAITool(tool) {
-    const schema = (0, zod_to_json_schema_1.zodToJsonSchema)(tool.schema);
-    return {
-        type: "function",
-        function: {
-            name: tool.name,
-            description: tool.description,
-            parameters: schema,
-        },
-    };
-}
-exports.formatToOpenAITool = formatToOpenAITool;
 function formatToOpenAIAssistantTool(tool) {
     return {
         type: "function",

package/dist/utils/openai.d.ts

@@ -1,13 +1,6 @@
 import { type OpenAI as OpenAIClient } from "openai";
 import type { StructuredToolInterface } from "@langchain/core/tools";
-import type { FunctionDefinition } from "@langchain/core/language_models/base";
+import { convertToOpenAIFunction, convertToOpenAITool } from "@langchain/core/utils/function_calling";
 export declare function wrapOpenAIClientError(e: any): any;
-/**
- * Formats a `StructuredTool` instance into a format that is compatible
- * with OpenAI's ChatCompletionFunctions. It uses the `zodToJsonSchema`
- * function to convert the schema of the `StructuredTool` into a JSON
- * schema, which is then used as the parameters for the OpenAI function.
- */
-export declare function formatToOpenAIFunction(tool: StructuredToolInterface): FunctionDefinition;
-export declare function formatToOpenAITool(tool: StructuredToolInterface): OpenAIClient.Chat.ChatCompletionTool;
+export { convertToOpenAIFunction as formatToOpenAIFunction, convertToOpenAITool as formatToOpenAITool, };
 export declare function formatToOpenAIAssistantTool(tool: StructuredToolInterface): OpenAIClient.Beta.AssistantCreateParams.AssistantToolsFunction;

package/dist/utils/openai.js

@@ -1,5 +1,6 @@
 import { APIConnectionTimeoutError, APIUserAbortError, } from "openai";
 import { zodToJsonSchema } from "zod-to-json-schema";
+import { convertToOpenAIFunction, convertToOpenAITool, } from "@langchain/core/utils/function_calling";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function wrapOpenAIClientError(e) {
     let error;
@@ -16,30 +17,7 @@ export function wrapOpenAIClientError(e) {
     }
     return error;
 }
-/**
- * Formats a `StructuredTool` instance into a format that is compatible
- * with OpenAI's ChatCompletionFunctions. It uses the `zodToJsonSchema`
- * function to convert the schema of the `StructuredTool` into a JSON
- * schema, which is then used as the parameters for the OpenAI function.
- */
-export function formatToOpenAIFunction(tool) {
-    return {
-        name: tool.name,
-        description: tool.description,
-        parameters: zodToJsonSchema(tool.schema),
-    };
-}
-export function formatToOpenAITool(tool) {
-    const schema = zodToJsonSchema(tool.schema);
-    return {
-        type: "function",
-        function: {
-            name: tool.name,
-            description: tool.description,
-            parameters: schema,
-        },
-    };
-}
+export { convertToOpenAIFunction as formatToOpenAIFunction, convertToOpenAITool as formatToOpenAITool, };
 export function formatToOpenAIAssistantTool(tool) {
     return {
         type: "function",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/openai",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "OpenAI integrations for LangChain.js",
   "type": "module",
   "engines": {
@@ -19,7 +19,7 @@
     "build:cjs": "NODE_OPTIONS=--max-old-space-size=4096 tsc --outDir dist-cjs/ -p tsconfig.cjs.json && node scripts/move-cjs-to-dist.js && rimraf dist-cjs",
     "build:watch": "node scripts/create-entrypoints.js && tsc --outDir dist/ --watch",
     "build:scripts": "node scripts/create-entrypoints.js && node scripts/check-tree-shaking.js",
-    "lint:eslint": "NODE_OPTIONS=--max-old-space-size=4096 eslint src",
+    "lint:eslint": "NODE_OPTIONS=--max-old-space-size=4096 eslint --cache --ext .ts,.js src/",
     "lint:dpdm": "dpdm --exit-code circular:1 --no-warning --no-tree src/*.ts src/**/*.ts",
     "lint": "yarn lint:eslint && yarn lint:dpdm",
     "lint:fix": "yarn lint:eslint --fix && yarn lint:dpdm",
@@ -29,17 +29,17 @@
     "test:watch": "yarn run build:deps && NODE_OPTIONS=--experimental-vm-modules jest --watch --testPathIgnorePatterns=\\.int\\.test.ts",
     "test:single": "yarn run build:deps && NODE_OPTIONS=--experimental-vm-modules yarn run jest --config jest.config.cjs --testTimeout 100000",
     "test:int": "NODE_OPTIONS=--experimental-vm-modules jest --testPathPattern=\\.int\\.test.ts --testTimeout 100000 --maxWorkers=50%",
-    "format": "prettier --write \"src\"",
-    "format:check": "prettier --check \"src\""
+    "format": "prettier --config .prettierrc --write \"src\" \"scripts\"",
+    "format:check": "prettier --config .prettierrc --check \"src\" \"scripts\""
   },
   "author": "LangChain",
   "license": "MIT",
   "dependencies": {
-    "@langchain/core": "~0.1.9",
+    "@langchain/core": "~0.1.13",
     "js-tiktoken": "^1.0.7",
-    "openai": "^4.24.2",
-    "zod": "^3.22.3",
-    "zod-to-json-schema": "3.20.3"
+    "openai": "^4.26.0",
+    "zod": "^3.22.4",
+    "zod-to-json-schema": "^3.22.3"
   },
   "devDependencies": {
     "@jest/globals": "^29.5.0",