@ai-sdk/mistral 4.0.68 → 4.0.70

package/src/mistral-conversation-language-model.ts

@@ -13,6 +13,9 @@ import type {
   SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonResponseHandler,
@@ -389,7 +392,7 @@ export class MistralConversationLanguageModel implements LanguageModelV4 {
     return {
       stream: response.pipeThrough(
         new TransformStream<
-          ParseResult<z.infer<typeof mistralConversationChunkSchema>>,
+          ParseResult<InferSchema<typeof mistralConversationChunkSchema>>,
           LanguageModelV4StreamPart
         >({
           start(controller) {
@@ -573,7 +576,7 @@ function createContentConverter({
   return {
     toolNameMapping,
     convertChunk(
-      chunk: z.infer<typeof mistralConversationContentSchema>,
+      chunk: z.infer<ReturnType<typeof mistralConversationContentSchema>>,
     ): Array<
       LanguageModelV4Text | LanguageModelV4Reasoning | LanguageModelV4Source
     > {
@@ -604,7 +607,9 @@ function createContentConverter({
       }
     },
     convertTool(
-      output: z.infer<typeof mistralConversationToolExecutionSchema>,
+      output: z.infer<
+        ReturnType<typeof mistralConversationToolExecutionSchema>
+      >,
     ): [LanguageModelV4ToolCall, LanguageModelV4ToolResult] {
       const toolName = toolNameMapping.toCustomToolName(output.name);
       return [
@@ -633,98 +638,110 @@ function createContentConverter({
   };
 }
 
-const mistralConversationContentSchema = z.discriminatedUnion('type', [
-  z.object({ type: z.literal('text'), text: z.string() }),
+const mistralConversationContentSchema = () =>
+  z.discriminatedUnion('type', [
+    z.object({ type: z.literal('text'), text: z.string() }),
+    z.object({
+      type: z.literal('thinking'),
+      thinking: z.array(
+        z.object({ type: z.literal('text'), text: z.string() }),
+      ),
+    }),
+    z.object({
+      type: z.literal('tool_reference'),
+      tool: z.string().nullish(),
+      title: z.string().nullish(),
+      url: z.string().nullish(),
+    }),
+  ]);
+const mistralConversationMessageContentSchema = () =>
+  z.union([z.string(), z.array(mistralConversationContentSchema())]);
+const mistralConversationToolExecutionSchema = () =>
   z.object({
-    type: z.literal('thinking'),
-    thinking: z.array(z.object({ type: z.literal('text'), text: z.string() })),
-  }),
+    type: z.literal('tool.execution'),
+    id: z.string(),
+    name: z.string(),
+    arguments: z.string(),
+    function: z.string().nullish(),
+    info: z.record(z.string(), z.json()).nullish(),
+  });
+const mistralConversationFunctionCallSchema = () =>
   z.object({
-    type: z.literal('tool_reference'),
-    tool: z.string().nullish(),
-    title: z.string().nullish(),
-    url: z.string().nullish(),
-  }),
-]);
-const mistralConversationMessageContentSchema = z.union([
-  z.string(),
-  z.array(mistralConversationContentSchema),
-]);
-const mistralConversationToolExecutionSchema = z.object({
-  type: z.literal('tool.execution'),
-  id: z.string(),
-  name: z.string(),
-  arguments: z.string(),
-  function: z.string().nullish(),
-  info: z.record(z.string(), z.json()).nullish(),
-});
-const mistralConversationFunctionCallSchema = z.object({
-  type: z.literal('function.call'),
-  tool_call_id: z.string(),
-  name: z.string(),
-  arguments: z.union([z.string(), z.record(z.string(), z.json())]),
-});
-const mistralConversationUsageSchema = mistralUsageSchema.extend({
-  prompt_tokens: z.number().default(0),
-  completion_tokens: z.number().default(0),
-  total_tokens: z.number().default(0),
-});
-const mistralConversationResponseSchema = z.object({
-  conversation_id: z.string(),
-  outputs: z.array(
+    type: z.literal('function.call'),
+    tool_call_id: z.string(),
+    name: z.string(),
+    arguments: z.union([z.string(), z.record(z.string(), z.json())]),
+  });
+const mistralConversationUsageSchema = () =>
+  mistralUsageSchema.extend({
+    prompt_tokens: z.number().default(0),
+    completion_tokens: z.number().default(0),
+    total_tokens: z.number().default(0),
+  });
+const mistralConversationResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      conversation_id: z.string(),
+      outputs: z.array(
+        z.discriminatedUnion('type', [
+          mistralConversationToolExecutionSchema(),
+          mistralConversationFunctionCallSchema(),
+          z.object({
+            type: z.literal('message.output'),
+            content: mistralConversationMessageContentSchema(),
+            model: z.string().nullish(),
+          }),
+        ]),
+      ),
+      usage: mistralConversationUsageSchema().nullish(),
+    }),
+  ),
+);
+const mistralConversationChunkSchema = lazySchema(() =>
+  zodSchema(
     z.discriminatedUnion('type', [
-      mistralConversationToolExecutionSchema,
-      mistralConversationFunctionCallSchema,
       z.object({
-        type: z.literal('message.output'),
-        content: mistralConversationMessageContentSchema,
+        type: z.literal('conversation.response.started'),
+        conversation_id: z.string(),
+        created_at: z.string().nullish(),
+      }),
+      z.object({
+        type: z.literal('conversation.response.done'),
+        usage: mistralConversationUsageSchema().nullish(),
+      }),
+      z.object({
+        type: z.literal('conversation.response.error'),
+        message: z.string(),
+        code: z.number(),
+      }),
+      z.object({
+        type: z.literal('message.output.delta'),
+        id: z.string(),
+        content_index: z.number().nullish(),
+        content: z.union([z.string(), mistralConversationContentSchema()]),
         model: z.string().nullish(),
       }),
+      z.object({
+        type: z.literal('function.call.delta'),
+        tool_call_id: z.string(),
+        name: z.string(),
+        arguments: z.string(),
+        output_index: z.number().nullish(),
+      }),
+      z.object({
+        type: z.enum(['tool.execution.started', 'tool.execution.delta']),
+        id: z.string(),
+        name: z.string(),
+        arguments: z.string(),
+        function: z.string().nullish(),
+      }),
+      z.object({
+        type: z.literal('tool.execution.done'),
+        id: z.string(),
+        name: z.string(),
+        function: z.string().nullish(),
+        info: z.record(z.string(), z.json()).nullish(),
+      }),
     ]),
   ),
-  usage: mistralConversationUsageSchema.nullish(),
-});
-const mistralConversationChunkSchema = z.discriminatedUnion('type', [
-  z.object({
-    type: z.literal('conversation.response.started'),
-    conversation_id: z.string(),
-    created_at: z.string().nullish(),
-  }),
-  z.object({
-    type: z.literal('conversation.response.done'),
-    usage: mistralConversationUsageSchema.nullish(),
-  }),
-  z.object({
-    type: z.literal('conversation.response.error'),
-    message: z.string(),
-    code: z.number(),
-  }),
-  z.object({
-    type: z.literal('message.output.delta'),
-    id: z.string(),
-    content_index: z.number().nullish(),
-    content: z.union([z.string(), mistralConversationContentSchema]),
-    model: z.string().nullish(),
-  }),
-  z.object({
-    type: z.literal('function.call.delta'),
-    tool_call_id: z.string(),
-    name: z.string(),
-    arguments: z.string(),
-    output_index: z.number().nullish(),
-  }),
-  z.object({
-    type: z.enum(['tool.execution.started', 'tool.execution.delta']),
-    id: z.string(),
-    name: z.string(),
-    arguments: z.string(),
-    function: z.string().nullish(),
-  }),
-  z.object({
-    type: z.literal('tool.execution.done'),
-    id: z.string(),
-    name: z.string(),
-    function: z.string().nullish(),
-    info: z.record(z.string(), z.json()).nullish(),
-  }),
-]);
+);

package/src/mistral-embedding-model.ts

@@ -3,6 +3,8 @@ import {
   type EmbeddingModelV4,
 } from '@ai-sdk/provider';
 import {
+  lazySchema,
+  zodSchema,
   combineHeaders,
   createJsonResponseHandler,
   parseProviderOptions,
@@ -121,7 +123,11 @@ export class MistralEmbeddingModel implements EmbeddingModelV4 {
 
 // minimal version of the schema, focussed on what is needed for the implementation
 // this approach limits breakages when the API changes and increases efficiency
-const MistralTextEmbeddingResponseSchema = z.object({
-  data: z.array(z.object({ embedding: z.array(z.number()) })),
-  usage: z.object({ prompt_tokens: z.number() }).nullish(),
-});
+const MistralTextEmbeddingResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      data: z.array(z.object({ embedding: z.array(z.number()) })),
+      usage: z.object({ prompt_tokens: z.number() }).nullish(),
+    }),
+  ),
+);

package/src/mistral-error.ts

@@ -1,15 +1,24 @@
-import { createJsonErrorResponseHandler } from '@ai-sdk/provider-utils';
+import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
+  createJsonErrorResponseHandler,
+} from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
-const mistralErrorDataSchema = z.object({
-  object: z.literal('error'),
-  message: z.string(),
-  type: z.string(),
-  param: z.string().nullable(),
-  code: z.string().nullable(),
-});
+const mistralErrorDataSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      object: z.literal('error'),
+      message: z.string(),
+      type: z.string(),
+      param: z.string().nullable(),
+      code: z.string().nullable(),
+    }),
+  ),
+);
 
