@ai-sdk/mistral 3.0.9 → 3.0.10

package/src/mistral-embedding-model.test.ts

@@ -0,0 +1,127 @@
+import { EmbeddingModelV3Embedding } from '@ai-sdk/provider';
+import { createTestServer } from '@ai-sdk/test-server/with-vitest';
+import { createMistral } from './mistral-provider';
+import { describe, it, expect, vi } from 'vitest';
+
+vi.mock('./version', () => ({
+  VERSION: '0.0.0-test',
+}));
+
+const dummyEmbeddings = [
+  [0.1, 0.2, 0.3, 0.4, 0.5],
+  [0.6, 0.7, 0.8, 0.9, 1.0],
+];
+const testValues = ['sunny day at the beach', 'rainy day in the city'];
+
+const provider = createMistral({ apiKey: 'test-api-key' });
+const model = provider.embeddingModel('mistral-embed');
+
+const server = createTestServer({
+  'https://api.mistral.ai/v1/embeddings': {},
+});
+
+describe('doEmbed', () => {
+  function prepareJsonResponse({
+    embeddings = dummyEmbeddings,
+    usage = { prompt_tokens: 8, total_tokens: 8 },
+    headers,
+  }: {
+    embeddings?: EmbeddingModelV3Embedding[];
+    usage?: { prompt_tokens: number; total_tokens: number };
+    headers?: Record<string, string>;
+  } = {}) {
+    server.urls['https://api.mistral.ai/v1/embeddings'].response = {
+      type: 'json-value',
+      headers,
+      body: {
+        id: 'b322cfc2b9d34e2f8e14fc99874faee5',
+        object: 'list',
+        data: embeddings.map((embedding, i) => ({
+          object: 'embedding',
+          embedding,
+          index: i,
+        })),
+        model: 'mistral-embed',
+        usage,
+      },
+    };
+  }
+
+  it('should extract embedding', async () => {
+    prepareJsonResponse();
+
+    const { embeddings } = await model.doEmbed({ values: testValues });
+
+    expect(embeddings).toStrictEqual(dummyEmbeddings);
+  });
+
+  it('should extract usage', async () => {
+    prepareJsonResponse({
+      usage: { prompt_tokens: 20, total_tokens: 20 },
+    });
+
+    const { usage } = await model.doEmbed({ values: testValues });
+
+    expect(usage).toStrictEqual({ tokens: 20 });
+  });
+
+  it('should expose the raw response', async () => {
+    prepareJsonResponse({
+      headers: { 'test-header': 'test-value' },
+    });
+
+    const { response } = await model.doEmbed({ values: testValues });
+
+    expect(response?.headers).toStrictEqual({
+      // default headers:
+      'content-length': '267',
+      'content-type': 'application/json',
+
+      // custom header
+      'test-header': 'test-value',
+    });
+    expect(response).toMatchSnapshot();
+  });
+
+  it('should pass the model and the values', async () => {
+    prepareJsonResponse();
+
+    await model.doEmbed({ values: testValues });
+
+    expect(await server.calls[0].requestBodyJson).toStrictEqual({
+      model: 'mistral-embed',
+      input: testValues,
+      encoding_format: 'float',
+    });
+  });
+
+  it('should pass headers', async () => {
+    prepareJsonResponse();
+
+    const provider = createMistral({
+      apiKey: 'test-api-key',
+      headers: {
+        'Custom-Provider-Header': 'provider-header-value',
+      },
+    });
+
+    await provider.embedding('mistral-embed').doEmbed({
+      values: testValues,
+      headers: {
+        'Custom-Request-Header': 'request-header-value',
+      },
+    });
+
+    const requestHeaders = server.calls[0].requestHeaders;
+
+    expect(requestHeaders).toStrictEqual({
+      authorization: 'Bearer test-api-key',
+      'content-type': 'application/json',
+      'custom-provider-header': 'provider-header-value',
+      'custom-request-header': 'request-header-value',
+    });
+    expect(server.calls[0].requestUserAgent).toContain(
+      `ai-sdk/mistral/0.0.0-test`,
+    );
+  });
+});

package/src/mistral-embedding-model.ts

