@ai-sdk/anthropic 4.0.0-beta.5 → 4.0.0-beta.67

package/src/{anthropic-messages-language-model.ts → anthropic-language-model.ts}

@@ -1,57 +1,70 @@
 import {
   APICallError,
-  JSONObject,
-  LanguageModelV4,
-  LanguageModelV4CallOptions,
-  LanguageModelV4Content,
-  LanguageModelV4FinishReason,
-  LanguageModelV4FunctionTool,
-  LanguageModelV4GenerateResult,
-  LanguageModelV4Prompt,
-  LanguageModelV4Source,
-  LanguageModelV4StreamPart,
-  LanguageModelV4StreamResult,
-  LanguageModelV4ToolCall,
-  SharedV4ProviderMetadata,
-  SharedV4Warning,
+  type JSONObject,
+  type LanguageModelV4,
+  type LanguageModelV4CallOptions,
+  type LanguageModelV4Content,
+  type LanguageModelV4FinishReason,
+  type LanguageModelV4FunctionTool,
+  type LanguageModelV4GenerateResult,
+  type LanguageModelV4Prompt,
+  type LanguageModelV4Source,
+  type LanguageModelV4StreamPart,
+  type LanguageModelV4StreamResult,
+  type LanguageModelV4ToolCall,
+  type SharedV4ProviderMetadata,
+  type SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonResponseHandler,
   createToolNameMapping,
-  FetchFunction,
   generateId,
-  InferSchema,
+  isCustomReasoning,
+  mapReasoningToProviderBudget,
+  mapReasoningToProviderEffort,
   parseProviderOptions,
-  ParseResult,
   postJsonToApi,
-  Resolvable,
   resolve,
+  resolveProviderReference,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE,
+  type FetchFunction,
+  type InferSchema,
+  type ParseResult,
+  type Resolvable,
 } from '@ai-sdk/provider-utils';
 import { anthropicFailedResponseHandler } from './anthropic-error';
-import { AnthropicMessageMetadata } from './anthropic-message-metadata';
+import type {
+  AnthropicMessageMetadata,
+  AnthropicUsageIteration,
+} from './anthropic-message-metadata';
 import {
-  AnthropicContainer,
-  anthropicMessagesChunkSchema,
-  anthropicMessagesResponseSchema,
-  AnthropicReasoningMetadata,
-  AnthropicResponseContextManagement,
-  AnthropicTool,
-  Citation,
-} from './anthropic-messages-api';
+  anthropicChunkSchema,
+  anthropicResponseSchema,
+  type AnthropicContainer,
+  type AnthropicReasoningMetadata,
+  type AnthropicResponseContextManagement,
+  type AnthropicStopDetails,
+  type AnthropicTool,
+  type Citation,
+} from './anthropic-api';
 import {
-  AnthropicMessagesModelId,
   anthropicLanguageModelOptions,
-} from './anthropic-messages-options';
+  type AnthropicModelId,
+  type AnthropicLanguageModelOptions,
+} from './anthropic-language-model-options';
 import { prepareTools } from './anthropic-prepare-tools';
 import {
-  AnthropicMessagesUsage,
-  convertAnthropicMessagesUsage,
-} from './convert-anthropic-messages-usage';
-import { convertToAnthropicMessagesPrompt } from './convert-to-anthropic-messages-prompt';
+  convertAnthropicUsage,
+  type AnthropicUsage,
+} from './convert-anthropic-usage';
+import { convertToAnthropicPrompt } from './convert-to-anthropic-prompt';
 import { CacheControlValidator } from './get-cache-control';
 import { mapAnthropicStopReason } from './map-anthropic-stop-reason';
+import { sanitizeJsonSchema } from './sanitize-json-schema';
 
 function createCitationSource(
   citation: Citation,
@@ -112,10 +125,10 @@ function createCitationSource(
   };
 }
 
