@ai-sdk/anthropic 4.0.58 → 4.0.60

package/docs/05-anthropic.mdx

@@ -197,17 +197,27 @@ 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.
+For `claude-opus-5-5` and `claude-fable-5-1`, the default `"auto"` mode uses
+native structured outputs through `output_config.format`. These models reject
+forced tool use, so the `"jsonTool"` mode cannot be used with them. If you
+request `"jsonTool"` anyway, the provider falls back to `"outputFormat"` and
+emits a warning. Likewise, a `required` or named `toolChoice` is downgraded to
+`auto` with a warning; instruct the model to use the tool in your prompt and
+verify that a tool call was made.
 
 ### 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.
+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-opus-5-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.
 
+On `claude-opus-5-5`, thinking is always adaptive and cannot be disabled, so
+`effort` is the main control for latency and cost. The API default effort for
+`claude-opus-5-5` is `medium`. Start there and test other levels rather than
+carrying over the setting you used on `claude-opus-5`. Set `maxOutputTokens`
+with room for thinking as well as the reply; thinking counts toward the limit
+even when its content is not returned.
+
 ```ts highlight="8-10"
 import { anthropic, AnthropicLanguageModelOptions } from '@ai-sdk/anthropic';
 import { generateText } from 'ai';
@@ -385,6 +395,57 @@ const servedByFallback = iterations?.some(
 console.log('Served by fallback:', servedByFallback);
 ```
 
+### Dangerous Tool Use Safeguard
+
+The `safeguards` option asks the API to run additional server-side checks as part of the request. The `dangerous_tool_use` safeguard classifies every `tool_use` block in the response for dangerous actions, such as destructive shell commands or data exfiltration, and returns a verdict per tool call. This is the check that Claude Code's auto mode relies on. The `dangerous-tool-use-2026-09-03` beta header is added for you.
+
+```ts highlight="9-16"
+import { anthropic, AnthropicLanguageModelOptions } from '@ai-sdk/anthropic';
+import { generateText, tool } from 'ai';
+import { z } from 'zod';
+
+const result = await generateText({
+  model: anthropic('claude-sonnet-4-5'),
+  prompt: 'Use the bash tool to run: echo hello',
+  tools: { bash: tool({ inputSchema: z.object({ command: z.string() }) }) },
+  providerOptions: {
+    anthropic: {
+      safeguards: [
+        {
+          type: 'dangerous_tool_use',
+          classifierContext: { v: 1, permission_mode: 'auto' },
+        },
+      ],
+    } satisfies AnthropicLanguageModelOptions,
+  },
+});
+
+console.log(result.providerMetadata?.anthropic?.safeguardResults);
+```
+
+The verdicts are available on `providerMetadata.anthropic.safeguardResults`, one entry per requested safeguard, in the API's wire shape:
+
+```json
+[
+  {
+    "type": "dangerous_tool_use",
+    "status": {
+      "type": "available",
+      "tool_uses": {
+        "toolu_01Ti4QpUfhLV6QqCTFVY8C7w": {
+          "type": "evaluated",
+          "outcome": "not_flagged"
+        }
+      }
+    }
+  }
+]
+```
+
+`status.type` is `available` when the classifier ran; `unsupported` means the API key is not enabled for the beta. Inside `status.tool_uses`, each tool call id maps to `evaluated` (with an `outcome` of `not_flagged` or `flagged`, the latter with an `explanation` such as `[Data Exfiltration]`), `skipped`, or `unavailable` (a transient classifier failure). When streaming, the verdicts arrive on the final `message_delta` event and are exposed on the `finish` part's provider metadata.
+
+Anthropic's platform reference does not document the beta yet; the feature is described from the client side in the Claude Code [auto mode classifier](https://code.claude.com/docs/en/auto-mode-classifier-billing) and [gateway compatibility](https://code.claude.com/docs/en/llm-gateway-protocol#feature-pass-through) guides.
+
 ### Reasoning
 
 Anthropic models support extended thinking, where Claude shows its reasoning process before providing a final answer.
