@nocobase/plugin-ai 1.6.0-beta.17

package/dist/node_modules/@langchain/openai/dist/tools/dalle.d.ts

@@ -0,0 +1,111 @@
+import { OpenAI as OpenAIClient } from "openai";
+import { Tool, ToolParams } from "@langchain/core/tools";
+import { MessageContentComplex } from "@langchain/core/messages";
+/**
+ * An interface for the Dall-E API Wrapper.
+ */
+export interface DallEAPIWrapperParams extends ToolParams {
+    /**
+     * The OpenAI API key
+     * Alias for `apiKey`
+     */
+    openAIApiKey?: string;
+    /**
+     * The OpenAI API key
+     */
+    apiKey?: string;
+    /**
+     * The model to use.
+     * Alias for `model`
+     * @params "dall-e-2" | "dall-e-3"
+     * @default "dall-e-3"
+     */
+    modelName?: string;
+    /**
+     * The model to use.
+     * @params "dall-e-2" | "dall-e-3"
+     * @default "dall-e-3"
+     */
+    model?: string;
+    /**
+     * The style of the generated images. Must be one of vivid or natural.
+     * Vivid causes the model to lean towards generating hyper-real and dramatic images.
+     * Natural causes the model to produce more natural, less hyper-real looking images.
+     * @default "vivid"
+     */
+    style?: "natural" | "vivid";
+    /**
+     * The quality of the image that will be generated. ‘hd’ creates images with finer
+     * details and greater consistency across the image.
+     * @default "standard"
+     */
+    quality?: "standard" | "hd";
+    /**
+     * The number of images to generate.
+     * Must be between 1 and 10.
+     * For dall-e-3, only `n: 1` is supported.
+     * @default 1
+     */
+    n?: number;
+    /**
+     * The size of the generated images.
+     * Must be one of 256x256, 512x512, or 1024x1024 for DALL·E-2 models.
+     * Must be one of 1024x1024, 1792x1024, or 1024x1792 for DALL·E-3 models.
+     * @default "1024x1024"
+     */
+    size?: "256x256" | "512x512" | "1024x1024" | "1792x1024" | "1024x1792";
+    /**
+     * The format in which the generated images are returned.
+     * Must be one of "url" or "b64_json".
+     * @default "url"
+     */
+    dallEResponseFormat?: "url" | "b64_json";
+    /**
+     * @deprecated Use dallEResponseFormat instead for the Dall-E response type.
+     */
+    responseFormat?: any;
+    /**
+     * A unique identifier representing your end-user, which will help
+     * OpenAI to monitor and detect abuse.
+     */
+    user?: string;
+    /**
+     * The organization to use
+     */
+    organization?: string;
+    /**
+     * The base URL of the OpenAI API.
+     */
+    baseUrl?: string;
+}
+/**
+ * A tool for generating images with Open AIs Dall-E 2 or 3 API.
+ */
+export declare class DallEAPIWrapper extends Tool {
+    static lc_name(): string;
+    name: string;
+    description: string;
+    protected client: OpenAIClient;
+    static readonly toolName = "dalle_api_wrapper";
+    private model;
+    private style;
+    private quality;
+    private n;
+    private size;
+    private dallEResponseFormat;
+    private user?;
+    constructor(fields?: DallEAPIWrapperParams);
+    /**
+     * Processes the API response if multiple images are generated.
+     * Returns a list of MessageContentImageUrl objects. If the response
+     * format is `url`, then the `image_url` field will contain the URL.
+     * If it is `b64_json`, then the `image_url` field will contain an object
+     * with a `url` field with the base64 encoded image.
+     *
+     * @param {OpenAIClient.Images.ImagesResponse[]} response The API response
+     * @returns {MessageContentImageUrl[]}
+     */
+    private processMultipleGeneratedUrls;
+    /** @ignore */
+    _call(input: string): Promise<string | MessageContentComplex[]>;
+}

package/dist/node_modules/@langchain/openai/dist/tools/dalle.js

