@ai-sdk/anthropic 4.0.30 → 4.0.32

package/docs/05-anthropic.mdx

@@ -1059,13 +1059,15 @@ import { generateText } from 'ai';
 
 const result = await generateText({
   model: anthropic('claude-sonnet-4-6'),
-  system: 'You have access to an `advisor` tool backed by a stronger reviewer model.'
+  system:
+    'You have access to an `advisor` tool backed by a stronger reviewer model.',
   prompt:
     'Build a concurrent worker pool in Go with graceful shutdown. Outline the design first.',
   tools: {
     advisor: anthropic.tools.advisor_20260301({
       model: 'claude-opus-4-8',
       maxUses: 3,
+      maxTokens: 2048,
     }),
   },
 });
@@ -1088,6 +1090,10 @@ The advisor tool supports the following configuration options:
 
   Optional. Maximum number of advisor calls allowed in a single request. Once the executor reaches this cap, further advisor calls return an `advisor_tool_result_error` with `errorCode: 'max_uses_exceeded'`, and the executor continues without further advice.
 
+- **maxTokens** _number_
+
+  Optional. Maximum number of tokens the advisor can generate per call, including thinking and text. The minimum is `1024`, and Anthropic recommends starting with `2048`. This limit applies independently to each advisor call and is separate from the request-level `maxOutputTokens`, which controls executor output. Values above the selected advisor model's output limit result in an Anthropic `400` error. When configured, successful advisor results include `stopReason`; check for `stopReason === 'max_tokens'` to detect truncated advice. The field is available on both plaintext and redacted advisor result variants and is preserved across follow-up turns.
+
 - **caching** _object_
 
   Optional. Enables prompt caching for the advisor's own transcript across calls within a conversation. Use `{ type: 'ephemeral', ttl: '5m' | '1h' }`. This is most useful for longer agent loops where you expect at least three advisor calls.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/anthropic",
