@ai-sdk/mistral 0.0.0-70e0935a-20260114150030 → 0.0.0-98261322-20260122142521

package/src/convert-to-mistral-chat-messages.test.ts

@@ -0,0 +1,372 @@
+import { convertToMistralChatMessages } from './convert-to-mistral-chat-messages';
+import { describe, it, expect } from 'vitest';
+
+describe('user messages', () => {
+  it('should convert messages with image parts', async () => {
+    const result = convertToMistralChatMessages([
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: 'Hello' },
+          {
+            type: 'file',
+            data: 'AAECAw==',
+            mediaType: 'image/png',
+          },
+        ],
+      },
+    ]);
+
+    expect(result).toMatchSnapshot();
+  });
+
+  it('should convert messages with image parts from Uint8Array', async () => {
+    const result = convertToMistralChatMessages([
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: 'Hi' },
+          {
+            type: 'file',
+            data: new Uint8Array([0, 1, 2, 3]),
+            mediaType: 'image/png',
+          },
+        ],
+      },
+    ]);
+
+    expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "content": [
+            {
+              "text": "Hi",
+              "type": "text",
+            },
+            {
+              "image_url": "data:image/png;base64,AAECAw==",
+              "type": "image_url",
+            },
+          ],
+          "role": "user",
+        },
+      ]
+    `);
+  });
+
+  it('should convert messages with PDF file parts using URL', () => {
+    const result = convertToMistralChatMessages([
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: 'Please analyze this document' },
+          {
+            type: 'file',
+            data: new URL('https://example.com/document.pdf'),
+            mediaType: 'application/pdf',
+          },
+        ],
+      },
+    ]);
+
+    expect(result).toMatchSnapshot();
+  });
+
+  it('should convert messages with PDF file parts from Uint8Array', () => {
+    const result = convertToMistralChatMessages([
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: 'Analyze this PDF' },
+          {
+            type: 'file',
+            data: new Uint8Array([0, 1, 2, 3]),
+            mediaType: 'application/pdf',
+          },
+        ],
+      },
+    ]);
+
+    expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "content": [
+            {
+              "text": "Analyze this PDF",
+              "type": "text",
+            },
+            {
+              "document_url": "data:application/pdf;base64,AAECAw==",
+              "type": "document_url",
+            },
+          ],
+          "role": "user",
+        },
+      ]
+    `);
+  });
+
+  it('should convert messages with reasoning content', () => {
+    const result = convertToMistralChatMessages([
+      {
+        role: 'assistant',
+        content: [
+          { type: 'reasoning', text: 'Let me think about this...' },
+          { type: 'text', text: 'The answer is 42.' },
+        ],
+      },
+    ]);
+
+    expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "content": "Let me think about this...The answer is 42.",
+          "prefix": true,
+          "role": "assistant",
+          "tool_calls": undefined,
+        },
+      ]
+    `);
+  });
+});
+
+describe('tool calls', () => {
+  it('should stringify arguments to tool calls', () => {
+    const result = convertToMistralChatMessages([
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: 'tool-call',
+            input: { key: 'arg-value' },
+            toolCallId: 'tool-call-id-1',
+            toolName: 'tool-1',
+          },
+        ],
+      },
+      {
+        role: 'tool',
+        content: [
+          {
+            type: 'tool-result',
+            toolCallId: 'tool-call-id-1',
+            toolName: 'tool-1',
+            output: { type: 'json', value: { key: 'result-value' } },
+          },
+        ],
+      },
+    ]);
+
+    expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "content": "",
+          "prefix": undefined,
+          "role": "assistant",
+          "tool_calls": [
+            {
+              "function": {
+                "arguments": "{"key":"arg-value"}",
+                "name": "tool-1",
+              },
+              "id": "tool-call-id-1",
+              "type": "function",
+            },
+          ],
+        },
+        {
+          "content": "{"key":"result-value"}",
+          "name": "tool-1",
+          "role": "tool",
+          "tool_call_id": "tool-call-id-1",
+        },
+      ]
+    `);
+  });
+
+  it('should handle text output format', () => {
+    const result = convertToMistralChatMessages([
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: 'tool-call',
+            input: { query: 'test' },
+            toolCallId: 'tool-call-id-2',
+            toolName: 'text-tool',
+          },
+        ],
+      },
+      {
+        role: 'tool',
+        content: [
+          {
+            type: 'tool-result',
+            toolCallId: 'tool-call-id-2',
+            toolName: 'text-tool',
+            output: { type: 'text', value: 'This is a text response' },
+          },
+        ],
+      },
+    ]);
+
+    expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "content": "",
+          "prefix": undefined,
+          "role": "assistant",
+          "tool_calls": [
+            {
+              "function": {
+                "arguments": "{"query":"test"}",
+                "name": "text-tool",
+              },
+              "id": "tool-call-id-2",
+              "type": "function",
+            },
+          ],
+        },
+        {
+          "content": "This is a text response",
+          "name": "text-tool",
+          "role": "tool",
+          "tool_call_id": "tool-call-id-2",
+        },
+      ]
+    `);
+  });
+
+  it('should handle content output format', () => {
+    const result = convertToMistralChatMessages([
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: 'tool-call',
+            input: { query: 'generate image' },
+            toolCallId: 'tool-call-id-3',
+            toolName: 'image-tool',
+          },
+        ],
+      },
+      {
+        role: 'tool',
+        content: [
+          {
+            type: 'tool-result',
+            toolCallId: 'tool-call-id-3',
+            toolName: 'image-tool',
+            output: {
+              type: 'content',
+              value: [
+                { type: 'text', text: 'Here is the result:' },
+                {
+                  type: 'image-data',
+                  data: 'base64data',
+                  mediaType: 'image/png',
+                },
+              ],
+            },
+          },
+        ],
+      },
+    ]);
+
+    expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "content": "",
+          "prefix": undefined,
+          "role": "assistant",
+          "tool_calls": [
+            {
+              "function": {
+                "arguments": "{"query":"generate image"}",
+                "name": "image-tool",
+              },
+              "id": "tool-call-id-3",
+              "type": "function",
+            },
+          ],
+        },
+        {
+          "content": "[{"type":"text","text":"Here is the result:"},{"type":"image-data","data":"base64data","mediaType":"image/png"}]",
+          "name": "image-tool",
+          "role": "tool",
+          "tool_call_id": "tool-call-id-3",
+        },
+      ]
+    `);
+  });
+
+  it('should handle error output format', () => {
+    const result = convertToMistralChatMessages([
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: 'tool-call',
+            input: { query: 'test' },
+            toolCallId: 'tool-call-id-4',
+            toolName: 'error-tool',
+          },
+        ],
+      },
+      {
+        role: 'tool',
+        content: [
+          {
+            type: 'tool-result',
+            toolCallId: 'tool-call-id-4',
+            toolName: 'error-tool',
+            output: { type: 'error-text', value: 'Invalid input provided' },
+          },
+        ],
+      },
+    ]);
+
+    expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "content": "",
+          "prefix": undefined,
+          "role": "assistant",
+          "tool_calls": [
+            {
+              "function": {
+                "arguments": "{"query":"test"}",
+                "name": "error-tool",
+              },
+              "id": "tool-call-id-4",
+              "type": "function",
+            },
+          ],
+        },
+        {
+          "content": "Invalid input provided",
+          "name": "error-tool",
+          "role": "tool",
+          "tool_call_id": "tool-call-id-4",
+        },
+      ]
+    `);
+  });
+});
+
+describe('assistant messages', () => {
+  it('should add prefix true to trailing assistant messages', () => {
+    const result = convertToMistralChatMessages([
+      {
+        role: 'user',
+        content: [{ type: 'text', text: 'Hello' }],
+      },
+      {
+        role: 'assistant',
+        content: [{ type: 'text', text: 'Hello!' }],
+      },
+    ]);
+
+    expect(result).toMatchSnapshot();
+  });
+});

package/src/convert-to-mistral-chat-messages.ts

@@ -0,0 +1,163 @@
+import {
+  LanguageModelV3DataContent,
+  LanguageModelV3Prompt,
+  UnsupportedFunctionalityError,
+} from '@ai-sdk/provider';
+import { MistralPrompt } from './mistral-chat-prompt';
+import { convertToBase64 } from '@ai-sdk/provider-utils';
+
+function formatFileUrl({
+  data,
+  mediaType,
+}: {
+  data: LanguageModelV3DataContent;
+  mediaType: string;
+}): string {
+  return data instanceof URL
+    ? data.toString()
+    : `data:${mediaType};base64,${convertToBase64(data as Uint8Array)}`;
+}
+
+export function convertToMistralChatMessages(
+  prompt: LanguageModelV3Prompt,
+): MistralPrompt {
+  const messages: MistralPrompt = [];
+
+  for (let i = 0; i < prompt.length; i++) {
+    const { role, content } = prompt[i];
+    const isLastMessage = i === prompt.length - 1;
+
+    switch (role) {
+      case 'system': {
+        messages.push({ role: 'system', content });
+        break;
+      }
+
+      case 'user': {
+        messages.push({
+          role: 'user',
+          content: content.map(part => {
+            switch (part.type) {
+              case 'text': {
+                return { type: 'text', text: part.text };
+              }
+
+              case 'file': {
+                if (part.mediaType.startsWith('image/')) {
+                  const mediaType =
+                    part.mediaType === 'image/*'
+                      ? 'image/jpeg'
+                      : part.mediaType;
+
+                  return {
+                    type: 'image_url',
+                    image_url: formatFileUrl({ data: part.data, mediaType }),
+                  };
+                } else if (part.mediaType === 'application/pdf') {
+                  return {
+                    type: 'document_url',
+                    document_url: formatFileUrl({
+                      data: part.data,
+                      mediaType: 'application/pdf',
+                    }),
+                  };
+                } else {
+                  throw new UnsupportedFunctionalityError({
+                    functionality:
+                      'Only images and PDF file parts are supported',
+                  });
+                }
+              }
+            }
+          }),
+        });
+        break;
+      }
+
+      case 'assistant': {
+        let text = '';
+        const toolCalls: Array<{
+          id: string;
+          type: 'function';
+          function: { name: string; arguments: string };
+        }> = [];
+
+        for (const part of content) {
+          switch (part.type) {
+            case 'text': {
+              text += part.text;
+              break;
+            }
+            case 'tool-call': {
+              toolCalls.push({
+                id: part.toolCallId,
+                type: 'function',
+                function: {
+                  name: part.toolName,
+                  arguments: JSON.stringify(part.input),
+                },
+              });
+              break;
+            }
+            case 'reasoning': {
+              text += part.text;
+              break;
+            }
+            default: {
+              throw new Error(
+                `Unsupported content type in assistant message: ${part.type}`,
+              );
+            }
+          }
+        }
+
+        messages.push({
+          role: 'assistant',
+          content: text,
+          prefix: isLastMessage ? true : undefined,
+          tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+        });
+
+        break;
+      }
+      case 'tool': {
+        for (const toolResponse of content) {
+          if (toolResponse.type === 'tool-approval-response') {
+            continue;
+          }
+          const output = toolResponse.output;
+
+          let contentValue: string;
+          switch (output.type) {
+            case 'text':
+            case 'error-text':
+              contentValue = output.value;
+              break;
+            case 'execution-denied':
+              contentValue = output.reason ?? 'Tool execution denied.';
+              break;
+            case 'content':
+            case 'json':
+            case 'error-json':
+              contentValue = JSON.stringify(output.value);
+              break;
+          }
+
+          messages.push({
+            role: 'tool',
+            name: toolResponse.toolName,
+            tool_call_id: toolResponse.toolCallId,
+            content: contentValue,
+          });
+        }
+        break;
+      }
+      default: {
+        const _exhaustiveCheck: never = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+
+  return messages;
+}

package/src/get-response-metadata.ts

@@ -0,0 +1,15 @@
+export function getResponseMetadata({
+  id,
+  model,
+  created,
+}: {
+  id?: string | undefined | null;
+  created?: number | undefined | null;
+  model?: string | undefined | null;
+}) {
+  return {
+    id: id ?? undefined,
+    modelId: model ?? undefined,
+    timestamp: created != null ? new Date(created * 1000) : undefined,
+  };
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export { createMistral, mistral } from './mistral-provider';
+export type {
+  MistralProvider,
+  MistralProviderSettings,
+} from './mistral-provider';
+export type { MistralLanguageModelOptions } from './mistral-chat-options';
+export { VERSION } from './version';

package/src/map-mistral-finish-reason.ts

@@ -0,0 +1,17 @@
+import { LanguageModelV3FinishReason } from '@ai-sdk/provider';
+
+export function mapMistralFinishReason(
+  finishReason: string | null | undefined,
+): LanguageModelV3FinishReason['unified'] {
+  switch (finishReason) {
+    case 'stop':
+      return 'stop';
+    case 'length':
+    case 'model_length':
+      return 'length';
+    case 'tool_calls':
+      return 'tool-calls';
+    default:
+      return 'other';
+  }
+}