@@ -0,0 +1,189 @@
+/* eslint-disable no-param-reassign */
+import { getEnvironmentVariable } from "@langchain/core/utils/env";
+import { OpenAI as OpenAIClient } from "openai";
+import { Tool } from "@langchain/core/tools";
+/**
+ * A tool for generating images with Open AIs Dall-E 2 or 3 API.
+ */
+export class DallEAPIWrapper extends Tool {
+    static lc_name() {
+        return "DallEAPIWrapper";
+    }
+    constructor(fields) {
+        // Shim for new base tool param name
+        if (fields?.responseFormat !== undefined &&
+            ["url", "b64_json"].includes(fields.responseFormat)) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            fields.dallEResponseFormat = fields.responseFormat;
+            fields.responseFormat = "content";
+        }
+        super(fields);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "dalle_api_wrapper"
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "A wrapper around OpenAI DALL-E API. Useful for when you need to generate images from a text description. Input should be an image description."
+        });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "dall-e-3"
+        });
+        Object.defineProperty(this, "style", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "vivid"
+        });
+        Object.defineProperty(this, "quality", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "standard"
+        });
+        Object.defineProperty(this, "n", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1
+        });
+        Object.defineProperty(this, "size", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "1024x1024"
+        });
+        Object.defineProperty(this, "dallEResponseFormat", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "url"
+        });
+        Object.defineProperty(this, "user", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const openAIApiKey = fields?.apiKey ??
+            fields?.openAIApiKey ??
+            getEnvironmentVariable("OPENAI_API_KEY");
+        const organization = fields?.organization ?? getEnvironmentVariable("OPENAI_ORGANIZATION");
+        const clientConfig = {
+            apiKey: openAIApiKey,
+            organization,
+            dangerouslyAllowBrowser: true,
+            baseUrl: fields?.baseUrl,
+        };
+        this.client = new OpenAIClient(clientConfig);
+        this.model = fields?.model ?? fields?.modelName ?? this.model;
+        this.style = fields?.style ?? this.style;
+        this.quality = fields?.quality ?? this.quality;
+        this.n = fields?.n ?? this.n;
+        this.size = fields?.size ?? this.size;
+        this.dallEResponseFormat =
+            fields?.dallEResponseFormat ?? this.dallEResponseFormat;
+        this.user = fields?.user;
+    }
+    /**
+     * Processes the API response if multiple images are generated.
+     * Returns a list of MessageContentImageUrl objects. If the response
+     * format is `url`, then the `image_url` field will contain the URL.
+     * If it is `b64_json`, then the `image_url` field will contain an object
+     * with a `url` field with the base64 encoded image.
+     *
+     * @param {OpenAIClient.Images.ImagesResponse[]} response The API response
+     * @returns {MessageContentImageUrl[]}
+     */
+    processMultipleGeneratedUrls(response) {
+        if (this.dallEResponseFormat === "url") {
+            return response.flatMap((res) => {
+                const imageUrlContent = res.data
+                    .flatMap((item) => {
+                    if (!item.url)
+                        return [];
+                    return {
+                        type: "image_url",
+                        image_url: item.url,
+                    };
+                })
+                    .filter((item) => item !== undefined &&
+                    item.type === "image_url" &&
+                    typeof item.image_url === "string" &&
+                    item.image_url !== undefined);
+                return imageUrlContent;
+            });
+        }
+        else {
+            return response.flatMap((res) => {
+                const b64Content = res.data
+                    .flatMap((item) => {
+                    if (!item.b64_json)
+                        return [];
+                    return {
+                        type: "image_url",
+                        image_url: {
+                            url: item.b64_json,
+                        },
+                    };
+                })
+                    .filter((item) => item !== undefined &&
+                    item.type === "image_url" &&
+                    typeof item.image_url === "object" &&
+                    "url" in item.image_url &&
+                    typeof item.image_url.url === "string" &&
+                    item.image_url.url !== undefined);
+                return b64Content;
+            });
+        }
+    }
+    /** @ignore */
+    async _call(input) {
+        const generateImageFields = {
+            model: this.model,
+            prompt: input,
+            n: 1,
+            size: this.size,
+            response_format: this.dallEResponseFormat,
+            style: this.style,
+            quality: this.quality,
+            user: this.user,
+        };
+        if (this.n > 1) {
+            const results = await Promise.all(Array.from({ length: this.n }).map(() => this.client.images.generate(generateImageFields)));
+            return this.processMultipleGeneratedUrls(results);
+        }
+        const response = await this.client.images.generate(generateImageFields);
+        let data = "";
+        if (this.dallEResponseFormat === "url") {
+            [data] = response.data
+                .map((item) => item.url)
+                .filter((url) => url !== "undefined");
+        }
+        else {
+            [data] = response.data
+                .map((item) => item.b64_json)
+                .filter((b64_json) => b64_json !== "undefined");
+        }
+        return data;
+    }
+}
+Object.defineProperty(DallEAPIWrapper, "toolName", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: "dalle_api_wrapper"
+});

