@ai-sdk/anthropic 3.0.115 → 3.0.116

package/docs/05-anthropic.mdx

@@ -189,9 +189,14 @@ const result = streamText({
 });
 ```
 
+For `claude-fable-5-1`, the default `"auto"` mode uses native structured
+outputs through `output_config.format`. Fable 5.1 rejects forced tool use, so
+do not use `"jsonTool"` or a required or named tool choice to implement
+structured output with this model.
+
 ### Effort
 
-Anthropic introduced an `effort` option with `claude-opus-4-5` that affects thinking, text responses, and function calls. Effort defaults to `high` and you can set it to `medium` or `low` to save tokens and to lower time-to-last-token latency (TTLT). `claude-opus-4-7`, `claude-opus-5`, and `claude-sonnet-5` additionally support `xhigh` for maximum reasoning effort.
+Anthropic introduced an `effort` option with `claude-opus-4-5` that affects thinking, text responses, and function calls. Effort defaults to `high` and you can set it to `medium` or `low` to save tokens and to lower time-to-last-token latency (TTLT). `claude-opus-4-7`, `claude-opus-4-8`, `claude-opus-5`, `claude-fable-5`, `claude-fable-5-1`, and `claude-sonnet-5` additionally support `xhigh` for maximum reasoning effort.
 
 On `claude-opus-5`, thinking can only be disabled at effort levels up to and including `high`. When you combine `thinking: { type: 'disabled' }` with `effort: 'xhigh'` or `effort: 'max'`, the AI SDK lowers the effort to `high` and emits a warning instead of sending a request that the API would reject.
 
@@ -439,6 +444,55 @@ console.log(text);
   progress during thinking.
 </Note>
 
+##### Thinking Updates
+
+Use `display: 'updates'` with `claude-fable-5-1` to stream thinking summaries
+between tool calls:
+
+```ts highlight="12-16"
+import { anthropic, AnthropicLanguageModelOptions } from '@ai-sdk/anthropic';
+import { streamText, tool } from 'ai';
+import { z } from 'zod';
+
+const result = streamText({
+  model: anthropic('claude-fable-5-1'),
+  tools: {
+    weather: tool({
+      inputSchema: z.object({ city: z.string() }),
+    }),
+  },
+  providerOptions: {
+    anthropic: {
+      thinking: { type: 'adaptive', display: 'updates' },
+    } satisfies AnthropicLanguageModelOptions,
+  },
+  prompt: 'Compare the weather in San Francisco and New York.',
+});
+```
+
+##### Thinking Block Binding
+
+Fable 5.1 can recover from a thinking-block prefix mismatch by dropping the
+mismatched block. Set `blockBinding.prefixMismatchBehavior` to `drop_block`.
+You can provide block binding by itself to preserve the model's default
+thinking mode, or combine it with adaptive thinking.
+
+```ts highlight="7-11"
+const { text } = await generateText({
+  model: anthropic('claude-fable-5-1'),
+  prompt: 'Continue from this conversation.',
+  providerOptions: {
+    anthropic: {
+      thinking: {
+        blockBinding: {
+          prefixMismatchBehavior: 'drop_block',
+        },
+      },
+    } satisfies AnthropicLanguageModelOptions,
+  },
+});
+```
+
 #### Budget-Based Thinking
 
 For earlier models (`claude-opus-4-20250514`, `claude-sonnet-4-20250514`, `claude-sonnet-4-5-20250929`),
@@ -1203,6 +1257,59 @@ const result = await generateText({
 
 This sends `tool_reference` blocks to Anthropic, which loads the corresponding deferred tool schemas into Claude's context.
 
+### Mid-Conversation System Controls
+
+With `claude-fable-5-1`, a mid-conversation system message can be cleared
+before the next user message with `clearAt: 'next_user_message'`, or set the
+effort for the next turn. The provider adds the required
+`mid-conversation-system-clear-at-2026-08-21` and
+`mid-conversation-effort-2026-08-01` beta headers automatically.
+
+```ts highlight="17-25"
+import { anthropic } from '@ai-sdk/anthropic';
+import { generateText } from 'ai';
+
+const result = await generateText({
+  model: anthropic('claude-fable-5-1'),
+  allowSystemInMessages: true,
+  messages: [
+    {
+      role: 'user',
+      content: 'Draft a migration plan.',
+    },
+    {
+      role: 'assistant',
+      content: 'First, inventory the public API.',
+    },
+    {
+      role: 'system',
+      content: 'For the next turn, verify every compatibility claim.',
+      providerOptions: {
+        anthropic: {
+          clearAt: 'next_user_message',
+          effort: 'high',
+        },
+      },
+    },
+    {
+      role: 'user',
+      content: 'Complete the plan.',
+    },
+  ],
+});
+```
+
+An effort-only system message can use an empty content array at the API level;
+in an AI SDK prompt, set `content: ''`. The provider serializes it as
+`content: []`.
+
+<Note>
+  `clearAt` and per-message `effort` apply only to mid-conversation system
+  messages. When used on the initial system message, the provider ignores them
+  and emits a warning. Use the top-level `effort` provider option to configure
+  effort for the full request.
+</Note>
+
 ### Mid-Conversation Tool Changes
 
 With `claude-opus-4-8`, you can add or remove tools between turns of a conversation without invalidating the prompt cache. Attach `toolChanges` to a system message that appears mid-conversation (right before an assistant message or at the end of the messages). The required `mid-conversation-tool-changes-2026-07-01` beta header is added automatically.
@@ -1640,6 +1747,7 @@ and the `mediaType` should be set to `'application/pdf'`.
 
 | Model               | Image Input         | Object Generation   | Tool Usage          | Computer Use        | Web Search          | Tool Search         | Compaction          |
 | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- |
+| `claude-fable-5-1`  | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> |
 | `claude-opus-5`     | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> |
 | `claude-sonnet-5`   | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> |
 | `claude-fable-5`    | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/anthropic",
-  "version": "3.0.115",
+  "version": "3.0.116",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",

package/src/anthropic-messages-api.ts

@@ -24,6 +24,10 @@ export type AnthropicCacheControl = {
 export interface AnthropicSystemMessage {
   role: 'system';
   content: Array<AnthropicTextContent | AnthropicToolChangeContent>;
+  clear_at?: 'next_user_message';
+  output_config?: {
+    effort: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+  };
 }
 
 /**

package/src/anthropic-messages-language-model.ts

@@ -418,13 +418,17 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
         toolNameMapping,
       });
 
+    const thinking = anthropicOptions?.thinking;
+    const thinkingType =
+      thinking != null && 'type' in thinking ? thinking.type : undefined;
+
     // Newer models only allow disabling thinking at effort levels up to and
     // including `high`; at `xhigh` and `max` the API returns a 400. Lower
     // the effort to `high` to preserve the explicit request to run without
     // thinking.
     if (
       rejectsThinkingDisabledAboveHighEffort &&
-      anthropicOptions?.thinking?.type === 'disabled' &&
+      thinkingType === 'disabled' &&
       (anthropicOptions.effort === 'xhigh' || anthropicOptions.effort === 'max')
     ) {
       warnings.push({
@@ -437,7 +441,6 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
       anthropicOptions.effort = 'high';
     }
 
-    const thinkingType = anthropicOptions?.thinking?.type;
     const isThinking =
       thinkingType === 'enabled' || thinkingType === 'adaptive';
     // `disabled` must still be forwarded to the API: some models (e.g. Sonnet 5)
@@ -445,13 +448,20 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
     // consume the max_tokens budget.
     const sendThinking = isThinking || thinkingType === 'disabled';
     let thinkingBudget =
-      thinkingType === 'enabled'
-        ? anthropicOptions?.thinking?.budgetTokens
+      thinkingType === 'enabled' &&
+      thinking != null &&
+      'budgetTokens' in thinking
+        ? thinking.budgetTokens
         : undefined;
     const thinkingDisplay =
-      thinkingType === 'adaptive'
-        ? anthropicOptions?.thinking?.display
+      thinkingType === 'adaptive' && thinking != null && 'display' in thinking
+        ? thinking.display
+        : undefined;
+    const thinkingBlockBinding =
+      thinking != null && 'blockBinding' in thinking
+        ? thinking.blockBinding
         : undefined;
+    const sendThinkingConfig = sendThinking || thinkingBlockBinding != null;
 
     const maxTokens = maxOutputTokens ?? maxOutputTokensForModel;
 
@@ -467,11 +477,17 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
       stop_sequences: stopSequences,
 
       // provider specific settings:
-      ...(sendThinking && {
+      ...(sendThinkingConfig && {
         thinking: {
-          type: thinkingType,
+          ...(thinkingType != null && { type: thinkingType }),
           ...(thinkingBudget != null && { budget_tokens: thinkingBudget }),
           ...(thinkingDisplay != null && { display: thinkingDisplay }),
+          ...(thinkingBlockBinding != null && {
+            block_binding: {
+              prefix_mismatch_behavior:
+                thinkingBlockBinding.prefixMismatchBehavior,
+            },
+          }),
         },
       }),
       ...((anthropicOptions?.effort ||
@@ -735,6 +751,14 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
       betas.add('task-budgets-2026-03-13');
     }
 
+    if (thinkingDisplay === 'updates') {
+      betas.add('thinking-display-updates-2026-08-18');
+    }
+
+    if (thinkingBlockBinding != null) {
+      betas.add('thinking-binding-controls-2026-08-01');
+    }
+
     if (anthropicOptions?.speed === 'fast') {
       betas.add('fast-mode-2026-02-01');
     }

package/src/anthropic-messages-options.ts

@@ -21,6 +21,7 @@ export type AnthropicMessagesModelId =
   | 'claude-opus-4-8'
   | 'claude-opus-5'
   | 'claude-fable-5'
+  | 'claude-fable-5-1'
   | 'claude-sonnet-5'
   | (string & {});
 
@@ -64,6 +65,23 @@ export type AnthropicFilePartProviderOptions = z.infer<
  * Anthropic provider options for system messages.
  */
 export const anthropicSystemMessageProviderOptions = z.object({
+  /**
+   * Clears this mid-conversation system message after the current turn.
+   *
+   * Requires the `mid-conversation-system-clear-at-2026-08-21` beta,
+   * which is added automatically.
+   */
+  clearAt: z.literal('next_user_message').optional(),
+
+  /**
+   * Overrides the effort level for the turn following this
+   * mid-conversation system message.
+   *
+   * Requires the `mid-conversation-effort-2026-08-01` beta,
+   * which is added automatically.
+   */
+  effort: z.enum(['low', 'medium', 'high', 'xhigh', 'max']).optional(),
+
   /**
    * Mid-conversation tool changes. Adds or removes tools from the
    * conversation's tool set between turns without invalidating the prompt
@@ -98,6 +116,10 @@ export type AnthropicSystemMessageProviderOptions = z.infer<
   typeof anthropicSystemMessageProviderOptions
 >;
 
+const anthropicThinkingBlockBinding = z.object({
+  prefixMismatchBehavior: z.literal('drop_block'),
+});
+
 export const anthropicLanguageModelOptions = z.object({
   /**
    * Whether to send reasoning to the model.
@@ -122,24 +144,41 @@ export const anthropicLanguageModelOptions = z.object({
    * Requires a minimum budget of 1,024 tokens and counts towards the `max_tokens` limit.
    */
   thinking: z
-    .discriminatedUnion('type', [
-      z.object({
-        /** for Sonnet 4.6, Opus 4.6, and newer models */
-        type: z.literal('adaptive'),
-        /**
-         * Controls whether thinking content is included in the response.
-         * - `"omitted"`: Thinking blocks are present but text is empty (default for Opus 4.7+).
-         * - `"summarized"`: Thinking content is returned. Required to see reasoning output.
-         */
-        display: z.enum(['omitted', 'summarized']).optional(),
-      }),
-      z.object({
-        /** for models before Opus 4.6, except Sonnet 4.6 still supports it */
-        type: z.literal('enabled'),
-        budgetTokens: z.number().optional(),
-      }),
+    .union([
+      z.discriminatedUnion('type', [
+        z.object({
+          /** for Sonnet 4.6, Opus 4.6, and newer models */
+          type: z.literal('adaptive'),
+          /**
+           * Controls whether thinking content is included in the response.
+           * - `"omitted"`: Thinking blocks are present but text is empty (default for Opus 4.7+).
+           * - `"summarized"`: Thinking content is returned. Required to see reasoning output.
+           * - `"updates"`: Thinking updates are returned between tool calls.
+           */
+          display: z.enum(['omitted', 'summarized', 'updates']).optional(),
+          /**
+           * Controls how thinking blocks are bound to an assistant prefix.
+           *
+           * Requires the `thinking-binding-controls-2026-08-01` beta,
+           * which is added automatically.
+           */
+          blockBinding: anthropicThinkingBlockBinding.optional(),
+        }),
+        z.object({
+          /** for models before Opus 4.6, except Sonnet 4.6 still supports it */
+          type: z.literal('enabled'),
+          budgetTokens: z.number().optional(),
+        }),
+        z.object({
+          type: z.literal('disabled'),
+        }),
+      ]),
+      /**
+       * Configures prefix mismatch recovery without changing the model's
+       * default thinking mode.
+       */
       z.object({
-        type: z.literal('disabled'),
+        blockBinding: anthropicThinkingBlockBinding,
       }),
     ])
     .optional(),

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

@@ -166,8 +166,9 @@ export async function convertToAnthropicMessagesPrompt({
 
     switch (type) {
       case 'system': {
-        const content: AnthropicSystemMessage['content'] = [];
+        const systemMessages: AnthropicSystemMessage[] = [];
         let toolChangeCount = 0;
+        let hasMidConversationOptions = false;
 
         for (const { content: text, providerOptions } of block.messages) {
           const systemMessageOptions = await parseProviderOptions({
@@ -176,10 +177,16 @@ export async function convertToAnthropicMessagesPrompt({
             schema: anthropicSystemMessageProviderOptions,
           });
           const toolChanges = systemMessageOptions?.toolChanges ?? [];
-
-          // A system message that only carries tool changes may have empty
-          // text; do not emit an empty text block for it.
-          if (text !== '' || toolChanges.length === 0) {
+          const clearAt = systemMessageOptions?.clearAt;
+          const effort = systemMessageOptions?.effort;
+          const content: AnthropicSystemMessage['content'] = [];
+
+          // A system message that only carries message-level options or tool
+          // changes may have empty text; do not emit an empty text block for it.
+          if (
+            text !== '' ||
+            (toolChanges.length === 0 && clearAt == null && effort == null)
+          ) {
             content.push({
               type: 'text' as const,
               text,
@@ -200,14 +207,29 @@ export async function convertToAnthropicMessagesPrompt({
               },
             } satisfies AnthropicToolChangeContent);
           }
+
+          hasMidConversationOptions ||= clearAt != null || effort != null;
+
+          systemMessages.push({
+            role: 'system',
+            content,
+            ...(clearAt != null && { clear_at: clearAt }),
+            ...(effort != null && { output_config: { effort } }),
+          });
         }
 
         // The first block becomes the top-level system prompt. Later system
         // blocks are sent as inline system messages — always when they carry
-        // tool changes (which are only valid mid-conversation), and otherwise
-        // only when a top-level system prompt already exists (preserving the
-        // existing hoisting behavior for plain text).
-        if (i === 0 || (system == null && toolChangeCount === 0)) {
+        // tool changes or per-turn options (which are only valid
+        // mid-conversation), and otherwise only when a top-level system prompt
+        // already exists (preserving the existing hoisting behavior for plain
+        // text).
+        if (
+          i === 0 ||
+          (system == null &&
+            toolChangeCount === 0 &&
+            !hasMidConversationOptions)
+        ) {
           if (toolChangeCount > 0) {
             warnings.push({
               type: 'other',
@@ -217,15 +239,32 @@ export async function convertToAnthropicMessagesPrompt({
                 'The tool changes have been ignored.',
             });
           }
-          system = content.filter(
-            (part): part is AnthropicTextContent => part.type === 'text',
+          if (hasMidConversationOptions) {
+            warnings.push({
+              type: 'other',
+              message:
+                'clearAt and effort on the initial system message are not supported by Anthropic. ' +
+                'Configure these options on a mid-conversation system message instead. ' +
+                'The options have been ignored.',
+            });
+          }
+          system = systemMessages.flatMap(message =>
+            message.content.filter(
+              (part): part is AnthropicTextContent => part.type === 'text',
+            ),
           );
         } else {
-          messages.push({ role: 'system', content });
+          messages.push(...systemMessages);
           betas.add('mid-conversation-system-2026-04-07');
           if (toolChangeCount > 0) {
             betas.add('mid-conversation-tool-changes-2026-07-01');
           }
+          if (systemMessages.some(message => message.clear_at != null)) {
+            betas.add('mid-conversation-system-clear-at-2026-08-21');
+          }
+          if (systemMessages.some(message => message.output_config != null)) {
+            betas.add('mid-conversation-effort-2026-08-01');
+          }
         }
 
         break;