@fairyhunter13/ai-anthropic 3.0.58-fork.2 → 3.0.58-fork.21

package/src/anthropic-prepare-tools.ts

@@ -1,6 +1,6 @@
 import {
-  LanguageModelV3CallOptions,
-  SharedV3Warning,
+  LanguageModelV4CallOptions,
+  SharedV4Warning,
   UnsupportedFunctionalityError,
 } from '@ai-sdk/provider';
 import { AnthropicTool, AnthropicToolChoice } from './anthropic-messages-api';
@@ -8,6 +8,7 @@ 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_20260309ArgsSchema } from './tool/web-fetch-20260309';
 import { webFetch_20260209ArgsSchema } from './tool/web-fetch-20260209';
 import { webFetch_20250910ArgsSchema } from './tool/web-fetch-20250910';
 import { validateTypes } from '@ai-sdk/provider-utils';
@@ -26,26 +27,32 @@ export async function prepareTools({
   disableParallelToolUse,
   cacheControlValidator,
   supportsStructuredOutput,
+  supportsStrictTools,
 }: {
-  tools: LanguageModelV3CallOptions['tools'];
-  toolChoice: LanguageModelV3CallOptions['toolChoice'] | undefined;
+  tools: LanguageModelV4CallOptions['tools'];
+  toolChoice: LanguageModelV4CallOptions['toolChoice'] | undefined;
   disableParallelToolUse?: boolean;
   cacheControlValidator?: CacheControlValidator;
 
   /**
-   * Whether the model supports structured output.
+   * Whether the model supports native structured output response format.
    */
   supportsStructuredOutput: boolean;
+
+  /**
+   * Whether the model supports strict mode on tool definitions.
+   */
+  supportsStrictTools: boolean;
 }): Promise<{
   tools: Array<AnthropicTool> | undefined;
   toolChoice: AnthropicToolChoice | undefined;
-  toolWarnings: SharedV3Warning[];
+  toolWarnings: SharedV4Warning[];
   betas: Set<string>;
 }> {
   // when the tools array is empty, change it to undefined to prevent errors:
   tools = tools?.length ? tools : undefined;
 
-  const toolWarnings: SharedV3Warning[] = [];
+  const toolWarnings: SharedV4Warning[] = [];
   const betas = new Set<string>();
   const validator = cacheControlValidator || new CacheControlValidator();
 
@@ -72,13 +79,21 @@ export async function prepareTools({
         const deferLoading = anthropicOptions?.deferLoading;
         const allowedCallers = anthropicOptions?.allowedCallers;
 
+        if (!supportsStrictTools && tool.strict != null) {
+          toolWarnings.push({
+            type: 'unsupported',
+            feature: 'strict',
+            details: `Tool '${tool.name}' has strict: ${tool.strict}, but strict mode is not supported by this provider. The strict property will be ignored.`,
+          });
+        }
+
         anthropicTools.push({
           name: tool.name,
           description: tool.description,
           input_schema: tool.inputSchema,
           cache_control: cacheControl,
           ...(eagerInputStreaming ? { eager_input_streaming: true } : {}),
-          ...(supportsStructuredOutput === true && tool.strict != null
+          ...(supportsStrictTools === true && tool.strict != null
             ? { strict: tool.strict }
             : {}),
           ...(deferLoading != null ? { defer_loading: deferLoading } : {}),
@@ -120,7 +135,7 @@ export async function prepareTools({
             break;
           }
           case 'anthropic.code_execution_20250825': {
-            betas.add('code-execution-2025-08-25');
+            // GA — no beta header needed
             anthropicTools.push({
               type: 'code_execution_20250825',
               name: 'code_execution',
@@ -238,7 +253,7 @@ export async function prepareTools({
             break;
           }
           case 'anthropic.web_fetch_20250910': {
-            betas.add('web-fetch-2025-09-10');
+            // GA — no beta header needed
             const args = await validateTypes({
               value: tool.args,
               schema: webFetch_20250910ArgsSchema,
@@ -256,7 +271,7 @@ export async function prepareTools({
             break;
           }
           case 'anthropic.web_fetch_20260209': {
-            betas.add('code-execution-web-tools-2026-02-09');
+            // GA — no beta header needed
             const args = await validateTypes({
               value: tool.args,
               schema: webFetch_20260209ArgsSchema,
@@ -273,6 +288,28 @@ export async function prepareTools({
             });
             break;
           }
+          case 'anthropic.web_fetch_20260309': {
+            // GA version — no beta header needed
+            const args = await validateTypes({
+              value: tool.args,
+              schema: webFetch_20260309ArgsSchema,
+            });
+            anthropicTools.push({
+              type: 'web_fetch_20260309',
+              name: 'web_fetch',
+              max_uses: args.maxUses,
+              allowed_domains: args.allowedDomains,
+              blocked_domains: args.blockedDomains,
+              citations: args.citations,
+              max_content_tokens: args.maxContentTokens,
+              allowed_callers: args.allowedCallers,
+              use_cache: args.useCache,
+              defer_loading: args.deferLoading,
+              strict: args.strict,
+              cache_control: undefined,
+            });
+            break;
+          }
           case 'anthropic.web_search_20250305': {
             const args = await validateTypes({
               value: tool.args,
@@ -290,7 +327,7 @@ export async function prepareTools({
             break;
           }
           case 'anthropic.web_search_20260209': {
-            betas.add('code-execution-web-tools-2026-02-09');
+            // GA — no beta header needed
             const args = await validateTypes({
               value: tool.args,
               schema: webSearch_20260209ArgsSchema,
@@ -302,13 +339,13 @@ export async function prepareTools({
               allowed_domains: args.allowedDomains,
               blocked_domains: args.blockedDomains,
               user_location: args.userLocation,
+              allowed_callers: args.allowedCallers,
               cache_control: undefined,
             });
             break;
           }
 
           case 'anthropic.tool_search_regex_20251119': {
-            betas.add('advanced-tool-use-2025-11-20');
             anthropicTools.push({
               type: 'tool_search_tool_regex_20251119',
               name: 'tool_search_tool_regex',
@@ -317,7 +354,6 @@ export async function prepareTools({
           }
 
           case 'anthropic.tool_search_bm25_20251119': {
-            betas.add('advanced-tool-use-2025-11-20');
             anthropicTools.push({
               type: 'tool_search_tool_bm25_20251119',
               name: 'tool_search_tool_bm25',

package/src/anthropic-provider.ts

@@ -1,8 +1,8 @@
 import {
   InvalidArgumentError,
-  LanguageModelV3,
+  LanguageModelV4,
   NoSuchModelError,
-  ProviderV3,
+  ProviderV4,
 } from '@ai-sdk/provider';
 import {
   FetchFunction,
@@ -17,20 +17,20 @@ import { AnthropicMessagesLanguageModel } from './anthropic-messages-language-mo
 import { AnthropicMessagesModelId } from './anthropic-messages-options';
 import { anthropicTools } from './anthropic-tools';
 
-export interface AnthropicProvider extends ProviderV3 {
+export interface AnthropicProvider extends ProviderV4 {
   /**
    * Creates a model for text generation.
    */
-  (modelId: AnthropicMessagesModelId): LanguageModelV3;
+  (modelId: AnthropicMessagesModelId): LanguageModelV4;
 
   /**
    * Creates a model for text generation.
    */
-  languageModel(modelId: AnthropicMessagesModelId): LanguageModelV3;
+  languageModel(modelId: AnthropicMessagesModelId): LanguageModelV4;
 
-  chat(modelId: AnthropicMessagesModelId): LanguageModelV3;
+  chat(modelId: AnthropicMessagesModelId): LanguageModelV4;
 
-  messages(modelId: AnthropicMessagesModelId): LanguageModelV3;
+  messages(modelId: AnthropicMessagesModelId): LanguageModelV4;
 
   /**
    * @deprecated Use `embeddingModel` instead.
@@ -153,7 +153,7 @@ export function createAnthropic(
     return createChatModel(modelId);
   };
 
-  provider.specificationVersion = 'v3' as const;
+  provider.specificationVersion = 'v4' as const;
   provider.languageModel = createChatModel;
   provider.chat = createChatModel;
   provider.messages = createChatModel;

package/src/anthropic-tools.ts

@@ -13,6 +13,7 @@ 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_20260309 } from './tool/web-fetch-20260309';
 import { webFetch_20260209 } from './tool/web-fetch-20260209';
 import { webFetch_20250910 } from './tool/web-fetch-20250910';
 import { webSearch_20260209 } from './tool/web-search_20260209';
@@ -186,6 +187,23 @@ export const anthropicTools = {
    */
   webFetch_20260209,
 
+  /**
+   * Creates a web fetch tool that gives Claude direct access to real-time web content.
+   * GA version (no beta header required). Includes caller restrictions, cache control,
+   * deferred loading, and strict mode.
+   *
+   * @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 - Citations configuration for fetched documents
+   * @param maxContentTokens - Max content tokens included in context
+   * @param allowedCallers - Restrict callers (e.g. ["direct"] to prevent code_execution usage)
+   * @param useCache - Whether to use cached content (set false for fresh content)
+   * @param deferLoading - Defer loading until tool_search discovers it
+   * @param strict - Enable strict schema validation
+   */
+  webFetch_20260309,
+
   /**
    * Creates a web search tool that gives Claude direct access to real-time web content.
    *

package/src/convert-anthropic-messages-usage.ts

@@ -1,4 +1,4 @@
-import { JSONObject, LanguageModelV3Usage } from '@ai-sdk/provider';
+import { JSONObject, LanguageModelV4Usage } from '@ai-sdk/provider';
 
 /**
  * Represents a single iteration in the usage breakdown.
@@ -31,7 +31,7 @@ export function convertAnthropicMessagesUsage({
 }: {
   usage: AnthropicMessagesUsage;
   rawUsage?: JSONObject;
-}): LanguageModelV3Usage {
+}): LanguageModelV4Usage {
   const cacheCreationTokens = usage.cache_creation_input_tokens ?? 0;
   const cacheReadTokens = usage.cache_read_input_tokens ?? 0;
 

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

@@ -1,9 +1,9 @@
 import {
-  SharedV3Warning,
-  LanguageModelV3DataContent,
-  LanguageModelV3Message,
-  LanguageModelV3Prompt,
-  SharedV3ProviderMetadata,
+  SharedV4Warning,
+  LanguageModelV4DataContent,
+  LanguageModelV4Message,
+  LanguageModelV4Prompt,
+  SharedV4ProviderMetadata,
   UnsupportedFunctionalityError,
 } from '@ai-sdk/provider';
 import {
@@ -31,7 +31,7 @@ import { toolSearchRegex_20251119OutputSchema as toolSearchOutputSchema } from '
 import { webFetch_20250910OutputSchema } from './tool/web-fetch-20250910';
 import { webSearch_20250305OutputSchema } from './tool/web-search_20250305';
 
-function convertToString(data: LanguageModelV3DataContent): string {
+function convertToString(data: LanguageModelV4DataContent): string {
   if (typeof data === 'string') {
     return new TextDecoder().decode(convertBase64ToUint8Array(data));
   }
@@ -55,24 +55,24 @@ function convertToString(data: LanguageModelV3DataContent): string {
  * Checks if data is a URL (either a URL object or a URL string).
  */
 function isUrlData(
-  data: LanguageModelV3DataContent,
+  data: LanguageModelV4DataContent,
 ): data is URL | (string & { __brand: 'url-string' }) {
   return data instanceof URL || isUrlString(data);
 }
 
-function isUrlString(data: LanguageModelV3DataContent): boolean {
+function isUrlString(data: LanguageModelV4DataContent): boolean {
   return typeof data === 'string' && /^https?:\/\//i.test(data);
 }
 
-function isFileIdData(data: LanguageModelV3DataContent): boolean {
+function isFileIdData(data: LanguageModelV4DataContent): boolean {
   return typeof data === 'string' && data.startsWith('anthropic-file://');
 }
 
-function getFileId(data: LanguageModelV3DataContent): string {
+function getFileId(data: LanguageModelV4DataContent): string {
   return (data as string).replace('anthropic-file://', '');
 }
 
-function getUrlString(data: LanguageModelV3DataContent): string {
+function getUrlString(data: LanguageModelV4DataContent): string {
   return data instanceof URL ? data.toString() : (data as string);
 }
 
@@ -83,9 +83,9 @@ export async function convertToAnthropicMessagesPrompt({
   cacheControlValidator,
   toolNameMapping,
 }: {
-  prompt: LanguageModelV3Prompt;
+  prompt: LanguageModelV4Prompt;
   sendReasoning: boolean;
-  warnings: SharedV3Warning[];
+  warnings: SharedV4Warning[];
   cacheControlValidator?: CacheControlValidator;
   toolNameMapping: ToolNameMapping;
 }): Promise<{
@@ -100,7 +100,7 @@ export async function convertToAnthropicMessagesPrompt({
   const messages: AnthropicMessagesPrompt['messages'] = [];
 
   async function shouldEnableCitations(
-    providerMetadata: SharedV3ProviderMetadata | undefined,
+    providerMetadata: SharedV4ProviderMetadata | undefined,
   ): Promise<boolean> {
     const anthropicOptions = await parseProviderOptions({
       provider: 'anthropic',
@@ -112,7 +112,7 @@ export async function convertToAnthropicMessagesPrompt({
   }
 
   async function getDocumentMetadata(
-    providerMetadata: SharedV3ProviderMetadata | undefined,
+    providerMetadata: SharedV4ProviderMetadata | undefined,
   ): Promise<{ title?: string; context?: string }> {
     const anthropicOptions = await parseProviderOptions({
       provider: 'anthropic',
@@ -140,14 +140,17 @@ export async function convertToAnthropicMessagesPrompt({
           });
         }
 
-        system = block.messages.map(({ content, providerOptions }) => ({
-          type: 'text',
-          text: content,
-          cache_control: validator.getCacheControl(providerOptions, {
+        system = block.messages.map(({ content, providerOptions }) => {
+          const cc = validator.getCacheControl(providerOptions, {
             type: 'system message',
             canCache: true,
-          }),
-        }));
+          });
+          return {
+            type: 'text',
+            text: content,
+            cache_control: cc,
+          };
+        });
 
         break;
       }
@@ -909,7 +912,7 @@ export async function convertToAnthropicMessagesPrompt({
                         errorCode:
                           typeof extractedErrorCode === 'string'
                             ? extractedErrorCode
-                            : 'unknown',
+                            : 'unavailable',
                       };
                     }
 
@@ -918,7 +921,7 @@ export async function convertToAnthropicMessagesPrompt({
                       tool_use_id: part.toolCallId,
                       content: {
                         type: 'web_fetch_tool_result_error',
-                        error_code: errorValue.errorCode ?? 'unknown',
+                        error_code: errorValue.errorCode ?? 'unavailable',
                       },
                       cache_control: cacheControl,
                     });
@@ -1012,6 +1015,23 @@ export async function convertToAnthropicMessagesPrompt({
                 ) {
                   const output = part.output;
 
+                  if (
+                    output.type === 'error-text' ||
+                    output.type === 'error-json'
+                  ) {
+                    anthropicContent.push({
+                      type: 'tool_search_tool_result',
+                      tool_use_id: part.toolCallId,
+                      content: {
+                        type: 'tool_search_tool_result_error',
+                        error_code: 'unavailable',
+                      },
+                      cache_control: cacheControl,
+                    });
+
+                    break;
+                  }
+
                   if (output.type !== 'json') {
                     warnings.push({
                       type: 'other',
@@ -1076,19 +1096,19 @@ export async function convertToAnthropicMessagesPrompt({
 
 type SystemBlock = {
   type: 'system';
-  messages: Array<LanguageModelV3Message & { role: 'system' }>;
+  messages: Array<LanguageModelV4Message & { role: 'system' }>;
 };
 type AssistantBlock = {
   type: 'assistant';
-  messages: Array<LanguageModelV3Message & { role: 'assistant' }>;
+  messages: Array<LanguageModelV4Message & { role: 'assistant' }>;
 };
 type UserBlock = {
   type: 'user';
-  messages: Array<LanguageModelV3Message & { role: 'user' | 'tool' }>;
+  messages: Array<LanguageModelV4Message & { role: 'user' | 'tool' }>;
 };
 
 function groupIntoBlocks(
-  prompt: LanguageModelV3Prompt,
+  prompt: LanguageModelV4Prompt,
 ): Array<SystemBlock | AssistantBlock | UserBlock> {
   const blocks: Array<SystemBlock | AssistantBlock | UserBlock> = [];
   let currentBlock: SystemBlock | AssistantBlock | UserBlock | undefined =

package/src/get-cache-control.ts

@@ -1,4 +1,4 @@
-import { SharedV3Warning, SharedV3ProviderMetadata } from '@ai-sdk/provider';
+import { SharedV4Warning, SharedV4ProviderMetadata } from '@ai-sdk/provider';
 import { AnthropicCacheControl } from './anthropic-messages-api';
 
 // Anthropic allows a maximum of 4 cache breakpoints per request
@@ -7,7 +7,7 @@ const MAX_CACHE_BREAKPOINTS = 4;
 // Helper function to extract cache_control from provider metadata
 // Allows both cacheControl and cache_control for flexibility
 function getCacheControl(
-  providerMetadata: SharedV3ProviderMetadata | undefined,
+  providerMetadata: SharedV4ProviderMetadata | undefined,
 ): AnthropicCacheControl | undefined {
   const anthropic = providerMetadata?.anthropic;
 
@@ -21,10 +21,10 @@ function getCacheControl(
 
 export class CacheControlValidator {
   private breakpointCount = 0;
-  private warnings: SharedV3Warning[] = [];
+  private warnings: SharedV4Warning[] = [];
 
   getCacheControl(
-    providerMetadata: SharedV3ProviderMetadata | undefined,
+    providerMetadata: SharedV4ProviderMetadata | undefined,
     context: { type: string; canCache: boolean },
   ): AnthropicCacheControl | undefined {
     const cacheControlValue = getCacheControl(providerMetadata);
@@ -57,7 +57,7 @@ export class CacheControlValidator {
     return cacheControlValue;
   }
 
-  getWarnings(): SharedV3Warning[] {
+  getWarnings(): SharedV4Warning[] {
     return this.warnings;
   }
 }

package/src/internal/index.ts

@@ -1,4 +1,7 @@
-export { AnthropicMessagesLanguageModel } from '../anthropic-messages-language-model';
+export {
+  AnthropicMessagesLanguageModel,
+  getModelCapabilities,
+} from '../anthropic-messages-language-model';
 export { anthropicTools } from '../anthropic-tools';
 export type { AnthropicMessagesModelId } from '../anthropic-messages-options';
 export { prepareTools } from '../anthropic-prepare-tools';

package/src/map-anthropic-stop-reason.ts

@@ -1,4 +1,4 @@
-import { LanguageModelV3FinishReason } from '@ai-sdk/provider';
+import { LanguageModelV4FinishReason } from '@ai-sdk/provider';
 
 /**
  * @see https://docs.anthropic.com/en/api/messages#response-stop-reason
@@ -9,7 +9,7 @@ export function mapAnthropicStopReason({
 }: {
   finishReason: string | null | undefined;
   isJsonResponseFromTool?: boolean;
-}): LanguageModelV3FinishReason['unified'] {
+}): LanguageModelV4FinishReason['unified'] {
   switch (finishReason) {
     case 'pause_turn':
     case 'end_turn':

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

@@ -0,0 +1,182 @@
+import {
+  createProviderToolFactoryWithOutputSchema,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export const webFetch_20260309ArgsSchema = 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(),
+      allowedCallers: z
+        .array(
+          z.enum([
+            'direct',
+            'code_execution_20250825',
+            'code_execution_20260120',
+          ]),
+        )
+        .optional(),
+      useCache: z.boolean().optional(),
+      deferLoading: z.boolean().optional(),
+      strict: z.boolean().optional(),
+    }),
+  ),
+);
+
+export const webFetch_20260309OutputSchema = 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_20260309InputSchema = 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;
+
+    /**
+     * Restrict which callers can invoke web_fetch.
+     * Set to ["direct"] to prevent code_execution from calling web_fetch programmatically.
+     */
+    allowedCallers?: Array<
+      'direct' | 'code_execution_20250825' | 'code_execution_20260120'
+    >;
+
+    /**
+     * Whether to use cached content.
+     * Set to false to bypass the cache and fetch fresh content.
+     */
+    useCache?: boolean;
+
+    /**
+     * If true, tool will not be included in initial system prompt.
+     * Only loaded when returned via tool_reference from tool search.
+     */
+    deferLoading?: boolean;
+
+    /**
+     * When true, guarantees schema validation on tool names and inputs.
+     */
+    strict?: boolean;
+  }
+>({
+  id: 'anthropic.web_fetch_20260309',
+  inputSchema: webFetch_20260309InputSchema,
+  outputSchema: webFetch_20260309OutputSchema,
+  supportsDeferredResults: true,
+});
+
+export const webFetch_20260309 = (
+  args: Parameters<typeof factory>[0] = {}, // default
+) => {
+  return factory(args);
+};