@ai-sdk/mistral 3.0.74 → 3.0.76

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

@@ -10,6 +10,9 @@ import {
   type SharedV3Warning,
 } from '@ai-sdk/provider';
 import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonResponseHandler,
@@ -300,7 +303,7 @@ export class MistralChatLanguageModel implements LanguageModelV3 {
     return {
       stream: response.pipeThrough(
         new TransformStream<
-          ParseResult<z.infer<typeof mistralChatChunkSchema>>,
+          ParseResult<InferSchema<typeof mistralChatChunkSchema>>,
           LanguageModelV3StreamPart
         >({
           start(controller) {
@@ -506,7 +509,9 @@ function extractReasoningContent(
     .join('');
 }
 
-function extractTextContent(content: z.infer<typeof mistralContentSchema>) {
+function extractTextContent(
+  content: z.infer<ReturnType<typeof mistralContentSchema>>,
+) {
   if (typeof content === 'string') {
     return content;
   }
@@ -539,98 +544,110 @@ function extractTextContent(content: z.infer<typeof mistralContentSchema>) {
   return textContent.length ? textContent.join('') : undefined;
 }
 
-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 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();
 
 // limited version of the schema, focussed on what is needed for the implementation
 // this approach limits breakages when the API changes and increases efficiency
-const mistralChatResponseSchema = z.object({
-  id: z.string().nullish(),
-  created: z.number().nullish(),
-  model: z.string().nullish(),
-  choices: z.array(
+const mistralChatResponseSchema = lazySchema(() =>
+  zodSchema(
     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(),
+      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,
     }),
   ),
-  object: z.literal('chat.completion'),
-  usage: mistralUsageSchema,
-});
+);
 
 // limited version of the schema, focussed on what is needed for the implementation
 // this approach limits breakages when the API changes and increases efficiency
-const mistralChatChunkSchema = z.object({
-  id: z.string().nullish(),
-  created: z.number().nullish(),
-  model: z.string().nullish(),
-  choices: z.array(
+const mistralChatChunkSchema = lazySchema(() =>
+  zodSchema(
     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(),
+      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(),
     }),
   ),
-  usage: mistralUsageSchema.nullish(),
-});
+);

package/src/mistral-chat-options.ts

@@ -1,3 +1,8 @@
+import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
+} from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
 // https://docs.mistral.ai/getting-started/models/models_overview/
@@ -24,48 +29,52 @@ export type MistralChatModelId =
   | 'magistral-small-2509'
   | (string & {});
 
-export const mistralLanguageModelOptions = z.object({
-  /**
-   * Whether to inject a safety prompt before all conversations.
-   *
-   * Defaults to `false`.
-   */
-  safePrompt: z.boolean().optional(),
+export const mistralLanguageModelOptions = lazySchema(() =>
+  zodSchema(
+    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(),
+      documentImageLimit: z.number().optional(),
+      documentPageLimit: z.number().optional(),
 
-  /**
-   * Whether to use structured outputs.
-   *
-   * @default true
-   */
-  structuredOutputs: z.boolean().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 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(),
+      /**
+       * 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(),
 
-  /**
-   * Controls the reasoning effort for models that support adjustable reasoning.
-   *
-   * - `'high'`: Enable reasoning
-   * - `'none'`: Disable reasoning
-   */
-  reasoningEffort: z.enum(['high', 'none']).optional(),
-});
+      /**
+       * Controls the reasoning effort for models that support adjustable reasoning.
+       *
+       * - `'high'`: Enable reasoning
+       * - `'none'`: Disable reasoning
+       */
+      reasoningEffort: z.enum(['high', 'none']).optional(),
+    }),
+  ),
+);
 
-export type MistralLanguageModelOptions = z.infer<
+export type MistralLanguageModelOptions = InferSchema<
   typeof mistralLanguageModelOptions
 >;

package/src/mistral-embedding-model.ts

@@ -3,6 +3,8 @@ import {
   type EmbeddingModelV3,
 } from '@ai-sdk/provider';
 import {
+  lazySchema,
+  zodSchema,
   combineHeaders,
   createJsonResponseHandler,
   postJsonToApi,
@@ -88,7 +90,11 @@ export class MistralEmbeddingModel implements EmbeddingModelV3 {
 
 // 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,16 +1,44 @@
+import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
+} from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
-export type MistralSpeechModelId = 'voxtral-mini-tts-2603' | (string & {});
+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 { SharedV3Warning, SpeechModelV3 } from '@ai-sdk/provider';
 import {
+  lazySchema,
+  zodSchema,
   combineHeaders,
   createJsonResponseHandler,
   parseProviderOptions,
@@ -99,6 +101,8 @@ export class MistralSpeechModel implements SpeechModelV3 {
       input: text,
       voice_id: refAudio == null ? voice : undefined,
       ref_audio: refAudio,
+      expressiveness: mistralOptions?.expressiveness,
+      phoneme_hints: mistralOptions?.phonemeHints,
       response_format: responseFormat,
       stream: false,
     };
@@ -157,6 +161,10 @@ export class MistralSpeechModel implements SpeechModelV3 {
   }
 }
 
-const mistralSpeechResponseSchema = z.object({
-  audio_data: z.string(),
-});
+const mistralSpeechResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      audio_data: z.string(),
+    }),
+  ),
+);