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

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

@@ -1,19 +1,19 @@
 import {
   APICallError,
   JSONObject,
-  LanguageModelV3,
-  LanguageModelV3CallOptions,
-  LanguageModelV3Content,
-  LanguageModelV3FinishReason,
-  LanguageModelV3FunctionTool,
-  LanguageModelV3GenerateResult,
-  LanguageModelV3Prompt,
-  LanguageModelV3Source,
-  LanguageModelV3StreamPart,
-  LanguageModelV3StreamResult,
-  LanguageModelV3ToolCall,
-  SharedV3ProviderMetadata,
-  SharedV3Warning,
+  LanguageModelV4,
+  LanguageModelV4CallOptions,
+  LanguageModelV4Content,
+  LanguageModelV4FinishReason,
+  LanguageModelV4FunctionTool,
+  LanguageModelV4GenerateResult,
+  LanguageModelV4Prompt,
+  LanguageModelV4Source,
+  LanguageModelV4StreamPart,
+  LanguageModelV4StreamResult,
+  LanguageModelV4ToolCall,
+  SharedV4ProviderMetadata,
+  SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
   combineHeaders,
@@ -29,6 +29,87 @@ import {
   Resolvable,
   resolve,
 } from '@ai-sdk/provider-utils';
+
+// Inlined from @ai-sdk/provider-utils (4.x) — not available in 3.x provider-utils
+type ReasoningLevel = Exclude<
+  LanguageModelV4CallOptions['reasoning'],
+  'none' | 'provider-default' | undefined
+>;
+
+function isCustomReasoning(
+  reasoning: LanguageModelV4CallOptions['reasoning'],
+): reasoning is Exclude<
+  LanguageModelV4CallOptions['reasoning'],
+  'provider-default' | undefined
+> {
+  return reasoning !== undefined && reasoning !== 'provider-default';
+}
+
+function mapReasoningToProviderEffort<T extends string>({
+  reasoning,
+  effortMap,
+  warnings,
+}: {
+  reasoning: ReasoningLevel;
+  effortMap: Partial<Record<ReasoningLevel, T>>;
+  warnings: SharedV4Warning[];
+}): T | undefined {
+  const mapped = effortMap[reasoning];
+  if (mapped == null) {
+    warnings.push({
+      type: 'unsupported',
+      feature: 'reasoning',
+      details: `reasoning "${reasoning}" is not supported by this model.`,
+    });
+    return undefined;
+  }
+  if (mapped !== reasoning) {
+    warnings.push({
+      type: 'compatibility',
+      feature: 'reasoning',
+      details: `reasoning "${reasoning}" is not directly supported by this model. mapped to effort "${mapped}".`,
+    });
+  }
+  return mapped;
+}
+
+const DEFAULT_REASONING_BUDGET_PERCENTAGES: Record<ReasoningLevel, number> = {
+  minimal: 0.02,
+  low: 0.1,
+  medium: 0.3,
+  high: 0.6,
+  xhigh: 0.9,
+};
+
+function mapReasoningToProviderBudget({
+  reasoning,
+  maxOutputTokens,
+  maxReasoningBudget,
+  minReasoningBudget = 1024,
+  budgetPercentages = DEFAULT_REASONING_BUDGET_PERCENTAGES,
+  warnings,
+}: {
+  reasoning: ReasoningLevel;
+  maxOutputTokens: number;
+  maxReasoningBudget: number;
+  minReasoningBudget?: number;
+  budgetPercentages?: Partial<Record<ReasoningLevel, number>>;
+  warnings: SharedV4Warning[];
+}): number | undefined {
+  const pct = budgetPercentages[reasoning];
+  if (pct == null) {
+    warnings.push({
+      type: 'unsupported',
+      feature: 'reasoning',
+      details: `reasoning "${reasoning}" is not supported by this model.`,
+    });
+    return undefined;
+  }
+  return Math.min(
+    maxReasoningBudget,
+    Math.max(minReasoningBudget, Math.round(maxOutputTokens * pct)),
+  );
+}
 import { anthropicFailedResponseHandler } from './anthropic-error';
 import { AnthropicMessageMetadata } from './anthropic-message-metadata';
 import {
@@ -42,6 +123,7 @@ import {
 } from './anthropic-messages-api';
 import {
   AnthropicMessagesModelId,
+  AnthropicLanguageModelOptions,
   anthropicLanguageModelOptions,
 } from './anthropic-messages-options';
 import { prepareTools } from './anthropic-prepare-tools';
@@ -61,7 +143,7 @@ function createCitationSource(
     mediaType: string;
   }>,
   generateId: () => string,
-): LanguageModelV3Source | undefined {
+): LanguageModelV4Source | undefined {
   if (citation.type === 'web_search_result_location') {
     return {
       type: 'source' as const,
@@ -74,7 +156,7 @@ function createCitationSource(
           citedText: citation.cited_text,
           encryptedIndex: citation.encrypted_index,
         },
-      } satisfies SharedV3ProviderMetadata,
+      } satisfies SharedV4ProviderMetadata,
     };
   }
 
