ai 6.0.312 → 6.0.314

package/dist/internal/index.js

@@ -164,7 +164,7 @@ function detectMediaType({
 var import_provider_utils2 = require("@ai-sdk/provider-utils");
 
 // src/version.ts
-var VERSION = true ? "6.0.312" : "0.0.0-test";
+var VERSION = true ? "6.0.314" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({

package/dist/internal/index.mjs

@@ -144,7 +144,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "6.0.312" : "0.0.0-test";
+var VERSION = true ? "6.0.314" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({

package/docs/03-ai-sdk-core/15-tools-and-tool-calling.mdx

@@ -603,6 +603,12 @@ It supports the following settings:
 - `none`: the model must not call tools
 - `{ type: 'tool', toolName: string (typed) }`: the model must call the specified tool
 
+When `toolChoice` is `'none'`, the SDK prevents local tool execution even if the
+model returns a tool call. Such responses produce a
+[`ToolChoiceViolationError`](/docs/reference/ai-sdk-errors/ai-tool-choice-violation-error).
+With `streamText`, tool parts are withheld from the stream, so client-side tools
+are not invoked either. Tool call repair is skipped for rejected tool calls.
+
 ```ts highlight="18"
 import { z } from 'zod';
 import { generateText, tool } from 'ai';

package/docs/03-ai-sdk-core/37-speech.mdx

@@ -142,6 +142,7 @@ try {
 | [OpenAI](/providers/ai-sdk-providers/openai#speech-models)         | `tts-1-hd`               |
 | [OpenAI](/providers/ai-sdk-providers/openai#speech-models)         | `gpt-4o-mini-tts`        |
 | [Mistral](/providers/ai-sdk-providers/mistral#speech-models)       | `voxtral-mini-tts-2603`  |
+| [Mistral](/providers/ai-sdk-providers/mistral#speech-models)       | `voxtral-mini-tts-3-0`   |
 | [Azure Speech](/providers/ai-sdk-providers/azure#mai-voice)        | `mai-voice-2.1-flash`    |
 | [Azure Speech](/providers/ai-sdk-providers/azure#mai-voice)        | `mai-voice-2.1`          |
 | [Azure Speech](/providers/ai-sdk-providers/azure#mai-voice)        | `mai-voice-2-flash`      |

package/docs/07-reference/05-ai-sdk-errors/ai-tool-choice-violation-error.mdx

@@ -6,13 +6,15 @@ description: Learn how to handle AI_ToolChoiceViolationError
 # AI_ToolChoiceViolationError
 
 This error occurs when a model response does not satisfy an enforced tool
-choice. It is thrown when `toolChoice` is set to `'required'` but the response
-contains no structured tool call, or when a specifically selected tool was not
-called.
+choice. It is thrown when `toolChoice` is set to `'none'` but the response
+contains a tool call, when `'required'` produces no structured tool call, or
+when a specifically selected tool was not called. With `streamText`, the error
+is emitted in the stream when `'none'` is selected. Tool calls returned while
+`'none'` is selected are not executed.
 
 The error does not automatically interpret text or reasoning as an executable
-tool call. You can inspect `content` to implement opt-in recovery, including
-schema validation before executing any recovered call.
+tool call. When tool calls are allowed, you can inspect `content` to implement
+opt-in recovery, including schema validation before executing any recovered call.
 
 ## Properties
 
@@ -30,7 +32,10 @@ You can check if an error is an instance of `AI_ToolChoiceViolationError` using:
 ```typescript
 import { ToolChoiceViolationError } from 'ai';
 
-if (ToolChoiceViolationError.isInstance(error)) {
+if (
+  ToolChoiceViolationError.isInstance(error) &&
+  error.toolChoice.type !== 'none'
+) {
   const serializedCall = error.content.find(part => part.type === 'text')?.text;
 
   // Parse and validate serializedCall before treating it as a tool call.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "6.0.312",
+  "version": "6.0.314",
   "description": "AI SDK by Vercel - build apps like ChatGPT, Claude, Gemini, and more with a single interface for any model using the Vercel AI Gateway or go direct to OpenAI, Anthropic, Google, or any other model provider.",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -45,7 +45,7 @@
   },
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
-    "@ai-sdk/gateway": "3.0.219",
+    "@ai-sdk/gateway": "3.0.220",
     "@ai-sdk/provider": "3.0.19",
     "@ai-sdk/provider-utils": "4.0.62"
   },

package/src/error/tool-choice-violation-error.ts

@@ -11,7 +11,7 @@ const symbol = Symbol.for(marker);
 
 type EnforcedToolChoice = Extract<
   LanguageModelV3ToolChoice,
-  { type: 'required' } | { type: 'tool' }
+  { type: 'none' } | { type: 'required' } | { type: 'tool' }
 >;
 
 /**
@@ -54,9 +54,11 @@ export class ToolChoiceViolationError extends AISDKError {
     provider,
     modelId,
     content,
-    message = toolChoice.type === 'required'
-      ? 'Model response did not contain a tool call even though tool choice was required.'
-      : `Model response did not contain a call to the required tool '${toolChoice.toolName}'.`,
+    message = toolChoice.type === 'none'
+      ? 'Model response contained a tool call even though tool choice was none.'
+      : toolChoice.type === 'required'
+        ? 'Model response did not contain a tool call even though tool choice was required.'
+        : `Model response did not contain a call to the required tool '${toolChoice.toolName}'.`,
   }: {
     toolChoice: EnforcedToolChoice;
     finishReason: FinishReason;

package/src/generate-text/collect-tool-approvals.ts

@@ -73,6 +73,7 @@ export function collectToolApprovals<TOOLS extends ToolSet>({
 
   const approvedToolApprovals: Array<CollectedToolApprovals<TOOLS>> = [];
   const deniedToolApprovals: Array<CollectedToolApprovals<TOOLS>> = [];
+  const collectedToolCallIds = new Set<string>();
 
   const approvalResponses = lastMessage.content.filter(
     part => part.type === 'tool-approval-response',
@@ -99,6 +100,15 @@ export function collectToolApprovals<TOOLS extends ToolSet>({
       });
     }
 
+    // Only the first response for a tool call is collected. Later responses
+    // (replays, conflicting decisions, or responses to another approval of the
+    // same call) would otherwise execute the tool twice or both execute and
+    // deny it.
+    if (collectedToolCallIds.has(toolCall.toolCallId)) {
+      continue;
+    }
+    collectedToolCallIds.add(toolCall.toolCallId);
+
     const approval: CollectedToolApprovals<TOOLS> = {
       approvalRequest,
       approvalResponse,

package/src/generate-text/generate-text.ts

@@ -956,7 +956,12 @@ export async function generateText<
                   parseToolCall({
                     toolCall,
                     tools: stepToolSet,
-                    repairToolCall,
+                    // tool calls are rejected with tool choice none,
+                    // so user callbacks must not process them:
+                    repairToolCall:
+                      stepToolChoice?.type === 'none'
+                        ? undefined
+                        : repairToolCall,
                     system,
                     messages: stepInputMessages,
                   }),
@@ -964,18 +969,17 @@ export async function generateText<
             );
 
             const enforcedToolChoice =
-              stepToolChoice?.type === 'required' ||
-              stepToolChoice?.type === 'tool'
-                ? stepToolChoice
-                : undefined;
+              stepToolChoice?.type === 'auto' ? undefined : stepToolChoice;
 
             if (
               enforcedToolChoice != null &&
-              !stepToolCalls.some(
-                toolCall =>
-                  enforcedToolChoice.type === 'required' ||
-                  toolCall.toolName === enforcedToolChoice.toolName,
-              )
+              (enforcedToolChoice.type === 'none'
+                ? stepToolCalls.length > 0
+                : !stepToolCalls.some(
+                    toolCall =>
+                      enforcedToolChoice.type === 'required' ||
+                      toolCall.toolName === enforcedToolChoice.toolName,
+                  ))
             ) {
               throw new ToolChoiceViolationError({
                 toolChoice: enforcedToolChoice,

package/src/generate-text/prune-messages.ts

@@ -161,42 +161,95 @@ export function pruneMessages({
         return message;
       }
 
-      return {
-        ...message,
-        content: message.content.filter(part => {
-          // keep non-tool parts:
-          if (
-            part.type !== 'tool-call' &&
-            part.type !== 'tool-result' &&
-            part.type !== 'tool-approval-request' &&
-            part.type !== 'tool-approval-response'
-          ) {
-            return true;
+      const keepParts = message.content.map(part => {
+        // keep non-tool parts:
+        if (
+          part.type !== 'tool-call' &&
+          part.type !== 'tool-result' &&
+          part.type !== 'tool-approval-request' &&
+          part.type !== 'tool-approval-response'
+        ) {
+          return true;
+        }
+
+        // keep parts that are associated with a tool call or approval that needs to be kept:
+        if (
+          ((part.type === 'tool-call' || part.type === 'tool-result') &&
+            keptToolCallIds.has(part.toolCallId)) ||
+          ((part.type === 'tool-approval-request' ||
+            part.type === 'tool-approval-response') &&
+            keptApprovalIds.has(part.approvalId))
+        ) {
+          return true;
+        }
+
+        // keep parts that are not associated with a tool that should be removed:
+        const partToolName =
+          part.type === 'tool-call' || part.type === 'tool-result'
+            ? part.toolName
+            : approvalIdToToolName.get(part.approvalId);
+
+        return (
+          toolCall.tools != null &&
+          partToolName != null &&
+          !toolCall.tools.includes(partToolName)
+        );
+      });
+
+      // Consecutive reasoning parts can belong to the same provider item.
+      // Remove the whole group when its following content was pruned.
+      if (message.role === 'assistant') {
+        for (
+          let reasoningIndex = 0;
+          reasoningIndex < message.content.length;
+          reasoningIndex++
+        ) {
+          const part = message.content[reasoningIndex];
+          if (part.type !== 'reasoning') {
+            continue;
+          }
+
+          let reasoningEndIndex = reasoningIndex + 1;
+          while (reasoningEndIndex < message.content.length) {
+            const nextPart = message.content[reasoningEndIndex];
+            if (nextPart.type !== 'reasoning') {
+              break;
+            }
+            reasoningEndIndex++;
+          }
+
+          let followingPartIndex = reasoningEndIndex;
+          let hasFollowingPart = false;
+          let hasKeptFollowingPart = false;
+
+          while (followingPartIndex < message.content.length) {
+            const followingPart = message.content[followingPartIndex];
+            if (followingPart.type === 'reasoning') {
+              break;
+            }
+
+            hasFollowingPart = true;
+            hasKeptFollowingPart ||= keepParts[followingPartIndex];
+            followingPartIndex++;
           }
 
-          // keep parts that are associated with a tool call or approval that needs to be kept:
-          if (
-            ((part.type === 'tool-call' || part.type === 'tool-result') &&
-              keptToolCallIds.has(part.toolCallId)) ||
-            ((part.type === 'tool-approval-request' ||
-              part.type === 'tool-approval-response') &&
-              keptApprovalIds.has(part.approvalId))
-          ) {
-            return true;
+          if (hasFollowingPart && !hasKeptFollowingPart) {
+            for (
+              let index = reasoningIndex;
+              index < reasoningEndIndex;
+              index++
+            ) {
+              keepParts[index] = false;
+            }
           }
 
-          // keep parts that are not associated with a tool that should be removed:
-          const partToolName =
-            part.type === 'tool-call' || part.type === 'tool-result'
-              ? part.toolName
-              : approvalIdToToolName.get(part.approvalId);
-
-          return (
-            toolCall.tools != null &&
-            partToolName != null &&
-            !toolCall.tools.includes(partToolName)
-          );
-        }),
+          reasoningIndex = followingPartIndex - 1;
+        }
+      }
+
+      return {
+        ...message,
+        content: message.content.filter((_, index) => keepParts[index]),
       } as AssistantModelMessage | ToolModelMessage;
     });
   }

package/src/generate-text/run-tools-transformation.ts

@@ -1,5 +1,7 @@
 import type {
+  LanguageModelV3Content,
   LanguageModelV3StreamPart,
+  LanguageModelV3ToolChoice,
   SharedV3Warning,
 } from '@ai-sdk/provider';
 import {
@@ -10,6 +12,7 @@ import {
 } from '@ai-sdk/provider-utils';
 import type { Tracer } from '@opentelemetry/api';
 import { ToolCallNotFoundForApprovalError } from '../error/tool-call-not-found-for-approval-error';
+import { ToolChoiceViolationError } from '../error/tool-choice-violation-error';
 import type { TelemetrySettings } from '../telemetry/telemetry-settings';
 import type {
   FinishReason,
@@ -122,6 +125,7 @@ export type SingleRequestTextStreamPart<TOOLS extends ToolSet> =
 
 export function runToolsTransformation<TOOLS extends ToolSet>({
   tools,
+  toolChoice,
   generatorStream,
   tracer,
   telemetry,
@@ -138,6 +142,7 @@ export function runToolsTransformation<TOOLS extends ToolSet>({
   onToolCallFinish,
 }: {
   tools: TOOLS | undefined;
+  toolChoice?: LanguageModelV3ToolChoice;
   generatorStream: ReadableStream<LanguageModelV3StreamPart>;
   tracer: Tracer;
   telemetry: TelemetrySettings | undefined;
@@ -265,6 +270,13 @@ export function runToolsTransformation<TOOLS extends ToolSet>({
   // overtake pending start or delta callbacks in a downstream stream.
   const activeToolCallToolNames = new Map<string, string>();
 
+  // Tool choice none rejects tool calls when the model call finishes.
+  // Withhold tool parts so that consumers (e.g. client-side tools) cannot
+  // act on them before the rejection, and skip user callbacks that would
+  // repair them or process their input.
+  const withholdToolParts = toolChoice?.type === 'none';
+  const withheldToolContent: Array<LanguageModelV3Content> = [];
+
   // forward stream
   const forwardStream = new TransformStream<
     LanguageModelV3StreamPart,
@@ -278,6 +290,24 @@ export function runToolsTransformation<TOOLS extends ToolSet>({
     ) {
       const chunkType = chunk.type;
 
+      if (
+        withholdToolParts &&
+        (chunkType === 'tool-input-start' ||
+          chunkType === 'tool-input-delta' ||
+          chunkType === 'tool-input-end' ||
+          chunkType === 'tool-approval-request')
+      ) {
+        return;
+      }
+
+      if (
+        withholdToolParts &&
+        (chunkType === 'tool-call' || chunkType === 'tool-result')
+      ) {
+        withheldToolContent.push(chunk);
+        return;
+      }
+
       switch (chunkType) {
         // forward:
         case 'stream-start':
@@ -343,14 +373,36 @@ export function runToolsTransformation<TOOLS extends ToolSet>({
         }
 
         case 'finish': {
+          const toolChoiceViolationError =
+            withholdToolParts &&
+            withheldToolContent.some(part => part.type === 'tool-call')
+              ? new ToolChoiceViolationError({
+                  toolChoice: { type: 'none' },
+                  finishReason: chunk.finishReason.unified,
+                  provider: model?.provider ?? 'unknown',
+                  modelId: model?.modelId ?? 'unknown',
+                  content: withheldToolContent,
+                })
+              : undefined;
+
           finishChunk = {
             type: 'finish',
-            finishReason: chunk.finishReason.unified,
+            finishReason:
+              toolChoiceViolationError == null
+                ? chunk.finishReason.unified
+                : 'error',
             rawFinishReason: chunk.finishReason.raw,
             usage: asLanguageModelUsage(chunk.usage),
             providerMetadata: chunk.providerMetadata,
           };
 
+          if (toolChoiceViolationError != null) {
+            controller.enqueue({
+              type: 'error',
+              error: toolChoiceViolationError,
+            });
+          }
+
           if (isToolExecutionAllowedFinishReason(chunk.finishReason.unified)) {
             for (const toolCall of toolCallsToExecute.splice(0)) {
               executeToolCallAfterFinish(toolCall);

package/src/generate-text/stream-text.ts

@@ -1946,6 +1946,7 @@ class DefaultStreamTextResult<
 
             const streamWithToolResults = runToolsTransformation({
               tools: stepToolSet,
+              toolChoice: stepToolChoice,
               generatorStream: stream,
               tracer,
               telemetry,

package/src/ui/process-ui-message-stream.ts

@@ -253,6 +253,7 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
 
             if (part != null) {
               part.state = options.state;
+              anyPart.type = `tool-${options.toolName}`;
               anyPart.input = anyOptions.input;
               anyPart.output = anyOptions.output;
               anyPart.errorText = anyOptions.errorText;