@@ -428,6 +489,41 @@ const { text } = await generateText({
 });
 ```
 
+##### Adaptive-Only Models
+
+`claude-opus-5-5`, `claude-fable-5`, and `claude-fable-5-1` always run adaptive
+thinking. The API rejects `thinking: { type: 'disabled' }` and budget-based
+`thinking: { type: 'enabled' }` for these models. To keep existing code working,
+the provider:
+
+- removes `thinking: { type: 'disabled' }` and emits a warning,
+- converts `thinking: { type: 'enabled', budgetTokens }` to `{ type: 'adaptive' }` and emits a warning,
+- maps the top-level `reasoning: 'none'` option to `effort: 'low'` and emits a warning.
+
+Use `effort` to control how much these models think. On `claude-opus-5-5`, set
+`effort: 'low'` when time to first token matters, and move to `medium` if
+quality drops:
+
+```ts highlight="6-9"
+const { text } = await generateText({
+  model: anthropic('claude-opus-5-5'),
+  prompt: 'Summarize this ticket in one sentence.',
+  providerOptions: {
+    anthropic: {
+      // thinking stays adaptive; effort controls how much the model thinks
+      effort: 'low',
+    } satisfies AnthropicLanguageModelOptions,
+  },
+});
+```
+
+<Note>
+  Responses from adaptive-only models can begin with a thinking block. Read the
+  response by content type (`text`, `reasoning`, `tool-call`) rather than
+  assuming the first part is text. Under the default `display: 'omitted'`
+  setting, thinking blocks are returned with empty text.
+</Note>
+
 ##### Thinking Display (Opus 4.7+)
 
 Starting with `claude-opus-4-7`, thinking content is omitted from the response by default — thinking blocks are present in the stream but their text is empty. To receive reasoning output, set `display: 'summarized'`:
@@ -455,8 +551,10 @@ console.log(text);
 
 ##### Thinking Updates
 
-Use `display: 'updates'` with `claude-fable-5-1` to stream thinking summaries
-between tool calls. The provider adds the required
+Use `display: 'updates'` with `claude-opus-5-5` or `claude-fable-5-1` to stream
+thinking summaries between tool calls. These models return progress notes
+between tool calls as thinking blocks rather than text, so without this setting
+a long tool-calling turn can look silent. The provider adds the required
 `thinking-display-updates-2026-08-18` beta header automatically:
 
 ```ts highlight="12-16"
