@ai-sdk/anthropic 4.0.59 → 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
@@ -903,6 +1001,7 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
             supportsStructuredOutput: false,
             supportsStrictTools,
             defaultEagerInputStreaming,
+            rejectsForcedToolUse,
           }
         : {
             tools: tools ?? [],
@@ -912,6 +1011,7 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
             supportsStructuredOutput,
             supportsStrictTools,
             defaultEagerInputStreaming,
+            rejectsForcedToolUse,
           },
     );
 
@@ -1184,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',
@@ -1696,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'
@@ -1862,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);
 
@@ -2352,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,
@@ -2394,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,
+                              }),
                             },
                           },
                         }),
@@ -2499,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 (
@@ -2872,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,
@@ -2882,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 {
@@ -2897,6 +3141,8 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: true,
       supportsXhighEffort: true,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
       isKnownModel: true,
     };
   } else if (
@@ -2910,6 +3156,8 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: false,
       supportsXhighEffort: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
       isKnownModel: true,
     };
   } else if (
@@ -2924,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')) {
@@ -2934,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)) {
@@ -2944,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)) {
@@ -2954,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')) {
@@ -2964,6 +3220,8 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: false,
       supportsXhighEffort: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
       isKnownModel: true,
     };
   } else if (
@@ -2976,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-')) {
@@ -2989,6 +3249,8 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: true,
       supportsXhighEffort: true,
       rejectsThinkingDisabledAboveHighEffort: true,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
       isKnownModel: false,
     };
   } else {
@@ -3001,6 +3263,8 @@ export function getModelCapabilities(modelId: string): {
       rejectsSamplingParameters: false,
       supportsXhighEffort: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
       isKnownModel: false,
     };
   }
@@ -3040,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 {
@@ -3056,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-prepare-tools.ts

@@ -6,6 +6,7 @@ import {
 import type { AnthropicTool, AnthropicToolChoice } from './anthropic-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_20260318ArgsSchema } from './tool/web-search_20260318';
 import { webSearch_20260209ArgsSchema } from './tool/web-search_20260209';
@@ -31,6 +32,7 @@ export async function prepareTools({
   supportsStructuredOutput,
   supportsStrictTools,
   defaultEagerInputStreaming = false,
+  rejectsForcedToolUse = false,
 }: {
   tools: LanguageModelV4CallOptions['tools'];
   toolChoice: LanguageModelV4CallOptions['toolChoice'] | undefined;
@@ -52,6 +54,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;
@@ -185,6 +194,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({
@@ -450,6 +487,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: {
@@ -463,6 +518,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';
@@ -147,6 +148,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,