@ai-sdk/mistral 4.0.58 → 4.0.60

package/dist/index.js

@@ -1,5 +1,5 @@
 import { InvalidArgumentError, NoSuchModelError, TooManyEmbeddingValuesForCallError, UnsupportedFunctionalityError } from "@ai-sdk/provider";
-import { StreamingToolCallTracker, WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE, combineHeaders, convertBase64ToUint8Array, convertToBase64, createEventSourceResponseHandler, createJsonErrorResponseHandler, createJsonResponseHandler, createLanguageModelResponseMetadata as getResponseMetadata, createNullLanguageModelUsage, generateId, getTopLevelMediaType, injectJsonInstructionIntoMessages, isCustomReasoning, lazySchema, loadApiKey, mapReasoningToProviderEffort, mediaTypeToExtension, parseProviderOptions, postFormDataToApi, postJsonToApi, postToApi, resolveFullMediaType, serializeModelOptions, withUserAgentSuffix, withoutTrailingSlash, zodSchema } from "@ai-sdk/provider-utils";
+import { StreamingToolCallTracker, WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE, combineHeaders, convertBase64ToUint8Array, convertToBase64, createEventSourceResponseHandler, createJsonErrorResponseHandler, createJsonResponseHandler, createLanguageModelResponseMetadata as getResponseMetadata, createNullLanguageModelUsage, createProviderExecutedToolFactory, createToolNameMapping, generateId, getTopLevelMediaType, injectJsonInstructionIntoMessages, isCustomReasoning, lazySchema, loadApiKey, mapReasoningToProviderEffort, mediaTypeToExtension, parseProviderOptions, postFormDataToApi, postJsonToApi, postToApi, resolveFullMediaType, serializeModelOptions, withUserAgentSuffix, withoutTrailingSlash, zodSchema } from "@ai-sdk/provider-utils";
 import { z } from "zod/v4";
 //#region src/convert-mistral-usage.ts
 const mistralPromptTokensDetailsSchema = z.object({
@@ -284,12 +284,14 @@ function prepareTools({ tools, toolChoice }) {
 }
 //#endregion
 //#region src/mistral-chat-language-model.ts
-const reasoningEffortModelIds = /* @__PURE__ */ new Set([
+const reasoningEffortModelIds$1 = /* @__PURE__ */ new Set([
 	"glm-5-2",
 	"labs-leanstral-1-5",
 	"labs-leanstral-1-5-1",
 	"magistral-medium-latest",
 	"magistral-small-latest",
+	"mistral-large-4",
+	"mistral-large-4-0",
 	"mistral-medium",
 	"mistral-medium-2604",
 	"mistral-medium-3",
@@ -334,7 +336,7 @@ var MistralChatLanguageModel = class MistralChatLanguageModel {
 			type: "unsupported",
 			feature: "topK"
 		});
-		const supportsReasoningEffort = reasoningEffortModelIds.has(this.modelId);
+		const supportsReasoningEffort = reasoningEffortModelIds$1.has(this.modelId);
 		let resolvedReasoningEffort;
 		if (supportsReasoningEffort) resolvedReasoningEffort = options.reasoningEffort ?? (isCustomReasoning(reasoning) ? reasoning === "none" ? "none" : mapReasoningToProviderEffort({
 			reasoning,
@@ -676,6 +678,713 @@ const mistralChatChunkSchema = z.object({
 	usage: mistralUsageSchema.nullish()
 });
 //#endregion
+//#region src/convert-to-mistral-conversation-inputs.ts
+function convertToMistralConversationInputs(prompt, toolNameMapping) {
+	const inputs = [];
+	const instructions = [];
+	const executions = /* @__PURE__ */ new Set();
+	const appendToolResult = (part) => {
+		if (executions.has(part.toolCallId)) {
+			let result = null;
+			if (part.output.type === "json") {
+				const value = part.output.value;
+				const info = value != null && typeof value === "object" && "info" in value ? value.info : void 0;
+				if (info != null && typeof info === "object" && !Array.isArray(info)) result = "result" in info ? info.result ?? info : info;
+			}
+			inputs.push({
+				type: "function.result",
+				tool_call_id: part.toolCallId,
+				result: typeof result === "string" ? result : JSON.stringify(result)
+			});
+			return;
+		}
+		const converted = convertToMistralChatMessages([{
+			role: "tool",
+			content: [part]
+		}])[0];
+		inputs.push({
+			type: "function.result",
+			tool_call_id: part.toolCallId,
+			result: converted.content
+		});
+	};
+	for (const message of prompt) switch (message.role) {
+		case "system":
+			instructions.push(message.content);
+			break;
+		case "user": {
+			const converted = convertToMistralChatMessages([message])[0];
+			if (converted.role === "user") inputs.push({
+				type: "message.input",
+				role: "user",
+				content: converted.content
+			});
+			break;
+		}
+		case "assistant": {
+			let content = [];
+			const flush = () => {
+				if (content.length > 0) {
+					inputs.push({
+						type: "message.input",
+						role: "assistant",
+						content
+					});
+					content = [];
+				}
+			};
+			for (const part of message.content) switch (part.type) {
+				case "text":
+					content.push({
+						type: "text",
+						text: part.text
+					});
+					break;
+				case "reasoning":
+					content.push({
+						type: "thinking",
+						thinking: [{
+							type: "text",
+							text: part.text
+						}],
+						closed: true
+					});
+					break;
+				case "tool-call":
+					flush();
+					if (part.providerExecuted) {
+						const name = part.providerOptions?.mistral?.function ?? part.providerOptions?.mistral?.name;
+						const args = part.input;
+						inputs.push({
+							type: "function.call",
+							tool_call_id: part.toolCallId,
+							name: typeof name === "string" ? name : toolNameMapping.toProviderToolName(part.toolName),
+							arguments: typeof args?.arguments === "string" ? args.arguments : JSON.stringify(part.input)
+						});
+						executions.add(part.toolCallId);
+					} else inputs.push({
+						type: "function.call",
+						tool_call_id: part.toolCallId,
+						name: part.toolName,
+						arguments: JSON.stringify(part.input)
+					});
+					break;
+				case "tool-result":
+					flush();
+					appendToolResult(part);
+					break;
+				default: throw new UnsupportedFunctionalityError({ functionality: `assistant content type: ${part.type}` });
+			}
+			flush();
+			break;
+		}
+		case "tool": for (const part of message.content) {
+			if (part.type === "tool-approval-response") continue;
+			appendToolResult(part);
+		}
+	}
+	return {
+		inputs,
+		instructions: instructions.length > 0 ? instructions.join("\n\n") : void 0
+	};
+}
+//#endregion
+//#region src/mistral-conversation-language-model-options.ts
+const mistralLanguageModelConversationOptions = mistralLanguageModelChatOptions;
+//#endregion
+//#region src/mistral-conversation-prepare-tools.ts
+const mistralProviderToolNames = {
+	"mistral.web_search": "web_search",
+	"mistral.web_search_premium": "web_search_premium"
+};
+function prepareConversationTools({ tools, toolChoice }) {
+	tools = tools?.length ? tools : void 0;
+	const toolWarnings = [];
+	if (tools == null) return {
+		tools: void 0,
+		toolChoice: void 0,
+		toolWarnings
+	};
+	const mistralTools = [];
+	for (const tool of tools) if (tool.type === "provider") {
+		if (tool.id === "mistral.web_search" || tool.id === "mistral.web_search_premium") {
+			mistralTools.push({ type: mistralProviderToolNames[tool.id] });
+			continue;
+		}
+		toolWarnings.push({
+			type: "unsupported",
+			feature: `provider-defined tool ${tool.id}`
+		});
+	} else mistralTools.push({
+		type: "function",
+		function: {
+			name: tool.name,
+			description: tool.description,
+			parameters: tool.inputSchema,
+			...tool.strict != null ? { strict: tool.strict } : {}
+		}
+	});
+	if (toolChoice == null) return {
+		tools: mistralTools,
+		toolChoice: void 0,
+		toolWarnings
+	};
+	const type = toolChoice.type;
+	switch (type) {
+		case "auto":
+		case "none": return {
+			tools: mistralTools,
+			toolChoice: type,
+			toolWarnings
+		};
+		case "required": return {
+			tools: mistralTools,
+			toolChoice: "any",
+			toolWarnings
+		};
+		case "tool": {
+			const toolName = createToolNameMapping({
+				tools,
+				providerToolNames: mistralProviderToolNames
+			}).toProviderToolName(toolChoice.toolName);
+			return {
+				tools: mistralTools.filter((tool) => tool.type === "function" ? tool.function.name === toolName : tool.type === toolName),
+				toolChoice: "any",
+				toolWarnings
+			};
+		}
+		default: throw new UnsupportedFunctionalityError({ functionality: `tool choice type: ${type}` });
+	}
+}
+//#endregion
+//#region src/mistral-conversation-language-model.ts
+const reasoningEffortModelIds = /* @__PURE__ */ new Set([
+	"glm-5-2",
+	"labs-leanstral-1-5",
+	"labs-leanstral-1-5-1",
+	"magistral-medium-latest",
+	"magistral-small-latest",
+	"mistral-large-4",
+	"mistral-large-4-0",
+	"mistral-medium",
+	"mistral-medium-2604",
+	"mistral-medium-3",
+	"mistral-medium-3-5",
+	"mistral-medium-3.5",
+	"mistral-medium-latest",
+	"mistral-small-2603",
+	"mistral-small-latest",
+	"mistral-vibe-cli-fast",
+	"mistral-vibe-cli-latest",
+	"mistral-vibe-cli-with-tools",
+	"zai-glm-5-2"
+]);
+var MistralConversationLanguageModel = class MistralConversationLanguageModel {
+	static [WORKFLOW_SERIALIZE](model) {
+		return serializeModelOptions({
+			modelId: model.modelId,
+			config: model.config
+		});
+	}
+	static [WORKFLOW_DESERIALIZE](options) {
+		return new MistralConversationLanguageModel(options.modelId, options.config);
+	}
+	constructor(modelId, config) {
+		this.specificationVersion = "v4";
+		this.supportedUrls = { "application/pdf": [/^https:\/\/.*$/] };
+		this.modelId = modelId;
+		this.config = config;
+		this.generateId = config.generateId ?? generateId;
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	async getArgs({ prompt, maxOutputTokens, temperature, topP, topK, frequencyPenalty, presencePenalty, reasoning, stopSequences, responseFormat, seed, providerOptions, tools, toolChoice }) {
+		const warnings = [];
+		const options = await parseProviderOptions({
+			provider: "mistral",
+			providerOptions,
+			schema: mistralLanguageModelConversationOptions
+		}) ?? {};
+		if (topK != null) warnings.push({
+			type: "unsupported",
+			feature: "topK"
+		});
+		const supportsReasoningEffort = reasoningEffortModelIds.has(this.modelId);
+		let resolvedReasoningEffort;
+		if (supportsReasoningEffort) resolvedReasoningEffort = options.reasoningEffort ?? (isCustomReasoning(reasoning) ? reasoning === "none" ? "none" : mapReasoningToProviderEffort({
+			reasoning,
+			effortMap: {
+				minimal: "high",
+				low: "high",
+				medium: "high",
+				high: "high",
+				xhigh: "high",
+				max: "high"
+			},
+			warnings
+		}) : void 0);
+		else if (isCustomReasoning(reasoning)) warnings.push({
+			type: "unsupported",
+			feature: "reasoning",
+			details: "This model does not support reasoning configuration."
+		});
+		const structuredOutputs = options.structuredOutputs ?? true;
+		const strictJsonSchema = options.strictJsonSchema ?? false;
+		if (responseFormat?.type === "json" && (!structuredOutputs || responseFormat.schema == null)) prompt = injectJsonInstructionIntoMessages({
+			messages: prompt,
+			schema: responseFormat.schema
+		});
+		const baseArgs = {
+			max_tokens: maxOutputTokens,
+			temperature,
+			top_p: topP,
+			...frequencyPenalty != null ? { frequency_penalty: frequencyPenalty } : {},
+			...presencePenalty != null ? { presence_penalty: presencePenalty } : {},
+			stop: stopSequences,
+			random_seed: seed,
+			reasoning_effort: resolvedReasoningEffort,
+			response_format: responseFormat?.type === "json" ? structuredOutputs && responseFormat?.schema != null ? {
+				type: "json_schema",
+				json_schema: {
+					schema: responseFormat.schema,
+					strict: strictJsonSchema,
+					name: responseFormat.name ?? "response",
+					description: responseFormat.description
+				}
+			} : { type: "json_object" } : void 0
+		};
+		const { tools: mistralTools, toolChoice: mistralToolChoice, toolWarnings } = prepareConversationTools({
+			tools,
+			toolChoice
+		});
+		for (const [feature, value] of Object.entries({
+			safePrompt: options.safePrompt,
+			documentImageLimit: options.documentImageLimit,
+			documentPageLimit: options.documentPageLimit,
+			promptCacheKey: options.promptCacheKey,
+			parallelToolCalls: options.parallelToolCalls
+		})) if (value != null) warnings.push({
+			type: "unsupported",
+			feature,
+			details: "Not supported by the Mistral Conversations API."
+		});
+		return {
+			args: {
+				model: this.modelId,
+				store: false,
+				...convertToMistralConversationInputs(prompt, createToolNameMapping({
+					tools,
+					providerToolNames: mistralProviderToolNames
+				})),
+				tools: mistralTools,
+				completion_args: {
+					...baseArgs,
+					tool_choice: mistralToolChoice
+				}
+			},
+			warnings: [...warnings, ...toolWarnings]
+		};
+	}
+	async doGenerate(options) {
+		const { args: body, warnings } = await this.getArgs(options);
+		const { value: response, rawValue: rawResponse, responseHeaders } = await postJsonToApi({
+			url: `${this.config.baseURL}/conversations`,
+			headers: combineHeaders(this.config.headers?.(), options.headers),
+			body,
+			failedResponseHandler: mistralFailedResponseHandler,
+			successfulResponseHandler: createJsonResponseHandler(mistralConversationResponseSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		const converter = createContentConverter({
+			tools: options.tools,
+			generateId: this.generateId
+		});
+		const content = [];
+		let hasFunctionCalls = false;
+		let modelId;
+		for (const output of response.outputs) switch (output.type) {
+			case "tool.execution":
+				content.push(...converter.convertTool(output));
+				break;
+			case "function.call":
+				hasFunctionCalls = true;
+				content.push({
+					type: "tool-call",
+					toolCallId: output.tool_call_id,
+					toolName: output.name,
+					input: typeof output.arguments === "string" ? output.arguments : JSON.stringify(output.arguments)
+				});
+				break;
+			case "message.output":
+				modelId = output.model ?? modelId;
+				for (const chunk of typeof output.content === "string" ? [{
+					type: "text",
+					text: output.content
+				}] : output.content) content.push(...converter.convertChunk(chunk));
+		}
+		return {
+			content,
+			finishReason: {
+				unified: hasFunctionCalls ? "tool-calls" : "stop",
+				raw: void 0
+			},
+			usage: convertMistralUsage(response.usage),
+			request: { body },
+			response: {
+				id: response.conversation_id,
+				modelId,
+				headers: responseHeaders,
+				body: rawResponse
+			},
+			warnings
+		};
+	}
+	async doStream(options) {
+		const { args, warnings } = await this.getArgs(options);
+		const body = {
+			...args,
+			stream: true
+		};
+		const { value: response, responseHeaders } = await postJsonToApi({
+			url: `${this.config.baseURL}/conversations`,
+			headers: combineHeaders(this.config.headers?.(), options.headers),
+			body,
+			failedResponseHandler: mistralFailedResponseHandler,
+			successfulResponseHandler: createEventSourceResponseHandler(mistralConversationChunkSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		const converter = createContentConverter({
+			tools: options.tools,
+			generateId: this.generateId
+		});
+		const executions = /* @__PURE__ */ new Map();
+		let toolCallTracker;
+		let active;
+		let usage;
+		let hasFunctionCalls = false;
+		let hasError = false;
+		let isDone = false;
+		let hasModelId = false;
+		const closeContent = (controller) => {
+			if (active != null) {
+				controller.enqueue({
+					type: active.type === "text" ? "text-end" : "reasoning-end",
+					id: active.id
+				});
+				active = void 0;
+			}
+		};
+		const generateId = this.generateId;
+		return {
+			stream: response.pipeThrough(new TransformStream({
+				start(controller) {
+					toolCallTracker = new StreamingToolCallTracker(controller, { generateId });
+					controller.enqueue({
+						type: "stream-start",
+						warnings
+					});
+				},
+				transform(chunk, controller) {
+					if (options.includeRawChunks) controller.enqueue({
+						type: "raw",
+						rawValue: chunk.rawValue
+					});
+					if (!chunk.success) {
+						hasError = true;
+						controller.enqueue({
+							type: "error",
+							error: chunk.error
+						});
+						return;
+					}
+					const event = chunk.value;
+					switch (event.type) {
+						case "conversation.response.started":
+							controller.enqueue({
+								type: "response-metadata",
+								id: event.conversation_id,
+								...event.created_at != null ? { timestamp: new Date(event.created_at) } : {}
+							});
+							break;
+						case "conversation.response.done":
+							usage = event.usage ?? void 0;
+							isDone = true;
+							break;
+						case "conversation.response.error":
+							hasError = true;
+							controller.enqueue({
+								type: "error",
+								error: event
+							});
+							break;
+						case "message.output.delta":
+							if (!hasModelId && event.model != null) {
+								hasModelId = true;
+								controller.enqueue({
+									type: "response-metadata",
+									modelId: event.model
+								});
+							}
+							for (const part of converter.convertChunk(typeof event.content === "string" ? {
+								type: "text",
+								text: event.content
+							} : event.content)) if (part.type === "text" || part.type === "reasoning") {
+								const id = `${event.id}-${event.content_index ?? 0}`;
+								if (active?.id !== id || active.type !== part.type) {
+									closeContent(controller);
+									active = {
+										id,
+										type: part.type
+									};
+									controller.enqueue({
+										type: part.type === "text" ? "text-start" : "reasoning-start",
+										id
+									});
+								}
+								controller.enqueue({
+									type: part.type === "text" ? "text-delta" : "reasoning-delta",
+									id,
+									delta: part.text
+								});
+							} else if (part.type === "source") controller.enqueue(part);
+							break;
+						case "function.call.delta":
+							closeContent(controller);
+							hasFunctionCalls = true;
+							toolCallTracker.processDelta({
+								id: event.tool_call_id,
+								index: event.output_index,
+								function: {
+									name: event.name,
+									arguments: event.arguments
+								}
+							});
+							break;
+						case "tool.execution.started":
+						case "tool.execution.delta": {
+							closeContent(controller);
+							const execution = executions.get(event.id);
+							if (execution == null) {
+								executions.set(event.id, {
+									name: event.name,
+									arguments: event.arguments,
+									function: event.function
+								});
+								controller.enqueue({
+									type: "tool-input-start",
+									id: event.id,
+									toolName: converter.toolNameMapping.toCustomToolName(event.name),
+									providerExecuted: true
+								});
+							} else execution.arguments += event.arguments;
+							break;
+						}
+						case "tool.execution.done": {
+							const execution = executions.get(event.id);
+							if (execution == null) {
+								hasError = true;
+								controller.enqueue({
+									type: "error",
+									error: /* @__PURE__ */ new Error(`Missing tool execution start for ${event.id}`)
+								});
+								break;
+							}
+							controller.enqueue({
+								type: "tool-input-delta",
+								id: event.id,
+								delta: JSON.stringify({ arguments: execution.arguments })
+							});
+							controller.enqueue({
+								type: "tool-input-end",
+								id: event.id
+							});
+							for (const part of converter.convertTool({
+								type: "tool.execution",
+								id: event.id,
+								name: execution.name,
+								arguments: execution.arguments,
+								function: event.function ?? execution.function,
+								info: event.info
+							})) controller.enqueue(part);
+							executions.delete(event.id);
+							break;
+						}
+					}
+				},
+				flush(controller) {
+					closeContent(controller);
+					toolCallTracker.flush();
+					controller.enqueue({
+						type: "finish",
+						finishReason: {
+							unified: hasError || !isDone || executions.size > 0 ? "error" : hasFunctionCalls ? "tool-calls" : "stop",
+							raw: void 0
+						},
+						usage: convertMistralUsage(usage)
+					});
+				}
+			})),
+			request: { body },
+			response: { headers: responseHeaders }
+		};
+	}
+};
+function createContentConverter({ tools, generateId }) {
+	const toolNameMapping = createToolNameMapping({
+		tools,
+		providerToolNames: mistralProviderToolNames
+	});
+	const sourceUrls = /* @__PURE__ */ new Set();
+	return {
+		toolNameMapping,
+		convertChunk(chunk) {
+			switch (chunk.type) {
+				case "text": return chunk.text.length > 0 ? [{
+					type: "text",
+					text: chunk.text
+				}] : [];
+				case "thinking": {
+					const text = chunk.thinking.map((part) => part.text).join("");
+					return text.length > 0 ? [{
+						type: "reasoning",
+						text
+					}] : [];
+				}
+				case "tool_reference":
+					if (chunk.url == null || sourceUrls.has(chunk.url)) return [];
+					const id = generateId();
+					sourceUrls.add(chunk.url);
+					return [{
+						type: "source",
+						sourceType: "url",
+						id,
+						url: chunk.url,
+						title: chunk.title ?? chunk.url
+					}];
+			}
+		},
+		convertTool(output) {
+			const toolName = toolNameMapping.toCustomToolName(output.name);
+			return [{
+				type: "tool-call",
+				toolCallId: output.id,
+				toolName,
+				input: JSON.stringify({ arguments: output.arguments }),
+				providerExecuted: true,
+				providerMetadata: { mistral: {
+					type: "tool.execution",
+					name: output.name,
+					...output.function != null ? { function: output.function } : {}
+				} }
+			}, {
+				type: "tool-result",
+				toolCallId: output.id,
+				toolName,
+				result: { ...output.info != null ? { info: output.info } : {} }
+			}];
+		}
+	};
+}
+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("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(z.discriminatedUnion("type", [
+		mistralConversationToolExecutionSchema,
+		mistralConversationFunctionCallSchema,
+		z.object({
+			type: z.literal("message.output"),
+			content: mistralConversationMessageContentSchema,
+			model: z.string().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()
+	})
+]);
+//#endregion
 //#region src/mistral-embedding-model-options.ts
 const mistralEmbeddingModelOptions = z.object({
 	/**
@@ -1030,7 +1739,31 @@ const mistralTranscriptionResponseSchema = z.object({
 });
 //#endregion
 //#region src/version.ts
-const VERSION = "4.0.58";
+const VERSION = "4.0.60";
+//#endregion
+//#region src/tool/web-search.ts
+const inputSchema = lazySchema(() => zodSchema(z.object({ arguments: z.string() })));
+const outputSchema = lazySchema(() => zodSchema(z.object({ info: z.record(z.string(), z.json()).optional() })));
+const webSearchFactory = createProviderExecutedToolFactory({
+	id: "mistral.web_search",
+	inputSchema,
+	outputSchema
+});
+const webSearchPremiumFactory = createProviderExecutedToolFactory({
+	id: "mistral.web_search_premium",
+	inputSchema,
+	outputSchema
+});
+/** Search the web using Mistral's Conversations API. */
+const webSearch = (args = {}) => webSearchFactory(args);
+/** Search the web and verified news using Mistral's Conversations API. */
+const webSearchPremium = (args = {}) => webSearchPremiumFactory(args);
+//#endregion
+//#region src/tool/index.ts
+const mistralTools = {
+	webSearch,
+	webSearchPremium
+};
 //#endregion
 //#region src/mistral-provider.ts
 /**
@@ -1059,6 +1792,13 @@ function createMistral(options = {}) {
 		headers: getHeaders,
 		fetch: options.fetch
 	});
+	const createConversationModel = (modelId) => new MistralConversationLanguageModel(modelId, {
+		provider: "mistral.conversation",
+		baseURL,
+		headers: getHeaders,
+		fetch: options.fetch,
+		generateId: options.generateId
+	});
 	const createSpeechModel = (modelId) => new MistralSpeechModel(modelId, {
 		provider: "mistral.speech",
 		baseURL,
@@ -1078,6 +1818,8 @@ function createMistral(options = {}) {
 	provider.specificationVersion = "v4";
 	provider.languageModel = createChatModel;
 	provider.chat = createChatModel;
+	provider.conversation = createConversationModel;
+	provider.tools = mistralTools;
 	provider.embedding = createEmbeddingModel;
 	provider.embeddingModel = createEmbeddingModel;
 	provider.textEmbedding = createEmbeddingModel;