langchain 0.0.140 → 0.0.142

package/dist/chat_models/openai.d.ts

@@ -1,9 +1,8 @@
-import { ChatCompletionFunctions, ConfigurationParameters, CreateChatCompletionRequest, CreateChatCompletionRequestFunctionCall, CreateChatCompletionResponse } from "openai";
+import { type ClientOptions, OpenAI as OpenAIClient } from "openai";
 import { CallbackManagerForLLMRun } from "../callbacks/manager.js";
 import { BaseMessage, ChatGenerationChunk, ChatResult } from "../schema/index.js";
 import { StructuredTool } from "../tools/base.js";
-import { AzureOpenAIInput, OpenAICallOptions, OpenAIChatInput } from "../types/openai-types.js";
-import type { StreamingAxiosConfiguration } from "../util/axios-types.js";
+import { AzureOpenAIInput, OpenAICallOptions, OpenAIChatInput, OpenAICoreRequestOptions, LegacyOpenAIInput } from "../types/openai-types.js";
 import { BaseChatModel, BaseChatModelParams } from "./base.js";
 export { AzureOpenAIInput, OpenAICallOptions, OpenAIChatInput };
 interface TokenUsage {
@@ -15,8 +14,8 @@ interface OpenAILLMOutput {
     tokenUsage: TokenUsage;
 }
 export interface ChatOpenAICallOptions extends OpenAICallOptions {
-    function_call?: CreateChatCompletionRequestFunctionCall;
-    functions?: ChatCompletionFunctions[];
+    function_call?: OpenAIClient.Chat.ChatCompletionCreateParams.FunctionCallOption;
+    functions?: OpenAIClient.Chat.ChatCompletionCreateParams.Function[];
     tools?: StructuredTool[];
     promptIndex?: number;
 }
@@ -70,79 +69,40 @@ export declare class ChatOpenAI extends BaseChatModel<ChatOpenAICallOptions> imp
     private client;
     private clientConfig;
     constructor(fields?: Partial<OpenAIChatInput> & Partial<AzureOpenAIInput> & BaseChatModelParams & {
-        configuration?: ConfigurationParameters;
+        configuration?: ClientOptions & LegacyOpenAIInput;
     }, 
     /** @deprecated */
-    configuration?: ConfigurationParameters);
+    configuration?: ClientOptions & LegacyOpenAIInput);
     /**
      * Get the parameters used to invoke the model
      */
-    invocationParams(options?: this["ParsedCallOptions"]): Omit<CreateChatCompletionRequest, "messages">;
+    invocationParams(options?: this["ParsedCallOptions"]): Omit<OpenAIClient.Chat.ChatCompletionCreateParams, "messages">;
     /** @ignore */
-    _identifyingParams(): {
-        apiKey?: string | Promise<string> | ((name: string) => string) | ((name: string) => Promise<string>) | undefined;
-        organization?: string | undefined;
-        username?: string | undefined;
-        password?: string | undefined;
-        accessToken?: string | Promise<string> | ((name?: string | undefined, scopes?: string[] | undefined) => string) | ((name?: string | undefined, scopes?: string[] | undefined) => Promise<string>) | undefined;
-        basePath?: string | undefined;
-        baseOptions?: any;
-        formDataCtor?: (new () => any) | undefined;
-        function_call?: CreateChatCompletionRequestFunctionCall | undefined;
-        stop?: import("openai").CreateChatCompletionRequestStop | undefined;
-        stream?: boolean | null | undefined;
-        user?: string | undefined;
-        functions?: ChatCompletionFunctions[] | undefined;
-        model: string;
-        temperature?: number | null | undefined;
-        top_p?: number | null | undefined;
-        n?: number | null | undefined;
-        max_tokens?: number | undefined;
-        presence_penalty?: number | null | undefined;
-        frequency_penalty?: number | null | undefined;
-        logit_bias?: object | null | undefined;
+    _identifyingParams(): Omit<OpenAIClient.Chat.ChatCompletionCreateParams, "messages"> & {
         model_name: string;
-    };
+    } & ClientOptions;
     _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
