langchain 0.0.140 → 0.0.142

package/dist/embeddings/openai.d.ts

@@ -1,5 +1,5 @@
-import { ConfigurationParameters } from "openai";
-import { AzureOpenAIInput } from "../types/openai-types.js";
+import { type ClientOptions } from "openai";
+import { AzureOpenAIInput, LegacyOpenAIInput } from "../types/openai-types.js";
 import { Embeddings, EmbeddingsParams } from "./base.js";
 /**
  * Interface for OpenAIEmbeddings parameters. Extends EmbeddingsParams and
@@ -43,7 +43,7 @@ export declare class OpenAIEmbeddings extends Embeddings implements OpenAIEmbedd
     constructor(fields?: Partial<OpenAIEmbeddingsParams> & Partial<AzureOpenAIInput> & {
         verbose?: boolean;
         openAIApiKey?: string;
-    }, configuration?: ConfigurationParameters);
+    }, configuration?: ClientOptions & LegacyOpenAIInput);
     /**
      * Method to generate embeddings for an array of documents. Splits the
      * documents into batches and makes requests to the OpenAI API to generate

package/dist/embeddings/openai.js

@@ -1,9 +1,9 @@
-import { Configuration, OpenAIApi, } from "openai";
-import { getEnvironmentVariable, isNode } from "../util/env.js";
-import fetchAdapter from "../util/axios-fetch-adapter.js";
+import { OpenAI as OpenAIClient } from "openai";
+import { getEnvironmentVariable } from "../util/env.js";
 import { chunkArray } from "../util/chunk.js";
 import { Embeddings } from "./base.js";
 import { getEndpoint } from "../util/azure.js";
+import { wrapOpenAIClientError } from "../util/openai.js";
 /**
  * Class for generating embeddings using the OpenAI API. Extends the
  * Embeddings class and implements OpenAIEmbeddingsParams and
@@ -120,6 +120,10 @@ export class OpenAIEmbeddings extends Embeddings {
         }
         this.clientConfig = {
             apiKey,
+            baseURL: configuration?.basePath,
+            dangerouslyAllowBrowser: true,
+            defaultHeaders: configuration?.baseOptions?.headers,
+            defaultQuery: configuration?.baseOptions?.params,
             ...configuration,
         };
     }
@@ -142,7 +146,7 @@ export class OpenAIEmbeddings extends 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;
@@ -158,7 +162,7 @@ export class OpenAIEmbeddings extends 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
@@ -174,31 +178,40 @@ export class OpenAIEmbeddings extends Embeddings {
                 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,
-                    adapter: isNode() ? undefined : fetchAdapter,
-                    ...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 = {};
+        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 = wrapOpenAIClientError(e);
+                throw error;
+            }
+        });
     }
 }

package/dist/experimental/chat_models/anthropic_functions.cjs

@@ -83,6 +83,9 @@ class AnthropicFunctions extends anthropic_js_1.ChatAnthropic {
         if (forced) {
             const parser = new fast_xml_parser_1.XMLParser();
             const result = parser.parse(`${chatGenerationContent}</tool_input>`);
+            if (functionCall === undefined) {
+                throw new Error(`Could not parse called function from model output.`);
+            }
             const responseMessageWithFunctions = new index_js_1.AIMessage({
                 content: "",
                 additional_kwargs: {

package/dist/experimental/chat_models/anthropic_functions.d.ts

@@ -1,4 +1,4 @@
-import type { ChatCompletionFunctions, CreateChatCompletionRequestFunctionCall } from "openai";
+import type { OpenAI as OpenAIClient } from "openai";
 import { BaseChatModelParams } from "../../chat_models/base.js";
 import { CallbackManagerForLLMRun } from "../../callbacks/manager.js";
 import { BaseMessage, ChatResult } from "../../schema/index.js";
@@ -6,8 +6,8 @@ import { ChatAnthropic, type AnthropicInput } from "../../chat_models/anthropic.
 import { BaseLanguageModelCallOptions } from "../../base_language/index.js";
 import { StructuredTool } from "../../tools/base.js";
 export interface ChatAnthropicFunctionsCallOptions extends BaseLanguageModelCallOptions {
-    function_call?: CreateChatCompletionRequestFunctionCall;
-    functions?: ChatCompletionFunctions[];
+    function_call?: OpenAIClient.Chat.ChatCompletionCreateParams.FunctionCallOption;
+    functions?: OpenAIClient.Chat.ChatCompletionCreateParams.Function[];
     tools?: StructuredTool[];
 }
 export declare class AnthropicFunctions extends ChatAnthropic<ChatAnthropicFunctionsCallOptions> {

package/dist/experimental/chat_models/anthropic_functions.js

@@ -80,6 +80,9 @@ export class AnthropicFunctions extends ChatAnthropic {
         if (forced) {
             const parser = new XMLParser();
             const result = parser.parse(`${chatGenerationContent}</tool_input>`);
+            if (functionCall === undefined) {
+                throw new Error(`Could not parse called function from model output.`);
+            }
             const responseMessageWithFunctions = new AIMessage({
                 content: "",
                 additional_kwargs: {

package/dist/llms/openai-chat.cjs

@@ -1,17 +1,13 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PromptLayerOpenAIChat = exports.OpenAIChat = void 0;
 const openai_1 = require("openai");
 const index_js_1 = require("../schema/index.cjs");
-const axios_fetch_adapter_js_1 = __importDefault(require("../util/axios-fetch-adapter.cjs"));
 const azure_js_1 = require("../util/azure.cjs");
 const env_js_1 = require("../util/env.cjs");
 const prompt_layer_js_1 = require("../util/prompt-layer.cjs");
-const stream_js_1 = require("../util/stream.cjs");
 const base_js_1 = require("./base.cjs");
+const openai_js_1 = require("../util/openai.cjs");
 /**
  * Wrapper around OpenAI large language models that use the Chat endpoint.
  *
@@ -266,6 +262,12 @@ class OpenAIChat extends base_js_1.LLM {
         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,
         };
@@ -319,18 +321,15 @@ class OpenAIChat extends base_js_1.LLM {
         };
         return this.prefixMessages ? [...this.prefixMessages, message] : [message];
     }
-    // TODO(jacoblee): Refactor with _generate(..., {stream: true}) implementation
-    // when we integrate OpenAI's new SDK.
     async *_streamResponseChunks(prompt, options, runManager) {
         const params = {
             ...this.invocationParams(options),
             messages: this.formatMessages(prompt),
             stream: true,
         };
-        const streamIterable = this.startStream(params, options);
-        for await (const streamedResponse of streamIterable) {
-            const data = JSON.parse(streamedResponse);
-            const choice = data.choices?.[0];
+        const stream = await this.completionWithRetry(params, options);
+        for await (const data of stream) {
+            const choice = data.choices[0];
             if (!choice) {
                 continue;
             }
@@ -339,201 +338,95 @@ class OpenAIChat extends base_js_1.LLM {
                 text: delta.content ?? "",
             });
             yield generationChunk;
+            const newTokenIndices = {
+                prompt: options.promptIndex ?? 0,
+                completion: choice.index ?? 0,
+            };
             // eslint-disable-next-line no-void
-            void runManager?.handleLLMNewToken(generationChunk.text ?? "");
+            void runManager?.handleLLMNewToken(generationChunk.text ?? "", newTokenIndices);
+        }
+        if (options.signal?.aborted) {
+            throw new Error("AbortError");
         }
     }
-    /**
-     * Starts a stream of responses from the OpenAI API.
-     * @param request The request to be sent to the OpenAI API.
-     * @param options Optional configuration for the Axios request.
-     * @returns An iterable object that can be used to iterate over the response chunks.
-     */
-    startStream(request, options) {
-        let done = false;
-        const stream = new TransformStream();
-        const writer = stream.writable.getWriter();
-        const iterable = (0, stream_js_1.readableStreamToAsyncIterable)(stream.readable);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let err;
-        this.completionWithRetry(request, {
-            ...options,
-            adapter: axios_fetch_adapter_js_1.default,
-            responseType: "stream",
-            onmessage: (event) => {
-                if (done)
-                    return;
-                if (event.data?.trim?.() === "[DONE]") {
-                    done = true;
-                    // eslint-disable-next-line no-void
-                    void writer.close();
+    /** @ignore */
+    async _call(prompt, options, runManager) {
+        const params = this.invocationParams(options);
+        if (params.stream) {
+            const stream = await this._streamResponseChunks(prompt, options, runManager);
+            let finalChunk;
+            for await (const chunk of stream) {
+                if (finalChunk === undefined) {
+                    finalChunk = chunk;
                 }
                 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);
+                    finalChunk = finalChunk.concat(chunk);
                 }
-            },
-        }).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;
-            },
-        };
-    }
-    /** @ignore */
-    async _call(prompt, options, runManager) {
-        const params = this.invocationParams(options);
-        const data = params.stream
-            ? await new Promise((resolve, reject) => {
-                let response;
-                let rejected = false;
-                let resolved = false;
-                this.completionWithRetry({
-                    ...params,
-                    messages: this.formatMessages(prompt),
-                }, {
-                    signal: options.signal,
-                    ...options.options,
-                    adapter: axios_fetch_adapter_js_1.default,
-                    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?.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.push(choice);
-                                    }
-                                    if (!choice.message) {
-                                        choice.message = {
-                                            role: part.delta
-                                                ?.role,
-                                            content: part.delta?.content ?? "",
-                                        };
-                                    }
-                                    choice.message.content += part.delta?.content ?? "";
-                                    // eslint-disable-next-line no-void
-                                    void runManager?.handleLLMNewToken(part.delta?.content ?? "", {
-                                        prompt: options.promptIndex ?? 0,
-                                        completion: part.index,
-                                    });
-                                }
-                            }
-                            // 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({
+            return finalChunk?.text ?? "";
+        }
+        else {
+            const response = await this.completionWithRetry({
                 ...params,
+                stream: false,
                 messages: this.formatMessages(prompt),
             }, {
                 signal: options.signal,
                 ...options.options,
             });
-        return data.choices[0].message?.content ?? "";
+            return response?.choices[0]?.message?.content ?? "";
+        }
     }