-export type MistralErrorData = z.infer<typeof mistralErrorDataSchema>;
+export type MistralErrorData = InferSchema<typeof mistralErrorDataSchema>;
 
 export const mistralFailedResponseHandler = createJsonErrorResponseHandler({
   errorSchema: mistralErrorDataSchema,

package/src/mistral-speech-model-options.ts

@@ -1,19 +1,44 @@
+import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
+} from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
 export type MistralSpeechModelId =
   | 'voxtral-mini-tts-2603'
+  | 'voxtral-mini-tts-3-0'
+  | 'voxtral-mini-tts-3'
   | 'voxtral-mini-tts-latest'
   | (string & {});
 
-export 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(),
-});
+export const mistralSpeechModelOptions = lazySchema(() =>
+  zodSchema(
+    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(),
 
-export type MistralSpeechModelOptions = z.infer<
+      /**
+       * How expressive the speech is, from 1 to 5. Higher values trade voice
+       * similarity and stability for stronger delivery. Supported by Voxtral 3.
+       */
+      expressiveness: z.number().min(1).max(5).optional(),
+
+      /**
+       * Pronunciation hints mapping words to lists of IPA phonemes.
+       * Supported by Voxtral 3.
+       */
+      phonemeHints: z
+        .record(z.string().min(1), z.array(z.string().min(1)).min(1))
+        .optional(),
+    }),
+  ),
+);
+
+export type MistralSpeechModelOptions = InferSchema<
   typeof mistralSpeechModelOptions
 >;