-    startStream(request: CreateChatCompletionRequest, options?: StreamingAxiosConfiguration): {
-        next(): Promise<any>;
-        [Symbol.asyncIterator](): any;
-    };
     /**
      * Get the identifying parameters for the model
      */
-    identifyingParams(): {
-        apiKey?: string | Promise<string> | ((name: string) => string) | ((name: string) => Promise<string>) | undefined;
-        organization?: string | undefined;
-        username?: string | undefined;
-        password?: string | undefined;
-        accessToken?: string | Promise<string> | ((name?: string | undefined, scopes?: string[] | undefined) => string) | ((name?: string | undefined, scopes?: string[] | undefined) => Promise<string>) | undefined;
-        basePath?: string | undefined;
-        baseOptions?: any;
-        formDataCtor?: (new () => any) | undefined;
-        function_call?: CreateChatCompletionRequestFunctionCall | undefined;
-        stop?: import("openai").CreateChatCompletionRequestStop | undefined;
-        stream?: boolean | null | undefined;
-        user?: string | undefined;
-        functions?: ChatCompletionFunctions[] | undefined;
-        model: string;
-        temperature?: number | null | undefined;
-        top_p?: number | null | undefined;
-        n?: number | null | undefined;
-        max_tokens?: number | undefined;
-        presence_penalty?: number | null | undefined;
-        frequency_penalty?: number | null | undefined;
-        logit_bias?: object | null | undefined;
+    identifyingParams(): Omit<OpenAIClient.Chat.Completions.ChatCompletionCreateParams, "messages"> & {
         model_name: string;
-    };
+    } & ClientOptions;
     /** @ignore */
     _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
     getNumTokensFromMessages(messages: BaseMessage[]): Promise<{
         totalCount: number;
         countPerMessage: number[];
     }>;
-    /** @ignore */
-    completionWithRetry(request: CreateChatCompletionRequest, options?: StreamingAxiosConfiguration): Promise<CreateChatCompletionResponse>;
+    /**
+     * Calls the OpenAI API with retry logic in case of failures.
+     * @param request The request to send to the OpenAI API.
+     * @param options Optional configuration for the API call.
+     * @returns The response from the OpenAI API.
+     */
+    completionWithRetry(request: OpenAIClient.Chat.ChatCompletionCreateParamsStreaming, options?: OpenAICoreRequestOptions): Promise<AsyncIterable<OpenAIClient.Chat.Completions.ChatCompletionChunk>>;
+    completionWithRetry(request: OpenAIClient.Chat.ChatCompletionCreateParamsNonStreaming, options?: OpenAICoreRequestOptions): Promise<OpenAIClient.Chat.Completions.ChatCompletion>;
+    private _getClientOptions;
     _llmType(): string;
     /** @ignore */
     _combineLLMOutput(...llmOutputs: OpenAILLMOutput[]): OpenAILLMOutput;

package/dist/chat_models/openai.js

@@ -1,13 +1,12 @@
-import { Configuration, OpenAIApi, } from "openai";
+import { OpenAI as OpenAIClient } from "openai";
 import { getModelNameForTiktoken } from "../base_language/count_tokens.js";
 import { AIMessage, AIMessageChunk, ChatGenerationChunk, ChatMessage, ChatMessageChunk, FunctionMessageChunk, HumanMessage, HumanMessageChunk, SystemMessage, SystemMessageChunk, } from "../schema/index.js";
 import { formatToOpenAIFunction } from "../tools/convert_to_openai.js";
-import fetchAdapter from "../util/axios-fetch-adapter.js";
 import { getEndpoint } from "../util/azure.js";
-import { getEnvironmentVariable, isNode } from "../util/env.js";
+import { getEnvironmentVariable } from "../util/env.js";
 import { promptLayerTrackRequest } from "../util/prompt-layer.js";