@@ -1026,11 +1124,74 @@ const computerTool = anthropic.tools.computer_20251124({
 ```
 
 <Note>
-  Use `computer_20251124` for Claude Opus 4.5 which supports the zoom action.
-  Use `computer_20250124` for Claude Sonnet 4.5, Haiku 4.5, Opus 4.1, Sonnet 4,
-  Opus 4, and Sonnet 3.7.
+  Use `computerToolset_20260801` for Claude Opus 5.5 (required), Opus 5, Sonnet
+  5, Fable 5, Fable 5.1, and Opus 4.8. Use `computer_20251124` for Claude Opus
+  4.5 through Opus 4.7, which support the zoom action. Use `computer_20250124`
+  for Claude Sonnet 4.5, Haiku 4.5, Opus 4.1, Sonnet 4, Opus 4, and Sonnet 3.7.
 </Note>
 
+#### Computer Toolset
+
+Newer models use the computer toolset instead of a versioned computer tool.
+`claude-opus-5-5` accepts computer use only through the toolset and rejects the
+older `computer_*` tool types with a 400. The toolset does not require a beta
+header and has no display size parameters: coordinates are always in the pixel
+space of the screenshots you return. Zoom is enabled by default, and Claude can
+return several actions in one turn, each as its own tool call.
+
+The API returns each action as a separate `tool_use` block with
+`toolset_name: 'computer'`. The AI SDK maps every action to the toolset tool and
+passes the action name as `action`, so `execute` receives the same input shape
+as the older computer tools:
+
+```ts
+const computerTool = anthropic.tools.computerToolset_20260801({
+  // optional: turn individual actions on or off
+  configs: {
+    zoom: { enabled: false },
+  },
+
+  execute: async ({ action, coordinate, text, region }) => {
+    switch (action) {
+      case 'screenshot': {
+        return {
+          type: 'image',
+          data: fs.readFileSync('./data/screenshot.png').toString('base64'),
+        };
+      }
+      default: {
+        console.log('Action:', action, coordinate, text, region);
+        return `executed ${action}`;
+      }
+    }
+  },
+
+  toModelOutput({ output }) {
+    return typeof output === 'string'
+      ? [{ type: 'text', text: output }]
+      : [{ type: 'file-data', data: output.data, mediaType: 'image/png' }];
+  },
+});
+```
+
+Parameters:
+
+- `action` ('screenshot' | 'zoom' | 'left_click' | 'right_click' | 'middle_click' | 'double_click' | 'triple_click' | 'left_click_drag' | 'mouse_move' | 'left_mouse_down' | 'left_mouse_up' | 'cursor_position' | 'scroll' | 'type' | 'key' | 'hold_key' | 'wait'): The member tool that Claude invoked.
+- `coordinate` (number[], optional): The (x, y) pixel coordinates for click, move, and scroll actions.
+- `start_coordinate` (number[], optional): Where a `left_click_drag` starts.
+- `region` (number[], optional): `[x1, y1, x2, y2]` for the `zoom` action.
+- `text` (string, optional): Text to type, the key combination for `key` and `hold_key`, or modifier keys to hold during click and scroll actions.
+- `repeat` (number, optional): How many times to press the key for `key`.
+- `duration` (number, optional): Seconds for `hold_key` and `wait`.
+- `scroll_direction` ('up' | 'down' | 'left' | 'right', optional) and `scroll_amount` (number, optional): For the `scroll` action.
+- `configs` (object, optional): Per-action settings keyed by action name. Each entry accepts `enabled` (default `true`) and `deferLoading` (default `false`, for tool search).
+
+Tool calls and results of the toolset are serialized with `toolset_name` when
+you pass the message history back. Keep the toolset tool in `tools` on
+follow-up requests, or the provider falls back to the `toolsetName` provider
+metadata on the tool calls of previous responses. Do not declare the toolset
+together with an older `computer_*` tool.
+
 Parameters:
 
 - `action` ('key' | 'type' | 'mouse_move' | 'left_click' | 'left_click_drag' | 'right_click' | 'middle_click' | 'double_click' | 'screenshot' | 'cursor_position' | 'zoom'): The action to perform. The `zoom` action is only available with `computer_20251124`.
@@ -1329,11 +1490,11 @@ This sends `tool_reference` blocks to Anthropic, which loads the corresponding d
 
 ### 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
+With `claude-opus-5-5` and `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 without invalidating the prompt cache. The provider adds the required
 `mid-conversation-system-clear-at-2026-08-21` and
-`mid-conversation-effort-2026-08-01` beta headers automatically.
+`mid-conversation-output-config-2026-07-01` beta headers automatically.
 
 ```ts highlight="17-25"
 import { anthropic } from '@ai-sdk/anthropic';
@@ -1872,6 +2033,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-opus-5-5`   | <Check />   | <Check />         | <Check />  | <Check />    | <Check />  | <Check />   | <Check />  |
 | `claude-opus-5`     | <Check />   | <Check />         | <Check />  | <Check />    | <Check />  | <Check />   | <Check />  |
 | `claude-sonnet-5`   | <Check />   | <Check />         | <Check />  | <Check />    | <Check />  | <Check />   | <Check />  |
 | `claude-fable-5-1`  | <Check />   | <Check />         | <Check />  | <Check />    | <Check />  | <Check />   | <Check />  |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/anthropic",
-  "version": "4.0.58",
+  "version": "4.0.60",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,

package/src/anthropic-api.ts

@@ -173,6 +173,11 @@ export interface AnthropicToolCallContent {
    * (e.g., code execution calling a user-defined tool programmatically).
    */
   caller?: AnthropicToolCallCaller;
+  /**
+   * Present when this tool call is a member call of a toolset
+   * (e.g. `computer` for the computer toolset). `name` is then the member name.
+   */
+  toolset_name?: string;
   cache_control: AnthropicCacheControl | undefined;
 }
 
@@ -228,6 +233,10 @@ export interface AnthropicToolReferenceContent {
 export interface AnthropicToolResultContent {
   type: 'tool_result';
   tool_use_id: string;
+  /**
+   * Required for results of toolset member calls (e.g. `computer`).
+   */
+  toolset_name?: string;
   content:
     | string
     | Array<
@@ -484,6 +493,15 @@ export type AnthropicTool =
       enable_zoom?: boolean;
       cache_control: AnthropicCacheControl | undefined;
     }
+  | {
+      /**
+       * Computer toolset. Declared without a `name`; the API returns member
+       * tool calls (e.g. `left_click`) with `toolset_name: 'computer'`.
+       */
+      type: 'computer_toolset_20260801';
+      configs?: Record<string, { enabled?: boolean; defer_loading?: boolean }>;
+      cache_control: AnthropicCacheControl | undefined;
+    }
   | {
       name: string;
       type:
@@ -657,6 +675,27 @@ const anthropicStopDetailsSchema = z.object({
 
 export type AnthropicStopDetails = z.infer<typeof anthropicStopDetailsSchema>;
 
+const anthropicSafeguardResultSchema = z.object({
+  type: z.string(),
+  status: z.object({
+    type: z.string(),
+    tool_uses: z
+      .record(
+        z.string(),
+        z.object({
+          type: z.string(),
+          outcome: z.string().nullish(),
+          explanation: z.string().nullish(),
+        }),
+      )
+      .nullish(),
+  }),
+});
+
+export type AnthropicSafeguardResult = z.infer<
+  typeof anthropicSafeguardResultSchema
+>;
+
 const anthropicToolCallCallerSchema = z.union([
   z.object({
     type: z.literal('code_execution_20250825'),
@@ -774,6 +813,8 @@ export const anthropicResponseSchema = lazySchema(() =>
             input: z.unknown(),
             // Programmatic tool calling: caller info when triggered from code execution
             caller: anthropicToolCallCallerSchema.optional(),
+            // Toolsets (e.g. computer toolset): name of the toolset this member call belongs to
+            toolset_name: z.string().nullish(),
           }),
           z.object({
             type: z.literal('server_tool_use'),
@@ -1004,6 +1045,7 @@ export const anthropicResponseSchema = lazySchema(() =>
       input_transformations: z
         .array(anthropicInputTransformationSchema)
         .nullish(),
+      safeguard_results: z.array(anthropicSafeguardResultSchema).nullish(),
       usage: z.looseObject({
         input_tokens: z.number(),
         output_tokens: z.number(),
@@ -1098,6 +1140,7 @@ export const anthropicChunkSchema = lazySchema(() =>
                   name: z.string(),
                   input: z.unknown(),
                   caller: anthropicToolCallCallerSchema.optional(),
+                  toolset_name: z.string().nullish(),
                 }),
               ]),
             )
@@ -1134,6 +1177,8 @@ export const anthropicChunkSchema = lazySchema(() =>
             input: z.record(z.string(), z.unknown()).optional(),
             // Programmatic tool calling: caller info when triggered from code execution
             caller: anthropicToolCallCallerSchema.optional(),
+            // Toolsets (e.g. computer toolset): name of the toolset this member call belongs to
+            toolset_name: z.string().nullish(),
           }),
           z.object({
             type: z.literal('redacted_thinking'),
@@ -1412,6 +1457,7 @@ export const anthropicChunkSchema = lazySchema(() =>
           stop_reason: z.string().nullish(),
           stop_sequence: z.string().nullish(),
           stop_details: anthropicStopDetailsSchema.nullish(),
+          safeguard_results: z.array(anthropicSafeguardResultSchema).nullish(),
           container: z
             .object({
               expires_at: z.string(),

package/src/anthropic-batch.ts

@@ -1098,6 +1098,9 @@ function convertAnthropicMessageMetadata(response: AnthropicResponse) {
     ...(response.input_transformations != null
       ? { inputTransformations: response.input_transformations }
       : {}),
+    ...(response.safeguard_results != null
+      ? { safeguardResults: response.safeguard_results }
+      : {}),
     iterations: response.usage.iterations
       ? response.usage.iterations.map(
           iteration =>

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

@@ -20,6 +20,7 @@ export type AnthropicModelId =
   | 'claude-opus-4-7'
   | 'claude-opus-4-8'
   | 'claude-opus-5'
+  | 'claude-opus-5-5'
   | 'claude-fable-5'
   | 'claude-fable-5-1'
   | 'claude-sonnet-5'
@@ -82,8 +83,8 @@ export const anthropicSystemMessageProviderOptions = z.object({
 
   /**
    * Sets the model effort for the turn that follows this mid-conversation
-   * system message. The required `mid-conversation-effort-2026-08-01` beta
-   * is added automatically.
+   * system message. The required `mid-conversation-output-config-2026-07-01`
+   * beta is added automatically.
    */
   effort: z.enum(['low', 'medium', 'high', 'xhigh', 'max']).optional(),
 
@@ -143,6 +144,11 @@ export const anthropicLanguageModelOptions = z.object({
    *
    * When enabled, responses include thinking content blocks showing Claude's thinking process before the final answer.
    * Requires a minimum budget of 1,024 tokens and counts towards the `max_tokens` limit.
+   *
+   * Models that always use adaptive thinking (e.g. `claude-opus-5-5`,
+   * `claude-fable-5-1`) reject `enabled` and `disabled`. For those models the
+   * provider drops the unsupported setting, emits a warning, and sends an
+   * adaptive thinking request. Use `effort` to control how much they think.
    */
   thinking: z
     .union([
@@ -278,7 +284,11 @@ export const anthropicLanguageModelOptions = z.object({
   toolStreaming: z.boolean().optional(),
 
   /**
-   * @default 'high'
+   * Controls how much effort the model spends on thinking, text responses,
+   * and tool calls. On models that always use adaptive thinking
+   * (e.g. `claude-opus-5-5`), effort is the main lever for latency and cost.
+   *
+   * The API default is `high` for most models and `medium` for `claude-opus-5-5`.
    */
   effort: z.enum(['low', 'medium', 'high', 'xhigh', 'max']).optional(),
 
@@ -355,6 +365,25 @@ export const anthropicLanguageModelOptions = z.object({
    */
   anthropicBeta: z.array(z.string()).optional(),
 
+  /**
+   * Server-side safeguards to run as part of the request.
+   *
+   * `dangerous_tool_use` asks the API to classify every `tool_use` block in
+   * the response for dangerous actions (the check Claude Code's auto mode
+   * relies on). The per-call verdicts are returned in
+   * `providerMetadata.anthropic.safeguardResults`, keyed by tool call id.
+   * `classifierContext` is passed through to the API as `classifier_context`.
+   * The `dangerous-tool-use-2026-09-03` beta is added automatically.
+   */
+  safeguards: z
+    .array(
+      z.object({
+        type: z.literal('dangerous_tool_use'),
+        classifierContext: z.record(z.string(), z.unknown()).optional(),
+      }),
+    )
+    .optional(),
+
   contextManagement: z
     .object({
       edits: z.array(