@ai-sdk/mistral 4.0.54 → 4.0.55

package/dist/index.js

@@ -1,1395 +1,1102 @@
-// src/mistral-provider.ts
-import {
-  NoSuchModelError
-} from "@ai-sdk/provider";
-import {
-  loadApiKey,
-  withoutTrailingSlash,
-  withUserAgentSuffix
-} from "@ai-sdk/provider-utils";
-
-// src/mistral-chat-language-model.ts
-import {
-  combineHeaders,
-  createEventSourceResponseHandler,
-  createJsonResponseHandler,
-  generateId,
-  injectJsonInstructionIntoMessages,
-  isCustomReasoning,
-  mapReasoningToProviderEffort,
-  parseProviderOptions,
-  postJsonToApi,
-  serializeModelOptions,
-  StreamingToolCallTracker,
-  WORKFLOW_SERIALIZE,
-  WORKFLOW_DESERIALIZE
-} from "@ai-sdk/provider-utils";
-import { z as z4 } from "zod/v4";
-
-// src/convert-mistral-usage.ts
-import { createNullLanguageModelUsage } from "@ai-sdk/provider-utils";
+import { InvalidArgumentError, NoSuchModelError, TooManyEmbeddingValuesForCallError, UnsupportedFunctionalityError } from "@ai-sdk/provider";
+import { StreamingToolCallTracker, WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE, combineHeaders, convertBase64ToUint8Array, convertToBase64, createEventSourceResponseHandler, createJsonErrorResponseHandler, createJsonResponseHandler, createLanguageModelResponseMetadata as getResponseMetadata, createNullLanguageModelUsage, generateId, getTopLevelMediaType, injectJsonInstructionIntoMessages, isCustomReasoning, lazySchema, loadApiKey, mapReasoningToProviderEffort, mediaTypeToExtension, parseProviderOptions, postFormDataToApi, postJsonToApi, postToApi, resolveFullMediaType, serializeModelOptions, withUserAgentSuffix, withoutTrailingSlash, zodSchema } from "@ai-sdk/provider-utils";
 import { z } from "zod/v4";