-import { readableStreamToAsyncIterable } from "../util/stream.js";
 import { BaseChatModel } from "./base.js";
+import { wrapOpenAIClientError } from "../util/openai.js";
 function extractGenericMessageCustomRole(message) {
     if (message.role !== "system" &&
         message.role !== "assistant" &&
@@ -327,6 +326,12 @@ export class ChatOpenAI extends BaseChatModel {
         this.clientConfig = {
             apiKey: this.openAIApiKey,
             organization: this.organization,
+            baseURL: configuration?.basePath ?? fields?.configuration?.basePath,
+            dangerouslyAllowBrowser: true,
+            defaultHeaders: configuration?.baseOptions?.headers ??
+                fields?.configuration?.baseOptions?.headers,
+            defaultQuery: configuration?.baseOptions?.params ??
+                fields?.configuration?.baseOptions?.params,
             ...configuration,
             ...fields?.configuration,
         };
@@ -363,8 +368,6 @@ export class ChatOpenAI extends BaseChatModel {
             ...this.clientConfig,
         };
     }
-    // TODO(jacoblee): Refactor with _generate(..., {stream: true}) implementation
-    // when we integrate OpenAI's new SDK.
     async *_streamResponseChunks(messages, options, runManager) {
         const messagesMapped = messages.map((message) => ({
             role: messageToOpenAIRole(message),
@@ -378,79 +381,32 @@ export class ChatOpenAI extends BaseChatModel {
             messages: messagesMapped,
             stream: true,
         };
-        let defaultRole = "assistant";
-        const streamIterable = this.startStream(params, options);
-        for await (const streamedResponse of streamIterable) {
-            const data = JSON.parse(streamedResponse);
-            const choice = data.choices?.[0];
+        let defaultRole;
+        const streamIterable = await this.completionWithRetry(params, options);
+        for await (const data of streamIterable) {
+            const choice = data.choices[0];
             if (!choice) {
                 continue;
             }
             const { delta } = choice;
             const chunk = _convertDeltaToMessageChunk(delta, defaultRole);
-            defaultRole = (delta.role ??
-                defaultRole);
+            defaultRole = delta.role ?? defaultRole;
+            const newTokenIndices = {
+                prompt: options.promptIndex ?? 0,
+                completion: choice.index ?? 0,
+            };
             const generationChunk = new ChatGenerationChunk({
                 message: chunk,
                 text: chunk.content,
+                generationInfo: newTokenIndices,
             });
             yield generationChunk;
             // eslint-disable-next-line no-void
-            void runManager?.handleLLMNewToken(generationChunk.text ?? "", {
-                prompt: 0,
-                completion: choice.index,
-            }, undefined, undefined, undefined, { chunk: generationChunk });
+            void runManager?.handleLLMNewToken(generationChunk.text ?? "", newTokenIndices, undefined, undefined, undefined, { chunk: generationChunk });
+        }
+        if (options.signal?.aborted) {
+            throw new Error("AbortError");
         }
-    }
-    startStream(request, options) {
-        let done = false;
-        const stream = new TransformStream();
-        const writer = stream.writable.getWriter();
-        const iterable = readableStreamToAsyncIterable(stream.readable);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let err;
-        this.completionWithRetry(request, {
-            ...options,
-            adapter: fetchAdapter,
-            responseType: "stream",
-            onmessage: (event) => {
-                if (done)
-                    return;
-                if (event.data?.trim?.() === "[DONE]") {
-                    done = true;
-                    // eslint-disable-next-line no-void
-                    void writer.close();
-                }
-                else {
-                    const data = JSON.parse(event.data);
-                    if (data.error) {
-                        done = true;
-                        throw data.error;
-                    }
-                    // eslint-disable-next-line no-void
-                    void writer.write(event.data);
-                }
-            },
-        }).catch((error) => {
-            if (!done) {
-                err = error;
-                done = true;
-                // eslint-disable-next-line no-void
-                void writer.close();
-            }
-        });
-        return {
-            async next() {
-                const chunk = await iterable.next();
-                if (err) {
-                    throw err;
-                }
-                return chunk;
-            },
-            [Symbol.asyncIterator]() {
-                return this;
-            },
-        };
     }
     /**
      * Get the identifying parameters for the model
@@ -469,139 +425,60 @@ export class ChatOpenAI extends BaseChatModel {
             function_call: message.additional_kwargs
                 .function_call,
         }));
-        const data = params.stream
-            ? await new Promise((resolve, reject) => {
-                let response;
-                let rejected = false;
-                let resolved = false;
-                this.completionWithRetry({
-                    ...params,
-                    messages: messagesMapped,
-                }, {
-                    signal: options?.signal,
-                    ...options?.options,
-                    adapter: fetchAdapter,
-                    responseType: "stream",
-                    onmessage: (event) => {
-                        if (event.data?.trim?.() === "[DONE]") {
-                            if (resolved || rejected) {
-                                return;
-                            }
-                            resolved = true;
-                            resolve(response);
-                        }
-                        else {
-                            const data = JSON.parse(event.data);
-                            if (!data.id)
-                                return;
-                            if (data?.error) {
-                                if (rejected) {
-                                    return;
-                                }
-                                rejected = true;
-                                reject(data.error);
-                                return;
-                            }
-                            const message = data;
-                            // on the first message set the response properties
-                            if (!response) {
-                                response = {
-                                    id: message.id,
-                                    object: message.object,
-                                    created: message.created,
-                                    model: message.model,
-                                    choices: [],
-                                };
-                            }
-                            // on all messages, update choice
-                            for (const part of message.choices ?? []) {
-                                if (part != null) {
-                                    let choice = response.choices.find((c) => c.index === part.index);
-                                    if (!choice) {
-                                        choice = {
-                                            index: part.index,
-                                            finish_reason: part.finish_reason ?? undefined,
-                                        };
-                                        response.choices[part.index] = choice;
-                                    }
-                                    if (!choice.message) {
-                                        choice.message = {
-                                            role: part.delta
-                                                ?.role,
-                                            content: "",
-                                        };
-                                    }
-                                    if (part.delta.function_call &&
-                                        !choice.message.function_call) {
-                                        choice.message.function_call = {
-                                            name: "",
-                                            arguments: "",
-                                        };
-                                    }
-                                    choice.message.content += part.delta?.content ?? "";
-                                    if (choice.message.function_call) {
-                                        choice.message.function_call.name +=
-                                            part.delta?.function_call?.name ?? "";
-                                        choice.message.function_call.arguments +=
-                                            part.delta?.function_call?.arguments ?? "";
-                                    }
-                                    const chunk = _convertDeltaToMessageChunk(part.delta, "assistant");
-                                    const generationChunk = new ChatGenerationChunk({
-                                        message: chunk,
-                                        text: chunk.content,
-                                    });
-                                    void runManager?.handleLLMNewToken(part.delta?.content ?? "", {
-                                        prompt: options.promptIndex ?? 0,
-                                        completion: part.index,
-                                    }, undefined, undefined, undefined, { chunk: generationChunk });
-                                }
-                            }
-                            // when all messages are finished, resolve
-                            if (!resolved &&
-                                !rejected &&
-                                message.choices?.every((c) => c.finish_reason != null)) {
-                                resolved = true;
-                                resolve(response);
-                            }
-                        }
-                    },
-                }).catch((error) => {
-                    if (!rejected) {
-                        rejected = true;
-                        reject(error);
-                    }
-                });
-            })
-            : await this.completionWithRetry({
+        if (params.stream) {
+            const stream = await this._streamResponseChunks(messages, options, runManager);
+            const finalChunks = {};
+            for await (const chunk of stream) {
+                const index = chunk.generationInfo?.completion ?? 0;
+                if (finalChunks[index] === undefined) {
+                    finalChunks[index] = chunk;
+                }
+                else {
+                    finalChunks[index] = finalChunks[index].concat(chunk);
+                }
+            }
+            const generations = Object.entries(finalChunks)
+                .sort(([aKey], [bKey]) => parseInt(aKey, 10) - parseInt(bKey, 10))
+                .map(([_, value]) => value);
+            return { generations };
+        }
+        else {
+            const data = await this.completionWithRetry({
                 ...params,
+                stream: false,
                 messages: messagesMapped,
             }, {
                 signal: options?.signal,
                 ...options?.options,
             });
-        const { completion_tokens: completionTokens, prompt_tokens: promptTokens, total_tokens: totalTokens, } = data.usage ?? {};
-        if (completionTokens) {
-            tokenUsage.completionTokens =
-                (tokenUsage.completionTokens ?? 0) + completionTokens;
-        }
-        if (promptTokens) {
-            tokenUsage.promptTokens = (tokenUsage.promptTokens ?? 0) + promptTokens;
-        }
-        if (totalTokens) {
-            tokenUsage.totalTokens = (tokenUsage.totalTokens ?? 0) + totalTokens;
-        }
-        const generations = [];
-        for (const part of data.choices) {
-            const text = part.message?.content ?? "";
-            generations.push({
-                text,
-                message: openAIResponseToChatMessage(part.message ?? { role: "assistant" }),
-            });
+            const { completion_tokens: completionTokens, prompt_tokens: promptTokens, total_tokens: totalTokens, } = data?.usage ?? {};
+            if (completionTokens) {
+                tokenUsage.completionTokens =
+                    (tokenUsage.completionTokens ?? 0) + completionTokens;
+            }
+            if (promptTokens) {
+                tokenUsage.promptTokens = (tokenUsage.promptTokens ?? 0) + promptTokens;
+            }
+            if (totalTokens) {
+                tokenUsage.totalTokens = (tokenUsage.totalTokens ?? 0) + totalTokens;
+            }
+            const generations = [];
+            for (const part of data?.choices ?? []) {
+                const text = part.message?.content ?? "";
+                const generation = {
+                    text,
+                    message: openAIResponseToChatMessage(part.message ?? { role: "assistant" }),
+                };
+                if (part.finish_reason) {
+                    generation.generationInfo = { finish_reason: part.finish_reason };
+                }
+                generations.push(generation);
+            }
+            return {
+                generations,
+                llmOutput: { tokenUsage },
+            };
         }
-        return {
-            generations,
-            llmOutput: { tokenUsage },
-        };
     }
     async getNumTokensFromMessages(messages) {
         let totalCount = 0;
@@ -629,45 +506,55 @@ export class ChatOpenAI extends BaseChatModel {
         totalCount += 3; // every reply is primed with <|start|>assistant<|message|>
         return { totalCount, countPerMessage };
     }
-    /** @ignore */
     async completionWithRetry(request, options) {
+        const requestOptions = this._getClientOptions(options);
+        return this.caller.call(async () => {
+            try {
+                const res = await this.client.chat.completions.create(request, requestOptions);
+                return res;
+            }
+            catch (e) {
+                const error = wrapOpenAIClientError(e);
+                throw error;
+            }
+        });
+    }
+    _getClientOptions(options) {
         if (!this.client) {
             const openAIEndpointConfig = {
                 azureOpenAIApiDeploymentName: this.azureOpenAIApiDeploymentName,
                 azureOpenAIApiInstanceName: this.azureOpenAIApiInstanceName,
                 azureOpenAIApiKey: this.azureOpenAIApiKey,
                 azureOpenAIBasePath: this.azureOpenAIBasePath,
-                basePath: this.clientConfig.basePath,
+                baseURL: this.clientConfig.baseURL,
             };
             const endpoint = getEndpoint(openAIEndpointConfig);
-            const clientConfig = new Configuration({
+            const params = {
                 ...this.clientConfig,
-                basePath: endpoint,
-                baseOptions: {
-                    timeout: this.timeout,
-                    ...this.clientConfig.baseOptions,
-                },
-            });
-            this.client = new OpenAIApi(clientConfig);
+                baseURL: endpoint,
+                timeout: this.timeout,
+                maxRetries: 0,
+            };
+            if (!params.baseURL) {
+                delete params.baseURL;
+            }
+            this.client = new OpenAIClient(params);
         }
-        const axiosOptions = {
-            adapter: isNode() ? undefined : fetchAdapter,
-            ...this.clientConfig.baseOptions,
+        const requestOptions = {
+            ...this.clientConfig,
             ...options,
         };
         if (this.azureOpenAIApiKey) {
-            axiosOptions.headers = {
+            requestOptions.headers = {
                 "api-key": this.azureOpenAIApiKey,
-                ...axiosOptions.headers,
+                ...requestOptions.headers,
             };
-            axiosOptions.params = {
+            requestOptions.query = {
                 "api-version": this.azureOpenAIApiVersion,
-                ...axiosOptions.params,
+                ...requestOptions.query,
             };
         }
-        return this.caller
-            .call(this.client.createChatCompletion.bind(this.client), request, axiosOptions)
-            .then((res) => res.data);
+        return requestOptions;
     }
     _llmType() {
         return "openai";
@@ -787,7 +674,7 @@ export class PromptLayerChatOpenAI extends ChatOpenAI {
                     role: messageToOpenAIRole(generation.message),
                 },
             ];
-            const promptLayerRespBody = await promptLayerTrackRequest(this.caller, "langchain.PromptLayerChatOpenAI", messageDicts, this._identifyingParams(), this.plTags, parsedResp, requestStartTime, requestEndTime, this.promptLayerApiKey);
+            const promptLayerRespBody = await promptLayerTrackRequest(this.caller, "langchain.PromptLayerChatOpenAI", { ...this._identifyingParams(), messages: messageDicts, stream: false }, this.plTags, parsedResp, requestStartTime, requestEndTime, this.promptLayerApiKey);
             if (this.returnPromptLayerId === true) {
                 if (promptLayerRespBody.success === true) {
                     promptLayerRequestId = promptLayerRespBody.request_id;

package/dist/document_loaders/web/github.cjs

@@ -112,6 +112,9 @@ class GithubRepoLoader extends base_js_1.BaseDocumentLoader {
         this.accessToken = accessToken;
         this.ignoreFiles = ignoreFiles;
         this.verbose = verbose;
+        this.headers = {
+            "User-Agent": "langchain",
+        };
         this.caller = new async_caller_js_1.AsyncCaller({
             maxConcurrency,
             maxRetries,
@@ -122,6 +125,7 @@ class GithubRepoLoader extends base_js_1.BaseDocumentLoader {
         }
         if (this.accessToken) {
             this.headers = {
+                ...this.headers,
                 Authorization: `Bearer ${this.accessToken}`,
             };
         }

package/dist/document_loaders/web/github.js

@@ -106,6 +106,9 @@ export class GithubRepoLoader extends BaseDocumentLoader {
         this.accessToken = accessToken;
         this.ignoreFiles = ignoreFiles;
         this.verbose = verbose;
+        this.headers = {
+            "User-Agent": "langchain",
+        };
         this.caller = new AsyncCaller({
             maxConcurrency,
             maxRetries,
@@ -116,6 +119,7 @@ export class GithubRepoLoader extends BaseDocumentLoader {
         }
         if (this.accessToken) {
             this.headers = {
+                ...this.headers,
                 Authorization: `Bearer ${this.accessToken}`,
             };
         }

package/dist/embeddings/openai.cjs

@@ -1,15 +1,12 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIEmbeddings = void 0;
 const openai_1 = require("openai");
 const env_js_1 = require("../util/env.cjs");
-const axios_fetch_adapter_js_1 = __importDefault(require("../util/axios-fetch-adapter.cjs"));
 const chunk_js_1 = require("../util/chunk.cjs");
 const base_js_1 = require("./base.cjs");
 const azure_js_1 = require("../util/azure.cjs");
+const openai_js_1 = require("../util/openai.cjs");
 /**
  * Class for generating embeddings using the OpenAI API. Extends the
  * Embeddings class and implements OpenAIEmbeddingsParams and
@@ -126,6 +123,10 @@ class OpenAIEmbeddings extends base_js_1.Embeddings {
         }
         this.clientConfig = {
             apiKey,
+            baseURL: configuration?.basePath,
+            dangerouslyAllowBrowser: true,
+            defaultHeaders: configuration?.baseOptions?.headers,
+            defaultQuery: configuration?.baseOptions?.params,
             ...configuration,
         };
     }
@@ -148,7 +149,7 @@ class OpenAIEmbeddings extends base_js_1.Embeddings {
             const batch = batches[i];
             const { data: batchResponse } = batchResponses[i];
             for (let j = 0; j < batch.length; j += 1) {
-                embeddings.push(batchResponse.data[j].embedding);
+                embeddings.push(batchResponse[j].embedding);
             }
         }
         return embeddings;
@@ -164,7 +165,7 @@ class OpenAIEmbeddings extends base_js_1.Embeddings {
             model: this.modelName,
             input: this.stripNewLines ? text.replace(/\n/g, " ") : text,
         });
-        return data.data[0].embedding;
+        return data[0].embedding;
     }
     /**
      * Private method to make a request to the OpenAI API to generate
@@ -180,32 +181,41 @@ class OpenAIEmbeddings extends base_js_1.Embeddings {
                 azureOpenAIApiInstanceName: this.azureOpenAIApiInstanceName,
                 azureOpenAIApiKey: this.azureOpenAIApiKey,
                 azureOpenAIBasePath: this.azureOpenAIBasePath,
-                basePath: this.clientConfig.basePath,
+                baseURL: this.clientConfig.baseURL,
             };
             const endpoint = (0, azure_js_1.getEndpoint)(openAIEndpointConfig);
-            const clientConfig = new openai_1.Configuration({
+            const params = {
                 ...this.clientConfig,
-                basePath: endpoint,
-                baseOptions: {
-                    timeout: this.timeout,
-                    adapter: (0, env_js_1.isNode)() ? undefined : axios_fetch_adapter_js_1.default,
-                    ...this.clientConfig.baseOptions,
-                },
-            });
-            this.client = new openai_1.OpenAIApi(clientConfig);
+                baseURL: endpoint,
+                timeout: this.timeout,
+                maxRetries: 0,
+            };
+            if (!params.baseURL) {
+                delete params.baseURL;
+            }
+            this.client = new openai_1.OpenAI(params);
         }
-        const axiosOptions = {};
+        const requestOptions = {};
         if (this.azureOpenAIApiKey) {
-            axiosOptions.headers = {
+            requestOptions.headers = {
                 "api-key": this.azureOpenAIApiKey,
-                ...axiosOptions.headers,
+                ...requestOptions.headers,
             };
-            axiosOptions.params = {
+            requestOptions.query = {
                 "api-version": this.azureOpenAIApiVersion,
-                ...axiosOptions.params,
+                ...requestOptions.query,
             };
         }
-        return this.caller.call(this.client.createEmbedding.bind(this.client), request, axiosOptions);
+        return this.caller.call(async () => {
+            try {
+                const res = await this.client.embeddings.create(request, requestOptions);
+                return res;
+            }
+            catch (e) {
+                const error = (0, openai_js_1.wrapOpenAIClientError)(e);
+                throw error;
+            }
+        });
     }
 }
 exports.OpenAIEmbeddings = OpenAIEmbeddings;