@ai-sdk/anthropic 4.0.83 → 4.0.85

package/src/anthropic-language-model.ts

@@ -69,7 +69,10 @@ import {
   convertAnthropicUsage,
   type AnthropicUsage,
 } from './convert-anthropic-usage';
-import { convertToAnthropicPrompt } from './convert-to-anthropic-prompt';
+import {
+  convertToAnthropicPrompt,
+  type AnthropicMediaPartConverter,
+} from './convert-to-anthropic-prompt';
 import { CacheControlValidator } from './get-cache-control';
 import { mapAnthropicStopReason } from './map-anthropic-stop-reason';
 import { sanitizeJsonSchema } from './sanitize-json-schema';
@@ -251,6 +254,8 @@ export type AnthropicLanguageModelConfig = {
   headers?: Resolvable<Record<string, string | undefined>>;
   fetch?: FetchFunction;
   buildRequestUrl?: (baseURL: string, isStreaming: boolean) => string;
+  /** Custom media conversion for compatible providers; undefined uses the default. */
+  convertMediaPart?: AnthropicMediaPartConverter;
   transformRequestBody?: (
     args: Record<string, any>,
     betas: Set<string>,
@@ -265,6 +270,12 @@ export type AnthropicLanguageModelConfig = {
   generateId?: () => string;
   supportsNativeStructuredOutput?: boolean;
   supportsStrictTools?: boolean;
+  /** Maximum temperature for compatible providers. Defaults to 1. */
+  maxTemperature?: number;
+  /** Preserve temperature and topP with thinking for compatible providers. */
+  supportsTemperatureAndTopPWithThinking?: boolean;
+  /** Cache option namespace for compatible providers. Defaults to anthropic. */
+  cacheControlProviderOptionsName?: string;
 };
 
 export class AnthropicLanguageModel implements LanguageModelV4 {
@@ -350,18 +361,24 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
       warnings.push({ type: 'unsupported', feature: 'seed' });
     }
 
-    if (temperature != null && temperature > 1) {
+    const maxTemperature = config.maxTemperature ?? 1;
+    const temperatureProvider =
+      config.maxTemperature == null
+        ? 'anthropic'
+        : getProviderOptionsName(config.provider);
+
+    if (temperature != null && temperature > maxTemperature) {
       warnings.push({
         type: 'unsupported',
         feature: 'temperature',
-        details: `${temperature} exceeds anthropic maximum of 1.0. clamped to 1.0`,
+        details: `${temperature} exceeds ${temperatureProvider} maximum of ${maxTemperature.toFixed(1)}. clamped to ${maxTemperature.toFixed(1)}`,
       });
-      temperature = 1;
+      temperature = maxTemperature;
     } else if (temperature != null && temperature < 0) {
       warnings.push({
         type: 'unsupported',
         feature: 'temperature',
-        details: `${temperature} is below anthropic minimum of 0. clamped to 0`,
+        details: `${temperature} is below ${temperatureProvider} minimum of 0. clamped to 0`,
       });
       temperature = 0;
     }
@@ -530,7 +547,9 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
     }
 
     // Create a shared cache control validator to track breakpoints across tools and messages
-    const cacheControlValidator = new CacheControlValidator();
+    const cacheControlValidator = new CacheControlValidator(
+      config.cacheControlProviderOptionsName,
+    );
 
     const toolNameMapping = createToolNameMapping({
       tools,
@@ -570,6 +589,7 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
       cacheControlValidator,
       toolNameMapping,
       toolsetNames,
+      convertMediaPart: config.convertMediaPart,
     });
 
     /*
@@ -921,7 +941,10 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
         thinkingBudget = 1024;
       }
 
-      if (baseArgs.temperature != null) {
+      if (
+        baseArgs.temperature != null &&
+        !config.supportsTemperatureAndTopPWithThinking
+      ) {
         baseArgs.temperature = undefined;
         warnings.push({
           type: 'unsupported',
@@ -939,7 +962,7 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
         });
       }
 
-      if (topP != null) {
+      if (topP != null && !config.supportsTemperatureAndTopPWithThinking) {
         baseArgs.top_p = undefined;
         warnings.push({
           type: 'unsupported',

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

@@ -2,6 +2,7 @@ import {
   UnsupportedFunctionalityError,
   type JSONObject,
   type JSONValue,
+  type LanguageModelV4FilePart,
   type SharedV4Warning,
   type LanguageModelV4Message,
   type LanguageModelV4Prompt,
@@ -21,9 +22,10 @@ import {
   type ToolNameMapping,
 } from '@ai-sdk/provider-utils';
 import {
-  anthropicFallbackContentSchema,
+  anthropicFallbackContentSchemaValidator,
   anthropicReasoningMetadataSchema,
   type AnthropicAssistantMessage,
+  type AnthropicImageContent,
   type AnthropicPrompt,
   type AnthropicSystemMessage,
   type AnthropicTextContent,
@@ -31,6 +33,7 @@ import {
   type AnthropicToolCallCaller,
   type AnthropicToolResultContent,
   type AnthropicUserMessage,
+  type AnthropicVideoContent,
   type AnthropicWebFetchToolResultContent,
   type Citation,
 } from './anthropic-api';
@@ -77,6 +80,14 @@ function extractErrorValue(value: unknown): { errorCode?: string } {
   return {};
 }
 
+/** Return undefined to use the default file conversion. */
+export type AnthropicMediaPartConverter = (
+  part: LanguageModelV4FilePart,
+) => PromiseLike<
+  | Omit<AnthropicImageContent | AnthropicVideoContent, 'cache_control'>
+  | undefined
+>;
+
 export async function convertToAnthropicPrompt({
   prompt,
   sendReasoning,
@@ -84,12 +95,14 @@ export async function convertToAnthropicPrompt({
   cacheControlValidator,
   toolNameMapping,
   toolsetNames = {},
+  convertMediaPart,
 }: {
   prompt: LanguageModelV4Prompt;
   sendReasoning: boolean;
   warnings: SharedV4Warning[];
   cacheControlValidator?: CacheControlValidator;
   toolNameMapping: ToolNameMapping;
+  convertMediaPart?: AnthropicMediaPartConverter;
 
   /**
    * Maps custom tool names of toolset tools (e.g. the computer toolset) to
@@ -329,6 +342,15 @@ export async function convertToAnthropicPrompt({
                   }
 
                   case 'file': {
+                    const convertedPart = await convertMediaPart?.(part);
+                    if (convertedPart != null) {
+                      anthropicContent.push({
+                        ...convertedPart,
+                        cache_control: cacheControl,
+                      });
+                      break;
+                    }
+
                     switch (part.data.type) {
                       case 'reference': {
                         const fileId = resolveProviderReference({
@@ -858,7 +880,7 @@ export async function convertToAnthropicPrompt({
 
                 const fallbackMetadata = await safeValidateTypes({
                   value: part.providerOptions?.anthropic,
-                  schema: anthropicFallbackContentSchema,
+                  schema: anthropicFallbackContentSchemaValidator,
                 });
 
                 if (!fallbackMetadata.success) {

package/src/get-cache-control.ts

@@ -11,11 +11,18 @@ const MAX_CACHE_BREAKPOINTS = 4;
 // Allows both cacheControl and cache_control for flexibility
 function getCacheControl(
   providerMetadata: SharedV4ProviderMetadata | undefined,
+  providerOptionsName: string,
 ): AnthropicCacheControl | undefined {
+  const custom = providerMetadata?.[providerOptionsName];
   const anthropic = providerMetadata?.anthropic;
 
-  // allow both cacheControl and cache_control:
-  const cacheControlValue = anthropic?.cacheControl ?? anthropic?.cache_control;
+  // Prefer the configured namespace, retaining the canonical namespace as a fallback.
+  // Allow both cacheControl and cache_control.
+  const cacheControlValue =
+    custom?.cacheControl ??
+    custom?.cache_control ??
+    anthropic?.cacheControl ??
+    anthropic?.cache_control;
 
   // Pass through value assuming it is of the correct type.
   // The Anthropic API will validate the value.
@@ -26,11 +33,16 @@ export class CacheControlValidator {
   private breakpointCount = 0;
   private warnings: SharedV4Warning[] = [];
 
+  constructor(private readonly providerOptionsName = 'anthropic') {}
+
   getCacheControl(
     providerMetadata: SharedV4ProviderMetadata | undefined,
     context: { type: string; canCache: boolean },
   ): AnthropicCacheControl | undefined {
-    const cacheControlValue = getCacheControl(providerMetadata);
+    const cacheControlValue = getCacheControl(
+      providerMetadata,
+      this.providerOptionsName,
+    );
 
     if (!cacheControlValue) {
       return undefined;

package/src/skills/anthropic-skills.ts

@@ -3,6 +3,7 @@ import {
   combineHeaders,
   convertInlineFileDataToUint8Array,
   createJsonResponseHandler,
+  encodePathSegment,
   getFromApi,
   postFormDataToApi,
   resolve,
@@ -22,17 +23,6 @@ interface AnthropicSkillsConfig {
   fetch?: FetchFunction;
 }
 
-function encodePathSegment(value: string): string {
-  const encodedValue = encodeURIComponent(value);
-
-  // URL parsing normalizes both literal and percent-encoded dot segments.
-  return encodedValue === '.'
-    ? '%252E'
-    : encodedValue === '..'
-      ? '%252E%252E'
-      : encodedValue;
-}
-
 export class AnthropicSkills implements SkillsV4 {
   readonly specificationVersion = 'v4';