@ai-sdk/anthropic 4.0.59 → 4.0.61

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'
@@ -700,6 +715,10 @@ export async function convertToAnthropicPrompt({
                   | undefined;
 
                 if (textMetadata?.type === 'compaction') {
+                  if (part.text === '') {
+                    break;
+                  }
+
                   anthropicContent.push({
                     type: 'compaction',
                     content: part.text,
@@ -902,6 +921,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,
@@ -1339,10 +1390,12 @@ export async function convertToAnthropicPrompt({
           }
         }
 
-        messages.push({
-          role: 'assistant',
-          content: moveToolUseBlocksToEnd(anthropicContent),
-        });
+        if (anthropicContent.length > 0) {
+          messages.push({
+            role: 'assistant',
+            content: moveToolUseBlocksToEnd(anthropicContent),
+          });
+        }
 
         break;
       }
@@ -1457,6 +1510,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,
+});