@ai-sdk/mistral 3.0.61 → 3.0.63

package/dist/index.mjs

@@ -21,9 +21,30 @@ import {
   parseProviderOptions,
   postJsonToApi
 } from "@ai-sdk/provider-utils";
-import { z as z3 } from "zod/v4";
+import { z as z4 } from "zod/v4";
 
 // src/convert-mistral-usage.ts
+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()
+}).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()
+}).catchall(z.json());
 function convertMistralUsage(usage) {
   var _a, _b, _c, _d, _e;
   if (usage == null) {
@@ -232,53 +253,53 @@ function mapMistralFinishReason(finishReason) {
 }
 
 // src/mistral-chat-options.ts
-import { z } from "zod/v4";
-var mistralLanguageModelOptions = z.object({
+import { z as z2 } from "zod/v4";
+var mistralLanguageModelOptions = z2.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(),
+  safePrompt: z2.boolean().optional(),
+  documentImageLimit: z2.number().optional(),
+  documentPageLimit: z2.number().optional(),
   /**
    * Whether to use structured outputs.
    *
    * @default true
    */
-  structuredOutputs: z.boolean().optional(),
+  structuredOutputs: z2.boolean().optional(),
   /**
    * Whether to use strict JSON schema validation.
    *
    * @default false
    */
-  strictJsonSchema: z.boolean().optional(),
+  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: z.boolean().optional(),
+  parallelToolCalls: z2.boolean().optional(),
   /**
    * Controls the reasoning effort for models that support adjustable reasoning.
    *
    * - `'high'`: Enable reasoning
    * - `'none'`: Disable reasoning
    */
-  reasoningEffort: z.enum(["high", "none"]).optional()
+  reasoningEffort: z2.enum(["high", "none"]).optional()
 });
 
 // src/mistral-error.ts
 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()
+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()
 });
 var mistralFailedResponseHandler = createJsonErrorResponseHandler({
   errorSchema: mistralErrorDataSchema,
@@ -729,93 +750,85 @@ function extractTextContent(content) {
   }
   return textContent.length ? textContent.join("") : void 0;
 }
-var mistralContentSchema = z3.union([
-  z3.string(),
-  z3.array(
-    z3.discriminatedUnion("type", [
-      z3.object({
-        type: z3.literal("text"),
-        text: z3.string()
+var mistralContentSchema = z4.union([
+  z4.string(),
+  z4.array(
+    z4.discriminatedUnion("type", [
+      z4.object({
+        type: z4.literal("text"),
+        text: z4.string()
       }),
-      z3.object({
-        type: z3.literal("image_url"),
-        image_url: z3.union([
-          z3.string(),
-          z3.object({
-            url: z3.string(),
-            detail: z3.string().nullable()
+      z4.object({
+        type: z4.literal("image_url"),
+        image_url: z4.union([
+          z4.string(),
+          z4.object({
+            url: z4.string(),
+            detail: z4.string().nullable()
           })
         ])
       }),
-      z3.object({
-        type: z3.literal("reference"),
-        reference_ids: z3.array(z3.union([z3.string(), z3.number()]))
+      z4.object({
+        type: z4.literal("reference"),
+        reference_ids: z4.array(z4.union([z4.string(), z4.number()]))
       }),
-      z3.object({
-        type: z3.literal("thinking"),
-        thinking: z3.array(
-          z3.object({
-            type: z3.literal("text"),
-            text: z3.string()
+      z4.object({
+        type: z4.literal("thinking"),
+        thinking: z4.array(
+          z4.object({
+            type: z4.literal("text"),
+            text: z4.string()
           })
         )
       })
     ])
   )
 ]).nullish();
-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 = 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"),
+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: z3.array(
-          z3.object({
-            id: z3.string(),
-            function: z3.object({ name: z3.string(), arguments: z3.string() })
+        tool_calls: z4.array(
+          z4.object({
+            id: z4.string(),
+            function: z4.object({ name: z4.string(), arguments: z4.string() })
           })
         ).nullish()
       }),
-      index: z3.number(),
-      finish_reason: z3.string().nullish()
+      index: z4.number(),
+      finish_reason: z4.string().nullish()
     })
   ),
-  object: z3.literal("chat.completion"),
+  object: z4.literal("chat.completion"),
   usage: mistralUsageSchema
 });
-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(),
+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: z3.array(
-          z3.object({
-            index: z3.number().nullish(),
-            id: z3.string().nullish(),
-            function: z3.object({
-              name: z3.string().nullish(),
-              arguments: z3.string().nullish()
+        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: z3.string().nullish(),
-      index: z3.number()
+      finish_reason: z4.string().nullish(),
+      index: z4.number()
     })
   ),
   usage: mistralUsageSchema.nullish()
@@ -830,7 +843,7 @@ import {
   createJsonResponseHandler as createJsonResponseHandler2,
   postJsonToApi as postJsonToApi2
 } from "@ai-sdk/provider-utils";
-import { z as z4 } from "zod/v4";
+import { z as z5 } from "zod/v4";
 var MistralEmbeddingModel = class {
   constructor(modelId, config) {
     this.specificationVersion = "v3";
@@ -882,9 +895,9 @@ var MistralEmbeddingModel = class {
     };
   }
 };
-var MistralTextEmbeddingResponseSchema = z4.object({
-  data: z4.array(z4.object({ embedding: z4.array(z4.number()) })),
-  usage: z4.object({ prompt_tokens: z4.number() }).nullish()
+var MistralTextEmbeddingResponseSchema = z5.object({
+  data: z5.array(z5.object({ embedding: z5.array(z5.number()) })),
+  usage: z5.object({ prompt_tokens: z5.number() }).nullish()
 });
 
 // src/mistral-speech-model.ts
@@ -894,17 +907,17 @@ import {
   parseProviderOptions as parseProviderOptions2,
   postToApi
 } from "@ai-sdk/provider-utils";
-import { z as z6 } from "zod/v4";
+import { z as z7 } from "zod/v4";
 
 // src/mistral-speech-model-options.ts
-import { z as z5 } from "zod/v4";
-var mistralSpeechModelOptions = z5.object({
+import { z as z6 } from "zod/v4";
+var mistralSpeechModelOptions = z6.object({
   /**
    * Base64-encoded reference audio for one-off voice cloning.
    *
    * When provided, this takes precedence over the standard `voice` option.
    */
-  refAudio: z5.string().min(1).optional()
+  refAudio: z6.string().min(1).optional()
 });
 
 // src/mistral-speech-model.ts
@@ -1019,12 +1032,12 @@ var MistralSpeechModel = class {
     };
   }
 };
-var mistralSpeechResponseSchema = z6.object({
-  audio_data: z6.string()
+var mistralSpeechResponseSchema = z7.object({
+  audio_data: z7.string()
 });
 
 // src/version.ts
-var VERSION = true ? "3.0.61" : "0.0.0-test";
+var VERSION = true ? "3.0.63" : "0.0.0-test";
 
 // src/mistral-provider.ts
 function createMistral(options = {}) {