@@ -0,0 +1,94 @@
+import {
+  EmbeddingModelV3,
+  TooManyEmbeddingValuesForCallError,
+} from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  createJsonResponseHandler,
+  FetchFunction,
+  postJsonToApi,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { MistralEmbeddingModelId } from './mistral-embedding-options';
+import { mistralFailedResponseHandler } from './mistral-error';
+
+type MistralEmbeddingConfig = {
+  provider: string;
+  baseURL: string;
+  headers: () => Record<string, string | undefined>;
+  fetch?: FetchFunction;
+};
+
+export class MistralEmbeddingModel implements EmbeddingModelV3 {
+  readonly specificationVersion = 'v3';
+  readonly modelId: MistralEmbeddingModelId;
+  readonly maxEmbeddingsPerCall = 32;
+  readonly supportsParallelCalls = false;
+
+  private readonly config: MistralEmbeddingConfig;
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  constructor(
+    modelId: MistralEmbeddingModelId,
+    config: MistralEmbeddingConfig,
+  ) {
+    this.modelId = modelId;
+    this.config = config;
+  }
+
+  async doEmbed({
+    values,
+    abortSignal,
+    headers,
+  }: Parameters<EmbeddingModelV3['doEmbed']>[0]): Promise<
+    Awaited<ReturnType<EmbeddingModelV3['doEmbed']>>
+  > {
+    if (values.length > this.maxEmbeddingsPerCall) {
+      throw new TooManyEmbeddingValuesForCallError({
+        provider: this.provider,
+        modelId: this.modelId,
+        maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
+        values,
+      });
+    }
+
+    const {
+      responseHeaders,
+      value: response,
+      rawValue,
+    } = await postJsonToApi({
+      url: `${this.config.baseURL}/embeddings`,
+      headers: combineHeaders(this.config.headers(), headers),
+      body: {
+        model: this.modelId,
+        input: values,
+        encoding_format: 'float',
+      },
+      failedResponseHandler: mistralFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        MistralTextEmbeddingResponseSchema,
+      ),
+      abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    return {
+      warnings: [],
+      embeddings: response.data.map(item => item.embedding),
+      usage: response.usage
+        ? { tokens: response.usage.prompt_tokens }
+        : undefined,
+      response: { headers: responseHeaders, body: rawValue },
+    };
+  }
+}
+
+// minimal version of the schema, focussed on what is needed for the implementation
+// this approach limits breakages when the API changes and increases efficiency
+const MistralTextEmbeddingResponseSchema = z.object({
+  data: z.array(z.object({ embedding: z.array(z.number()) })),
+  usage: z.object({ prompt_tokens: z.number() }).nullish(),
+});

package/src/mistral-embedding-options.ts

@@ -0,0 +1 @@
+export type MistralEmbeddingModelId = 'mistral-embed' | (string & {});

package/src/mistral-error.ts

@@ -0,0 +1,17 @@
+import { createJsonErrorResponseHandler } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+const mistralErrorDataSchema = z.object({
+  object: z.literal('error'),
+  message: z.string(),
+  type: z.string(),
+  param: z.string().nullable(),
+  code: z.string().nullable(),
+});
+
+export type MistralErrorData = z.infer<typeof mistralErrorDataSchema>;
+
+export const mistralFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: mistralErrorDataSchema,
+  errorToMessage: data => data.message,
+});

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

