langchain 0.0.140 → 0.0.141

package/dist/llms/openai-chat.js

@@ -1,11 +1,10 @@
-import { Configuration, OpenAIApi, } from "openai";
+import { OpenAI as OpenAIClient } from "openai";
 import { GenerationChunk } from "../schema/index.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 { LLM } from "./base.js";
+import { wrapOpenAIClientError } from "../util/openai.js";
 /**
  * Wrapper around OpenAI large language models that use the Chat endpoint.
  *
@@ -260,6 +259,12 @@ export class OpenAIChat extends 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,
         };
@@ -313,18 +318,15 @@ export class OpenAIChat extends 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;
             }
@@ -333,201 +335,95 @@ export class OpenAIChat extends 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 = 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();
+    /** @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: 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?.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 = 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 = 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";
@@ -577,19 +473,6 @@ export 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) => {
@@ -600,7 +483,9 @@ export class PromptLayerOpenAIChat extends OpenAIChat {
             const parsedResp = {
                 text,
             };
-            const promptLayerRespBody = await promptLayerTrackRequest(this.caller, "langchain.PromptLayerOpenAIChat", [prompt], this._identifyingParams(), this.plTags, parsedResp, requestStartTime, requestEndTime, this.promptLayerApiKey);
+            const promptLayerRespBody = await 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 = {