@ai-sdk/anthropic 3.0.119 → 3.0.120

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

@@ -138,6 +138,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: LanguageModelV3CallOptions['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)
+      : {}),
+  };
+}
+
 type AnthropicMessagesConfig = {
   provider: string;
   baseURL: string;
@@ -297,6 +339,8 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
       supportsStructuredOutput: modelSupportsStructuredOutput,
       rejectsSamplingParameters,
       rejectsThinkingDisabledAboveHighEffort,
+      rejectsThinkingDisabled,
+      rejectsForcedToolUse,
       isKnownModel,
     } = getModelCapabilities(this.modelId);
 
@@ -350,10 +394,30 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
 
     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 ${this.modelId} because it rejects forced tool use. ` +
+          `Using 'outputFormat' instead.`,
+      });
+      useStructuredOutput = true;
+    }
+
     const jsonResponseTool: LanguageModelV3FunctionTool | undefined =
       responseFormat?.type === 'json' &&
       responseFormat.schema != null &&
@@ -392,6 +456,8 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
         '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',
@@ -409,6 +475,8 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
       },
     });
 
+    const toolsetNames = getAnthropicToolsetNames(tools);
+
     const { prompt: messagesPrompt, betas } =
       await convertToAnthropicMessagesPrompt({
         prompt,
@@ -416,8 +484,38 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
         warnings,
         cacheControlValidator,
         toolNameMapping,
+        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.
+    if (rejectsThinkingDisabled && anthropicOptions?.thinking != null) {
+      const requestedThinking = anthropicOptions.thinking;
+      const requestedType =
+        'type' in requestedThinking ? requestedThinking.type : undefined;
+
+      if (requestedType === 'disabled') {
+        warnings.push({
+          type: 'unsupported',
+          feature: 'providerOptions.anthropic.thinking',
+          details:
+            `thinking cannot be disabled for ${this.modelId}; it always uses adaptive thinking. ` +
+            `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' };
+      }
+    }
+
     const thinking = anthropicOptions?.thinking;
     const thinkingType =
       thinking != null && 'type' in thinking ? thinking.type : undefined;
@@ -790,6 +888,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
             supportsStructuredOutput: false,
             supportsStrictTools,
             defaultEagerInputStreaming,
+            rejectsForcedToolUse,
           }
         : {
             tools: tools ?? [],
@@ -799,6 +898,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
             supportsStructuredOutput,
             supportsStrictTools,
             defaultEagerInputStreaming,
+            rejectsForcedToolUse,
           },
     );
 
@@ -1049,6 +1149,27 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
               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',
@@ -1554,6 +1675,12 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
           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'
@@ -1720,6 +1847,34 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
                       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);
 
@@ -2200,6 +2355,37 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
                       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,
@@ -2242,10 +2428,15 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
                         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,
+                              }),
                             },
                           },
                         }),