@@ -0,0 +1,178 @@
+import { describe, it, expect } from 'vitest';
+import { prepareTools } from './mistral-prepare-tools';
+
+describe('prepareTools', () => {
+  it('should pass through strict mode when strict is true', () => {
+    const result = prepareTools({
+      tools: [
+        {
+          type: 'function',
+          name: 'testFunction',
+          description: 'A test function',
+          inputSchema: { type: 'object', properties: {} },
+          strict: true,
+        },
+      ],
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "toolChoice": undefined,
+        "toolWarnings": [],
+        "tools": [
+          {
+            "function": {
+              "description": "A test function",
+              "name": "testFunction",
+              "parameters": {
+                "properties": {},
+                "type": "object",
+              },
+              "strict": true,
+            },
+            "type": "function",
+          },
+        ],
+      }
+    `);
+  });
+
+  it('should pass through strict mode when strict is false', () => {
+    const result = prepareTools({
+      tools: [
+        {
+          type: 'function',
+          name: 'testFunction',
+          description: 'A test function',
+          inputSchema: { type: 'object', properties: {} },
+          strict: false,
+        },
+      ],
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "toolChoice": undefined,
+        "toolWarnings": [],
+        "tools": [
+          {
+            "function": {
+              "description": "A test function",
+              "name": "testFunction",
+              "parameters": {
+                "properties": {},
+                "type": "object",
+              },
+              "strict": false,
+            },
+            "type": "function",
+          },
+        ],
+      }
+    `);
+  });
+
+  it('should not include strict mode when strict is undefined', () => {
+    const result = prepareTools({
+      tools: [
+        {
+          type: 'function',
+          name: 'testFunction',
+          description: 'A test function',
+          inputSchema: { type: 'object', properties: {} },
+        },
+      ],
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "toolChoice": undefined,
+        "toolWarnings": [],
+        "tools": [
+          {
+            "function": {
+              "description": "A test function",
+              "name": "testFunction",
+              "parameters": {
+                "properties": {},
+                "type": "object",
+              },
+            },
+            "type": "function",
+          },
+        ],
+      }
+    `);
+  });
+
+  it('should pass through strict mode for multiple tools with different strict settings', () => {
+    const result = prepareTools({
+      tools: [
+        {
+          type: 'function',
+          name: 'strictTool',
+          description: 'A strict tool',
+          inputSchema: { type: 'object', properties: {} },
+          strict: true,
+        },
+        {
+          type: 'function',
+          name: 'nonStrictTool',
+          description: 'A non-strict tool',
+          inputSchema: { type: 'object', properties: {} },
+          strict: false,
+        },
+        {
+          type: 'function',
+          name: 'defaultTool',
+          description: 'A tool without strict setting',
+          inputSchema: { type: 'object', properties: {} },
+        },
+      ],
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "toolChoice": undefined,
+        "toolWarnings": [],
+        "tools": [
+          {
+            "function": {
+              "description": "A strict tool",
+              "name": "strictTool",
+              "parameters": {
+                "properties": {},
+                "type": "object",
+              },
+              "strict": true,
+            },
+            "type": "function",
+          },
+          {
+            "function": {
+              "description": "A non-strict tool",
+              "name": "nonStrictTool",
+              "parameters": {
+                "properties": {},
+                "type": "object",
+              },
+              "strict": false,
+            },
+            "type": "function",
+          },
+          {
+            "function": {
+              "description": "A tool without strict setting",
+              "name": "defaultTool",
+              "parameters": {
+                "properties": {},
+                "type": "object",
+              },
+            },
+            "type": "function",
+          },
+        ],
+      }
+    `);
+  });
+});

package/src/mistral-prepare-tools.ts

