@ai-sdk/mistral 2.0.0-canary.9 → 2.0.1

package/dist/index.js

@@ -31,7 +31,7 @@ var import_provider_utils4 = require("@ai-sdk/provider-utils");
 
 // src/mistral-chat-language-model.ts
 var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_zod3 = require("zod");
+var import_v43 = require("zod/v4");
 
 // src/convert-to-mistral-chat-messages.ts
 var import_provider = require("@ai-sdk/provider");
@@ -91,7 +91,7 @@ function convertToMistralChatMessages(prompt) {
                 type: "function",
                 function: {
                   name: part.toolName,
-                  arguments: JSON.stringify(part.args)
+                  arguments: JSON.stringify(part.input)
                 }
               });
               break;
@@ -108,11 +108,24 @@ function convertToMistralChatMessages(prompt) {
       }
       case "tool": {
         for (const toolResponse of content) {
+          const output = toolResponse.output;
+          let contentValue;
+          switch (output.type) {
+            case "text":
+            case "error-text":
+              contentValue = output.value;
+              break;
+            case "content":
+            case "json":
+            case "error-json":
+              contentValue = JSON.stringify(output.value);
+              break;
+          }
           messages.push({
             role: "tool",
             name: toolResponse.toolName,
-            content: JSON.stringify(toolResponse.result),
-            tool_call_id: toolResponse.toolCallId
+            tool_call_id: toolResponse.toolCallId,
+            content: contentValue
           });
         }
         break;
@@ -155,27 +168,27 @@ function mapMistralFinishReason(finishReason) {
 }
 
 // src/mistral-chat-options.ts
-var import_zod = require("zod");
-var mistralProviderOptions = import_zod.z.object({
+var import_v4 = require("zod/v4");
+var mistralProviderOptions = import_v4.z.object({
   /**
   Whether to inject a safety prompt before all conversations.
   
   Defaults to `false`.
      */
-  safePrompt: import_zod.z.boolean().nullish(),
-  documentImageLimit: import_zod.z.number().nullish(),
-  documentPageLimit: import_zod.z.number().nullish()
+  safePrompt: import_v4.z.boolean().optional(),
+  documentImageLimit: import_v4.z.number().optional(),
+  documentPageLimit: import_v4.z.number().optional()
 });
 
 // src/mistral-error.ts
 var import_provider_utils = require("@ai-sdk/provider-utils");
-var import_zod2 = require("zod");
-var mistralErrorDataSchema = import_zod2.z.object({
-  object: import_zod2.z.literal("error"),
-  message: import_zod2.z.string(),
-  type: import_zod2.z.string(),
-  param: import_zod2.z.string().nullable(),
-  code: import_zod2.z.string().nullable()
+var import_v42 = require("zod/v4");
+var mistralErrorDataSchema = import_v42.z.object({
+  object: import_v42.z.literal("error"),
+  message: import_v42.z.string(),
+  type: import_v42.z.string(),
+  param: import_v42.z.string().nullable(),
+  code: import_v42.z.string().nullable()
 });
 var mistralFailedResponseHandler = (0, import_provider_utils.createJsonErrorResponseHandler)({
   errorSchema: mistralErrorDataSchema,
@@ -203,7 +216,7 @@ function prepareTools({
         function: {
           name: tool.name,
           description: tool.description,
-          parameters: tool.parameters
+          parameters: tool.inputSchema
         }
       });
     }
@@ -239,18 +252,16 @@ function prepareTools({
 var MistralChatLanguageModel = class {
   constructor(modelId, config) {
     this.specificationVersion = "v2";
+    this.supportedUrls = {
+      "application/pdf": [/^https:\/\/.*$/]
+    };
     this.modelId = modelId;
     this.config = config;
   }
   get provider() {
     return this.config.provider;
   }
-  async getSupportedUrls() {
-    return {
-      "application/pdf": [/^https:\/\/.*$/]
-    };
-  }
-  getArgs({
+  async getArgs({
     prompt,
     maxOutputTokens,
     temperature,
@@ -267,7 +278,7 @@ var MistralChatLanguageModel = class {
   }) {
     var _a;
     const warnings = [];
-    const options = (_a = (0, import_provider_utils2.parseProviderOptions)({
+    const options = (_a = await (0, import_provider_utils2.parseProviderOptions)({
       provider: "mistral",
       providerOptions,
       schema: mistralProviderOptions
@@ -339,7 +350,7 @@ var MistralChatLanguageModel = class {
     };
   }
   async doGenerate(options) {
-    const { args: body, warnings } = this.getArgs(options);
+    const { args: body, warnings } = await this.getArgs(options);
     const {
       responseHeaders,
       value: response,
@@ -369,10 +380,9 @@ var MistralChatLanguageModel = class {
       for (const toolCall of choice.message.tool_calls) {
         content.push({
           type: "tool-call",
-          toolCallType: "function",
           toolCallId: toolCall.id,
           toolName: toolCall.function.name,
-          args: toolCall.function.arguments
+          input: toolCall.function.arguments
         });
       }
     }
@@ -381,7 +391,8 @@ var MistralChatLanguageModel = class {
       finishReason: mapMistralFinishReason(choice.finish_reason),
       usage: {
         inputTokens: response.usage.prompt_tokens,
-        outputTokens: response.usage.completion_tokens
+        outputTokens: response.usage.completion_tokens,
+        totalTokens: response.usage.total_tokens
       },
       request: { body },
       response: {
@@ -393,7 +404,7 @@ var MistralChatLanguageModel = class {
     };
   }
   async doStream(options) {
-    const { args, warnings } = this.getArgs(options);
+    const { args, warnings } = await this.getArgs(options);
     const body = { ...args, stream: true };
     const { responseHeaders, value: response } = await (0, import_provider_utils2.postJsonToApi)({
       url: `${this.config.baseURL}/chat/completions`,
@@ -409,10 +420,11 @@ var MistralChatLanguageModel = class {
     let finishReason = "unknown";
     const usage = {
       inputTokens: void 0,
-      outputTokens: void 0
+      outputTokens: void 0,
+      totalTokens: void 0
     };
-    let chunkNumber = 0;
-    let trimLeadingSpace = false;
+    let isFirstChunk = true;
+    let activeText = false;
     return {
       stream: response.pipeThrough(
         new TransformStream({
@@ -420,13 +432,16 @@ var MistralChatLanguageModel = class {
             controller.enqueue({ type: "stream-start", warnings });
           },
           transform(chunk, controller) {
+            if (options.includeRawChunks) {
+              controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
+            }
             if (!chunk.success) {
               controller.enqueue({ type: "error", error: chunk.error });
               return;
             }
-            chunkNumber++;
             const value = chunk.value;
-            if (chunkNumber === 1) {
+            if (isFirstChunk) {
+              isFirstChunk = false;
               controller.enqueue({
                 type: "response-metadata",
                 ...getResponseMetadata(value)
@@ -435,53 +450,62 @@ var MistralChatLanguageModel = class {
             if (value.usage != null) {
               usage.inputTokens = value.usage.prompt_tokens;
               usage.outputTokens = value.usage.completion_tokens;
+              usage.totalTokens = value.usage.total_tokens;
             }
             const choice = value.choices[0];
-            if ((choice == null ? void 0 : choice.finish_reason) != null) {
-              finishReason = mapMistralFinishReason(choice.finish_reason);
-            }
-            if ((choice == null ? void 0 : choice.delta) == null) {
-              return;
-            }
             const delta = choice.delta;
             const textContent = extractTextContent(delta.content);
-            if (chunkNumber <= 2) {
-              const lastMessage = body.messages[body.messages.length - 1];
-              if (lastMessage.role === "assistant" && textContent === lastMessage.content.trimEnd()) {
-                if (textContent.length < lastMessage.content.length) {
-                  trimLeadingSpace = true;
-                }
-                return;
+            if (textContent != null && textContent.length > 0) {
+              if (!activeText) {
+                controller.enqueue({ type: "text-start", id: "0" });
+                activeText = true;
               }
-            }
-            if (textContent != null) {
               controller.enqueue({
-                type: "text",
-                text: trimLeadingSpace ? textContent.trimStart() : textContent
+                type: "text-delta",
+                id: "0",
+                delta: textContent
               });
-              trimLeadingSpace = false;
             }
-            if (delta.tool_calls != null) {
+            if ((delta == null ? void 0 : 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-call-delta",
-                  toolCallType: "function",
-                  toolCallId: toolCall.id,
-                  toolName: toolCall.function.name,
-                  argsTextDelta: toolCall.function.arguments
+                  type: "tool-input-delta",
+                  id: toolCallId,
+                  delta: input
+                });
+                controller.enqueue({
+                  type: "tool-input-end",
+                  id: toolCallId
                 });
                 controller.enqueue({
                   type: "tool-call",
-                  toolCallType: "function",
-                  toolCallId: toolCall.id,
-                  toolName: toolCall.function.name,
-                  args: toolCall.function.arguments
+                  toolCallId,
+                  toolName,
+                  input
                 });
               }
             }
+            if (choice.finish_reason != null) {
+              finishReason = mapMistralFinishReason(choice.finish_reason);
+            }
           },
           flush(controller) {
-            controller.enqueue({ type: "finish", finishReason, usage });
+            if (activeText) {
+              controller.enqueue({ type: "text-end", id: "0" });
+            }
+            controller.enqueue({
+              type: "finish",
+              finishReason,
+              usage
+            });
           }
         })
       ),
@@ -515,105 +539,97 @@ function extractTextContent(content) {
   }
   return textContent.length ? textContent.join("") : void 0;
 }
-var mistralContentSchema = import_zod3.z.union([
-  import_zod3.z.string(),
-  import_zod3.z.array(
-    import_zod3.z.discriminatedUnion("type", [
-      import_zod3.z.object({
-        type: import_zod3.z.literal("text"),
-        text: import_zod3.z.string()
+var mistralContentSchema = import_v43.z.union([
+  import_v43.z.string(),
+  import_v43.z.array(
+    import_v43.z.discriminatedUnion("type", [
+      import_v43.z.object({
+        type: import_v43.z.literal("text"),
+        text: import_v43.z.string()
       }),
-      import_zod3.z.object({
-        type: import_zod3.z.literal("image_url"),
-        image_url: import_zod3.z.union([
-          import_zod3.z.string(),
-          import_zod3.z.object({
-            url: import_zod3.z.string(),
-            detail: import_zod3.z.string().nullable()
+      import_v43.z.object({
+        type: import_v43.z.literal("image_url"),
+        image_url: import_v43.z.union([
+          import_v43.z.string(),
+          import_v43.z.object({
+            url: import_v43.z.string(),
+            detail: import_v43.z.string().nullable()
           })
         ])
       }),
-      import_zod3.z.object({
-        type: import_zod3.z.literal("reference"),
-        reference_ids: import_zod3.z.array(import_zod3.z.number())
+      import_v43.z.object({
+        type: import_v43.z.literal("reference"),
+        reference_ids: import_v43.z.array(import_v43.z.number())
       })
     ])
   )
 ]).nullish();
-var mistralChatResponseSchema = import_zod3.z.object({
-  id: import_zod3.z.string().nullish(),
-  created: import_zod3.z.number().nullish(),
-  model: import_zod3.z.string().nullish(),
-  choices: import_zod3.z.array(
-    import_zod3.z.object({
-      message: import_zod3.z.object({
-        role: import_zod3.z.literal("assistant"),
+var mistralUsageSchema = import_v43.z.object({
+  prompt_tokens: import_v43.z.number(),
+  completion_tokens: import_v43.z.number(),
+  total_tokens: import_v43.z.number()
+});
+var mistralChatResponseSchema = import_v43.z.object({
+  id: import_v43.z.string().nullish(),
+  created: import_v43.z.number().nullish(),
+  model: import_v43.z.string().nullish(),
+  choices: import_v43.z.array(
+    import_v43.z.object({
+      message: import_v43.z.object({
+        role: import_v43.z.literal("assistant"),
         content: mistralContentSchema,
-        tool_calls: import_zod3.z.array(
-          import_zod3.z.object({
-            id: import_zod3.z.string(),
-            function: import_zod3.z.object({ name: import_zod3.z.string(), arguments: import_zod3.z.string() })
+        tool_calls: import_v43.z.array(
+          import_v43.z.object({
+            id: import_v43.z.string(),
+            function: import_v43.z.object({ name: import_v43.z.string(), arguments: import_v43.z.string() })
           })
         ).nullish()
       }),
-      index: import_zod3.z.number(),
-      finish_reason: import_zod3.z.string().nullish()
+      index: import_v43.z.number(),
+      finish_reason: import_v43.z.string().nullish()
     })
   ),
-  object: import_zod3.z.literal("chat.completion"),
-  usage: import_zod3.z.object({
-    prompt_tokens: import_zod3.z.number(),
-    completion_tokens: import_zod3.z.number()
-  })
+  object: import_v43.z.literal("chat.completion"),
+  usage: mistralUsageSchema
 });
-var mistralChatChunkSchema = import_zod3.z.object({
-  id: import_zod3.z.string().nullish(),
-  created: import_zod3.z.number().nullish(),
-  model: import_zod3.z.string().nullish(),
-  choices: import_zod3.z.array(
-    import_zod3.z.object({
-      delta: import_zod3.z.object({
-        role: import_zod3.z.enum(["assistant"]).optional(),
+var mistralChatChunkSchema = import_v43.z.object({
+  id: import_v43.z.string().nullish(),
+  created: import_v43.z.number().nullish(),
+  model: import_v43.z.string().nullish(),
+  choices: import_v43.z.array(
+    import_v43.z.object({
+      delta: import_v43.z.object({
+        role: import_v43.z.enum(["assistant"]).optional(),
         content: mistralContentSchema,
-        tool_calls: import_zod3.z.array(
-          import_zod3.z.object({
-            id: import_zod3.z.string(),
-            function: import_zod3.z.object({ name: import_zod3.z.string(), arguments: import_zod3.z.string() })
+        tool_calls: import_v43.z.array(
+          import_v43.z.object({
+            id: import_v43.z.string(),
+            function: import_v43.z.object({ name: import_v43.z.string(), arguments: import_v43.z.string() })
           })
         ).nullish()
       }),
-      finish_reason: import_zod3.z.string().nullish(),
-      index: import_zod3.z.number()
+      finish_reason: import_v43.z.string().nullish(),
+      index: import_v43.z.number()
     })
   ),
-  usage: import_zod3.z.object({
-    prompt_tokens: import_zod3.z.number(),
-    completion_tokens: import_zod3.z.number()
-  }).nullish()
+  usage: mistralUsageSchema.nullish()
 });
 
 // src/mistral-embedding-model.ts
 var import_provider3 = require("@ai-sdk/provider");
 var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_zod4 = require("zod");
+var import_v44 = require("zod/v4");
 var MistralEmbeddingModel = class {
-  constructor(modelId, settings, config) {
+  constructor(modelId, config) {
     this.specificationVersion = "v2";
+    this.maxEmbeddingsPerCall = 32;
+    this.supportsParallelCalls = false;
     this.modelId = modelId;
-    this.settings = settings;
     this.config = config;
   }
   get provider() {
     return this.config.provider;
   }
-  get maxEmbeddingsPerCall() {
-    var _a;
-    return (_a = this.settings.maxEmbeddingsPerCall) != null ? _a : 32;
-  }
-  get supportsParallelCalls() {
-    var _a;
-    return (_a = this.settings.supportsParallelCalls) != null ? _a : false;
-  }
   async doEmbed({
     values,
     abortSignal,
@@ -653,9 +669,9 @@ var MistralEmbeddingModel = class {
     };
   }
 };
-var MistralTextEmbeddingResponseSchema = import_zod4.z.object({
-  data: import_zod4.z.array(import_zod4.z.object({ embedding: import_zod4.z.array(import_zod4.z.number()) })),
-  usage: import_zod4.z.object({ prompt_tokens: import_zod4.z.number() }).nullish()
+var MistralTextEmbeddingResponseSchema = import_v44.z.object({
+  data: import_v44.z.array(import_v44.z.object({ embedding: import_v44.z.array(import_v44.z.number()) })),
+  usage: import_v44.z.object({ prompt_tokens: import_v44.z.number() }).nullish()
 });
 
 // src/mistral-provider.ts
@@ -676,7 +692,7 @@ function createMistral(options = {}) {
     headers: getHeaders,
     fetch: options.fetch
   });
-  const createEmbeddingModel = (modelId, settings = {}) => new MistralEmbeddingModel(modelId, settings, {
+  const createEmbeddingModel = (modelId) => new MistralEmbeddingModel(modelId, {
     provider: "mistral.embedding",
     baseURL,
     headers: getHeaders,