langchain 0.0.197-rc.1 → 0.0.198

package/dist/tools/convert_to_openai.js

@@ -1 +1,35 @@
-export { formatToOpenAIFunction, formatToOpenAITool, formatToOpenAIAssistantTool, } from "@langchain/openai";
+import { zodToJsonSchema } from "zod-to-json-schema";
+/**
+ * Formats a `StructuredTool` instance into a format that is compatible
+ * with OpenAI's ChatCompletionFunctions. It uses the `zodToJsonSchema`
+ * function to convert the schema of the `StructuredTool` into a JSON
+ * schema, which is then used as the parameters for the OpenAI function.
+ */
+export function formatToOpenAIFunction(tool) {
+    return {
+        name: tool.name,
+        description: tool.description,
+        parameters: zodToJsonSchema(tool.schema),
+    };
+}
+export function formatToOpenAITool(tool) {
+    const schema = zodToJsonSchema(tool.schema);
+    return {
+        type: "function",
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: schema,
+        },
+    };
+}
+export function formatToOpenAIAssistantTool(tool) {
+    return {
+        type: "function",
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: zodToJsonSchema(tool.schema),
+        },
+    };
+}

package/dist/types/openai-types.d.ts

@@ -1,3 +1,135 @@
+import type { OpenAI as OpenAIClient } from "openai";
 import { TiktokenModel } from "js-tiktoken/lite";
+import { BaseLanguageModelCallOptions } from "../base_language/index.js";
 export type { TiktokenModel };
-export type { OpenAIBaseInput, OpenAICoreRequestOptions, OpenAICallOptions, OpenAIInput, LegacyOpenAIInput, OpenAIChatInput, AzureOpenAIInput, } from "@langchain/openai";
+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/util/env.cjs

@@ -1,73 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEnvironmentVariable = exports.getRuntimeEnvironment = exports.getEnv = exports.isNode = exports.isDeno = exports.isJsDom = exports.isWebWorker = exports.isBrowser = void 0;
-const isBrowser = () => typeof window !== "undefined" && typeof window.document !== "undefined";
-exports.isBrowser = isBrowser;
-const isWebWorker = () => typeof globalThis === "object" &&
-    globalThis.constructor &&
-    globalThis.constructor.name === "DedicatedWorkerGlobalScope";
-exports.isWebWorker = isWebWorker;
-const isJsDom = () => (typeof window !== "undefined" && window.name === "nodejs") ||
-    (typeof navigator !== "undefined" &&
-        (navigator.userAgent.includes("Node.js") ||
-            navigator.userAgent.includes("jsdom")));
-exports.isJsDom = isJsDom;
-// Supabase Edge Function provides a `Deno` global object
-// without `version` property
-const isDeno = () => typeof Deno !== "undefined";
-exports.isDeno = isDeno;
-// Mark not-as-node if in Supabase Edge Function
-const isNode = () => typeof process !== "undefined" &&
-    typeof process.versions !== "undefined" &&
-    typeof process.versions.node !== "undefined" &&
-    !(0, exports.isDeno)();
-exports.isNode = isNode;
-const getEnv = () => {
-    let env;
-    if ((0, exports.isBrowser)()) {
-        env = "browser";
-    }
-    else if ((0, exports.isNode)()) {
-        env = "node";
-    }
-    else if ((0, exports.isWebWorker)()) {
-        env = "webworker";
-    }
-    else if ((0, exports.isJsDom)()) {
-        env = "jsdom";
-    }
-    else if ((0, exports.isDeno)()) {
-        env = "deno";
-    }
-    else {
-        env = "other";
-    }
-    return env;
-};
-exports.getEnv = getEnv;
-let runtimeEnvironment;
-async function getRuntimeEnvironment() {
-    if (runtimeEnvironment === undefined) {
-        const env = (0, exports.getEnv)();
-        runtimeEnvironment = {
-            library: "langchain-js",
-            runtime: env,
-        };
-    }
-    return runtimeEnvironment;
-}
-exports.getRuntimeEnvironment = getRuntimeEnvironment;
-function getEnvironmentVariable(name) {
-    // Certain Deno setups will throw an error if you try to access environment variables
-    // https://github.com/langchain-ai/langchainjs/issues/1412
-    try {
-        return typeof process !== "undefined"
-            ? // eslint-disable-next-line no-process-env
-                process.env?.[name]
-            : undefined;
-    }
-    catch (e) {
-        return undefined;
-    }
-}
-exports.getEnvironmentVariable = getEnvironmentVariable;
+var env_1 = require("@langchain/core/utils/env");
+Object.defineProperty(exports, "isBrowser", { enumerable: true, get: function () { return env_1.isBrowser; } });
+Object.defineProperty(exports, "isWebWorker", { enumerable: true, get: function () { return env_1.isWebWorker; } });
+Object.defineProperty(exports, "isJsDom", { enumerable: true, get: function () { return env_1.isJsDom; } });
+Object.defineProperty(exports, "isDeno", { enumerable: true, get: function () { return env_1.isDeno; } });
+Object.defineProperty(exports, "isNode", { enumerable: true, get: function () { return env_1.isNode; } });
+Object.defineProperty(exports, "getEnv", { enumerable: true, get: function () { return env_1.getEnv; } });
+Object.defineProperty(exports, "getRuntimeEnvironment", { enumerable: true, get: function () { return env_1.getRuntimeEnvironment; } });
+Object.defineProperty(exports, "getEnvironmentVariable", { enumerable: true, get: function () { return env_1.getEnvironmentVariable; } });

