@ai-sdk/anthropic 3.0.46 → 3.0.48

package/docs/05-anthropic.mdx

@@ -282,19 +282,25 @@ const result = await generateText({
 console.log(result.providerMetadata?.anthropic?.contextManagement);
 ```
 
-#### Clear Tool Uses
+#### Context Editing
 
-The `clear_tool_uses_20250919` edit type removes old tool calls from the conversation history:
+Context editing strategies selectively remove specific content types from earlier in the conversation to reduce token usage without losing the overall conversation flow.
 
-- **trigger** - Condition that triggers the clearing (e.g., `{ type: 'input_tokens', value: 10000 }`)
+##### Clear Tool Uses
+
+The `clear_tool_uses_20250919` edit type removes old tool call/result pairs from the conversation history:
+
+- **trigger** - Condition that triggers the clearing (e.g., `{ type: 'input_tokens', value: 10000 }` or `{ type: 'tool_uses', value: 10 }`)
 - **keep** - How many recent tool uses to preserve (e.g., `{ type: 'tool_uses', value: 5 }`)
 - **clearAtLeast** - Minimum amount to clear (e.g., `{ type: 'input_tokens', value: 1000 }`)
 - **clearToolInputs** - Whether to clear tool input parameters (boolean)
 - **excludeTools** - Array of tool names to never clear
 
-#### Clear Thinking
+##### Clear Thinking
 
-The `clear_thinking_20251015` edit type removes thinking/reasoning content:
+The `clear_thinking_20251015` edit type removes thinking/reasoning blocks from earlier turns, keeping only the most recent ones:
+
+- **keep** - How many recent thinking turns to preserve (e.g., `{ type: 'thinking_turns', value: 2 }`) or `'all'` to keep everything
 
 ```ts
 const result = await generateText({
@@ -425,7 +431,6 @@ if (metadata?.appliedEdits) {
       console.log(`Freed ${edit.clearedInputTokens} tokens`);
     } else if (edit.type === 'compact_20260112') {
       console.log('Compaction was applied');
-      console.log(`Freed ${edit.clearedInputTokens} tokens`);
     }
   });
 }
@@ -1031,7 +1036,7 @@ You can enable code execution using the provider-defined code execution tool:
 import { anthropic } from '@ai-sdk/anthropic';
 import { generateText } from 'ai';
 
-const codeExecutionTool = anthropic.tools.codeExecution_20250825();
+const codeExecutionTool = anthropic.tools.codeExecution_20260120();
 
 const result = await generateText({
   model: anthropic('claude-opus-4-20250514'),
@@ -1044,9 +1049,10 @@ const result = await generateText({
 ```
 
 <Note>
-  Two versions are available: `codeExecution_20250825` (recommended, supports
-  Python and Bash with enhanced file operations) and `codeExecution_20250522`
-  (supports Bash only).
+  Three versions are available: `codeExecution_20260120` (recommended, does not
+  require a beta header, supports Claude Opus 4.6, Sonnet 4.6, Sonnet 4.5, and
+  Opus 4.5), `codeExecution_20250825` (supports Python and Bash with enhanced
+  file operations), and `codeExecution_20250522` (supports Bash only).
 </Note>
 
 #### Error Handling
@@ -1117,7 +1123,7 @@ const result = await generateText({
   prompt:
     'Get the weather for Tokyo, Sydney, and London, then calculate the average temperature.',
   tools: {
-    code_execution: anthropic.tools.codeExecution_20250825(),
+    code_execution: anthropic.tools.codeExecution_20260120(),
 
     getWeather: tool({
       description: 'Get current weather data for a city.',
@@ -1131,7 +1137,7 @@ const result = await generateText({
       // Enable this tool to be called from within code execution
       providerOptions: {
         anthropic: {
-          allowedCallers: ['code_execution_20250825'],
+          allowedCallers: ['code_execution_20260120'],
         },
       },
     }),
@@ -1151,7 +1157,7 @@ In this flow:
 <Note>
   Programmatic tool calling requires `claude-sonnet-4-6`, `claude-sonnet-4-5`,
   `claude-opus-4-6`, or `claude-opus-4-5` models and uses the
-  `code_execution_20250825` tool.
+  `code_execution_20260120` or `code_execution_20250825` tool.
 </Note>
 
 #### Container Persistence
@@ -1183,7 +1189,7 @@ import { generateText } from 'ai';
 const result = await generateText({
   model: anthropic('claude-sonnet-4-5'),
   tools: {
-    code_execution: anthropic.tools.codeExecution_20250825(),
+    code_execution: anthropic.tools.codeExecution_20260120(),
   },
   prompt: 'Create a presentation about renewable energy with 5 slides',
   providerOptions: {
@@ -1210,7 +1216,7 @@ You can also use custom skills by specifying `type: 'custom'`:
 const result = await generateText({
   model: anthropic('claude-sonnet-4-5'),
   tools: {
-    code_execution: anthropic.tools.codeExecution_20250825(),
+    code_execution: anthropic.tools.codeExecution_20260120(),
   },
   prompt: 'Use my custom skill to process this data',
   providerOptions: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/anthropic",
-  "version": "3.0.46",
+  "version": "3.0.48",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",

package/src/anthropic-messages-api.ts

@@ -113,6 +113,10 @@ export type AnthropicToolCallCaller =
       type: 'code_execution_20250825';
       tool_id: string;
     }
+  | {
+      type: 'code_execution_20260120';
+      tool_id: string;
+    }
   | {
       type: 'direct';
     };
@@ -354,7 +358,9 @@ export type AnthropicTool =
        *
        * @example ['code_execution_20250825']
        */
-      allowed_callers?: Array<'code_execution_20250825'>;
+      allowed_callers?: Array<
+        'direct' | 'code_execution_20250825' | 'code_execution_20260120'
+      >;
     }
   | {
       type: 'code_execution_20250522';
@@ -365,6 +371,10 @@ export type AnthropicTool =
       type: 'code_execution_20250825';
       name: string;
     }
+  | {
+      type: 'code_execution_20260120';
+      name: string;
+    }
   | {
       name: string;
       type: 'computer_20250124' | 'computer_20241022';
@@ -597,6 +607,10 @@ export const anthropicMessagesResponseSchema = lazySchema(() =>
                   type: z.literal('code_execution_20250825'),
                   tool_id: z.string(),
                 }),
+                z.object({
+                  type: z.literal('code_execution_20260120'),
+                  tool_id: z.string(),
+                }),
                 z.object({
                   type: z.literal('direct'),
                 }),
@@ -870,6 +884,10 @@ export const anthropicMessagesChunkSchema = lazySchema(() =>
                         type: z.literal('code_execution_20250825'),
                         tool_id: z.string(),
                       }),
+                      z.object({
+                        type: z.literal('code_execution_20260120'),
+                        tool_id: z.string(),
+                      }),
                       z.object({
                         type: z.literal('direct'),
                       }),
@@ -913,6 +931,10 @@ export const anthropicMessagesChunkSchema = lazySchema(() =>
                   type: z.literal('code_execution_20250825'),
                   tool_id: z.string(),
                 }),
+                z.object({
+                  type: z.literal('code_execution_20260120'),
+                  tool_id: z.string(),
+                }),
                 z.object({
                   type: z.literal('direct'),
                 }),

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

@@ -294,6 +294,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
       providerToolNames: {
         'anthropic.code_execution_20250522': 'code_execution',
         'anthropic.code_execution_20250825': 'code_execution',
+        'anthropic.code_execution_20260120': 'code_execution',
         'anthropic.computer_20241022': 'computer',
         'anthropic.computer_20250124': 'computer',
         'anthropic.text_editor_20241022': 'str_replace_editor',
@@ -353,6 +354,9 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
       ...(anthropicOptions?.speed && {
         speed: anthropicOptions.speed,
       }),
+      ...(anthropicOptions?.cacheControl && {
+        cache_control: anthropicOptions.cacheControl,
+      }),
 
       // structured output:
       ...(useStructuredOutput &&
@@ -562,7 +566,8 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
         !tools?.some(
           tool =>
             tool.type === 'provider' &&
-            tool.id === 'anthropic.code_execution_20250825',
+            (tool.id === 'anthropic.code_execution_20250825' ||
+              tool.id === 'anthropic.code_execution_20260120'),
         )
       ) {
         warnings.push({
@@ -1241,7 +1246,10 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
           firstDelta: boolean;
           providerToolName?: string;
           caller?: {
-            type: 'code_execution_20250825' | 'direct';
+            type:
+              | 'code_execution_20250825'
+              | 'code_execution_20260120'
+              | 'direct';
             toolId?: string;
           };
         }

package/src/anthropic-prepare-tools.ts

@@ -12,7 +12,9 @@ import { validateTypes } from '@ai-sdk/provider-utils';
 
 export interface AnthropicToolOptions {
   deferLoading?: boolean;
-  allowedCallers?: Array<'code_execution_20250825'>;
+  allowedCallers?: Array<
+    'direct' | 'code_execution_20250825' | 'code_execution_20260120'
+  >;
 }
 
 export async function prepareTools({
@@ -119,6 +121,13 @@ export async function prepareTools({
             });
             break;
           }
+          case 'anthropic.code_execution_20260120': {
+            anthropicTools.push({
+              type: 'code_execution_20260120',
+              name: 'code_execution',
+            });
+            break;
+          }
           case 'anthropic.computer_20250124': {
             betas.add('computer-use-2025-01-24');
             anthropicTools.push({

package/src/anthropic-tools.ts

@@ -2,6 +2,7 @@ import { bash_20241022 } from './tool/bash_20241022';
 import { bash_20250124 } from './tool/bash_20250124';
 import { codeExecution_20250522 } from './tool/code-execution_20250522';
 import { codeExecution_20250825 } from './tool/code-execution_20250825';
+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';
@@ -54,6 +55,20 @@ export const anthropicTools = {
    */
   codeExecution_20250825,
 
+  /**
+   * Claude can analyze data, create visualizations, perform complex calculations,
+   * run system commands, create and edit files, and process uploaded files directly within
+   * the API conversation.
+   *
+   * The code execution tool allows Claude to run both Python and Bash commands and manipulate files,
+   * including writing code, in a secure, sandboxed environment.
+   *
+   * This is the recommended version. Does not require a beta header.
+   *
+   * Supported models: Claude Opus 4.6, Sonnet 4.6, Sonnet 4.5, Opus 4.5
+   */
+  codeExecution_20260120,
+
   /**
    * Claude can interact with computer environments through the computer use tool, which
    * provides screenshot capabilities and mouse/keyboard control for autonomous desktop interaction.

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

@@ -648,10 +648,14 @@ export async function convertToAnthropicMessagesPrompt({
                   | { caller?: { type: string; toolId?: string } }
                   | undefined;
                 const caller = callerOptions?.caller
-                  ? callerOptions.caller.type === 'code_execution_20250825' &&
+                  ? (callerOptions.caller.type === 'code_execution_20250825' ||
+                      callerOptions.caller.type ===
+                        'code_execution_20260120') &&
                     callerOptions.caller.toolId
                     ? {
-                        type: 'code_execution_20250825' as const,
+                        type: callerOptions.caller.type as
+                          | 'code_execution_20250825'
+                          | 'code_execution_20260120',
                         tool_id: callerOptions.caller.toolId,
                       }
                     : callerOptions.caller.type === 'direct'

package/src/tool/code-execution_20260120.ts

@@ -0,0 +1,277 @@
+import {
+  createProviderToolFactoryWithOutputSchema,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export const codeExecution_20260120OutputSchema = lazySchema(() =>
+  zodSchema(
+    z.discriminatedUnion('type', [
+      z.object({
+        type: z.literal('code_execution_result'),
+        stdout: z.string(),
+        stderr: z.string(),
+        return_code: z.number(),
+        content: z
+          .array(
+            z.object({
+              type: z.literal('code_execution_output'),
+              file_id: z.string(),
+            }),
+          )
+          .optional()
+          .default([]),
+      }),
+      z.object({
+        type: z.literal('bash_code_execution_result'),
+        content: z.array(
+          z.object({
+            type: z.literal('bash_code_execution_output'),
+            file_id: z.string(),
+          }),
+        ),
+        stdout: z.string(),
+        stderr: z.string(),
+        return_code: z.number(),
+      }),
+      z.object({
+        type: z.literal('bash_code_execution_tool_result_error'),
+        error_code: z.string(),
+      }),
+      z.object({
+        type: z.literal('text_editor_code_execution_tool_result_error'),
+        error_code: z.string(),
+      }),
+      z.object({
+        type: z.literal('text_editor_code_execution_view_result'),
+        content: z.string(),
+        file_type: z.string(),
+        num_lines: z.number().nullable(),
+        start_line: z.number().nullable(),
+        total_lines: z.number().nullable(),
+      }),
+      z.object({
+        type: z.literal('text_editor_code_execution_create_result'),
+        is_file_update: z.boolean(),
+      }),
+      z.object({
+        type: z.literal('text_editor_code_execution_str_replace_result'),
+        lines: z.array(z.string()).nullable(),
+        new_lines: z.number().nullable(),
+        new_start: z.number().nullable(),
+        old_lines: z.number().nullable(),
+        old_start: z.number().nullable(),
+      }),
+    ]),
+  ),
+);
+
+export const codeExecution_20260120InputSchema = lazySchema(() =>
+  zodSchema(
+    z.discriminatedUnion('type', [
+      z.object({
+        type: z.literal('programmatic-tool-call'),
+        code: z.string(),
+      }),
+      z.object({
+        type: z.literal('bash_code_execution'),
+        command: z.string(),
+      }),
+      z.discriminatedUnion('command', [
+        z.object({
+          type: z.literal('text_editor_code_execution'),
+          command: z.literal('view'),
+          path: z.string(),
+        }),
+        z.object({
+          type: z.literal('text_editor_code_execution'),
+          command: z.literal('create'),
+          path: z.string(),
+          file_text: z.string().nullish(),
+        }),
+        z.object({
+          type: z.literal('text_editor_code_execution'),
+          command: z.literal('str_replace'),
+          path: z.string(),
+          old_str: z.string(),
+          new_str: z.string(),
+        }),
+      ]),
+    ]),
+  ),
+);
+
+const factory = createProviderToolFactoryWithOutputSchema<
+  | {
+      type: 'programmatic-tool-call';
+      /**
+       * Programmatic tool calling: Python code to execute when code_execution
+       * is used with allowedCallers to trigger client-executed tools.
+       */
+      code: string;
+    }
+  | {
+      type: 'bash_code_execution';
+
+      /**
+       * Shell command to execute.
+       */
+      command: string;
+    }
+  | {
+      type: 'text_editor_code_execution';
+      command: 'view';
+
+      /**
+       * The path to the file to view.
+       */
+      path: string;
+    }
+  | {
+      type: 'text_editor_code_execution';
+      command: 'create';
+
+      /**
+       * The path to the file to edit.
+       */
+      path: string;
+
+      /**
+       * The text of the file to edit.
+       */
+      file_text?: string | null;
+    }
+  | {
+      type: 'text_editor_code_execution';
+      command: 'str_replace';
+
+      /**
+       * The path to the file to edit.
+       */
+      path: string;
+
+      /**
+       * The string to replace.
+       */
+      old_str: string;
+
+      /**
+       * The new string to replace the old string with.
+       */
+      new_str: string;
+    },
+  | {
+      /**
+       * Programmatic tool calling result: returned when code_execution runs code
+       * that calls client-executed tools via allowedCallers.
+       */
+      type: 'code_execution_result';
+
+      /**
+       * Output from successful execution
+       */
+      stdout: string;
+
+      /**
+       * Error messages if execution fails
+       */
+      stderr: string;
+
+      /**
+       * 0 for success, non-zero for failure
+       */
+      return_code: number;
+
+      /**
+       * Output file Id list
+       */
+      content: Array<{ type: 'code_execution_output'; file_id: string }>;
+    }
+  | {
+      type: 'bash_code_execution_result';
+
+      /**
+       * Output file Id list
+       */
+      content: Array<{
+        type: 'bash_code_execution_output';
+        file_id: string;
+      }>;
+
+      /**
+       * Output from successful execution
+       */
+      stdout: string;
+
+      /**
+       * Error messages if execution fails
+       */
+      stderr: string;
+
+      /**
+       * 0 for success, non-zero for failure
+       */
+      return_code: number;
+    }
+  | {
+      type: 'bash_code_execution_tool_result_error';
+
+      /**
+       * Available options: invalid_tool_input, unavailable, too_many_requests,
+       * execution_time_exceeded, output_file_too_large.
+       */
+      error_code: string;
+    }
+  | {
+      type: 'text_editor_code_execution_tool_result_error';
+
+      /**
+       * Available options: invalid_tool_input, unavailable, too_many_requests,
+       * execution_time_exceeded, file_not_found.
+       */
+      error_code: string;
+    }
+  | {
+      type: 'text_editor_code_execution_view_result';
+
+      content: string;
+
+      /**
+       * The type of the file. Available options: text, image, pdf.
+       */
+      file_type: string;
+
+      num_lines: number | null;
+      start_line: number | null;
+      total_lines: number | null;
+    }
+  | {
+      type: 'text_editor_code_execution_create_result';
+
+      is_file_update: boolean;
+    }
+  | {
+      type: 'text_editor_code_execution_str_replace_result';
+
+      lines: string[] | null;
+      new_lines: number | null;
+      new_start: number | null;
+      old_lines: number | null;
+      old_start: number | null;
+    },
+  {
+    // no arguments
+  }
+>({
+  id: 'anthropic.code_execution_20260120',
+  inputSchema: codeExecution_20260120InputSchema,
+  outputSchema: codeExecution_20260120OutputSchema,
+  supportsDeferredResults: true,
+});
+
+export const codeExecution_20260120 = (
+  args: Parameters<typeof factory>[0] = {},
+) => {
+  return factory(args);
+};