ai 7.0.87 → 7.0.88

package/docs/03-agents/07-workflow-agent.mdx

@@ -587,11 +587,11 @@ Agents provide lifecycle callbacks for logging, observability, and custom teleme
 const agent = new WorkflowAgent({
   model: 'anthropic/claude-sonnet-4-6',
 
-  experimental_onStart({ modelId, messages }) {
-    console.log('Agent started');
+  onStart({ messages }) {
+    console.log(`Agent started with ${messages.length} messages`);
   },
 
-  experimental_onStepStart({ stepNumber }) {
+  onStepStart({ stepNumber }) {
     console.log(`Step ${stepNumber} starting`);
   },
 
@@ -613,6 +613,11 @@ const agent = new WorkflowAgent({
 });
 ```
 
+The deprecated `experimental_onStart` and `experimental_onStepStart` names
+remain available for backwards compatibility. When both the stable and
+experimental name are provided in the same constructor or `stream()` call, the
+stable callback is used.
+
 ## Type Inference
 
 Infer the UI message type for type-safe client components:
@@ -764,7 +769,7 @@ For persistence, store `UIMessage[]` as your source of truth and call [`convertT
 
 ### Everything else
 
-Other options carry over with the same names: `prepareStep`, `onStepEnd`, `onEnd`, `onError`, `toolChoice`, `activeTools`, `timeout`, `repairToolCall`, `experimental_sandbox`, and the usual generation settings (`temperature`, `maxOutputTokens`, `topP`, …). `WorkflowAgent` additionally adds `prepareCall` (runs once before the loop) and the `experimental_onStart` / `experimental_onStepStart` / `onToolExecutionStart` / `onToolExecutionEnd` lifecycle callbacks documented above.
+Other options carry over with the same names: `prepareStep`, `onStart`, `onStepStart`, `onStepEnd`, `onEnd`, `onError`, `toolChoice`, `activeTools`, `timeout`, `repairToolCall`, `experimental_sandbox`, and the usual generation settings (`temperature`, `maxOutputTokens`, `topP`, …). `WorkflowAgent` additionally adds `prepareCall` (runs once before the loop) and the `onToolExecutionStart` / `onToolExecutionEnd` lifecycle callbacks documented above. The deprecated `experimental_onStart` and `experimental_onStepStart` aliases remain available for backwards compatibility.
 
 ## Next Steps
 

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

@@ -1133,11 +1133,12 @@ async function generateSomething(prompt: string): Promise<{
 
 ## Handling Errors
 
-The AI SDK has three tool-call related errors:
+The AI SDK has four tool-call related errors:
 
 - [`NoSuchToolError`](/docs/reference/ai-sdk-errors/ai-no-such-tool-error): the model tries to call a tool that is not defined in the tools object
 - [`InvalidToolInputError`](/docs/reference/ai-sdk-errors/ai-invalid-tool-input-error): the model calls a tool with inputs that do not match the tool's input schema
 - [`ToolCallRepairError`](/docs/reference/ai-sdk-errors/ai-tool-call-repair-error): an error that occurred during tool call repair
+- [`ToolChoiceViolationError`](/docs/reference/ai-sdk-errors/ai-tool-choice-violation-error): the `generateText` response does not satisfy a required or specifically selected tool choice
 
 When tool execution fails (errors thrown by your tool's `execute` function), the AI SDK adds them as `tool-error` content parts to enable automated LLM roundtrips in multi-step scenarios.
 

package/docs/07-reference/04-ai-sdk-workflow/01-workflow-agent.mdx

@@ -179,11 +179,11 @@ To see `WorkflowAgent` in action, check out [these examples](#examples).
         'Telemetry configuration with options for enabling/disabling telemetry, setting a function ID, and recording inputs/outputs.',
     },
     {
-      name: 'experimental_onStart',
+      name: 'onStart',
       type: 'WorkflowAgentOnStartCallback',
       isOptional: true,
       description:
-        'Callback called when the agent starts streaming, before any LLM calls. Receives the model, messages, runtime context, and tools context. If also specified in `stream()`, both callbacks fire (constructor first). Experimental (can break in patch releases).',
+        'Callback called when the agent starts streaming, before any LLM calls. Receives the model, messages, runtime context, and tools context. If also specified in `stream()`, both callbacks fire (constructor first). Takes precedence over `experimental_onStart` when both are provided in the constructor.',
       properties: [
         {
           type: 'GenerateTextStartEvent',
@@ -213,11 +213,18 @@ To see `WorkflowAgent` in action, check out [these examples](#examples).
       ],
     },
     {
-      name: 'experimental_onStepStart',
+      name: 'experimental_onStart',
+      type: 'WorkflowAgentOnStartCallback',
+      isOptional: true,
+      description:
+        'Deprecated alias for `onStart`. Used only when `onStart` is not provided in the constructor.',
+    },
+    {
+      name: 'onStepStart',
       type: 'WorkflowAgentOnStepStartCallback',
       isOptional: true,
       description:
-        'Callback called before each step (LLM call) begins. Receives step number, model, messages, previous steps, runtime context, and tools context. If also specified in `stream()`, both callbacks fire (constructor first). Experimental (can break in patch releases).',
+        'Callback called before each step (LLM call) begins. Receives step number, model, messages, previous steps, runtime context, and tools context. If also specified in `stream()`, both callbacks fire (constructor first). Takes precedence over `experimental_onStepStart` when both are provided in the constructor.',
       properties: [
         {
           type: 'GenerateTextStepStartEvent',
@@ -252,6 +259,13 @@ To see `WorkflowAgent` in action, check out [these examples](#examples).
         },
       ],
     },
+    {
+      name: 'experimental_onStepStart',
+      type: 'WorkflowAgentOnStepStartCallback',
+      isOptional: true,
+      description:
+        'Deprecated alias for `onStepStart`. Used only when `onStepStart` is not provided in the constructor.',
+    },
     {
       name: 'onToolExecutionStart',
       type: 'WorkflowAgentonToolExecutionStartCallback',
@@ -600,19 +614,33 @@ const result = await agent.stream({
       description:
         'Per-call prepareStep override. Receives the initial instructions and messages alongside the current step state.',
     },
+    {
+      name: 'onStart',
+      type: 'WorkflowAgentOnStartCallback',
+      isOptional: true,
+      description:
+        'Per-call onStart callback. If also specified in the constructor, both fire (constructor first). Takes precedence over `experimental_onStart` when both are provided in this call.',
+    },
     {
       name: 'experimental_onStart',
       type: 'WorkflowAgentOnStartCallback',
       isOptional: true,
       description:
-        'Per-call onStart callback. If also specified in the constructor, both fire (constructor first). Experimental.',
+        'Deprecated alias for the per-call `onStart` callback. Used only when `onStart` is not provided in this call.',
+    },
+    {
+      name: 'onStepStart',
+      type: 'WorkflowAgentOnStepStartCallback',
+      isOptional: true,
+      description:
+        'Per-call onStepStart callback. If also specified in the constructor, both fire (constructor first). Takes precedence over `experimental_onStepStart` when both are provided in this call.',
     },
     {
       name: 'experimental_onStepStart',
       type: 'WorkflowAgentOnStepStartCallback',
       isOptional: true,
       description:
-        'Per-call onStepStart callback. If also specified in the constructor, both fire (constructor first). Experimental.',
+        'Deprecated alias for the per-call `onStepStart` callback. Used only when `onStepStart` is not provided in this call.',
     },
     {
       name: 'onToolExecutionStart',

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

@@ -0,0 +1,38 @@
+---
+title: ToolChoiceViolationError
+description: Learn how to fix AI SDK ToolChoiceViolationError
+---
+
+# ToolChoiceViolationError
+
+This error occurs when a `generateText` 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.
+
+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.
+
+## Properties
+
+- `toolChoice`: The effective tool choice that the response did not satisfy
+- `finishReason`: The reason why the model finished generating the response
+- `provider`: The provider that returned the response
+- `modelId`: The model that returned the response
+- `content`: The normalized content returned by the model
+- `message`: The error message
+
+## Checking for this Error
+
+You can check if an error is an instance of `ToolChoiceViolationError` using:
+
+```typescript
+import { ToolChoiceViolationError } from 'ai';
+
+if (ToolChoiceViolationError.isInstance(error)) {
+  const serializedCall = error.content.find(part => part.type === 'text')?.text;
+
+  // Parse and validate serializedCall before treating it as a tool call.
+}
+```

package/docs/07-reference/05-ai-sdk-errors/index.mdx

@@ -36,6 +36,7 @@ collapsed: true
 - [AI_StreamProviderError](/docs/reference/ai-sdk-errors/ai-stream-provider-error)
 - [AI_ToolCallNotFoundForApprovalError](/docs/reference/ai-sdk-errors/ai-tool-call-not-found-for-approval-error)
 - [AI_ToolCallRepairError](/docs/reference/ai-sdk-errors/ai-tool-call-repair-error)
+- [AI_ToolChoiceViolationError](/docs/reference/ai-sdk-errors/ai-tool-choice-violation-error)
 - [AI_TooManyEmbeddingValuesForCallError](/docs/reference/ai-sdk-errors/ai-too-many-embedding-values-for-call-error)
 - [AI_TypeValidationError](/docs/reference/ai-sdk-errors/ai-type-validation-error)
 - [AI_UIMessageStreamError](/docs/reference/ai-sdk-errors/ai-ui-message-stream-error)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.87",
+  "version": "7.0.88",
   "type": "module",
   "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",
@@ -47,15 +47,15 @@
     "@ai-sdk/provider-utils": "5.0.34"
   },
   "devDependencies": {
-    "@ai-sdk/amazon-bedrock": "5.0.69",
+    "@ai-sdk/amazon-bedrock": "5.0.70",
     "@ai-sdk/deepseek": "3.0.37",
-    "@ai-sdk/google": "4.0.59",
+    "@ai-sdk/google": "4.0.60",
     "@ai-sdk/groq": "4.0.35",
     "@ai-sdk/huggingface": "2.0.41",
     "@ai-sdk/moonshotai": "3.0.43",
-    "@ai-sdk/openai": "4.0.53",
+    "@ai-sdk/openai": "4.0.54",
     "@ai-sdk/test-server": "2.0.1",
-    "@ai-sdk/xai": "4.0.50",
+    "@ai-sdk/xai": "4.0.51",
     "@edge-runtime/vm": "^5.0.0",
     "@smithy/eventstream-codec": "^4.3.3",
     "@smithy/util-utf8": "^4.3.3",

package/src/batch/batch-types.ts

@@ -4,13 +4,19 @@ import type {
   Experimental_BatchV4Status as BatchV4Status,
   Experimental_BatchLanguageModelV4 as BatchLanguageModelV4,
 } from '@ai-sdk/provider';
-import type { ProviderOptions, ToolSet } from '@ai-sdk/provider-utils';
+import type {
+  InferToolSetContext,
+  ProviderOptions,
+  ToolSet,
+} from '@ai-sdk/provider-utils';
 import type { ContentPart } from '../generate-text/content-part';
+import type { ToolOrder } from '../generate-text/tool-order';
 import type { LanguageModelCallOptions } from '../prompt/language-model-call-options';
 import type { Prompt } from '../prompt/prompt';
 import type {
   FinishReason,
   GlobalProviderModelId,
+  ToolChoice,
 } from '../types/language-model';
 import type { ProviderMetadata } from '../types/provider-metadata';
 import type { LanguageModelUsage } from '../types/usage';
@@ -74,9 +80,34 @@ type BatchRequestOptions = {
 /**
  * Options for starting a text batch.
  */
-export type StartTextBatchOptions = {
+export type StartTextBatchOptions<TOOLS extends ToolSet = ToolSet> = {
   model: BatchLanguageModel;
   requests: ReadonlyArray<TextBatchRequest>;
+
+  /**
+   * Tools that the model can call for every request in the batch.
+   *
+   * Tool definitions are sent to the provider, but their `execute` functions
+   * are never invoked by batch processing.
+   */
+  tools?: TOOLS;
+
+  /**
+   * The tool choice strategy. Default: 'auto'.
+   */
+  toolChoice?: ToolChoice<NoInfer<TOOLS>>;
+
+  /**
+   * Controls the order in which tools are sent to the provider. Tools not
+   * listed are appended alphabetically.
+   */
+  toolOrder?: ToolOrder<TOOLS>;
+
+  /**
+   * Context used when resolving dynamic tool descriptions.
+   */
+  toolsContext?: InferToolSetContext<TOOLS>;
+
   providerOptions?: ProviderOptions;
 
   /**
@@ -97,9 +128,18 @@ export type StartTextBatchResult = TextBatch & {
 /**
  * Options shared by batch status and result retrieval operations.
  */
-export type BatchOperationOptions = {
+export type BatchOperationOptions<TOOLS extends ToolSet = ToolSet> = {
   model: BatchLanguageModel;
   batch: BatchReference;
+
+  /**
+   * Definitions for client tools that were provided to `startTextBatch`.
+   *
+   * The definitions are used only to validate and normalize returned tool
+   * calls. Their `execute` functions are never invoked.
+   */
+  tools?: TOOLS;
+
   providerOptions?: ProviderOptions;
   maxRetries?: number;
 } & BatchRequestOptions;
@@ -107,9 +147,9 @@ export type BatchOperationOptions = {
 /**
  * A normalized result for a successful text batch item.
  */
-export type TextBatchGenerationResult = {
+export type TextBatchGenerationResult<TOOLS extends ToolSet = ToolSet> = {
   /** Ordered normalized content, including citations, sources, and tool data. */
-  readonly content: Array<ContentPart<ToolSet>>;
+  readonly content: Array<ContentPart<TOOLS>>;
   readonly text: string;
   readonly finishReason: FinishReason;
   readonly rawFinishReason?: string;
@@ -125,8 +165,8 @@ export type TextBatchGenerationResult = {
 /**
  * A complete terminal result for one request in a text batch.
  */
-export type TextBatchItemResult =
-  | (TextBatchGenerationResult & {
+export type TextBatchItemResult<TOOLS extends ToolSet = ToolSet> =
+  | (TextBatchGenerationResult<TOOLS> & {
       readonly id: string;
       readonly status: 'succeeded';
     })

package/src/batch/batch.ts

@@ -10,6 +10,8 @@ import { type ToolSet, withUserAgentSuffix } from '@ai-sdk/provider-utils';
 import { InvalidArgumentError } from '../error/invalid-argument-error';
 import { convertLanguageModelContent } from '../generate-text/convert-language-model-content';
 import { parseToolCall } from '../generate-text/parse-tool-call';
+import { prepareToolChoice } from '../prompt/prepare-tool-choice';
+import { prepareTools } from '../prompt/prepare-tools';
 import { logWarnings } from '../logger/log-warnings';
 import { resolveLanguageModel } from '../model/resolve-model';
 import { convertToLanguageModelPrompt } from '../prompt/convert-to-language-model-prompt';
@@ -36,15 +38,19 @@ import type {
 /**
  * Starts a durable text-generation batch.
  */
-export async function startTextBatch({
+export async function startTextBatch<TOOLS extends ToolSet>({
   model: modelArg,
   requests,
+  tools,
+  toolChoice,
+  toolOrder,
+  toolsContext,
   providerOptions,
   webhookUrl,
   abortSignal,
   headers,
   timeout,
-}: StartTextBatchOptions): Promise<StartTextBatchResult> {
+}: StartTextBatchOptions<TOOLS>): Promise<StartTextBatchResult> {
   validateRequests(requests);
 
   const model = resolveBatchLanguageModel(modelArg);
@@ -53,6 +59,12 @@ export async function startTextBatch({
     getTotalTimeoutMs(timeout),
   );
   const supportedUrls = await model.supportedUrls;
+  const preparedTools = await prepareTools({
+    tools,
+    toolOrder,
+    toolsContext,
+  });
+  const preparedToolChoice = prepareToolChoice({ toolChoice });
   operationAbortSignal?.throwIfAborted();
   const normalizedRequests = [];
 
@@ -69,6 +81,8 @@ export async function startTextBatch({
           download: undefined,
           provider: model.provider.split('.')[0],
         }),
+        tools: preparedTools,
+        toolChoice: preparedToolChoice,
         providerOptions: request.providerOptions,
       },
     });
@@ -120,7 +134,7 @@ export async function getBatchStatus({
   abortSignal,
   headers,
   timeout,
-}: BatchOperationOptions): Promise<BatchStatus> {
+}: Omit<BatchOperationOptions, 'tools'>): Promise<BatchStatus> {
   const model = resolveBatchLanguageModel(modelArg);
   validateBatchReference({ model, batch });
 
@@ -152,15 +166,16 @@ export async function getBatchStatus({
 /**
  * Streams complete terminal results for the requests in a durable batch.
  */
-export function getBatchResults({
+export function getBatchResults<TOOLS extends ToolSet>({
   model: modelArg,
   batch,
+  tools,
   providerOptions,
   maxRetries,
   abortSignal,
   headers,
   timeout,
-}: BatchOperationOptions) {
+}: BatchOperationOptions<TOOLS>) {
   const model = resolveBatchLanguageModel(modelArg);
   validateBatchReference({ model, batch });
 
@@ -176,10 +191,10 @@ export function getBatchResults({
   });
   const transformer: Transformer<
     BatchV4ItemResult<LanguageModelV4GenerateResult>,
-    TextBatchItemResult
+    TextBatchItemResult<TOOLS>
   > & { cancel?: (reason?: unknown) => void } = {
     async transform(item, controller) {
-      controller.enqueue(await convertBatchItemResult(item));
+      controller.enqueue(await convertBatchItemResult({ item, tools }));
     },
 
     cancel(reason) {
@@ -190,7 +205,7 @@ export function getBatchResults({
   };
   const transform = new TransformStream<
     BatchV4ItemResult<LanguageModelV4GenerateResult>,
-    TextBatchItemResult
+    TextBatchItemResult<TOOLS>
   >(transformer);
 
   void (async () => {
@@ -299,9 +314,13 @@ function validateBatchReference({
   }
 }
 
-async function convertBatchItemResult(
-  item: BatchV4ItemResult<LanguageModelV4GenerateResult>,
-): Promise<TextBatchItemResult> {
+async function convertBatchItemResult<TOOLS extends ToolSet>({
+  item,
+  tools,
+}: {
+  item: BatchV4ItemResult<LanguageModelV4GenerateResult>;
+  tools: TOOLS | undefined;
+}): Promise<TextBatchItemResult<TOOLS>> {
   if (item.status !== 'succeeded') {
     return item;
   }
@@ -309,22 +328,26 @@ async function convertBatchItemResult(
   return {
     id: item.id,
     status: 'succeeded',
-    ...(await convertGenerateResult(item.result)),
+    ...(await convertGenerateResult({ result: item.result, tools })),
   };
 }
 
-async function convertGenerateResult(
-  result: LanguageModelV4GenerateResult,
-): Promise<TextBatchGenerationResult> {
+async function convertGenerateResult<TOOLS extends ToolSet>({
+  result,
+  tools,
+}: {
+  result: LanguageModelV4GenerateResult;
+  tools: TOOLS | undefined;
+}): Promise<TextBatchGenerationResult<TOOLS>> {
   const toolCalls = await Promise.all(
     result.content
       .filter(
         (part): part is LanguageModelV4ToolCall => part.type === 'tool-call',
       )
       .map(toolCall =>
-        parseToolCall<ToolSet>({
+        parseToolCall<TOOLS>({
           toolCall,
-          tools: undefined,
+          tools,
           repairToolCall: undefined,
           refineToolInput: undefined,
           instructions: undefined,
@@ -332,18 +355,18 @@ async function convertGenerateResult(
         }),
       ),
   );
-  const content = convertLanguageModelContent<ToolSet>({
+  const content = convertLanguageModelContent<TOOLS>({
     content: result.content,
     toolCalls,
     toolOutputs: [],
     toolApprovalRequests: [],
     toolApprovalResponses: [],
-    tools: undefined,
+    tools,
   });
 
   return {
     content,
-    text: content
+    text: result.content
       .filter(
         (part): part is Extract<typeof part, { type: 'text' }> =>
           part.type === 'text',

package/src/error/index.ts

@@ -32,6 +32,7 @@ export { NoVideoGeneratedError } from './no-video-generated-error';
 export { NoSuchToolError } from './no-such-tool-error';
 export { StreamProviderError } from './stream-provider-error';
 export { ToolCallRepairError } from './tool-call-repair-error';
+export { ToolChoiceViolationError } from './tool-choice-violation-error';
 export { UnsupportedModelVersionError } from './unsupported-model-version-error';
 export { UIMessageStreamError } from './ui-message-stream-error';
 export { InvalidDataContentError } from '../prompt/invalid-data-content-error';

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

@@ -0,0 +1,80 @@
+import {
+  AISDKError,
+  type LanguageModelV4Content,
+  type LanguageModelV4ToolChoice,
+} from '@ai-sdk/provider';
+import type { FinishReason } from '../types/language-model';
+
+const name = 'AI_ToolChoiceViolationError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+type EnforcedToolChoice = Extract<
+  LanguageModelV4ToolChoice,
+  { type: 'required' } | { type: 'tool' }
+>;
+
+/**
+ * Thrown when a model response does not satisfy an enforced tool choice.
+ */
+export class ToolChoiceViolationError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  /**
+   * The tool choice that the model response did not satisfy.
+   */
+  readonly toolChoice: EnforcedToolChoice;
+
+  /**
+   * Reason why the model finished generating the response.
+   */
+  readonly finishReason: FinishReason;
+
+  /**
+   * The provider that returned the response.
+   */
+  readonly provider: string;
+
+  /**
+   * The model that returned the response.
+   */
+  readonly modelId: string;
+
+  /**
+   * The normalized content returned by the model.
+   *
+   * This can be inspected to recover a tool call that the provider returned as
+   * text or reasoning instead of a structured tool call.
+   */
+  readonly content: Array<LanguageModelV4Content>;
+
+  constructor({
+    toolChoice,
+    finishReason,
+    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}'.`,
+  }: {
+    toolChoice: EnforcedToolChoice;
+    finishReason: FinishReason;
+    provider: string;
+    modelId: string;
+    content: Array<LanguageModelV4Content>;
+    message?: string;
+  }) {
+    super({ name, message });
+
+    this.toolChoice = toolChoice;
+    this.finishReason = finishReason;
+    this.provider = provider;
+    this.modelId = modelId;
+    this.content = content;
+  }
+
+  static isInstance(error: unknown): error is ToolChoiceViolationError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

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

@@ -15,7 +15,7 @@ import {
   type ProviderOptions,
   type ToolSet,
 } from '@ai-sdk/provider-utils';
-import { NoOutputGeneratedError } from '../error';
+import { NoOutputGeneratedError, ToolChoiceViolationError } from '../error';
 import { logWarnings } from '../logger/log-warnings';
 import { resolveLanguageModel } from '../model/resolve-model';
 import type { ModelMessage } from '../prompt';
@@ -1073,6 +1073,7 @@ export async function generateText<
                     }),
                   ),
               );
+
               const toolApprovalRequests: Record<
                 string,
                 ToolApprovalRequestOutput<TOOLS>
@@ -1132,6 +1133,29 @@ export async function generateText<
                 ],
               });
 
+              const enforcedToolChoice =
+                stepToolChoice.type === 'required' ||
+                stepToolChoice.type === 'tool'
+                  ? stepToolChoice
+                  : undefined;
+
+              if (
+                enforcedToolChoice != null &&
+                !stepToolCalls.some(
+                  toolCall =>
+                    enforcedToolChoice.type === 'required' ||
+                    toolCall.toolName === enforcedToolChoice.toolName,
+                )
+              ) {
+                throw new ToolChoiceViolationError({
+                  toolChoice: enforcedToolChoice,
+                  finishReason: currentModelResponse.finishReason.unified,
+                  provider: stepModel.provider,
+                  modelId: stepModel.modelId,
+                  content: currentModelResponse.content,
+                });
+              }
+
               // notify the tools that the tool calls are available:
               for (const toolCall of stepToolCalls) {
                 if (toolCall.invalid) {