@@ -0,0 +1,97 @@
+import {
+  LanguageModelV3CallOptions,
+  SharedV3Warning,
+  UnsupportedFunctionalityError,
+} from '@ai-sdk/provider';
+import { MistralToolChoice } from './mistral-chat-prompt';
+
+export function prepareTools({
+  tools,
+  toolChoice,
+}: {
+  tools: LanguageModelV3CallOptions['tools'];
+  toolChoice?: LanguageModelV3CallOptions['toolChoice'];
+}): {
+  tools:
+    | Array<{
+        type: 'function';
+        function: {
+          name: string;
+          description: string | undefined;
+          parameters: unknown;
+          strict?: boolean;
+        };
+      }>
+    | undefined;
+  toolChoice: MistralToolChoice | undefined;
+  toolWarnings: SharedV3Warning[];
+} {
+  // when the tools array is empty, change it to undefined to prevent errors:
+  tools = tools?.length ? tools : undefined;
+
+  const toolWarnings: SharedV3Warning[] = [];
+
+  if (tools == null) {
+    return { tools: undefined, toolChoice: undefined, toolWarnings };
+  }
+
+  const mistralTools: Array<{
+    type: 'function';
+    function: {
+      name: string;
+      description: string | undefined;
+      parameters: unknown;
+      strict?: boolean;
+    };
+  }> = [];
+
+  for (const tool of tools) {
+    if (tool.type === 'provider') {
+      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':
+      return {
+        tools: mistralTools.filter(
+          tool => tool.function.name === toolChoice.toolName,
+        ),
+        toolChoice: 'any',
+        toolWarnings,
+      };
+    default: {
+      const _exhaustiveCheck: never = type;
+      throw new UnsupportedFunctionalityError({
+        functionality: `tool choice type: ${_exhaustiveCheck}`,
+      });
+    }
+  }
+}

package/src/mistral-provider.ts

@@ -0,0 +1,147 @@
+import {
+  EmbeddingModelV3,
+  LanguageModelV3,
+  NoSuchModelError,
+  ProviderV3,
+} from '@ai-sdk/provider';
+import {
+  FetchFunction,
+  loadApiKey,
+  withoutTrailingSlash,
+  withUserAgentSuffix,
+} from '@ai-sdk/provider-utils';
+import { MistralChatLanguageModel } from './mistral-chat-language-model';
+import { MistralChatModelId } from './mistral-chat-options';
+import { MistralEmbeddingModel } from './mistral-embedding-model';
+import { MistralEmbeddingModelId } from './mistral-embedding-options';
+import { VERSION } from './version';
+
+export interface MistralProvider extends ProviderV3 {
+  (modelId: MistralChatModelId): LanguageModelV3;
+
+  /**
+Creates a model for text generation.
+*/
+  languageModel(modelId: MistralChatModelId): LanguageModelV3;
+
+  /**
+Creates a model for text generation.
+*/
+  chat(modelId: MistralChatModelId): LanguageModelV3;
+
+  /**
+   * Creates a model for text embeddings.
+   */
+  embedding(modelId: MistralEmbeddingModelId): EmbeddingModelV3;
+
+  /**
+   * Creates a model for text embeddings.
+   */
+  embeddingModel: (modelId: MistralEmbeddingModelId) => EmbeddingModelV3;
+
+  /**
+   * @deprecated Use `embedding` instead.
+   */
+  textEmbedding(modelId: MistralEmbeddingModelId): EmbeddingModelV3;
+
+  /**
+   * @deprecated Use `embeddingModel` instead.
+   */
+  textEmbeddingModel(modelId: MistralEmbeddingModelId): EmbeddingModelV3;
+}
+
+export interface MistralProviderSettings {
+  /**
+Use a different URL prefix for API calls, e.g. to use proxy servers.
+The default prefix is `https://api.mistral.ai/v1`.
+   */
+  baseURL?: string;
+
+  /**
+API key that is being send using the `Authorization` header.
+It defaults to the `MISTRAL_API_KEY` environment variable.
+   */
+  apiKey?: string;
+
+  /**
+Custom headers to include in the requests.
+     */
+  headers?: Record<string, string>;
+
+  /**
+Custom fetch implementation. You can use it as a middleware to intercept requests,
+or to provide a custom fetch implementation for e.g. testing.
+    */
+  fetch?: FetchFunction;
+
+  generateId?: () => string;
+}
+
+/**
+Create a Mistral AI provider instance.
+ */
+export function createMistral(
+  options: MistralProviderSettings = {},
+): MistralProvider {
+  const baseURL =
+    withoutTrailingSlash(options.baseURL) ?? 'https://api.mistral.ai/v1';
+
+  const getHeaders = () =>
+    withUserAgentSuffix(
+      {
+        Authorization: `Bearer ${loadApiKey({
+          apiKey: options.apiKey,
+          environmentVariableName: 'MISTRAL_API_KEY',
+          description: 'Mistral',
+        })}`,
+        ...options.headers,
+      },
+      `ai-sdk/mistral/${VERSION}`,
+    );
+
+  const createChatModel = (modelId: MistralChatModelId) =>
+    new MistralChatLanguageModel(modelId, {
+      provider: 'mistral.chat',
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+      generateId: options.generateId,
+    });
+
+  const createEmbeddingModel = (modelId: MistralEmbeddingModelId) =>
+    new MistralEmbeddingModel(modelId, {
+      provider: 'mistral.embedding',
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
+  const provider = function (modelId: MistralChatModelId) {
+    if (new.target) {
+      throw new Error(
+        'The Mistral model function cannot be called with the new keyword.',
+      );
+    }
+
+    return createChatModel(modelId);
+  };
+
+  provider.specificationVersion = 'v3' as const;
+  provider.languageModel = createChatModel;
+  provider.chat = createChatModel;
+  provider.embedding = createEmbeddingModel;
+  provider.embeddingModel = createEmbeddingModel;
+  provider.textEmbedding = createEmbeddingModel;
+  provider.textEmbeddingModel = createEmbeddingModel;
+
+  provider.imageModel = (modelId: string) => {
+    throw new NoSuchModelError({ modelId, modelType: 'imageModel' });
+  };
+
+  return provider;
+}
+
+/**
+Default Mistral provider instance.
+ */
+export const mistral = createMistral();

package/src/version.ts

@@ -0,0 +1,6 @@
+// Version string of this package injected at build time.
+declare const __PACKAGE_VERSION__: string | undefined;
+export const VERSION: string =
+  typeof __PACKAGE_VERSION__ !== 'undefined'
+    ? __PACKAGE_VERSION__
+    : '0.0.0-test';