-type AnthropicMessagesConfig = {
+type AnthropicLanguageModelConfig = {
   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?: (
@@ -137,18 +150,29 @@ type AnthropicMessagesConfig = {
   supportsStrictTools?: boolean;
 };
 
-export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
+export class AnthropicLanguageModel implements LanguageModelV4 {
   readonly specificationVersion = 'v4';
 
-  readonly modelId: AnthropicMessagesModelId;
+  readonly modelId: AnthropicModelId;
 
-  private readonly config: AnthropicMessagesConfig;
+  private readonly config: AnthropicLanguageModelConfig;
   private readonly generateId: () => string;
 
-  constructor(
-    modelId: AnthropicMessagesModelId,
-    config: AnthropicMessagesConfig,
-  ) {
+  static [WORKFLOW_SERIALIZE](model: AnthropicLanguageModel) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config,
+    });
+  }
+
+  static [WORKFLOW_DESERIALIZE](options: {
+    modelId: AnthropicModelId;
+    config: AnthropicLanguageModelConfig;
+  }) {
+    return new AnthropicLanguageModel(options.modelId, options.config);
+  }
+
+  constructor(modelId: AnthropicModelId, config: AnthropicLanguageModelConfig) {
     this.modelId = modelId;
     this.config = config;
     this.generateId = config.generateId ?? generateId;
@@ -190,6 +214,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
     seed,
     tools,
     toolChoice,
+    reasoning,
     providerOptions,
     stream,
   }: LanguageModelV4CallOptions & {
@@ -269,9 +294,41 @@ 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;
@@ -324,17 +381,42 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
         'anthropic.web_fetch_20260209': 'web_fetch',
         'anthropic.tool_search_regex_20251119': 'tool_search_tool_regex',
         'anthropic.tool_search_bm25_20251119': 'tool_search_tool_bm25',
+        'anthropic.advisor_20260301': 'advisor',
       },
     });
 
-    const { prompt: messagesPrompt, betas } =
-      await convertToAnthropicMessagesPrompt({
-        prompt,
-        sendReasoning: anthropicOptions?.sendReasoning ?? true,
+    const { prompt: messagesPrompt, betas } = await convertToAnthropicPrompt({
+      prompt,
+      sendReasoning: anthropicOptions?.sendReasoning ?? true,
+      warnings,
+      cacheControlValidator,
+      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,
-        cacheControlValidator,
-        toolNameMapping,
       });
+      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 =
@@ -343,6 +425,10 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
       thinkingType === 'enabled'
         ? anthropicOptions?.thinking?.budgetTokens
         : undefined;
+    const thinkingDisplay =
+      thinkingType === 'adaptive'
+        ? anthropicOptions?.thinking?.display
+        : undefined;
 
     const maxTokens = maxOutputTokens ?? maxOutputTokensForModel;
 
@@ -362,9 +448,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)) && {
@@ -372,12 +460,21 @@ 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 && {
               format: {
                 type: 'json_schema',
-                schema: responseFormat.schema,
+                schema: sanitizeJsonSchema(responseFormat.schema),
               },
             }),
         },
@@ -385,9 +482,19 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
       ...(anthropicOptions?.speed && {
         speed: anthropicOptions.speed,
       }),
+      ...(anthropicOptions?.inferenceGeo && {
+        inference_geo: anthropicOptions.inferenceGeo,
+      }),
+      ...(anthropicOptions?.fallbacks &&
+        anthropicOptions.fallbacks.length > 0 && {
+          fallbacks: anthropicOptions.fallbacks,
+        }),
       ...(anthropicOptions?.cacheControl && {
         cache_control: anthropicOptions.cacheControl,
       }),
+      ...(anthropicOptions?.metadata?.userId != null && {
+        metadata: { user_id: anthropicOptions.metadata.userId },
+      }),
 
       // mcp servers:
       ...(anthropicOptions?.mcpServers &&
@@ -416,7 +523,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)
@@ -532,8 +645,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',
@@ -598,19 +713,21 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
       }
     }
 
-    if (anthropicOptions?.effort) {
-      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');
+    if (anthropicOptions?.fallbacks && anthropicOptions.fallbacks.length > 0) {
+      betas.add('server-side-fallback-2026-06-01');
     }
 
+    const defaultEagerInputStreaming =
+      stream && (anthropicOptions?.toolStreaming ?? true);
+
     const {
       tools: anthropicTools,
       toolChoice: anthropicToolChoice,
@@ -625,6 +742,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
             cacheControlValidator,
             supportsStructuredOutput: false,
             supportsStrictTools,
+            defaultEagerInputStreaming,
           }
         : {
             tools: tools ?? [],
@@ -633,6 +751,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
             cacheControlValidator,
             supportsStructuredOutput,
             supportsStrictTools,
+            defaultEagerInputStreaming,
           },
     );
 