package/dist/util/env.d.ts

@@ -1,21 +1 @@
-declare global {
-    const Deno: {
-        version: {
-            deno: string;
-        };
-    } | undefined;
-}
-export declare const isBrowser: () => boolean;
-export declare const isWebWorker: () => boolean;
-export declare const isJsDom: () => boolean;
-export declare const isDeno: () => boolean;
-export declare const isNode: () => boolean;
-export declare const getEnv: () => string;
-export type RuntimeEnvironment = {
-    library: string;
-    libraryVersion?: string;
-    runtime: string;
-    runtimeVersion?: string;
-};
-export declare function getRuntimeEnvironment(): Promise<RuntimeEnvironment>;
-export declare function getEnvironmentVariable(name: string): string | undefined;
+export { isBrowser, isWebWorker, isJsDom, isDeno, isNode, getEnv, type RuntimeEnvironment, getRuntimeEnvironment, getEnvironmentVariable, } from "@langchain/core/utils/env";

package/dist/util/env.js

@@ -1,62 +1 @@
-export const isBrowser = () => typeof window !== "undefined" && typeof window.document !== "undefined";
-export const isWebWorker = () => typeof globalThis === "object" &&
-    globalThis.constructor &&
-    globalThis.constructor.name === "DedicatedWorkerGlobalScope";
-export const isJsDom = () => (typeof window !== "undefined" && window.name === "nodejs") ||
-    (typeof navigator !== "undefined" &&
-        (navigator.userAgent.includes("Node.js") ||
-            navigator.userAgent.includes("jsdom")));
-// Supabase Edge Function provides a `Deno` global object
-// without `version` property
-export const isDeno = () => typeof Deno !== "undefined";
-// Mark not-as-node if in Supabase Edge Function
-export const isNode = () => typeof process !== "undefined" &&
-    typeof process.versions !== "undefined" &&
-    typeof process.versions.node !== "undefined" &&
-    !isDeno();
-export const getEnv = () => {
-    let env;
-    if (isBrowser()) {
-        env = "browser";
-    }
-    else if (isNode()) {
-        env = "node";
-    }
-    else if (isWebWorker()) {
-        env = "webworker";
-    }
-    else if (isJsDom()) {
-        env = "jsdom";
-    }
-    else if (isDeno()) {
-        env = "deno";
-    }
-    else {
-        env = "other";
-    }
-    return env;
-};
-let runtimeEnvironment;
-export async function getRuntimeEnvironment() {
-    if (runtimeEnvironment === undefined) {
-        const env = getEnv();
-        runtimeEnvironment = {
-            library: "langchain-js",
-            runtime: env,
-        };
-    }
-    return runtimeEnvironment;
-}
-export function getEnvironmentVariable(name) {
-    // Certain Deno setups will throw an error if you try to access environment variables
-    // https://github.com/langchain-ai/langchainjs/issues/1412
-    try {
-        return typeof process !== "undefined"
-            ? // eslint-disable-next-line no-process-env
-                process.env?.[name]
-            : undefined;
-    }
-    catch (e) {
-        return undefined;
-    }
-}
+export { isBrowser, isWebWorker, isJsDom, isDeno, isNode, getEnv, getRuntimeEnvironment, getEnvironmentVariable, } from "@langchain/core/utils/env";