-    /** @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 = (0, openai_js_1.wrapOpenAIClientError)(e);
+                throw error;
+            }
+        });
+    }
+    /** @ignore */
+    _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 = (0, azure_js_1.getEndpoint)(openAIEndpointConfig);
-            const clientConfig = new openai_1.Configuration({
+            const params = {
                 ...this.clientConfig,
-                basePath: endpoint,
-                baseOptions: {
-                    timeout: this.timeout,
-                    ...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 = {
-            adapter: (0, env_js_1.isNode)() ? undefined : axios_fetch_adapter_js_1.default,
-            ...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";
@@ -584,19 +477,6 @@ class PromptLayerOpenAIChat extends OpenAIChat {
             throw new Error("Missing PromptLayer API key");
         }
     }
-    /**
-     * Makes a call to the OpenAI API with retry logic in case of failures.
-     * @param request The request to be sent to the OpenAI API.
-     * @param options Optional configuration for the Axios request.
-     * @returns The response from the OpenAI API.
-     */
-    async completionWithRetry(request, options) {
-        if (request.stream) {
-            return super.completionWithRetry(request, options);
-        }
-        const response = await super.completionWithRetry(request);
-        return response;
-    }
     async _generate(prompts, options, runManager) {
         let choice;
         const generations = await Promise.all(prompts.map(async (prompt) => {
@@ -607,7 +487,9 @@ class PromptLayerOpenAIChat extends OpenAIChat {
             const parsedResp = {
                 text,
             };
-            const promptLayerRespBody = await (0, prompt_layer_js_1.promptLayerTrackRequest)(this.caller, "langchain.PromptLayerOpenAIChat", [prompt], this._identifyingParams(), this.plTags, parsedResp, requestStartTime, requestEndTime, this.promptLayerApiKey);
+            const promptLayerRespBody = await (0, prompt_layer_js_1.promptLayerTrackRequest)(this.caller, "langchain.PromptLayerOpenAIChat", 
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            { ...this._identifyingParams(), prompt }, this.plTags, parsedResp, requestStartTime, requestEndTime, this.promptLayerApiKey);
             if (this.returnPromptLayerId === true &&
                 promptLayerRespBody.success === true) {
                 choice[0].generationInfo = {

package/dist/llms/openai-chat.d.ts

@@ -1,8 +1,7 @@
-import { ChatCompletionRequestMessage, ConfigurationParameters, CreateChatCompletionRequest, CreateChatCompletionResponse } from "openai";
+import { type ClientOptions, OpenAI as OpenAIClient } from "openai";
 import { CallbackManagerForLLMRun } from "../callbacks/manager.js";
 import { GenerationChunk, LLMResult } from "../schema/index.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 { BaseLLMParams, LLM } from "./base.js";
 export { AzureOpenAIInput, OpenAIChatInput };
 /**
@@ -51,7 +50,7 @@ export declare class OpenAIChat extends LLM<OpenAIChatCallOptions> implements Op
     logitBias?: Record<string, number>;
     maxTokens?: number;
     modelName: string;
-    prefixMessages?: ChatCompletionRequestMessage[];
+    prefixMessages?: OpenAIClient.Chat.ChatCompletionMessageParam[];
     modelKwargs?: OpenAIChatInput["modelKwargs"];
     timeout?: number;
     stop?: string[];
@@ -67,66 +66,24 @@ export declare class OpenAIChat extends LLM<OpenAIChatCallOptions> implements Op
     private client;
     private clientConfig;
     constructor(fields?: Partial<OpenAIChatInput> & Partial<AzureOpenAIInput> & BaseLLMParams & {
-        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?: import("openai").CreateChatCompletionRequestFunctionCall | undefined;
-        stop?: import("openai").CreateChatCompletionRequestStop | undefined;
-        stream?: boolean | null | undefined;
-        user?: string | undefined;
-        functions?: import("openai").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;
     /**
      * 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?: import("openai").CreateChatCompletionRequestFunctionCall | undefined;
-        stop?: import("openai").CreateChatCompletionRequestStop | undefined;
-        stream?: boolean | null | undefined;
-        user?: string | undefined;
-        functions?: import("openai").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;
     /**
      * Formats the messages for the OpenAI API.
      * @param prompt The prompt to be formatted.
@@ -134,20 +91,18 @@ export declare class OpenAIChat extends LLM<OpenAIChatCallOptions> implements Op
      */
     private formatMessages;
     _streamResponseChunks(prompt: string, options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<GenerationChunk>;
-    /**
-     * Starts a stream of responses from the OpenAI API.
-     * @param request The request to be sent to the OpenAI API.
-     * @param options Optional configuration for the Axios request.
-     * @returns An iterable object that can be used to iterate over the response chunks.
-     */
-    startStream(request: CreateChatCompletionRequest, options?: StreamingAxiosConfiguration): {
-        next(): Promise<any>;
-        [Symbol.asyncIterator](): any;
-    };
     /** @ignore */
     _call(prompt: string, options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<string>;
+    /**
+     * 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>;
     /** @ignore */
-    completionWithRetry(request: CreateChatCompletionRequest, options?: StreamingAxiosConfiguration): Promise<CreateChatCompletionResponse>;
+    private _getClientOptions;
     _llmType(): string;
 }
 /**
@@ -166,12 +121,5 @@ export declare class PromptLayerOpenAIChat extends OpenAIChat {
         plTags?: string[];
         returnPromptLayerId?: boolean;
     });
-    /**
-     * Makes a call to the OpenAI API with retry logic in case of failures.
-     * @param request The request to be sent to the OpenAI API.
-     * @param options Optional configuration for the Axios request.
-     * @returns The response from the OpenAI API.
-     */
-    completionWithRetry(request: CreateChatCompletionRequest, options?: StreamingAxiosConfiguration): Promise<CreateChatCompletionResponse>;
     _generate(prompts: string[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<LLMResult>;
 }