@@ -2347,6 +2538,13 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
                       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 (
@@ -2710,20 +2908,60 @@ export function getModelCapabilities(modelId: string): {
   supportsStructuredOutput: boolean;
   rejectsSamplingParameters: 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,
       rejectsSamplingParameters: true,
       rejectsThinkingDisabledAboveHighEffort: true,
+      rejectsThinkingDisabled: true,
+      rejectsForcedToolUse: true,
+      isKnownModel: true,
+    };
+  } else if (modelId.includes('claude-opus-5')) {
+    return {
+      maxOutputTokens: 128000,
+      supportsStructuredOutput: true,
+      rejectsSamplingParameters: true,
+      rejectsThinkingDisabledAboveHighEffort: true,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
+      isKnownModel: true,
+    };
+  } else if (modelId.includes('claude-fable-5-1')) {
+    return {
+      maxOutputTokens: 128000,
+      supportsStructuredOutput: true,
+      rejectsSamplingParameters: true,
+      rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: true,
+      rejectsForcedToolUse: true,
+      isKnownModel: true,
+    };
+  } else if (modelId.includes('claude-fable-5')) {
+    return {
+      maxOutputTokens: 128000,
+      supportsStructuredOutput: true,
+      rejectsSamplingParameters: 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 {
@@ -2731,6 +2969,8 @@ export function getModelCapabilities(modelId: string): {
       supportsStructuredOutput: true,
       rejectsSamplingParameters: true,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
       isKnownModel: true,
     };
   } else if (
@@ -2742,6 +2982,8 @@ export function getModelCapabilities(modelId: string): {
       supportsStructuredOutput: true,
       rejectsSamplingParameters: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
       isKnownModel: true,
     };
   } else if (
@@ -2754,6 +2996,8 @@ export function getModelCapabilities(modelId: string): {
       supportsStructuredOutput: true,
       rejectsSamplingParameters: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
       isKnownModel: true,
     };
   } else if (modelId.includes('claude-opus-4-1')) {
@@ -2762,6 +3006,8 @@ export function getModelCapabilities(modelId: string): {
       supportsStructuredOutput: true,
       rejectsSamplingParameters: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
       isKnownModel: true,
     };
   } else if (modelId.includes('claude-sonnet-4-')) {
@@ -2770,6 +3016,8 @@ export function getModelCapabilities(modelId: string): {
       supportsStructuredOutput: false,
       rejectsSamplingParameters: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
       isKnownModel: true,
     };
   } else if (modelId.includes('claude-opus-4-')) {
@@ -2778,6 +3026,8 @@ export function getModelCapabilities(modelId: string): {
       supportsStructuredOutput: false,
       rejectsSamplingParameters: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
       isKnownModel: true,
     };
   } else if (modelId.includes('claude-3-haiku')) {
@@ -2786,6 +3036,8 @@ export function getModelCapabilities(modelId: string): {
       supportsStructuredOutput: false,
       rejectsSamplingParameters: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
       isKnownModel: true,
     };
   } else if (
@@ -2796,6 +3048,8 @@ export function getModelCapabilities(modelId: string): {
       supportsStructuredOutput: false,
       rejectsSamplingParameters: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
       isKnownModel: false,
     };
   } else if (modelId.includes('claude-')) {
@@ -2807,6 +3061,8 @@ export function getModelCapabilities(modelId: string): {
       supportsStructuredOutput: true,
       rejectsSamplingParameters: true,
       rejectsThinkingDisabledAboveHighEffort: true,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
       isKnownModel: false,
     };
   } else {
@@ -2817,6 +3073,8 @@ export function getModelCapabilities(modelId: string): {
       supportsStructuredOutput: false,
       rejectsSamplingParameters: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
       isKnownModel: false,
     };
   }
@@ -2839,7 +3097,7 @@ function hasWebTool20260209WithoutCodeExecution(
       hasWebTool20260209 = true;
       continue;
     }
-    if (tool.name === 'code_execution') {
+    if ('name' in tool && tool.name === 'code_execution') {
       hasCodeExecutionTool = true;
       break;
     }

package/src/anthropic-messages-options.ts

@@ -20,6 +20,7 @@ export type AnthropicMessagesModelId =
   | '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'
@@ -77,7 +78,7 @@ export const anthropicSystemMessageProviderOptions = z.object({
    * Overrides the effort level for the turn following this
    * mid-conversation system message.
    *
-   * Requires the `mid-conversation-effort-2026-08-01` beta,
+   * Requires the `mid-conversation-output-config-2026-07-01` beta,
    * which is added automatically.
    */
   effort: z.enum(['low', 'medium', 'high', 'xhigh', 'max']).optional(),
@@ -142,6 +143,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([
@@ -269,7 +275,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(),
 

package/src/anthropic-prepare-tools.ts

@@ -9,6 +9,7 @@ import type {
 } from './anthropic-messages-api';
 import { CacheControlValidator } from './get-cache-control';
 import { advisor_20260301ArgsSchema } from './tool/advisor_20260301';
+import { computerToolset_20260801ArgsSchema } from './tool/computer-toolset_20260801';
 import { textEditor_20250728ArgsSchema } from './tool/text-editor_20250728';
 import { webSearch_20260209ArgsSchema } from './tool/web-search_20260209';
 import { webSearch_20250305ArgsSchema } from './tool/web-search_20250305';
@@ -32,6 +33,7 @@ export async function prepareTools({
   supportsStructuredOutput,
   supportsStrictTools,
   defaultEagerInputStreaming = false,
+  rejectsForcedToolUse = false,
 }: {
   tools: LanguageModelV3CallOptions['tools'];
   toolChoice: LanguageModelV3CallOptions['toolChoice'] | undefined;
@@ -53,6 +55,13 @@ export async function prepareTools({
    * it explicitly. Driven by the model-level `toolStreaming` option.
    */
   defaultEagerInputStreaming?: boolean;
+
+  /**
+   * Whether the model rejects forced tool use (`tool_choice` `any` or a
+   * named tool). When true, `required` and `tool` tool choices fall back to
+   * `auto` with a warning.
+   */
+  rejectsForcedToolUse?: boolean;
 }): Promise<{
   tools: Array<AnthropicTool> | undefined;
   toolChoice: AnthropicToolChoice | undefined;
@@ -186,6 +195,34 @@ export async function prepareTools({
             });
             break;
           }
+          case 'anthropic.computer_toolset_20260801': {
+            const args = await validateTypes({
+              value: tool.args,
+              schema: computerToolset_20260801ArgsSchema,
+            });
+            const configs =
+              args.configs != null
+                ? Object.fromEntries(
+                    Object.entries(args.configs).map(([member, config]) => [
+                      member,
+                      {
+                        ...(config?.enabled != null && {
+                          enabled: config.enabled,
+                        }),
+                        ...(config?.deferLoading != null && {
+                          defer_loading: config.deferLoading,
+                        }),
+                      },
+                    ]),
+                  )
+                : undefined;
+            anthropicTools.push({
+              type: 'computer_toolset_20260801',
+              ...(configs != null && { configs }),
+              cache_control: undefined,
+            });
+            break;
+          }
           case 'anthropic.computer_20241022': {
             betas.add('computer-use-2024-10-22');
             anthropicTools.push({
@@ -412,6 +449,24 @@ export async function prepareTools({
         betas,
       };
     case 'required':
+      if (rejectsForcedToolUse) {
+        toolWarnings.push({
+          type: 'unsupported',
+          feature: 'toolChoice',
+          details:
+            `toolChoice 'required' is not supported by this model because it rejects forced tool use. ` +
+            `Using 'auto' instead. Instruct the model to use a tool in the prompt and verify that a tool call was made.`,
+        });
+        return {
+          tools: anthropicTools,
+          toolChoice: {
+            type: 'auto',
+            disable_parallel_tool_use: disableParallelToolUse,
+          },
+          toolWarnings,
+          betas,
+        };
+      }
       return {
         tools: anthropicTools,
         toolChoice: {
@@ -425,6 +480,27 @@ export async function prepareTools({
       // Anthropic does not support 'none' tool choice, so we remove the tools:
       return { tools: undefined, toolChoice: undefined, toolWarnings, betas };
     case 'tool':
+      if (rejectsForcedToolUse) {
+        toolWarnings.push({
+          type: 'unsupported',
+          feature: 'toolChoice',
+          details:
+            `toolChoice 'tool' is not supported by this model because it rejects forced tool use. ` +
+            `Only the '${toolChoice.toolName}' tool is sent with 'auto' tool choice. ` +
+            `Instruct the model to use the tool in the prompt and verify that a tool call was made.`,
+        });
+        return {
+          tools: anthropicTools.filter(
+            tool => 'name' in tool && tool.name === toolChoice.toolName,
+          ),
+          toolChoice: {
+            type: 'auto',
+            disable_parallel_tool_use: disableParallelToolUse,
+          },
+          toolWarnings,
+          betas,
+        };
+      }
       return {
         tools: anthropicTools,
         toolChoice: {

package/src/anthropic-tools.ts

@@ -7,6 +7,7 @@ import { codeExecution_20260120 } from './tool/code-execution_20260120';
 import { computer_20241022 } from './tool/computer_20241022';
 import { computer_20250124 } from './tool/computer_20250124';
 import { computer_20251124 } from './tool/computer_20251124';
+import { computerToolset_20260801 } from './tool/computer-toolset_20260801';
 import { memory_20250818 } from './tool/memory_20250818';
 import { textEditor_20241022 } from './tool/text-editor_20241022';
 import { textEditor_20250124 } from './tool/text-editor_20250124';
@@ -143,6 +144,30 @@ export const anthropicTools = {
    */
   computer_20251124,
 
+  /**
+   * The computer toolset lets Claude control a computer through screenshots,
+   * mouse, and keyboard. It replaces the versioned computer tools
+   * (`computer_20251124` and earlier) on newer models.
+   *
+   * The API returns each computer action as its own `tool_use` block with
+   * `toolset_name: 'computer'`. The AI SDK maps every member call to this tool
+   * and exposes the member name as `action`, so `execute` receives the same
+   * input shape as the older computer tools. Claude may return several actions
+   * in one turn.
+   *
+   * Coordinates are always in the pixel space of the screenshots you return;
+   * there are no display size parameters. Zoom is enabled by default.
+   *
+   * Does not require a beta header.
+   *
+   * Supported models: Claude Opus 5.5 (required; older computer tool types
+   * are rejected), Opus 5, Sonnet 5, Fable 5, Fable 5.1, Opus 4.8.
+   *
+   * @param configs - Per-member settings keyed by member name, e.g.
+   * `{ zoom: { enabled: false } }`. Omitted members keep their defaults.
+   */
+  computerToolset_20260801,
+
   /**
    * The memory tool enables Claude to store and retrieve information across conversations through a memory file directory.
    * Claude can create, read, update, and delete files that persist between sessions,