package/dist/util/openai-format-fndef.cjs

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatFunctionDefinitions = void 0;
+function isAnyOfProp(prop) {
+    return (prop.anyOf !== undefined &&
+        Array.isArray(prop.anyOf));
+}
+// When OpenAI use functions in the prompt, they format them as TypeScript definitions rather than OpenAPI JSON schemas.
+// This function converts the JSON schemas into TypeScript definitions.
+function formatFunctionDefinitions(functions) {
+    const lines = ["namespace functions {", ""];
+    for (const f of functions) {
+        if (f.description) {
+            lines.push(`// ${f.description}`);
+        }
+        if (Object.keys(f.parameters.properties ?? {}).length > 0) {
+            lines.push(`type ${f.name} = (_: {`);
+            lines.push(formatObjectProperties(f.parameters, 0));
+            lines.push("}) => any;");
+        }
+        else {
+            lines.push(`type ${f.name} = () => any;`);
+        }
+        lines.push("");
+    }
+    lines.push("} // namespace functions");
+    return lines.join("\n");
+}
+exports.formatFunctionDefinitions = formatFunctionDefinitions;
+// Format just the properties of an object (not including the surrounding braces)
+function formatObjectProperties(obj, indent) {
+    const lines = [];
+    for (const [name, param] of Object.entries(obj.properties ?? {})) {
+        if (param.description && indent < 2) {
+            lines.push(`// ${param.description}`);
+        }
+        if (obj.required?.includes(name)) {
+            lines.push(`${name}: ${formatType(param, indent)},`);
+        }
+        else {
+            lines.push(`${name}?: ${formatType(param, indent)},`);
+        }
+    }
+    return lines.map((line) => " ".repeat(indent) + line).join("\n");
+}
+// Format a single property type
+function formatType(param, indent) {
+    if (isAnyOfProp(param)) {
+        return param.anyOf.map((v) => formatType(v, indent)).join(" | ");
+    }
+    switch (param.type) {
+        case "string":
+            if (param.enum) {
+                return param.enum.map((v) => `"${v}"`).join(" | ");
+            }
+            return "string";
+        case "number":
+            if (param.enum) {
+                return param.enum.map((v) => `${v}`).join(" | ");
+            }
+            return "number";
+        case "integer":
+            if (param.enum) {
+                return param.enum.map((v) => `${v}`).join(" | ");
+            }
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "null":
+            return "null";
+        case "object":
+            return ["{", formatObjectProperties(param, indent + 2), "}"].join("\n");
+        case "array":
+            if (param.items) {
+                return `${formatType(param.items, indent)}[]`;
+            }
+            return "any[]";
+        default:
+            return "";
+    }
+}

