@ai-sdk/anthropic 3.0.126 → 3.0.128

package/docs/05-anthropic.mdx

@@ -200,9 +200,18 @@ 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-opus-5-5`, `claude-fable-5`, `claude-fable-5-1`, `claude-sonnet-5`, and `claude-sonnet-5-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`, `claude-sonnet-5`, `claude-sonnet-5-5`, and `claude-haiku-5-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` and `claude-haiku-5-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.
+
+`claude-haiku-5-5` is the first Haiku model with effort levels and supports all
+five of them. It uses adaptive thinking and does not support thinking token
+budgets: the AI SDK converts `thinking: { type: 'enabled', budgetTokens }` to
+`{ type: 'adaptive' }` and emits a warning. Use `effort` to control how much it
+thinks. Unlike `claude-sonnet-5-5`, thinking can still be turned off with
+`thinking: { type: 'disabled' }`, but only at `low`, `medium`, and `high` effort.
+Start at `medium` effort and test other levels rather than carrying over the
+settings you used on `claude-haiku-4-5`.
 
 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
@@ -325,6 +334,8 @@ The `inferenceGeo` option accepts `'us'` (US-only infrastructure) or `'global'`
 
 Claude Fable 5 has safeguards that limit its performance in certain areas like cybersecurity, biology, and chemistry, and automated safety checks are run on every request.
 
+Claude Haiku 5.5 has the same biology safeguards as Claude Sonnet 5 and 5.5, plus safeguards that prevent cyber misuse.
+
 Claude Sonnet 5.5 also has safety classifiers enabled, including for cybersecurity, biology, and reasoning extraction. Requests that ask the model to reproduce its internal reasoning in the response text can be declined with the `reasoning_extraction` category; use `thinking: { type: 'adaptive', display: 'summarized' }` and read the reasoning parts instead.
 
 When one of these checks blocks a request, the API does not answer it. Instead it returns a classifier block: a `200` response with a `refusal` stop reason and an optional `stop_details` object describing the category that triggered the block. The AI SDK surfaces this as a `content-filter` finish reason, with the details available on `providerMetadata.anthropic.stopDetails`.