@@ -108,7 +190,7 @@ function createCitationSource(
               startCharIndex: citation.start_char_index,
               endCharIndex: citation.end_char_index,
             },
-    } satisfies SharedV3ProviderMetadata,
+    } satisfies SharedV4ProviderMetadata,
   };
 }
 
@@ -122,17 +204,23 @@ type AnthropicMessagesConfig = {
     args: Record<string, any>,
     betas: Set<string>,
   ) => Record<string, any>;
-  supportedUrls?: () => LanguageModelV3['supportedUrls'];
+  supportedUrls?: () => LanguageModelV4['supportedUrls'];
   generateId?: () => string;
 
   /**
    * 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 LanguageModelV3 {
-  readonly specificationVersion = 'v3';
+export class AnthropicMessagesLanguageModel implements LanguageModelV4 {
+  readonly specificationVersion = 'v4';
 
   readonly modelId: AnthropicMessagesModelId;
 
@@ -184,13 +272,14 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
     seed,
     tools,
     toolChoice,
+    reasoning,
     providerOptions,
     stream,
-  }: LanguageModelV3CallOptions & {
+  }: LanguageModelV4CallOptions & {
     stream: boolean;
     userSuppliedBetas: Set<string>;
   }) {
-    const warnings: SharedV3Warning[] = [];
+    const warnings: SharedV4Warning[] = [];
 
     if (frequencyPenalty != null) {
       warnings.push({ type: 'unsupported', feature: 'frequencyPenalty' });
@@ -263,6 +352,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
     const {
       maxOutputTokens: maxOutputTokensForModel,
       supportsStructuredOutput: modelSupportsStructuredOutput,
+      supportsAdaptiveThinking,
       isKnownModel,
     } = getModelCapabilities(this.modelId);
 
@@ -270,13 +360,17 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
       (this.config.supportsNativeStructuredOutput ?? true) &&
       modelSupportsStructuredOutput;
 
+    const supportsStrictTools =
+      (this.config.supportsStrictTools ?? true) &&
+      modelSupportsStructuredOutput;
+
     const structureOutputMode =
       anthropicOptions?.structuredOutputMode ?? 'auto';
     const useStructuredOutput =
       structureOutputMode === 'outputFormat' ||
       (structureOutputMode === 'auto' && supportsStructuredOutput);
 
-    const jsonResponseTool: LanguageModelV3FunctionTool | undefined =
+    const jsonResponseTool: LanguageModelV4FunctionTool | undefined =
       responseFormat?.type === 'json' &&
       responseFormat.schema != null &&
       !useStructuredOutput
@@ -311,6 +405,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
         'anthropic.web_search_20250305': 'web_search',
         'anthropic.web_search_20260209': 'web_search',
         'anthropic.web_fetch_20250910': 'web_fetch',
+        'anthropic.web_fetch_20260309': 'web_fetch',
         'anthropic.web_fetch_20260209': 'web_fetch',
         'anthropic.tool_search_regex_20251119': 'tool_search_tool_regex',
         'anthropic.tool_search_bm25_20251119': 'tool_search_tool_bm25',
@@ -326,6 +421,29 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
         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?.thinking == null &&
+      anthropicOptions?.effort == null
+    ) {
+      const reasoningConfig = resolveAnthropicReasoningConfig({
+        reasoning,
+        supportsAdaptiveThinking,
+        maxOutputTokensForModel,
+        warnings,
+      });
+      if (reasoningConfig != null) {
+        anthropicOptions.thinking = reasoningConfig.thinking;
+        if (reasoningConfig.effort != null) {
+          anthropicOptions.effort = reasoningConfig.effort;
+        }
+      }
+    }
+
     // Handle assistant prefill: append a partial assistant message
     if (anthropicOptions?.prefill) {
       const lastMessage =
@@ -405,9 +523,22 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
       ...(anthropicOptions?.speed && {
         speed: anthropicOptions.speed,
       }),
+      ...(anthropicOptions?.metadata && {
+        metadata: {
+          ...(anthropicOptions.metadata.userId && {
+            user_id: anthropicOptions.metadata.userId,
+          }),
+        },
+      }),
+      ...(anthropicOptions?.serviceTier && {
+        service_tier: anthropicOptions.serviceTier,
+      }),
       ...(anthropicOptions?.cacheControl && {
         cache_control: anthropicOptions.cacheControl,
       }),
+      ...(anthropicOptions?.metadata?.userId != null && {
+        metadata: { user_id: anthropicOptions.metadata.userId },
+      }),
 
       // mcp servers:
       ...(anthropicOptions?.mcpServers &&
@@ -599,7 +730,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
       anthropicOptions.container.skills &&
       anthropicOptions.container.skills.length > 0
     ) {
-      betas.add('code-execution-2025-08-25');
+      // code-execution-2025-08-25 is GA — no beta header needed
       betas.add('skills-2025-10-02');
       betas.add('files-api-2025-04-14');
 
@@ -644,6 +775,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
             disableParallelToolUse: true,
             cacheControlValidator,
             supportsStructuredOutput: false,
+            supportsStrictTools,
           }
         : {
             tools: tools ?? [],
@@ -651,6 +783,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
             disableParallelToolUse: anthropicOptions?.disableParallelToolUse,
             cacheControlValidator,
             supportsStructuredOutput,
+            supportsStrictTools,
           },
     );
 
@@ -724,7 +857,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
     return this.config.transformRequestBody?.(args, betas) ?? args;
   }
 
-  private extractCitationDocuments(prompt: LanguageModelV3Prompt): Array<{
+  private extractCitationDocuments(prompt: LanguageModelV4Prompt): Array<{
     title: string;
     filename?: string;
     mediaType: string;
@@ -768,8 +901,8 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
   }
 
   async doGenerate(
-    options: LanguageModelV3CallOptions,
-  ): Promise<LanguageModelV3GenerateResult> {
+    options: LanguageModelV4CallOptions,
+  ): Promise<LanguageModelV4GenerateResult> {
     const {
       args,
       warnings,
@@ -809,8 +942,8 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
       fetch: this.config.fetch,
     });
 
-    const content: Array<LanguageModelV3Content> = [];
-    const mcpToolCalls: Record<string, LanguageModelV3ToolCall> = {};
+    const content: Array<LanguageModelV4Content> = [];
+    const mcpToolCalls: Record<string, LanguageModelV4ToolCall> = {};
     const serverToolCalls: Record<string, string> = {}; // tool_use_id -> provider tool name
     let isJsonResponseFromTool = false;
 
@@ -1084,6 +1217,20 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
 
         // code execution 20250522:
         case 'code_execution_tool_result': {
+          // When code_execution was not explicitly requested (markCodeExecutionDynamic),
+          // intercept ALL results and return a clear error telling the model to use
+          // web_search/web_fetch as direct tool calls instead of wrapping them in Python.
+          if (markCodeExecutionDynamic) {
+            content.push({
+              type: 'tool-result',
+              toolCallId: part.tool_use_id,
+              toolName: toolNameMapping.toCustomToolName('code_execution'),
+              isError: true,
+              result:
+                'STOP: code_execution is disabled. Do NOT wrap web_search or web_fetch in Python code. Call web_search and web_fetch as DIRECT tool calls — they are standalone tools, not Python functions.',
+            });
+            break;
+          }
           if (part.content.type === 'code_execution_result') {
             content.push({
               type: 'tool-result',
@@ -1128,6 +1275,17 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
         // code execution 20250825:
         case 'bash_code_execution_tool_result':
         case 'text_editor_code_execution_tool_result': {
+          if (markCodeExecutionDynamic) {
+            content.push({
+              type: 'tool-result',
+              toolCallId: part.tool_use_id,
+              toolName: toolNameMapping.toCustomToolName('code_execution'),
+              isError: true,
+              result:
+                'STOP: code_execution is disabled. Do NOT wrap web_search or web_fetch in Python code. Call web_search and web_fetch as DIRECT tool calls — they are standalone tools, not Python functions.',
+            });
+            break;
+          }
           content.push({
             type: 'tool-result',
             toolCallId: part.tool_use_id,
@@ -1235,7 +1393,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
             ) ?? null,
         } satisfies AnthropicMessageMetadata;
 
-        const providerMetadata: SharedV3ProviderMetadata = {
+        const providerMetadata: SharedV4ProviderMetadata = {
           anthropic: anthropicMetadata,
         };
 
@@ -1249,8 +1407,8 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
   }
 
   async doStream(
-    options: LanguageModelV3CallOptions,
-  ): Promise<LanguageModelV3StreamResult> {
+    options: LanguageModelV4CallOptions,
+  ): Promise<LanguageModelV4StreamResult> {
     const {
       args: body,
       warnings,
@@ -1287,7 +1445,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
       fetch: this.config.fetch,
     });
 
-    let finishReason: LanguageModelV3FinishReason = {
+    let finishReason: LanguageModelV4FinishReason = {
       unified: 'other',
       raw: undefined,
     };
@@ -1319,7 +1477,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
         }
       | { type: 'text' | 'reasoning' }
     > = {};
-    const mcpToolCalls: Record<string, LanguageModelV3ToolCall> = {};
+    const mcpToolCalls: Record<string, LanguageModelV4ToolCall> = {};
     const serverToolCalls: Record<string, string> = {}; // tool_use_id -> provider tool name
 
     let contextManagement:
@@ -1353,7 +1511,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
     const transformedStream = response.pipeThrough(
       new TransformStream<
         ParseResult<InferSchema<typeof anthropicMessagesChunkSchema>>,
-        LanguageModelV3StreamPart
+        LanguageModelV4StreamPart
       >({
         start(controller) {
           controller.enqueue({ type: 'stream-start', warnings });
@@ -1662,6 +1820,18 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
 
                 // code execution 20250522:
                 case 'code_execution_tool_result': {
+                  if (markCodeExecutionDynamic) {
+                    controller.enqueue({
+                      type: 'tool-result',
+                      toolCallId: part.tool_use_id,
+                      toolName:
+                        toolNameMapping.toCustomToolName('code_execution'),
+                      isError: true,
+                      result:
+                        'STOP: code_execution is disabled. Do NOT wrap web_search or web_fetch in Python code. Call web_search and web_fetch as DIRECT tool calls — they are standalone tools, not Python functions.',
+                    });
+                    return;
+                  }
                   if (part.content.type === 'code_execution_result') {
                     controller.enqueue({
                       type: 'tool-result',
@@ -1714,6 +1884,18 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
                 // code execution 20250825:
                 case 'bash_code_execution_tool_result':
                 case 'text_editor_code_execution_tool_result': {
+                  if (markCodeExecutionDynamic) {
+                    controller.enqueue({
+                      type: 'tool-result',
+                      toolCallId: part.tool_use_id,
+                      toolName:
+                        toolNameMapping.toCustomToolName('code_execution'),
+                      isError: true,
+                      result:
+                        'STOP: code_execution is disabled. Do NOT wrap web_search or web_fetch in Python code. Call web_search and web_fetch as DIRECT tool calls — they are standalone tools, not Python functions.',
+                    });
+                    return;
+                  }
                   controller.enqueue({
                     type: 'tool-result',
                     toolCallId: part.tool_use_id,
@@ -2206,7 +2388,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
                 contextManagement,
               } satisfies AnthropicMessageMetadata;
 
-              const providerMetadata: SharedV3ProviderMetadata = {
+              const providerMetadata: SharedV4ProviderMetadata = {
                 anthropic: anthropicMetadata,
               };
 
@@ -2289,9 +2471,10 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
  * @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;
   isKnownModel: boolean;
 } {
   if (
@@ -2301,6 +2484,7 @@ function getModelCapabilities(modelId: string): {
     return {
       maxOutputTokens: 128000,
       supportsStructuredOutput: true,
+      supportsAdaptiveThinking: true,
       isKnownModel: true,
     };
   } else if (
@@ -2311,36 +2495,42 @@ function getModelCapabilities(modelId: string): {
     return {
       maxOutputTokens: 64000,
       supportsStructuredOutput: true,
+      supportsAdaptiveThinking: false,
       isKnownModel: true,
     };
   } else if (modelId.includes('claude-opus-4-1')) {
     return {
       maxOutputTokens: 32000,
       supportsStructuredOutput: true,
+      supportsAdaptiveThinking: false,
       isKnownModel: true,
     };
   } else if (modelId.includes('claude-sonnet-4-')) {
     return {
       maxOutputTokens: 64000,
       supportsStructuredOutput: false,
+      supportsAdaptiveThinking: false,
       isKnownModel: true,
     };
   } else if (modelId.includes('claude-opus-4-')) {
     return {
       maxOutputTokens: 32000,
       supportsStructuredOutput: false,
+      supportsAdaptiveThinking: false,
       isKnownModel: true,
     };
   } else if (modelId.includes('claude-3-haiku')) {
     return {
       maxOutputTokens: 4096,
       supportsStructuredOutput: false,
+      supportsAdaptiveThinking: false,
       isKnownModel: true,
     };
   } else {
     return {
       maxOutputTokens: 4096,
       supportsStructuredOutput: false,
+      supportsAdaptiveThinking: false,
       isKnownModel: false,
     };
   }
@@ -2371,6 +2561,52 @@ function hasWebTool20260209WithoutCodeExecution(
   return hasWebTool20260209 && !hasCodeExecutionTool;
 }
 
+function resolveAnthropicReasoningConfig({
+  reasoning,
+  supportsAdaptiveThinking,
+  maxOutputTokensForModel,
+  warnings,
+}: {
+  reasoning: LanguageModelV4CallOptions['reasoning'];
+  supportsAdaptiveThinking: 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: '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

@@ -124,6 +124,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.
    */
@@ -200,6 +217,13 @@ export const anthropicLanguageModelOptions = z.object({
    */
   prefill: z.string().optional(),
 
+  /**
+   * Service tier selection.
+   * - 'auto': Allow Anthropic to pick standard or priority based on availability.
+   * See https://docs.anthropic.com/en/api/messages
+   */
+  serviceTier: z.enum(['auto']).optional(),
+
   contextManagement: z
     .object({
       edits: z.array(