langchain 0.0.140 → 0.0.142

package/dist/llms/openai.cjs

@@ -1,20 +1,16 @@
 "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 = exports.PromptLayerOpenAI = exports.OpenAI = void 0;
 const openai_1 = require("openai");
 const count_tokens_js_1 = require("../base_language/count_tokens.cjs");
 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 chunk_js_1 = require("../util/chunk.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_chat_js_1 = require("./openai-chat.cjs");
+const openai_js_1 = require("../util/openai.cjs");
 /**
  * Wrapper around OpenAI large language models.
  *
@@ -274,6 +270,12 @@ class OpenAI extends base_js_1.BaseLLM {
         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,
         };
@@ -298,6 +300,7 @@ class OpenAI extends base_js_1.BaseLLM {
             ...this.modelKwargs,
         };
     }
+    /** @ignore */
     _identifyingParams() {
         return {
             model_name: this.modelName,
@@ -344,94 +347,62 @@ class OpenAI extends base_js_1.BaseLLM {
         }
         for (let i = 0; i < subPrompts.length; i += 1) {
             const data = params.stream
-                ? await new Promise((resolve, reject) => {
+                ? await (async () => {
                     const choices = [];
                     let response;
-                    let rejected = false;
-                    let resolved = false;
-                    this.completionWithRetry({
+                    const stream = await this.completionWithRetry({
                         ...params,
+                        stream: true,
                         prompt: subPrompts[i],
-                    }, {
-                        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,
-                                    choices,
-                                });
+                    }, options);
+                    for await (const message of stream) {
+                        // on the first message set the response properties
+                        if (!response) {
+                            response = {
+                                id: message.id,
+                                object: message.object,
+                                created: message.created,
+                                model: message.model,
+                            };
+                        }
+                        // on all messages, update choice
+                        for (const part of message.choices) {
+                            if (!choices[part.index]) {
+                                choices[part.index] = part;
                             }
                             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,
-                                    };
-                                }
-                                // on all messages, update choice
-                                for (const part of message.choices) {
-                                    if (part != null && part.index != null) {
-                                        if (!choices[part.index])
-                                            choices[part.index] = {};
-                                        const choice = choices[part.index];
-                                        choice.text = (choice.text ?? "") + (part.text ?? "");
-                                        choice.finish_reason = part.finish_reason;
-                                        choice.logprobs = part.logprobs;
-                                        // eslint-disable-next-line no-void
-                                        void runManager?.handleLLMNewToken(part.text ?? "", {
-                                            prompt: Math.floor(part.index / this.n),
-                                            completion: part.index % this.n,
-                                        });
-                                    }
-                                }
-                                // when all messages are finished, resolve
-                                if (!resolved &&
-                                    !rejected &&
-                                    choices.every((c) => c.finish_reason != null)) {
-                                    resolved = true;
-                                    resolve({
-                                        ...response,
-                                        choices,
-                                    });
-                                }
+                                const choice = choices[part.index];
+                                choice.text += part.text;
+                                choice.finish_reason = part.finish_reason;
+                                choice.logprobs = part.logprobs;
                             }
-                        },
-                    }).catch((error) => {
-                        if (!rejected) {
-                            rejected = true;
-                            reject(error);
+                            void runManager?.handleLLMNewToken(part.text, {
+                                prompt: Math.floor(part.index / this.n),
+                                completion: part.index % this.n,
+                            });
                         }
-                    });
-                })
+                    }
+                    if (options.signal?.aborted) {
+                        throw new Error("AbortError");
+                    }
+                    return { ...response, choices };
+                })()
                 : await this.completionWithRetry({
                     ...params,
+                    stream: false,
                     prompt: subPrompts[i],
                 }, {
                     signal: options.signal,
                     ...options.options,
                 });
             choices.push(...data.choices);
