@ai-sdk/mistral 4.0.68 → 4.0.70

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @ai-sdk/mistral
 
+## 4.0.70
+
+### Patch Changes
+
+- e104368: Add Voxtral 3 offline transcription and speech model IDs. Support transcription context phrases and detected language, update timestamp validation for Voxtral 3, and expose speech expressiveness and pronunciation hints.
+- 43ad966: Report `interrupted` when a stream ends cleanly without its provider completion signal, preserving partial output without emitting an error solely for the interruption.
+
+  This applies to OpenAI (Chat, Responses, and Completions), Anthropic, Google (Generate Content and Interactions), Alibaba, Amazon Bedrock Converse, Cohere, DeepSeek, Groq, Hugging Face Responses, Mistral Chat, Moonshot AI, Open Responses, Perplexity, and xAI Responses. It also covers cutoffs in later Anthropic messages and Google automatic continuations.
+
+  **Compatibility notice:** These streams previously fell back to `other` or omitted the finish part. Applications must now handle `interrupted` in finish-reason switches, mappings, and custom validation. Check `finishReason === 'interrupted'` to detect incomplete responses; interruption alone does not trigger error handling.
+
+  Explicit unknown completion reasons still map to `other`. Actual provider, parsing, and transport errors retain their error paths; affected error paths that previously left the finish reason as `other` now report `error`. OpenAI-compatible remains unchanged.
+
+- Updated dependencies [10026d1]
+  - @ai-sdk/provider@4.0.32
+  - @ai-sdk/provider-utils@5.0.66
+
+## 4.0.69
+
+### Patch Changes
+
+- 77b925f: Defer construction of provider validation schemas until first use to reduce package import time.
+- Updated dependencies [b089ce8]
+- Updated dependencies [39a776b]
+  - @ai-sdk/provider-utils@5.0.65
+
 ## 4.0.68
 
 ### Patch Changes

package/dist/index.d.ts

@@ -3,7 +3,7 @@ import { FetchFunction, InferSchema } from "@ai-sdk/provider-utils";
 import { z } from "zod/v4";
 //#region src/mistral-chat-language-model-options.d.ts
 type MistralChatModelId = 'codestral-2508' | 'codestral-latest' | 'glm-5-2' | 'labs-leanstral-1-5' | 'labs-leanstral-1-5-1' | 'magistral-medium-latest' | 'magistral-small-latest' | 'ministral-14b-2512' | 'ministral-14b-latest' | 'ministral-3b-2512' | 'ministral-3b-latest' | 'ministral-8b-2512' | 'ministral-8b-latest' | 'mistral-code-fim-latest' | 'mistral-code-latest' | 'mistral-large-4' | 'mistral-large-4-0' | 'mistral-large-latest' | 'mistral-large-2512' | 'mistral-medium' | 'mistral-medium-latest' | 'mistral-medium-2604' | 'mistral-medium-3' | 'mistral-medium-3-5' | 'mistral-medium-3.5' | 'mistral-small-2603' | 'mistral-small-latest' | 'mistral-vibe-cli-fast' | 'mistral-vibe-cli-latest' | 'mistral-vibe-cli-with-tools' | 'voxtral-small-2507' | 'voxtral-small-latest' | 'zai-glm-5-2' | (string & {});
