@ai-sdk/anthropic 4.0.0-beta.3 → 4.0.0-beta.32

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

@@ -23,11 +23,18 @@ import {
   FetchFunction,
   generateId,
   InferSchema,
+  isCustomReasoning,
+  mapReasoningToProviderBudget,
+  mapReasoningToProviderEffort,
   parseProviderOptions,
   ParseResult,
   postJsonToApi,
   Resolvable,
   resolve,
+  resolveProviderReference,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE,
 } from '@ai-sdk/provider-utils';
 import { anthropicFailedResponseHandler } from './anthropic-error';
 import { AnthropicMessageMetadata } from './anthropic-message-metadata';
@@ -42,6 +49,7 @@ import {
 } from './anthropic-messages-api';
 import {
   AnthropicMessagesModelId,
+  AnthropicLanguageModelOptions,
   anthropicLanguageModelOptions,
 } from './anthropic-messages-options';
 import { prepareTools } from './anthropic-prepare-tools';
@@ -115,7 +123,7 @@ function createCitationSource(
 type AnthropicMessagesConfig = {
   provider: string;
   baseURL: string;
-  headers: Resolvable<Record<string, string | undefined>>;
+  headers?: Resolvable<Record<string, string | undefined>>;
   fetch?: FetchFunction;
   buildRequestUrl?: (baseURL: string, isStreaming: boolean) => string;
   transformRequestBody?: (
@@ -129,6 +137,12 @@ type AnthropicMessagesConfig = {
    * When false, the model will use JSON tool fallback for structured outputs.
    */
   supportsNativeStructuredOutput?: boolean;
+
+  /**
+   * When false, `strict` on tool definitions will be ignored and a warning emitted.
+   * Defaults to true.
+   */
+  supportsStrictTools?: boolean;
 };
 
 export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
@@ -139,6 +153,20 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
   private readonly config: AnthropicMessagesConfig;
   private readonly generateId: () => string;
 
+  static [WORKFLOW_SERIALIZE](model: AnthropicMessagesLanguageModel) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config,
+    });
+  }
+
+  static [WORKFLOW_DESERIALIZE](options: {
+    modelId: AnthropicMessagesModelId;
+    config: AnthropicMessagesConfig;
+  }) {
+    return new AnthropicMessagesLanguageModel(options.modelId, options.config);
+  }
+
   constructor(
     modelId: AnthropicMessagesModelId,
     config: AnthropicMessagesConfig,
@@ -184,6 +212,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
     seed,
     tools,
     toolChoice,
+    reasoning,
     providerOptions,
     stream,
   }: LanguageModelV4CallOptions & {
@@ -263,13 +292,49 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
     const {
       maxOutputTokens: maxOutputTokensForModel,
       supportsStructuredOutput: modelSupportsStructuredOutput,
+      supportsAdaptiveThinking,
+      rejectsSamplingParameters,
+      supportsXhighEffort,
       isKnownModel,
     } = getModelCapabilities(this.modelId);
 
+    if (rejectsSamplingParameters) {
+      if (temperature != null) {
+        warnings.push({
+          type: 'unsupported',
+          feature: 'temperature',
+          details: `temperature is not supported by ${this.modelId} and will be ignored`,
+        });
+        temperature = undefined;
+      }
+      if (topK != null) {
+        warnings.push({
+          type: 'unsupported',
+          feature: 'topK',
+          details: `topK is not supported by ${this.modelId} and will be ignored`,
+        });
+        topK = undefined;
+      }
+      if (topP != null) {
+        warnings.push({
+          type: 'unsupported',
+          feature: 'topP',
+          details: `topP is not supported by ${this.modelId} and will be ignored`,
+        });
+        topP = undefined;
+      }
+    }
+
+    const isAnthropicModel = isKnownModel || this.modelId.startsWith('claude-');
+
     const supportsStructuredOutput =
       (this.config.supportsNativeStructuredOutput ?? true) &&
       modelSupportsStructuredOutput;
 
+    const supportsStrictTools =
+      (this.config.supportsStrictTools ?? true) &&
+      modelSupportsStructuredOutput;
+
     const structureOutputMode =
       anthropicOptions?.structuredOutputMode ?? 'auto';
     const useStructuredOutput =
@@ -326,6 +391,31 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
         toolNameMapping,
       });
 
