@ai-sdk/anthropic 4.0.58 → 4.0.60

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,

package/src/convert-to-anthropic-prompt.ts

@@ -81,12 +81,20 @@ export async function convertToAnthropicPrompt({
   warnings,
   cacheControlValidator,
   toolNameMapping,
+  toolsetNames = {},
 }: {
   prompt: LanguageModelV4Prompt;
   sendReasoning: boolean;
   warnings: SharedV4Warning[];
   cacheControlValidator?: CacheControlValidator;
   toolNameMapping: ToolNameMapping;
+
+  /**
+   * Maps custom tool names of toolset tools (e.g. the computer toolset) to
+   * the Anthropic `toolset_name`. Tool calls and results of these tools are
+   * serialized as toolset member calls.
+   */
+  toolsetNames?: Record<string, string>;
 }): Promise<{
   prompt: AnthropicPrompt;
   betas: Set<string>;
@@ -258,7 +266,7 @@ export async function convertToAnthropicPrompt({
               betas.add('mid-conversation-system-clear-at-2026-08-21');
             }
             if (message.effort != null) {
-              betas.add('mid-conversation-effort-2026-08-01');
+              betas.add('mid-conversation-output-config-2026-07-01');
             }
           }
         }
@@ -636,9 +644,16 @@ export async function convertToAnthropicPrompt({
                     break;
                 }
 
+                const toolsetName = getAnthropicToolsetName({
+                  toolName: part.toolName,
+                  providerOptions: part.providerOptions,
+                  toolsetNames,
+                });
+
                 anthropicContent.push({
                   type: 'tool_result',
                   tool_use_id: part.toolCallId,
+                  ...(toolsetName != null && { toolset_name: toolsetName }),
                   content: contentValue,
                   is_error:
                     output.type === 'error-text' || output.type === 'error-json'
@@ -902,6 +917,38 @@ export async function convertToAnthropicPrompt({
                   break;
                 }
 
+                const toolsetName = getAnthropicToolsetName({
+                  toolName: part.toolName,
+                  providerOptions: part.providerOptions,
+                  toolsetNames,
+                });
+
+                if (toolsetName != null) {
+                  // toolset member call: the `action` is the member tool name
+                  const { action, ...memberInput } = toAnthropicToolInput(
+                    part.input,
+                  );
+
+                  if (typeof action !== 'string') {
+                    warnings.push({
+                      type: 'other',
+                      message: `toolset tool call for tool ${part.toolName} is missing the action`,
+                    });
+                    break;
+                  }
+
+                  anthropicContent.push({
+                    type: 'tool_use',
+                    id: part.toolCallId,
+                    name: action,
+                    toolset_name: toolsetName,
+                    input: memberInput,
+                    ...(caller && { caller }),
+                    cache_control: cacheControl,
+                  });
+                  break;
+                }
+
                 anthropicContent.push({
                   type: 'tool_use',
                   id: part.toolCallId,
@@ -1457,6 +1504,32 @@ function moveToolUseBlocksToEnd(
   return result;
 }
 
+/**
+ * Resolves the Anthropic `toolset_name` for a tool call or tool result. The
+ * toolset is identified either through the tools passed to the request or
+ * through the `toolsetName` provider metadata of a previous response.
+ */
+function getAnthropicToolsetName({
+  toolName,
+  providerOptions,
+  toolsetNames,
+}: {
+  toolName: string;
+  providerOptions: SharedV4ProviderMetadata | undefined;
+  toolsetNames: Record<string, string>;
+}): string | undefined {
+  const fromTools = toolsetNames[toolName];
+  if (fromTools != null) {
+    return fromTools;
+  }
+
+  const fromMetadata = (
+    providerOptions?.anthropic as { toolsetName?: unknown } | undefined
+  )?.toolsetName;
+
+  return typeof fromMetadata === 'string' ? fromMetadata : undefined;
+}
+
 function getAnthropicCaller(
   providerOptions: SharedV4ProviderMetadata | undefined,
 ): AnthropicToolCallCaller | undefined {

package/src/tool/computer-toolset_20260801.ts

@@ -0,0 +1,165 @@
+import {
+  createProviderDefinedToolFactory,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+/**
+ * Member tools of the computer toolset. Each member is returned by the API as
+ * its own `tool_use` block; the AI SDK exposes it as the `action` of a single
+ * computer tool call.
+ */
+export const computerToolset_20260801Members = [
+  'screenshot',
+  'zoom',
+  'left_click',
+  'right_click',
+  'middle_click',
+  'double_click',
+  'triple_click',
+  'left_click_drag',
+  'mouse_move',
+  'left_mouse_down',
+  'left_mouse_up',
+  'cursor_position',
+  'scroll',
+  'type',
+  'key',
+  'hold_key',
+  'wait',
+] as const;
+
+export type ComputerToolset_20260801Member =
+  (typeof computerToolset_20260801Members)[number];
+
+const computerToolset_20260801InputSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      action: z.enum(computerToolset_20260801Members),
+      coordinate: z.tuple([z.number().int(), z.number().int()]).optional(),
+      duration: z.number().optional(),
+      region: z
+        .tuple([
+          z.number().int(),
+          z.number().int(),
+          z.number().int(),
+          z.number().int(),
+        ])
+        .optional(),
+      repeat: z.number().int().optional(),
+      scroll_amount: z.number().optional(),
+      scroll_direction: z.enum(['up', 'down', 'left', 'right']).optional(),
+      start_coordinate: z
+        .tuple([z.number().int(), z.number().int()])
+        .optional(),
+      text: z.string().optional(),
+    }),
+  ),
+);
+
+export const computerToolset_20260801ArgsSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      configs: z
+        .partialRecord(
+          z.enum(computerToolset_20260801Members),
+          z.object({
+            enabled: z.boolean().optional(),
+            deferLoading: z.boolean().optional(),
+          }),
+        )
+        .optional(),
+    }),
+  ),
+);
+
+export const computerToolset_20260801 = createProviderDefinedToolFactory<
+  {
+    /**
+     * The member tool that Claude invoked. Each member is returned by the API
+     * as a separate `tool_use` block; the AI SDK maps it to the `action`.
+     *
+     * - `screenshot`: Capture the full display as an image.
+     * - `zoom`: Capture a `region` of the screen at full resolution.
+     * - `left_click`, `right_click`, `middle_click`, `double_click`, `triple_click`: Click at `coordinate`. `text` may hold modifier keys to hold while clicking.
+     * - `left_click_drag`: Drag from `start_coordinate` to `coordinate`.
+     * - `mouse_move`: Move the cursor to `coordinate` without clicking.
+     * - `left_mouse_down`, `left_mouse_up`: Press or release the left mouse button at the current position.
+     * - `cursor_position`: Report the current cursor position as text.
+     * - `scroll`: Scroll `scroll_amount` clicks in `scroll_direction` at `coordinate`.
+     * - `type`: Type the literal `text`.
+     * - `key`: Press a key or key combination (`text`), optionally `repeat` times.
+     * - `hold_key`: Hold a key or key combination (`text`) for `duration` seconds.
+     * - `wait`: Pause for `duration` seconds.
+     */
+    action: ComputerToolset_20260801Member;
+
+    /**
+     * (x, y): Pixel coordinates in the space of the screenshots you return.
+     */
+    coordinate?: [number, number];
+
+    /**
+     * Duration in seconds. Used by `hold_key` and `wait`.
+     */
+    duration?: number;
+
+    /**
+     * [x1, y1, x2, y2]: The region to zoom into. Used by `zoom`.
+     */
+    region?: [number, number, number, number];
+
+    /**
+     * How many times to press the key. Used by `key`.
+     */
+    repeat?: number;
+
+    /**
+     * The number of scroll wheel clicks. Used by `scroll`.
+     */
+    scroll_amount?: number;
+
+    /**
+     * The direction to scroll. Used by `scroll`.
+     */
+    scroll_direction?: 'up' | 'down' | 'left' | 'right';
+
+    /**
+     * (x, y): Where a drag starts. Used by `left_click_drag`.
+     */
+    start_coordinate?: [number, number];
+
+    /**
+     * Text to type, a key combination to press or hold, or modifier keys to
+     * hold during click and scroll actions.
+     */
+    text?: string;
+  },
+  {
+    /**
+     * Per-member configuration. Members you omit keep their defaults
+     * (all members enabled, including `zoom`).
+     */
+    configs?: Partial<
+      Record<
+        ComputerToolset_20260801Member,
+        {
+          /**
+           * Whether Claude can use this member tool. Default: true.
+           */
+          enabled?: boolean;
+
+          /**
+           * Whether this member tool is only loaded once discovered through
+           * tool search. Default: false.
+           */
+          deferLoading?: boolean;
+        }
+      >
+    >;
+  }
+>({
+  id: 'anthropic.computer_toolset_20260801',
+  inputSchema: computerToolset_20260801InputSchema,
+});