@@ -668,7 +787,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(',') } : {},
     );
@@ -677,9 +796,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(
@@ -785,7 +906,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
       body: this.transformRequestBody(args, betas),
       failedResponseHandler: anthropicFailedResponseHandler,
       successfulResponseHandler: createJsonResponseHandler(
-        anthropicMessagesResponseSchema,
+        anthropicResponseSchema,
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch,
@@ -900,12 +1021,23 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
             part.name === 'text_editor_code_execution' ||
             part.name === 'bash_code_execution'
           ) {
+            // map tool names for the code execution 20250825 tool:
+            // both map to 'code_execution'.
+            const providerToolName = 'code_execution';
             content.push({
               type: 'tool-call',
               toolCallId: part.id,
               toolName: toolNameMapping.toCustomToolName('code_execution'),
               input: JSON.stringify({ type: part.name, ...part.input }),
               providerExecuted: true,
+              // Specific 'web_fetch' or 'web_search' tools may need code execution, which the Anthropic API
+              // implicitly allows. In this scenario, we need to allow 'code_execution' tool calls even if the
+              // tool was not explicitly provided. We therefore bypass the general validation by marking the
+              // tool as dynamic.
+              ...(markCodeExecutionDynamic &&
+              providerToolName === 'code_execution'
+                ? { dynamic: true }
+                : {}),
             });
           } else if (
             part.name === 'web_search' ||
@@ -928,8 +1060,10 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
               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.
+              // Specific 'web_fetch' or 'web_search' tools may need code execution, which the Anthropic API
+              // implicitly allows. In this scenario, we need to allow 'code_execution' tool calls even if the
+              // tool was not explicitly provided. We therefore bypass the general validation by marking the
+              // tool as dynamic.
               ...(markCodeExecutionDynamic && part.name === 'code_execution'
                 ? { dynamic: true }
                 : {}),
@@ -946,6 +1080,14 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
               input: JSON.stringify(part.input),
               providerExecuted: true,
             });
+          } else if (part.name === 'advisor') {
+            content.push({
+              type: 'tool-call',
+              toolCallId: part.id,
+              toolName: toolNameMapping.toCustomToolName('advisor'),
+              input: JSON.stringify(part.input),
+              providerExecuted: true,
+            });
           }
 
           break;
@@ -1164,6 +1306,51 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
           }
           break;
         }
+
+        // advisor results for advisor_20260301:
+        case 'advisor_tool_result': {
+          const advisorToolName = toolNameMapping.toCustomToolName('advisor');
+          if (part.content.type === 'advisor_result') {
+            content.push({
+              type: 'tool-result',
+              toolCallId: part.tool_use_id,
+              toolName: advisorToolName,
+              result: {
+                type: 'advisor_result',
+                text: part.content.text,
+              },
+            });
+          } else if (part.content.type === 'advisor_redacted_result') {
+            content.push({
+              type: 'tool-result',
+              toolCallId: part.tool_use_id,
+              toolName: advisorToolName,
+              result: {
+                type: 'advisor_redacted_result',
+                encryptedContent: part.content.encrypted_content,
+              },
+            });
+          } else {
+            content.push({
+              type: 'tool-result',
+              toolCallId: part.tool_use_id,
+              toolName: advisorToolName,
+              isError: true,
+              result: {
+                type: 'advisor_tool_result_error',
+                errorCode: part.content.error_code,
+              },
+            });
+          }
+          break;
+        }
+
+        // Server-side fallback marker: the AI SDK has no content primitive for
+        // a model hop, so drop it. The hop is still observable via
+        // usage.iterations.
+        case 'fallback': {
+          break;
+        }
       }
     }
 
@@ -1176,7 +1363,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
         }),
         raw: response.stop_reason ?? undefined,
       },
