@nocobase/plugin-ai 2.2.0-beta.8 → 2.2.0-beta.9

package/dist/node_modules/@langchain/mistralai/dist/index.d.cts

@@ -0,0 +1,4 @@
+import { ChatMistralAI, ChatMistralAICallOptions, ChatMistralAIInput, convertMessagesToMistralMessages } from "./chat_models.cjs";
+import { MistralAIEmbeddings, MistralAIEmbeddingsParams } from "./embeddings.cjs";
+import { MistralAI, MistralAICallOptions, MistralAIInput } from "./llms.cjs";
+export { ChatMistralAI, ChatMistralAICallOptions, ChatMistralAIInput, MistralAI, MistralAICallOptions, MistralAIEmbeddings, MistralAIEmbeddingsParams, MistralAIInput, convertMessagesToMistralMessages };

package/dist/node_modules/@langchain/mistralai/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { ChatMistralAI, ChatMistralAICallOptions, ChatMistralAIInput, convertMessagesToMistralMessages } from "./chat_models.js";
+import { MistralAIEmbeddings, MistralAIEmbeddingsParams } from "./embeddings.js";
+import { MistralAI, MistralAICallOptions, MistralAIInput } from "./llms.js";
+export { ChatMistralAI, ChatMistralAICallOptions, ChatMistralAIInput, MistralAI, MistralAICallOptions, MistralAIEmbeddings, MistralAIEmbeddingsParams, MistralAIInput, convertMessagesToMistralMessages };

package/dist/node_modules/@langchain/mistralai/dist/index.js

@@ -0,0 +1,5 @@
+import { ChatMistralAI, convertMessagesToMistralMessages } from "./chat_models.js";
+import { MistralAIEmbeddings } from "./embeddings.js";
+import { MistralAI } from "./llms.js";
+
+export { ChatMistralAI, MistralAI, MistralAIEmbeddings, convertMessagesToMistralMessages };

package/dist/node_modules/@langchain/mistralai/dist/llms.cjs