-var mistralPromptTokensDetailsSchema = z.object({
-  messages: z.array(z.json()).nullish(),
-  cached_tokens: z.number().nullish(),
-  audio_tokens: z.number().nullish()
+//#region src/convert-mistral-usage.ts
+const mistralPromptTokensDetailsSchema = z.object({
+	messages: z.array(z.json()).nullish(),
+	cached_tokens: z.number().nullish(),
+	audio_tokens: z.number().nullish()
 }).catchall(z.json());
-var mistralCompletionTokensDetailsSchema = z.object({
-  reasoning_tokens: z.number().nullish()
-}).catchall(z.json());
-var mistralUsageSchema = z.object({
-  prompt_tokens: z.number(),
-  completion_tokens: z.number(),
-  total_tokens: z.number(),
-  prompt_audio_seconds: z.number().nullish(),
-  request_count: z.number().nullish(),
-  service_tier: z.string().nullish(),
-  num_cached_tokens: z.number().nullish(),
-  prompt_tokens_details: mistralPromptTokensDetailsSchema.nullish(),
-  prompt_token_details: mistralPromptTokensDetailsSchema.nullish(),
-  completion_tokens_details: mistralCompletionTokensDetailsSchema.nullish()
+const mistralCompletionTokensDetailsSchema = z.object({ reasoning_tokens: z.number().nullish() }).catchall(z.json());
+const mistralUsageSchema = z.object({
+	prompt_tokens: z.number(),
+	completion_tokens: z.number(),
+	total_tokens: z.number(),
+	prompt_audio_seconds: z.number().nullish(),
+	request_count: z.number().nullish(),
+	service_tier: z.string().nullish(),
+	num_cached_tokens: z.number().nullish(),
+	prompt_tokens_details: mistralPromptTokensDetailsSchema.nullish(),
+	prompt_token_details: mistralPromptTokensDetailsSchema.nullish(),
+	completion_tokens_details: mistralCompletionTokensDetailsSchema.nullish()
 }).catchall(z.json());
 function convertMistralUsage(usage) {
-  if (usage == null) {
-    return createNullLanguageModelUsage();
-  }
-  const promptTokens = usage.prompt_tokens;
-  const completionTokens = usage.completion_tokens;
-  const cacheReadTokens = usage.num_cached_tokens ?? usage.prompt_tokens_details?.cached_tokens ?? usage.prompt_token_details?.cached_tokens ?? 0;
-  return {
-    inputTokens: {
-      total: promptTokens,
-      noCache: promptTokens - cacheReadTokens,
-      cacheRead: cacheReadTokens || void 0,
-      cacheWrite: void 0
-    },
-    outputTokens: {
-      total: completionTokens,
-      text: completionTokens,
-      reasoning: void 0
-    },
-    raw: usage
-  };
+	if (usage == null) return createNullLanguageModelUsage();
+	const promptTokens = usage.prompt_tokens;
+	const completionTokens = usage.completion_tokens;
+	const cacheReadTokens = usage.num_cached_tokens ?? usage.prompt_tokens_details?.cached_tokens ?? usage.prompt_token_details?.cached_tokens ?? 0;
+	return {
+		inputTokens: {
+			total: promptTokens,
+			noCache: promptTokens - cacheReadTokens,
+			cacheRead: cacheReadTokens || void 0,
+			cacheWrite: void 0
+		},
+		outputTokens: {
+			total: completionTokens,
+			text: completionTokens,
+			reasoning: void 0
+		},
+		raw: usage
+	};
 }
-
-// src/convert-to-mistral-chat-messages.ts
-import {
-  UnsupportedFunctionalityError
-} from "@ai-sdk/provider";
-import {
-  convertToBase64,
-  getTopLevelMediaType,
-  resolveFullMediaType
-} from "@ai-sdk/provider-utils";
+//#endregion
+//#region src/convert-to-mistral-chat-messages.ts
 function formatFileUrl({ part }) {
-  if (part.data.type === "url") {
-    return part.data.url.toString();
-  }
-  if (part.data.type === "data") {
-    return `data:${resolveFullMediaType({ part })};base64,${convertToBase64(part.data.data)}`;
-  }
-  throw new UnsupportedFunctionalityError({
-    functionality: `file part data type ${part.data.type}`
-  });
+	if (part.data.type === "url") return part.data.url.toString();
+	if (part.data.type === "data") return `data:${resolveFullMediaType({ part })};base64,${convertToBase64(part.data.data)}`;
+	throw new UnsupportedFunctionalityError({ functionality: `file part data type ${part.data.type}` });
 }
 function convertToMistralChatMessages(prompt) {
-  const messages = [];
-  for (let i = 0; i < prompt.length; i++) {
-    const { role, content } = prompt[i];
-    const isLastMessage = i === prompt.length - 1;
-    switch (role) {
-      case "system": {
-        messages.push({ role: "system", content });
-        break;
-      }
-      case "user": {
-        messages.push({
-          role: "user",
-          content: content.map((part) => {
-            switch (part.type) {
-              case "text": {
-                return { type: "text", text: part.text };
-              }
-              case "file": {
-                switch (part.data.type) {
-                  case "reference": {
-                    throw new UnsupportedFunctionalityError({
-                      functionality: "file parts with provider references"
-                    });
-                  }
-                  case "text": {
-                    throw new UnsupportedFunctionalityError({
-                      functionality: "text file parts"
-                    });
-                  }
-                  case "url":
-                  case "data": {
-                    const topLevel = getTopLevelMediaType(part.mediaType);
-                    if (topLevel === "image") {
-                      return {
-                        type: "image_url",
-                        image_url: formatFileUrl({ part })
-                      };
-                    } else {
-                      if (part.data.type === "data") {
-                        const fullMediaType = resolveFullMediaType({ part });
-                        if (fullMediaType !== "application/pdf") {
-                          throw new UnsupportedFunctionalityError({
-                            functionality: "Only images and PDF file parts are supported"
-                          });
-                        }
-                      } else if (part.mediaType !== "application/pdf") {
-                        throw new UnsupportedFunctionalityError({
-                          functionality: "Only images and PDF file parts are supported"
-                        });
-                      }
-                      return {
-                        type: "document_url",
-                        document_url: formatFileUrl({ part })
-                      };
-                    }
-                  }
-                }
-              }
-            }
-          })
-        });
-        break;
-      }
-      case "assistant": {
-        let text = "";
-        let hasReasoning = false;
-        const contentParts = [];
-        const toolCalls = [];
-        for (const part of content) {
-          switch (part.type) {
-            case "text": {
-              text += part.text;
-              contentParts.push({ type: "text", text: part.text });
-              break;
-            }
-            case "tool-call": {
-              toolCalls.push({
-                id: part.toolCallId,
-                type: "function",
-                function: {
-                  name: part.toolName,
-                  arguments: JSON.stringify(part.input)
-                }
-              });
-              break;
-            }
-            case "reasoning": {
-              hasReasoning = true;
-              contentParts.push({
-                type: "thinking",
-                thinking: [{ type: "text", text: part.text }],
-                closed: true
-              });
-              break;
-            }
-            default: {
-              throw new Error(
-                `Unsupported content type in assistant message: ${part.type}`
-              );
-            }
-          }
-        }
-        messages.push({
-          role: "assistant",
-          content: hasReasoning ? contentParts : text,
-          prefix: isLastMessage ? true : void 0,
-          tool_calls: toolCalls.length > 0 ? toolCalls : void 0
-        });
-        break;
-      }
-      case "tool": {
-        for (const toolResponse of content) {
-          if (toolResponse.type === "tool-approval-response") {
-            continue;
-          }
-          const output = toolResponse.output;
-          let contentValue;
-          switch (output.type) {
-            case "text":
-            case "error-text":
-              contentValue = output.value;
-              break;
-            case "execution-denied":
-              contentValue = output.reason ?? "Tool call execution denied.";
-              break;
-            case "content":
-            case "json":
-            case "error-json":
-              contentValue = JSON.stringify(output.value);
-              break;
-          }
-          messages.push({
-            role: "tool",
-            name: toolResponse.toolName,
-            tool_call_id: toolResponse.toolCallId,
-            content: contentValue
-          });
-        }
-        break;
-      }
-      default: {
-        const _exhaustiveCheck = role;
-        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
-      }
-    }
-  }
-  return messages;
+	const messages = [];
+	for (let i = 0; i < prompt.length; i++) {
+		const { role, content } = prompt[i];
+		const isLastMessage = i === prompt.length - 1;
+		switch (role) {
+			case "system":
+				messages.push({
+					role: "system",
+					content
+				});
+				break;
+			case "user":
+				messages.push({
+					role: "user",
+					content: content.map((part) => {
+						switch (part.type) {
+							case "text": return {
+								type: "text",
+								text: part.text
+							};
+							case "file": switch (part.data.type) {
+								case "reference": throw new UnsupportedFunctionalityError({ functionality: "file parts with provider references" });
+								case "text": throw new UnsupportedFunctionalityError({ functionality: "text file parts" });
+								case "url":
+								case "data": if (getTopLevelMediaType(part.mediaType) === "image") return {
+									type: "image_url",
+									image_url: formatFileUrl({ part })
+								};
+								else {
+									if (part.data.type === "data") {
+										if (resolveFullMediaType({ part }) !== "application/pdf") throw new UnsupportedFunctionalityError({ functionality: "Only images and PDF file parts are supported" });
+									} else if (part.mediaType !== "application/pdf") throw new UnsupportedFunctionalityError({ functionality: "Only images and PDF file parts are supported" });
+									return {
+										type: "document_url",
+										document_url: formatFileUrl({ part })
+									};
+								}
+							}
+						}
+					})
+				});
+				break;
+			case "assistant": {
+				let text = "";
+				let hasReasoning = false;
+				const contentParts = [];
+				const toolCalls = [];
+				for (const part of content) switch (part.type) {
+					case "text":
+						text += part.text;
+						contentParts.push({
+							type: "text",
+							text: part.text
+						});
+						break;
+					case "tool-call":
+						toolCalls.push({
+							id: part.toolCallId,
+							type: "function",
+							function: {
+								name: part.toolName,
+								arguments: JSON.stringify(part.input)
+							}
+						});
+						break;
+					case "reasoning":
+						hasReasoning = true;
+						contentParts.push({
+							type: "thinking",
+							thinking: [{
+								type: "text",
+								text: part.text
+							}],
+							closed: true
+						});
+						break;
+					default: throw new Error(`Unsupported content type in assistant message: ${part.type}`);
+				}
+				messages.push({
+					role: "assistant",
+					content: hasReasoning ? contentParts : text,
+					prefix: isLastMessage ? true : void 0,
+					tool_calls: toolCalls.length > 0 ? toolCalls : void 0
+				});
+				break;
+			}
+			case "tool":
+				for (const toolResponse of content) {
+					if (toolResponse.type === "tool-approval-response") continue;
+					const output = toolResponse.output;
+					let contentValue;
+					switch (output.type) {
+						case "text":
+						case "error-text":
+							contentValue = output.value;
+							break;
+						case "execution-denied":
+							contentValue = output.reason ?? "Tool call execution denied.";
+							break;
+						case "content":
+						case "json":
+						case "error-json": contentValue = JSON.stringify(output.value);
+					}
+					messages.push({
+						role: "tool",
+						name: toolResponse.toolName,
+						tool_call_id: toolResponse.toolCallId,
+						content: contentValue
+					});
+				}
+				break;
+			default: throw new Error(`Unsupported role: ${role}`);
+		}
+	}
+	return messages;
 }
-
-// src/get-response-metadata.ts
-import { createLanguageModelResponseMetadata } from "@ai-sdk/provider-utils";
-
-// src/map-mistral-finish-reason.ts
+//#endregion
+//#region src/map-mistral-finish-reason.ts
 function mapMistralFinishReason(finishReason) {
-  switch (finishReason) {
-    case "stop":
-      return "stop";
-    case "length":
-    case "model_length":
-      return "length";
-    case "tool_calls":
-      return "tool-calls";
-    default:
-      return "other";
-  }
+	switch (finishReason) {
+		case "stop": return "stop";
+		case "length":
+		case "model_length": return "length";
+		case "tool_calls": return "tool-calls";
+		case "error": return "error";
+		default: return "other";
+	}
 }
-
-// src/mistral-chat-language-model-options.ts
-import { z as z2 } from "zod/v4";
-var mistralLanguageModelChatOptions = z2.object({
-  /**
-   * Whether to inject a safety prompt before all conversations.
-   *
-   * Defaults to `false`.
-   */
-  safePrompt: z2.boolean().optional(),
-  documentImageLimit: z2.number().optional(),
-  documentPageLimit: z2.number().optional(),
-  /**
-   * Whether to use structured outputs.
-   *
-   * @default true
-   */
-  structuredOutputs: z2.boolean().optional(),
-  /**
-   * Whether to use strict JSON schema validation.
-   *
-   * @default false
-   */
-  strictJsonSchema: z2.boolean().optional(),
-  /**
-   * Whether to enable parallel function calling during tool use.
-   * When set to false, the model will use at most one tool per response.
-   *
-   * @default true
-   */
-  parallelToolCalls: z2.boolean().optional(),
-  /**
-   * A stable identifier used to route requests with shared prompt prefixes to
-   * the same cache.
-   */
-  promptCacheKey: z2.string().optional(),
-  /**
-   * Controls the reasoning effort for models that support adjustable reasoning.
-   *
-   * - `'high'`: Enable reasoning
-   * - `'none'`: Disable reasoning
-   */
-  reasoningEffort: z2.enum(["high", "none"]).optional()
+//#endregion
+//#region src/mistral-chat-language-model-options.ts
+const mistralLanguageModelChatOptions = z.object({
+	/**
+	* Whether to inject a safety prompt before all conversations.
+	*
+	* Defaults to `false`.
+	*/
+	safePrompt: z.boolean().optional(),
+	documentImageLimit: z.number().optional(),
+	documentPageLimit: z.number().optional(),
+	/**
+	* Whether to use structured outputs.
+	*
+	* @default true
+	*/
+	structuredOutputs: z.boolean().optional(),
+	/**
+	* Whether to use strict JSON schema validation.
+	*
+	* @default false
+	*/
+	strictJsonSchema: z.boolean().optional(),
+	/**
+	* Whether to enable parallel function calling during tool use.
+	* When set to false, the model will use at most one tool per response.
+	*
+	* @default true
+	*/
+	parallelToolCalls: z.boolean().optional(),
+	/**
+	* A stable identifier used to route requests with shared prompt prefixes to
+	* the same cache.
+	*/
+	promptCacheKey: z.string().optional(),
+	/**
+	* Controls the reasoning effort for models that support adjustable reasoning.
+	*
+	* - `'high'`: Enable reasoning
+	* - `'none'`: Disable reasoning
+	*/
+	reasoningEffort: z.enum(["high", "none"]).optional()
 });
-
-// src/mistral-error.ts
-import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
-import { z as z3 } from "zod/v4";
-var mistralErrorDataSchema = z3.object({
-  object: z3.literal("error"),
-  message: z3.string(),
-  type: z3.string(),
-  param: z3.string().nullable(),
-  code: z3.string().nullable()
+//#endregion
+//#region src/mistral-error.ts
+const mistralErrorDataSchema = z.object({
+	object: z.literal("error"),
+	message: z.string(),
+	type: z.string(),
+	param: z.string().nullable(),
+	code: z.string().nullable()
 });
-var mistralFailedResponseHandler = createJsonErrorResponseHandler({
-  errorSchema: mistralErrorDataSchema,
-  errorToMessage: (data) => data.message
+const mistralFailedResponseHandler = createJsonErrorResponseHandler({
+	errorSchema: mistralErrorDataSchema,
+	errorToMessage: (data) => data.message
 });
-
-// src/mistral-prepare-tools.ts
-import {
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
-} from "@ai-sdk/provider";
-function prepareTools({
-  tools,
-  toolChoice
-}) {
-  tools = tools?.length ? tools : void 0;
-  const toolWarnings = [];
-  if (tools == null) {
-    return { tools: void 0, toolChoice: void 0, toolWarnings };
-  }
-  const mistralTools = [];
-  for (const tool of tools) {
-    if (tool.type === "provider") {
-      toolWarnings.push({
-        type: "unsupported",
-        feature: `provider-defined tool ${tool.id}`
-      });
-    } else {
-      mistralTools.push({
-        type: "function",
-        function: {
-          name: tool.name,
-          description: tool.description,
-          parameters: tool.inputSchema,
-          ...tool.strict != null ? { strict: tool.strict } : {}
-        }
-      });
-    }
-  }
-  if (toolChoice == null) {
-    return { tools: mistralTools, toolChoice: void 0, toolWarnings };
-  }
-  const type = toolChoice.type;
-  switch (type) {
-    case "auto":
-    case "none":
-      return { tools: mistralTools, toolChoice: type, toolWarnings };
-    case "required":
-      return { tools: mistralTools, toolChoice: "any", toolWarnings };
-    // mistral does not support tool mode directly,
-    // so we filter the tools and force the tool choice through 'any'
-    case "tool":
-      return {
-        tools: mistralTools.filter(
-          (tool) => tool.function.name === toolChoice.toolName
-        ),
-        toolChoice: "any",
-        toolWarnings
-      };
-    default: {
-      const _exhaustiveCheck = type;
-      throw new UnsupportedFunctionalityError2({
-        functionality: `tool choice type: ${_exhaustiveCheck}`
-      });
-    }
-  }
+//#endregion
+//#region src/mistral-prepare-tools.ts
+function prepareTools({ tools, toolChoice }) {
+	tools = tools?.length ? tools : void 0;
+	const toolWarnings = [];
+	if (tools == null) return {
+		tools: void 0,
+		toolChoice: void 0,
+		toolWarnings
+	};
+	const mistralTools = [];
+	for (const tool of tools) if (tool.type === "provider") toolWarnings.push({
+		type: "unsupported",
+		feature: `provider-defined tool ${tool.id}`
+	});
+	else mistralTools.push({
+		type: "function",
+		function: {
+			name: tool.name,
+			description: tool.description,
+			parameters: tool.inputSchema,
+			...tool.strict != null ? { strict: tool.strict } : {}
+		}
+	});
+	if (toolChoice == null) return {
+		tools: mistralTools,
+		toolChoice: void 0,
+		toolWarnings
+	};
+	const type = toolChoice.type;
+	switch (type) {
+		case "auto":
+		case "none": return {
+			tools: mistralTools,
+			toolChoice: type,
+			toolWarnings
+		};
+		case "required": return {
+			tools: mistralTools,
+			toolChoice: "any",
+			toolWarnings
+		};
+		case "tool": return {
+			tools: mistralTools.filter((tool) => tool.function.name === toolChoice.toolName),
+			toolChoice: "any",
+			toolWarnings
+		};
+		default: throw new UnsupportedFunctionalityError({ functionality: `tool choice type: ${type}` });
+	}
 }
-
-// src/mistral-chat-language-model.ts
-var reasoningEffortModelIds = /* @__PURE__ */ new Set([
-  "glm-5-2",
-  "labs-leanstral-1-5",
-  "labs-leanstral-1-5-1",
-  "magistral-medium-latest",
-  "magistral-small-latest",
-  "mistral-medium",
-  "mistral-medium-2604",
-  "mistral-medium-3",
-  "mistral-medium-3-5",
-  "mistral-medium-3.5",
-  "mistral-medium-latest",
-  "mistral-small-2603",
-  "mistral-small-latest",
-  "mistral-vibe-cli-fast",
-  "mistral-vibe-cli-latest",
-  "mistral-vibe-cli-with-tools",
-  "zai-glm-5-2"
+//#endregion
+//#region src/mistral-chat-language-model.ts
+const reasoningEffortModelIds = /* @__PURE__ */ new Set([
+	"glm-5-2",
+	"labs-leanstral-1-5",
+	"labs-leanstral-1-5-1",
+	"magistral-medium-latest",
+	"magistral-small-latest",
+	"mistral-medium",
+	"mistral-medium-2604",
+	"mistral-medium-3",
+	"mistral-medium-3-5",
+	"mistral-medium-3.5",
+	"mistral-medium-latest",
+	"mistral-small-2603",
+	"mistral-small-latest",
+	"mistral-vibe-cli-fast",
+	"mistral-vibe-cli-latest",
+	"mistral-vibe-cli-with-tools",
+	"zai-glm-5-2"
 ]);
-var MistralChatLanguageModel = class _MistralChatLanguageModel {
-  constructor(modelId, config) {
-    this.specificationVersion = "v4";
-    this.supportedUrls = {
-      "application/pdf": [/^https:\/\/.*$/]
-    };
-    this.modelId = modelId;
-    this.config = config;
-    this.generateId = config.generateId ?? generateId;
-  }
-  static [WORKFLOW_SERIALIZE](model) {
-    return serializeModelOptions({
-      modelId: model.modelId,
-      config: model.config
-    });
-  }
-  static [WORKFLOW_DESERIALIZE](options) {
-    return new _MistralChatLanguageModel(options.modelId, options.config);
-  }
-  get provider() {
-    return this.config.provider;
-  }
-  async getArgs({
-    prompt,
-    maxOutputTokens,
-    temperature,
-    topP,
-    topK,
-    frequencyPenalty,
-    presencePenalty,
-    reasoning,
-    stopSequences,
-    responseFormat,
-    seed,
-    providerOptions,
-    tools,
-    toolChoice
-  }) {
-    const warnings = [];
-    const options = await parseProviderOptions({
-      provider: "mistral",
-      providerOptions,
-      schema: mistralLanguageModelChatOptions
-    }) ?? {};
-    if (topK != null) {
-      warnings.push({ type: "unsupported", feature: "topK" });
-    }
-    const supportsReasoningEffort = reasoningEffortModelIds.has(this.modelId);
-    let resolvedReasoningEffort;
-    if (supportsReasoningEffort) {
-      resolvedReasoningEffort = options.reasoningEffort ?? (isCustomReasoning(reasoning) ? reasoning === "none" ? "none" : mapReasoningToProviderEffort({
-        reasoning,
-        effortMap: {
-          minimal: "high",
-          low: "high",
-          medium: "high",
-          high: "high",
-          xhigh: "high"
-        },
-        warnings
-      }) : void 0);
-    } else if (isCustomReasoning(reasoning)) {
-      warnings.push({
-        type: "unsupported",
-        feature: "reasoning",
-        details: "This model does not support reasoning configuration."
-      });
-    }
-    const structuredOutputs = options.structuredOutputs ?? true;
-    const strictJsonSchema = options.strictJsonSchema ?? false;
-    if (responseFormat?.type === "json" && !responseFormat?.schema) {
-      prompt = injectJsonInstructionIntoMessages({
-        messages: prompt,
-        schema: responseFormat.schema
-      });
-    }
-    const baseArgs = {
-      // model id:
-      model: this.modelId,
-      // model specific settings:
-      safe_prompt: options.safePrompt,
-      // standardized settings:
-      max_tokens: maxOutputTokens,
-      temperature,
-      top_p: topP,
-      ...frequencyPenalty != null ? { frequency_penalty: frequencyPenalty } : {},
-      ...presencePenalty != null ? { presence_penalty: presencePenalty } : {},
-      stop: stopSequences,
-      random_seed: seed,
-      reasoning_effort: resolvedReasoningEffort,
-      // response format:
-      response_format: responseFormat?.type === "json" ? structuredOutputs && responseFormat?.schema != null ? {
-        type: "json_schema",
-        json_schema: {
-          schema: responseFormat.schema,
-          strict: strictJsonSchema,
-          name: responseFormat.name ?? "response",
-          description: responseFormat.description
-        }
-      } : { type: "json_object" } : void 0,
-      // mistral-specific provider options:
-      document_image_limit: options.documentImageLimit,
-      document_page_limit: options.documentPageLimit,
-      ...options.promptCacheKey !== void 0 ? { prompt_cache_key: options.promptCacheKey } : {},
-      // messages:
-      messages: convertToMistralChatMessages(prompt)
-    };
-    const {
-      tools: mistralTools,
-      toolChoice: mistralToolChoice,
-      toolWarnings
-    } = prepareTools({
-      tools,
-      toolChoice
-    });
-    return {
-      args: {
-        ...baseArgs,
-        tools: mistralTools,
-        tool_choice: mistralToolChoice,
-        ...mistralTools != null && options.parallelToolCalls !== void 0 ? { parallel_tool_calls: options.parallelToolCalls } : {}
-      },
-      warnings: [...warnings, ...toolWarnings]
-    };
-  }
-  async doGenerate(options) {
-    const { args: body, warnings } = await this.getArgs(options);
-    const {
-      responseHeaders,
-      value: response,
-      rawValue: rawResponse
-    } = await postJsonToApi({
-      url: `${this.config.baseURL}/chat/completions`,
-      headers: combineHeaders(this.config.headers?.(), options.headers),
-      body,
-      failedResponseHandler: mistralFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler(
-        mistralChatResponseSchema
-      ),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    const choice = response.choices[0];
-    const content = [];
-    if (choice.message.content != null && Array.isArray(choice.message.content)) {
-      for (const part of choice.message.content) {
-        if (part.type === "thinking") {
-          const reasoningText = extractReasoningContent(part.thinking);
-          if (reasoningText.length > 0) {
-            content.push({ type: "reasoning", text: reasoningText });
-          }
-        } else if (part.type === "text") {
-          if (part.text.length > 0) {
-            content.push({ type: "text", text: part.text });
-          }
-        }
-      }
-    } else {
-      const text = extractTextContent(choice.message.content);
-      if (text != null && text.length > 0) {
-        content.push({ type: "text", text });
-      }
-    }
-    if (choice.message.tool_calls != null) {
-      for (const toolCall of choice.message.tool_calls) {
-        content.push({
-          type: "tool-call",
-          toolCallId: toolCall.id,
-          toolName: toolCall.function.name,
-          input: toolCall.function.arguments
-        });
-      }
-    }
-    return {
-      content,
-      finishReason: {
-        unified: mapMistralFinishReason(choice.finish_reason),
-        raw: choice.finish_reason ?? void 0
-      },
-      usage: convertMistralUsage(response.usage),
-      request: { body },
-      response: {
-        ...createLanguageModelResponseMetadata(response),
-        headers: responseHeaders,
-        body: rawResponse
-      },
-      warnings
-    };
-  }
-  async doStream(options) {
-    const { args, warnings } = await this.getArgs(options);
-    const body = { ...args, stream: true };
-    const { responseHeaders, value: response } = await postJsonToApi({
-      url: `${this.config.baseURL}/chat/completions`,
-      headers: combineHeaders(this.config.headers?.(), options.headers),
-      body,
-      failedResponseHandler: mistralFailedResponseHandler,
-      successfulResponseHandler: createEventSourceResponseHandler(
-        mistralChatChunkSchema
-      ),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    let finishReason = {
-      unified: "other",
-      raw: void 0
-    };
-    let usage = void 0;
-    let isFirstChunk = true;
-    let activeText = false;
-    let activeReasoningId = null;
-    let toolCallTracker;
-    const generateId2 = this.generateId;
-    return {
-      stream: response.pipeThrough(
-        new TransformStream({
-          start(controller) {
-            toolCallTracker = new StreamingToolCallTracker(controller, {
-              generateId: generateId2
-            });
-            controller.enqueue({ type: "stream-start", warnings });
-          },
-          transform(chunk, controller) {
-            if (options.includeRawChunks) {
-              controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
-            }
-            if (!chunk.success) {
-              controller.enqueue({ type: "error", error: chunk.error });
-              return;
-            }
-            const value = chunk.value;
-            if (isFirstChunk) {
-              isFirstChunk = false;
-              controller.enqueue({
-                type: "response-metadata",
-                ...createLanguageModelResponseMetadata(value)
-              });
-            }
-            if (value.usage != null) {
-              usage = value.usage;
-            }
-            const choice = value.choices[0];
-            const delta = choice.delta;
-            const textContent = extractTextContent(delta.content);
-            if (delta.content != null && Array.isArray(delta.content)) {
-              for (const part of delta.content) {
-                if (part.type === "thinking") {
-                  const reasoningDelta = extractReasoningContent(part.thinking);
-                  if (reasoningDelta.length > 0) {
-                    if (activeReasoningId == null) {
-                      if (activeText) {
-                        controller.enqueue({ type: "text-end", id: "0" });
-                        activeText = false;
-                      }
-                      activeReasoningId = generateId2();
-                      controller.enqueue({
-                        type: "reasoning-start",
-                        id: activeReasoningId
-                      });
-                    }
-                    controller.enqueue({
-                      type: "reasoning-delta",
-                      id: activeReasoningId,
-                      delta: reasoningDelta
-                    });
-                  }
-                }
-              }
-            }
-            if (textContent != null && textContent.length > 0) {
-              if (!activeText) {
-                if (activeReasoningId != null) {
-                  controller.enqueue({
-                    type: "reasoning-end",
-                    id: activeReasoningId
-                  });
-                  activeReasoningId = null;
-                }
-                controller.enqueue({ type: "text-start", id: "0" });
-                activeText = true;
-              }
-              controller.enqueue({
-                type: "text-delta",
-                id: "0",
-                delta: textContent
-              });
-            }
-            if (delta?.tool_calls != null) {
-              for (const toolCall of delta.tool_calls) {
-                toolCallTracker.processDelta(toolCall);
-              }
-            }
-            if (choice.finish_reason != null) {
-              finishReason = {
-                unified: mapMistralFinishReason(choice.finish_reason),
-                raw: choice.finish_reason
-              };
-            }
-          },
-          flush(controller) {
-            if (activeReasoningId != null) {
-              controller.enqueue({
-                type: "reasoning-end",
-                id: activeReasoningId
-              });
-            }
-            if (activeText) {
-              controller.enqueue({ type: "text-end", id: "0" });
-            }
-            toolCallTracker.flush();
-            controller.enqueue({
-              type: "finish",
-              finishReason,
-              usage: convertMistralUsage(usage)
-            });
-          }
-        })
-      ),
-      request: { body },
-      response: { headers: responseHeaders }
-    };
-  }
+var MistralChatLanguageModel = class MistralChatLanguageModel {
+	static [WORKFLOW_SERIALIZE](model) {
+		return serializeModelOptions({
+			modelId: model.modelId,
+			config: model.config
+		});
+	}
+	static [WORKFLOW_DESERIALIZE](options) {
+		return new MistralChatLanguageModel(options.modelId, options.config);
+	}
+	constructor(modelId, config) {
+		this.specificationVersion = "v4";
+		this.supportedUrls = { "application/pdf": [/^https:\/\/.*$/] };
+		this.modelId = modelId;
+		this.config = config;
+		this.generateId = config.generateId ?? generateId;
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	async getArgs({ prompt, maxOutputTokens, temperature, topP, topK, frequencyPenalty, presencePenalty, reasoning, stopSequences, responseFormat, seed, providerOptions, tools, toolChoice }) {
+		const warnings = [];
+		const options = await parseProviderOptions({
+			provider: "mistral",
+			providerOptions,
+			schema: mistralLanguageModelChatOptions
+		}) ?? {};
+		if (topK != null) warnings.push({
+			type: "unsupported",
+			feature: "topK"
+		});
+		const supportsReasoningEffort = reasoningEffortModelIds.has(this.modelId);
+		let resolvedReasoningEffort;
+		if (supportsReasoningEffort) resolvedReasoningEffort = options.reasoningEffort ?? (isCustomReasoning(reasoning) ? reasoning === "none" ? "none" : mapReasoningToProviderEffort({
+			reasoning,
+			effortMap: {
+				minimal: "high",
+				low: "high",
+				medium: "high",
+				high: "high",
+				xhigh: "high"
+			},
+			warnings
+		}) : void 0);
+		else if (isCustomReasoning(reasoning)) warnings.push({
+			type: "unsupported",
+			feature: "reasoning",
+			details: "This model does not support reasoning configuration."
+		});
+		const structuredOutputs = options.structuredOutputs ?? true;
+		const strictJsonSchema = options.strictJsonSchema ?? false;
+		if (responseFormat?.type === "json" && (!structuredOutputs || responseFormat.schema == null)) prompt = injectJsonInstructionIntoMessages({
+			messages: prompt,
+			schema: responseFormat.schema
+		});
+		const baseArgs = {
+			model: this.modelId,
+			safe_prompt: options.safePrompt,
+			max_tokens: maxOutputTokens,
+			temperature,
+			top_p: topP,
+			...frequencyPenalty != null ? { frequency_penalty: frequencyPenalty } : {},
+			...presencePenalty != null ? { presence_penalty: presencePenalty } : {},
+			stop: stopSequences,
+			random_seed: seed,
+			reasoning_effort: resolvedReasoningEffort,
+			response_format: responseFormat?.type === "json" ? structuredOutputs && responseFormat?.schema != null ? {
+				type: "json_schema",
+				json_schema: {
+					schema: responseFormat.schema,
+					strict: strictJsonSchema,
+					name: responseFormat.name ?? "response",
+					description: responseFormat.description
+				}
+			} : { type: "json_object" } : void 0,
+			document_image_limit: options.documentImageLimit,
+			document_page_limit: options.documentPageLimit,
+			...options.promptCacheKey !== void 0 ? { prompt_cache_key: options.promptCacheKey } : {},
+			messages: convertToMistralChatMessages(prompt)
+		};
+		const { tools: mistralTools, toolChoice: mistralToolChoice, toolWarnings } = prepareTools({
+			tools,
+			toolChoice
+		});
+		return {
+			args: {
+				...baseArgs,
+				tools: mistralTools,
+				tool_choice: mistralToolChoice,
+				...mistralTools != null && options.parallelToolCalls !== void 0 ? { parallel_tool_calls: options.parallelToolCalls } : {}
+			},
+			warnings: [...warnings, ...toolWarnings]
+		};
+	}
+	async doGenerate(options) {
+		const { args: body, warnings } = await this.getArgs(options);
+		const { responseHeaders, value: response, rawValue: rawResponse } = await postJsonToApi({
+			url: `${this.config.baseURL}/chat/completions`,
+			headers: combineHeaders(this.config.headers?.(), options.headers),
+			body,
+			failedResponseHandler: mistralFailedResponseHandler,
+			successfulResponseHandler: createJsonResponseHandler(mistralChatResponseSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		const choice = response.choices[0];
+		const content = [];
+		if (choice.message.content != null && Array.isArray(choice.message.content)) {
+			for (const part of choice.message.content) if (part.type === "thinking") {
+				const reasoningText = extractReasoningContent(part.thinking);
+				if (reasoningText.length > 0) content.push({
+					type: "reasoning",
+					text: reasoningText
+				});
+			} else if (part.type === "text") {
+				if (part.text.length > 0) content.push({
+					type: "text",
+					text: part.text
+				});
+			}
+		} else {
+			const text = extractTextContent(choice.message.content);
+			if (text != null && text.length > 0) content.push({
+				type: "text",
+				text
+			});
+		}
+		if (choice.message.tool_calls != null) for (const toolCall of choice.message.tool_calls) content.push({
+			type: "tool-call",
+			toolCallId: toolCall.id,
+			toolName: toolCall.function.name,
+			input: toolCall.function.arguments
+		});
+		return {
+			content,
+			finishReason: {
+				unified: mapMistralFinishReason(choice.finish_reason),
+				raw: choice.finish_reason ?? void 0
+			},
+			usage: convertMistralUsage(response.usage),
+			request: { body },
+			response: {
+				...getResponseMetadata(response),
+				headers: responseHeaders,
+				body: rawResponse
+			},
+			warnings
+		};
+	}
+	async doStream(options) {
+		const { args, warnings } = await this.getArgs(options);
+		const body = {
+			...args,
+			stream: true
+		};
+		const { responseHeaders, value: response } = await postJsonToApi({
+			url: `${this.config.baseURL}/chat/completions`,
+			headers: combineHeaders(this.config.headers?.(), options.headers),
+			body,
+			failedResponseHandler: mistralFailedResponseHandler,
+			successfulResponseHandler: createEventSourceResponseHandler(mistralChatChunkSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		let finishReason = {
+			unified: "other",
+			raw: void 0
+		};
+		let usage = void 0;
+		let isFirstChunk = true;
+		let activeText = false;
+		let activeReasoningId = null;
+		let toolCallTracker;
+		const generateId = this.generateId;
+		return {
+			stream: response.pipeThrough(new TransformStream({
+				start(controller) {
+					toolCallTracker = new StreamingToolCallTracker(controller, { generateId });
+					controller.enqueue({
+						type: "stream-start",
+						warnings
+					});
+				},
+				transform(chunk, controller) {
+					if (options.includeRawChunks) controller.enqueue({
+						type: "raw",
+						rawValue: chunk.rawValue
+					});
+					if (!chunk.success) {
+						controller.enqueue({
+							type: "error",
+							error: chunk.error
+						});
+						return;
+					}
+					const value = chunk.value;
+					if (isFirstChunk) {
+						isFirstChunk = false;
+						controller.enqueue({
+							type: "response-metadata",
+							...getResponseMetadata(value)
+						});
+					}
+					if (value.usage != null) usage = value.usage;
+					const choice = value.choices[0];
+					const delta = choice.delta;
+					const textContent = extractTextContent(delta.content);
+					if (delta.content != null && Array.isArray(delta.content)) {
+						for (const part of delta.content) if (part.type === "thinking") {
+							const reasoningDelta = extractReasoningContent(part.thinking);
+							if (reasoningDelta.length > 0) {
+								if (activeReasoningId == null) {
+									if (activeText) {
+										controller.enqueue({
+											type: "text-end",
+											id: "0"
+										});
+										activeText = false;
+									}
+									activeReasoningId = generateId();
+									controller.enqueue({
+										type: "reasoning-start",
+										id: activeReasoningId
+									});
+								}
+								controller.enqueue({
+									type: "reasoning-delta",
+									id: activeReasoningId,
+									delta: reasoningDelta
+								});
+							}
+						}
+					}
+					if (textContent != null && textContent.length > 0) {
+						if (!activeText) {
+							if (activeReasoningId != null) {
+								controller.enqueue({
+									type: "reasoning-end",
+									id: activeReasoningId
+								});
+								activeReasoningId = null;
+							}
+							controller.enqueue({
+								type: "text-start",
+								id: "0"
+							});
+							activeText = true;
+						}
+						controller.enqueue({
+							type: "text-delta",
+							id: "0",
+							delta: textContent
+						});
+					}
+					if (delta?.tool_calls != null) for (const toolCall of delta.tool_calls) toolCallTracker.processDelta(toolCall);
+					if (choice.finish_reason != null) finishReason = {
+						unified: mapMistralFinishReason(choice.finish_reason),
+						raw: choice.finish_reason
+					};
+				},
+				flush(controller) {
+					if (activeReasoningId != null) controller.enqueue({
+						type: "reasoning-end",
+						id: activeReasoningId
+					});
+					if (activeText) controller.enqueue({
+						type: "text-end",
+						id: "0"
+					});
+					toolCallTracker.flush();
+					controller.enqueue({
+						type: "finish",
+						finishReason,
+						usage: convertMistralUsage(usage)
+					});
+				}
+			})),
+			request: { body },
+			response: { headers: responseHeaders }
+		};
+	}
 };
 function extractReasoningContent(thinking) {
-  return thinking.filter((chunk) => chunk.type === "text").map((chunk) => chunk.text).join("");
+	return thinking.filter((chunk) => chunk.type === "text").map((chunk) => chunk.text).join("");
 }
 function extractTextContent(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  if (content == null) {
-    return void 0;
-  }
-  const textContent = [];
-  for (const chunk of content) {
-    const { type } = chunk;
-    switch (type) {
-      case "text":
-        textContent.push(chunk.text);
-        break;
-      case "thinking":
-      case "image_url":
-      case "reference":
-        break;
-      default: {
-        const _exhaustiveCheck = type;
-        throw new Error(`Unsupported type: ${_exhaustiveCheck}`);
-      }
-    }
-  }
-  return textContent.length ? textContent.join("") : void 0;
+	if (typeof content === "string") return content;
+	if (content == null) return;
+	const textContent = [];
+	for (const chunk of content) {
+		const { type } = chunk;
+		switch (type) {
+			case "text":
+				textContent.push(chunk.text);
+				break;
+			case "thinking":
+			case "image_url":
+			case "reference": break;
+			default: throw new Error(`Unsupported type: ${type}`);
+		}
+	}
+	return textContent.length ? textContent.join("") : void 0;
 }
-var mistralContentSchema = z4.union([
-  z4.string(),
-  z4.array(
-    z4.discriminatedUnion("type", [
-      z4.object({
-        type: z4.literal("text"),
-        text: z4.string()
-      }),
-      z4.object({
-        type: z4.literal("image_url"),
-        image_url: z4.union([
-          z4.string(),
-          z4.object({
-            url: z4.string(),
-            detail: z4.string().nullable()
-          })
-        ])
-      }),
-      z4.object({
-        type: z4.literal("reference"),
-        reference_ids: z4.array(z4.union([z4.string(), z4.number()]))
-      }),
-      z4.object({
-        type: z4.literal("thinking"),
-        thinking: z4.array(
-          z4.object({
-            type: z4.literal("text"),
-            text: z4.string()
-          })
-        )
-      })
-    ])
-  )
-]).nullish();
-var mistralChatResponseSchema = z4.object({
-  id: z4.string().nullish(),
-  created: z4.number().nullish(),
-  model: z4.string().nullish(),
-  choices: z4.array(
-    z4.object({
-      message: z4.object({
-        role: z4.literal("assistant"),
-        content: mistralContentSchema,
-        tool_calls: z4.array(
-          z4.object({
-            id: z4.string(),
-            function: z4.object({ name: z4.string(), arguments: z4.string() })
-          })
-        ).nullish()
-      }),
-      index: z4.number(),
-      finish_reason: z4.string().nullish()
-    })
-  ),
-  object: z4.literal("chat.completion"),
-  usage: mistralUsageSchema
+const mistralContentSchema = z.union([z.string(), z.array(z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("text"),
+		text: z.string()
+	}),
+	z.object({
+		type: z.literal("image_url"),
+		image_url: z.union([z.string(), z.object({
+			url: z.string(),
+			detail: z.string().nullable()
+		})])
+	}),
+	z.object({
+		type: z.literal("reference"),
+		reference_ids: z.array(z.union([z.string(), z.number()]))
+	}),
+	z.object({
+		type: z.literal("thinking"),
+		thinking: z.array(z.object({
+			type: z.literal("text"),
+			text: z.string()
+		}))
+	})
+]))]).nullish();
+const mistralChatResponseSchema = z.object({
+	id: z.string().nullish(),
+	created: z.number().nullish(),
+	model: z.string().nullish(),
+	choices: z.array(z.object({
+		message: z.object({
+			role: z.literal("assistant"),
+			content: mistralContentSchema,
+			tool_calls: z.array(z.object({
+				id: z.string(),
+				function: z.object({
+					name: z.string(),
+					arguments: z.string()
+				})
+			})).nullish()
+		}),
+		index: z.number(),
+		finish_reason: z.string().nullish()
+	})),
+	object: z.literal("chat.completion"),
+	usage: mistralUsageSchema
 });
-var mistralChatChunkSchema = z4.object({
-  id: z4.string().nullish(),
-  created: z4.number().nullish(),
-  model: z4.string().nullish(),
-  choices: z4.array(
-    z4.object({
-      delta: z4.object({
-        role: z4.enum(["assistant"]).optional(),
-        content: mistralContentSchema,
-        tool_calls: z4.array(
-          z4.object({
-            index: z4.number().nullish(),
-            id: z4.string().nullish(),
-            function: z4.object({
-              name: z4.string().nullish(),
-              arguments: z4.string().nullish()
-            })
-          })
-        ).nullish()
-      }),
-      finish_reason: z4.string().nullish(),
-      index: z4.number()
-    })
-  ),
-  usage: mistralUsageSchema.nullish()
+const mistralChatChunkSchema = z.object({
+	id: z.string().nullish(),
+	created: z.number().nullish(),
+	model: z.string().nullish(),
+	choices: z.array(z.object({
+		delta: z.object({
+			role: z.enum(["assistant"]).optional(),
+			content: mistralContentSchema,
+			tool_calls: z.array(z.object({
+				index: z.number().nullish(),
+				id: z.string().nullish(),
+				function: z.object({
+					name: z.string().nullish(),
+					arguments: z.string().nullish()
+				})
+			})).nullish()
+		}),
+		finish_reason: z.string().nullish(),
+		index: z.number()
+	})),
+	usage: mistralUsageSchema.nullish()
 });
-
-// src/mistral-embedding-model.ts
-import {
-  TooManyEmbeddingValuesForCallError
-} from "@ai-sdk/provider";
-import {
-  combineHeaders as combineHeaders2,
-  createJsonResponseHandler as createJsonResponseHandler2,
-  parseProviderOptions as parseProviderOptions2,
-  postJsonToApi as postJsonToApi2,
-  serializeModelOptions as serializeModelOptions2,
-  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2,
-  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2
-} from "@ai-sdk/provider-utils";
-import { z as z6 } from "zod/v4";
-
-// src/mistral-embedding-model-options.ts
-import { z as z5 } from "zod/v4";
-var mistralEmbeddingModelOptions = z5.object({
-  /**
-   * Additional metadata to attach to the embedding request.
-   */
-  metadata: z5.record(z5.string(), z5.any()).optional(),
-  /**
-   * The dimension of the output embeddings when supported by the model.
-   */
-  outputDimension: z5.number().int().positive().optional(),
-  /**
-   * The data type of the output embeddings when supported by the model.
-   */
-  outputDtype: z5.enum(["float", "int8", "uint8", "binary", "ubinary"]).optional()
+//#endregion
+//#region src/mistral-embedding-model-options.ts
+const mistralEmbeddingModelOptions = z.object({
+	/**
+	* Additional metadata to attach to the embedding request.
+	*/
+	metadata: z.record(z.string(), z.any()).optional(),
+	/**
+	* The dimension of the output embeddings when supported by the model.
+	*/
+	outputDimension: z.number().int().positive().optional(),
+	/**
+	* The data type of the output embeddings when supported by the model.
+	*/
+	outputDtype: z.enum([
+		"float",
+		"int8",
+		"uint8",
+		"binary",
+		"ubinary"
+	]).optional()
 });
-
-// src/mistral-embedding-model.ts
-var MistralEmbeddingModel = class _MistralEmbeddingModel {
-  constructor(modelId, config) {
-    this.specificationVersion = "v4";
-    this.maxEmbeddingsPerCall = 32;
-    this.supportsParallelCalls = false;
-    this.modelId = modelId;
-    this.config = config;
-  }
-  get provider() {
-    return this.config.provider;
-  }
-  static [WORKFLOW_SERIALIZE2](model) {
-    return serializeModelOptions2({
-      modelId: model.modelId,
-      config: model.config
-    });
-  }
-  static [WORKFLOW_DESERIALIZE2](options) {
-    return new _MistralEmbeddingModel(options.modelId, options.config);
-  }
-  async doEmbed({
-    values,
-    abortSignal,
-    headers,
-    providerOptions
-  }) {
-    if (values.length > this.maxEmbeddingsPerCall) {
-      throw new TooManyEmbeddingValuesForCallError({
-        provider: this.provider,
-        modelId: this.modelId,
-        maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
-        values
-      });
-    }
-    const mistralOptions = await parseProviderOptions2({
-      provider: "mistral",
-      providerOptions,
-      schema: mistralEmbeddingModelOptions
-    }) ?? {};
-    const {
-      responseHeaders,
-      value: response,
-      rawValue
-    } = await postJsonToApi2({
-      url: `${this.config.baseURL}/embeddings`,
-      headers: combineHeaders2(this.config.headers?.(), headers),
-      body: {
-        model: this.modelId,
-        input: values,
-        metadata: mistralOptions.metadata,
-        output_dimension: mistralOptions.outputDimension,
-        output_dtype: mistralOptions.outputDtype,
-        encoding_format: "float"
-      },
-      failedResponseHandler: mistralFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler2(
-        MistralTextEmbeddingResponseSchema
-      ),
-      abortSignal,
-      fetch: this.config.fetch
-    });
-    return {
-      warnings: [],
-      embeddings: response.data.map((item) => item.embedding),
-      usage: response.usage ? { tokens: response.usage.prompt_tokens } : void 0,
-      response: { headers: responseHeaders, body: rawValue }
-    };
-  }
+//#endregion
+//#region src/mistral-embedding-model.ts
+var MistralEmbeddingModel = class MistralEmbeddingModel {
+	get provider() {
+		return this.config.provider;
+	}
+	static [WORKFLOW_SERIALIZE](model) {
+		return serializeModelOptions({
+			modelId: model.modelId,
+			config: model.config
+		});
+	}
+	static [WORKFLOW_DESERIALIZE](options) {
+		return new MistralEmbeddingModel(options.modelId, options.config);
+	}
+	constructor(modelId, config) {
+		this.specificationVersion = "v4";
+		this.maxEmbeddingsPerCall = 32;
+		this.supportsParallelCalls = false;
+		this.modelId = modelId;
+		this.config = config;
+	}
+	async doEmbed({ values, abortSignal, headers, providerOptions }) {
+		if (values.length > this.maxEmbeddingsPerCall) throw new TooManyEmbeddingValuesForCallError({
+			provider: this.provider,
+			modelId: this.modelId,
+			maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
+			values
+		});
+		const mistralOptions = await parseProviderOptions({
+			provider: "mistral",
+			providerOptions,
+			schema: mistralEmbeddingModelOptions
+		}) ?? {};
+		const { responseHeaders, value: response, rawValue } = await postJsonToApi({
+			url: `${this.config.baseURL}/embeddings`,
+			headers: combineHeaders(this.config.headers?.(), headers),
+			body: {
+				model: this.modelId,
+				input: values,
+				metadata: mistralOptions.metadata,
+				output_dimension: mistralOptions.outputDimension,
+				output_dtype: mistralOptions.outputDtype,
+				encoding_format: "float"
+			},
+			failedResponseHandler: mistralFailedResponseHandler,
+			successfulResponseHandler: createJsonResponseHandler(MistralTextEmbeddingResponseSchema),
+			abortSignal,
+			fetch: this.config.fetch
+		});
+		return {
+			warnings: [],
+			embeddings: response.data.map((item) => item.embedding),
+			usage: response.usage ? { tokens: response.usage.prompt_tokens } : void 0,
+			response: {
+				headers: responseHeaders,
+				body: rawValue
+			}
+		};
+	}
 };
-var MistralTextEmbeddingResponseSchema = z6.object({
-  data: z6.array(z6.object({ embedding: z6.array(z6.number()) })),
-  usage: z6.object({ prompt_tokens: z6.number() }).nullish()
+const MistralTextEmbeddingResponseSchema = z.object({
+	data: z.array(z.object({ embedding: z.array(z.number()) })),
+	usage: z.object({ prompt_tokens: z.number() }).nullish()
 });
-
-// src/mistral-speech-model.ts
-import {
-  combineHeaders as combineHeaders3,
-  createJsonResponseHandler as createJsonResponseHandler3,
-  parseProviderOptions as parseProviderOptions3,
-  postToApi,
-  serializeModelOptions as serializeModelOptions3,
-  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE3,
-  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE3
-} from "@ai-sdk/provider-utils";
-import { z as z8 } from "zod/v4";
-
-// src/mistral-speech-model-options.ts
-import { z as z7 } from "zod/v4";
-var mistralSpeechModelOptions = z7.object({
-  /**
-   * Base64-encoded reference audio for one-off voice cloning.
-   *
-   * When provided, this takes precedence over the standard `voice` option.
-   */
-  refAudio: z7.string().min(1).optional()
-});
-
-// src/mistral-speech-model.ts
-var MistralSpeechModel = class _MistralSpeechModel {
-  constructor(modelId, config) {
-    this.modelId = modelId;
-    this.config = config;
-    this.specificationVersion = "v4";
-  }
-  static [WORKFLOW_SERIALIZE3](model) {
-    return serializeModelOptions3({
-      modelId: model.modelId,
-      config: model.config
-    });
-  }
-  static [WORKFLOW_DESERIALIZE3](options) {
-    return new _MistralSpeechModel(options.modelId, options.config);
-  }
-  get provider() {
-    return this.config.provider;
-  }
-  async getArgs({
-    text,
-    voice,
-    outputFormat = "mp3",
-    instructions,
-    speed,
-    language,
-    providerOptions
-  }) {
-    const warnings = [];
-    const mistralOptions = await parseProviderOptions3({
-      provider: "mistral",
-      providerOptions,
-      schema: mistralSpeechModelOptions
-    });
-    let responseFormat = "mp3";
-    if (["pcm", "wav", "mp3", "flac", "opus"].includes(outputFormat)) {
-      responseFormat = outputFormat;
-    } else {
-      warnings.push({
-        type: "unsupported",
-        feature: "outputFormat",
-        details: `Unsupported output format: ${outputFormat}. Using mp3 instead.`
-      });
-    }
-    if (instructions != null) {
-      warnings.push({
-        type: "unsupported",
-        feature: "instructions",
-        details: "Mistral speech models do not support the `instructions` option. Use a reference audio clip to guide delivery."
-      });
-    }
-    if (speed != null) {
-      warnings.push({
-        type: "unsupported",
-        feature: "speed",
-        details: "Mistral speech models do not support the `speed` option. It was ignored."
-      });
-    }
-    if (language != null) {
-      warnings.push({
-        type: "unsupported",
-        feature: "language",
-        details: "Mistral speech models do not support the `language` option. Language is inferred from the input text and voice."
-      });
-    }
-    const refAudio = mistralOptions?.refAudio;
-    const requestBody = {
-      model: this.modelId,
-      input: text,
-      voice_id: refAudio == null ? voice : void 0,
-      ref_audio: refAudio,
-      response_format: responseFormat,
-      stream: false
-    };
-    const requestBodyValues = {
-      ...requestBody,
-      ref_audio: refAudio == null ? void 0 : "[redacted]"
-    };
-    return { requestBody, requestBodyValues, warnings };
-  }
-  async doGenerate(options) {
-    const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
-    const { requestBody, requestBodyValues, warnings } = await this.getArgs(options);
-    const {
-      value: response,
-      responseHeaders,
-      rawValue: rawResponse
-    } = await postToApi({
-      url: `${this.config.baseURL}/audio/speech`,
-      headers: combineHeaders3(
-        { "Content-Type": "application/json" },
-        this.config.headers?.(),
-        options.headers
-      ),
-      body: {
-        content: JSON.stringify(requestBody),
-        values: requestBodyValues
-      },
-      failedResponseHandler: mistralFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler3(
-        mistralSpeechResponseSchema
-      ),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    return {
-      audio: response.audio_data,
-      warnings,
-      request: {
-        body: JSON.stringify(requestBodyValues)
-      },
-      response: {
-        timestamp: currentDate,
-        modelId: this.modelId,
-        headers: responseHeaders,
-        body: rawResponse
-      }
-    };
-  }
+//#endregion
+//#region src/mistral-speech-model-options.ts
+const mistralSpeechModelOptions = z.object({ 
+/**
+* Base64-encoded reference audio for one-off voice cloning.
+*
+* When provided, this takes precedence over the standard `voice` option.
+*/
+refAudio: z.string().min(1).optional() });
+//#endregion
+//#region src/mistral-speech-model.ts
+var MistralSpeechModel = class MistralSpeechModel {
+	static [WORKFLOW_SERIALIZE](model) {
+		return serializeModelOptions({
+			modelId: model.modelId,
+			config: model.config
+		});
+	}
+	static [WORKFLOW_DESERIALIZE](options) {
+		return new MistralSpeechModel(options.modelId, options.config);
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+		this.specificationVersion = "v4";
+	}
+	async getArgs({ text, voice, outputFormat = "mp3", instructions, speed, language, providerOptions }) {
+		const warnings = [];
+		const mistralOptions = await parseProviderOptions({
+			provider: "mistral",
+			providerOptions,
+			schema: mistralSpeechModelOptions
+		});
+		let responseFormat = "mp3";
+		if ([
+			"pcm",
+			"wav",
+			"mp3",
+			"flac",
+			"opus"
+		].includes(outputFormat)) responseFormat = outputFormat;
+		else warnings.push({
+			type: "unsupported",
+			feature: "outputFormat",
+			details: `Unsupported output format: ${outputFormat}. Using mp3 instead.`
+		});
+		if (instructions != null) warnings.push({
+			type: "unsupported",
+			feature: "instructions",
+			details: "Mistral speech models do not support the `instructions` option. Use a reference audio clip to guide delivery."
+		});
+		if (speed != null) warnings.push({
+			type: "unsupported",
+			feature: "speed",
+			details: "Mistral speech models do not support the `speed` option. It was ignored."
+		});
+		if (language != null) warnings.push({
+			type: "unsupported",
+			feature: "language",
+			details: "Mistral speech models do not support the `language` option. Language is inferred from the input text and voice."
+		});
+		const refAudio = mistralOptions?.refAudio;
+		const requestBody = {
+			model: this.modelId,
+			input: text,
+			voice_id: refAudio == null ? voice : void 0,
+			ref_audio: refAudio,
+			response_format: responseFormat,
+			stream: false
+		};
+		return {
+			requestBody,
+			requestBodyValues: {
+				...requestBody,
+				ref_audio: refAudio == null ? void 0 : "[redacted]"
+			},
+			warnings
+		};
+	}
+	async doGenerate(options) {
+		const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
+		const { requestBody, requestBodyValues, warnings } = await this.getArgs(options);
+		const { value: response, responseHeaders, rawValue: rawResponse } = await postToApi({
+			url: `${this.config.baseURL}/audio/speech`,
+			headers: combineHeaders({ "Content-Type": "application/json" }, this.config.headers?.(), options.headers),
+			body: {
+				content: JSON.stringify(requestBody),
+				values: requestBodyValues
+			},
+			failedResponseHandler: mistralFailedResponseHandler,
+			successfulResponseHandler: createJsonResponseHandler(mistralSpeechResponseSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		return {
+			audio: response.audio_data,
+			warnings,
+			request: { body: JSON.stringify(requestBodyValues) },
+			response: {
+				timestamp: currentDate,
+				modelId: this.modelId,
+				headers: responseHeaders,
+				body: rawResponse
+			}
+		};
+	}
 };
-var mistralSpeechResponseSchema = z8.object({
-  audio_data: z8.string()
-});
-
-// src/mistral-transcription-model.ts
-import {
-  InvalidArgumentError
-} from "@ai-sdk/provider";
-import {
-  combineHeaders as combineHeaders4,
-  convertBase64ToUint8Array,
-  createJsonResponseHandler as createJsonResponseHandler4,
-  mediaTypeToExtension,
-  parseProviderOptions as parseProviderOptions4,
-  postFormDataToApi,
-  serializeModelOptions as serializeModelOptions4,
-  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE4,
-  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE4
-} from "@ai-sdk/provider-utils";
-import { z as z10 } from "zod/v4";
-
-// src/mistral-transcription-model-options.ts
-import {
-  lazySchema,
-  zodSchema
-} from "@ai-sdk/provider-utils";
-import { z as z9 } from "zod/v4";
-var mistralTranscriptionModelOptions = lazySchema(
-  () => zodSchema(
-    z9.object({
-      /**
-       * The language of the audio, e.g. "en". Providing the language can boost
-       * accuracy.
-       */
-      language: z9.string().min(1).optional(),
-      /**
-       * The sampling temperature.
-       */
-      temperature: z9.number().optional(),
-      /**
-       * The timestamp granularities to include in the transcription response.
-       */
-      timestampGranularities: z9.array(z9.enum(["segment", "word"])).min(1).optional(),
-      /**
-       * Whether to identify speakers in the transcription.
-       */
-      diarize: z9.boolean().optional(),
-      /**
-       * Words or phrases to guide the model toward correct spellings of names,
-       * technical terms, or domain-specific vocabulary.
-       *
-       * Mistral requires each item to omit commas and whitespace. Use
-       * underscores to represent multi-word phrases.
-       */
-      contextBias: z9.array(
-        z9.string().min(1).regex(
-          /^[^\s,]+$/,
-          "Context bias items must not contain commas or whitespace."
-        )
-      ).max(100).optional()
-    })
-  )
-);
-
-// src/mistral-transcription-model.ts
-var MistralTranscriptionModel = class _MistralTranscriptionModel {
-  constructor(modelId, config) {
-    this.modelId = modelId;
-    this.config = config;
-    this.specificationVersion = "v4";
-  }
-  static [WORKFLOW_SERIALIZE4](model) {
-    return serializeModelOptions4({
-      modelId: model.modelId,
-      config: model.config
-    });
-  }
-  static [WORKFLOW_DESERIALIZE4](options) {
-    return new _MistralTranscriptionModel(options.modelId, options.config);
-  }
-  get provider() {
-    return this.config.provider;
-  }
-  async getArgs({
-    audio,
-    mediaType,
-    providerOptions
-  }) {
-    const warnings = [];
-    const mistralOptions = await parseProviderOptions4({
-      provider: "mistral",
-      providerOptions,
-      schema: mistralTranscriptionModelOptions
-    });
-    if (mistralOptions?.language != null && mistralOptions.timestampGranularities != null) {
-      throw new InvalidArgumentError({
-        argument: "providerOptions",
-        message: "providerOptions.mistral.language cannot be combined with providerOptions.mistral.timestampGranularities"
-      });
-    }
-    const formData = new FormData();
-    const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([convertBase64ToUint8Array(audio)]);
-    formData.append("model", this.modelId);
-    formData.append(
-      "file",
-      new File([blob], "audio", { type: mediaType }),
-      `audio.${mediaTypeToExtension(mediaType)}`
-    );
-    if (mistralOptions != null) {
-      appendFormValue(formData, "language", mistralOptions.language);
-      appendFormValue(formData, "temperature", mistralOptions.temperature);
-      appendFormValue(
-        formData,
-        "timestamp_granularities",
-        mistralOptions.timestampGranularities
-      );
-      appendFormValue(formData, "diarize", mistralOptions.diarize);
-      appendFormValue(formData, "context_bias", mistralOptions.contextBias);
-    }
-    return { formData, warnings };
-  }
-  async doGenerate(options) {
-    const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
-    const { formData, warnings } = await this.getArgs(options);
-    const {
-      value: response,
-      responseHeaders,
-      rawValue: rawResponse
-    } = await postFormDataToApi({
-      url: `${this.config.baseURL}/audio/transcriptions`,
-      headers: combineHeaders4(this.config.headers?.(), options.headers),
-      formData,
-      failedResponseHandler: mistralFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler4(
-        mistralTranscriptionResponseSchema
-      ),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    const segments = response.segments?.map((segment) => ({
-      text: segment.text,
-      startSecond: segment.start,
-      endSecond: segment.end
-    })) ?? [];
-    const mistralMetadata = {};
-    if (response.usage != null) {
-      mistralMetadata.usage = {
-        ...response.usage.prompt_tokens != null && {
-          promptTokens: response.usage.prompt_tokens
-        },
-        ...response.usage.completion_tokens != null && {
-          completionTokens: response.usage.completion_tokens
-        },
-        ...response.usage.total_tokens != null && {
-          totalTokens: response.usage.total_tokens
-        },
-        ...response.usage.prompt_audio_seconds != null && {
-          promptAudioSeconds: response.usage.prompt_audio_seconds
-        },
-        ...response.usage.request_count != null && {
-          requestCount: response.usage.request_count
-        }
-      };
-    }
-    const providerSegments = response.segments?.filter(
-      (segment) => segment.type != null || segment.score != null || segment.speaker_id != null
-    ).map((segment) => ({
-      text: segment.text,
-      startSecond: segment.start,
-      endSecond: segment.end,
-      ...segment.type != null && { type: segment.type },
-      ...segment.score != null && { score: segment.score },
-      ...segment.speaker_id != null && {
-        speakerId: segment.speaker_id
-      }
-    }));
-    if (providerSegments != null && providerSegments.length > 0) {
-      mistralMetadata.segments = providerSegments;
-    }
-    return {
-      text: response.text,
-      segments,
-      language: response.language ?? void 0,
-      durationInSeconds: response.usage?.prompt_audio_seconds ?? segments.at(-1)?.endSecond ?? void 0,
-      warnings,
-      response: {
-        timestamp: currentDate,
-        modelId: response.model,
-        headers: responseHeaders,
-        body: rawResponse
-      },
-      ...Object.keys(mistralMetadata).length > 0 && {
-        providerMetadata: {
-          mistral: mistralMetadata
-        }
-      }
-    };
-  }
+const mistralSpeechResponseSchema = z.object({ audio_data: z.string() });
+//#endregion
+//#region src/mistral-transcription-model-options.ts
+const mistralTranscriptionModelOptions = lazySchema(() => zodSchema(z.object({
+	/**
+	* The language of the audio, e.g. "en". Providing the language can boost
+	* accuracy.
+	*/
+	language: z.string().min(1).optional(),
+	/**
+	* The sampling temperature.
+	*/
+	temperature: z.number().optional(),
+	/**
+	* The timestamp granularities to include in the transcription response.
+	*/
+	timestampGranularities: z.array(z.enum(["segment", "word"])).min(1).optional(),
+	/**
+	* Whether to identify speakers in the transcription.
+	*/
+	diarize: z.boolean().optional(),
+	/**
+	* Words or phrases to guide the model toward correct spellings of names,
+	* technical terms, or domain-specific vocabulary.
+	*
+	* Mistral requires each item to omit commas and whitespace. Use
+	* underscores to represent multi-word phrases.
+	*/
+	contextBias: z.array(z.string().min(1).regex(/^[^\s,]+$/, "Context bias items must not contain commas or whitespace.")).max(100).optional()
+})));
+//#endregion
+//#region src/mistral-transcription-model.ts
+var MistralTranscriptionModel = class MistralTranscriptionModel {
+	static [WORKFLOW_SERIALIZE](model) {
+		return serializeModelOptions({
+			modelId: model.modelId,
+			config: model.config
+		});
+	}
+	static [WORKFLOW_DESERIALIZE](options) {
+		return new MistralTranscriptionModel(options.modelId, options.config);
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+		this.specificationVersion = "v4";
+	}
+	async getArgs({ audio, mediaType, providerOptions }) {
+		const warnings = [];
+		const mistralOptions = await parseProviderOptions({
+			provider: "mistral",
+			providerOptions,
+			schema: mistralTranscriptionModelOptions
+		});
+		if (mistralOptions?.language != null && mistralOptions.timestampGranularities != null) throw new InvalidArgumentError({
+			argument: "providerOptions",
+			message: "providerOptions.mistral.language cannot be combined with providerOptions.mistral.timestampGranularities"
+		});
+		const formData = new FormData();
+		const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([convertBase64ToUint8Array(audio)]);
+		formData.append("model", this.modelId);
+		formData.append("file", new File([blob], "audio", { type: mediaType }), `audio.${mediaTypeToExtension(mediaType)}`);
+		if (mistralOptions != null) {
+			appendFormValue(formData, "language", mistralOptions.language);
+			appendFormValue(formData, "temperature", mistralOptions.temperature);
+			appendFormValue(formData, "timestamp_granularities", mistralOptions.timestampGranularities);
+			appendFormValue(formData, "diarize", mistralOptions.diarize);
+			appendFormValue(formData, "context_bias", mistralOptions.contextBias);
+		}
+		return {
+			formData,
+			warnings
+		};
+	}
+	async doGenerate(options) {
+		const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
+		const { formData, warnings } = await this.getArgs(options);
+		const { value: response, responseHeaders, rawValue: rawResponse } = await postFormDataToApi({
+			url: `${this.config.baseURL}/audio/transcriptions`,
+			headers: combineHeaders(this.config.headers?.(), options.headers),
+			formData,
+			failedResponseHandler: mistralFailedResponseHandler,
+			successfulResponseHandler: createJsonResponseHandler(mistralTranscriptionResponseSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		const segments = response.segments?.map((segment) => ({
+			text: segment.text,
+			startSecond: segment.start,
+			endSecond: segment.end
+		})) ?? [];
+		const mistralMetadata = {};
+		if (response.usage != null) mistralMetadata.usage = {
+			...response.usage.prompt_tokens != null && { promptTokens: response.usage.prompt_tokens },
+			...response.usage.completion_tokens != null && { completionTokens: response.usage.completion_tokens },
+			...response.usage.total_tokens != null && { totalTokens: response.usage.total_tokens },
+			...response.usage.prompt_audio_seconds != null && { promptAudioSeconds: response.usage.prompt_audio_seconds },
+			...response.usage.request_count != null && { requestCount: response.usage.request_count }
+		};
+		const providerSegments = response.segments?.filter((segment) => segment.type != null || segment.score != null || segment.speaker_id != null).map((segment) => ({
+			text: segment.text,
+			startSecond: segment.start,
+			endSecond: segment.end,
+			...segment.type != null && { type: segment.type },
+			...segment.score != null && { score: segment.score },
+			...segment.speaker_id != null && { speakerId: segment.speaker_id }
+		}));
+		if (providerSegments != null && providerSegments.length > 0) mistralMetadata.segments = providerSegments;
+		return {
+			text: response.text,
+			segments,
+			language: response.language ?? void 0,
+			durationInSeconds: response.usage?.prompt_audio_seconds ?? segments.at(-1)?.endSecond ?? void 0,
+			warnings,
+			response: {
+				timestamp: currentDate,
+				modelId: response.model,
+				headers: responseHeaders,
+				body: rawResponse
+			},
+			...Object.keys(mistralMetadata).length > 0 && { providerMetadata: { mistral: mistralMetadata } }
+		};
+	}
 };
 function appendFormValue(formData, key, value) {
-  if (value == null) {
-    return;
-  }
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      formData.append(key, item);
-    }
-    return;
-  }
-  formData.append(key, String(value));
+	if (value == null) return;
+	if (Array.isArray(value)) {
+		for (const item of value) formData.append(key, item);
+		return;
+	}
+	formData.append(key, String(value));
 }
-var mistralTranscriptionResponseSchema = z10.object({
-  model: z10.string(),
-  text: z10.string(),
-  language: z10.string().nullish(),
-  segments: z10.array(
-    z10.object({
-      type: z10.literal("transcription_segment").nullish(),
-      text: z10.string(),
-      start: z10.number(),
-      end: z10.number(),
-      score: z10.number().nullish(),
-      speaker_id: z10.string().nullish()
-    })
-  ).nullish(),
-  usage: z10.object({
-    prompt_tokens: z10.number().nullish(),
-    completion_tokens: z10.number().nullish(),
-    total_tokens: z10.number().nullish(),
-    prompt_audio_seconds: z10.number().nullish(),
-    request_count: z10.number().nullish()
-  }).nullish()
+const mistralTranscriptionResponseSchema = z.object({
+	model: z.string(),
+	text: z.string(),
+	language: z.string().nullish(),
+	segments: z.array(z.object({
+		type: z.literal("transcription_segment").nullish(),
+		text: z.string(),
+		start: z.number(),
+		end: z.number(),
+		score: z.number().nullish(),
+		speaker_id: z.string().nullish()
+	})).nullish(),
+	usage: z.object({
+		prompt_tokens: z.number().nullish(),
+		completion_tokens: z.number().nullish(),
+		total_tokens: z.number().nullish(),
+		prompt_audio_seconds: z.number().nullish(),
+		request_count: z.number().nullish()
+	}).nullish()
 });
-
-// src/version.ts
-var VERSION = true ? "4.0.54" : "0.0.0-test";
-
-// src/mistral-provider.ts
+//#endregion
+//#region src/version.ts
+const VERSION = "4.0.55";
+//#endregion
+//#region src/mistral-provider.ts
+/**
+* Create a Mistral AI provider instance.
+*/
 function createMistral(options = {}) {
-  const baseURL = withoutTrailingSlash(options.baseURL) ?? "https://api.mistral.ai/v1";
-  const getHeaders = () => withUserAgentSuffix(
-    {
-      Authorization: `Bearer ${loadApiKey({
-        apiKey: options.apiKey,
-        environmentVariableName: "MISTRAL_API_KEY",
-        description: "Mistral"
-      })}`,
-      ...options.headers
-    },
-    `ai-sdk-mistral/${VERSION}`
-  );
-  const createChatModel = (modelId) => new MistralChatLanguageModel(modelId, {
-    provider: "mistral.chat",
-    baseURL,
-    headers: getHeaders,
-    fetch: options.fetch,
-    generateId: options.generateId
-  });
-  const createEmbeddingModel = (modelId) => new MistralEmbeddingModel(modelId, {
-    provider: "mistral.embedding",
-    baseURL,
-    headers: getHeaders,
-    fetch: options.fetch
-  });
-  const createSpeechModel = (modelId) => new MistralSpeechModel(modelId, {
-    provider: "mistral.speech",
-    baseURL,
-    headers: getHeaders,
-    fetch: options.fetch
-  });
-  const createTranscriptionModel = (modelId) => new MistralTranscriptionModel(modelId, {
-    provider: "mistral.transcription",
-    baseURL,
-    headers: getHeaders,
-    fetch: options.fetch
-  });
-  const provider = function(modelId) {
-    if (new.target) {
-      throw new Error(
-        "The Mistral model function cannot be called with the new keyword."
-      );
-    }
-    return createChatModel(modelId);
-  };
-  provider.specificationVersion = "v4";
-  provider.languageModel = createChatModel;
-  provider.chat = createChatModel;
-  provider.embedding = createEmbeddingModel;
-  provider.embeddingModel = createEmbeddingModel;
-  provider.textEmbedding = createEmbeddingModel;
-  provider.textEmbeddingModel = createEmbeddingModel;
-  provider.speech = createSpeechModel;
-  provider.speechModel = createSpeechModel;
-  provider.transcription = createTranscriptionModel;
-  provider.transcriptionModel = createTranscriptionModel;
-  provider.imageModel = (modelId) => {
-    throw new NoSuchModelError({ modelId, modelType: "imageModel" });
-  };
-  return provider;
+	const baseURL = withoutTrailingSlash(options.baseURL) ?? "https://api.mistral.ai/v1";
+	const getHeaders = () => withUserAgentSuffix({
+		Authorization: `Bearer ${loadApiKey({
+			apiKey: options.apiKey,
+			environmentVariableName: "MISTRAL_API_KEY",
+			description: "Mistral"
+		})}`,
+		...options.headers
+	}, `ai-sdk-mistral/${VERSION}`);
+	const createChatModel = (modelId) => new MistralChatLanguageModel(modelId, {
+		provider: "mistral.chat",
+		baseURL,
+		headers: getHeaders,
+		fetch: options.fetch,
+		generateId: options.generateId
+	});
+	const createEmbeddingModel = (modelId) => new MistralEmbeddingModel(modelId, {
+		provider: "mistral.embedding",
+		baseURL,
+		headers: getHeaders,
+		fetch: options.fetch
+	});
+	const createSpeechModel = (modelId) => new MistralSpeechModel(modelId, {
+		provider: "mistral.speech",
+		baseURL,
+		headers: getHeaders,
+		fetch: options.fetch
+	});
+	const createTranscriptionModel = (modelId) => new MistralTranscriptionModel(modelId, {
+		provider: "mistral.transcription",
+		baseURL,
+		headers: getHeaders,
+		fetch: options.fetch
+	});
+	const provider = function(modelId) {
+		if (new.target) throw new Error("The Mistral model function cannot be called with the new keyword.");
+		return createChatModel(modelId);
+	};
+	provider.specificationVersion = "v4";
+	provider.languageModel = createChatModel;
+	provider.chat = createChatModel;
+	provider.embedding = createEmbeddingModel;
+	provider.embeddingModel = createEmbeddingModel;
+	provider.textEmbedding = createEmbeddingModel;
+	provider.textEmbeddingModel = createEmbeddingModel;
+	provider.speech = createSpeechModel;
+	provider.speechModel = createSpeechModel;
+	provider.transcription = createTranscriptionModel;
+	provider.transcriptionModel = createTranscriptionModel;
+	provider.imageModel = (modelId) => {
+		throw new NoSuchModelError({
+			modelId,
+			modelType: "imageModel"
+		});
+	};
+	return provider;
 }
-var mistral = createMistral();
-export {
-  VERSION,
-  createMistral,
-  mistral
-};
+/**
+* Default Mistral provider instance.
+*/
+const mistral = createMistral();
+//#endregion
+export { VERSION, createMistral, mistral };
+
 //# sourceMappingURL=index.js.map