package/dist/node_modules/@langchain/openai/dist/tools/index.cjs

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./dalle.cjs"), exports);

package/dist/node_modules/@langchain/openai/dist/tools/index.d.ts

@@ -0,0 +1 @@
+export * from "./dalle.js";

package/dist/node_modules/@langchain/openai/dist/tools/index.js

@@ -0,0 +1 @@
+export * from "./dalle.js";

package/dist/node_modules/@langchain/openai/dist/types.cjs

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

package/dist/node_modules/@langchain/openai/dist/types.d.ts

@@ -0,0 +1,218 @@
+import type { OpenAI as OpenAIClient } from "openai";
+import type { ResponseFormatText, ResponseFormatJSONObject, ResponseFormatJSONSchema } from "openai/resources/shared";
+import { TiktokenModel } from "js-tiktoken/lite";
+import type { BaseLanguageModelCallOptions } from "@langchain/core/language_models/base";
+import type { z } from "zod";
+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;
+    /**
+     * 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.
+     * Alias for `maxTokens` for reasoning models.
+     */
+    maxCompletionTokens?: 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;
+    /**
+     * Whether or not to include token usage data in streamed chunks.
+     * @default true
+     */
+    streamUsage?: boolean;
+    /**
+     * Model name to use
+     * Alias for `model`
+     * @deprecated Use "model" instead.
+     */
+    modelName: string;
+    /** Model name to use */
+    model: 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
+     * Alias for `stopSequences`
+     */
+    stop?: string[];
+    /** List of stop words to use when generating */
+    stopSequences?: 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.
+     * Alias for `apiKey`
+     */
+    openAIApiKey?: string;
+    /**
+     * API key to use when making requests to OpenAI. Defaults to the value of
+     * `OPENAI_API_KEY` environment variable.
+     */
+    apiKey?: 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;
+}
+export interface OpenAIChatInput extends OpenAIBaseInput {
+    /**
+     * Whether to return log probabilities of the output tokens or not.
+     * If true, returns the log probabilities of each output token returned in the content of message.
+     */
+    logprobs?: boolean;
+    /**
+     * An integer between 0 and 5 specifying the number of most likely tokens to return at each token position,
+     * each with an associated log probability. logprobs must be set to true if this parameter is used.
+     */
+    topLogprobs?: number;
+    /** ChatGPT messages to pass as a prefix to the prompt */
+    prefixMessages?: OpenAIClient.Chat.ChatCompletionMessageParam[];
+    /**
+     * Whether to include the raw OpenAI response in the output message's "additional_kwargs" field.
+     * Currently in experimental beta.
+     */
+    __includeRawResponse?: boolean;
+    /**
+     * Whether the model supports the `strict` argument when passing in tools.
+     * If `undefined` the `strict` argument will not be passed to OpenAI.
+     */
+    supportsStrictToolCalling?: boolean;
+    /**
+     * Output types that you would like the model to generate for this request. Most
+     * models are capable of generating text, which is the default:
+     *
+     * `["text"]`
+     *
+     * The `gpt-4o-audio-preview` model can also be used to
+     * [generate audio](https://platform.openai.com/docs/guides/audio). To request that
+     * this model generate both text and audio responses, you can use:
+     *
+     * `["text", "audio"]`
+     */
+    modalities?: Array<OpenAIClient.Chat.ChatCompletionModality>;
+    /**
+     * Parameters for audio output. Required when audio output is requested with
+     * `modalities: ["audio"]`.
+     * [Learn more](https://platform.openai.com/docs/guides/audio).
+     */
+    audio?: OpenAIClient.Chat.ChatCompletionAudioParam;
+    /**
+     * Constrains effort on reasoning for reasoning models. Currently supported values are low, medium, and high.
+     * Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
+     */
+    reasoningEffort?: OpenAIClient.ChatCompletionReasoningEffort;
+}
+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 base url 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;
+    /**
+     * 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/"
+     * will be result in the endpoint URL: https://westeurope.api.cognitive.microsoft.com/openai/deployments/{DeploymentName}/
+     */
+    azureOpenAIEndpoint?: string;
+    /**
+     * A function that returns an access token for Microsoft Entra (formerly known as Azure Active Directory),
+     * which will be invoked on every request.
+     */
+    azureADTokenProvider?: () => Promise<string>;
+}
+type ChatOpenAIResponseFormatJSONSchema = Omit<ResponseFormatJSONSchema, "json_schema"> & {
+    json_schema: Omit<ResponseFormatJSONSchema["json_schema"], "schema"> & {
+        /**
+         * The schema for the response format, described as a JSON Schema object
+         * or a Zod object.
+         */
+        schema: Record<string, any> | z.ZodObject<any, any, any, any>;
+    };
+};
+export type ChatOpenAIResponseFormat = ResponseFormatText | ResponseFormatJSONObject | ChatOpenAIResponseFormatJSONSchema;