+    /*
+     * Map top-level `reasoning` to Anthropic thinking/effort when provider
+     * options don't already specify them. Provider options always take precedence.
+     */
+    if (isCustomReasoning(reasoning) && anthropicOptions?.effort == null) {
+      const reasoningConfig = resolveAnthropicReasoningConfig({
+        reasoning,
+        supportsAdaptiveThinking,
+        supportsXhighEffort,
+        maxOutputTokensForModel,
+        warnings,
+      });
+      if (reasoningConfig != null) {
+        if (anthropicOptions.thinking == null) {
+          anthropicOptions.thinking = reasoningConfig.thinking;
+        }
+        if (
+          reasoningConfig.effort != null &&
+          anthropicOptions.thinking?.type !== 'disabled'
+        ) {
+          anthropicOptions.effort = reasoningConfig.effort;
+        }
+      }
+    }
+
     const thinkingType = anthropicOptions?.thinking?.type;
     const isThinking =
       thinkingType === 'enabled' || thinkingType === 'adaptive';
@@ -333,6 +423,10 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
       thinkingType === 'enabled'
         ? anthropicOptions?.thinking?.budgetTokens
         : undefined;
+    const thinkingDisplay =
+      thinkingType === 'adaptive'
+        ? anthropicOptions?.thinking?.display
+        : undefined;
 
     const maxTokens = maxOutputTokens ?? maxOutputTokensForModel;
 
