@ai-sdk/anthropic 4.0.0-beta.4 → 4.0.0-beta.40

package/src/{anthropic-messages-options.ts → anthropic-options.ts}

@@ -1,7 +1,7 @@
 import { z } from 'zod/v4';
 
 // https://docs.claude.com/en/docs/about-claude/models/overview
-export type AnthropicMessagesModelId =
+export type AnthropicModelId =
   | 'claude-3-haiku-20240307'
   | 'claude-haiku-4-5-20251001'
   | 'claude-haiku-4-5'
@@ -17,6 +17,7 @@ export type AnthropicMessagesModelId =
   | 'claude-sonnet-4-5'
   | 'claude-sonnet-4-6'
   | 'claude-opus-4-6'
+  | 'claude-opus-4-7'
   | (string & {});
 
 /**
@@ -83,6 +84,12 @@ export const anthropicLanguageModelOptions = z.object({
       z.object({
         /** for Sonnet 4.6, Opus 4.6, and newer models */
         type: z.literal('adaptive'),
+        /**
+         * Controls whether thinking content is included in the response.
+         * - `"omitted"`: Thinking blocks are present but text is empty (default for Opus 4.7+).
+         * - `"summarized"`: Thinking content is returned. Required to see reasoning output.
+         */
+        display: z.enum(['omitted', 'summarized']).optional(),
       }),
       z.object({
         /** for models before Opus 4.6, except Sonnet 4.6 still supports it */
@@ -112,6 +119,23 @@ export const anthropicLanguageModelOptions = z.object({
     })
     .optional(),
 
+  /**
+   * Metadata to include with the request.
+   *
+   * See https://platform.claude.com/docs/en/api/messages/create for details.
+   */
+  metadata: z
+    .object({
+      /**
+       * An external identifier for the user associated with the request.
+       *
+       * Should be a UUID, hash value, or other opaque identifier.
+       * Must not contain PII (name, email, phone number, etc.).
+       */
+      userId: z.string().optional(),
+    })
+    .optional(),
+
   /**
    * MCP servers to be utilized in this request.
    */
@@ -142,21 +166,29 @@ export const anthropicLanguageModelOptions = z.object({
       id: z.string().optional(),
       skills: z
         .array(
-          z.object({
-            type: z.union([z.literal('anthropic'), z.literal('custom')]),
-            skillId: z.string(),
-            version: z.string().optional(),
-          }),
+          z.discriminatedUnion('type', [
+            z.object({
+              type: z.literal('anthropic'),
+              skillId: z.string(),
+              version: z.string().optional(),
+            }),
+            z.object({
+              type: z.literal('custom'),
+              providerReference: z.record(z.string(), z.string()),
+              version: z.string().optional(),
+            }),
+          ]),
         )
         .optional(),
     })
     .optional(),
 
   /**
-   * Whether to enable tool streaming (and structured output streaming).
-   *
-   * When set to false, the model will return all tool calls and results
-   * at once after a delay.
+   * Whether to enable fine-grained (eager) streaming of tool call inputs
+   * and structured outputs for every function tool in the request. When
+   * true (the default), each function tool receives a default of
+   * `eager_input_streaming: true` unless it explicitly sets
+   * `providerOptions.anthropic.eagerInputStreaming`.
    *
    * @default true
    */
@@ -165,7 +197,22 @@ export const anthropicLanguageModelOptions = z.object({
   /**
    * @default 'high'
    */
-  effort: z.enum(['low', 'medium', 'high', 'max']).optional(),
+  effort: z.enum(['low', 'medium', 'high', 'xhigh', 'max']).optional(),
+
+  /**
+   * Task budget for agentic turns. Informs the model of the total token budget
+   * available for the current task, allowing it to prioritize work and wind down
+   * gracefully as the budget is consumed.
+   *
+   * Advisory only — does not enforce a hard token limit.
+   */
+  taskBudget: z
+    .object({
+      type: z.literal('tokens'),
+      total: z.number().int().min(20000),
+      remaining: z.number().int().min(0).optional(),
+    })
+    .optional(),
 
   /**
    * Enable fast mode for faster inference (2.5x faster output token speeds).
@@ -173,6 +220,16 @@ export const anthropicLanguageModelOptions = z.object({
    */
   speed: z.enum(['fast', 'standard']).optional(),
 
+  /**
+   * Controls where model inference runs for this request.
+   *
+   * - `"global"`: Inference may run in any available geography (default).
+   * - `"us"`: Inference runs only in US-based infrastructure.
+   *
+   * See https://platform.claude.com/docs/en/build-with-claude/data-residency
+   */
+  inferenceGeo: z.enum(['us', 'global']).optional(),
+
   /**
    * A set of beta features to enable.
    * Allow a provider to receive the full `betas` set if it needs it.

package/src/anthropic-prepare-tools.ts

@@ -3,7 +3,7 @@ import {
   SharedV4Warning,
   UnsupportedFunctionalityError,
 } from '@ai-sdk/provider';
-import { AnthropicTool, AnthropicToolChoice } from './anthropic-messages-api';
+import { AnthropicTool, AnthropicToolChoice } from './anthropic-api';
 import { CacheControlValidator } from './get-cache-control';
 import { textEditor_20250728ArgsSchema } from './tool/text-editor_20250728';
 import { webSearch_20260209ArgsSchema } from './tool/web-search_20260209';
@@ -27,6 +27,7 @@ export async function prepareTools({
   cacheControlValidator,
   supportsStructuredOutput,
   supportsStrictTools,
+  defaultEagerInputStreaming = false,
 }: {
   tools: LanguageModelV4CallOptions['tools'];
   toolChoice: LanguageModelV4CallOptions['toolChoice'] | undefined;
@@ -42,6 +43,12 @@ export async function prepareTools({
    * Whether the model supports strict mode on tool definitions.
    */
   supportsStrictTools: boolean;
+
+  /**
+   * Default for `eager_input_streaming` on function tools that do not set
+   * it explicitly. Driven by the model-level `toolStreaming` option.
+   */
+  defaultEagerInputStreaming?: boolean;
 }): Promise<{
   tools: Array<AnthropicTool> | undefined;
   toolChoice: AnthropicToolChoice | undefined;
@@ -73,8 +80,10 @@ export async function prepareTools({
         const anthropicOptions = tool.providerOptions?.anthropic as
           | AnthropicToolOptions
           | undefined;
-        // eager_input_streaming is only supported on custom (function) tools
-        const eagerInputStreaming = anthropicOptions?.eagerInputStreaming;
+        // eager_input_streaming is only supported on custom (function) tools.
+        // Fall back to the model-level default when the tool doesn't set it.
+        const eagerInputStreaming =
+          anthropicOptions?.eagerInputStreaming ?? defaultEagerInputStreaming;
         const deferLoading = anthropicOptions?.deferLoading;
         const allowedCallers = anthropicOptions?.allowedCallers;
 
@@ -322,7 +331,6 @@ export async function prepareTools({
           }
 
           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',
@@ -331,7 +339,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,10 @@
 import {
+  FilesV4,
   InvalidArgumentError,
   LanguageModelV4,
   NoSuchModelError,
   ProviderV4,
+  SkillsV4,
 } from '@ai-sdk/provider';
 import {
   FetchFunction,
@@ -12,31 +14,40 @@ import {
   withoutTrailingSlash,
   withUserAgentSuffix,
 } from '@ai-sdk/provider-utils';
-import { VERSION } from './version';
-import { AnthropicMessagesLanguageModel } from './anthropic-messages-language-model';
-import { AnthropicMessagesModelId } from './anthropic-messages-options';
+import { AnthropicFiles } from './anthropic-files';
+import { AnthropicLanguageModel } from './anthropic-language-model';
+import { AnthropicModelId } from './anthropic-options';
 import { anthropicTools } from './anthropic-tools';
+import { AnthropicSkills } from './skills/anthropic-skills';
+import { VERSION } from './version';
 
 export interface AnthropicProvider extends ProviderV4 {
   /**
    * Creates a model for text generation.
    */
-  (modelId: AnthropicMessagesModelId): LanguageModelV4;
+  (modelId: AnthropicModelId): LanguageModelV4;
 
   /**
    * Creates a model for text generation.
    */
-  languageModel(modelId: AnthropicMessagesModelId): LanguageModelV4;
+  languageModel(modelId: AnthropicModelId): LanguageModelV4;
 
-  chat(modelId: AnthropicMessagesModelId): LanguageModelV4;
+  chat(modelId: AnthropicModelId): LanguageModelV4;
 
-  messages(modelId: AnthropicMessagesModelId): LanguageModelV4;
+  messages(modelId: AnthropicModelId): LanguageModelV4;
 
   /**
    * @deprecated Use `embeddingModel` instead.
    */
   textEmbeddingModel(modelId: string): never;
 
+  files(): FilesV4;
+
+  /**
+   * Returns a SkillsV4 interface for uploading skills to Anthropic.
+   */
+  skills(): SkillsV4;
+
   /**
    * Anthropic-specific computer use tool.
    */
@@ -130,8 +141,8 @@ export function createAnthropic(
     );
   };
 
-  const createChatModel = (modelId: AnthropicMessagesModelId) =>
-    new AnthropicMessagesLanguageModel(modelId, {
+  const createChatModel = (modelId: AnthropicModelId) =>
+    new AnthropicLanguageModel(modelId, {
       provider: providerName,
       baseURL,
       headers: getHeaders,
@@ -143,7 +154,15 @@ export function createAnthropic(
       }),
     });
 
-  const provider = function (modelId: AnthropicMessagesModelId) {
+  const createSkills = () =>
+    new AnthropicSkills({
+      provider: `${providerName.replace('.messages', '')}.skills`,
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
+  const provider = function (modelId: AnthropicModelId) {
     if (new.target) {
       throw new Error(
         'The Anthropic model function cannot be called with the new keyword.',
@@ -166,6 +185,16 @@ export function createAnthropic(
     throw new NoSuchModelError({ modelId, modelType: 'imageModel' });
   };
 
+  provider.files = () =>
+    new AnthropicFiles({
+      provider: providerName,
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
+  provider.skills = createSkills;
+
   provider.tools = anthropicTools;
 
   return provider;

package/src/{convert-anthropic-messages-usage.ts → convert-anthropic-usage.ts}

@@ -11,7 +11,7 @@ export type AnthropicUsageIteration = {
   output_tokens: number;
 };
 
-export type AnthropicMessagesUsage = {
+export type AnthropicUsage = {
   input_tokens: number;
   output_tokens: number;
   cache_creation_input_tokens?: number | null;
@@ -25,11 +25,11 @@ export type AnthropicMessagesUsage = {
   iterations?: AnthropicUsageIteration[] | null;
 };
 
-export function convertAnthropicMessagesUsage({
+export function convertAnthropicUsage({
   usage,
   rawUsage,
 }: {
-  usage: AnthropicMessagesUsage;
+  usage: AnthropicUsage;
   rawUsage?: JSONObject;
 }): LanguageModelV4Usage {
   const cacheCreationTokens = usage.cache_creation_input_tokens ?? 0;

package/src/{convert-to-anthropic-messages-prompt.ts → convert-to-anthropic-prompt.ts}

@@ -9,20 +9,22 @@ import {
 import {
   convertBase64ToUint8Array,
   convertToBase64,
+  isProviderReference,
   parseProviderOptions,
+  resolveProviderReference,
   validateTypes,
   isNonNullable,
   ToolNameMapping,
 } from '@ai-sdk/provider-utils';
 import {
   AnthropicAssistantMessage,
-  AnthropicMessagesPrompt,
+  AnthropicPrompt,
   anthropicReasoningMetadataSchema,
   AnthropicToolResultContent,
   AnthropicUserMessage,
   AnthropicWebFetchToolResultContent,
-} from './anthropic-messages-api';
-import { anthropicFilePartProviderOptions } from './anthropic-messages-options';
+} from './anthropic-api';
+import { anthropicFilePartProviderOptions } from './anthropic-options';
 import { CacheControlValidator } from './get-cache-control';
 import { codeExecution_20250522OutputSchema } from './tool/code-execution_20250522';
 import { codeExecution_20250825OutputSchema } from './tool/code-execution_20250825';
@@ -68,7 +70,7 @@ function getUrlString(data: LanguageModelV4DataContent): string {
   return data instanceof URL ? data.toString() : (data as string);
 }
 
-export async function convertToAnthropicMessagesPrompt({
+export async function convertToAnthropicPrompt({
   prompt,
   sendReasoning,
   warnings,
@@ -81,15 +83,15 @@ export async function convertToAnthropicMessagesPrompt({
   cacheControlValidator?: CacheControlValidator;
   toolNameMapping: ToolNameMapping;
 }): Promise<{
-  prompt: AnthropicMessagesPrompt;
+  prompt: AnthropicPrompt;
   betas: Set<string>;
 }> {
   const betas = new Set<string>();
   const blocks = groupIntoBlocks(prompt);
   const validator = cacheControlValidator || new CacheControlValidator();
 
-  let system: AnthropicMessagesPrompt['system'] = undefined;
-  const messages: AnthropicMessagesPrompt['messages'] = [];
+  let system: AnthropicPrompt['system'] = undefined;
+  const messages: AnthropicPrompt['messages'] = [];
 
   async function shouldEnableCitations(
     providerMetadata: SharedV4ProviderMetadata | undefined,
@@ -183,7 +185,27 @@ export async function convertToAnthropicMessagesPrompt({
                   }
 
                   case 'file': {
-                    if (part.mediaType.startsWith('image/')) {
+                    if (isProviderReference(part.data)) {
+                      const fileId = resolveProviderReference({
+                        reference: part.data,
+                        provider: 'anthropic',
+                      });
+                      betas.add('files-api-2025-04-14');
+
+                      if (part.mediaType.startsWith('image/')) {
+                        anthropicContent.push({
+                          type: 'image',
+                          source: { type: 'file', file_id: fileId },
+                          cache_control: cacheControl,
+                        });
+                      } else {
+                        anthropicContent.push({
+                          type: 'document',
+                          source: { type: 'file', file_id: fileId },
+                          cache_control: cacheControl,
+                        });
+                      }
+                    } else if (part.mediaType.startsWith('image/')) {
                       anthropicContent.push({
                         type: 'image',
                         source: isUrlData(part.data)
@@ -309,26 +331,16 @@ export async function convertToAnthropicMessagesPrompt({
                               type: 'text' as const,
                               text: contentPart.text,
                             };
-                          case 'image-data': {
-                            return {
-                              type: 'image' as const,
-                              source: {
-                                type: 'base64' as const,
-                                media_type: contentPart.mediaType,
-                                data: contentPart.data,
-                              },
-                            };
-                          }
-                          case 'image-url': {
-                            return {
-                              type: 'image' as const,
-                              source: {
-                                type: 'url' as const,
-                                url: contentPart.url,
-                              },
-                            };
-                          }
                           case 'file-url': {
+                            if (contentPart.mediaType.startsWith('image/')) {
+                              return {
+                                type: 'image' as const,
+                                source: {
+                                  type: 'url' as const,
+                                  url: contentPart.url,
+                                },
+                              };
+                            }
                             return {
                               type: 'document' as const,
                               source: {
@@ -338,6 +350,16 @@ export async function convertToAnthropicMessagesPrompt({
                             };
                           }
                           case 'file-data': {
+                            if (contentPart.mediaType.startsWith('image/')) {
+                              return {
+                                type: 'image' as const,
+                                source: {
+                                  type: 'base64' as const,
+                                  media_type: contentPart.mediaType,
+                                  data: contentPart.data,
+                                },
+                              };
+                            }
                             if (contentPart.mediaType === 'application/pdf') {
                               betas.add('pdfs-2024-09-25');
                               return {
@@ -391,7 +413,8 @@ export async function convertToAnthropicMessagesPrompt({
                     contentValue = output.value;
                     break;
                   case 'execution-denied':
-                    contentValue = output.reason ?? 'Tool execution denied.';
+                    contentValue =
+                      output.reason ?? 'Tool call execution denied.';
                     break;
                   case 'json':
                   case 'error-json':

package/src/get-cache-control.ts

@@ -1,5 +1,5 @@
 import { SharedV4Warning, SharedV4ProviderMetadata } from '@ai-sdk/provider';
-import { AnthropicCacheControl } from './anthropic-messages-api';
+import { AnthropicCacheControl } from './anthropic-api';
 
 // Anthropic allows a maximum of 4 cache breakpoints per request
 const MAX_CACHE_BREAKPOINTS = 4;

package/src/index.ts

@@ -6,7 +6,7 @@ export type {
   AnthropicLanguageModelOptions,
   /** @deprecated Use `AnthropicLanguageModelOptions` instead. */
   AnthropicLanguageModelOptions as AnthropicProviderOptions,
-} from './anthropic-messages-options';
+} from './anthropic-options';
 export type { AnthropicToolOptions } from './anthropic-prepare-tools';
 export { anthropic, createAnthropic } from './anthropic-provider';
 export type {

package/src/internal/index.ts

@@ -1,4 +1,13 @@
-export { AnthropicMessagesLanguageModel } from '../anthropic-messages-language-model';
+export {
+  AnthropicLanguageModel,
+  /** @deprecated Use `AnthropicLanguageModel` instead. */
+  AnthropicLanguageModel as AnthropicMessagesLanguageModel,
+  getModelCapabilities,
+} from '../anthropic-language-model';
 export { anthropicTools } from '../anthropic-tools';
-export type { AnthropicMessagesModelId } from '../anthropic-messages-options';
+export type {
+  AnthropicModelId,
+  /** @deprecated Use `AnthropicModelId` instead. */
+  AnthropicModelId as AnthropicMessagesModelId,
+} from '../anthropic-options';
 export { prepareTools } from '../anthropic-prepare-tools';