@ai-sdk/mistral 3.0.73 → 3.0.75

package/dist/index.mjs

@@ -13,6 +13,8 @@ import {
   InvalidResponseDataError
 } from "@ai-sdk/provider";
 import {
+  lazySchema as lazySchema3,
+  zodSchema as zodSchema3,
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonResponseHandler,
@@ -253,54 +255,70 @@ function mapMistralFinishReason(finishReason) {
 }
 
 // src/mistral-chat-options.ts
+import {
+  lazySchema,
+  zodSchema
+} from "@ai-sdk/provider-utils";
 import { z as z2 } from "zod/v4";
-var mistralLanguageModelOptions = z2.object({
-  /**
-   * Whether to inject a safety prompt before all conversations.
-   *
-   * Defaults to `false`.
-   */
-  safePrompt: z2.boolean().optional(),
-  documentImageLimit: z2.number().optional(),
-  documentPageLimit: z2.number().optional(),
-  /**
-   * Whether to use structured outputs.
-   *
-   * @default true
-   */
-  structuredOutputs: z2.boolean().optional(),
-  /**
-   * Whether to use strict JSON schema validation.
-   *
-   * @default false
-   */
-  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: z2.boolean().optional(),
-  /**
-   * Controls the reasoning effort for models that support adjustable reasoning.
-   *
-   * - `'high'`: Enable reasoning
-   * - `'none'`: Disable reasoning
-   */
-  reasoningEffort: z2.enum(["high", "none"]).optional()
-});
+var mistralLanguageModelOptions = lazySchema(
+  () => zodSchema(
+    z2.object({
+      /**
+       * Whether to inject a safety prompt before all conversations.
+       *
+       * Defaults to `false`.
+       */
+      safePrompt: z2.boolean().optional(),
+      documentImageLimit: z2.number().optional(),
+      documentPageLimit: z2.number().optional(),
+      /**
+       * Whether to use structured outputs.
+       *
+       * @default true
+       */
+      structuredOutputs: z2.boolean().optional(),
+      /**
+       * Whether to use strict JSON schema validation.
+       *
+       * @default false
+       */
+      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: z2.boolean().optional(),
+      /**
+       * Controls the reasoning effort for models that support adjustable reasoning.
+       *
+       * - `'high'`: Enable reasoning
+       * - `'none'`: Disable reasoning
+       */
+      reasoningEffort: z2.enum(["high", "none"]).optional()
+    })
+  )
+);
 
 // src/mistral-error.ts
-import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
+import {
+  lazySchema as lazySchema2,
+  zodSchema as zodSchema2,
+  createJsonErrorResponseHandler
+} from "@ai-sdk/provider-utils";
 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 mistralErrorDataSchema = lazySchema2(
+  () => zodSchema2(
+    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,
   errorToMessage: (data) => data.message
@@ -750,7 +768,7 @@ function extractTextContent(content) {
   }
   return textContent.length ? textContent.join("") : void 0;
 }
-var mistralContentSchema = z4.union([
+var mistralContentSchema = () => z4.union([
   z4.string(),
   z4.array(
     z4.discriminatedUnion("type", [
@@ -784,61 +802,74 @@ var mistralContentSchema = z4.union([
     ])
   )
 ]).nullish();
-var mistralChatResponseSchema = z4.object({
-  id: z4.string().nullish(),
-  created: z4.number().nullish(),
-  model: z4.string().nullish(),
-  choices: z4.array(
+var mistralChatResponseSchema = lazySchema3(
+  () => zodSchema3(
     z4.object({
-      message: z4.object({
-        role: z4.literal("assistant"),
-        content: mistralContentSchema,
-        tool_calls: z4.array(
-          z4.object({
-            id: z4.string(),
-            function: z4.object({ name: z4.string(), arguments: z4.string() })
-          })
-        ).nullish()
-      }),
-      index: z4.number(),
-      finish_reason: z4.string().nullish()
+      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: z4.array(
+              z4.object({
+                id: z4.string(),
+                function: z4.object({
+                  name: z4.string(),
+                  arguments: z4.string()
+                })
+              })
+            ).nullish()
+          }),
+          index: z4.number(),
+          finish_reason: z4.string().nullish()
+        })
+      ),
+      object: z4.literal("chat.completion"),
+      usage: mistralUsageSchema
     })
-  ),
-  object: z4.literal("chat.completion"),
-  usage: mistralUsageSchema
-});
-var mistralChatChunkSchema = z4.object({
-  id: z4.string().nullish(),
-  created: z4.number().nullish(),
-  model: z4.string().nullish(),
-  choices: z4.array(
+  )
+);
+var mistralChatChunkSchema = lazySchema3(
+  () => zodSchema3(
     z4.object({
-      delta: z4.object({
-        role: z4.enum(["assistant"]).optional(),
-        content: mistralContentSchema,
-        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: z4.string().nullish(),
-      index: z4.number()
+      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: 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: z4.string().nullish(),
+          index: z4.number()
+        })
+      ),
+      usage: mistralUsageSchema.nullish()
     })
-  ),
-  usage: mistralUsageSchema.nullish()
-});
+  )
+);
 
 // src/mistral-embedding-model.ts
 import {
   TooManyEmbeddingValuesForCallError
 } from "@ai-sdk/provider";
 import {
+  lazySchema as lazySchema4,
+  zodSchema as zodSchema4,
   combineHeaders as combineHeaders2,
   createJsonResponseHandler as createJsonResponseHandler2,
   postJsonToApi as postJsonToApi2
@@ -895,13 +926,19 @@ var MistralEmbeddingModel = class {
     };
   }
 };
-var MistralTextEmbeddingResponseSchema = z5.object({
-  data: z5.array(z5.object({ embedding: z5.array(z5.number()) })),
-  usage: z5.object({ prompt_tokens: z5.number() }).nullish()
-});
+var MistralTextEmbeddingResponseSchema = lazySchema4(
+  () => zodSchema4(
+    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
 import {
+  lazySchema as lazySchema6,
+  zodSchema as zodSchema6,
   combineHeaders as combineHeaders3,
   createJsonResponseHandler as createJsonResponseHandler3,
   parseProviderOptions as parseProviderOptions2,
@@ -910,15 +947,23 @@ import {
 import { z as z7 } from "zod/v4";
 
 // src/mistral-speech-model-options.ts
+import {
+  lazySchema as lazySchema5,
+  zodSchema as zodSchema5
+} from "@ai-sdk/provider-utils";
 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: z6.string().min(1).optional()
-});
+var mistralSpeechModelOptions = lazySchema5(
+  () => zodSchema5(
+    z6.object({
+      /**
+       * Base64-encoded reference audio for one-off voice cloning.
+       *
+       * When provided, this takes precedence over the standard `voice` option.
+       */
+      refAudio: z6.string().min(1).optional()
+    })
+  )
+);
 
 // src/mistral-speech-model.ts
 var MistralSpeechModel = class {
@@ -1032,12 +1077,16 @@ var MistralSpeechModel = class {
     };
   }
 };
-var mistralSpeechResponseSchema = z7.object({
-  audio_data: z7.string()
-});
+var mistralSpeechResponseSchema = lazySchema6(
+  () => zodSchema6(
+    z7.object({
+      audio_data: z7.string()
+    })
+  )
+);
 
 // src/version.ts
-var VERSION = true ? "3.0.73" : "0.0.0-test";
+var VERSION = true ? "3.0.75" : "0.0.0-test";
 
 // src/mistral-provider.ts
 function createMistral(options = {}) {