-  "version": "4.0.30",
+  "version": "4.0.32",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -36,7 +36,7 @@
   },
   "dependencies": {
     "@ai-sdk/provider": "4.0.5",
-    "@ai-sdk/provider-utils": "5.0.21"
+    "@ai-sdk/provider-utils": "5.0.22"
   },
   "devDependencies": {
     "@types/node": "22.19.19",

package/src/anthropic-api.ts

@@ -358,10 +358,12 @@ export interface AnthropicAdvisorToolResultContent {
     | {
         type: 'advisor_result';
         text: string;
+        stop_reason?: string;
       }
     | {
         type: 'advisor_redacted_result';
         encrypted_content: string;
+        stop_reason?: string;
       }
     | {
         type: 'advisor_tool_result_error';
@@ -530,6 +532,7 @@ export type AnthropicTool =
       name: 'advisor';
       model: string;
       max_uses?: number;
+      max_tokens?: number;
       caching?: {
         type: 'ephemeral';
         ttl: '5m' | '1h';
@@ -924,10 +927,12 @@ export const anthropicResponseSchema = lazySchema(() =>
               z.object({
                 type: z.literal('advisor_result'),
                 text: z.string(),
+                stop_reason: z.string().nullish(),
               }),
               z.object({
                 type: z.literal('advisor_redacted_result'),
                 encrypted_content: z.string(),
+                stop_reason: z.string().nullish(),
               }),
               z.object({
                 type: z.literal('advisor_tool_result_error'),
@@ -1321,10 +1326,12 @@ export const anthropicChunkSchema = lazySchema(() =>
               z.object({
                 type: z.literal('advisor_result'),
                 text: z.string(),
+                stop_reason: z.string().nullish(),
               }),
               z.object({
                 type: z.literal('advisor_redacted_result'),
                 encrypted_content: z.string(),
+                stop_reason: z.string().nullish(),
               }),
               z.object({
                 type: z.literal('advisor_tool_result_error'),

package/src/anthropic-language-model.ts

@@ -1,5 +1,6 @@
 import {
   APICallError,
+  InvalidResponseDataError,
   type JSONObject,
   type LanguageModelV4,
   type LanguageModelV4CallOptions,
@@ -1388,6 +1389,9 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
               result: {
                 type: 'advisor_result',
                 text: part.content.text,
+                ...(part.content.stop_reason != null && {
+                  stopReason: part.content.stop_reason,
+                }),
               },
             });
           } else if (part.content.type === 'advisor_redacted_result') {
@@ -1398,6 +1402,9 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
               result: {
                 type: 'advisor_redacted_result',
                 encryptedContent: part.content.encrypted_content,
+                ...(part.content.stop_reason != null && {
+                  stopReason: part.content.stop_reason,
+                }),
               },
             });
           } else {
@@ -1588,6 +1595,9 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
     let stopDetails: AnthropicMessageMetadata['stopDetails'] = undefined;
     let container: AnthropicMessageMetadata['container'] | null = null;
     let isJsonResponseFromTool = false;
+    let isMessageOpen = false;
+    let activeMessageId: string | null | undefined;
+    let hasInvalidMessageSequence = false;
 
     let blockType:
       | 'text'
@@ -1619,6 +1629,10 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
         },
 
         transform(chunk, controller) {
+          if (hasInvalidMessageSequence) {
+            return;
+          }
+
           if (options.includeRawChunks) {
             controller.enqueue({ type: 'raw', rawValue: chunk.rawValue });
           }
@@ -2097,6 +2111,9 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
                       result: {
                         type: 'advisor_result',
                         text: part.content.text,
+                        ...(part.content.stop_reason != null && {
+                          stopReason: part.content.stop_reason,
+                        }),
                       },
                     });
                   } else if (part.content.type === 'advisor_redacted_result') {
@@ -2107,6 +2124,9 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
                       result: {
                         type: 'advisor_redacted_result',
                         encryptedContent: part.content.encrypted_content,
+                        ...(part.content.stop_reason != null && {
+                          stopReason: part.content.stop_reason,
+                        }),
                       },
                     });
                   } else {
@@ -2405,6 +2425,27 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
             }
 
             case 'message_start': {
+              if (isMessageOpen) {
+                if (activeMessageId === value.message.id) {
+                  return;
+                }
+
+                hasInvalidMessageSequence = true;
+                controller.enqueue({
+                  type: 'error',
+                  error: new InvalidResponseDataError({
+                    data: value,
+                    message:
+                      `Received message_start for message ${JSON.stringify(value.message.id)} ` +
+                      `while message ${JSON.stringify(activeMessageId)} is still open.`,
+                  }),
+                });
+                return;
+              }
+
+              isMessageOpen = true;
+              activeMessageId = value.message.id;
+
               usage.input_tokens = value.message.usage.input_tokens;
               usage.cache_read_input_tokens =
                 value.message.usage.cache_read_input_tokens ?? 0;
@@ -2559,6 +2600,9 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
             }
 
             case 'message_stop': {
+              isMessageOpen = false;
+              activeMessageId = undefined;
+
               const anthropicMetadata = {
                 usage: (rawUsage as JSONObject) ?? null,
                 stopSequence,

package/src/anthropic-prepare-tools.ts

@@ -358,6 +358,9 @@ export async function prepareTools({
               name: 'advisor',
               model: args.model,
               ...(args.maxUses !== undefined && { max_uses: args.maxUses }),
+              ...(args.maxTokens !== undefined && {
+                max_tokens: args.maxTokens,
+              }),
               ...(args.caching !== undefined && { caching: args.caching }),
             });
             break;

package/src/anthropic-tools.ts

@@ -44,6 +44,8 @@ export const anthropicTools = {
    *
    * @param model - The advisor model ID (required), e.g. `"claude-opus-4-8"`.
    * @param maxUses - Maximum advisor calls per request (per-request cap).
+   * @param maxTokens - Maximum advisor output tokens per call, including
+   * thinking and text. Minimum 1024; Anthropic recommends starting with 2048.
    * @param caching - Enables prompt caching for the advisor's transcript
    * across calls within a conversation. Worthwhile from ~3 advisor calls
    * per conversation.

package/src/convert-to-anthropic-prompt.ts

@@ -1243,6 +1243,9 @@ export async function convertToAnthropicPrompt({
                       content: {
                         type: 'advisor_result',
                         text: advisorOutput.text,
+                        ...(advisorOutput.stopReason !== undefined && {
+                          stop_reason: advisorOutput.stopReason,
+                        }),
                       },
                       cache_control: cacheControl,
                     });
@@ -1253,6 +1256,9 @@ export async function convertToAnthropicPrompt({
                       content: {
                         type: 'advisor_redacted_result',
                         encrypted_content: advisorOutput.encryptedContent,
+                        ...(advisorOutput.stopReason !== undefined && {
+                          stop_reason: advisorOutput.stopReason,
+                        }),
                       },
                       cache_control: cacheControl,
                     });

package/src/tool/advisor_20260301.ts

@@ -10,6 +10,7 @@ export const advisor_20260301ArgsSchema = lazySchema(() =>
     z.object({
       model: z.string(),
       maxUses: z.number().optional(),
+      maxTokens: z.number().int().min(1024).optional(),
       caching: z
         .object({
           type: z.literal('ephemeral'),
@@ -26,10 +27,12 @@ export const advisor_20260301OutputSchema = lazySchema(() =>
       z.object({
         type: z.literal('advisor_result'),
         text: z.string(),
+        stopReason: z.string().optional(),
       }),
       z.object({
         type: z.literal('advisor_redacted_result'),
         encryptedContent: z.string(),
+        stopReason: z.string().optional(),
       }),
       z.object({
         type: z.literal('advisor_tool_result_error'),
@@ -54,6 +57,12 @@ const factory = createProviderExecutedToolFactory<
        * Plaintext advice from the advisor model.
        */
       text: string;
+
+      /**
+       * The advisor sub-inference stop reason when `maxTokens` is configured.
+       * A value of `"max_tokens"` indicates that the advice was truncated.
+       */
+      stopReason?: string;
     }
   | {
       type: 'advisor_redacted_result';
@@ -64,6 +73,12 @@ const factory = createProviderExecutedToolFactory<
        * advice into the executor's prompt.
        */
       encryptedContent: string;
+
+      /**
+       * The advisor sub-inference stop reason when `maxTokens` is configured.
+       * A value of `"max_tokens"` indicates that the advice was truncated.
+       */
+      stopReason?: string;
     }
   | {
       type: 'advisor_tool_result_error';
@@ -99,6 +114,17 @@ const factory = createProviderExecutedToolFactory<
      */
     maxUses?: number;
 
+    /**
+     * Maximum number of tokens the advisor can generate per call, including
+     * thinking and text. This is independent of the executor's request-level
+     * `maxOutputTokens`.
+     *
+     * The minimum value is 1024. Anthropic recommends starting with 2048.
+     * Values above the selected advisor model's output limit return a
+     * `400 invalid_request_error` from the API.
+     */
+    maxTokens?: number;
+
     /**
      * Enables prompt caching for the advisor's own transcript across calls
      * within a conversation. Unlike `cache_control` on content blocks, this