@@ -0,0 +1,275 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const __mistralai_mistralai_lib_http_js = require_rolldown_runtime.__toESM(require("@mistralai/mistralai/lib/http.js"));
+const __langchain_core_outputs = require_rolldown_runtime.__toESM(require("@langchain/core/outputs"));
+const __langchain_core_utils_async_caller = require_rolldown_runtime.__toESM(require("@langchain/core/utils/async_caller"));
+const __langchain_core_utils_env = require_rolldown_runtime.__toESM(require("@langchain/core/utils/env"));
+const __langchain_core_utils_chunk_array = require_rolldown_runtime.__toESM(require("@langchain/core/utils/chunk_array"));
+const __langchain_core_language_models_llms = require_rolldown_runtime.__toESM(require("@langchain/core/language_models/llms"));
+
+//#region src/llms.ts
+/**
+* MistralAI completions LLM.
+*/
+var MistralAI = class extends __langchain_core_language_models_llms.LLM {
+	static lc_name() {
+		return "MistralAI";
+	}
+	lc_namespace = [
+		"langchain",
+		"llms",
+		"mistralai"
+	];
+	lc_serializable = true;
+	model = "codestral-latest";
+	temperature = 0;
+	topP;
+	maxTokens;
+	randomSeed;
+	streaming = false;
+	batchSize = 20;
+	apiKey;
+	/**
+	* @deprecated use serverURL instead
+	*/
+	endpoint;
+	serverURL;
+	maxRetries;
+	maxConcurrency;
+	beforeRequestHooks;
+	requestErrorHooks;
+	responseHooks;
+	httpClient;
+	constructor(fields) {
+		super(fields ?? {});
+		this.model = fields?.model ?? this.model;
+		this.temperature = fields?.temperature ?? this.temperature;
+		this.topP = fields?.topP ?? this.topP;
+		this.maxTokens = fields?.maxTokens ?? this.maxTokens;
+		this.randomSeed = fields?.randomSeed ?? this.randomSeed;
+		this.batchSize = fields?.batchSize ?? this.batchSize;
+		this.streaming = fields?.streaming ?? this.streaming;
+		this.serverURL = fields?.serverURL ?? this.serverURL;
+		this.maxRetries = fields?.maxRetries;
+		this.maxConcurrency = fields?.maxConcurrency;
+		this.beforeRequestHooks = fields?.beforeRequestHooks ?? this.beforeRequestHooks;
+		this.requestErrorHooks = fields?.requestErrorHooks ?? this.requestErrorHooks;
+		this.responseHooks = fields?.responseHooks ?? this.responseHooks;
+		this.httpClient = fields?.httpClient ?? this.httpClient;
+		const apiKey = fields?.apiKey ?? (0, __langchain_core_utils_env.getEnvironmentVariable)("MISTRAL_API_KEY");
+		if (!apiKey) throw new Error(`MistralAI requires an API key to be set.
+Either provide one via the "apiKey" field in the constructor, or set the "MISTRAL_API_KEY" environment variable.`);
+		this.apiKey = apiKey;
+		this.addAllHooksToHttpClient();
+	}
+	get lc_secrets() {
+		return { apiKey: "MISTRAL_API_KEY" };
+	}
+	get lc_aliases() {
+		return { apiKey: "mistral_api_key" };
+	}
+	_llmType() {
+		return "mistralai";
+	}
+	invocationParams(options) {
+		return {
+			model: this.model,
+			suffix: options.suffix,
+			temperature: this.temperature,
+			maxTokens: this.maxTokens,
+			topP: this.topP,
+			randomSeed: this.randomSeed,
+			stop: options.stop
+		};
+	}
+	/**
+	* For some given input string and options, return a string output.
+	*
+	* Despite the fact that `invoke` is overridden below, we still need this
+	* in order to handle public APi calls to `generate()`.
+	*/
+	async _call(prompt, options) {
+		const params = {
+			...this.invocationParams(options),
+			prompt
+		};
+		const result = await this.completionWithRetry(params, options, false);
+		let content = result?.choices?.[0].message.content ?? "";
+		if (Array.isArray(content)) content = content[0].type === "text" ? content[0].text : "";
+		return content;
+	}
+	async _generate(prompts, options, runManager) {
+		const subPrompts = (0, __langchain_core_utils_chunk_array.chunkArray)(prompts, this.batchSize);
+		const choices = [];
+		const params = this.invocationParams(options);
+		for (let i = 0; i < subPrompts.length; i += 1) {
+			const data = await (async () => {
+				if (this.streaming) {
+					const responseData = [];
+					for (let x = 0; x < subPrompts[i].length; x += 1) {
+						const choices$1 = [];
+						let response;
+						const stream = await this.completionWithRetry({
+							...params,
+							prompt: subPrompts[i][x]
+						}, options, true);
+						for await (const { data: data$1 } of stream) {
+							if (!response) response = {
+								id: data$1.id,
+								object: "chat.completion",
+								created: data$1.created,
+								model: data$1.model
+							};
+							for (const part of data$1.choices) {
+								let content = part.delta.content ?? "";
+								if (Array.isArray(content)) {
+									let strContent = "";
+									for (const contentChunk of content) if (contentChunk.type === "text") strContent += contentChunk.text;
+									else if (contentChunk.type === "image_url") {
+										const imageURL = typeof contentChunk.imageUrl === "string" ? contentChunk.imageUrl : contentChunk.imageUrl.url;
+										strContent += imageURL;
+									}
+									content = strContent;
+								}
+								if (!choices$1[part.index]) choices$1[part.index] = {
+									index: part.index,
+									message: {
+										role: "assistant",
+										content,
+										toolCalls: null
+									},
+									finishReason: part.finishReason ?? "length"
+								};
+								else {
+									const choice = choices$1[part.index];
+									choice.message.content += content;
+									choice.finishReason = part.finishReason ?? "length";
+								}
+								runManager?.handleLLMNewToken(content, {
+									prompt: part.index,
+									completion: part.index
+								});
+							}
+						}
+						if (options.signal?.aborted) throw new Error("AbortError");
+						responseData.push({
+							...response,
+							choices: choices$1
+						});
+					}
+					return responseData;
+				} else {
+					const responseData = [];
+					for (let x = 0; x < subPrompts[i].length; x += 1) {
+						const res = await this.completionWithRetry({
+							...params,
+							prompt: subPrompts[i][x]
+						}, options, false);
+						responseData.push(res);
+					}
+					return responseData;
+				}
+			})();
+			choices.push(...data.map((d) => d.choices ?? []));
+		}
+		const generations = choices.map((promptChoices) => promptChoices.map((choice) => {
+			let text = choice.message?.content ?? "";
+			if (Array.isArray(text)) text = text[0].type === "text" ? text[0].text : "";
+			return {
+				text,
+				generationInfo: { finishReason: choice.finishReason }
+			};
+		}));
+		return { generations };
+	}
+	async completionWithRetry(request, options, stream) {
+		const { Mistral } = await this.imports();
+		const caller = new __langchain_core_utils_async_caller.AsyncCaller({
+			maxConcurrency: options.maxConcurrency || this.maxConcurrency,
+			maxRetries: this.maxRetries
+		});
+		const client = new Mistral({
+			apiKey: this.apiKey,
+			serverURL: this.serverURL,
+			timeoutMs: options.timeout,
+			...this.httpClient ? { httpClient: this.httpClient } : {}
+		});
+		return caller.callWithOptions({ signal: options.signal }, async () => {
+			try {
+				let res;
+				if (stream) res = await client.fim.stream(request);
+				else res = await client.fim.complete(request);
+				return res;
+			} catch (e) {
+				if (e.message?.includes("status: 400") || e.message?.toLowerCase().includes("status 400") || e.message?.includes("validation failed")) e.status = 400;
+				throw e;
+			}
+		});
+	}
+	async *_streamResponseChunks(prompt, options, runManager) {
+		const params = {
+			...this.invocationParams(options),
+			prompt
+		};
+		const stream = await this.completionWithRetry(params, options, true);
+		for await (const message of stream) {
+			const { data } = message;
+			const choice = data?.choices[0];
+			if (!choice) continue;
+			let text = choice.delta.content ?? "";
+			if (Array.isArray(text)) text = text[0].type === "text" ? text[0].text : "";
+			const chunk = new __langchain_core_outputs.GenerationChunk({
+				text,
+				generationInfo: {
+					finishReason: choice.finishReason,
+					tokenUsage: data.usage
+				}
+			});
+			yield chunk;
+			runManager?.handleLLMNewToken(chunk.text ?? "");
+		}
+		if (options.signal?.aborted) throw new Error("AbortError");
+	}
+	addAllHooksToHttpClient() {
+		try {
+			this.removeAllHooksFromHttpClient();
+			const hasHooks = [
+				this.beforeRequestHooks,
+				this.requestErrorHooks,
+				this.responseHooks
+			].some((hook) => hook && hook.length > 0);
+			if (hasHooks && !this.httpClient) this.httpClient = new __mistralai_mistralai_lib_http_js.HTTPClient();
+			if (this.beforeRequestHooks) for (const hook of this.beforeRequestHooks) this.httpClient?.addHook("beforeRequest", hook);
+			if (this.requestErrorHooks) for (const hook of this.requestErrorHooks) this.httpClient?.addHook("requestError", hook);
+			if (this.responseHooks) for (const hook of this.responseHooks) this.httpClient?.addHook("response", hook);
+		} catch {
+			throw new Error("Error in adding all hooks");
+		}
+	}
+	removeAllHooksFromHttpClient() {
+		try {
+			if (this.beforeRequestHooks) for (const hook of this.beforeRequestHooks) this.httpClient?.removeHook("beforeRequest", hook);
+			if (this.requestErrorHooks) for (const hook of this.requestErrorHooks) this.httpClient?.removeHook("requestError", hook);
+			if (this.responseHooks) for (const hook of this.responseHooks) this.httpClient?.removeHook("response", hook);
+		} catch {
+			throw new Error("Error in removing hooks");
+		}
+	}
+	removeHookFromHttpClient(hook) {
+		try {
+			this.httpClient?.removeHook("beforeRequest", hook);
+			this.httpClient?.removeHook("requestError", hook);
+			this.httpClient?.removeHook("response", hook);
+		} catch {
+			throw new Error("Error in removing hook");
+		}
+	}
+	/** @ignore */
+	async imports() {
+		const { Mistral } = await import("@mistralai/mistralai");
+		return { Mistral };
+	}
+};
+
+//#endregion
+exports.MistralAI = MistralAI;
+//# sourceMappingURL=llms.cjs.map

