@ai-sdk/anthropic 3.0.53 → 3.0.55

package/package.json

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

package/src/anthropic-messages-api.ts

@@ -238,6 +238,13 @@ export interface AnthropicCodeExecutionToolResultContent {
         return_code: number;
         content: Array<{ type: 'code_execution_output'; file_id: string }>;
       }
+    | {
+        type: 'encrypted_code_execution_result';
+        encrypted_stdout: string;
+        stderr: string;
+        return_code: number;
+        content: Array<{ type: 'code_execution_output'; file_id: string }>;
+      }
     | {
         type: 'code_execution_tool_result_error';
         error_code: string;
@@ -416,7 +423,7 @@ export type AnthropicTool =
       type: 'memory_20250818';
     }
   | {
-      type: 'web_fetch_20250910';
+      type: 'web_fetch_20250910' | 'web_fetch_20260209';
       name: string;
       max_uses?: number;
       allowed_domains?: string[];
@@ -426,7 +433,7 @@ export type AnthropicTool =
       cache_control: AnthropicCacheControl | undefined;
     }
   | {
-      type: 'web_search_20250305';
+      type: 'web_search_20250305' | 'web_search_20260209';
       name: string;
       max_uses?: number;
       allowed_domains?: string[];
@@ -622,6 +629,17 @@ export const anthropicMessagesResponseSchema = lazySchema(() =>
             id: z.string(),
             name: z.string(),
             input: z.record(z.string(), z.unknown()).nullish(),
+            caller: z
+              .union([
+                z.object({
+                  type: z.literal('code_execution_20260120'),
+                  tool_id: z.string(),
+                }),
+                z.object({
+                  type: z.literal('direct'),
+                }),
+              ])
+              .optional(),
           }),
           z.object({
             type: z.literal('mcp_tool_use'),
@@ -712,6 +730,21 @@ export const anthropicMessagesResponseSchema = lazySchema(() =>
                   .optional()
                   .default([]),
               }),
+              z.object({
+                type: z.literal('encrypted_code_execution_result'),
+                encrypted_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('code_execution_tool_result_error'),
                 error_code: z.string(),
@@ -954,6 +987,17 @@ export const anthropicMessagesChunkSchema = lazySchema(() =>
             id: z.string(),
             name: z.string(),
             input: z.record(z.string(), z.unknown()).nullish(),
+            caller: z
+              .union([
+                z.object({
+                  type: z.literal('code_execution_20260120'),
+                  tool_id: z.string(),
+                }),
+                z.object({
+                  type: z.literal('direct'),
+                }),
+              ])
+              .optional(),
           }),
           z.object({
             type: z.literal('mcp_tool_use'),
@@ -1044,6 +1088,21 @@ export const anthropicMessagesChunkSchema = lazySchema(() =>
                   .optional()
                   .default([]),
               }),
+              z.object({
+                type: z.literal('encrypted_code_execution_result'),
+                encrypted_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('code_execution_tool_result_error'),
                 error_code: z.string(),

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

@@ -37,6 +37,7 @@ import {
   anthropicMessagesResponseSchema,
   AnthropicReasoningMetadata,
   AnthropicResponseContextManagement,
+  AnthropicTool,
   Citation,
 } from './anthropic-messages-api';
 import {
@@ -305,7 +306,9 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
         'anthropic.bash_20250124': 'bash',
         'anthropic.memory_20250818': 'memory',
         'anthropic.web_search_20250305': 'web_search',
+        'anthropic.web_search_20260209': 'web_search',
         'anthropic.web_fetch_20250910': 'web_fetch',
+        'anthropic.web_fetch_20260209': 'web_fetch',
         'anthropic.tool_search_regex_20251119': 'tool_search_tool_regex',
         'anthropic.tool_search_bm25_20251119': 'tool_search_tool_bm25',
       },
@@ -745,6 +748,10 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
       ...this.extractCitationDocuments(options.prompt),
     ];
 
+    const markCodeExecutionDynamic = hasWebTool20260209WithoutCodeExecution(
+      args.tools,
+    );
+
     const {
       responseHeaders,
       value: response,
@@ -898,6 +905,11 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
               toolName: toolNameMapping.toCustomToolName(part.name),
               input: JSON.stringify(inputToSerialize),
               providerExecuted: true,
+              // We want this 'code_execution' tool call to be allowed even if the tool is not explicitly provided.
+              // Since the validation generally bypasses dynamic tools, we mark this specific tool as dynamic.
+              ...(markCodeExecutionDynamic && part.name === 'code_execution'
+                ? { dynamic: true }
+                : {}),
             });
           } else if (
             part.name === 'tool_search_tool_regex' ||
@@ -1044,6 +1056,19 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
                 content: part.content.content ?? [],
               },
             });