package/dist/util/openai-format-fndef.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Formatting function definitions for calculating openai function defination token usage.
+ *
+ * https://github.com/hmarr/openai-chat-tokens/blob/main/src/functions.ts
+ * (c) 2023 Harry Marr
+ * MIT license
+ */
+import OpenAI from "openai";
+type OpenAIFunction = OpenAI.Chat.ChatCompletionCreateParams.Function;
+export interface FunctionDef extends Omit<OpenAIFunction, "parameters"> {
+    name: string;
+    description?: string;
+    parameters: ObjectProp;
+}
+interface ObjectProp {
+    type: "object";
+    properties?: {
+        [key: string]: Prop;
+    };
+    required?: string[];
+}
+interface AnyOfProp {
+    anyOf: Prop[];
+}
+type Prop = {
+    description?: string;
+} & (AnyOfProp | ObjectProp | {
+    type: "string";
+    enum?: string[];
+} | {
+    type: "number" | "integer";
+    minimum?: number;
+    maximum?: number;
+    enum?: number[];
+} | {
+    type: "boolean";
+} | {
+    type: "null";
+} | {
+    type: "array";
+    items?: Prop;
+});
+export declare function formatFunctionDefinitions(functions: FunctionDef[]): string;
+export {};

package/dist/util/openai-format-fndef.js

@@ -0,0 +1,77 @@
+function isAnyOfProp(prop) {
+    return (prop.anyOf !== undefined &&
+        Array.isArray(prop.anyOf));
+}
+// When OpenAI use functions in the prompt, they format them as TypeScript definitions rather than OpenAPI JSON schemas.
+// This function converts the JSON schemas into TypeScript definitions.
+export function formatFunctionDefinitions(functions) {
+    const lines = ["namespace functions {", ""];
+    for (const f of functions) {
+        if (f.description) {
+            lines.push(`// ${f.description}`);
+        }
+        if (Object.keys(f.parameters.properties ?? {}).length > 0) {
+            lines.push(`type ${f.name} = (_: {`);
+            lines.push(formatObjectProperties(f.parameters, 0));
+            lines.push("}) => any;");
+        }
+        else {
+            lines.push(`type ${f.name} = () => any;`);
+        }
+        lines.push("");
+    }
+    lines.push("} // namespace functions");
+    return lines.join("\n");
+}
+// Format just the properties of an object (not including the surrounding braces)
+function formatObjectProperties(obj, indent) {
+    const lines = [];
+    for (const [name, param] of Object.entries(obj.properties ?? {})) {
+        if (param.description && indent < 2) {
+            lines.push(`// ${param.description}`);
+        }
+        if (obj.required?.includes(name)) {
+            lines.push(`${name}: ${formatType(param, indent)},`);
+        }
+        else {
+            lines.push(`${name}?: ${formatType(param, indent)},`);
+        }
+    }
+    return lines.map((line) => " ".repeat(indent) + line).join("\n");
+}
+// Format a single property type
+function formatType(param, indent) {
+    if (isAnyOfProp(param)) {
+        return param.anyOf.map((v) => formatType(v, indent)).join(" | ");
+    }
+    switch (param.type) {
+        case "string":
+            if (param.enum) {
+                return param.enum.map((v) => `"${v}"`).join(" | ");
+            }
+            return "string";
+        case "number":
+            if (param.enum) {
+                return param.enum.map((v) => `${v}`).join(" | ");
+            }
+            return "number";
+        case "integer":
+            if (param.enum) {
+                return param.enum.map((v) => `${v}`).join(" | ");
+            }
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "null":
+            return "null";
+        case "object":
+            return ["{", formatObjectProperties(param, indent + 2), "}"].join("\n");
+        case "array":
+            if (param.items) {
+                return `${formatType(param.items, indent)}[]`;
+            }
+            return "any[]";
+        default:
+            return "";
+    }
+}

package/dist/util/openai.cjs