package/src/mistral-speech-model.ts

@@ -1,5 +1,7 @@
 import type { SharedV4Warning, SpeechModelV4 } from '@ai-sdk/provider';
 import {
+  lazySchema,
+  zodSchema,
   combineHeaders,
   createJsonResponseHandler,
   parseProviderOptions,
@@ -116,6 +118,8 @@ export class MistralSpeechModel implements SpeechModelV4 {
       input: text,
       voice_id: refAudio == null ? voice : undefined,
       ref_audio: refAudio,
+      expressiveness: mistralOptions?.expressiveness,
+      phoneme_hints: mistralOptions?.phonemeHints,
       response_format: responseFormat,
       stream: false,
     };
@@ -174,6 +178,10 @@ export class MistralSpeechModel implements SpeechModelV4 {
   }
 }
 
-const mistralSpeechResponseSchema = z.object({
-  audio_data: z.string(),
-});
+const mistralSpeechResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      audio_data: z.string(),
+    }),
+  ),
+);

package/src/mistral-transcription-model-options.ts

@@ -8,6 +8,12 @@ import { z } from 'zod/v4';
 export type MistralTranscriptionModelId =
   | 'voxtral-mini-2602'
   | 'voxtral-mini-latest'
+  | 'voxtral-mini-transcribe-3-0'
+  | 'voxtral-mini-transcribe-3'
+  | 'voxtral-mini-transcribe-latest'
+  | 'voxtral-small-transcribe-3-0'
+  | 'voxtral-small-transcribe-3'
+  | 'voxtral-small-transcribe-latest'
   | (string & {});
 
 // https://docs.mistral.ai/api/endpoint/audio/transcriptions