+          } else if (part.content.type === 'encrypted_code_execution_result') {
+            content.push({
+              type: 'tool-result',
+              toolCallId: part.tool_use_id,
+              toolName: toolNameMapping.toCustomToolName('code_execution'),
+              result: {
+                type: part.content.type,
+                encrypted_stdout: part.content.encrypted_stdout,
+                stderr: part.content.stderr,
+                return_code: part.content.return_code,
+                content: part.content.content ?? [],
+              },
+            });
           } else if (part.content.type === 'code_execution_tool_result_error') {
             content.push({
               type: 'tool-result',
@@ -1204,6 +1229,10 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
       ...this.extractCitationDocuments(options.prompt),
     ];
 
+    const markCodeExecutionDynamic = hasWebTool20260209WithoutCodeExecution(
+      body.tools,
+    );
+
     const url = this.buildRequestUrl(true);
     const { responseHeaders, value: response } = await postJsonToApi({
       url,
@@ -1438,12 +1467,26 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
                     const customToolName =
                       toolNameMapping.toCustomToolName(providerToolName);
 
+                    // Tools like 'web_fetch_20260209' provide input data here.
+                    // Other tools like 'code_execution_20260120' provide input data via deltas.
+                    // So we only use this if it's non-empty to avoid conflicts.
+                    const finalInput =
+                      part.input != null &&
+                      typeof part.input === 'object' &&
+                      Object.keys(part.input).length > 0
+                        ? JSON.stringify(part.input)
+                        : '';
+
                     contentBlocks[value.index] = {
                       type: 'tool-call',
                       toolCallId: part.id,
                       toolName: customToolName,
-                      input: '',
+                      input: finalInput,
                       providerExecuted: true,
+                      ...(markCodeExecutionDynamic &&
+                      providerToolName === 'code_execution'
+                        ? { dynamic: true }
+                        : {}),
                       firstDelta: true,
                       providerToolName: part.name,
                     };
@@ -1453,6 +1496,10 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
                       id: part.id,
                       toolName: customToolName,
                       providerExecuted: true,
+                      ...(markCodeExecutionDynamic &&
+                      providerToolName === 'code_execution'
+                        ? { dynamic: true }
+                        : {}),
                     });
                   } else if (
                     part.name === 'tool_search_tool_regex' ||
@@ -1588,6 +1635,22 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
                         content: part.content.content ?? [],
                       },
                     });
