@ai-sdk/mistral 3.0.8 → 3.0.10

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

@@ -0,0 +1,580 @@
+import {
+  LanguageModelV3,
+  LanguageModelV3CallOptions,
+  LanguageModelV3Content,
+  LanguageModelV3FinishReason,
+  LanguageModelV3GenerateResult,
+  LanguageModelV3StreamPart,
+  LanguageModelV3StreamResult,
+  SharedV3Warning,
+} from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  createEventSourceResponseHandler,
+  createJsonResponseHandler,
+  FetchFunction,
+  generateId,
+  injectJsonInstructionIntoMessages,
+  parseProviderOptions,
+  ParseResult,
+  postJsonToApi,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { convertMistralUsage, MistralUsage } from './convert-mistral-usage';
+import { convertToMistralChatMessages } from './convert-to-mistral-chat-messages';
+import { getResponseMetadata } from './get-response-metadata';
+import { mapMistralFinishReason } from './map-mistral-finish-reason';
+import {
+  MistralChatModelId,
+  mistralLanguageModelOptions,
+} from './mistral-chat-options';
+import { mistralFailedResponseHandler } from './mistral-error';
+import { prepareTools } from './mistral-prepare-tools';
+
+type MistralChatConfig = {
+  provider: string;
+  baseURL: string;
+  headers: () => Record<string, string | undefined>;
+  fetch?: FetchFunction;
+  generateId?: () => string;
+};
+
+export class MistralChatLanguageModel implements LanguageModelV3 {
+  readonly specificationVersion = 'v3';
+
+  readonly modelId: MistralChatModelId;
+
+  private readonly config: MistralChatConfig;
+  private readonly generateId: () => string;
+
+  constructor(modelId: MistralChatModelId, config: MistralChatConfig) {
+    this.modelId = modelId;
+    this.config = config;
+    this.generateId = config.generateId ?? generateId;
+  }
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  readonly supportedUrls: Record<string, RegExp[]> = {
+    'application/pdf': [/^https:\/\/.*$/],
+  };
+
+  private async getArgs({
+    prompt,
+    maxOutputTokens,
+    temperature,
+    topP,
+    topK,
+    frequencyPenalty,
+    presencePenalty,
+    stopSequences,
+    responseFormat,
+    seed,
+    providerOptions,
+    tools,
+    toolChoice,
+  }: LanguageModelV3CallOptions) {
+    const warnings: SharedV3Warning[] = [];
+
+    const options =
+      (await parseProviderOptions({
+        provider: 'mistral',
+        providerOptions,
+        schema: mistralLanguageModelOptions,
+      })) ?? {};
+
+    if (topK != null) {
+      warnings.push({ type: 'unsupported', feature: 'topK' });
+    }
+
+    if (frequencyPenalty != null) {
+      warnings.push({ type: 'unsupported', feature: 'frequencyPenalty' });
+    }
+
+    if (presencePenalty != null) {
+      warnings.push({ type: 'unsupported', feature: 'presencePenalty' });
+    }
+
+    if (stopSequences != null) {
+      warnings.push({ type: 'unsupported', feature: 'stopSequences' });
+    }
+
+    const structuredOutputs = options.structuredOutputs ?? true;
+    const strictJsonSchema = options.strictJsonSchema ?? false;
+
+    // For Mistral we need to need to instruct the model to return a JSON object.
+    // https://docs.mistral.ai/capabilities/structured-output/structured_output_overview/
+    if (responseFormat?.type === 'json' && !responseFormat?.schema) {
+      prompt = injectJsonInstructionIntoMessages({
+        messages: prompt,
+        schema: responseFormat.schema,
+      });
+    }
+
+    const baseArgs = {
+      // model id:
+      model: this.modelId,
+
+      // model specific settings:
+      safe_prompt: options.safePrompt,
+
+      // standardized settings:
+      max_tokens: maxOutputTokens,
+      temperature,
+      top_p: topP,
+      random_seed: seed,
+
+      // response format:
+      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' }
+          : undefined,
+
+      // mistral-specific provider options:
+      document_image_limit: options.documentImageLimit,
+      document_page_limit: options.documentPageLimit,
+
+      // messages:
+      messages: convertToMistralChatMessages(prompt),
+    };
+
+    const {
+      tools: mistralTools,
+      toolChoice: mistralToolChoice,
+      toolWarnings,
+    } = prepareTools({
+      tools,
+      toolChoice,
+    });
+
+    return {
+      args: {
+        ...baseArgs,
+        tools: mistralTools,
+        tool_choice: mistralToolChoice,
+        ...(mistralTools != null && options.parallelToolCalls !== undefined
+          ? { parallel_tool_calls: options.parallelToolCalls }
+          : {}),
+      },
+      warnings: [...warnings, ...toolWarnings],
+    };
+  }
+
+  async doGenerate(
+    options: LanguageModelV3CallOptions,
+  ): Promise<LanguageModelV3GenerateResult> {
+    const { args: body, warnings } = await this.getArgs(options);
+
+    const {
+      responseHeaders,
+      value: response,
+      rawValue: rawResponse,
+    } = await postJsonToApi({
+      url: `${this.config.baseURL}/chat/completions`,
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body,
+      failedResponseHandler: mistralFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        mistralChatResponseSchema,
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    const choice = response.choices[0];
+    const content: Array<LanguageModelV3Content> = [];
+
+    // process content parts in order to preserve sequence
+    if (
+      choice.message.content != null &&
+      Array.isArray(choice.message.content)
+    ) {
+      for (const part of choice.message.content) {
+        if (part.type === 'thinking') {
+          const reasoningText = extractReasoningContent(part.thinking);
+          if (reasoningText.length > 0) {
+            content.push({ type: 'reasoning', text: reasoningText });
+          }
+        } else if (part.type === 'text') {
+          if (part.text.length > 0) {
+            content.push({ type: 'text', text: part.text });
+          }
+        }
+      }
+    } else {
+      // handle legacy string content
+      const text = extractTextContent(choice.message.content);
+      if (text != null && text.length > 0) {
+        content.push({ type: 'text', text });
+      }
+    }
+
+    // when there is a trailing assistant message, mistral will send the
+    // content of that message again. we skip this repeated content to
+    // avoid duplication, e.g. in continuation mode.
+
+    // tool calls:
+    if (choice.message.tool_calls != null) {
+      for (const toolCall of choice.message.tool_calls) {
+        content.push({
+          type: 'tool-call',
+          toolCallId: toolCall.id,
+          toolName: toolCall.function.name,
+          input: toolCall.function.arguments!,
+        });
+      }
+    }
+
+    return {
+      content,
+      finishReason: {
+        unified: mapMistralFinishReason(choice.finish_reason),
+        raw: choice.finish_reason ?? undefined,
+      },
+      usage: convertMistralUsage(response.usage),
+      request: { body },
+      response: {
+        ...getResponseMetadata(response),
+        headers: responseHeaders,
+        body: rawResponse,
+      },
+      warnings,
+    };
+  }
+
+  async doStream(
+    options: LanguageModelV3CallOptions,
+  ): Promise<LanguageModelV3StreamResult> {
+    const { args, warnings } = await this.getArgs(options);
+    const body = { ...args, stream: true };
+
+    const { responseHeaders, value: response } = await postJsonToApi({
+      url: `${this.config.baseURL}/chat/completions`,
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body,
+      failedResponseHandler: mistralFailedResponseHandler,
+      successfulResponseHandler: createEventSourceResponseHandler(
+        mistralChatChunkSchema,
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    let finishReason: LanguageModelV3FinishReason = {
+      unified: 'other',
+      raw: undefined,
+    };
+    let usage: MistralUsage | undefined = undefined;
+
+    let isFirstChunk = true;
+    let activeText = false;
+    let activeReasoningId: string | null = null;
+
+    const generateId = this.generateId;
+
+    return {
+      stream: response.pipeThrough(
+        new TransformStream<
+          ParseResult<z.infer<typeof mistralChatChunkSchema>>,
+          LanguageModelV3StreamPart
+        >({
+          start(controller) {
+            controller.enqueue({ type: 'stream-start', warnings });
+          },
+
+          transform(chunk, controller) {
+            // Emit raw chunk if requested (before anything else)
+            if (options.includeRawChunks) {
+              controller.enqueue({ type: 'raw', rawValue: chunk.rawValue });
+            }
+
+            if (!chunk.success) {
+              controller.enqueue({ type: 'error', error: chunk.error });
+              return;
+            }
+
+            const value = chunk.value;
+
+            if (isFirstChunk) {
+              isFirstChunk = false;
+
+              controller.enqueue({
+                type: 'response-metadata',
+                ...getResponseMetadata(value),
+              });
+            }
+
+            if (value.usage != null) {
+              usage = value.usage;
+            }
+
+            const choice = value.choices[0];
+            const delta = choice.delta;
+
+            const textContent = extractTextContent(delta.content);
+
+            if (delta.content != null && Array.isArray(delta.content)) {
+              for (const part of delta.content) {
+                if (part.type === 'thinking') {
+                  const reasoningDelta = extractReasoningContent(part.thinking);
+                  if (reasoningDelta.length > 0) {
+                    if (activeReasoningId == null) {
+                      // end any active text before starting reasoning
+                      if (activeText) {
+                        controller.enqueue({ type: 'text-end', id: '0' });
+                        activeText = false;
+                      }
+
+                      activeReasoningId = generateId();
+                      controller.enqueue({
+                        type: 'reasoning-start',
+                        id: activeReasoningId,
+                      });
+                    }
+                    controller.enqueue({
+                      type: 'reasoning-delta',
+                      id: activeReasoningId,
+                      delta: reasoningDelta,
+                    });
+                  }
+                }
+              }
+            }
+
+            if (textContent != null && textContent.length > 0) {
+              if (!activeText) {
+                // if we were in reasoning mode, end it before starting text
+                if (activeReasoningId != null) {
+                  controller.enqueue({
+                    type: 'reasoning-end',
+                    id: activeReasoningId,
+                  });
+                  activeReasoningId = null;
+                }
+                controller.enqueue({ type: 'text-start', id: '0' });
+                activeText = true;
+              }
+
+              controller.enqueue({
+                type: 'text-delta',
+                id: '0',
+                delta: textContent,
+              });
+            }
+
+            if (delta?.tool_calls != null) {
+              for (const toolCall of delta.tool_calls) {
+                const toolCallId = toolCall.id;
+                const toolName = toolCall.function.name;
+                const input = toolCall.function.arguments;
+
+                controller.enqueue({
+                  type: 'tool-input-start',
+                  id: toolCallId,
+                  toolName,
+                });
+
+                controller.enqueue({
+                  type: 'tool-input-delta',
+                  id: toolCallId,
+                  delta: input,
+                });
+
+                controller.enqueue({
+                  type: 'tool-input-end',
+                  id: toolCallId,
+                });
+
+                controller.enqueue({
+                  type: 'tool-call',
+                  toolCallId,
+                  toolName,
+                  input,
+                });
+              }
+            }
+
+            if (choice.finish_reason != null) {
+              finishReason = {
+                unified: mapMistralFinishReason(choice.finish_reason),
+                raw: choice.finish_reason,
+              };
+            }
+          },
+
+          flush(controller) {
+            if (activeReasoningId != null) {
+              controller.enqueue({
+                type: 'reasoning-end',
+                id: activeReasoningId,
+              });
+            }
+            if (activeText) {
+              controller.enqueue({ type: 'text-end', id: '0' });
+            }
+
+            controller.enqueue({
+              type: 'finish',
+              finishReason,
+              usage: convertMistralUsage(usage),
+            });
+          },
+        }),
+      ),
+      request: { body },
+      response: { headers: responseHeaders },
+    };
+  }
+}
+
+function extractReasoningContent(
+  thinking: Array<{ type: string; text: string }>,
+) {
+  return thinking
+    .filter(chunk => chunk.type === 'text')
+    .map(chunk => chunk.text)
+    .join('');
+}
+
+function extractTextContent(content: z.infer<typeof mistralContentSchema>) {
+  if (typeof content === 'string') {
+    return content;
+  }
+
+  if (content == null) {
+    return undefined;
+  }
+
+  const textContent: string[] = [];
+
+  for (const chunk of content) {
+    const { type } = chunk;
+
+    switch (type) {
+      case 'text':
+        textContent.push(chunk.text);
+        break;
+      case 'thinking':
+      case 'image_url':
+      case 'reference':
+        // thinking, image content, and reference content are currently ignored
+        break;
+      default: {
+        const _exhaustiveCheck: never = type;
+        throw new Error(`Unsupported type: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+
+  return textContent.length ? textContent.join('') : undefined;
+}
+
+const mistralContentSchema = z
+  .union([
+    z.string(),
+    z.array(
+      z.discriminatedUnion('type', [
+        z.object({
+          type: z.literal('text'),
+          text: z.string(),
+        }),
+        z.object({
+          type: z.literal('image_url'),
+          image_url: z.union([
+            z.string(),
+            z.object({
+              url: z.string(),
+              detail: z.string().nullable(),
+            }),
+          ]),
+        }),
+        z.object({
+          type: z.literal('reference'),
+          reference_ids: z.array(z.union([z.string(), z.number()])),
+        }),
+        z.object({
+          type: z.literal('thinking'),
+          thinking: z.array(
+            z.object({
+              type: z.literal('text'),
+              text: z.string(),
+            }),
+          ),
+        }),
+      ]),
+    ),
+  ])
+  .nullish();
+
+const mistralUsageSchema = z.object({
+  prompt_tokens: z.number(),
+  completion_tokens: z.number(),
+  total_tokens: z.number(),
+});
+
+// limited version of the schema, focussed on what is needed for the implementation
+// this approach limits breakages when the API changes and increases efficiency
+const mistralChatResponseSchema = 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,
+        tool_calls: z
+          .array(
+            z.object({
+              id: z.string(),
+              function: z.object({ name: z.string(), arguments: z.string() }),
+            }),
+          )
+          .nullish(),
+      }),
+      index: z.number(),
+      finish_reason: z.string().nullish(),
+    }),
+  ),
+  object: z.literal('chat.completion'),
+  usage: mistralUsageSchema,
+});
+
+// limited version of the schema, focussed on what is needed for the implementation
+// this approach limits breakages when the API changes and increases efficiency
+const mistralChatChunkSchema = 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,
+        tool_calls: z
+          .array(
+            z.object({
+              id: z.string(),
+              function: z.object({ name: z.string(), arguments: z.string() }),
+            }),
+          )
+          .nullish(),
+      }),
+      finish_reason: z.string().nullish(),
+      index: z.number(),
+    }),
+  ),
+  usage: mistralUsageSchema.nullish(),
+});

package/src/mistral-chat-options.ts

@@ -0,0 +1,63 @@
+import { z } from 'zod/v4';
+
+// https://docs.mistral.ai/getting-started/models/models_overview/
+export type MistralChatModelId =
+  // premier
+  | 'ministral-3b-latest'
+  | 'ministral-8b-latest'
+  | 'mistral-large-latest'
+  | 'mistral-medium-latest'
+  | 'mistral-medium-2508'
+  | 'mistral-medium-2505'
+  | 'mistral-small-latest'
+  | 'pixtral-large-latest'
+  // reasoning models
+  | 'magistral-small-2507'
+  | 'magistral-medium-2507'
+  | 'magistral-small-2506'
+  | 'magistral-medium-2506'
+  // free
+  | 'pixtral-12b-2409'
+  // legacy
+  | 'open-mistral-7b'
+  | 'open-mixtral-8x7b'
+  | 'open-mixtral-8x22b'
+  | (string & {});
+
+export const mistralLanguageModelOptions = z.object({
+  /**
+Whether to inject a safety prompt before all conversations.
+
+Defaults to `false`.
+   */
+  safePrompt: z.boolean().optional(),
+
+  documentImageLimit: z.number().optional(),
+  documentPageLimit: z.number().optional(),
+
+  /**
+   * Whether to use structured outputs.
+   *
+   * @default true
+   */
+  structuredOutputs: z.boolean().optional(),
+
+  /**
+   * Whether to use strict JSON schema validation.
+   *
+   * @default false
+   */
+  strictJsonSchema: z.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: z.boolean().optional(),
+});
+
+export type MistralLanguageModelOptions = z.infer<
+  typeof mistralLanguageModelOptions
+>;

package/src/mistral-chat-prompt.ts

@@ -0,0 +1,46 @@
+export type MistralPrompt = Array<MistralMessage>;
+
+export type MistralMessage =
+  | MistralSystemMessage
+  | MistralUserMessage
+  | MistralAssistantMessage
+  | MistralToolMessage;
+
+export interface MistralSystemMessage {
+  role: 'system';
+  content: string;
+}
+
+export interface MistralUserMessage {
+  role: 'user';
+  content: Array<MistralUserMessageContent>;
+}
+
+export type MistralUserMessageContent =
+  | { type: 'text'; text: string }
+  | { type: 'image_url'; image_url: string }
+  | { type: 'document_url'; document_url: string };
+
+export interface MistralAssistantMessage {
+  role: 'assistant';
+  content: string;
+  prefix?: boolean;
+  tool_calls?: Array<{
+    id: string;
+    type: 'function';
+    function: { name: string; arguments: string };
+  }>;
+}
+
+export interface MistralToolMessage {
+  role: 'tool';
+  name: string;
+  content: string;
+  tool_call_id: string;
+}
+
+export type MistralToolChoice =
+  | { type: 'function'; function: { name: string } }
+  | 'auto'
+  | 'none'
+  | 'any';