@@ -20,6 +26,11 @@ export const mistralTranscriptionModelOptions = lazySchema(() =>
        */
       language: z.string().min(1).optional(),
 
+      /**
+       * Return the detected language. Cannot be combined with `language`.
+       */
+      returnLanguage: z.boolean().optional(),
+
       /**
        * The sampling temperature.
        */
@@ -27,6 +38,7 @@ export const mistralTranscriptionModelOptions = lazySchema(() =>
 
       /**
        * The timestamp granularities to include in the transcription response.
+       * Voxtral 3 supports segment timestamps only.
        */
       timestampGranularities: z
         .array(z.enum(['segment', 'word']))
@@ -35,6 +47,7 @@ export const mistralTranscriptionModelOptions = lazySchema(() =>
 
       /**
        * Whether to identify speakers in the transcription.
+       * Voxtral 3 requires segment timestamps when diarization is enabled.
        */
       diarize: z.boolean().optional(),
 
@@ -42,21 +55,11 @@ export const mistralTranscriptionModelOptions = lazySchema(() =>
        * 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.
+       * Voxtral 3 also accepts phrases and descriptions of the recording,
+       * including spaces and punctuation. Entries share the context window
+       * with the audio.
        */
-      contextBias: z
-        .array(
-          z
-            .string()
-            .min(1)
-            .regex(
-              /^[^\s,]+$/,
-              'Context bias items must not contain commas or whitespace.',
-            ),
-        )
-        .max(100)
-        .optional(),
+      contextBias: z.array(z.string().min(1)).optional(),
     }),
   ),
 );

package/src/mistral-transcription-model.ts

@@ -5,6 +5,8 @@ import {
   type TranscriptionModelV4,
 } from '@ai-sdk/provider';
 import {
+  lazySchema,
+  zodSchema,
   combineHeaders,
   convertBase64ToUint8Array,
   createJsonResponseHandler,
@@ -71,9 +73,14 @@ export class MistralTranscriptionModel implements TranscriptionModelV4 {
       schema: mistralTranscriptionModelOptions,
     });
 
-    // Mistral documents these options as mutually incompatible. Rejecting the
-    // combination locally provides a stable SDK error instead of an API 4xx.
+    // Restrict only known legacy models so future and custom models can combine
+    // a pinned language with timestamps without an SDK update.
     if (
+      [
+        'voxtral-mini-2507',
+        'voxtral-mini-2602',
+        'voxtral-mini-latest',
+      ].includes(this.modelId) &&
       mistralOptions?.language != null &&
       mistralOptions.timestampGranularities != null
     ) {
@@ -84,6 +91,14 @@ export class MistralTranscriptionModel implements TranscriptionModelV4 {
       });
     }
 
+    if (mistralOptions?.language != null && mistralOptions.returnLanguage) {
+      throw new InvalidArgumentError({
+        argument: 'providerOptions',
+        message:
+          'providerOptions.mistral.language cannot be combined with providerOptions.mistral.returnLanguage',
+      });
+    }
+
     const formData = new FormData();
     const blob =
       audio instanceof Uint8Array
@@ -99,6 +114,11 @@ export class MistralTranscriptionModel implements TranscriptionModelV4 {
 
     if (mistralOptions != null) {
       appendFormValue(formData, 'language', mistralOptions.language);
+      appendFormValue(
+        formData,
+        'return_language',
+        mistralOptions.returnLanguage,
+      );
       appendFormValue(formData, 'temperature', mistralOptions.temperature);
       appendFormValue(
         formData,
@@ -229,29 +249,33 @@ function appendFormValue(
   formData.append(key, String(value));
 }
 
-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(),
-});
+const mistralTranscriptionResponseSchema = lazySchema(() =>
+  zodSchema(
+    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(),
+    }),
+  ),
+);