@ai-sdk/anthropic 4.0.58 → 4.0.60

package/src/anthropic-language-model.ts

@@ -195,6 +195,48 @@ function getAnthropicCallerMetadata(
     : { providerMetadata: { anthropic: { caller: callerInfo } } };
 }
 
+/**
+ * Maps the custom tool names of toolset tools (e.g. the computer toolset) to
+ * the toolset name that the Anthropic API uses in `toolset_name`.
+ */
+function getAnthropicToolsetNames(
+  tools: LanguageModelV4CallOptions['tools'],
+): Record<string, string> {
+  const toolsetNames: Record<string, string> = {};
+
+  for (const tool of tools ?? []) {
+    if (
+      tool.type === 'provider' &&
+      tool.id === 'anthropic.computer_toolset_20260801'
+    ) {
+      toolsetNames[tool.name] = 'computer';
+    }
+  }
+
+  return toolsetNames;
+}
+
+/**
+ * Toolset member calls (e.g. `left_click` from the computer toolset) are
+ * exposed as a single tool call on the toolset tool. The member name is
+ * injected as the `action` property, matching the input shape of the older
+ * computer tool versions.
+ */
+function toToolsetMemberInput({
+  memberName,
+  input,
+}: {
+  memberName: string;
+  input: unknown;
+}): JSONObject {
+  return {
+    action: memberName,
+    ...(typeof input === 'object' && input !== null && !Array.isArray(input)
+      ? (input as JSONObject)
+      : {}),
+  };
+}
+
 function getProviderOptionsName(provider: string): string {
   const dotIndex = provider.indexOf('.');
   return dotIndex === -1 ? provider : provider.substring(0, dotIndex);
@@ -362,6 +404,8 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
       rejectsSamplingParameters,
       supportsXhighEffort,
       rejectsThinkingDisabledAboveHighEffort,
+      rejectsThinkingDisabled,
+      rejectsForcedToolUse,
       isKnownModel,
     } = getModelCapabilities(modelId);
 
@@ -414,10 +458,30 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
 
     const structureOutputMode =
       anthropicOptions?.structuredOutputMode ?? 'auto';
-    const useStructuredOutput =
+    let useStructuredOutput =
       structureOutputMode === 'outputFormat' ||
       (structureOutputMode === 'auto' && supportsStructuredOutput);
 
+    // The JSON response tool relies on forced tool use, which some models
+    // reject (e.g. Opus 5.5, Fable 5.1). Fall back to native structured
+    // outputs when the model supports them.
+    if (
+      !useStructuredOutput &&
+      rejectsForcedToolUse &&
+      supportsStructuredOutput &&
+      responseFormat?.type === 'json' &&
+      responseFormat.schema != null
+    ) {
+      warnings.push({
+        type: 'unsupported',
+        feature: 'providerOptions.anthropic.structuredOutputMode',
+        details:
+          `structuredOutputMode 'jsonTool' is not supported by ${modelId} because it rejects forced tool use. ` +
+          `Using 'outputFormat' instead.`,
+      });
+      useStructuredOutput = true;
+    }
+
     const jsonResponseTool: LanguageModelV4FunctionTool | undefined =
       responseFormat?.type === 'json' &&
       responseFormat.schema != null &&
@@ -456,6 +520,8 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
         'anthropic.code_execution_20260120': 'code_execution',
         'anthropic.computer_20241022': 'computer',
         'anthropic.computer_20250124': 'computer',
+        'anthropic.computer_20251124': 'computer',
+        'anthropic.computer_toolset_20260801': 'computer',
         'anthropic.text_editor_20241022': 'str_replace_editor',
         'anthropic.text_editor_20250124': 'str_replace_editor',
         'anthropic.text_editor_20250429': 'str_replace_based_edit_tool',
@@ -475,12 +541,15 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
       },
     });
 
