@ai-sdk/mistral 4.0.58 → 4.0.60

package/src/mistral-conversation-prepare-tools.ts

@@ -0,0 +1,111 @@
+import {
+  UnsupportedFunctionalityError,
+  type LanguageModelV4CallOptions,
+  type SharedV4Warning,
+} from '@ai-sdk/provider';
+import type { MistralToolChoice } from './mistral-chat-prompt';
+import { createToolNameMapping } from '@ai-sdk/provider-utils';
+
+type MistralTool =
+  | { type: 'web_search' | 'web_search_premium' }
+  | {
+      type: 'function';
+      function: {
+        name: string;
+        description: string | undefined;
+        parameters: unknown;
+        strict?: boolean;
+      };
+    };
+
+export const mistralProviderToolNames = {
+  'mistral.web_search': 'web_search',
+  'mistral.web_search_premium': 'web_search_premium',
+} as const;
+
+export function prepareConversationTools({
+  tools,
+  toolChoice,
+}: {
+  tools: LanguageModelV4CallOptions['tools'];
+  toolChoice?: LanguageModelV4CallOptions['toolChoice'];
+}): {
+  tools: Array<MistralTool> | undefined;
+  toolChoice: MistralToolChoice | undefined;
+  toolWarnings: SharedV4Warning[];
+} {
+  // when the tools array is empty, change it to undefined to prevent errors:
+  tools = tools?.length ? tools : undefined;
+
+  const toolWarnings: SharedV4Warning[] = [];
+
+  if (tools == null) {
+    return { tools: undefined, toolChoice: undefined, toolWarnings };
+  }
+
+  const mistralTools: Array<MistralTool> = [];
+
+  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: undefined, 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 };
+
+    // mistral does not support tool mode directly,
+    // so we filter the tools and force the tool choice through 'any'
+    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: {
+      const _exhaustiveCheck: never = type;
+      throw new UnsupportedFunctionalityError({
+        functionality: `tool choice type: ${_exhaustiveCheck}`,
+      });
+    }
+  }
+}

package/src/mistral-provider.ts

@@ -13,6 +13,7 @@ import {
   type FetchFunction,
 } from '@ai-sdk/provider-utils';
 import { MistralChatLanguageModel } from './mistral-chat-language-model';
+import { MistralConversationLanguageModel } from './mistral-conversation-language-model';
 import type { MistralChatModelId } from './mistral-chat-language-model-options';
 import { MistralEmbeddingModel } from './mistral-embedding-model';
 import type { MistralEmbeddingModelId } from './mistral-embedding-model-options';
@@ -21,8 +22,10 @@ import type { MistralSpeechModelId } from './mistral-speech-model-options';
 import { MistralTranscriptionModel } from './mistral-transcription-model';
 import type { MistralTranscriptionModelId } from './mistral-transcription-model-options';
 import { VERSION } from './version';
+import { mistralTools } from './tool';
 
 export interface MistralProvider extends ProviderV4 {
+  tools: typeof mistralTools;
   (modelId: MistralChatModelId): LanguageModelV4;
 
   /**
@@ -35,6 +38,11 @@ export interface MistralProvider extends ProviderV4 {
    */
   chat(modelId: MistralChatModelId): LanguageModelV4;
 
+  /**
+   * Creates a model using the Conversations API, with support for web search.
+   */
+  conversation(modelId: MistralChatModelId): LanguageModelV4;
+
   /**
    * Creates a model for text embeddings.
    */
@@ -144,6 +152,15 @@ export function createMistral(
       fetch: options.fetch,
     });
 
+  const createConversationModel = (modelId: MistralChatModelId) =>
+    new MistralConversationLanguageModel(modelId, {
+      provider: 'mistral.conversation',
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+      generateId: options.generateId,
+    });
+
   const createSpeechModel = (modelId: MistralSpeechModelId) =>
     new MistralSpeechModel(modelId, {
       provider: 'mistral.speech',
@@ -173,6 +190,8 @@ export function createMistral(
   provider.specificationVersion = 'v4' as const;
   provider.languageModel = createChatModel;
   provider.chat = createChatModel;
+  provider.conversation = createConversationModel;
+  provider.tools = mistralTools;
   provider.embedding = createEmbeddingModel;
   provider.embeddingModel = createEmbeddingModel;
   provider.textEmbedding = createEmbeddingModel;

package/src/tool/index.ts

@@ -0,0 +1,3 @@
+import { webSearch, webSearchPremium } from './web-search';
+
+export const mistralTools = { webSearch, webSearchPremium };

package/src/tool/web-search.ts

@@ -0,0 +1,35 @@
+import type { JSONValue } from '@ai-sdk/provider';
+import {
+  createProviderExecutedToolFactory,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+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<
+  { arguments: string },
+  { info?: Record<string, JSONValue> },
+  {}
+>({ id: 'mistral.web_search', inputSchema, outputSchema });
+
+const webSearchPremiumFactory = createProviderExecutedToolFactory<
+  { arguments: string },
+  { info?: Record<string, JSONValue> },
+  {}
+>({ id: 'mistral.web_search_premium', inputSchema, outputSchema });
+
+/** Search the web using Mistral's Conversations API. */
+export const webSearch = (args: Parameters<typeof webSearchFactory>[0] = {}) =>
+  webSearchFactory(args);
+
+/** Search the web and verified news using Mistral's Conversations API. */
+export const webSearchPremium = (
+  args: Parameters<typeof webSearchPremiumFactory>[0] = {},
+) => webSearchPremiumFactory(args);