-      usage: convertAnthropicMessagesUsage({ usage: response.usage }),
+      usage: convertAnthropicUsage({ usage: response.usage }),
       request: { body: args },
       response: {
         id: response.id ?? undefined,
@@ -1186,18 +1373,34 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
       },
       warnings,
       providerMetadata: (() => {
+        const stopDetails = mapAnthropicStopDetails(response.stop_details);
+
         const anthropicMetadata = {
           usage: response.usage as JSONObject,
-          cacheCreationInputTokens:
-            response.usage.cache_creation_input_tokens ?? null,
           stopSequence: response.stop_sequence ?? null,
+          ...(stopDetails != null ? { stopDetails } : {}),
 
           iterations: response.usage.iterations
-            ? response.usage.iterations.map(iter => ({
-                type: iter.type,
-                inputTokens: iter.input_tokens,
-                outputTokens: iter.output_tokens,
-              }))
+            ? response.usage.iterations.map(
+                iter =>
+                  ({
+                    type: iter.type,
+                    ...(iter.model != null ? { model: iter.model } : {}),
+                    inputTokens: iter.input_tokens,
+                    outputTokens: iter.output_tokens,
+                    ...(iter.cache_creation_input_tokens
+                      ? {
+                          cacheCreationInputTokens:
+                            iter.cache_creation_input_tokens,
+                        }
+                      : {}),
+                    ...(iter.cache_read_input_tokens
+                      ? {
+                          cacheReadInputTokens: iter.cache_read_input_tokens,
+                        }
+                      : {}),
+                  }) satisfies AnthropicUsageIteration,
+              )
             : null,
           container: response.container
             ? {
@@ -1233,6 +1436,8 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
   async doStream(
     options: LanguageModelV4CallOptions,
   ): Promise<LanguageModelV4StreamResult> {
+    'use step';
+
     const {
       args: body,
       warnings,
@@ -1262,9 +1467,8 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
       headers: await this.getHeaders({ betas, headers: options.headers }),
       body: this.transformRequestBody(body, betas),
       failedResponseHandler: anthropicFailedResponseHandler,
-      successfulResponseHandler: createEventSourceResponseHandler(
-        anthropicMessagesChunkSchema,
-      ),
+      successfulResponseHandler:
+        createEventSourceResponseHandler(anthropicChunkSchema),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch,
     });
@@ -1273,7 +1477,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
       unified: 'other',
       raw: undefined,
     };
-    const usage: AnthropicMessagesUsage = {
+    const usage: AnthropicUsage = {
       input_tokens: 0,
       output_tokens: 0,
       cache_creation_input_tokens: 0,
@@ -1308,8 +1512,8 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
       | AnthropicMessageMetadata['contextManagement']
       | null = null;
     let rawUsage: JSONObject | undefined = undefined;
-    let cacheCreationInputTokens: number | null = null;
     let stopSequence: string | null = null;
+    let stopDetails: AnthropicMessageMetadata['stopDetails'] = undefined;
     let container: AnthropicMessageMetadata['container'] | null = null;
     let isJsonResponseFromTool = false;
 
@@ -1325,6 +1529,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
       | 'text_editor_code_execution_tool_result'
       | 'bash_code_execution_tool_result'
       | 'tool_search_tool_result'
+      | 'advisor_tool_result'
       | 'mcp_tool_use'
       | 'mcp_tool_result'
       | 'compaction'
@@ -1334,7 +1539,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
 
     const transformedStream = response.pipeThrough(
       new TransformStream<
-        ParseResult<InferSchema<typeof anthropicMessagesChunkSchema>>,
+        ParseResult<InferSchema<typeof anthropicChunkSchema>>,
         LanguageModelV4StreamPart
       >({
         start(controller) {
@@ -1361,6 +1566,14 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
             case 'content_block_start': {
               const part = value.content_block;
               const contentBlockType = part.type;
+
+              // Server-side fallback marker: the AI SDK has no content
+              // primitive for a model hop, so drop it. The hop is still
+              // observable via usage.iterations.
+              if (contentBlockType === 'fallback') {
+                return;
+              }
+
               blockType = contentBlockType;
 
               switch (contentBlockType) {
@@ -1506,12 +1719,16 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
                       toolName: customToolName,
                       input: finalInput,
                       providerExecuted: true,
+                      // Specific 'web_fetch' or 'web_search' tools may need code execution, which the Anthropic API
+                      // implicitly allows. In this scenario, we need to allow 'code_execution' tool calls even if the
+                      // tool was not explicitly provided. We therefore bypass the general validation by marking the
+                      // tool as dynamic.
                       ...(markCodeExecutionDynamic &&
                       providerToolName === 'code_execution'
                         ? { dynamic: true }
                         : {}),
                       firstDelta: true,
-                      providerToolName: part.name,
+                      providerToolName,
                     };
 
                     controller.enqueue({
@@ -1519,6 +1736,10 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
                       id: part.id,
                       toolName: customToolName,
                       providerExecuted: true,
+                      // Specific 'web_fetch' or 'web_search' tools may need code execution, which the Anthropic API
+                      // implicitly allows. In this scenario, we need to allow 'code_execution' tool calls even if the
+                      // tool was not explicitly provided. We therefore bypass the general validation by marking the
+                      // tool as dynamic.
                       ...(markCodeExecutionDynamic &&
                       providerToolName === 'code_execution'
                         ? { dynamic: true }
@@ -1543,6 +1764,26 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
                       providerToolName: part.name,
                     };
 
+                    controller.enqueue({
+                      type: 'tool-input-start',
+                      id: part.id,
+                      toolName: customToolName,
+                      providerExecuted: true,
+                    });
+                  } else if (part.name === 'advisor') {
+                    const customToolName =
+                      toolNameMapping.toCustomToolName('advisor');
+
+                    contentBlocks[value.index] = {
+                      type: 'tool-call',
+                      toolCallId: part.id,
+                      toolName: customToolName,
+                      input: '{}',
+                      providerExecuted: true,
+                      firstDelta: true,
+                      providerToolName: part.name,
+                    };
+
                     controller.enqueue({
                       type: 'tool-input-start',
                       id: part.id,
@@ -1754,6 +1995,46 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
                   return;
                 }
 
+                // advisor results for advisor_20260301:
+                // arrives fully formed in a single content_block_start (no deltas).
+                case 'advisor_tool_result': {
+                  const advisorToolName =
+                    toolNameMapping.toCustomToolName('advisor');
+                  if (part.content.type === 'advisor_result') {
+                    controller.enqueue({
+                      type: 'tool-result',
+                      toolCallId: part.tool_use_id,
+                      toolName: advisorToolName,
+                      result: {
+                        type: 'advisor_result',
+                        text: part.content.text,
+                      },
+                    });
+                  } else if (part.content.type === 'advisor_redacted_result') {
+                    controller.enqueue({
+                      type: 'tool-result',
+                      toolCallId: part.tool_use_id,
+                      toolName: advisorToolName,
+                      result: {
+                        type: 'advisor_redacted_result',
+                        encryptedContent: part.content.encrypted_content,
+                      },
+                    });
+                  } else {
+                    controller.enqueue({
+                      type: 'tool-result',
+                      toolCallId: part.tool_use_id,
+                      toolName: advisorToolName,
+                      isError: true,
+                      result: {
+                        type: 'advisor_tool_result_error',
+                        errorCode: part.content.error_code,
+                      },
+                    });
+                  }
+                  return;
+                }
+
                 case 'mcp_tool_use': {
                   mcpToolCalls[part.id] = {
                     type: 'tool-call',
@@ -1859,6 +2140,10 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
                         toolName: contentBlock.toolName,
                         input: finalInput,
                         providerExecuted: contentBlock.providerExecuted,
+                        // Specific 'web_fetch' or 'web_search' tools may need code execution, which the Anthropic API
+                        // implicitly allows. In this scenario, we need to allow 'code_execution' tool calls even if the
+                        // tool was not explicitly provided. We therefore bypass the general validation by marking the
+                        // tool as dynamic.
                         ...(markCodeExecutionDynamic &&
                         contentBlock.providerToolName === 'code_execution'
                           ? { dynamic: true }
@@ -1972,12 +2257,9 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
                     // the type to the delta and change the tool name.
                     if (
                       contentBlock.firstDelta &&
-                      (contentBlock.providerToolName ===
-                        'bash_code_execution' ||
-                        contentBlock.providerToolName ===
-                          'text_editor_code_execution')
+                      contentBlock.providerToolName === 'code_execution'
                     ) {
-                      delta = `{"type": "${contentBlock.providerToolName}",${delta.substring(1)}`;
+                      delta = `{"type": "programmatic-tool-call",${delta.substring(1)}`;
                     }
 
                     controller.enqueue({
@@ -2028,9 +2310,6 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
                 ...(value.message.usage as JSONObject),
               };
 
-              cacheCreationInputTokens =
-                value.message.usage.cache_creation_input_tokens ?? null;
-
               if (value.message.container != null) {
                 container = {
                   expiresAt: value.message.container.expires_at,
@@ -2128,8 +2407,6 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
               if (value.usage.cache_creation_input_tokens != null) {
                 usage.cache_creation_input_tokens =
                   value.usage.cache_creation_input_tokens;
-                cacheCreationInputTokens =
-                  value.usage.cache_creation_input_tokens;
               }
               if (value.usage.iterations != null) {
                 usage.iterations = value.usage.iterations;
@@ -2144,6 +2421,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
               };
 
               stopSequence = value.delta.stop_sequence ?? null;
+              stopDetails = mapAnthropicStopDetails(value.delta.stop_details);
               container =
                 value.delta.container != null
                   ? {
@@ -2175,14 +2453,30 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
             case 'message_stop': {
               const anthropicMetadata = {
                 usage: (rawUsage as JSONObject) ?? null,
-                cacheCreationInputTokens,
                 stopSequence,
+                ...(stopDetails != null ? { stopDetails } : {}),
                 iterations: usage.iterations
-                  ? usage.iterations.map(iter => ({
-                      type: iter.type,
-                      inputTokens: iter.input_tokens,
-                      outputTokens: iter.output_tokens,
-                    }))
+                  ? usage.iterations.map(
+                      iter =>
+                        ({
+                          type: iter.type,
+                          ...(iter.model != null ? { model: iter.model } : {}),
+                          inputTokens: iter.input_tokens,
+                          outputTokens: iter.output_tokens,
+                          ...(iter.cache_creation_input_tokens
+                            ? {
+                                cacheCreationInputTokens:
+                                  iter.cache_creation_input_tokens,
+                              }
+                            : {}),
+                          ...(iter.cache_read_input_tokens
+                            ? {
+                                cacheReadInputTokens:
+                                  iter.cache_read_input_tokens,
+                              }
+                            : {}),
+                        }) satisfies AnthropicUsageIteration,
+                    )
                   : null,
                 container,
                 contextManagement,
@@ -2202,7 +2496,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
               controller.enqueue({
                 type: 'finish',
                 finishReason,
-                usage: convertAnthropicMessagesUsage({ usage, rawUsage }),
+                usage: convertAnthropicUsage({ usage, rawUsage }),
                 providerMetadata,
               });
               return;
@@ -2271,18 +2565,37 @@ 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 (
+    modelId.includes('claude-opus-4-8') ||
+    modelId.includes('claude-opus-4-7') ||
+    modelId.includes('claude-fable-5')
+  ) {
+    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 (
@@ -2293,36 +2606,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,
     };
   }
@@ -2353,6 +2684,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 {
@@ -2387,3 +2766,22 @@ function mapAnthropicResponseContextManagement(
       }
     : null;
 }
+
+function mapAnthropicStopDetails(
+  stopDetails: AnthropicStopDetails | null | undefined,
+): AnthropicMessageMetadata['stopDetails'] | undefined {
+  if (stopDetails == null) {
+    return undefined;
+  }
+
+  return {
+    type: stopDetails.type,
+    ...(stopDetails.category != null ? { category: stopDetails.category } : {}),
+    ...(stopDetails.explanation != null
+      ? { explanation: stopDetails.explanation }
+      : {}),
+    ...(stopDetails.recommended_model != null
+      ? { recommendedModel: stopDetails.recommended_model }
+      : {}),
+  };
+}