-            const { completion_tokens: completionTokens, prompt_tokens: promptTokens, total_tokens: totalTokens, } = data.usage ?? {};
+            const { completion_tokens: completionTokens, prompt_tokens: promptTokens, total_tokens: totalTokens, } = data.usage
+                ? data.usage
+                : {
+                    completion_tokens: undefined,
+                    prompt_tokens: undefined,
+                    total_tokens: undefined,
+                };
             if (completionTokens) {
                 tokenUsage.completionTokens =
                     (tokenUsage.completionTokens ?? 0) + completionTokens;
@@ -455,18 +426,16 @@ class OpenAI extends base_js_1.BaseLLM {
             llmOutput: { tokenUsage },
         };
     }
-    // TODO(jacoblee): Refactor with _generate(..., {stream: true}) implementation
-    // when we integrate OpenAI's new SDK.
+    // TODO(jacoblee): Refactor with _generate(..., {stream: true}) implementation?
     async *_streamResponseChunks(input, options, runManager) {
         const params = {
             ...this.invocationParams(options),
             prompt: input,
             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;
             }
@@ -474,103 +443,71 @@ class OpenAI extends base_js_1.BaseLLM {
                 text: choice.text,
                 generationInfo: {
                     finishReason: choice.finish_reason,
-                    logprobs: choice.logprobs,
                 },
             });
             yield chunk;
             // eslint-disable-next-line no-void
             void runManager?.handleLLMNewToken(chunk.text ?? "");
         }
+        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 = (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();
-                }
-                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();
+    async completionWithRetry(request, options) {
+        const requestOptions = this._getClientOptions(options);
+        return this.caller.call(async () => {
+            try {
+                const res = await this.client.completions.create(request, requestOptions);
+                return res;
+            }
+            catch (e) {
+                const error = (0, openai_js_1.wrapOpenAIClientError)(e);
+                throw error;
             }
         });
-        return {
-            async next() {
-                const chunk = await iterable.next();
-                if (err) {
-                    throw err;
-                }
-                return chunk;
-            },
-            [Symbol.asyncIterator]() {
-                return this;
-            },
-        };
     }
-    /** @ignore */
-    async completionWithRetry(request, options) {
+    /**
+     * 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.
+     */
+    _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.createCompletion.bind(this.client), request, axiosOptions)
-            .then((res) => res.data);
+        return requestOptions;
     }
     _llmType() {
         return "openai";
@@ -622,19 +559,6 @@ class PromptLayerOpenAI extends OpenAI {
             throw new Error("Missing PromptLayer API key");
         }
     }