+    const toolsetNames = getAnthropicToolsetNames(tools);
+
     const { prompt: messagesPrompt, betas } = await convertToAnthropicPrompt({
       prompt,
       sendReasoning: anthropicOptions?.sendReasoning ?? true,
       warnings,
       cacheControlValidator,
       toolNameMapping,
+      toolsetNames,
     });
 
     /*
@@ -490,8 +559,10 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
     if (isCustomReasoning(reasoning) && anthropicOptions?.effort == null) {
       const reasoningConfig = resolveAnthropicReasoningConfig({
         reasoning,
+        modelId,
         supportsAdaptiveThinking,
         supportsXhighEffort,
+        rejectsThinkingDisabled,
         maxOutputTokensForModel,
         warnings,
       });
@@ -508,6 +579,33 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
       }
     }
 
+    // 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.
+    if (rejectsThinkingDisabled && anthropicOptions?.thinking != null) {
+      const thinking = anthropicOptions.thinking;
+
+      if (thinking.type === 'disabled') {
+        warnings.push({
+          type: 'unsupported',
+          feature: 'providerOptions.anthropic.thinking',
+          details:
+            `thinking cannot be disabled for ${modelId}; it always uses adaptive thinking. ` +
+            `The thinking setting has been removed. Lower 'effort' to reduce thinking.`,
+        });
+        anthropicOptions.thinking = undefined;
+      } else if (thinking.type === 'enabled') {
+        warnings.push({
+          type: 'unsupported',
+          feature: 'providerOptions.anthropic.thinking',
+          details:
+            `budget-based thinking is not supported by ${modelId}; it always uses adaptive thinking. ` +
+            `Using adaptive thinking instead. Use 'effort' to control how much the model thinks.`,
+        });
+        anthropicOptions.thinking = { type: 'adaptive' };
+      }
+    }
+
     // 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
@@ -671,6 +769,16 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
       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
@@ -810,6 +918,13 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
       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');
 
@@ -886,6 +1001,7 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
             supportsStructuredOutput: false,
             supportsStrictTools,
             defaultEagerInputStreaming,
+            rejectsForcedToolUse,
           }
         : {
             tools: tools ?? [],
@@ -895,6 +1011,7 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
             supportsStructuredOutput,
             supportsStrictTools,
             defaultEagerInputStreaming,
+            rejectsForcedToolUse,
           },
     );
 
@@ -1167,6 +1284,27 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
               type: 'text',
               text: JSON.stringify(part.input),
             });
+          } else if (part.toolset_name != null) {
+            // toolset member calls (e.g. the computer toolset) are mapped to
+            // the toolset tool with the member name as the `action`:
+            content.push({
+              type: 'tool-call',
+              toolCallId: part.id,
+              toolName: toolNameMapping.toCustomToolName(part.toolset_name),
+              input: JSON.stringify(
+                toToolsetMemberInput({
+                  memberName: part.name,
+                  input: part.input,
+                }),
+              ),
+              providerMetadata: {
+                anthropic: {
+                  toolsetName: part.toolset_name,
+                  ...getAnthropicCallerMetadata(part.caller).providerMetadata
+                    ?.anthropic,
+                },
+              },
+            });
           } else {
             content.push({
               type: 'tool-call',
@@ -1560,6 +1698,9 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
           ...(response.input_transformations != null
             ? { inputTransformations: response.input_transformations }
             : {}),
+          ...(response.safeguard_results != null
+            ? { safeguardResults: response.safeguard_results }
+            : {}),
 
           iterations: response.usage.iterations
             ? response.usage.iterations.map(
@@ -1676,6 +1817,12 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
           firstDelta: boolean;
           providerToolName?: string;
           providerToolInputType?: string;
+          /**
+           * Set for toolset member calls (e.g. the computer toolset). The raw
+           * member input is accumulated and emitted as a single delta with the
+           * member name injected as `action` when the block completes.
+           */
+          toolset?: { name: string; memberName: string };
           caller?: {
             type:
               | 'code_execution_20250825'
@@ -1697,6 +1844,7 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
     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;
@@ -1841,6 +1989,34 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
                       type: 'text-start',
                       id: String(value.index),
                     });
