@ai-sdk/mistral 4.0.0-beta.4 → 4.0.0-beta.55

package/dist/index.js

@@ -1,41 +1,33 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  VERSION: () => VERSION,
-  createMistral: () => createMistral,
-  mistral: () => mistral
-});
-module.exports = __toCommonJS(index_exports);
-
 // src/mistral-provider.ts
-var import_provider4 = require("@ai-sdk/provider");
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
+import {
+  NoSuchModelError
+} from "@ai-sdk/provider";
+import {
+  loadApiKey,
+  withoutTrailingSlash,
+  withUserAgentSuffix
+} from "@ai-sdk/provider-utils";
 
 // src/mistral-chat-language-model.ts
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_v43 = require("zod/v4");
+import {
+  combineHeaders,
+  createEventSourceResponseHandler,
+  createJsonResponseHandler,
+  generateId,
+  injectJsonInstructionIntoMessages,
+  isCustomReasoning,
+  mapReasoningToProviderEffort,
+  parseProviderOptions,
+  postJsonToApi,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE
+} from "@ai-sdk/provider-utils";
+import { z as z3 } from "zod/v4";
 
 // src/convert-mistral-usage.ts
 function convertMistralUsage(usage) {
+  var _a, _b, _c, _d, _e;
   if (usage == null) {
     return {
       inputTokens: {
@@ -54,11 +46,12 @@ function convertMistralUsage(usage) {
   }
   const promptTokens = usage.prompt_tokens;
   const completionTokens = usage.completion_tokens;
+  const cacheReadTokens = (_e = (_d = (_b = usage.num_cached_tokens) != null ? _b : (_a = usage.prompt_tokens_details) == null ? void 0 : _a.cached_tokens) != null ? _d : (_c = usage.prompt_token_details) == null ? void 0 : _c.cached_tokens) != null ? _e : 0;
   return {
     inputTokens: {
       total: promptTokens,
-      noCache: promptTokens,
-      cacheRead: void 0,
+      noCache: promptTokens - cacheReadTokens,
+      cacheRead: cacheReadTokens || void 0,
       cacheWrite: void 0
     },
     outputTokens: {
@@ -71,13 +64,24 @@ function convertMistralUsage(usage) {
 }
 
 // src/convert-to-mistral-chat-messages.ts
-var import_provider = require("@ai-sdk/provider");
-var import_provider_utils = require("@ai-sdk/provider-utils");
-function formatFileUrl({
-  data,
-  mediaType
-}) {
-  return data instanceof URL ? data.toString() : `data:${mediaType};base64,${(0, import_provider_utils.convertToBase64)(data)}`;
+import {
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
+import {
+  convertToBase64,
+  getTopLevelMediaType,
+  resolveFullMediaType
+} from "@ai-sdk/provider-utils";
+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}`
+  });
 }
 function convertToMistralChatMessages(prompt) {
   var _a;
@@ -99,24 +103,44 @@ function convertToMistralChatMessages(prompt) {
                 return { type: "text", text: part.text };
               }
               case "file": {
-                if (part.mediaType.startsWith("image/")) {
-                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
-                  return {
-                    type: "image_url",
-                    image_url: formatFileUrl({ data: part.data, mediaType })
-                  };
-                } else if (part.mediaType === "application/pdf") {
-                  return {
-                    type: "document_url",
-                    document_url: formatFileUrl({
-                      data: part.data,
-                      mediaType: "application/pdf"
-                    })
-                  };
-                } else {
-                  throw new import_provider.UnsupportedFunctionalityError({
-                    functionality: "Only images and PDF file parts are supported"
-                  });
+                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 })
+                      };
+                    }
+                  }
                 }
               }
             }
@@ -176,7 +200,7 @@ function convertToMistralChatMessages(prompt) {
               contentValue = output.value;
               break;
             case "execution-denied":
-              contentValue = (_a = output.reason) != null ? _a : "Tool execution denied.";
+              contentValue = (_a = output.reason) != null ? _a : "Tool call execution denied.";
               break;
             case "content":
             case "json":
@@ -230,55 +254,64 @@ function mapMistralFinishReason(finishReason) {
   }
 }
 
-// src/mistral-chat-options.ts
-var import_v4 = require("zod/v4");
-var mistralLanguageModelOptions = import_v4.z.object({
+// src/mistral-chat-language-model-options.ts
+import { z } from "zod/v4";
+var mistralLanguageModelChatOptions = z.object({
   /**
    * Whether to inject a safety prompt before all conversations.
    *
    * Defaults to `false`.
    */
-  safePrompt: import_v4.z.boolean().optional(),
-  documentImageLimit: import_v4.z.number().optional(),
-  documentPageLimit: import_v4.z.number().optional(),
+  safePrompt: z.boolean().optional(),
+  documentImageLimit: z.number().optional(),
+  documentPageLimit: z.number().optional(),
   /**
    * Whether to use structured outputs.
    *
    * @default true
    */
-  structuredOutputs: import_v4.z.boolean().optional(),
+  structuredOutputs: z.boolean().optional(),
   /**
    * Whether to use strict JSON schema validation.
    *
    * @default false
    */
-  strictJsonSchema: import_v4.z.boolean().optional(),
+  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: import_v4.z.boolean().optional()
+  parallelToolCalls: z.boolean().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
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_v42 = require("zod/v4");
-var mistralErrorDataSchema = import_v42.z.object({
-  object: import_v42.z.literal("error"),
-  message: import_v42.z.string(),
-  type: import_v42.z.string(),
-  param: import_v42.z.string().nullable(),
-  code: import_v42.z.string().nullable()
+import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
+import { z as z2 } from "zod/v4";
+var mistralErrorDataSchema = z2.object({
+  object: z2.literal("error"),
+  message: z2.string(),
+  type: z2.string(),
+  param: z2.string().nullable(),
+  code: z2.string().nullable()
 });
-var mistralFailedResponseHandler = (0, import_provider_utils2.createJsonErrorResponseHandler)({
+var mistralFailedResponseHandler = createJsonErrorResponseHandler({
   errorSchema: mistralErrorDataSchema,
   errorToMessage: (data) => data.message
 });
 
 // src/mistral-prepare-tools.ts
-var import_provider2 = require("@ai-sdk/provider");
+import {
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
+} from "@ai-sdk/provider";
 function prepareTools({
   tools,
   toolChoice
@@ -329,7 +362,7 @@ function prepareTools({
       };
     default: {
       const _exhaustiveCheck = type;
-      throw new import_provider2.UnsupportedFunctionalityError({
+      throw new UnsupportedFunctionalityError2({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
@@ -337,7 +370,7 @@ function prepareTools({
 }
 
 // src/mistral-chat-language-model.ts
-var MistralChatLanguageModel = class {
+var MistralChatLanguageModel = class _MistralChatLanguageModel {
   constructor(modelId, config) {
     this.specificationVersion = "v4";
     this.supportedUrls = {
@@ -346,7 +379,16 @@ var MistralChatLanguageModel = class {
     var _a;
     this.modelId = modelId;
     this.config = config;
-    this.generateId = (_a = config.generateId) != null ? _a : import_provider_utils3.generateId;
+    this.generateId = (_a = config.generateId) != null ? _a : 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;
@@ -359,6 +401,7 @@ var MistralChatLanguageModel = class {
     topK,
     frequencyPenalty,
     presencePenalty,
+    reasoning,
     stopSequences,
     responseFormat,
     seed,
@@ -366,12 +409,12 @@ var MistralChatLanguageModel = class {
     tools,
     toolChoice
   }) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e;
     const warnings = [];
-    const options = (_a = await (0, import_provider_utils3.parseProviderOptions)({
+    const options = (_a = await parseProviderOptions({
       provider: "mistral",
       providerOptions,
-      schema: mistralLanguageModelOptions
+      schema: mistralLanguageModelChatOptions
     })) != null ? _a : {};
     if (topK != null) {
       warnings.push({ type: "unsupported", feature: "topK" });
@@ -382,13 +425,31 @@ var MistralChatLanguageModel = class {
     if (presencePenalty != null) {
       warnings.push({ type: "unsupported", feature: "presencePenalty" });
     }
-    if (stopSequences != null) {
-      warnings.push({ type: "unsupported", feature: "stopSequences" });
+    const supportsReasoningEffort = this.modelId === "mistral-small-latest" || this.modelId === "mistral-small-2603" || this.modelId === "mistral-medium-3" || this.modelId === "mistral-medium-3.5";
+    let resolvedReasoningEffort;
+    if (supportsReasoningEffort) {
+      resolvedReasoningEffort = (_b = options.reasoningEffort) != null ? _b : 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 = (_b = options.structuredOutputs) != null ? _b : true;
-    const strictJsonSchema = (_c = options.strictJsonSchema) != null ? _c : false;
+    const structuredOutputs = (_c = options.structuredOutputs) != null ? _c : true;
+    const strictJsonSchema = (_d = options.strictJsonSchema) != null ? _d : false;
     if ((responseFormat == null ? void 0 : responseFormat.type) === "json" && !(responseFormat == null ? void 0 : responseFormat.schema)) {
-      prompt = (0, import_provider_utils3.injectJsonInstructionIntoMessages)({
+      prompt = injectJsonInstructionIntoMessages({
         messages: prompt,
         schema: responseFormat.schema
       });
@@ -402,14 +463,16 @@ var MistralChatLanguageModel = class {
       max_tokens: maxOutputTokens,
       temperature,
       top_p: topP,
+      stop: stopSequences,
       random_seed: seed,
+      reasoning_effort: resolvedReasoningEffort,
       // response format:
       response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? structuredOutputs && (responseFormat == null ? void 0 : responseFormat.schema) != null ? {
         type: "json_schema",
         json_schema: {
           schema: responseFormat.schema,
           strict: strictJsonSchema,
-          name: (_d = responseFormat.name) != null ? _d : "response",
+          name: (_e = responseFormat.name) != null ? _e : "response",
           description: responseFormat.description
         }
       } : { type: "json_object" } : void 0,
@@ -438,18 +501,18 @@ var MistralChatLanguageModel = class {
     };
   }
   async doGenerate(options) {
-    var _a;
+    var _a, _b, _c;
     const { args: body, warnings } = await this.getArgs(options);
     const {
       responseHeaders,
       value: response,
       rawValue: rawResponse
-    } = await (0, import_provider_utils3.postJsonToApi)({
+    } = await postJsonToApi({
       url: `${this.config.baseURL}/chat/completions`,
-      headers: (0, import_provider_utils3.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), options.headers),
       body,
       failedResponseHandler: mistralFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler(
         mistralChatResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -490,7 +553,7 @@ var MistralChatLanguageModel = class {
       content,
       finishReason: {
         unified: mapMistralFinishReason(choice.finish_reason),
-        raw: (_a = choice.finish_reason) != null ? _a : void 0
+        raw: (_c = choice.finish_reason) != null ? _c : void 0
       },
       usage: convertMistralUsage(response.usage),
       request: { body },
@@ -503,14 +566,15 @@ var MistralChatLanguageModel = class {
     };
   }
   async doStream(options) {
+    var _a, _b;
     const { args, warnings } = await this.getArgs(options);
     const body = { ...args, stream: true };
-    const { responseHeaders, value: response } = await (0, import_provider_utils3.postJsonToApi)({
+    const { responseHeaders, value: response } = await postJsonToApi({
       url: `${this.config.baseURL}/chat/completions`,
-      headers: (0, import_provider_utils3.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), options.headers),
       body,
       failedResponseHandler: mistralFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils3.createEventSourceResponseHandler)(
+      successfulResponseHandler: createEventSourceResponseHandler(
         mistralChatChunkSchema
       ),
       abortSignal: options.abortSignal,
@@ -682,96 +746,108 @@ function extractTextContent(content) {
   }
   return textContent.length ? textContent.join("") : void 0;
 }
-var mistralContentSchema = import_v43.z.union([
-  import_v43.z.string(),
-  import_v43.z.array(
-    import_v43.z.discriminatedUnion("type", [
-      import_v43.z.object({
-        type: import_v43.z.literal("text"),
-        text: import_v43.z.string()
+var mistralContentSchema = z3.union([
+  z3.string(),
+  z3.array(
+    z3.discriminatedUnion("type", [
+      z3.object({
+        type: z3.literal("text"),
+        text: z3.string()
       }),
-      import_v43.z.object({
-        type: import_v43.z.literal("image_url"),
-        image_url: import_v43.z.union([
-          import_v43.z.string(),
-          import_v43.z.object({
-            url: import_v43.z.string(),
-            detail: import_v43.z.string().nullable()
+      z3.object({
+        type: z3.literal("image_url"),
+        image_url: z3.union([
+          z3.string(),
+          z3.object({
+            url: z3.string(),
+            detail: z3.string().nullable()
           })
         ])
       }),
-      import_v43.z.object({
-        type: import_v43.z.literal("reference"),
-        reference_ids: import_v43.z.array(import_v43.z.union([import_v43.z.string(), import_v43.z.number()]))
+      z3.object({
+        type: z3.literal("reference"),
+        reference_ids: z3.array(z3.union([z3.string(), z3.number()]))
       }),
-      import_v43.z.object({
-        type: import_v43.z.literal("thinking"),
-        thinking: import_v43.z.array(
-          import_v43.z.object({
-            type: import_v43.z.literal("text"),
-            text: import_v43.z.string()
+      z3.object({
+        type: z3.literal("thinking"),
+        thinking: z3.array(
+          z3.object({
+            type: z3.literal("text"),
+            text: z3.string()
           })
         )
       })
     ])
   )
 ]).nullish();
-var mistralUsageSchema = import_v43.z.object({
-  prompt_tokens: import_v43.z.number(),
-  completion_tokens: import_v43.z.number(),
-  total_tokens: import_v43.z.number()
+var mistralUsageSchema = z3.object({
+  prompt_tokens: z3.number(),
+  completion_tokens: z3.number(),
+  total_tokens: z3.number(),
+  num_cached_tokens: z3.number().nullish(),
+  prompt_tokens_details: z3.object({ cached_tokens: z3.number().nullish() }).nullish(),
+  prompt_token_details: z3.object({ cached_tokens: z3.number().nullish() }).nullish()
 });
-var mistralChatResponseSchema = import_v43.z.object({
-  id: import_v43.z.string().nullish(),
-  created: import_v43.z.number().nullish(),
-  model: import_v43.z.string().nullish(),
-  choices: import_v43.z.array(
-    import_v43.z.object({
-      message: import_v43.z.object({
-        role: import_v43.z.literal("assistant"),
+var mistralChatResponseSchema = z3.object({
+  id: z3.string().nullish(),
+  created: z3.number().nullish(),
+  model: z3.string().nullish(),
+  choices: z3.array(
+    z3.object({
+      message: z3.object({
+        role: z3.literal("assistant"),
         content: mistralContentSchema,
-        tool_calls: import_v43.z.array(
-          import_v43.z.object({
-            id: import_v43.z.string(),
-            function: import_v43.z.object({ name: import_v43.z.string(), arguments: import_v43.z.string() })
+        tool_calls: z3.array(
+          z3.object({
+            id: z3.string(),
+            function: z3.object({ name: z3.string(), arguments: z3.string() })
           })
         ).nullish()
       }),
-      index: import_v43.z.number(),
-      finish_reason: import_v43.z.string().nullish()
+      index: z3.number(),
+      finish_reason: z3.string().nullish()
     })
   ),
-  object: import_v43.z.literal("chat.completion"),
+  object: z3.literal("chat.completion"),
   usage: mistralUsageSchema
 });
-var mistralChatChunkSchema = import_v43.z.object({
-  id: import_v43.z.string().nullish(),
-  created: import_v43.z.number().nullish(),
-  model: import_v43.z.string().nullish(),
-  choices: import_v43.z.array(
-    import_v43.z.object({
-      delta: import_v43.z.object({
-        role: import_v43.z.enum(["assistant"]).optional(),
+var mistralChatChunkSchema = z3.object({
+  id: z3.string().nullish(),
+  created: z3.number().nullish(),
+  model: z3.string().nullish(),
+  choices: z3.array(
+    z3.object({
+      delta: z3.object({
+        role: z3.enum(["assistant"]).optional(),
         content: mistralContentSchema,
-        tool_calls: import_v43.z.array(
-          import_v43.z.object({
-            id: import_v43.z.string(),
-            function: import_v43.z.object({ name: import_v43.z.string(), arguments: import_v43.z.string() })
+        tool_calls: z3.array(
+          z3.object({
+            id: z3.string(),
+            function: z3.object({ name: z3.string(), arguments: z3.string() })
           })
         ).nullish()
       }),
-      finish_reason: import_v43.z.string().nullish(),
-      index: import_v43.z.number()
+      finish_reason: z3.string().nullish(),
+      index: z3.number()
     })
   ),
   usage: mistralUsageSchema.nullish()
 });
 
 // src/mistral-embedding-model.ts
-var import_provider3 = require("@ai-sdk/provider");
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var import_v44 = require("zod/v4");
-var MistralEmbeddingModel = class {
+import {
+  TooManyEmbeddingValuesForCallError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders as combineHeaders2,
+  createJsonResponseHandler as createJsonResponseHandler2,
+  postJsonToApi as postJsonToApi2,
+  serializeModelOptions as serializeModelOptions2,
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2,
+  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2
+} from "@ai-sdk/provider-utils";
+import { z as z4 } from "zod/v4";
+var MistralEmbeddingModel = class _MistralEmbeddingModel {
   constructor(modelId, config) {
     this.specificationVersion = "v4";
     this.maxEmbeddingsPerCall = 32;
@@ -782,13 +858,23 @@ var MistralEmbeddingModel = class {
   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
   }) {
+    var _a, _b;
     if (values.length > this.maxEmbeddingsPerCall) {
-      throw new import_provider3.TooManyEmbeddingValuesForCallError({
+      throw new TooManyEmbeddingValuesForCallError({
         provider: this.provider,
         modelId: this.modelId,
         maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
@@ -799,16 +885,16 @@ var MistralEmbeddingModel = class {
       responseHeaders,
       value: response,
       rawValue
-    } = await (0, import_provider_utils4.postJsonToApi)({
+    } = await postJsonToApi2({
       url: `${this.config.baseURL}/embeddings`,
-      headers: (0, import_provider_utils4.combineHeaders)(this.config.headers(), headers),
+      headers: combineHeaders2((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), headers),
       body: {
         model: this.modelId,
         input: values,
         encoding_format: "float"
       },
       failedResponseHandler: mistralFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler2(
         MistralTextEmbeddingResponseSchema
       ),
       abortSignal,
@@ -822,21 +908,21 @@ var MistralEmbeddingModel = class {
     };
   }
 };
-var MistralTextEmbeddingResponseSchema = import_v44.z.object({
-  data: import_v44.z.array(import_v44.z.object({ embedding: import_v44.z.array(import_v44.z.number()) })),
-  usage: import_v44.z.object({ prompt_tokens: import_v44.z.number() }).nullish()
+var MistralTextEmbeddingResponseSchema = z4.object({
+  data: z4.array(z4.object({ embedding: z4.array(z4.number()) })),
+  usage: z4.object({ prompt_tokens: z4.number() }).nullish()
 });
 
 // src/version.ts
-var VERSION = true ? "4.0.0-beta.4" : "0.0.0-test";
+var VERSION = true ? "4.0.0-beta.55" : "0.0.0-test";
 
 // src/mistral-provider.ts
 function createMistral(options = {}) {
   var _a;
-  const baseURL = (_a = (0, import_provider_utils5.withoutTrailingSlash)(options.baseURL)) != null ? _a : "https://api.mistral.ai/v1";
-  const getHeaders = () => (0, import_provider_utils5.withUserAgentSuffix)(
+  const baseURL = (_a = withoutTrailingSlash(options.baseURL)) != null ? _a : "https://api.mistral.ai/v1";
+  const getHeaders = () => withUserAgentSuffix(
     {
-      Authorization: `Bearer ${(0, import_provider_utils5.loadApiKey)({
+      Authorization: `Bearer ${loadApiKey({
         apiKey: options.apiKey,
         environmentVariableName: "MISTRAL_API_KEY",
         description: "Mistral"
@@ -874,15 +960,14 @@ function createMistral(options = {}) {
   provider.textEmbedding = createEmbeddingModel;
   provider.textEmbeddingModel = createEmbeddingModel;
   provider.imageModel = (modelId) => {
-    throw new import_provider4.NoSuchModelError({ modelId, modelType: "imageModel" });
+    throw new NoSuchModelError({ modelId, modelType: "imageModel" });
   };
   return provider;
 }
 var mistral = createMistral();
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   VERSION,
   createMistral,
   mistral
-});
+};
 //# sourceMappingURL=index.js.map