@ai-sdk/mistral 4.0.68 → 4.0.69

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,3 +1,8 @@
+import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
+} from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
 export type MistralSpeechModelId =
@@ -5,15 +10,19 @@ export type MistralSpeechModelId =
   | '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<
+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,
@@ -174,6 +176,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.ts

@@ -5,6 +5,8 @@ import {
   type TranscriptionModelV4,
 } from '@ai-sdk/provider';
 import {
+  lazySchema,
+  zodSchema,
   combineHeaders,
   convertBase64ToUint8Array,
   createJsonResponseHandler,
@@ -229,29 +231,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(),
+    }),
+  ),
+);