package/dist/node_modules/@langchain/openai/dist/types.js

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

package/dist/node_modules/@langchain/openai/dist/utils/azure.cjs

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEndpoint = void 0;
+/**
+ * This function generates an endpoint URL for (Azure) OpenAI
+ * based on the configuration parameters provided.
+ *
+ * @param {OpenAIEndpointConfig} config - The configuration object for the (Azure) endpoint.
+ *
+ * @property {string} config.azureOpenAIApiDeploymentName - The deployment name of Azure OpenAI.
+ * @property {string} config.azureOpenAIApiInstanceName - The instance name of Azure OpenAI, e.g. `example-resource`.
+ * @property {string} config.azureOpenAIApiKey - The API Key for Azure OpenAI.
+ * @property {string} config.azureOpenAIBasePath - The base path for Azure OpenAI, e.g. `https://example-resource.azure.openai.com/openai/deployments/`.
+ * @property {string} config.baseURL - Some other custom base path URL.
+ * @property {string} config.azureOpenAIEndpoint - The endpoint for the Azure OpenAI instance, e.g. `https://example-resource.azure.openai.com/`.
+ *
+ * The function operates as follows:
+ * - If both `azureOpenAIBasePath` and `azureOpenAIApiDeploymentName` (plus `azureOpenAIApiKey`) are provided, it returns an URL combining these two parameters (`${azureOpenAIBasePath}/${azureOpenAIApiDeploymentName}`).
+ * - If both `azureOpenAIEndpoint` and `azureOpenAIApiDeploymentName` (plus `azureOpenAIApiKey`) are provided, it returns an URL combining these two parameters (`${azureOpenAIEndpoint}/openai/deployments/${azureOpenAIApiDeploymentName}`).
+ * - If `azureOpenAIApiKey` is provided, it checks for `azureOpenAIApiInstanceName` and `azureOpenAIApiDeploymentName` and throws an error if any of these is missing. If both are provided, it generates an URL incorporating these parameters.
+ * - If none of the above conditions are met, return any custom `baseURL`.
+ * - The function returns the generated URL as a string, or undefined if no custom paths are specified.
+ *
+ * @throws Will throw an error if the necessary parameters for generating the URL are missing.
+ *
+ * @returns {string | undefined} The generated (Azure) OpenAI endpoint URL.
+ */
+function getEndpoint(config) {
+    const { azureOpenAIApiDeploymentName, azureOpenAIApiInstanceName, azureOpenAIApiKey, azureOpenAIBasePath, baseURL, azureADTokenProvider, azureOpenAIEndpoint, } = config;
+    if ((azureOpenAIApiKey || azureADTokenProvider) &&
+        azureOpenAIBasePath &&
+        azureOpenAIApiDeploymentName) {
+        return `${azureOpenAIBasePath}/${azureOpenAIApiDeploymentName}`;
+    }
+    if ((azureOpenAIApiKey || azureADTokenProvider) &&
+        azureOpenAIEndpoint &&
+        azureOpenAIApiDeploymentName) {
+        return `${azureOpenAIEndpoint}/openai/deployments/${azureOpenAIApiDeploymentName}`;
+    }
+    if (azureOpenAIApiKey || azureADTokenProvider) {
+        if (!azureOpenAIApiInstanceName) {
+            throw new Error("azureOpenAIApiInstanceName is required when using azureOpenAIApiKey");
+        }
+        if (!azureOpenAIApiDeploymentName) {
+            throw new Error("azureOpenAIApiDeploymentName is a required parameter when using azureOpenAIApiKey");
+        }
+        return `https://${azureOpenAIApiInstanceName}.openai.azure.com/openai/deployments/${azureOpenAIApiDeploymentName}`;
+    }
+    return baseURL;
+}
+exports.getEndpoint = getEndpoint;