+                  } else if (part.toolset_name != null) {
+                    const callerInfo = getAnthropicCallerInfo(part.caller);
+                    const customToolName = toolNameMapping.toCustomToolName(
+                      part.toolset_name,
+                    );
+                    const hasNonEmptyInput =
+                      part.input && Object.keys(part.input).length > 0;
+
+                    // toolset member input is accumulated and emitted when the
+                    // block completes (see content_block_stop):
+                    contentBlocks[value.index] = {
+                      type: 'tool-call',
+                      toolCallId: part.id,
+                      toolName: customToolName,
+                      input: hasNonEmptyInput ? JSON.stringify(part.input) : '',
+                      firstDelta: true,
+                      toolset: {
+                        name: part.toolset_name,
+                        memberName: part.name,
+                      },
+                      ...(callerInfo && { caller: callerInfo }),
+                    };
+
+                    controller.enqueue({
+                      type: 'tool-input-start',
+                      id: part.id,
+                      toolName: customToolName,
+                    });
                   } else {
                     const callerInfo = getAnthropicCallerInfo(part.caller);
 
@@ -2331,6 +2507,37 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
                       usesJsonResponseTool && contentBlock.toolName === 'json';
 
                     if (!isJsonResponseTool) {
+                      // toolset member calls: emit the accumulated input with
+                      // the member name injected as `action` in one delta.
+                      if (contentBlock.toolset != null) {
+                        let memberInput: unknown = {};
+                        try {
+                          memberInput =
+                            contentBlock.input === ''
+                              ? {}
+                              : secureJsonParse(contentBlock.input);
+                        } catch {
+                          // ignore parse errors, fall back to the raw input
+                          memberInput = undefined;
+                        }
+
+                        contentBlock.input =
+                          memberInput === undefined
+                            ? contentBlock.input
+                            : JSON.stringify(
+                                toToolsetMemberInput({
+                                  memberName: contentBlock.toolset.memberName,
+                                  input: memberInput,
+                                }),
+                              );
+
+                        controller.enqueue({
+                          type: 'tool-input-delta',
+                          id: contentBlock.toolCallId,
+                          delta: contentBlock.input,
+                        });
+                      }
+
                       controller.enqueue({
                         type: 'tool-input-end',
                         id: contentBlock.toolCallId,
@@ -2373,10 +2580,15 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
                         contentBlock.providerToolName === 'code_execution'
                           ? { dynamic: true }
                           : {}),
-                        ...(contentBlock.caller && {
+                        ...((contentBlock.caller || contentBlock.toolset) && {
                           providerMetadata: {
                             anthropic: {
-                              caller: contentBlock.caller,
+                              ...(contentBlock.toolset && {
+                                toolsetName: contentBlock.toolset.name,
+                              }),
+                              ...(contentBlock.caller && {
+                                caller: contentBlock.caller,
+                              }),
                             },
                           },
                         }),
@@ -2478,6 +2690,13 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
                       return;
                     }
 
+                    // toolset member input is emitted as a single delta once
+                    // the block is complete (the member name is injected):
+                    if (contentBlock.toolset != null) {
+                      contentBlock.input += delta;
+                      return;
+                    }
+
                     // for the code execution 20250825, we need to add
                     // the type to the delta and change the tool name.
                     if (
@@ -2701,6 +2920,12 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
                 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),
@@ -2720,6 +2945,7 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
                 ...(inputTransformations != null
                   ? { inputTransformations }
                   : {}),
+                ...(safeguardResults != null ? { safeguardResults } : {}),
                 iterations: usage.iterations
                   ? usage.iterations.map(
                       iter =>
@@ -2844,9 +3070,30 @@ export function getModelCapabilities(modelId: string): {
   rejectsSamplingParameters: boolean;
   supportsXhighEffort: boolean;
   rejectsThinkingDisabledAboveHighEffort: boolean;
+  /**
+   * Thinking is always adaptive: `thinking.type` `disabled` and `enabled`
+   * are rejected with a 400.
+   */
+  rejectsThinkingDisabled: boolean;
+  /**
+   * Forced tool use (`tool_choice` `any` or a named tool) is rejected with a 400.
+   */
+  rejectsForcedToolUse: boolean;
   isKnownModel: boolean;
 } {
-  if (modelId.includes('claude-opus-5')) {
+  if (modelId.includes('claude-opus-5-5')) {
+    return {
+      maxOutputTokens: 128000,
+      supportsStructuredOutput: true,
+      supportsAdaptiveThinking: true,
+      rejectsSamplingParameters: true,
+      supportsXhighEffort: true,
+      rejectsThinkingDisabledAboveHighEffort: true,
+      rejectsThinkingDisabled: true,
+      rejectsForcedToolUse: true,
+      isKnownModel: true,
+    };
+  } else if (modelId.includes('claude-opus-5')) {
     return {
       maxOutputTokens: 128000,
       supportsStructuredOutput: true,
@@ -2854,12 +3101,37 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: true,
       supportsXhighEffort: true,
       rejectsThinkingDisabledAboveHighEffort: true,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
+      isKnownModel: true,
+    };
+  } else if (modelId.includes('claude-fable-5-1')) {
+    return {
+      maxOutputTokens: 128000,
+      supportsStructuredOutput: true,
+      supportsAdaptiveThinking: true,
+      rejectsSamplingParameters: true,
+      supportsXhighEffort: true,
+      rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: true,
+      rejectsForcedToolUse: true,
+      isKnownModel: true,
+    };
+  } else if (modelId.includes('claude-fable-5')) {
+    return {
+      maxOutputTokens: 128000,
+      supportsStructuredOutput: true,
+      supportsAdaptiveThinking: true,
+      rejectsSamplingParameters: true,
+      supportsXhighEffort: true,
+      rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: true,
+      rejectsForcedToolUse: false,
       isKnownModel: true,
     };
   } else if (
     modelId.includes('claude-opus-4-8') ||
     modelId.includes('claude-opus-4-7') ||
-    modelId.includes('claude-fable-5') ||
     modelId.includes('claude-sonnet-5')
   ) {
     return {
@@ -2869,6 +3141,8 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: true,
       supportsXhighEffort: true,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
       isKnownModel: true,
     };
   } else if (
@@ -2882,6 +3156,8 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: false,
       supportsXhighEffort: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
       isKnownModel: true,
     };
   } else if (
@@ -2896,6 +3172,8 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: false,
       supportsXhighEffort: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
       isKnownModel: true,
     };
   } else if (modelId.includes('claude-opus-4-1')) {
@@ -2906,6 +3184,8 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: false,
       supportsXhighEffort: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
       isKnownModel: true,
     };
   } else if (/claude-sonnet-4(?:-|@)/.test(modelId)) {
@@ -2916,6 +3196,8 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: false,
       supportsXhighEffort: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
       isKnownModel: true,
     };
   } else if (/claude-opus-4(?:-|@)/.test(modelId)) {
@@ -2926,6 +3208,8 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: false,
       supportsXhighEffort: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
       isKnownModel: true,
     };
   } else if (modelId.includes('claude-3-haiku')) {
@@ -2936,6 +3220,8 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: false,
       supportsXhighEffort: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
       isKnownModel: true,
     };
   } else if (
@@ -2948,6 +3234,8 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: false,
       supportsXhighEffort: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
       isKnownModel: false,
     };
   } else if (modelId.includes('claude-')) {
@@ -2961,6 +3249,8 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: true,
       supportsXhighEffort: true,
       rejectsThinkingDisabledAboveHighEffort: true,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
       isKnownModel: false,
     };
   } else {
@@ -2973,6 +3263,8 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: false,
       supportsXhighEffort: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
       isKnownModel: false,
     };
   }
