@ai-sdk/mistral 4.0.58 → 4.0.60

package/docs/20-mistral.mdx

@@ -321,6 +321,109 @@ const result = await generateText({
   the standard structured-output APIs.
 </Note>
 
+### Conversations API
+
+Use `mistral.conversation(modelId)` to create a model that calls Mistral's
+Conversations API (`/v1/conversations`). It supports `generateText` and
+`streamText`, including Mistral's built-in web search tools.
+
+#### Web Search
+
+The provider offers two tools:
+
+- `mistral.tools.webSearch()`: searches the web.
+- `mistral.tools.webSearchPremium()`: searches the web and accesses news articles
+  through Mistral's integrated news providers.
+
+Mistral executes these tools on the server. No `execute` function is needed.
+Search calls and results are available in `result.toolCalls` and
+`result.toolResults`, and URL citations are available in `result.sources`.
+
+```ts
+import { mistral } from '@ai-sdk/mistral';
+import { generateText } from 'ai';
+
+const result = await generateText({
+  model: mistral.conversation('mistral-medium-latest'),
+  tools: {
+    web_search: mistral.tools.webSearch(),
+  },
+  prompt:
+    "Use web search to find Mistral AI's official website. Cite your source.",
+});
+
+console.log(result.text);
+console.log(result.sources);
+```
+
+Replace `mistral.tools.webSearch()` with `mistral.tools.webSearchPremium()` to use
+premium search.
+
+<Note>
+  Web search requires `mistral.conversation()`. The default `mistral()` factory
+  and `mistral.chat()` use the Chat Completions API, which does not support
+  these tools. See [Mistral's web search
+  documentation](https://docs.mistral.ai/studio/agents/agent-tools/websearch).
+</Note>
+
+You can also stream the answer and access citations after the stream completes:
+
+```ts
+import { mistral } from '@ai-sdk/mistral';
+import { streamText } from 'ai';
+
+const result = streamText({
+  model: mistral.conversation('mistral-medium-latest'),
+  tools: {
+    web_search: mistral.tools.webSearch(),
+  },
+  prompt:
+    "Use web search to find Mistral AI's official website. Cite your source.",
+});
+
+for await (const text of result.textStream) {
+  process.stdout.write(text);
+}
+
+console.log(await result.sources);
+```
+
+#### Multi-Turn Conversations
+
+Pass the previous user messages and `responseMessages` into the next call.
+Keep the complete response history, including search calls and results, so
+follow-up questions can use the retrieved information. The model does not
+retain conversation history between calls.
+
+```ts
+import { mistral } from '@ai-sdk/mistral';
+import { generateText, type ModelMessage } from 'ai';
+
+const model = mistral.conversation('mistral-medium-latest');
+const tools = { web_search: mistral.tools.webSearch() };
+const messages: ModelMessage[] = [
+  {
+    role: 'user',
+    content: "Use web search to find Mistral AI's official website.",
+  },
+];
+
+const first = await generateText({ model, tools, messages });
+messages.push(...first.responseMessages);
+messages.push({
+  role: 'user',
+  content:
+    'Where is that company headquartered? Use web search and cite your source.',
+});
+
+const second = await generateText({ model, tools, messages });
+console.log(second.text);
+console.log(second.sources);
+```
+
+For `streamText`, consume the stream before appending
+`await result.responseMessages` to your message history.
+
 ### Model Capabilities
 
 | Model                     | Image Input | Tool Usage |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/mistral",
-  "version": "4.0.58",
+  "version": "4.0.60",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -29,8 +29,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.23",
-    "@ai-sdk/provider-utils": "5.0.55"
+    "@ai-sdk/provider": "4.0.24",
+    "@ai-sdk/provider-utils": "5.0.56"
   },
   "devDependencies": {
     "@ai-sdk/test-server": "2.0.4",

package/src/convert-to-mistral-conversation-inputs.ts

@@ -0,0 +1,165 @@
+import {
+  UnsupportedFunctionalityError,
+  type JSONValue,
+  type LanguageModelV4Prompt,
+  type LanguageModelV4ToolResultPart,
+} from '@ai-sdk/provider';
+import type { ToolNameMapping } from '@ai-sdk/provider-utils';
+import { convertToMistralChatMessages } from './convert-to-mistral-chat-messages';
+import type {
+  MistralAssistantMessageContent,
+  MistralToolMessage,
+  MistralUserMessageContent,
+} from './mistral-chat-prompt';
+
+type ConversationInput =
+  | {
+      type: 'message.input';
+      role: 'user' | 'assistant';
+      content: Array<
+        MistralUserMessageContent | MistralAssistantMessageContent
+      >;
+    }
+  | {
+      type: 'function.call';
+      tool_call_id: string;
+      name: string;
+      arguments: string;
+    }
+  | { type: 'function.result'; tool_call_id: string; result: string };
+
+export function convertToMistralConversationInputs(
+  prompt: LanguageModelV4Prompt,
+  toolNameMapping: ToolNameMapping,
+) {
+  const inputs: ConversationInput[] = [];
+  const instructions: string[] = [];
+  const executions = new Set<string>();
+  const appendToolResult = (part: LanguageModelV4ToolResultPart) => {
+    if (executions.has(part.toolCallId)) {
+      let result: JSONValue = null;
+      if (part.output.type === 'json') {
+        const value = part.output.value;
+        const info =
+          value != null && typeof value === 'object' && 'info' in value
+            ? value.info
+            : undefined;
+        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] as MistralToolMessage;
+    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: MistralAssistantMessageContent[] = [];
+        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 as { arguments?: unknown } | null;
+                // Replay built-in executions as calls and results. Entry IDs
+                // and tool.execution output entries cannot be sent as inputs.
+                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);
+        }
+        break;
+    }
+  }
+
+  return {
+    inputs,
+    instructions:
+      instructions.length > 0 ? instructions.join('\n\n') : undefined,
+  };
+}

package/src/index.ts

@@ -8,6 +8,7 @@ export type {
   /** @deprecated Use `MistralLanguageModelChatOptions` instead. */
   MistralLanguageModelChatOptions as MistralLanguageModelOptions,
 } from './mistral-chat-language-model-options';
+export type { MistralLanguageModelConversationOptions } from './mistral-conversation-language-model-options';
 export type { MistralEmbeddingModelOptions } from './mistral-embedding-model-options';
 export type {
   MistralSpeechModelId,

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

@@ -17,6 +17,8 @@ export type MistralChatModelId =
   | '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'

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

@@ -50,13 +50,15 @@ type MistralChatConfig = {
   generateId?: () => string;
 };
 
-// https://api.mistral.ai/v1/models (2026-09-10)
+// https://api.mistral.ai/v1/models (2026-10-06)
 const reasoningEffortModelIds = new Set<MistralChatModelId>([
   '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',

package/src/mistral-conversation-language-model-options.ts

@@ -0,0 +1,13 @@
+import {
+  mistralLanguageModelChatOptions,
+  type MistralChatModelId,
+  type MistralLanguageModelChatOptions,
+} from './mistral-chat-language-model-options';
+
+export type MistralConversationModelId = MistralChatModelId;
+
+export const mistralLanguageModelConversationOptions =
+  mistralLanguageModelChatOptions;
+
+export type MistralLanguageModelConversationOptions =
+  MistralLanguageModelChatOptions;