@@ -1,5 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.wrapOpenAIClientError = void 0;
-var openai_1 = require("@langchain/openai");
-Object.defineProperty(exports, "wrapOpenAIClientError", { enumerable: true, get: function () { return openai_1.wrapOpenAIClientError; } });
+const openai_1 = require("openai");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function wrapOpenAIClientError(e) {
+    let error;
+    if (e.constructor.name === openai_1.APIConnectionTimeoutError.name) {
+        error = new Error(e.message);
+        error.name = "TimeoutError";
+    }
+    else if (e.constructor.name === openai_1.APIUserAbortError.name) {
+        error = new Error(e.message);
+        error.name = "AbortError";
+    }
+    else {
+        error = e;
+    }
+    return error;
+}
+exports.wrapOpenAIClientError = wrapOpenAIClientError;

package/dist/util/openai.d.ts

@@ -1 +1 @@
-export { wrapOpenAIClientError } from "@langchain/openai";
+export declare function wrapOpenAIClientError(e: any): any;

package/dist/util/openai.js

@@ -1 +1,17 @@
-export { wrapOpenAIClientError } from "@langchain/openai";
+import { APIConnectionTimeoutError, APIUserAbortError } from "openai";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function wrapOpenAIClientError(e) {
+    let error;
+    if (e.constructor.name === APIConnectionTimeoutError.name) {
+        error = new Error(e.message);
+        error.name = "TimeoutError";
+    }
+    else if (e.constructor.name === APIUserAbortError.name) {
+        error = new Error(e.message);
+        error.name = "AbortError";
+    }
+    else {
+        error = e;
+    }
+    return error;
+}

package/dist/util/openapi.d.ts

@@ -7,7 +7,7 @@ export declare class OpenAPISpec {
     getParametersStrict(): Record<string, OpenAPIV3.ParameterObject | OpenAPIV3_1.ReferenceObject>;
     getSchemasStrict(): Record<string, OpenAPIV3_1.SchemaObject>;
     getRequestBodiesStrict(): Record<string, OpenAPIV3_1.ReferenceObject | OpenAPIV3_1.RequestBodyObject>;
-    getPathStrict(path: string): Omit<OpenAPIV3.PathItemObject<{}>, "servers" | "parameters"> & {
+    getPathStrict(path: string): Omit<OpenAPIV3.PathItemObject<{}>, "parameters" | "servers"> & {
         servers?: OpenAPIV3_1.ServerObject[] | undefined;
         parameters?: (OpenAPIV3.ParameterObject | OpenAPIV3_1.ReferenceObject)[] | undefined;
     } & {
@@ -59,7 +59,7 @@ export declare class OpenAPISpec {
         deprecated?: boolean | undefined;
         security?: OpenAPIV3.SecurityRequirementObject[] | undefined;
         servers?: OpenAPIV3.ServerObject[] | undefined;
-    }, "callbacks" | "servers" | "parameters" | "responses" | "requestBody"> & {
+    }, "callbacks" | "parameters" | "servers" | "responses" | "requestBody"> & {
         parameters?: (OpenAPIV3.ParameterObject | OpenAPIV3_1.ReferenceObject)[] | undefined;
         requestBody?: OpenAPIV3_1.ReferenceObject | OpenAPIV3_1.RequestBodyObject | undefined;
         responses?: OpenAPIV3_1.ResponsesObject | undefined;

package/dist/util/prompt-layer.d.ts

@@ -1,3 +1,3 @@
-import type { OpenAIClient } from "@langchain/openai";
+import type { OpenAI as OpenAIClient } from "openai";
 import { AsyncCaller } from "../util/async_caller.js";
 export declare const promptLayerTrackRequest: (callerFunc: AsyncCaller, functionName: string, kwargs: OpenAIClient.CompletionCreateParams | OpenAIClient.Chat.CompletionCreateParams, plTags: string[] | undefined, requestResponse: any, startTime: number, endTime: number, apiKey: string | undefined) => Promise<any>;