@@ -3012,14 +3304,18 @@ export function hasDynamicFilteringWebToolWithoutCodeExecution(
 
 function resolveAnthropicReasoningConfig({
   reasoning,
+  modelId,
   supportsAdaptiveThinking,
   supportsXhighEffort,
+  rejectsThinkingDisabled,
   maxOutputTokensForModel,
   warnings,
 }: {
   reasoning: LanguageModelV4CallOptions['reasoning'];
+  modelId: string;
   supportsAdaptiveThinking: boolean;
   supportsXhighEffort: boolean;
+  rejectsThinkingDisabled: boolean;
   maxOutputTokensForModel: number;
   warnings: SharedV4Warning[];
 }): Pick<AnthropicLanguageModelOptions, 'thinking' | 'effort'> | undefined {
@@ -3028,6 +3324,20 @@ function resolveAnthropicReasoningConfig({
   }
 
   if (reasoning === 'none') {
+    // Models that always run adaptive thinking cannot disable it. Use low
+    // effort to keep thinking short instead of sending a request that the
+    // API would reject.
+    if (rejectsThinkingDisabled) {
+      warnings.push({
+        type: 'compatibility',
+        feature: 'reasoning',
+        details:
+          `reasoning 'none' is not supported by ${modelId}; it always uses adaptive thinking. ` +
+          `Using effort 'low' to minimize thinking instead.`,
+      });
+      return { effort: 'low' };
+    }
+
     return { thinking: { type: 'disabled' } };
   }
 

package/src/anthropic-message-metadata.ts

@@ -1,4 +1,5 @@
 import type { JSONObject } from '@ai-sdk/provider';
+import type { AnthropicSafeguardResult } from './anthropic-api';
 
 /**
  * Represents a single iteration in the usage breakdown.
@@ -62,6 +63,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