package/dist/node_modules/@langchain/openai/dist/utils/azure.d.ts

@@ -0,0 +1,34 @@
+export interface OpenAIEndpointConfig {
+    azureOpenAIApiDeploymentName?: string;
+    azureOpenAIApiInstanceName?: string;
+    azureOpenAIApiKey?: string;
+    azureADTokenProvider?: () => Promise<string>;
+    azureOpenAIBasePath?: string;
+    baseURL?: string | null;
+    azureOpenAIEndpoint?: string;
+}
+/**
+ * This function generates an endpoint URL for (Azure) OpenAI
+ * based on the configuration parameters provided.
+ *
+ * @param {OpenAIEndpointConfig} config - The configuration object for the (Azure) endpoint.
+ *
+ * @property {string} config.azureOpenAIApiDeploymentName - The deployment name of Azure OpenAI.
+ * @property {string} config.azureOpenAIApiInstanceName - The instance name of Azure OpenAI, e.g. `example-resource`.
+ * @property {string} config.azureOpenAIApiKey - The API Key for Azure OpenAI.
+ * @property {string} config.azureOpenAIBasePath - The base path for Azure OpenAI, e.g. `https://example-resource.azure.openai.com/openai/deployments/`.
+ * @property {string} config.baseURL - Some other custom base path URL.
+ * @property {string} config.azureOpenAIEndpoint - The endpoint for the Azure OpenAI instance, e.g. `https://example-resource.azure.openai.com/`.
+ *
+ * The function operates as follows:
+ * - If both `azureOpenAIBasePath` and `azureOpenAIApiDeploymentName` (plus `azureOpenAIApiKey`) are provided, it returns an URL combining these two parameters (`${azureOpenAIBasePath}/${azureOpenAIApiDeploymentName}`).
+ * - If both `azureOpenAIEndpoint` and `azureOpenAIApiDeploymentName` (plus `azureOpenAIApiKey`) are provided, it returns an URL combining these two parameters (`${azureOpenAIEndpoint}/openai/deployments/${azureOpenAIApiDeploymentName}`).
+ * - If `azureOpenAIApiKey` is provided, it checks for `azureOpenAIApiInstanceName` and `azureOpenAIApiDeploymentName` and throws an error if any of these is missing. If both are provided, it generates an URL incorporating these parameters.
+ * - If none of the above conditions are met, return any custom `baseURL`.
+ * - The function returns the generated URL as a string, or undefined if no custom paths are specified.
+ *
+ * @throws Will throw an error if the necessary parameters for generating the URL are missing.
+ *
+ * @returns {string | undefined} The generated (Azure) OpenAI endpoint URL.
+ */
+export declare function getEndpoint(config: OpenAIEndpointConfig): string | null | undefined;