-    /**
-     * 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.
-     */
-    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) {
         const requestStartTime = Date.now();
         const generations = await super._generate(prompts, options, runManager);
@@ -644,7 +568,9 @@ class PromptLayerOpenAI extends OpenAI {
                 text: generations.generations[i][0].text,
                 llm_output: generations.llmOutput,
             };
-            const promptLayerRespBody = await (0, prompt_layer_js_1.promptLayerTrackRequest)(this.caller, "langchain.PromptLayerOpenAI", [prompts[i]], this._identifyingParams(), this.plTags, parsedResp, requestStartTime, requestEndTime, this.promptLayerApiKey);
+            const promptLayerRespBody = await (0, prompt_layer_js_1.promptLayerTrackRequest)(this.caller, "langchain.PromptLayerOpenAI", 
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            { ...this._identifyingParams(), prompt: prompts[i] }, this.plTags, parsedResp, requestStartTime, requestEndTime, this.promptLayerApiKey);
             let promptLayerRequestId;
             if (this.returnPromptLayerId === true) {
                 if (promptLayerRespBody && promptLayerRespBody.success === true) {

package/dist/llms/openai.d.ts

@@ -1,8 +1,7 @@
-import { ConfigurationParameters, CreateCompletionRequest, CreateCompletionResponse } 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, OpenAIInput } from "../types/openai-types.js";
-import type { StreamingAxiosConfiguration } from "../util/axios-types.js";
+import { AzureOpenAIInput, OpenAICallOptions, OpenAICoreRequestOptions, OpenAIInput, LegacyOpenAIInput } from "../types/openai-types.js";
 import { BaseLLM, BaseLLMParams } from "./base.js";
 export { AzureOpenAIInput, OpenAICallOptions, OpenAIInput };
 /**
@@ -56,71 +55,24 @@ export declare class OpenAI extends BaseLLM<OpenAICallOptions> implements OpenAI
     private client;
     private clientConfig;
     constructor(fields?: Partial<OpenAIInput> & 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"]): CreateCompletionRequest;
-    _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;
-        model: string;
-        prompt?: import("openai").CreateCompletionRequestPrompt | null | undefined;
-        suffix?: string | null | undefined;
-        max_tokens?: number | null | undefined;
-        temperature?: number | null | undefined;
-        top_p?: number | null | undefined;
-        n?: number | null | undefined;
-        stream?: boolean | null | undefined;
-        logprobs?: number | null | undefined;
-        echo?: boolean | null | undefined;
-        stop?: import("openai").CreateCompletionRequestStop | null | undefined;
-        presence_penalty?: number | null | undefined;
-        frequency_penalty?: number | null | undefined;
-        best_of?: number | null | undefined;
-        logit_bias?: object | null | undefined;
-        user?: string | undefined;
+    invocationParams(options?: this["ParsedCallOptions"]): Omit<OpenAIClient.CompletionCreateParams, "prompt">;
+    /** @ignore */
+    _identifyingParams(): Omit<OpenAIClient.CompletionCreateParams, "prompt"> & {
         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;
-        model: string;
-        prompt?: import("openai").CreateCompletionRequestPrompt | null | undefined;
-        suffix?: string | null | undefined;
-        max_tokens?: number | null | undefined;
-        temperature?: number | null | undefined;
-        top_p?: number | null | undefined;
-        n?: number | null | undefined;
-        stream?: boolean | null | undefined;
-        logprobs?: number | null | undefined;
-        echo?: boolean | null | undefined;
-        stop?: import("openai").CreateCompletionRequestStop | null | undefined;
-        presence_penalty?: number | null | undefined;
-        frequency_penalty?: number | null | undefined;
-        best_of?: number | null | undefined;
-        logit_bias?: object | null | undefined;
-        user?: string | undefined;
+    identifyingParams(): Omit<OpenAIClient.CompletionCreateParams, "prompt"> & {
         model_name: string;
-    };
+    } & ClientOptions;
     /**
      * Call out to OpenAI's endpoint with k unique prompts
      *
@@ -139,12 +91,21 @@ export declare class OpenAI extends BaseLLM<OpenAICallOptions> implements OpenAI
      */
     _generate(prompts: string[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<LLMResult>;
     _streamResponseChunks(input: string, options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<GenerationChunk>;
-    startStream(request: CreateCompletionRequest, options?: StreamingAxiosConfiguration): {
-        next(): Promise<any>;
-        [Symbol.asyncIterator](): any;
-    };
-    /** @ignore */
-    completionWithRetry(request: CreateCompletionRequest, options?: StreamingAxiosConfiguration): Promise<CreateCompletionResponse>;
+    /**
+     * 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.CompletionCreateParamsStreaming, options?: OpenAICoreRequestOptions): Promise<AsyncIterable<OpenAIClient.Completion>>;
+    completionWithRetry(request: OpenAIClient.CompletionCreateParamsNonStreaming, options?: OpenAICoreRequestOptions): Promise<OpenAIClient.Completions.Completion>;
+    /**
+     * 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.
+     */
+    private _getClientOptions;
     _llmType(): string;
 }
 /**
@@ -164,13 +125,6 @@ export declare class PromptLayerOpenAI extends OpenAI {
         plTags?: string[];
         returnPromptLayerId?: boolean;
     });
-    /**
-     * 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: CreateCompletionRequest, options?: StreamingAxiosConfiguration): Promise<CreateCompletionResponse>;
     _generate(prompts: string[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<LLMResult>;
 }
 export { OpenAIChat, PromptLayerOpenAIChat } from "./openai-chat.js";