package/dist/node_modules/@langchain/mistralai/dist/llms.d.cts

@@ -0,0 +1,147 @@
+import { CompletionEvent } from "@mistralai/mistralai/models/components/completionevent.js";
+import { BeforeRequestHook, HTTPClient, RequestErrorHook, ResponseHook } from "@mistralai/mistralai/lib/http.js";
+import { BaseLanguageModelCallOptions } from "@langchain/core/language_models/base";
+import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
+import { GenerationChunk, LLMResult } from "@langchain/core/outputs";
+import { BaseLLMParams, LLM } from "@langchain/core/language_models/llms";
+import { FIMCompletionRequest } from "@mistralai/mistralai/models/components/fimcompletionrequest.js";
+import { FIMCompletionStreamRequest } from "@mistralai/mistralai/models/components/fimcompletionstreamrequest.js";
+import { FIMCompletionResponse } from "@mistralai/mistralai/models/components/fimcompletionresponse.js";
+
+//#region src/llms.d.ts
+interface MistralAICallOptions extends BaseLanguageModelCallOptions {
+  /**
+   * Optional text/code that adds more context for the model.
+   * When given a prompt and a suffix the model will fill what
+   * is between them. When suffix is not provided, the model
+   * will simply execute completion starting with prompt.
+   */
+  suffix?: string;
+}
+interface MistralAIInput extends BaseLLMParams {
+  /**
+   * The name of the model to use.
+   * @default "codestral-latest"
+   */
+  model?: string;
+  /**
+   * The API key to use.
+   * @default {process.env.MISTRAL_API_KEY}
+   */
+  apiKey?: string;
+  /**
+   * Override the default server URL used by the Mistral SDK.
+   * @deprecated use serverURL instead
+   */
+  endpoint?: string;
+  /**
+   * Override the default server URL used by the Mistral SDK.
+   */
+  serverURL?: string;
+  /**
+   * What sampling temperature to use, between 0.0 and 2.0.
+   * Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic.
+   * @default {0.7}
+   */
+  temperature?: number;
+  /**
+   * Nucleus sampling, where the model considers the results of the tokens with `topP` probability mass.
+   * So 0.1 means only the tokens comprising the top 10% probability mass are considered.
+   * Should be between 0 and 1.
+   * @default {1}
+   */
+  topP?: number;
+  /**
+   * The maximum number of tokens to generate in the completion.
+   * The token count of your prompt plus maxTokens cannot exceed the model's context length.
+   */
+  maxTokens?: number;
+  /**
+   * Whether or not to stream the response.
+   * @default {false}
+   */
+  streaming?: boolean;
+  /**
+   * The seed to use for random sampling. If set, different calls will generate deterministic results.
+   * Alias for `seed`
+   */
+  randomSeed?: number;
+  /**
+   * Batch size to use when passing multiple documents to generate
+   */
+  batchSize?: number;
+  /**
+   * A list of custom hooks that must follow (req: Request) => Awaitable<Request | void>
+   * They are automatically added when a ChatMistralAI instance is created
+   */
+  beforeRequestHooks?: BeforeRequestHook[];
+  /**
+   * A list of custom hooks that must follow (err: unknown, req: Request) => Awaitable<void>
+   * They are automatically added when a ChatMistralAI instance is created
+   */
+  requestErrorHooks?: RequestErrorHook[];
+  /**
+   * A list of custom hooks that must follow (res: Response, req: Request) => Awaitable<void>
+   * They are automatically added when a ChatMistralAI instance is created
+   */
+  responseHooks?: ResponseHook[];
+  /**
+   * Optional custom HTTP client to manage API requests
+   * Allows users to add custom fetch implementations, hooks, as well as error and response processing.
+   */
+  httpClient?: HTTPClient;
+}
+/**
+ * MistralAI completions LLM.
+ */
+declare class MistralAI extends LLM<MistralAICallOptions> implements MistralAIInput {
+  static lc_name(): string;
+  lc_namespace: string[];
+  lc_serializable: boolean;
+  model: string;
+  temperature: number;
+  topP?: number;
+  maxTokens?: number | undefined;
+  randomSeed?: number | undefined;
+  streaming: boolean;
+  batchSize: number;
+  apiKey: string;
+  /**
+   * @deprecated use serverURL instead
+   */
+  endpoint: string;
+  serverURL?: string;
+  maxRetries?: number;
+  maxConcurrency?: number;
+  beforeRequestHooks?: Array<BeforeRequestHook>;
+  requestErrorHooks?: Array<RequestErrorHook>;
+  responseHooks?: Array<ResponseHook>;
+  httpClient?: HTTPClient;
+  constructor(fields?: MistralAIInput);
+  get lc_secrets(): {
+    [key: string]: string;
+  } | undefined;
+  get lc_aliases(): {
+    [key: string]: string;
+  } | undefined;
+  _llmType(): string;
+  invocationParams(options: this["ParsedCallOptions"]): Omit<FIMCompletionRequest | FIMCompletionStreamRequest, "prompt">;
+  /**
+   * For some given input string and options, return a string output.
+   *
+   * Despite the fact that `invoke` is overridden below, we still need this
+   * in order to handle public APi calls to `generate()`.
+   */
+  _call(prompt: string, options: this["ParsedCallOptions"]): Promise<string>;
+  _generate(prompts: string[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<LLMResult>;
+  completionWithRetry(request: FIMCompletionRequest, options: this["ParsedCallOptions"], stream: false): Promise<FIMCompletionResponse>;
+  completionWithRetry(request: FIMCompletionStreamRequest, options: this["ParsedCallOptions"], stream: true): Promise<AsyncIterable<CompletionEvent>>;
+  _streamResponseChunks(prompt: string, options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<GenerationChunk>;
+  addAllHooksToHttpClient(): void;
+  removeAllHooksFromHttpClient(): void;
+  removeHookFromHttpClient(hook: BeforeRequestHook | RequestErrorHook | ResponseHook): void;
+  private imports;
+}
+//#endregion
+export { MistralAI, MistralAICallOptions, MistralAIInput };
+//# sourceMappingURL=llms.d.cts.map

package/dist/node_modules/@langchain/mistralai/dist/llms.d.ts

@@ -0,0 +1,147 @@
+import { BeforeRequestHook, HTTPClient, RequestErrorHook, ResponseHook } from "@mistralai/mistralai/lib/http.js";
+import { GenerationChunk, LLMResult } from "@langchain/core/outputs";
+import { BaseLLMParams, LLM } from "@langchain/core/language_models/llms";
+import { CompletionEvent } from "@mistralai/mistralai/models/components/completionevent.js";
+import { BaseLanguageModelCallOptions } from "@langchain/core/language_models/base";
+import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
+import { FIMCompletionRequest } from "@mistralai/mistralai/models/components/fimcompletionrequest.js";
+import { FIMCompletionStreamRequest } from "@mistralai/mistralai/models/components/fimcompletionstreamrequest.js";
+import { FIMCompletionResponse } from "@mistralai/mistralai/models/components/fimcompletionresponse.js";
+
+//#region src/llms.d.ts
+interface MistralAICallOptions extends BaseLanguageModelCallOptions {
+  /**
+   * Optional text/code that adds more context for the model.
+   * When given a prompt and a suffix the model will fill what
+   * is between them. When suffix is not provided, the model
+   * will simply execute completion starting with prompt.
+   */
+  suffix?: string;
+}
+interface MistralAIInput extends BaseLLMParams {
+  /**
+   * The name of the model to use.
+   * @default "codestral-latest"
+   */
+  model?: string;
+  /**
+   * The API key to use.
+   * @default {process.env.MISTRAL_API_KEY}
+   */
+  apiKey?: string;
+  /**
+   * Override the default server URL used by the Mistral SDK.
+   * @deprecated use serverURL instead
+   */
+  endpoint?: string;
+  /**
+   * Override the default server URL used by the Mistral SDK.
+   */
+  serverURL?: string;
+  /**
+   * What sampling temperature to use, between 0.0 and 2.0.
+   * Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic.
+   * @default {0.7}
+   */
+  temperature?: number;
+  /**
+   * Nucleus sampling, where the model considers the results of the tokens with `topP` probability mass.
+   * So 0.1 means only the tokens comprising the top 10% probability mass are considered.
+   * Should be between 0 and 1.
+   * @default {1}
+   */
+  topP?: number;
+  /**
+   * The maximum number of tokens to generate in the completion.
+   * The token count of your prompt plus maxTokens cannot exceed the model's context length.
+   */
+  maxTokens?: number;
+  /**
+   * Whether or not to stream the response.
+   * @default {false}
+   */
+  streaming?: boolean;
+  /**
+   * The seed to use for random sampling. If set, different calls will generate deterministic results.
+   * Alias for `seed`
+   */
+  randomSeed?: number;
+  /**
+   * Batch size to use when passing multiple documents to generate
+   */
+  batchSize?: number;
+  /**
+   * A list of custom hooks that must follow (req: Request) => Awaitable<Request | void>
+   * They are automatically added when a ChatMistralAI instance is created
+   */
+  beforeRequestHooks?: BeforeRequestHook[];
+  /**
+   * A list of custom hooks that must follow (err: unknown, req: Request) => Awaitable<void>
+   * They are automatically added when a ChatMistralAI instance is created
+   */
+  requestErrorHooks?: RequestErrorHook[];
+  /**
+   * A list of custom hooks that must follow (res: Response, req: Request) => Awaitable<void>
+   * They are automatically added when a ChatMistralAI instance is created
+   */
+  responseHooks?: ResponseHook[];
+  /**
+   * Optional custom HTTP client to manage API requests
+   * Allows users to add custom fetch implementations, hooks, as well as error and response processing.
+   */
+  httpClient?: HTTPClient;
+}
+/**
+ * MistralAI completions LLM.
+ */
+declare class MistralAI extends LLM<MistralAICallOptions> implements MistralAIInput {
+  static lc_name(): string;
+  lc_namespace: string[];
+  lc_serializable: boolean;
+  model: string;
+  temperature: number;
+  topP?: number;
+  maxTokens?: number | undefined;
+  randomSeed?: number | undefined;
+  streaming: boolean;
+  batchSize: number;
+  apiKey: string;
+  /**
+   * @deprecated use serverURL instead
+   */
+  endpoint: string;
+  serverURL?: string;
+  maxRetries?: number;
+  maxConcurrency?: number;
+  beforeRequestHooks?: Array<BeforeRequestHook>;
+  requestErrorHooks?: Array<RequestErrorHook>;
+  responseHooks?: Array<ResponseHook>;
+  httpClient?: HTTPClient;
+  constructor(fields?: MistralAIInput);
+  get lc_secrets(): {
+    [key: string]: string;
+  } | undefined;
+  get lc_aliases(): {
+    [key: string]: string;
+  } | undefined;
+  _llmType(): string;
+  invocationParams(options: this["ParsedCallOptions"]): Omit<FIMCompletionRequest | FIMCompletionStreamRequest, "prompt">;
+  /**
+   * For some given input string and options, return a string output.
+   *
+   * Despite the fact that `invoke` is overridden below, we still need this
+   * in order to handle public APi calls to `generate()`.
+   */
+  _call(prompt: string, options: this["ParsedCallOptions"]): Promise<string>;
+  _generate(prompts: string[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<LLMResult>;
+  completionWithRetry(request: FIMCompletionRequest, options: this["ParsedCallOptions"], stream: false): Promise<FIMCompletionResponse>;
+  completionWithRetry(request: FIMCompletionStreamRequest, options: this["ParsedCallOptions"], stream: true): Promise<AsyncIterable<CompletionEvent>>;
+  _streamResponseChunks(prompt: string, options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<GenerationChunk>;
+  addAllHooksToHttpClient(): void;
+  removeAllHooksFromHttpClient(): void;
+  removeHookFromHttpClient(hook: BeforeRequestHook | RequestErrorHook | ResponseHook): void;
+  private imports;
+}
+//#endregion
+export { MistralAI, MistralAICallOptions, MistralAIInput };
+//# sourceMappingURL=llms.d.ts.map