-declare const mistralLanguageModelChatOptions: z.ZodObject<{
+declare const mistralLanguageModelChatOptions: () => z.ZodObject<{
   safePrompt: z.ZodOptional<z.ZodBoolean>;
   documentImageLimit: z.ZodOptional<z.ZodNumber>;
   documentPageLimit: z.ZodOptional<z.ZodNumber>;
@@ -16,7 +16,7 @@ declare const mistralLanguageModelChatOptions: z.ZodObject<{
     none: "none";
   }>>;
 }, z.core.$strip>;
-type MistralLanguageModelChatOptions = z.infer<typeof mistralLanguageModelChatOptions>;
+type MistralLanguageModelChatOptions = z.infer<ReturnType<typeof mistralLanguageModelChatOptions>>;
 //#endregion
 //#region src/mistral-embedding-model-options.d.ts
 type MistralEmbeddingModelId = 'mistral-embed' | 'mistral-embed-2312' | 'codestral-embed' | 'codestral-embed-2505' | (string & {});
@@ -34,16 +34,19 @@ declare const mistralEmbeddingModelOptions: z.ZodObject<{
 type MistralEmbeddingModelOptions = z.infer<typeof mistralEmbeddingModelOptions>;
 //#endregion
 //#region src/mistral-speech-model-options.d.ts
-type MistralSpeechModelId = 'voxtral-mini-tts-2603' | 'voxtral-mini-tts-latest' | (string & {});
-declare const mistralSpeechModelOptions: z.ZodObject<{
-  refAudio: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-type MistralSpeechModelOptions = z.infer<typeof mistralSpeechModelOptions>;
+type MistralSpeechModelId = 'voxtral-mini-tts-2603' | 'voxtral-mini-tts-3-0' | 'voxtral-mini-tts-3' | 'voxtral-mini-tts-latest' | (string & {});
+declare const mistralSpeechModelOptions: import("@ai-sdk/provider-utils").LazySchema<{
+  refAudio?: string | undefined;
+  expressiveness?: number | undefined;
+  phonemeHints?: Record<string, string[]> | undefined;
+}>;
+type MistralSpeechModelOptions = InferSchema<typeof mistralSpeechModelOptions>;
 //#endregion
 //#region src/mistral-transcription-model-options.d.ts
-type MistralTranscriptionModelId = 'voxtral-mini-2602' | 'voxtral-mini-latest' | (string & {});
+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 & {});
 declare const mistralTranscriptionModelOptions: import("@ai-sdk/provider-utils").LazySchema<{
   language?: string | undefined;
+  returnLanguage?: boolean | undefined;
   temperature?: number | undefined;
   timestampGranularities?: ("segment" | "word")[] | undefined;
   diarize?: boolean | undefined;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/mistral-chat-language-model-options.ts","../src/mistral-embedding-model-options.ts","../src/mistral-speech-model-options.ts","../src/mistral-transcription-model-options.ts","../src/tool/index.ts","../src/mistral-provider.ts","../src/mistral-conversation-language-model-options.ts","../src/version.ts"],"mappings":";;;;KAGY;cAoCC,iCAA+B,EAAA;;;;;;;;;;;;GA8C1C,EAAA,KAAA;KAEU,kCAAkC,EAAE,aACvC;;;KCtFG;cAOC,8BAA4B,EAAA;;;;;;;;;;GAiBvC,EAAA,KAAA;KAEU,+BAA+B,EAAE,aACpC;;;KC3BG;cAKC,2BAAyB,EAAA;;GAOpC,EAAA,KAAA;KAEU,4BAA4B,EAAE,aACjC;;;KCVG;cAMC,mEAAgC;;;;;;;KAkDjC,mCAAmC,mBACtC;;;cC9DI;;;;;;;;;;;;;;;;;;;;;;UCwBI,wBAAwB;EACvC,cAAc;GACb,SAAS,qBAAqB;;;;EAK/B,cAAc,SAAS,qBAAqB;;;;EAK5C,KAAK,SAAS,qBAAqB;;;;EAKnC,aAAa,SAAS,qBAAqB;;;;EAK3C,UAAU,SAAS,0BAA0B;;;;EAK7C,iBAAiB,SAAS,4BAA4B;;;;EAKtD,OAAO,SAAS,uBAAuB;;;;EAKvC,YAAY,SAAS,uBAAuB;;;;EAK5C,cAAc,SAAS,8BAA8B;;;;EAKrD,mBACE,SAAS,8BACR;;;;EAKH,cAAc,SAAS,0BAA0B;;;;EAKjD,mBAAmB,SAAS,0BAA0B;;UAGvC;;;;;EAKf;;;;;EAMA;;;;EAKA,UAAU;;;;;EAMV,QAAQ;EAER;;;;;wBAMc,cACd,UAAS,0BACR;;;;qBA6FU,SAAO;;;KC1MR,0CACV;;;qBCVW"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/mistral-chat-language-model-options.ts","../src/mistral-embedding-model-options.ts","../src/mistral-speech-model-options.ts","../src/mistral-transcription-model-options.ts","../src/tool/index.ts","../src/mistral-provider.ts","../src/mistral-conversation-language-model-options.ts","../src/version.ts"],"mappings":";;;;KAIY;cAoCC,uCAA+B,EAAA;;;;;;;;;;;;GA+CxC,EAAA,KAAA;KAKQ,kCAAkC,EAAE,MAC9C,kBAAkB;;;KC3FR;cAOC,8BAA4B,EAAA;;;;;;;;;;GAiBvC,EAAA,KAAA;KAEU,+BAA+B,EAAE,aACpC;;;KCtBG;cAOC,4DAAyB;;;iBAAzB;;KA2BD,4BAA4B,mBAC/B;;;KCnCG;cAYC,mEAAgC;;;;;;;;KA+CjC,mCAAmC,mBACtC;;;cCjEI;;;;;;;;;;;;;;;;;;;;;;UCwBI,wBAAwB;EACvC,cAAc;GACb,SAAS,qBAAqB;;;;EAK/B,cAAc,SAAS,qBAAqB;;;;EAK5C,KAAK,SAAS,qBAAqB;;;;EAKnC,aAAa,SAAS,qBAAqB;;;;EAK3C,UAAU,SAAS,0BAA0B;;;;EAK7C,iBAAiB,SAAS,4BAA4B;;;;EAKtD,OAAO,SAAS,uBAAuB;;;;EAKvC,YAAY,SAAS,uBAAuB;;;;EAK5C,cAAc,SAAS,8BAA8B;;;;EAKrD,mBACE,SAAS,8BACR;;;;EAKH,cAAc,SAAS,0BAA0B;;;;EAKjD,mBAAmB,SAAS,0BAA0B;;UAGvC;;;;;EAKf;;;;;EAMA;;;;EAKA,UAAU;;;;;EAMV,QAAQ;EAER;;;;;wBAMc,cACd,UAAS,0BACR;;;;qBA6FU,SAAO;;;KCxMR,0CACV;;;qBCZW"}

package/dist/index.js

@@ -178,7 +178,7 @@ function mapMistralFinishReason(finishReason) {
 }
 //#endregion
 //#region src/mistral-chat-language-model-options.ts
-const mistralLanguageModelChatOptions = z.object({
+const mistralLanguageModelChatOptions = () => z.object({
 	/**
 	* Whether to inject a safety prompt before all conversations.
 	*
@@ -219,15 +219,16 @@ const mistralLanguageModelChatOptions = z.object({
 	*/
 	reasoningEffort: z.enum(["high", "none"]).optional()
 });
+const mistralLanguageModelChatOptionsValidator = lazySchema(() => zodSchema(mistralLanguageModelChatOptions()));
 //#endregion
 //#region src/mistral-error.ts
-const mistralErrorDataSchema = z.object({
+const mistralErrorDataSchema = lazySchema(() => zodSchema(z.object({
 	object: z.literal("error"),
 	message: z.string(),
 	type: z.string(),
 	param: z.string().nullable(),
 	code: z.string().nullable()
-});
+})));
 const mistralFailedResponseHandler = createJsonErrorResponseHandler({
 	errorSchema: mistralErrorDataSchema,
 	errorToMessage: (data) => data.message
@@ -325,7 +326,7 @@ var MistralChatLanguageModel = class MistralChatLanguageModel {
 		const options = await parseProviderOptions({
 			provider: "mistral",
 			providerOptions,
-			schema: mistralLanguageModelChatOptions
+			schema: mistralLanguageModelChatOptionsValidator
 		}) ?? {};
 		if (topK != null) warnings.push({
 			type: "unsupported",
@@ -466,7 +467,7 @@ var MistralChatLanguageModel = class MistralChatLanguageModel {
 			fetch: this.config.fetch
 		});
 		let finishReason = {
-			unified: "other",
+			unified: "interrupted",
 			raw: void 0
 		};
 		let usage = void 0;
@@ -490,6 +491,10 @@ var MistralChatLanguageModel = class MistralChatLanguageModel {
 						rawValue: chunk.rawValue
 					});
 					if (!chunk.success) {
+						finishReason = {
+							unified: "error",
+							raw: void 0
+						};
 						controller.enqueue({
 							type: "error",
 							error: chunk.error
@@ -604,7 +609,7 @@ function extractTextContent(content) {
 	}
 	return textContent.length ? textContent.join("") : void 0;
 }
-const mistralContentSchema = z.union([z.string(), z.array(z.discriminatedUnion("type", [
+const mistralContentSchema = () => z.union([z.string(), z.array(z.discriminatedUnion("type", [
 	z.object({
 		type: z.literal("text"),
 		text: z.string()
@@ -628,14 +633,14 @@ const mistralContentSchema = z.union([z.string(), z.array(z.discriminatedUnion("
 		}))
 	})
 ]))]).nullish();
-const mistralChatResponseSchema = z.object({
+const mistralChatResponseSchema = lazySchema(() => zodSchema(z.object({
 	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,
+			content: mistralContentSchema(),
 			tool_calls: z.array(z.object({
 				id: z.string(),
 				function: z.object({
@@ -649,15 +654,15 @@ const mistralChatResponseSchema = z.object({
 	})),
 	object: z.literal("chat.completion"),
 	usage: mistralUsageSchema
-});
-const mistralChatChunkSchema = z.object({
+})));
+const mistralChatChunkSchema = lazySchema(() => zodSchema(z.object({
 	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,
+			content: mistralContentSchema(),
 			tool_calls: z.array(z.object({
 				index: z.number().nullish(),
 				id: z.string().nullish(),
@@ -671,7 +676,7 @@ const mistralChatChunkSchema = z.object({
 		index: z.number()
 	})),
 	usage: mistralUsageSchema.nullish()
-});
+})));
 //#endregion
 //#region src/convert-to-mistral-conversation-inputs.ts
 function convertToMistralConversationInputs(prompt, toolNameMapping) {
@@ -785,7 +790,7 @@ function convertToMistralConversationInputs(prompt, toolNameMapping) {
 }
 //#endregion
 //#region src/mistral-conversation-language-model-options.ts
-const mistralLanguageModelConversationOptions = mistralLanguageModelChatOptions;
+const mistralLanguageModelConversationOptions = lazySchema(() => zodSchema(mistralLanguageModelChatOptions()));
 //#endregion
 //#region src/mistral-conversation-prepare-tools.ts
 const mistralProviderToolNames = {
@@ -1283,7 +1288,7 @@ function createContentConverter({ tools, generateId }) {
 		}
 	};
 }
-const mistralConversationContentSchema = z.discriminatedUnion("type", [
+const mistralConversationContentSchema = () => z.discriminatedUnion("type", [
 	z.object({
 		type: z.literal("text"),
 		text: z.string()
@@ -1302,8 +1307,8 @@ const mistralConversationContentSchema = z.discriminatedUnion("type", [
 		url: z.string().nullish()
 	})
 ]);
-const mistralConversationMessageContentSchema = z.union([z.string(), z.array(mistralConversationContentSchema)]);
-const mistralConversationToolExecutionSchema = z.object({
+const mistralConversationMessageContentSchema = () => z.union([z.string(), z.array(mistralConversationContentSchema())]);
+const mistralConversationToolExecutionSchema = () => z.object({
 	type: z.literal("tool.execution"),
 	id: z.string(),
 	name: z.string(),
@@ -1311,31 +1316,31 @@ const mistralConversationToolExecutionSchema = z.object({
 	function: z.string().nullish(),
 	info: z.record(z.string(), z.json()).nullish()
 });
-const mistralConversationFunctionCallSchema = z.object({
+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({
+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({
+const mistralConversationResponseSchema = lazySchema(() => zodSchema(z.object({
 	conversation_id: z.string(),
 	outputs: z.array(z.discriminatedUnion("type", [
-		mistralConversationToolExecutionSchema,
-		mistralConversationFunctionCallSchema,
+		mistralConversationToolExecutionSchema(),
+		mistralConversationFunctionCallSchema(),
 		z.object({
 			type: z.literal("message.output"),
-			content: mistralConversationMessageContentSchema,
+			content: mistralConversationMessageContentSchema(),
 			model: z.string().nullish()
 		})
 	])),
-	usage: mistralConversationUsageSchema.nullish()
-});
-const mistralConversationChunkSchema = z.discriminatedUnion("type", [
+	usage: mistralConversationUsageSchema().nullish()
+})));
+const mistralConversationChunkSchema = lazySchema(() => zodSchema(z.discriminatedUnion("type", [
 	z.object({
 		type: z.literal("conversation.response.started"),
 		conversation_id: z.string(),
@@ -1343,7 +1348,7 @@ const mistralConversationChunkSchema = z.discriminatedUnion("type", [
 	}),
 	z.object({
 		type: z.literal("conversation.response.done"),
-		usage: mistralConversationUsageSchema.nullish()
+		usage: mistralConversationUsageSchema().nullish()
 	}),
 	z.object({
 		type: z.literal("conversation.response.error"),
@@ -1354,7 +1359,7 @@ const mistralConversationChunkSchema = z.discriminatedUnion("type", [
 		type: z.literal("message.output.delta"),
 		id: z.string(),
 		content_index: z.number().nullish(),
-		content: z.union([z.string(), mistralConversationContentSchema]),
+		content: z.union([z.string(), mistralConversationContentSchema()]),
 		model: z.string().nullish()
 	}),
 	z.object({
@@ -1378,7 +1383,7 @@ const mistralConversationChunkSchema = z.discriminatedUnion("type", [
 		function: z.string().nullish(),
 		info: z.record(z.string(), z.json()).nullish()
 	})
-]);
+])));
 //#endregion
 //#region src/mistral-embedding-model-options.ts
 const mistralEmbeddingModelOptions = z.object({
@@ -1462,19 +1467,30 @@ var MistralEmbeddingModel = class MistralEmbeddingModel {
 		};
 	}
 };
-const MistralTextEmbeddingResponseSchema = z.object({
+const MistralTextEmbeddingResponseSchema = lazySchema(() => zodSchema(z.object({
 	data: z.array(z.object({ embedding: z.array(z.number()) })),
 	usage: z.object({ prompt_tokens: z.number() }).nullish()
-});
+})));
 //#endregion
 //#region src/mistral-speech-model-options.ts
-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() });
+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(),
+	/**
+	* 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()
+})));
 //#endregion
 //#region src/mistral-speech-model.ts
 var MistralSpeechModel = class MistralSpeechModel {
@@ -1536,6 +1552,8 @@ var MistralSpeechModel = class MistralSpeechModel {
 			input: text,
 			voice_id: refAudio == null ? voice : void 0,
 			ref_audio: refAudio,
+			expressiveness: mistralOptions?.expressiveness,
+			phoneme_hints: mistralOptions?.phonemeHints,
 			response_format: responseFormat,
 			stream: false
 		};
@@ -1576,7 +1594,7 @@ var MistralSpeechModel = class MistralSpeechModel {
 		};
 	}
 };
-const mistralSpeechResponseSchema = z.object({ audio_data: z.string() });
+const mistralSpeechResponseSchema = lazySchema(() => zodSchema(z.object({ audio_data: z.string() })));
 //#endregion
 //#region src/mistral-transcription-model-options.ts
 const mistralTranscriptionModelOptions = lazySchema(() => zodSchema(z.object({
@@ -1586,25 +1604,32 @@ const mistralTranscriptionModelOptions = lazySchema(() => zodSchema(z.object({
 	*/
 	language: z.string().min(1).optional(),
 	/**
+	* Return the detected language. Cannot be combined with `language`.
+	*/
+	returnLanguage: z.boolean().optional(),
+	/**
 	* The sampling temperature.
 	*/
 	temperature: z.number().optional(),
 	/**
 	* The timestamp granularities to include in the transcription response.
+	* Voxtral 3 supports segment timestamps only.
 	*/
 	timestampGranularities: z.array(z.enum(["segment", "word"])).min(1).optional(),
 	/**
 	* Whether to identify speakers in the transcription.
+	* Voxtral 3 requires segment timestamps when diarization is enabled.
 	*/
 	diarize: z.boolean().optional(),
 	/**
 	* 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()
 })));
 //#endregion
 //#region src/mistral-transcription-model.ts
@@ -1633,16 +1658,25 @@ var MistralTranscriptionModel = class MistralTranscriptionModel {
 			providerOptions,
 			schema: mistralTranscriptionModelOptions
 		});
-		if (mistralOptions?.language != null && mistralOptions.timestampGranularities != null) throw new InvalidArgumentError({
+		if ([
+			"voxtral-mini-2507",
+			"voxtral-mini-2602",
+			"voxtral-mini-latest"
+		].includes(this.modelId) && mistralOptions?.language != null && mistralOptions.timestampGranularities != null) throw new InvalidArgumentError({
 			argument: "providerOptions",
 			message: "providerOptions.mistral.language cannot be combined with providerOptions.mistral.timestampGranularities"
 		});
+		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 ? new Blob([audio]) : new Blob([convertBase64ToUint8Array(audio)]);
 		formData.append("model", this.modelId);
 		formData.append("file", new File([blob], "audio", { type: mediaType }), `audio.${mediaTypeToExtension(mediaType)}`);
 		if (mistralOptions != null) {
 			appendFormValue(formData, "language", mistralOptions.language);
+			appendFormValue(formData, "return_language", mistralOptions.returnLanguage);
 			appendFormValue(formData, "temperature", mistralOptions.temperature);
 			appendFormValue(formData, "timestamp_granularities", mistralOptions.timestampGranularities);
 			appendFormValue(formData, "diarize", mistralOptions.diarize);
@@ -1712,7 +1746,7 @@ function appendFormValue(formData, key, value) {
 	}
 	formData.append(key, String(value));
 }
-const mistralTranscriptionResponseSchema = z.object({
+const mistralTranscriptionResponseSchema = lazySchema(() => zodSchema(z.object({
 	model: z.string(),
 	text: z.string(),
 	language: z.string().nullish(),
@@ -1731,10 +1765,10 @@ const mistralTranscriptionResponseSchema = z.object({
 		prompt_audio_seconds: z.number().nullish(),
 		request_count: z.number().nullish()
 	}).nullish()
-});
+})));
 //#endregion
 //#region src/version.ts
-const VERSION = "4.0.68";
+const VERSION = "4.0.70";
 //#endregion
 //#region src/tool/web-search.ts
 const inputSchema = lazySchema(() => zodSchema(z.object({ arguments: z.string() })));