+                  } else if (
+                    part.content.type === 'encrypted_code_execution_result'
+                  ) {
+                    controller.enqueue({
+                      type: 'tool-result',
+                      toolCallId: part.tool_use_id,
+                      toolName:
+                        toolNameMapping.toCustomToolName('code_execution'),
+                      result: {
+                        type: part.content.type,
+                        encrypted_stdout: part.content.encrypted_stdout,
+                        stderr: part.content.stderr,
+                        return_code: part.content.return_code,
+                        content: part.content.content ?? [],
+                      },
+                    });
                   } else if (
                     part.content.type === 'code_execution_tool_result_error'
                   ) {
@@ -1773,6 +1836,10 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
                         toolName: contentBlock.toolName,
                         input: finalInput,
                         providerExecuted: contentBlock.providerExecuted,
+                        ...(markCodeExecutionDynamic &&
+                        contentBlock.providerToolName === 'code_execution'
+                          ? { dynamic: true }
+                          : {}),
                         ...(contentBlock.caller && {
                           providerMetadata: {
                             anthropic: {
@@ -2238,6 +2305,31 @@ function getModelCapabilities(modelId: string): {
   }
 }
 
+function hasWebTool20260209WithoutCodeExecution(
+  tools: AnthropicTool[] | undefined,
+): boolean {
+  if (!tools) {
+    return false;
+  }
+  let hasWebTool20260209 = false;
+  let hasCodeExecutionTool = false;
+  for (const tool of tools) {
+    if (
+      'type' in tool &&
+      (tool.type === 'web_fetch_20260209' ||
+        tool.type === 'web_search_20260209')
+    ) {
+      hasWebTool20260209 = true;
+      continue;
+    }
+    if (tool.name === 'code_execution') {
+      hasCodeExecutionTool = true;
+      break;
+    }
+  }
+  return hasWebTool20260209 && !hasCodeExecutionTool;
+}
+
 function mapAnthropicResponseContextManagement(
   contextManagement: AnthropicResponseContextManagement | null | undefined,
 ): AnthropicMessageMetadata['contextManagement'] | null {

package/src/anthropic-prepare-tools.ts

@@ -6,7 +6,9 @@ import {
 import { AnthropicTool, AnthropicToolChoice } from './anthropic-messages-api';
 import { CacheControlValidator } from './get-cache-control';
 import { textEditor_20250728ArgsSchema } from './tool/text-editor_20250728';
+import { webSearch_20260209ArgsSchema } from './tool/web-search_20260209';
 import { webSearch_20250305ArgsSchema } from './tool/web-search_20250305';
+import { webFetch_20260209ArgsSchema } from './tool/web-fetch-20260209';
 import { webFetch_20250910ArgsSchema } from './tool/web-fetch-20250910';
 import { validateTypes } from '@ai-sdk/provider-utils';
 
@@ -249,6 +251,24 @@ export async function prepareTools({
             });
             break;
           }
+          case 'anthropic.web_fetch_20260209': {
+            betas.add('code-execution-web-tools-2026-02-09');
+            const args = await validateTypes({
+              value: tool.args,
+              schema: webFetch_20260209ArgsSchema,
+            });
+            anthropicTools.push({
+              type: 'web_fetch_20260209',
+              name: 'web_fetch',
+              max_uses: args.maxUses,
+              allowed_domains: args.allowedDomains,
+              blocked_domains: args.blockedDomains,
+              citations: args.citations,
+              max_content_tokens: args.maxContentTokens,
+              cache_control: undefined,
+            });
+            break;
+          }
           case 'anthropic.web_search_20250305': {
             const args = await validateTypes({
               value: tool.args,
@@ -265,6 +285,23 @@ export async function prepareTools({
             });
             break;
           }
+          case 'anthropic.web_search_20260209': {
+            betas.add('code-execution-web-tools-2026-02-09');
+            const args = await validateTypes({
+              value: tool.args,
+              schema: webSearch_20260209ArgsSchema,
+            });
+            anthropicTools.push({
+              type: 'web_search_20260209',
+              name: 'web_search',
+              max_uses: args.maxUses,
+              allowed_domains: args.allowedDomains,
+              blocked_domains: args.blockedDomains,
+              user_location: args.userLocation,
+              cache_control: undefined,
+            });
+            break;
+          }
 
           case 'anthropic.tool_search_regex_20251119': {
             betas.add('advanced-tool-use-2025-11-20');

package/src/anthropic-tools.ts

@@ -13,7 +13,9 @@ import { textEditor_20250429 } from './tool/text-editor_20250429';
 import { textEditor_20250728 } from './tool/text-editor_20250728';
 import { toolSearchBm25_20251119 } from './tool/tool-search-bm25_20251119';
 import { toolSearchRegex_20251119 } from './tool/tool-search-regex_20251119';
+import { webFetch_20260209 } from './tool/web-fetch-20260209';
 import { webFetch_20250910 } from './tool/web-fetch-20250910';
+import { webSearch_20260209 } from './tool/web-search_20260209';
 import { webSearch_20250305 } from './tool/web-search_20250305';
 
 export const anthropicTools = {
@@ -173,6 +175,17 @@ export const anthropicTools = {
    */
   webFetch_20250910,
 
+  /**
+   * Creates a web fetch tool that gives Claude direct access to real-time web content.
+   *
+   * @param maxUses - The max_uses parameter limits the number of web fetches performed
+   * @param allowedDomains - Only fetch from these domains
+   * @param blockedDomains - Never fetch from these domains
+   * @param citations - Unlike web search where citations are always enabled, citations are optional for web fetch. Set "citations": {"enabled": true} to enable Claude to cite specific passages from fetched documents.
+   * @param maxContentTokens - The max_content_tokens parameter limits the amount of content that will be included in the context.
+   */
+  webFetch_20260209,
+
   /**
    * Creates a web search tool that gives Claude direct access to real-time web content.
    *
@@ -183,6 +196,16 @@ export const anthropicTools = {
    */
   webSearch_20250305,
 
+  /**
+   * Creates a web search tool that gives Claude direct access to real-time web content.
+   *
+   * @param maxUses - Maximum number of web searches Claude can perform during the conversation.
+   * @param allowedDomains - Optional list of domains that Claude is allowed to search.
+   * @param blockedDomains - Optional list of domains that Claude should avoid when searching.
+   * @param userLocation - Optional user location information to provide geographically relevant search results.
+   */
+  webSearch_20260209,
+
   /**
    * Creates a tool search tool that uses regex patterns to find tools.
    *

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

@@ -26,6 +26,7 @@ import { anthropicFilePartProviderOptions } from './anthropic-messages-options';
 import { CacheControlValidator } from './get-cache-control';
 import { codeExecution_20250522OutputSchema } from './tool/code-execution_20250522';
 import { codeExecution_20250825OutputSchema } from './tool/code-execution_20250825';
+import { codeExecution_20260120OutputSchema } from './tool/code-execution_20260120';
 import { toolSearchRegex_20251119OutputSchema as toolSearchOutputSchema } from './tool/tool-search-regex_20251119';
 import { webFetch_20250910OutputSchema } from './tool/web-fetch-20250910';
 import { webSearch_20250305OutputSchema } from './tool/web-search_20250305';
@@ -767,8 +768,9 @@ export async function convertToAnthropicMessagesPrompt({
                     break;
                   }
 
-                  // to distinguish between code execution 20250522 and 20250825,
-                  // we check if a type property is present in the output.value
+                  // to distinguish between code execution 20250522, 20250825,
+                  // and encrypted results (from web_fetch_20260209/web_search_20260209 injection),
+                  // we check the type property in output.value
                   if (output.value.type === 'code_execution_result') {
                     // code execution 20250522
                     const codeExecutionOutput = await validateTypes({
@@ -788,6 +790,33 @@ export async function convertToAnthropicMessagesPrompt({
                       },
                       cache_control: cacheControl,
                     });
+                  } else if (
+                    output.value.type === 'encrypted_code_execution_result'
+                  ) {
+                    // code execution 20260120 encrypted result
+                    const codeExecutionOutput = await validateTypes({
+                      value: output.value,
+                      schema: codeExecution_20260120OutputSchema,
+                    });
+
+                    if (
+                      codeExecutionOutput.type ===
+                      'encrypted_code_execution_result'
+                    ) {
+                      anthropicContent.push({
+                        type: 'code_execution_tool_result',
+                        tool_use_id: part.toolCallId,
+                        content: {
+                          type: codeExecutionOutput.type,
+                          encrypted_stdout:
+                            codeExecutionOutput.encrypted_stdout,
+                          stderr: codeExecutionOutput.stderr,
+                          return_code: codeExecutionOutput.return_code,
+                          content: codeExecutionOutput.content ?? [],
+                        },
+                        cache_control: cacheControl,
+                      });
+                    }
                   } else {
                     // code execution 20250825
                     const codeExecutionOutput = await validateTypes({
@@ -796,7 +825,6 @@ export async function convertToAnthropicMessagesPrompt({
                     });
 
                     if (codeExecutionOutput.type === 'code_execution_result') {
-                      // Programmatic tool calling result - same format as 20250522
                       anthropicContent.push({
                         type: 'code_execution_tool_result',
                         tool_use_id: part.toolCallId,
@@ -882,6 +910,9 @@ export async function convertToAnthropicMessagesPrompt({
                     break;
                   }
 
+                  // ideally we'd switch schema based on the tool version (e.g.
+                  // web_fetch_20260209 vs web_fetch_20250910), but since both
+                  // versions share an identical output schema, we use one here.
                   const webFetchOutput = await validateTypes({
                     value: output.value,
                     schema: webFetch_20250910OutputSchema,
@@ -926,6 +957,9 @@ export async function convertToAnthropicMessagesPrompt({
                     break;
                   }
 
+                  // ideally we'd switch schema based on the tool version (e.g.
+                  // web_search_20260209 vs web_search_20250305), but since both
+                  // versions share an identical output schema, we use one here.
                   const webSearchOutput = await validateTypes({
                     value: output.value,
                     schema: webSearch_20250305OutputSchema,

package/src/tool/code-execution_20260120.ts

@@ -23,6 +23,21 @@ export const codeExecution_20260120OutputSchema = lazySchema(() =>
           .optional()
           .default([]),
       }),
+      z.object({
+        type: z.literal('encrypted_code_execution_result'),
+        encrypted_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(
@@ -183,6 +198,29 @@ const factory = createProviderToolFactoryWithOutputSchema<
        */
       return_code: number;
 
+      /**
+       * Output file Id list
+       */
+      content: Array<{ type: 'code_execution_output'; file_id: string }>;
+    }
+  | {
+      type: 'encrypted_code_execution_result';
+
+      /**
+       * Encrypted output from successful execution
+       */
+      encrypted_stdout: string;
+
+      /**
+       * Error messages if execution fails
+       */
+      stderr: string;
+
+      /**
+       * 0 for success, non-zero for failure
+       */
+      return_code: number;
+
       /**
        * Output file Id list
        */

package/src/tool/web-fetch-20260209.ts

@@ -0,0 +1,145 @@
+import {
+  createProviderToolFactoryWithOutputSchema,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export const webFetch_20260209ArgsSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      maxUses: z.number().optional(),
+      allowedDomains: z.array(z.string()).optional(),
+      blockedDomains: z.array(z.string()).optional(),
+      citations: z.object({ enabled: z.boolean() }).optional(),
+      maxContentTokens: z.number().optional(),
+    }),
+  ),
+);
+
+export const webFetch_20260209OutputSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      type: z.literal('web_fetch_result'),
+      url: z.string(),
+      content: z.object({
+        type: z.literal('document'),
+        title: z.string().nullable(),
+        citations: z.object({ enabled: z.boolean() }).optional(),
+        source: z.union([
+          z.object({
+            type: z.literal('base64'),
+            mediaType: z.literal('application/pdf'),
+            data: z.string(),
+          }),
+          z.object({
+            type: z.literal('text'),
+            mediaType: z.literal('text/plain'),
+            data: z.string(),
+          }),
+        ]),
+      }),
+      retrievedAt: z.string().nullable(),
+    }),
+  ),
+);
+
+const webFetch_20260209InputSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      url: z.string(),
+    }),
+  ),
+);
+
+const factory = createProviderToolFactoryWithOutputSchema<
+  {
+    /**
+     * The URL to fetch.
+     */
+    url: string;
+  },
+  {
+    type: 'web_fetch_result';
+
+    /**
+     * Fetched content URL
+     */
+    url: string;
+
+    /**
+     * Fetched content.
+     */
+    content: {
+      type: 'document';
+
+      /**
+       * Title of the document
+       */
+      title: string | null;
+
+      /**
+       * Citation configuration for the document
+       */
+      citations?: { enabled: boolean };
+
+      source:
+        | {
+            type: 'base64';
+            mediaType: 'application/pdf';
+            data: string;
+          }
+        | {
+            type: 'text';
+            mediaType: 'text/plain';
+            data: string;
+          };
+    };
+
+    /**
+     * ISO 8601 timestamp when the content was retrieved
+     */
+    retrievedAt: string | null;
+  },
+  {
+    /**
+     * The maxUses parameter limits the number of web fetches performed
+     */
+    maxUses?: number;
+
+    /**
+     * Only fetch from these domains
+     */
+    allowedDomains?: string[];
+
+    /**
+     * Never fetch from these domains
+     */
+    blockedDomains?: string[];
+
+    /**
+     * Unlike web search where citations are always enabled, citations are optional for
+     * web fetch. Set "citations": {"enabled": true} to enable Claude to cite specific passages
+     * from fetched documents.
+     */
+    citations?: {
+      enabled: boolean;
+    };
+
+    /**
+     * The maxContentTokens parameter limits the amount of content that will be included in the context.
+     */
+    maxContentTokens?: number;
+  }
+>({
+  id: 'anthropic.web_fetch_20260209',
+  inputSchema: webFetch_20260209InputSchema,
+  outputSchema: webFetch_20260209OutputSchema,
+  supportsDeferredResults: true,
+});
+
+export const webFetch_20260209 = (
+  args: Parameters<typeof factory>[0] = {}, // default
+) => {
+  return factory(args);
+};