@ai-sdk/anthropic 4.0.53 → 4.0.55

package/docs/05-anthropic.mdx

@@ -1052,12 +1052,13 @@ You can enable web search using the provider-defined web search tool:
 import { anthropic } from '@ai-sdk/anthropic';
 import { generateText } from 'ai';
 
-const webSearchTool = anthropic.tools.webSearch_20250305({
+const webSearchTool = anthropic.tools.webSearch_20260318({
   maxUses: 5,
+  responseInclusion: 'excluded',
 });
 
 const result = await generateText({
-  model: anthropic('claude-opus-4-20250514'),
+  model: anthropic('claude-opus-5'),
   prompt: 'What are the latest developments in AI?',
   tools: {
     web_search: webSearchTool,
@@ -1072,6 +1073,10 @@ const result = await generateText({
 
 #### Configuration Options
 
+Use `webSearch_20260318` for dynamic filtering and response inclusion control.
+The older `webSearch_20260209` and `webSearch_20250305` versions remain
+available for applications that need their earlier behavior.
+
 The web search tool supports several configuration options:
 
 - **maxUses** _number_
@@ -1090,11 +1095,17 @@ The web search tool supports several configuration options:
 
   Optional user location information to provide geographically relevant search results.
 
+- **responseInclusion** _'full' | 'excluded'_
+
+  Available with `webSearch_20260318`. Controls whether search result blocks
+  consumed by a completed code execution call in the same turn are included in
+  the API response. The default is `'full'`. Use `'excluded'` to omit those
+  nested call/result pairs and reduce output token usage.
+
 ```ts
-const webSearchTool = anthropic.tools.webSearch_20250305({
+const webSearchTool = anthropic.tools.webSearch_20260318({
   maxUses: 3,
   allowedDomains: ['techcrunch.com', 'wired.com'],
-  blockedDomains: ['example-spam-site.com'],
   userLocation: {
     type: 'approximate',
     country: 'US',
@@ -1102,10 +1113,11 @@ const webSearchTool = anthropic.tools.webSearch_20250305({
     city: 'San Francisco',
     timezone: 'America/Los_Angeles',
   },
+  responseInclusion: 'excluded',
 });
 
 const result = await generateText({
-  model: anthropic('claude-opus-4-20250514'),
+  model: anthropic('claude-opus-5'),
   prompt: 'Find local news about technology',
   tools: {
     web_search: webSearchTool,
@@ -1113,6 +1125,13 @@ const result = await generateText({
 });
 ```
 
+<Note>
+  `responseInclusion: 'excluded'` only omits results consumed by code execution
+  calls that complete in the same turn. Results from direct calls and from code
+  execution calls that pause before completing are always returned in full so
+  they can be sent back on the next turn.
+</Note>
+
 ### Web Fetch Tool
 
 Anthropic provides a provider-defined web fetch tool that allows Claude to retrieve content from specific URLs. This is useful when you want Claude to analyze or reference content from a particular webpage or document.
@@ -1124,11 +1143,14 @@ import { anthropic } from '@ai-sdk/anthropic';
 import { generateText } from 'ai';
 
 const result = await generateText({
-  model: anthropic('claude-sonnet-4-0'),
+  model: anthropic('claude-opus-5'),
   prompt:
     'What is this page about? https://en.wikipedia.org/wiki/Maglemosian_culture',
   tools: {
-    web_fetch: anthropic.tools.webFetch_20250910({ maxUses: 1 }),
+    web_fetch: anthropic.tools.webFetch_20260318({
+      maxUses: 1,
+      responseInclusion: 'excluded',
+    }),
   },
 });
 ```
@@ -1473,6 +1495,19 @@ The web fetch tool supports several configuration options:
 
   The maxContentTokens parameter limits the amount of content that will be included in the context.
 
+- **useCache** _boolean_
+
+  Available with `webFetch_20260318`. Set to `false` to bypass cached content
+  and fetch fresh content. The default is `true`; disabling the cache can
+  increase latency.
+
+- **responseInclusion** _'full' | 'excluded'_
+
+  Available with `webFetch_20260318`. Controls whether fetch result blocks
+  consumed by a completed code execution call in the same turn are included in
+  the API response. The default is `'full'`. Direct results and results from
+  code execution calls that pause before completing are always returned in full.
+
 #### Error Handling
 
 Web search errors are handled differently depending on whether you're using streaming or non-streaming:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/anthropic",
-  "version": "4.0.53",
+  "version": "4.0.55",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -35,8 +35,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.14",
-    "@ai-sdk/provider-utils": "5.0.40"
+    "@ai-sdk/provider": "4.0.16",
+    "@ai-sdk/provider-utils": "5.0.42"
   },
   "devDependencies": {
     "@ai-sdk/test-server": "2.0.1",

package/src/anthropic-api.ts

@@ -508,17 +508,22 @@ export type AnthropicTool =
       type: 'memory_20250818';
     }
   | {
-      type: 'web_fetch_20250910' | 'web_fetch_20260209';
+      type: 'web_fetch_20250910' | 'web_fetch_20260209' | 'web_fetch_20260318';
       name: string;
       max_uses?: number;
       allowed_domains?: string[];
       blocked_domains?: string[];
       citations?: { enabled: boolean };
       max_content_tokens?: number;
+      use_cache?: boolean;
+      response_inclusion?: 'full' | 'excluded';
       cache_control: AnthropicCacheControl | undefined;
     }
   | {
-      type: 'web_search_20250305' | 'web_search_20260209';
+      type:
+        | 'web_search_20250305'
+        | 'web_search_20260209'
+        | 'web_search_20260318';
       name: string;
       max_uses?: number;
       allowed_domains?: string[];
@@ -530,6 +535,7 @@ export type AnthropicTool =
         country?: string;
         timezone?: string;
       };
+      response_inclusion?: 'full' | 'excluded';
       cache_control: AnthropicCacheControl | undefined;
     }
   | {

package/src/anthropic-language-model.ts

@@ -465,8 +465,10 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
         'anthropic.memory_20250818': 'memory',
         'anthropic.web_search_20250305': 'web_search',
         'anthropic.web_search_20260209': 'web_search',
+        'anthropic.web_search_20260318': 'web_search',
         'anthropic.web_fetch_20250910': 'web_fetch',
         'anthropic.web_fetch_20260209': 'web_fetch',
+        'anthropic.web_fetch_20260318': 'web_fetch',
         'anthropic.tool_search_regex_20251119': 'tool_search_tool_regex',
         'anthropic.tool_search_bm25_20251119': 'tool_search_tool_bm25',
         'anthropic.advisor_20260301': 'advisor',
@@ -1046,9 +1048,8 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
       ...this.extractCitationDocuments(options.prompt),
     ];
 
-    const markCodeExecutionDynamic = hasWebTool20260209WithoutCodeExecution(
-      args.tools,
-    );
+    const markCodeExecutionDynamic =
+      hasDynamicFilteringWebToolWithoutCodeExecution(args.tools);
 
     const {
       responseHeaders,
@@ -1637,9 +1638,8 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
       ...this.extractCitationDocuments(options.prompt),
     ];
 
-    const markCodeExecutionDynamic = hasWebTool20260209WithoutCodeExecution(
-      body.tools,
-    );
+    const markCodeExecutionDynamic =
+      hasDynamicFilteringWebToolWithoutCodeExecution(body.tools);
 
     const url = this.buildRequestUrl(true);
     const { responseHeaders, value: response } = await postJsonToApi({
@@ -1903,7 +1903,7 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
                     const customToolName =
                       toolNameMapping.toCustomToolName(providerToolName);
 
-                    // Tools like 'web_fetch_20260209' provide input data here.
+                    // Dynamic web tools 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 =
@@ -2978,21 +2978,23 @@ export function getModelCapabilities(modelId: string): {
   }
 }
 
-export function hasWebTool20260209WithoutCodeExecution(
+export function hasDynamicFilteringWebToolWithoutCodeExecution(
   tools: AnthropicTool[] | undefined,
 ): boolean {
   if (!tools) {
     return false;
   }
-  let hasWebTool20260209 = false;
+  let hasDynamicFilteringWebTool = false;
   let hasCodeExecutionTool = false;
   for (const tool of tools) {
     if (
       'type' in tool &&
       (tool.type === 'web_fetch_20260209' ||
-        tool.type === 'web_search_20260209')
+        tool.type === 'web_fetch_20260318' ||
+        tool.type === 'web_search_20260209' ||
+        tool.type === 'web_search_20260318')
     ) {
-      hasWebTool20260209 = true;
+      hasDynamicFilteringWebTool = true;
       continue;
     }
     if (
@@ -3005,7 +3007,7 @@ export function hasWebTool20260209WithoutCodeExecution(
       break;
     }
   }
-  return hasWebTool20260209 && !hasCodeExecutionTool;
+  return hasDynamicFilteringWebTool && !hasCodeExecutionTool;
 }
 
 function resolveAnthropicReasoningConfig({

package/src/anthropic-prepare-tools.ts

@@ -7,8 +7,10 @@ import type { AnthropicTool, AnthropicToolChoice } from './anthropic-api';
 import { CacheControlValidator } from './get-cache-control';
 import { advisor_20260301ArgsSchema } from './tool/advisor_20260301';
 import { textEditor_20250728ArgsSchema } from './tool/text-editor_20250728';
+import { webSearch_20260318ArgsSchema } from './tool/web-search_20260318';
 import { webSearch_20260209ArgsSchema } from './tool/web-search_20260209';
 import { webSearch_20250305ArgsSchema } from './tool/web-search_20250305';
+import { webFetch_20260318ArgsSchema } from './tool/web-fetch-20260318';
 import { webFetch_20260209ArgsSchema } from './tool/web-fetch-20260209';
 import { webFetch_20250910ArgsSchema } from './tool/web-fetch-20250910';
 import { validateTypes } from '@ai-sdk/provider-utils';
@@ -297,6 +299,25 @@ export async function prepareTools({
             });
             break;
           }
+          case 'anthropic.web_fetch_20260318': {
+            const args = await validateTypes({
+              value: tool.args,
+              schema: webFetch_20260318ArgsSchema,
+            });
+            anthropicTools.push({
+              type: 'web_fetch_20260318',
+              name: 'web_fetch',
+              max_uses: args.maxUses,
+              allowed_domains: args.allowedDomains,
+              blocked_domains: args.blockedDomains,
+              citations: args.citations,
+              max_content_tokens: args.maxContentTokens,
+              use_cache: args.useCache,
+              response_inclusion: args.responseInclusion,
+              cache_control: undefined,
+            });
+            break;
+          }
           case 'anthropic.web_search_20250305': {
             const args = await validateTypes({
               value: tool.args,
@@ -330,6 +351,23 @@ export async function prepareTools({
             });
             break;
           }
+          case 'anthropic.web_search_20260318': {
+            const args = await validateTypes({
+              value: tool.args,
+              schema: webSearch_20260318ArgsSchema,
+            });
+            anthropicTools.push({
+              type: 'web_search_20260318',
+              name: 'web_search',
+              max_uses: args.maxUses,
+              allowed_domains: args.allowedDomains,
+              blocked_domains: args.blockedDomains,
+              user_location: args.userLocation,
+              response_inclusion: args.responseInclusion,
+              cache_control: undefined,
+            });
+            break;
+          }
 
           case 'anthropic.tool_search_regex_20251119': {
             anthropicTools.push({

package/src/anthropic-tools.ts

@@ -14,8 +14,10 @@ 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_20260318 } from './tool/web-fetch-20260318';
 import { webFetch_20260209 } from './tool/web-fetch-20260209';
 import { webFetch_20250910 } from './tool/web-fetch-20250910';
+import { webSearch_20260318 } from './tool/web-search_20260318';
 import { webSearch_20260209 } from './tool/web-search_20260209';
 import { webSearch_20250305 } from './tool/web-search_20250305';
 
@@ -219,6 +221,19 @@ export const anthropicTools = {
    */
   webFetch_20260209,
 
+  /**
+   * 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.
+   * @param useCache - Whether cached content may be returned. Set to false to fetch fresh content.
+   * @param responseInclusion - Whether result blocks consumed by completed code execution calls are returned. Defaults to "full".
+   */
+  webFetch_20260318,
+
   /**
    * Creates a web search tool that gives Claude direct access to real-time web content.
    *
@@ -239,6 +254,17 @@ export const anthropicTools = {
    */
   webSearch_20260209,
 
+  /**
+   * 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.
+   * @param responseInclusion - Whether result blocks consumed by completed code execution calls are returned. Defaults to "full".
+   */
+  webSearch_20260318,
+
   /**
    * Creates a tool search tool that uses regex patterns to find tools.
    *

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

@@ -1007,7 +1007,8 @@ export async function convertToAnthropicPrompt({
                   }
 
                   // to distinguish between code execution 20250522, 20250825,
-                  // and encrypted results (from web_fetch_20260209/web_search_20260209 injection),
+                  // and encrypted results from implicitly provisioned code
+                  // execution for dynamic web tools,
                   // we check the type property in output.value
                   if (output.value.type === 'code_execution_result') {
                     // code execution 20250522
@@ -1140,9 +1141,9 @@ export async function convertToAnthropicPrompt({
                     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.
+                  // ideally we'd switch schema based on the tool version, but
+                  // all supported versions share an identical output schema,
+                  // so we use one here.
                   const webFetchOutput = await validateTypes({
                     value: output.value,
                     schema: webFetch_20250910OutputSchema,
@@ -1205,9 +1206,9 @@ export async function convertToAnthropicPrompt({
                     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.
+                  // ideally we'd switch schema based on the tool version, but
+                  // all supported versions share an identical output schema,
+                  // so we use one here.
                   const webSearchOutput = await validateTypes({
                     value: output.value,
                     schema: webSearch_20250305OutputSchema,

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

@@ -0,0 +1,159 @@
+import {
+  createProviderExecutedToolFactory,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export const webFetch_20260318ArgsSchema = 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(),
+      useCache: z.boolean().optional(),
+      responseInclusion: z.enum(['full', 'excluded']).optional(),
+    }),
+  ),
+);
+
+export const webFetch_20260318OutputSchema = 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_20260318InputSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      url: z.string(),
+    }),
+  ),
+);
+
+const factory = createProviderExecutedToolFactory<
+  {
+    /**
+     * 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;
+
+    /**
+     * Whether cached content may be returned. Set to `false` to fetch fresh
+     * content. Defaults to `true`.
+     */
+    useCache?: boolean;
+
+    /**
+     * Controls whether web fetch result blocks consumed by completed code
+     * execution calls are included in the response. Defaults to `full`.
+     */
+    responseInclusion?: 'full' | 'excluded';
+  }
+>({
+  id: 'anthropic.web_fetch_20260318',
+  inputSchema: webFetch_20260318InputSchema,
+  outputSchema: webFetch_20260318OutputSchema,
+  supportsDeferredResults: true,
+});
+
+export const webFetch_20260318 = (
+  args: Parameters<typeof factory>[0] = {}, // default
+) => {
+  return factory(args);
+};

package/src/tool/web-search_20260318.ts

@@ -0,0 +1,143 @@
+import {
+  createProviderExecutedToolFactory,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export const webSearch_20260318ArgsSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      maxUses: z.number().optional(),
+      allowedDomains: z.array(z.string()).optional(),
+      blockedDomains: z.array(z.string()).optional(),
+      userLocation: z
+        .object({
+          type: z.literal('approximate'),
+          city: z.string().optional(),
+          region: z.string().optional(),
+          country: z.string().optional(),
+          timezone: z.string().optional(),
+        })
+        .optional(),
+      responseInclusion: z.enum(['full', 'excluded']).optional(),
+    }),
+  ),
+);
+
+export const webSearch_20260318OutputSchema = lazySchema(() =>
+  zodSchema(
+    z.array(
+      z.object({
+        url: z.string(),
+        title: z.string().nullable(),
+        pageAge: z.string().nullable(),
+        encryptedContent: z.string(),
+        type: z.literal('web_search_result'),
+      }),
+    ),
+  ),
+);
+
+const webSearch_20260318InputSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      query: z.string(),
+    }),
+  ),
+);
+
+const factory = createProviderExecutedToolFactory<
+  {
+    /**
+     * The search query to execute.
+     */
+    query: string;
+  },
+  Array<{
+    type: 'web_search_result';
+
+    /**
+     * The URL of the source page.
+     */
+    url: string;
+
+    /**
+     * The title of the source page.
+     */
+    title: string | null;
+
+    /**
+     * When the site was last updated
+     */
+    pageAge: string | null;
+
+    /**
+     * Encrypted content that must be passed back in multi-turn conversations for citations
+     */
+    encryptedContent: string;
+  }>,
+  {
+    /**
+     * Maximum number of web searches Claude can perform during the conversation.
+     */
+    maxUses?: number;
+
+    /**
+     * Optional list of domains that Claude is allowed to search.
+     */
+    allowedDomains?: string[];
+
+    /**
+     * Optional list of domains that Claude should avoid when searching.
+     */
+    blockedDomains?: string[];
+
+    /**
+     * Optional user location information to provide geographically relevant search results.
+     */
+    userLocation?: {
+      /**
+       * The type of location (must be approximate)
+       */
+      type: 'approximate';
+
+      /**
+       * The city name
+       */
+      city?: string;
+
+      /**
+       * The region or state
+       */
+      region?: string;
+
+      /**
+       * The country
+       */
+      country?: string;
+
+      /**
+       * The IANA timezone ID.
+       */
+      timezone?: string;
+    };
+
+    /**
+     * Controls whether web search result blocks consumed by completed code
+     * execution calls are included in the response. Defaults to `full`.
+     */
+    responseInclusion?: 'full' | 'excluded';
+  }
+>({
+  id: 'anthropic.web_search_20260318',
+  inputSchema: webSearch_20260318InputSchema,
+  outputSchema: webSearch_20260318OutputSchema,
+  supportsDeferredResults: true,
+});
+
+export const webSearch_20260318 = (
+  args: Parameters<typeof factory>[0] = {}, // default
+) => {
+  return factory(args);
+};