@langchain/openai 0.0.0

package/dist/llms.js

@@ -0,0 +1,527 @@
+import { OpenAI as OpenAIClient } from "openai";
+import { calculateMaxTokens } from "@langchain/core/language_models/base";
+import { GenerationChunk } from "@langchain/core/outputs";
+import { getEnvironmentVariable } from "@langchain/core/utils/env";
+import { BaseLLM, } from "@langchain/core/language_models/llms";
+import { getEndpoint } from "./utils/azure.js";
+import { chunkArray } from "./utils/chunk.js";
+import { OpenAIChat } from "./legacy.js";
+import { wrapOpenAIClientError } from "./utils/openai.js";
+export { OpenAIChat };
+/**
+ * Wrapper around OpenAI large language models.
+ *
+ * To use you should have the `openai` package installed, with the
+ * `OPENAI_API_KEY` environment variable set.
+ *
+ * To use with Azure you should have the `openai` package installed, with the
+ * `AZURE_OPENAI_API_KEY`,
+ * `AZURE_OPENAI_API_INSTANCE_NAME`,
+ * `AZURE_OPENAI_API_DEPLOYMENT_NAME`
+ * and `AZURE_OPENAI_API_VERSION` environment variable set.
+ *
+ * @remarks
+ * Any parameters that are valid to be passed to {@link
+ * https://platform.openai.com/docs/api-reference/completions/create |
+ * `openai.createCompletion`} can be passed through {@link modelKwargs}, even
+ * if not explicitly available on this class.
+ * @example
+ * ```typescript
+ * const model = new OpenAI({
+ *   modelName: "gpt-4",
+ *   temperature: 0.7,
+ *   maxTokens: 1000,
+ *   maxRetries: 5,
+ * });
+ *
+ * const res = await model.call(
+ *   "Question: What would be a good company name for a company that makes colorful socks?\nAnswer:"
+ * );
+ * console.log({ res });
+ * ```
+ */
+export class OpenAI extends BaseLLM {
+    static lc_name() {
+        return "OpenAI";
+    }
+    get callKeys() {
+        return [...super.callKeys, "options"];
+    }
+    get lc_secrets() {
+        return {
+            openAIApiKey: "OPENAI_API_KEY",
+            azureOpenAIApiKey: "AZURE_OPENAI_API_KEY",
+            organization: "OPENAI_ORGANIZATION",
+        };
+    }
+    get lc_aliases() {
+        return {
+            modelName: "model",
+            openAIApiKey: "openai_api_key",
+            azureOpenAIApiVersion: "azure_openai_api_version",
+            azureOpenAIApiKey: "azure_openai_api_key",
+            azureOpenAIApiInstanceName: "azure_openai_api_instance_name",
+            azureOpenAIApiDeploymentName: "azure_openai_api_deployment_name",
+        };
+    }
+    constructor(fields, 
+    /** @deprecated */
+    configuration) {
+        if ((fields?.modelName?.startsWith("gpt-3.5-turbo") ||
+            fields?.modelName?.startsWith("gpt-4")) &&
+            !fields?.modelName?.includes("-instruct")) {
+            // eslint-disable-next-line no-constructor-return
+            return new OpenAIChat(fields, configuration);
+        }
+        super(fields ?? {});
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "temperature", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0.7
+        });
+        Object.defineProperty(this, "maxTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 256
+        });
+        Object.defineProperty(this, "topP", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1
+        });
+        Object.defineProperty(this, "frequencyPenalty", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "presencePenalty", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "n", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1
+        });
+        Object.defineProperty(this, "bestOf", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "logitBias", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "modelName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "gpt-3.5-turbo-instruct"
+        });
+        Object.defineProperty(this, "modelKwargs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "batchSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 20
+        });
+        Object.defineProperty(this, "timeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "stop", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "user", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "streaming", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "openAIApiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "azureOpenAIApiVersion", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "azureOpenAIApiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "azureOpenAIApiInstanceName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "azureOpenAIApiDeploymentName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "azureOpenAIBasePath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "organization", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "clientConfig", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.openAIApiKey =
+            fields?.openAIApiKey ?? getEnvironmentVariable("OPENAI_API_KEY");
+        this.azureOpenAIApiKey =
+            fields?.azureOpenAIApiKey ??
+                getEnvironmentVariable("AZURE_OPENAI_API_KEY");
+        if (!this.azureOpenAIApiKey && !this.openAIApiKey) {
+            throw new Error("OpenAI or Azure OpenAI API key not found");
+        }
+        this.azureOpenAIApiInstanceName =
+            fields?.azureOpenAIApiInstanceName ??
+                getEnvironmentVariable("AZURE_OPENAI_API_INSTANCE_NAME");
+        this.azureOpenAIApiDeploymentName =
+            (fields?.azureOpenAIApiCompletionsDeploymentName ||
+                fields?.azureOpenAIApiDeploymentName) ??
+                (getEnvironmentVariable("AZURE_OPENAI_API_COMPLETIONS_DEPLOYMENT_NAME") ||
+                    getEnvironmentVariable("AZURE_OPENAI_API_DEPLOYMENT_NAME"));
+        this.azureOpenAIApiVersion =
+            fields?.azureOpenAIApiVersion ??
+                getEnvironmentVariable("AZURE_OPENAI_API_VERSION");
+        this.azureOpenAIBasePath =
+            fields?.azureOpenAIBasePath ??
+                getEnvironmentVariable("AZURE_OPENAI_BASE_PATH");
+        this.organization =
+            fields?.configuration?.organization ??
+                getEnvironmentVariable("OPENAI_ORGANIZATION");
+        this.modelName = fields?.modelName ?? this.modelName;
+        this.modelKwargs = fields?.modelKwargs ?? {};
+        this.batchSize = fields?.batchSize ?? this.batchSize;
+        this.timeout = fields?.timeout;
+        this.temperature = fields?.temperature ?? this.temperature;
+        this.maxTokens = fields?.maxTokens ?? this.maxTokens;
+        this.topP = fields?.topP ?? this.topP;
+        this.frequencyPenalty = fields?.frequencyPenalty ?? this.frequencyPenalty;
+        this.presencePenalty = fields?.presencePenalty ?? this.presencePenalty;
+        this.n = fields?.n ?? this.n;
+        this.bestOf = fields?.bestOf ?? this.bestOf;
+        this.logitBias = fields?.logitBias;
+        this.stop = fields?.stop;
+        this.user = fields?.user;
+        this.streaming = fields?.streaming ?? false;
+        if (this.streaming && this.bestOf && this.bestOf > 1) {
+            throw new Error("Cannot stream results when bestOf > 1");
+        }
+        if (this.azureOpenAIApiKey) {
+            if (!this.azureOpenAIApiInstanceName && !this.azureOpenAIBasePath) {
+                throw new Error("Azure OpenAI API instance name not found");
+            }
+            if (!this.azureOpenAIApiDeploymentName) {
+                throw new Error("Azure OpenAI API deployment name not found");
+            }
+            if (!this.azureOpenAIApiVersion) {
+                throw new Error("Azure OpenAI API version not found");
+            }
+            this.openAIApiKey = this.openAIApiKey ?? "";
+        }
+        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,
+        };
+    }
+    /**
+     * Get the parameters used to invoke the model
+     */
+    invocationParams(options) {
+        return {
+            model: this.modelName,
+            temperature: this.temperature,
+            max_tokens: this.maxTokens,
+            top_p: this.topP,
+            frequency_penalty: this.frequencyPenalty,
+            presence_penalty: this.presencePenalty,
+            n: this.n,
+            best_of: this.bestOf,
+            logit_bias: this.logitBias,
+            stop: options?.stop ?? this.stop,
+            user: this.user,
+            stream: this.streaming,
+            ...this.modelKwargs,
+        };
+    }
+    /** @ignore */
+    _identifyingParams() {
+        return {
+            model_name: this.modelName,
+            ...this.invocationParams(),
+            ...this.clientConfig,
+        };
+    }
+    /**
+     * Get the identifying parameters for the model
+     */
+    identifyingParams() {
+        return this._identifyingParams();
+    }
+    /**
+     * Call out to OpenAI's endpoint with k unique prompts
+     *
+     * @param [prompts] - The prompts to pass into the model.
+     * @param [options] - Optional list of stop words to use when generating.
+     * @param [runManager] - Optional callback manager to use when generating.
+     *
+     * @returns The full LLM output.
+     *
+     * @example
+     * ```ts
+     * import { OpenAI } from "langchain/llms/openai";
+     * const openai = new OpenAI();
+     * const response = await openai.generate(["Tell me a joke."]);
+     * ```
+     */
+    async _generate(prompts, options, runManager) {
+        const subPrompts = chunkArray(prompts, this.batchSize);
+        const choices = [];
+        const tokenUsage = {};
+        const params = this.invocationParams(options);
+        if (params.max_tokens === -1) {
+            if (prompts.length !== 1) {
+                throw new Error("max_tokens set to -1 not supported for multiple inputs");
+            }
+            params.max_tokens = await calculateMaxTokens({
+                prompt: prompts[0],
+                // Cast here to allow for other models that may not fit the union
+                modelName: this.modelName,
+            });
+        }
+        for (let i = 0; i < subPrompts.length; i += 1) {
+            const data = params.stream
+                ? await (async () => {
+                    const choices = [];
+                    let response;
+                    const stream = await this.completionWithRetry({
+                        ...params,
+                        stream: true,
+                        prompt: subPrompts[i],
+                    }, 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 choice = choices[part.index];
+                                choice.text += part.text;
+                                choice.finish_reason = part.finish_reason;
+                                choice.logprobs = part.logprobs;
+                            }
+                            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
+                ? data.usage
+                : {
+                    completion_tokens: undefined,
+                    prompt_tokens: undefined,
+                    total_tokens: undefined,
+                };
+            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 = chunkArray(choices, this.n).map((promptChoices) => promptChoices.map((choice) => ({
+            text: choice.text ?? "",
+            generationInfo: {
+                finishReason: choice.finish_reason,
+                logprobs: choice.logprobs,
+            },
+        })));
+        return {
+            generations,
+            llmOutput: { tokenUsage },
+        };
+    }
+    // TODO(jacoblee): Refactor with _generate(..., {stream: true}) implementation?
+    async *_streamResponseChunks(input, options, runManager) {
+        const params = {
+            ...this.invocationParams(options),
+            prompt: input,
+            stream: true,
+        };
+        const stream = await this.completionWithRetry(params, options);
+        for await (const data of stream) {
+            const choice = data?.choices[0];
+            if (!choice) {
+                continue;
+            }
+            const chunk = new GenerationChunk({
+                text: choice.text,
+                generationInfo: {
+                    finishReason: choice.finish_reason,
+                },
+            });
+            yield chunk;
+            // eslint-disable-next-line no-void
+            void runManager?.handleLLMNewToken(chunk.text ?? "");
+        }
+        if (options.signal?.aborted) {
+            throw new Error("AbortError");
+        }
+    }
+    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 = wrapOpenAIClientError(e);
+                throw error;
+            }
+        });
+    }
+    /**
+     * 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,
+                baseURL: this.clientConfig.baseURL,
+            };
+            const endpoint = getEndpoint(openAIEndpointConfig);
+            const params = {
+                ...this.clientConfig,
+                baseURL: endpoint,
+                timeout: this.timeout,
+                maxRetries: 0,
+            };
+            if (!params.baseURL) {
+                delete params.baseURL;
+            }
+            this.client = new OpenAIClient(params);
+        }
+        const requestOptions = {
+            ...this.clientConfig,
+            ...options,
+        };
+        if (this.azureOpenAIApiKey) {
+            requestOptions.headers = {
+                "api-key": this.azureOpenAIApiKey,
+                ...requestOptions.headers,
+            };
+            requestOptions.query = {
+                "api-version": this.azureOpenAIApiVersion,
+                ...requestOptions.query,
+            };
+        }
+        return requestOptions;
+    }
+    _llmType() {
+        return "openai";
+    }
+}

package/dist/types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types.d.ts

@@ -0,0 +1,135 @@
+import type { OpenAI as OpenAIClient } from "openai";
+import { TiktokenModel } from "js-tiktoken/lite";
+import type { BaseLanguageModelCallOptions } from "@langchain/core/language_models/base";
+export type { TiktokenModel };
+export declare interface OpenAIBaseInput {
+    /** Sampling temperature to use */
+    temperature: number;
+    /**
+     * Maximum number of tokens to generate in the completion. -1 returns as many
+     * tokens as possible given the prompt and the model's maximum context size.
+     */
+    maxTokens?: number;
+    /** Total probability mass of tokens to consider at each step */
+    topP: number;
+    /** Penalizes repeated tokens according to frequency */
+    frequencyPenalty: number;
+    /** Penalizes repeated tokens */
+    presencePenalty: number;
+    /** Number of completions to generate for each prompt */
+    n: number;
+    /** Dictionary used to adjust the probability of specific tokens being generated */
+    logitBias?: Record<string, number>;
+    /** Unique string identifier representing your end-user, which can help OpenAI to monitor and detect abuse. */
+    user?: string;
+    /** Whether to stream the results or not. Enabling disables tokenUsage reporting */
+    streaming: boolean;
+    /** Model name to use */
+    modelName: string;
+    /** Holds any additional parameters that are valid to pass to {@link
+     * https://platform.openai.com/docs/api-reference/completions/create |
+     * `openai.createCompletion`} that are not explicitly specified on this class.
+     */
+    modelKwargs?: Record<string, any>;
+    /** List of stop words to use when generating */
+    stop?: string[];
+    /**
+     * Timeout to use when making requests to OpenAI.
+     */
+    timeout?: number;
+    /**
+     * API key to use when making requests to OpenAI. Defaults to the value of
+     * `OPENAI_API_KEY` environment variable.
+     */
+    openAIApiKey?: string;
+}
+export type OpenAICoreRequestOptions<Req extends object = Record<string, unknown>> = {
+    path?: string;
+    query?: Req | undefined;
+    body?: Req | undefined;
+    headers?: Record<string, string | null | undefined> | undefined;
+    maxRetries?: number;
+    stream?: boolean | undefined;
+    timeout?: number;
+    httpAgent?: any;
+    signal?: AbortSignal | undefined | null;
+    idempotencyKey?: string;
+};
+export interface OpenAICallOptions extends BaseLanguageModelCallOptions {
+    /**
+     * Additional options to pass to the underlying axios request.
+     */
+    options?: OpenAICoreRequestOptions;
+}
+/**
+ * Input to OpenAI class.
+ */
+export declare interface OpenAIInput extends OpenAIBaseInput {
+    /** Generates `bestOf` completions server side and returns the "best" */
+    bestOf?: number;
+    /** Batch size to use when passing multiple documents to generate */
+    batchSize: number;
+}
+/**
+ * @deprecated Use "baseURL", "defaultHeaders", and "defaultParams" instead.
+ */
+export interface LegacyOpenAIInput {
+    /** @deprecated Use baseURL instead */
+    basePath?: string;
+    /** @deprecated Use defaultHeaders and defaultQuery instead */
+    baseOptions?: {
+        headers?: Record<string, string>;
+        params?: Record<string, string>;
+    };
+}
+export interface OpenAIChatInput extends OpenAIBaseInput {
+    /** ChatGPT messages to pass as a prefix to the prompt */
+    prefixMessages?: OpenAIClient.Chat.CreateChatCompletionRequestMessage[];
+}
+export declare interface AzureOpenAIInput {
+    /**
+     * API version to use when making requests to Azure OpenAI.
+     */
+    azureOpenAIApiVersion?: string;
+    /**
+     * API key to use when making requests to Azure OpenAI.
+     */
+    azureOpenAIApiKey?: string;
+    /**
+     * Azure OpenAI API instance name to use when making requests to Azure OpenAI.
+     * this is the name of the instance you created in the Azure portal.
+     * e.g. "my-openai-instance"
+     * this will be used in the endpoint URL: https://my-openai-instance.openai.azure.com/openai/deployments/{DeploymentName}/
+     */
+    azureOpenAIApiInstanceName?: string;
+    /**
+     * Azure OpenAI API deployment name to use for completions when making requests to Azure OpenAI.
+     * This is the name of the deployment you created in the Azure portal.
+     * e.g. "my-openai-deployment"
+     * this will be used in the endpoint URL: https://{InstanceName}.openai.azure.com/openai/deployments/my-openai-deployment/
+     */
+    azureOpenAIApiDeploymentName?: string;
+    /**
+     * Azure OpenAI API deployment name to use for embedding when making requests to Azure OpenAI.
+     * This is the name of the deployment you created in the Azure portal.
+     * This will fallback to azureOpenAIApiDeploymentName if not provided.
+     * e.g. "my-openai-deployment"
+     * this will be used in the endpoint URL: https://{InstanceName}.openai.azure.com/openai/deployments/my-openai-deployment/
+     */
+    azureOpenAIApiEmbeddingsDeploymentName?: string;
+    /**
+     * Azure OpenAI API deployment name to use for completions when making requests to Azure OpenAI.
+     * Completions are only available for gpt-3.5-turbo and text-davinci-003 deployments.
+     * This is the name of the deployment you created in the Azure portal.
+     * This will fallback to azureOpenAIApiDeploymentName if not provided.
+     * e.g. "my-openai-deployment"
+     * this will be used in the endpoint URL: https://{InstanceName}.openai.azure.com/openai/deployments/my-openai-deployment/
+     */
+    azureOpenAIApiCompletionsDeploymentName?: string;
+    /**
+     * Custom endpoint for Azure OpenAI API. This is useful in case you have a deployment in another region.
+     * e.g. setting this value to "https://westeurope.api.cognitive.microsoft.com/openai/deployments"
+     * will be result in the endpoint URL: https://westeurope.api.cognitive.microsoft.com/openai/deployments/{DeploymentName}/
+     */
+    azureOpenAIBasePath?: string;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};