@@ -352,9 +446,11 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
         thinking: {
           type: thinkingType,
           ...(thinkingBudget != null && { budget_tokens: thinkingBudget }),
+          ...(thinkingDisplay != null && { display: thinkingDisplay }),
         },
       }),
       ...((anthropicOptions?.effort ||
+        anthropicOptions?.taskBudget ||
         (useStructuredOutput &&
           responseFormat?.type === 'json' &&
           responseFormat.schema != null)) && {
@@ -362,6 +458,15 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
           ...(anthropicOptions?.effort && {
             effort: anthropicOptions.effort,
           }),
+          ...(anthropicOptions?.taskBudget && {
+            task_budget: {
+              type: anthropicOptions.taskBudget.type,
+              total: anthropicOptions.taskBudget.total,
+              ...(anthropicOptions.taskBudget.remaining != null && {
+                remaining: anthropicOptions.taskBudget.remaining,
+              }),
+            },
+          }),
           ...(useStructuredOutput &&
             responseFormat?.type === 'json' &&
             responseFormat.schema != null && {
@@ -375,9 +480,15 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
       ...(anthropicOptions?.speed && {
         speed: anthropicOptions.speed,
       }),
+      ...(anthropicOptions?.inferenceGeo && {
+        inference_geo: anthropicOptions.inferenceGeo,
+      }),
       ...(anthropicOptions?.cacheControl && {
         cache_control: anthropicOptions.cacheControl,
       }),
+      ...(anthropicOptions?.metadata?.userId != null && {
+        metadata: { user_id: anthropicOptions.metadata.userId },
+      }),
 
       // mcp servers:
       ...(anthropicOptions?.mcpServers &&
@@ -406,7 +517,13 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
                 id: anthropicOptions.container.id,
                 skills: anthropicOptions.container.skills.map(skill => ({
                   type: skill.type,
-                  skill_id: skill.skillId,
+                  skill_id:
+                    skill.type === 'custom'
+                      ? resolveProviderReference({
+                          reference: skill.providerReference,
+                          provider: 'anthropic',
+                        })
+                      : skill.skillId,
                   version: skill.version,
                 })),
               } satisfies AnthropicContainer)
@@ -522,8 +639,10 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
       // adjust max tokens to account for thinking:
       baseArgs.max_tokens = maxTokens + (thinkingBudget ?? 0);
     } else {
-      // Only check temperature/topP mutual exclusivity when thinking is not enabled
-      if (topP != null && temperature != null) {
+      // Only check temperature/topP mutual exclusivity for known Anthropic models
+      // when thinking is not enabled. Non-Anthropic models using the Anthropic-compatible
+      // API (e.g. Minimax) may require both parameters to be set.
+      if (isAnthropicModel && topP != null && temperature != null) {
         warnings.push({
           type: 'unsupported',
           feature: 'topP',
@@ -592,14 +711,16 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
       betas.add('effort-2025-11-24');
     }
 
+    if (anthropicOptions?.taskBudget) {
+      betas.add('task-budgets-2026-03-13');
+    }
+
     if (anthropicOptions?.speed === 'fast') {
       betas.add('fast-mode-2026-02-01');
     }
 
-    // only when streaming: enable fine-grained tool streaming
-    if (stream && (anthropicOptions?.toolStreaming ?? true)) {
-      betas.add('fine-grained-tool-streaming-2025-05-14');
-    }
+    const defaultEagerInputStreaming =
+      stream && (anthropicOptions?.toolStreaming ?? true);
 
     const {
       tools: anthropicTools,
@@ -614,6 +735,8 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
             disableParallelToolUse: true,
             cacheControlValidator,
             supportsStructuredOutput: false,
+            supportsStrictTools,
+            defaultEagerInputStreaming,
           }
         : {
             tools: tools ?? [],
@@ -621,6 +744,8 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
             disableParallelToolUse: anthropicOptions?.disableParallelToolUse,
             cacheControlValidator,
             supportsStructuredOutput,
+            supportsStrictTools,
+            defaultEagerInputStreaming,
           },
     );
 
@@ -656,7 +781,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
     headers: Record<string, string | undefined> | undefined;
   }) {
     return combineHeaders(
-      await resolve(this.config.headers),
+      this.config.headers ? await resolve(this.config.headers) : undefined,
       headers,
       betas.size > 0 ? { 'anthropic-beta': Array.from(betas).join(',') } : {},
     );
@@ -665,9 +790,11 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
   private async getBetasFromHeaders(
     requestHeaders: Record<string, string | undefined> | undefined,
   ) {
-    const configHeaders = await resolve(this.config.headers);
+    const configHeaders = this.config.headers
+      ? await resolve(this.config.headers)
+      : undefined;
 
-    const configBetaHeader = configHeaders['anthropic-beta'] ?? '';
+    const configBetaHeader = configHeaders?.['anthropic-beta'] ?? '';
     const requestBetaHeader = requestHeaders?.['anthropic-beta'] ?? '';
 
     return new Set(
@@ -1221,6 +1348,8 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
   async doStream(
     options: LanguageModelV4CallOptions,
   ): Promise<LanguageModelV4StreamResult> {
+    'use step';
+
     const {
       args: body,
       warnings,
@@ -2259,18 +2388,33 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
  * @see https://docs.claude.com/en/docs/about-claude/models/overview#model-comparison-table
  * @see https://platform.claude.com/docs/en/build-with-claude/structured-outputs
  */
-function getModelCapabilities(modelId: string): {
+export function getModelCapabilities(modelId: string): {
   maxOutputTokens: number;
   supportsStructuredOutput: boolean;
+  supportsAdaptiveThinking: boolean;
+  rejectsSamplingParameters: boolean;
+  supportsXhighEffort: boolean;
   isKnownModel: boolean;
 } {
-  if (
+  if (modelId.includes('claude-opus-4-7')) {
+    return {
+      maxOutputTokens: 128000,
+      supportsStructuredOutput: true,
+      supportsAdaptiveThinking: true,
+      rejectsSamplingParameters: true,
+      supportsXhighEffort: true,
+      isKnownModel: true,
+    };
+  } else if (
     modelId.includes('claude-sonnet-4-6') ||
     modelId.includes('claude-opus-4-6')
   ) {
     return {
       maxOutputTokens: 128000,
       supportsStructuredOutput: true,
+      supportsAdaptiveThinking: true,
+      rejectsSamplingParameters: false,
+      supportsXhighEffort: false,
       isKnownModel: true,
     };
   } else if (
@@ -2281,36 +2425,54 @@ function getModelCapabilities(modelId: string): {
     return {
       maxOutputTokens: 64000,
       supportsStructuredOutput: true,
+      supportsAdaptiveThinking: false,
+      rejectsSamplingParameters: false,
+      supportsXhighEffort: false,
       isKnownModel: true,
     };
   } else if (modelId.includes('claude-opus-4-1')) {
     return {
       maxOutputTokens: 32000,
       supportsStructuredOutput: true,
+      supportsAdaptiveThinking: false,
+      rejectsSamplingParameters: false,
+      supportsXhighEffort: false,
       isKnownModel: true,
     };
   } else if (modelId.includes('claude-sonnet-4-')) {
     return {
       maxOutputTokens: 64000,
       supportsStructuredOutput: false,
+      supportsAdaptiveThinking: false,
+      rejectsSamplingParameters: false,
+      supportsXhighEffort: false,
       isKnownModel: true,
     };
   } else if (modelId.includes('claude-opus-4-')) {
     return {
       maxOutputTokens: 32000,
       supportsStructuredOutput: false,
+      supportsAdaptiveThinking: false,
+      rejectsSamplingParameters: false,
+      supportsXhighEffort: false,
       isKnownModel: true,
     };
   } else if (modelId.includes('claude-3-haiku')) {
     return {
       maxOutputTokens: 4096,
       supportsStructuredOutput: false,
+      supportsAdaptiveThinking: false,
+      rejectsSamplingParameters: false,
+      supportsXhighEffort: false,
       isKnownModel: true,
     };
   } else {
     return {
       maxOutputTokens: 4096,
       supportsStructuredOutput: false,
+      supportsAdaptiveThinking: false,
+      rejectsSamplingParameters: false,
+      supportsXhighEffort: false,
       isKnownModel: false,
     };
   }
@@ -2341,6 +2503,54 @@ function hasWebTool20260209WithoutCodeExecution(
   return hasWebTool20260209 && !hasCodeExecutionTool;
 }
 
+function resolveAnthropicReasoningConfig({
+  reasoning,
+  supportsAdaptiveThinking,
+  supportsXhighEffort,
+  maxOutputTokensForModel,
+  warnings,
+}: {
+  reasoning: LanguageModelV4CallOptions['reasoning'];
+  supportsAdaptiveThinking: boolean;
+  supportsXhighEffort: boolean;
+  maxOutputTokensForModel: number;
+  warnings: SharedV4Warning[];
+}): Pick<AnthropicLanguageModelOptions, 'thinking' | 'effort'> | undefined {
+  if (!isCustomReasoning(reasoning)) {
+    return undefined;
+  }
+
+  if (reasoning === 'none') {
+    return { thinking: { type: 'disabled' } };
+  }
+
+  if (supportsAdaptiveThinking) {
+    const effort = mapReasoningToProviderEffort({
+      reasoning,
+      effortMap: {
+        minimal: 'low' as const,
+        low: 'low' as const,
+        medium: 'medium' as const,
+        high: 'high' as const,
+        xhigh: supportsXhighEffort ? ('xhigh' as const) : ('max' as const),
+      },
+      warnings,
+    });
+    return { thinking: { type: 'adaptive' }, effort };
+  }
+
+  const budgetTokens = mapReasoningToProviderBudget({
+    reasoning,
+    maxOutputTokens: maxOutputTokensForModel,
+    maxReasoningBudget: maxOutputTokensForModel,
+    warnings,
+  });
+  if (budgetTokens == null) {
+    return undefined;
+  }
+  return { thinking: { type: 'enabled', budgetTokens } };
+}
+
 function mapAnthropicResponseContextManagement(
   contextManagement: AnthropicResponseContextManagement | null | undefined,
 ): AnthropicMessageMetadata['contextManagement'] | null {

package/src/anthropic-messages-options.ts

@@ -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

@@ -26,6 +26,8 @@ export async function prepareTools({
   disableParallelToolUse,
   cacheControlValidator,
   supportsStructuredOutput,
+  supportsStrictTools,
+  defaultEagerInputStreaming = false,
 }: {
   tools: LanguageModelV4CallOptions['tools'];
   toolChoice: LanguageModelV4CallOptions['toolChoice'] | undefined;
@@ -33,9 +35,20 @@ export async function prepareTools({
   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;
+
+  /**
+   * 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;
@@ -67,18 +80,28 @@ 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;
 
+        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 } : {}),
@@ -308,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',
@@ -317,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',