@@ -399,6 +410,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.
@@ -1961,6 +2023,7 @@ and the `mediaType` should be set to `'application/pdf'`.
 | `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-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-haiku-5-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} /> |
 | `claude-opus-4-8`   | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> |
 | `claude-opus-4-7`   | <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.126",
+  "version": "3.0.128",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",

package/src/anthropic-message-metadata.ts

@@ -1,4 +1,5 @@
 import type { JSONObject } from '@ai-sdk/provider';
+import type { AnthropicSafeguardResult } from './anthropic-messages-api';
 
 /**
  * Represents a single iteration in the usage breakdown.
@@ -65,6 +66,19 @@ export interface AnthropicMessageMetadata {
     reason: string;
   }>;
 
+  /**
+   * Verdicts of the server-side safeguards requested with
+   * `providerOptions.anthropic.safeguards`, one entry per requested safeguard.
+   * For `dangerous_tool_use`, `status.type` is `'available'` when the
+   * classifier ran and `status.tool_uses` maps each tool call id to its
+   * verdict (`type: 'evaluated'` with an `outcome` of `'not_flagged'` or
+   * `'flagged'` plus an `explanation`, `'skipped'`, or `'unavailable'`).
+   *
+   * Kept in the API's wire shape (snake_case), since consumers such as Claude
+   * Code read the verdicts verbatim.
+   */
+  safeguardResults?: AnthropicSafeguardResult[];
+
   /**
    * Details about why the request stopped. Present only when the API returns
    * a `refusal` stop reason together with a `stop_details` object (a

package/src/anthropic-messages-api.ts

@@ -649,6 +649,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'),
@@ -963,6 +984,7 @@ export const anthropicMessagesResponseSchema = lazySchema(() =>
       input_transformations: z
         .array(anthropicInputTransformationSchema)
         .nullish(),
+      safeguard_results: z.array(anthropicSafeguardResultSchema).nullish(),
       usage: z.looseObject({
         input_tokens: z.number(),
         output_tokens: z.number(),
@@ -1397,6 +1419,7 @@ export const anthropicMessagesChunkSchema = 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-messages-language-model.ts

@@ -340,6 +340,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
       rejectsSamplingParameters,
       rejectsThinkingDisabledAboveHighEffort,
       rejectsThinkingDisabled,
+      rejectsBudgetThinking,
       rejectsForcedToolUse,
       supportsBetweenToolsThinking,
       isKnownModel,
@@ -488,9 +489,9 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
         toolsetNames,
       });
 
-    // Some models always run adaptive thinking and reject `disabled` and
-    // budget-based `enabled` thinking with a 400. Drop the unsupported
-    // setting and keep the request adaptive so it still succeeds.
+    // Some models always run adaptive thinking and reject `disabled` thinking
+    // with a 400. Drop the unsupported setting and keep the request adaptive
+    // so it still succeeds.
     if (rejectsThinkingDisabled && anthropicOptions?.thinking != null) {
       const requestedThinking = anthropicOptions.thinking;
       const requestedType =
@@ -514,18 +515,30 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
             `The thinking setting has been removed. Lower 'effort' to reduce thinking.`,
         });
         anthropicOptions.thinking = undefined;
-      } else if (requestedType === 'enabled') {
-        warnings.push({
-          type: 'unsupported',
-          feature: 'providerOptions.anthropic.thinking',
-          details:
-            `budget-based thinking is not supported by ${this.modelId}; it always uses adaptive thinking. ` +
-            `Using adaptive thinking instead. Use 'effort' to control how much the model thinks.`,
-        });
-        anthropicOptions.thinking = { type: 'adaptive' };
       }
     }
 
+    // Models that only support adaptive thinking reject budget-based thinking
+    // with a 400. Use adaptive thinking instead and let `effort` control how
+    // much the model thinks.
+    if (
+      rejectsBudgetThinking &&
+      anthropicOptions?.thinking != null &&
+      'type' in anthropicOptions.thinking &&
+      anthropicOptions.thinking.type === 'enabled'
+    ) {
+      warnings.push({
+        type: 'unsupported',
+        feature: 'providerOptions.anthropic.thinking',
+        details: rejectsThinkingDisabled
+          ? `budget-based thinking is not supported by ${this.modelId}; it always uses adaptive thinking. ` +
+            `Using adaptive thinking instead. Use 'effort' to control how much the model thinks.`
+          : `budget-based thinking is not supported by ${this.modelId}. ` +
+            `Using adaptive thinking instead. Use 'effort' to control how much the model thinks.`,
+      });
+      anthropicOptions.thinking = { type: 'adaptive' };
+    }
+
     const thinking = anthropicOptions?.thinking;
     const thinkingType =
       thinking != null && 'type' in thinking ? thinking.type : undefined;
@@ -702,6 +715,16 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
       system: messagesPrompt.system,
       messages: messagesPrompt.messages,
 
+      ...(anthropicOptions?.safeguards &&
+        anthropicOptions.safeguards.length > 0 && {
+          safeguards: anthropicOptions.safeguards.map(safeguard => ({
+            type: safeguard.type,
+            ...(safeguard.classifierContext !== undefined && {
+              classifier_context: safeguard.classifierContext,
+            }),
+          })),
+        }),
+
       ...(contextManagement && {
         context_management: {
           edits: contextManagement.edits
@@ -841,6 +864,13 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
       betas.add('mcp-client-2025-04-04');
     }
 
+    if (
+      anthropicOptions?.safeguards &&
+      anthropicOptions.safeguards.length > 0
+    ) {
+      betas.add('dangerous-tool-use-2026-09-03');
+    }
+
     if (contextManagement) {
       betas.add('context-management-2025-06-27');
 
@@ -1588,6 +1618,9 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
           ...(response.input_transformations != null
             ? { inputTransformations: response.input_transformations }
             : {}),
+          ...(response.safeguard_results != null
+            ? { safeguardResults: response.safeguard_results }
+            : {}),
 
           iterations: response.usage.iterations
             ? response.usage.iterations.map(
@@ -1732,6 +1765,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
     let stopSequence: string | null = null;
     let stopDetails: AnthropicMessageMetadata['stopDetails'] = undefined;
     let inputTransformations: AnthropicMessageMetadata['inputTransformations'];
+    let safeguardResults: AnthropicMessageMetadata['safeguardResults'];
     let container: AnthropicMessageMetadata['container'] | null = null;
     let isJsonResponseFromTool = false;
     let isMessageOpen = false;
@@ -2802,6 +2836,12 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
                 inputTransformations = value.input_transformations;
               }
 
+              // Earlier deltas may carry null while the classifier is still
+              // running; the last non-null value is the final verdict.
+              if (value.delta.safeguard_results != null) {
+                safeguardResults = value.delta.safeguard_results;
+              }
+
               rawUsage = {
                 ...rawUsage,
                 ...(value.usage as JSONObject),
@@ -2822,6 +2862,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
                 ...(inputTransformations != null
                   ? { inputTransformations }
                   : {}),
+                ...(safeguardResults != null ? { safeguardResults } : {}),
                 iterations: usage.iterations
                   ? usage.iterations.map(
                       iter =>
@@ -2942,6 +2983,11 @@ export function getModelCapabilities(modelId: string): {
    * are rejected with a 400.
    */
   rejectsThinkingDisabled: boolean;
+  /**
+   * Budget-based thinking (`thinking.type` `enabled` with `budget_tokens`) is
+   * rejected with a 400. Only adaptive thinking is supported.
+   */
+  rejectsBudgetThinking: boolean;
   /**
    * Forced tool use (`tool_choice` `any` or a named tool) is rejected with a 400.
    */
@@ -2960,6 +3006,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: true,
       rejectsThinkingDisabledAboveHighEffort: true,
       rejectsThinkingDisabled: true,
+      rejectsBudgetThinking: true,
       rejectsForcedToolUse: true,
       supportsBetweenToolsThinking: true,
       isKnownModel: true,
@@ -2971,10 +3018,24 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: true,
       rejectsThinkingDisabledAboveHighEffort: true,
       rejectsThinkingDisabled: true,
+      rejectsBudgetThinking: true,
       rejectsForcedToolUse: true,
       supportsBetweenToolsThinking: false,
       isKnownModel: true,
     };
+  } else if (modelId.includes('claude-haiku-5-5')) {
+    // Thinking can be turned off, but only up to `high` effort.
+    return {
+      maxOutputTokens: 128000,
+      supportsStructuredOutput: true,
+      rejectsSamplingParameters: true,
+      rejectsThinkingDisabledAboveHighEffort: true,
+      rejectsThinkingDisabled: false,
+      rejectsBudgetThinking: true,
+      rejectsForcedToolUse: false,
+      supportsBetweenToolsThinking: false,
+      isKnownModel: true,
+    };
   } else if (modelId.includes('claude-opus-5')) {
     return {
       maxOutputTokens: 128000,
@@ -2982,6 +3043,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: true,
       rejectsThinkingDisabledAboveHighEffort: true,
       rejectsThinkingDisabled: false,
+      rejectsBudgetThinking: false,
       rejectsForcedToolUse: false,
       supportsBetweenToolsThinking: false,
       isKnownModel: true,
@@ -2993,6 +3055,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: true,
       rejectsThinkingDisabledAboveHighEffort: false,
       rejectsThinkingDisabled: true,
+      rejectsBudgetThinking: true,
       rejectsForcedToolUse: true,
       supportsBetweenToolsThinking: false,
       isKnownModel: true,
@@ -3004,6 +3067,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: true,
       rejectsThinkingDisabledAboveHighEffort: false,
       rejectsThinkingDisabled: true,
+      rejectsBudgetThinking: true,
       rejectsForcedToolUse: false,
       supportsBetweenToolsThinking: false,
       isKnownModel: true,
@@ -3019,6 +3083,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: true,
       rejectsThinkingDisabledAboveHighEffort: false,
       rejectsThinkingDisabled: false,
+      rejectsBudgetThinking: false,
       rejectsForcedToolUse: false,
       supportsBetweenToolsThinking: false,
       isKnownModel: true,
@@ -3033,6 +3098,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: false,
       rejectsThinkingDisabledAboveHighEffort: false,
       rejectsThinkingDisabled: false,
+      rejectsBudgetThinking: false,
       rejectsForcedToolUse: false,
       supportsBetweenToolsThinking: false,
       isKnownModel: true,
@@ -3048,6 +3114,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: false,
       rejectsThinkingDisabledAboveHighEffort: false,
       rejectsThinkingDisabled: false,
+      rejectsBudgetThinking: false,
       rejectsForcedToolUse: false,
       supportsBetweenToolsThinking: false,
       isKnownModel: true,
@@ -3059,6 +3126,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: false,
       rejectsThinkingDisabledAboveHighEffort: false,
       rejectsThinkingDisabled: false,
+      rejectsBudgetThinking: false,
       rejectsForcedToolUse: false,
       supportsBetweenToolsThinking: false,
       isKnownModel: true,
@@ -3070,6 +3138,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: false,
       rejectsThinkingDisabledAboveHighEffort: false,
       rejectsThinkingDisabled: false,
+      rejectsBudgetThinking: false,
       rejectsForcedToolUse: false,
       supportsBetweenToolsThinking: false,
       isKnownModel: true,
@@ -3081,6 +3150,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: false,
       rejectsThinkingDisabledAboveHighEffort: false,
       rejectsThinkingDisabled: false,
+      rejectsBudgetThinking: false,
       rejectsForcedToolUse: false,
       supportsBetweenToolsThinking: false,
       isKnownModel: true,
@@ -3092,6 +3162,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: false,
       rejectsThinkingDisabledAboveHighEffort: false,
       rejectsThinkingDisabled: false,
+      rejectsBudgetThinking: false,
       rejectsForcedToolUse: false,
       supportsBetweenToolsThinking: false,
       isKnownModel: true,
@@ -3105,6 +3176,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: false,
       rejectsThinkingDisabledAboveHighEffort: false,
       rejectsThinkingDisabled: false,
+      rejectsBudgetThinking: false,
       rejectsForcedToolUse: false,
       supportsBetweenToolsThinking: false,
       isKnownModel: false,
@@ -3119,6 +3191,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: true,
       rejectsThinkingDisabledAboveHighEffort: true,
       rejectsThinkingDisabled: false,
+      rejectsBudgetThinking: false,
       rejectsForcedToolUse: false,
       supportsBetweenToolsThinking: false,
       isKnownModel: false,
@@ -3132,6 +3205,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: false,
       rejectsThinkingDisabledAboveHighEffort: false,
       rejectsThinkingDisabled: false,
+      rejectsBudgetThinking: false,
       rejectsForcedToolUse: false,
       supportsBetweenToolsThinking: false,
       isKnownModel: false,

package/src/anthropic-messages-options.ts

@@ -5,6 +5,7 @@ export type AnthropicMessagesModelId =
   | 'claude-3-haiku-20240307'
   | 'claude-haiku-4-5-20251001'
   | 'claude-haiku-4-5'
+  | 'claude-haiku-5-5'
   | 'claude-opus-4-0'
   | 'claude-opus-4-20250514'
   | 'claude-opus-4-1-20250805'
@@ -364,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(