langchain 0.0.127 → 0.0.128

package/dist/document_loaders/web/github.js

@@ -5,12 +5,13 @@ import { BaseDocumentLoader } from "../base.js";
 import { UnknownHandling } from "../fs/directory.js";
 import { extname } from "../../util/extname.js";
 import { getEnvironmentVariable } from "../../util/env.js";
+import { AsyncCaller } from "../../util/async_caller.js";
 const extensions = new Set(binaryExtensions);
 function isBinaryPath(name) {
     return extensions.has(extname(name).slice(1).toLowerCase());
 }
 export class GithubRepoLoader extends BaseDocumentLoader {
-    constructor(githubUrl, { accessToken = getEnvironmentVariable("GITHUB_ACCESS_TOKEN"), branch = "main", recursive = true, unknown = UnknownHandling.Warn, ignoreFiles = [], ignorePaths, } = {}) {
+    constructor(githubUrl, { accessToken = getEnvironmentVariable("GITHUB_ACCESS_TOKEN"), branch = "main", recursive = true, unknown = UnknownHandling.Warn, ignoreFiles = [], ignorePaths, verbose = false, maxConcurrency = 2, maxRetries = 2, ...rest } = {}) {
         super();
         Object.defineProperty(this, "owner", {
             enumerable: true,
@@ -72,6 +73,18 @@ export class GithubRepoLoader extends BaseDocumentLoader {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "verbose", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "caller", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         const { owner, repo, path } = this.extractOwnerAndRepoAndPath(githubUrl);
         this.owner = owner;
         this.repo = repo;
@@ -81,6 +94,12 @@ export class GithubRepoLoader extends BaseDocumentLoader {
         this.unknown = unknown;
         this.accessToken = accessToken;
         this.ignoreFiles = ignoreFiles;
+        this.verbose = verbose;
+        this.caller = new AsyncCaller({
+            maxConcurrency,
+            maxRetries,
+            ...rest,
+        });
         if (ignorePaths) {
             this.ignore = ignore.default().add(ignorePaths);
         }
@@ -98,11 +117,12 @@ export class GithubRepoLoader extends BaseDocumentLoader {
         return { owner: match[1], repo: match[2], path: match[4] || "" };
     }
     async load() {
-        const documents = [];
-        await this.processDirectory(this.initialPath, documents);
-        return documents;
+        return (await this.processRepo()).map((fileResponse) => new Document({
+            pageContent: fileResponse.contents,
+            metadata: fileResponse.metadata,
+        }));
     }
-    async shouldIgnore(path, fileType) {
+    shouldIgnore(path, fileType) {
         if (fileType !== "dir" && isBinaryPath(path)) {
             return true;
         }
@@ -122,46 +142,98 @@ export class GithubRepoLoader extends BaseDocumentLoader {
                 }
             }));
     }
-    async processDirectory(path, documents) {
-        try {
-            const files = await this.fetchRepoFiles(path);
-            for (const file of files) {
-                if (!(await this.shouldIgnore(file.path, file.type))) {
-                    if (file.type !== "dir") {
-                        try {
-                            const fileContent = await this.fetchFileContent(file);
-                            const metadata = { source: file.path };
-                            documents.push(new Document({ pageContent: fileContent, metadata }));
-                        }
-                        catch (e) {
-                            this.handleError(`Failed to fetch file content: ${file.path}, ${e}`);
-                        }
+    /**
+     * Takes the file info and wrap it in a promise that will resolve to the file content and metadata
+     * @param file
+     * @returns
+     */
+    async fetchFileContentWrapper(file) {
+        const fileContent = await this.fetchFileContent(file).catch((error) => {
+            this.handleError(`Failed wrap file content: ${file}, ${error}`);
+        });
+        return {
+            contents: fileContent || "",
+            metadata: { source: file.path },
+        };
+    }
+    /**
+     * Maps a list of files / directories to a list of promises that will fetch the file / directory contents
+     */
+    async getCurrentDirectoryFilePromises(files) {
+        const currentDirectoryFilePromises = [];
+        // Directories have nested files / directories, which is why this is a list of promises of promises
+        const currentDirectoryDirectoryPromises = [];
+        for (const file of files) {
+            if (!this.shouldIgnore(file.path, file.type)) {
+                if (file.type !== "dir") {
+                    try {
+                        currentDirectoryFilePromises.push(this.fetchFileContentWrapper(file));
                     }
-                    else if (this.recursive) {
-                        await this.processDirectory(file.path, documents);
+                    catch (e) {
+                        this.handleError(`Failed to fetch file content: ${file.path}, ${e}`);
                     }
                 }
+                else if (this.recursive) {
+                    currentDirectoryDirectoryPromises.push(this.processDirectory(file.path));
+                }
             }
         }
+        const curDirDirectories = await Promise.all(currentDirectoryDirectoryPromises);
+        return [...currentDirectoryFilePromises, ...curDirDirectories.flat()];
+    }
+    /**
+     * Begins the process of fetching the contents of the repository
+     */
+    async processRepo() {
+        try {
+            // Get the list of file / directory names in the root directory
+            const files = await this.fetchRepoFiles(this.initialPath);
+            // Map the file / directory paths to promises that will fetch the file / directory contents
+            const currentDirectoryFilePromises = await this.getCurrentDirectoryFilePromises(files);
+            return Promise.all(currentDirectoryFilePromises);
+        }
+        catch (error) {
+            this.handleError(`Failed to process directory: ${this.initialPath}, ${error}`);
+            return Promise.reject(error);
+        }
+    }
+    async processDirectory(path) {
+        try {
+            const files = await this.fetchRepoFiles(path);
+            return this.getCurrentDirectoryFilePromises(files);
+        }
         catch (error) {
             this.handleError(`Failed to process directory: ${path}, ${error}`);
+            return Promise.reject(error);
         }
     }
     async fetchRepoFiles(path) {
         const url = `https://api.github.com/repos/${this.owner}/${this.repo}/contents/${path}?ref=${this.branch}`;
-        const response = await fetch(url, { headers: this.headers });
-        const data = await response.json();
-        if (!response.ok) {
-            throw new Error(`Unable to fetch repository files: ${response.status} ${JSON.stringify(data)}`);
-        }
-        if (!Array.isArray(data)) {
-            throw new Error("Unable to fetch repository files.");
-        }
-        return data;
+        return this.caller.call(async () => {
+            if (this.verbose) {
+                console.log("Fetching", url);
+            }
+            const response = await fetch(url, { headers: this.headers });
+            const data = await response.json();
+            if (!response.ok) {
+                throw new Error(`Unable to fetch repository files: ${response.status} ${JSON.stringify(data)}`);
+            }
+            if (!Array.isArray(data)) {
+                throw new Error("Unable to fetch repository files.");
+            }
+            return data;
+        });
     }
     async fetchFileContent(file) {
-        const response = await fetch(file.download_url, { headers: this.headers });
-        return response.text();
+        return this.caller.call(async () => {
+            if (this.verbose) {
+                console.log("Fetching", file.download_url);
+            }
+            const response = await fetch(file.download_url, {
+                headers: this.headers,
+            });
+            return response.text();
+        });
     }
     handleError(message) {
         switch (this.unknown) {

package/dist/document_transformers/mozilla_readability.cjs

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MozillaReadabilityTransformer = void 0;
+const readability_1 = require("@mozilla/readability");
+const jsdom_1 = require("jsdom");
+const document_js_1 = require("../document.cjs");
+const document_js_2 = require("../schema/document.cjs");
+class MozillaReadabilityTransformer extends document_js_2.MappingDocumentTransformer {
+    constructor(options = {}) {
+        super(options);
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: options
+        });
+    }
+    async _transformDocument(document) {
+        const doc = new jsdom_1.JSDOM(document.pageContent);
+        const readability = new readability_1.Readability(doc.window.document, this.options);
+        const result = readability.parse();
+        return new document_js_1.Document({
+            pageContent: result?.textContent ?? "",
+            metadata: {
+                ...document.metadata,
+            },
+        });
+    }
+}
+exports.MozillaReadabilityTransformer = MozillaReadabilityTransformer;

package/dist/document_transformers/mozilla_readability.d.ts

@@ -0,0 +1,8 @@
+import { Options } from "mozilla-readability";
+import { Document } from "../document.js";
+import { MappingDocumentTransformer } from "../schema/document.js";
+export declare class MozillaReadabilityTransformer extends MappingDocumentTransformer {
+    protected options: Options;
+    constructor(options?: Options);
+    _transformDocument(document: Document): Promise<Document>;
+}

package/dist/document_transformers/mozilla_readability.js

@@ -0,0 +1,26 @@
+import { Readability } from "@mozilla/readability";
+import { JSDOM } from "jsdom";
+import { Document } from "../document.js";
+import { MappingDocumentTransformer } from "../schema/document.js";
+export class MozillaReadabilityTransformer extends MappingDocumentTransformer {
+    constructor(options = {}) {
+        super(options);
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: options
+        });
+    }
+    async _transformDocument(document) {
+        const doc = new JSDOM(document.pageContent);
+        const readability = new Readability(doc.window.document, this.options);
+        const result = readability.parse();
+        return new Document({
+            pageContent: result?.textContent ?? "",
+            metadata: {
+                ...document.metadata,
+            },
+        });
+    }
+}

package/dist/llms/base.cjs

@@ -75,7 +75,9 @@ class BaseLLM extends index_js_3.BaseLanguageModel {
                     else {
                         generation = generation.concat(chunk);
                     }
-                    yield chunk.text;
+                    if (typeof chunk.text === "string") {
+                        yield chunk.text;
+                    }
                 }
             }
             catch (err) {

package/dist/llms/base.js

@@ -72,7 +72,9 @@ export class BaseLLM extends BaseLanguageModel {
                     else {
                         generation = generation.concat(chunk);
                     }
-                    yield chunk.text;
+                    if (typeof chunk.text === "string") {
+                        yield chunk.text;
+                    }
                 }
             }
             catch (err) {

package/dist/llms/bedrock.cjs

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bedrock = void 0;
+const signature_v4_1 = require("@aws-sdk/signature-v4");
+const credential_provider_node_1 = require("@aws-sdk/credential-provider-node");
+const protocol_http_1 = require("@aws-sdk/protocol-http");
+const sha256_js_1 = require("@aws-crypto/sha256-js");
+const env_js_1 = require("../util/env.cjs");
+const base_js_1 = require("./base.cjs");
+class BedrockLLMInputOutputAdapter {
+    /** Adapter class to prepare the inputs from Langchain to a format
+    that LLM model expects. Also, provides a helper function to extract
+    the generated text from the model response. */
+    static prepareInput(provider, prompt) {
+        const inputBody = {};
+        if (provider === "anthropic" || provider === "ai21") {
+            inputBody.prompt = prompt;
+        }
+        else if (provider === "amazon") {
+            inputBody.inputText = prompt;
+            inputBody.textGenerationConfig = {};
+        }
+        else {
+            inputBody.inputText = prompt;
+        }
+        if (provider === "anthropic" && !("max_tokens_to_sample" in inputBody)) {
+            inputBody.max_tokens_to_sample = 50;
+        }
+        return inputBody;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static prepareOutput(provider, responseBody) {
+        if (provider === "anthropic") {
+            return responseBody.completion;
+        }
+        else if (provider === "ai21") {
+            return responseBody.completions[0].data.text;
+        }
+        return responseBody.results[0].outputText;
+    }
+}
+class Bedrock extends base_js_1.LLM {
+    get lc_secrets() {
+        return {};
+    }
+    _llmType() {
+        return "bedrock";
+    }
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "amazon.titan-tg1-large"
+        });
+        Object.defineProperty(this, "region", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "credentials", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "temperature", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "maxTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "fetchFn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.model = fields?.model ?? this.model;
+        const allowedModels = ["ai21", "anthropic", "amazon"];
+        if (!allowedModels.includes(this.model.split(".")[0])) {
+            throw new Error(`Unknown model: '${this.model}', only these are supported: ${allowedModels}`);
+        }
+        const region = fields?.region ?? (0, env_js_1.getEnvironmentVariable)("AWS_DEFAULT_REGION");
+        if (!region) {
+            throw new Error("Please set the AWS_DEFAULT_REGION environment variable or pass it to the constructor as the region field.");
+        }
+        this.region = region;
+        this.credentials = fields?.credentials ?? (0, credential_provider_node_1.defaultProvider)();
+        this.temperature = fields?.temperature ?? this.temperature;
+        this.maxTokens = fields?.maxTokens ?? this.maxTokens;
+        this.fetchFn = fields?.fetchFn ?? fetch;
+    }
+    /** Call out to Bedrock service model.
+      Arguments:
+        prompt: The prompt to pass into the model.
+  
+      Returns:
+        The string generated by the model.
+  
+      Example:
+        response = model.call("Tell me a joke.")
+    */
+    async _call(prompt) {
+        const provider = this.model.split(".")[0];
+        const service = "bedrock";
+        const inputBody = BedrockLLMInputOutputAdapter.prepareInput(provider, prompt);
+        const url = new URL(`https://${service}.${this.region}.amazonaws.com/model/${this.model}/invoke`);
+        const request = new protocol_http_1.HttpRequest({
+            hostname: url.hostname,
+            path: url.pathname,
+            protocol: url.protocol,
+            method: "POST",
+            body: JSON.stringify(inputBody),
+            query: Object.fromEntries(url.searchParams.entries()),
+            headers: {
+                // host is required by AWS Signature V4: https://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html
+                host: url.host,
+                accept: "application/json",
+                "Content-Type": "application/json",
+            },
+        });
+        const signer = new signature_v4_1.SignatureV4({
+            credentials: this.credentials,
+            service,
+            region: this.region,
+            sha256: sha256_js_1.Sha256,
+        });
+        const signedRequest = await signer.sign(request);
+        // Send request to AWS using the low-level fetch API
+        const response = await this.fetchFn(url, {
+            headers: signedRequest.headers,
+            body: signedRequest.body,
+            method: signedRequest.method,
+        });
+        if (response.status < 200 || response.status >= 300) {
+            throw Error(`Failed to access underlying url '${url}': got ${response.status} ${response.statusText}: ${await response.text()}`);
+        }
+        const responseJson = await response.json();
+        const text = BedrockLLMInputOutputAdapter.prepareOutput(provider, responseJson);
+        return text;
+    }
+}
+exports.Bedrock = Bedrock;

package/dist/llms/bedrock.d.ts

@@ -0,0 +1,54 @@
+import type { AwsCredentialIdentity, Provider } from "@aws-sdk/types";
+import { LLM, BaseLLMParams } from "./base.js";
+type CredentialType = AwsCredentialIdentity | Provider<AwsCredentialIdentity>;
+/** Bedrock models.
+    To authenticate, the AWS client uses the following methods to automatically load credentials:
+    https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html
+    If a specific credential profile should be used, you must pass the name of the profile from the ~/.aws/credentials file that is to be used.
+    Make sure the credentials / roles used have the required policies to access the Bedrock service.
+*/
+export interface BedrockInput {
+    /** Model to use.
+        For example, "amazon.titan-tg1-large", this is equivalent to the modelId property in the list-foundation-models api.
+    */
+    model: string;
+    /** The AWS region e.g. `us-west-2`.
+        Fallback to AWS_DEFAULT_REGION env variable or region specified in ~/.aws/config in case it is not provided here.
+    */
+    region?: string;
+    /** AWS Credentials.
+        If no credentials are provided, the default credentials from `@aws-sdk/credential-provider-node` will be used.
+     */
+    credentials?: CredentialType;
+    /** Temperature */
+    temperature?: number;
+    /** Max tokens */
+    maxTokens?: number;
+    /** A custom fetch function for low-level access to AWS API. Defaults to fetch() */
+    fetchFn?: typeof fetch;
+}
+export declare class Bedrock extends LLM implements BedrockInput {
+    model: string;
+    region: string;
+    credentials: CredentialType;
+    temperature?: number | undefined;
+    maxTokens?: number | undefined;
+    fetchFn: typeof fetch;
+    get lc_secrets(): {
+        [key: string]: string;
+    } | undefined;
+    _llmType(): string;
+    constructor(fields?: Partial<BedrockInput> & BaseLLMParams);
+    /** Call out to Bedrock service model.
+      Arguments:
+        prompt: The prompt to pass into the model.
+  
+      Returns:
+        The string generated by the model.
+  
+      Example:
+        response = model.call("Tell me a joke.")
+    */
+    _call(prompt: string): Promise<string>;
+}
+export {};

package/dist/llms/bedrock.js

@@ -0,0 +1,148 @@
+import { SignatureV4 } from "@aws-sdk/signature-v4";
+import { defaultProvider } from "@aws-sdk/credential-provider-node";
+import { HttpRequest } from "@aws-sdk/protocol-http";
+import { Sha256 } from "@aws-crypto/sha256-js";
+import { getEnvironmentVariable } from "../util/env.js";
+import { LLM } from "./base.js";
+class BedrockLLMInputOutputAdapter {
+    /** Adapter class to prepare the inputs from Langchain to a format
+    that LLM model expects. Also, provides a helper function to extract
+    the generated text from the model response. */
+    static prepareInput(provider, prompt) {
+        const inputBody = {};
+        if (provider === "anthropic" || provider === "ai21") {
+            inputBody.prompt = prompt;
+        }
+        else if (provider === "amazon") {
+            inputBody.inputText = prompt;
+            inputBody.textGenerationConfig = {};
+        }
+        else {
+            inputBody.inputText = prompt;
+        }
+        if (provider === "anthropic" && !("max_tokens_to_sample" in inputBody)) {
+            inputBody.max_tokens_to_sample = 50;
+        }
+        return inputBody;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static prepareOutput(provider, responseBody) {
+        if (provider === "anthropic") {
+            return responseBody.completion;
+        }
+        else if (provider === "ai21") {
+            return responseBody.completions[0].data.text;
+        }
+        return responseBody.results[0].outputText;
+    }
+}
+export class Bedrock extends LLM {
+    get lc_secrets() {
+        return {};
+    }
+    _llmType() {
+        return "bedrock";
+    }
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "amazon.titan-tg1-large"
+        });
+        Object.defineProperty(this, "region", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "credentials", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "temperature", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "maxTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "fetchFn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.model = fields?.model ?? this.model;
+        const allowedModels = ["ai21", "anthropic", "amazon"];
+        if (!allowedModels.includes(this.model.split(".")[0])) {
+            throw new Error(`Unknown model: '${this.model}', only these are supported: ${allowedModels}`);
+        }
+        const region = fields?.region ?? getEnvironmentVariable("AWS_DEFAULT_REGION");
+        if (!region) {
+            throw new Error("Please set the AWS_DEFAULT_REGION environment variable or pass it to the constructor as the region field.");
+        }
+        this.region = region;
+        this.credentials = fields?.credentials ?? defaultProvider();
+        this.temperature = fields?.temperature ?? this.temperature;
+        this.maxTokens = fields?.maxTokens ?? this.maxTokens;
+        this.fetchFn = fields?.fetchFn ?? fetch;
+    }
+    /** Call out to Bedrock service model.
+      Arguments:
+        prompt: The prompt to pass into the model.
+  
+      Returns:
+        The string generated by the model.
+  
+      Example:
+        response = model.call("Tell me a joke.")
+    */
+    async _call(prompt) {
+        const provider = this.model.split(".")[0];
+        const service = "bedrock";
+        const inputBody = BedrockLLMInputOutputAdapter.prepareInput(provider, prompt);
+        const url = new URL(`https://${service}.${this.region}.amazonaws.com/model/${this.model}/invoke`);
+        const request = new HttpRequest({
+            hostname: url.hostname,
+            path: url.pathname,
+            protocol: url.protocol,
+            method: "POST",
+            body: JSON.stringify(inputBody),
+            query: Object.fromEntries(url.searchParams.entries()),
+            headers: {
+                // host is required by AWS Signature V4: https://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html
+                host: url.host,
+                accept: "application/json",
+                "Content-Type": "application/json",
+            },
+        });
+        const signer = new SignatureV4({
+            credentials: this.credentials,
+            service,
+            region: this.region,
+            sha256: Sha256,
+        });
+        const signedRequest = await signer.sign(request);
+        // Send request to AWS using the low-level fetch API
+        const response = await this.fetchFn(url, {
+            headers: signedRequest.headers,
+            body: signedRequest.body,
+            method: signedRequest.method,
+        });
+        if (response.status < 200 || response.status >= 300) {
+            throw Error(`Failed to access underlying url '${url}': got ${response.status} ${response.statusText}: ${await response.text()}`);
+        }
+        const responseJson = await response.json();
+        const text = BedrockLLMInputOutputAdapter.prepareOutput(provider, responseJson);
+        return text;
+    }
+}

package/dist/llms/openai-chat.cjs

@@ -140,6 +140,12 @@ class OpenAIChat extends base_js_1.LLM {
             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,
@@ -228,6 +234,7 @@ class OpenAIChat extends base_js_1.LLM {
         this.logitBias = fields?.logitBias;
         this.maxTokens = fields?.maxTokens;
         this.stop = fields?.stop;
+        this.user = fields?.user;
         this.streaming = fields?.streaming ?? false;
         if (this.n > 1) {
             throw new Error("Cannot use n > 1 in OpenAIChat LLM. Use ChatOpenAI Chat Model instead.");
@@ -263,6 +270,7 @@ class OpenAIChat extends base_js_1.LLM {
             logit_bias: this.logitBias,
             max_tokens: this.maxTokens === -1 ? undefined : this.maxTokens,
             stop: options?.stop ?? this.stop,
+            user: this.user,
             stream: this.streaming,
             ...this.modelKwargs,
         };

package/dist/llms/openai-chat.d.ts

@@ -49,6 +49,7 @@ export declare class OpenAIChat extends LLM<OpenAIChatCallOptions> implements Op
     modelKwargs?: OpenAIChatInput["modelKwargs"];
     timeout?: number;
     stop?: string[];
+    user?: string;
     streaming: boolean;
     openAIApiKey?: string;
     azureOpenAIApiVersion?: string;