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

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

@@ -1,28 +1,30 @@
 import {
-  SharedV4Warning,
-  LanguageModelV4DataContent,
-  LanguageModelV4Message,
-  LanguageModelV4Prompt,
-  SharedV4ProviderMetadata,
   UnsupportedFunctionalityError,
+  type SharedV4Warning,
+  type LanguageModelV4Message,
+  type LanguageModelV4Prompt,
+  type SharedV4ProviderMetadata,
 } from '@ai-sdk/provider';
 import {
   convertBase64ToUint8Array,
   convertToBase64,
+  getTopLevelMediaType,
   parseProviderOptions,
+  resolveFullMediaType,
+  resolveProviderReference,
   validateTypes,
   isNonNullable,
-  ToolNameMapping,
+  type ToolNameMapping,
 } from '@ai-sdk/provider-utils';
 import {
-  AnthropicAssistantMessage,
-  AnthropicMessagesPrompt,
   anthropicReasoningMetadataSchema,
-  AnthropicToolResultContent,
-  AnthropicUserMessage,
-  AnthropicWebFetchToolResultContent,
-} from './anthropic-messages-api';
-import { anthropicFilePartProviderOptions } from './anthropic-messages-options';
+  type AnthropicAssistantMessage,
+  type AnthropicPrompt,
+  type AnthropicToolResultContent,
+  type AnthropicUserMessage,
+  type AnthropicWebFetchToolResultContent,
+} from './anthropic-api';
+import { anthropicFilePartProviderOptions } from './anthropic-options';
 import { CacheControlValidator } from './get-cache-control';
 import { codeExecution_20250522OutputSchema } from './tool/code-execution_20250522';
 import { codeExecution_20250825OutputSchema } from './tool/code-execution_20250825';
@@ -31,44 +33,14 @@ import { toolSearchRegex_20251119OutputSchema as toolSearchOutputSchema } from '
 import { webFetch_20250910OutputSchema } from './tool/web-fetch-20250910';
 import { webSearch_20250305OutputSchema } from './tool/web-search_20250305';
 
-function convertToString(data: LanguageModelV4DataContent): string {
+function convertBytesDataToString(data: Uint8Array | string): string {
   if (typeof data === 'string') {
     return new TextDecoder().decode(convertBase64ToUint8Array(data));
   }
-
-  if (data instanceof Uint8Array) {
-    return new TextDecoder().decode(data);
-  }
-
-  if (data instanceof URL) {
-    throw new UnsupportedFunctionalityError({
-      functionality: 'URL-based text documents are not supported for citations',
-    });
-  }
-
-  throw new UnsupportedFunctionalityError({
-    functionality: `unsupported data type for text documents: ${typeof data}`,
-  });
-}
-
-/**
- * Checks if data is a URL (either a URL object or a URL string).
- */
-function isUrlData(
-  data: LanguageModelV4DataContent,
-): data is URL | (string & { __brand: 'url-string' }) {
-  return data instanceof URL || isUrlString(data);
+  return new TextDecoder().decode(data);
 }
 
-function isUrlString(data: LanguageModelV4DataContent): boolean {
-  return typeof data === 'string' && /^https?:\/\//i.test(data);
-}
-
-function getUrlString(data: LanguageModelV4DataContent): string {
-  return data instanceof URL ? data.toString() : (data as string);
-}
-
-export async function convertToAnthropicMessagesPrompt({
+export async function convertToAnthropicPrompt({
   prompt,
   sendReasoning,
   warnings,
@@ -81,15 +53,15 @@ export async function convertToAnthropicMessagesPrompt({
   cacheControlValidator?: CacheControlValidator;
   toolNameMapping: ToolNameMapping;
 }): Promise<{
-  prompt: AnthropicMessagesPrompt;
+  prompt: AnthropicPrompt;
   betas: Set<string>;
 }> {
   const betas = new Set<string>();
   const blocks = groupIntoBlocks(prompt);
   const validator = cacheControlValidator || new CacheControlValidator();
 
-  let system: AnthropicMessagesPrompt['system'] = undefined;
-  const messages: AnthropicMessagesPrompt['messages'] = [];
+  let system: AnthropicPrompt['system'] = undefined;
+  const messages: AnthropicPrompt['messages'] = [];
 
   async function shouldEnableCitations(
     providerMetadata: SharedV4ProviderMetadata | undefined,
@@ -183,86 +155,154 @@ export async function convertToAnthropicMessagesPrompt({
                   }
 
                   case 'file': {
-                    if (part.mediaType.startsWith('image/')) {
-                      anthropicContent.push({
-                        type: 'image',
-                        source: isUrlData(part.data)
-                          ? {
-                              type: 'url',
-                              url: getUrlString(part.data),
-                            }
-                          : {
-                              type: 'base64',
-                              media_type:
-                                part.mediaType === 'image/*'
-                                  ? 'image/jpeg'
-                                  : part.mediaType,
-                              data: convertToBase64(part.data),
-                            },
-                        cache_control: cacheControl,
-                      });
-                    } else if (part.mediaType === 'application/pdf') {
-                      betas.add('pdfs-2024-09-25');
-
-                      const enableCitations = await shouldEnableCitations(
-                        part.providerOptions,
-                      );
-
-                      const metadata = await getDocumentMetadata(
-                        part.providerOptions,
-                      );
-
-                      anthropicContent.push({
-                        type: 'document',
-                        source: isUrlData(part.data)
-                          ? {
-                              type: 'url',
-                              url: getUrlString(part.data),
-                            }
-                          : {
-                              type: 'base64',
-                              media_type: 'application/pdf',
-                              data: convertToBase64(part.data),
-                            },
-                        title: metadata.title ?? part.filename,
-                        ...(metadata.context && { context: metadata.context }),
-                        ...(enableCitations && {
-                          citations: { enabled: true },
-                        }),
-                        cache_control: cacheControl,
-                      });
-                    } else if (part.mediaType === 'text/plain') {
-                      const enableCitations = await shouldEnableCitations(
-                        part.providerOptions,
-                      );
-
-                      const metadata = await getDocumentMetadata(
-                        part.providerOptions,
-                      );
-
-                      anthropicContent.push({
-                        type: 'document',
-                        source: isUrlData(part.data)
-                          ? {
-                              type: 'url',
-                              url: getUrlString(part.data),
-                            }
-                          : {
-                              type: 'text',
-                              media_type: 'text/plain',
-                              data: convertToString(part.data),
-                            },
-                        title: metadata.title ?? part.filename,
-                        ...(metadata.context && { context: metadata.context }),
-                        ...(enableCitations && {
-                          citations: { enabled: true },
-                        }),
-                        cache_control: cacheControl,
-                      });
-                    } else {
-                      throw new UnsupportedFunctionalityError({
-                        functionality: `media type: ${part.mediaType}`,
-                      });
+                    switch (part.data.type) {
+                      case 'reference': {
+                        const fileId = resolveProviderReference({
+                          reference: part.data.reference,
+                          provider: 'anthropic',
+                        });
+                        betas.add('files-api-2025-04-14');
+
+                        if (getTopLevelMediaType(part.mediaType) === 'image') {
+                          anthropicContent.push({
+                            type: 'image',
+                            source: { type: 'file', file_id: fileId },
+                            cache_control: cacheControl,
+                          });
+                        } else {
+                          anthropicContent.push({
+                            type: 'document',
+                            source: { type: 'file', file_id: fileId },
+                            cache_control: cacheControl,
+                          });
+                        }
+                        break;
+                      }
+                      case 'text': {
+                        const enableCitations = await shouldEnableCitations(
+                          part.providerOptions,
+                        );
+
+                        const metadata = await getDocumentMetadata(
+                          part.providerOptions,
+                        );
+
+                        anthropicContent.push({
+                          type: 'document',
+                          source: {
+                            type: 'text',
+                            media_type: 'text/plain',
+                            data: part.data.text,
+                          },
+                          title: metadata.title ?? part.filename,
+                          ...(metadata.context && {
+                            context: metadata.context,
+                          }),
+                          ...(enableCitations && {
+                            citations: { enabled: true },
+                          }),
+                          cache_control: cacheControl,
+                        });
+                        break;
+                      }
+                      case 'url':
+                      case 'data': {
+                        const topLevel = getTopLevelMediaType(part.mediaType);
+                        if (topLevel === 'image') {
+                          anthropicContent.push({
+                            type: 'image',
+                            source:
+                              part.data.type === 'url'
+                                ? {
+                                    type: 'url',
+                                    url: part.data.url.toString(),
+                                  }
+                                : {
+                                    type: 'base64',
+                                    media_type: resolveFullMediaType({ part }),
+                                    data: convertToBase64(part.data.data),
+                                  },
+                            cache_control: cacheControl,
+                          });
+                        } else if (
+                          topLevel === 'application' &&
+                          (part.data.type === 'url'
+                            ? part.mediaType === 'application/pdf'
+                            : resolveFullMediaType({ part }) ===
+                              'application/pdf')
+                        ) {
+                          betas.add('pdfs-2024-09-25');
+
+                          const enableCitations = await shouldEnableCitations(
+                            part.providerOptions,
+                          );
+
+                          const metadata = await getDocumentMetadata(
+                            part.providerOptions,
+                          );
+
+                          anthropicContent.push({
+                            type: 'document',
+                            source:
+                              part.data.type === 'url'
+                                ? {
+                                    type: 'url',
+                                    url: part.data.url.toString(),
+                                  }
+                                : {
+                                    type: 'base64',
+                                    media_type: 'application/pdf',
+                                    data: convertToBase64(part.data.data),
+                                  },
+                            title: metadata.title ?? part.filename,
+                            ...(metadata.context && {
+                              context: metadata.context,
+                            }),
+                            ...(enableCitations && {
+                              citations: { enabled: true },
+                            }),
+                            cache_control: cacheControl,
+                          });
+                        } else if (part.mediaType === 'text/plain') {
+                          const enableCitations = await shouldEnableCitations(
+                            part.providerOptions,
+                          );
+
+                          const metadata = await getDocumentMetadata(
+                            part.providerOptions,
+                          );
+
+                          anthropicContent.push({
+                            type: 'document',
+                            source:
+                              part.data.type === 'url'
+                                ? {
+                                    type: 'url',
+                                    url: part.data.url.toString(),
+                                  }
+                                : {
+                                    type: 'text',
+                                    media_type: 'text/plain',
+                                    data: convertBytesDataToString(
+                                      part.data.data,
+                                    ),
+                                  },
+                            title: metadata.title ?? part.filename,
+                            ...(metadata.context && {
+                              context: metadata.context,
+                            }),
+                            ...(enableCitations && {
+                              citations: { enabled: true },
+                            }),
+                            cache_control: cacheControl,
+                          });
+                        } else {
+                          throw new UnsupportedFunctionalityError({
+                            functionality: `media type: ${part.mediaType}`,
+                          });
+                        }
+                        break;
+                      }
                     }
 
                     break;
@@ -309,26 +349,16 @@ export async function convertToAnthropicMessagesPrompt({
                               type: 'text' as const,
                               text: contentPart.text,
                             };
-                          case 'image-data': {
-                            return {
-                              type: 'image' as const,
-                              source: {
-                                type: 'base64' as const,
-                                media_type: contentPart.mediaType,
-                                data: contentPart.data,
-                              },
-                            };
-                          }
-                          case 'image-url': {
-                            return {
-                              type: 'image' as const,
-                              source: {
-                                type: 'url' as const,
-                                url: contentPart.url,
-                              },
-                            };
-                          }
                           case 'file-url': {
+                            if (contentPart.mediaType.startsWith('image/')) {
+                              return {
+                                type: 'image' as const,
+                                source: {
+                                  type: 'url' as const,
+                                  url: contentPart.url,
+                                },
+                              };
+                            }
                             return {
                               type: 'document' as const,
                               source: {
@@ -338,6 +368,16 @@ export async function convertToAnthropicMessagesPrompt({
                             };
                           }
                           case 'file-data': {
+                            if (contentPart.mediaType.startsWith('image/')) {
+                              return {
+                                type: 'image' as const,
+                                source: {
+                                  type: 'base64' as const,
+                                  media_type: contentPart.mediaType,
+                                  data: contentPart.data,
+                                },
+                              };
+                            }
                             if (contentPart.mediaType === 'application/pdf') {
                               betas.add('pdfs-2024-09-25');
                               return {
@@ -391,7 +431,8 @@ export async function convertToAnthropicMessagesPrompt({
                     contentValue = output.value;
                     break;
                   case 'execution-denied':
-                    contentValue = output.reason ?? 'Tool execution denied.';
+                    contentValue =
+                      output.reason ?? 'Tool call execution denied.';
                     break;
                   case 'json':
                   case 'error-json':

package/src/forward-anthropic-container-id-from-last-step.ts

@@ -1,5 +1,5 @@
-import { JSONObject } from '@ai-sdk/provider';
-import { AnthropicMessageMetadata } from './anthropic-message-metadata';
+import type { JSONObject } from '@ai-sdk/provider';
+import type { AnthropicMessageMetadata } from './anthropic-message-metadata';
 
 /**
  * Sets the Anthropic container ID in the provider options based on

package/src/get-cache-control.ts

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

package/src/index.ts

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

package/src/internal/index.ts

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

package/src/map-anthropic-stop-reason.ts

@@ -1,4 +1,4 @@
-import { LanguageModelV4FinishReason } from '@ai-sdk/provider';
+import type { LanguageModelV4FinishReason } from '@ai-sdk/provider';
 
 /**
  * @see https://docs.anthropic.com/en/api/messages#response-stop-reason

package/src/sanitize-json-schema.ts

@@ -0,0 +1,203 @@
+import type { JSONSchema7, JSONSchema7Definition } from '@ai-sdk/provider';
+
+const SUPPORTED_STRING_FORMATS = new Set([
+  'date-time',
+  'time',
+  'date',
+  'duration',
+  'email',
+  'hostname',
+  'uri',
+  'ipv4',
+  'ipv6',
+  'uuid',
+]);
+
+const DESCRIPTION_CONSTRAINT_KEYS = [
+  'minimum',
+  'maximum',
+  'exclusiveMinimum',
+  'exclusiveMaximum',
+  'multipleOf',
+  'minLength',
+  'maxLength',
+  'pattern',
+  'minItems',
+  'maxItems',
+  'uniqueItems',
+  'minProperties',
+  'maxProperties',
+  'not',
+] satisfies Array<keyof JSONSchema7>;
+
+/**
+ * Removes JSON Schema keywords that Anthropic rejects in
+ * `output_config.format.schema`.
+ *
+ * The full original schema is still used by AI SDK result validation. This
+ * only relaxes the schema sent to Anthropic's constrained decoder.
+ */
+export function sanitizeJsonSchema(schema: JSONSchema7): JSONSchema7 {
+  return sanitizeSchema(schema) as JSONSchema7;
+}
+
+function sanitizeDefinition(
+  definition: JSONSchema7Definition,
+): JSONSchema7Definition {
+  if (typeof definition === 'boolean' || !isPlainObject(definition)) {
+    return definition;
+  }
+
+  return sanitizeSchema(definition as JSONSchema7);
+}
+
+function sanitizeSchema(schema: JSONSchema7): JSONSchema7 {
+  const result: JSONSchema7 = {};
+  const schemaWithDefs = schema as JSONSchema7 & {
+    $defs?: Record<string, JSONSchema7Definition>;
+  };
+
+  if (schema.$ref != null) {
+    return { $ref: schema.$ref };
+  }
+
+  if (schema.$schema != null) {
+    result.$schema = schema.$schema;
+  }
+
+  if (schema.$id != null) {
+    result.$id = schema.$id;
+  }
+
+  if (schema.title != null) {
+    result.title = schema.title;
+  }
+
+  if (schema.description != null) {
+    result.description = schema.description;
+  }
+
+  if (schema.default !== undefined) {
+    result.default = schema.default;
+  }
+
+  if (schema.const !== undefined) {
+    result.const = schema.const;
+  }
+
+  if (schema.enum != null) {
+    result.enum = schema.enum;
+  }
+
+  if (schema.type != null) {
+    result.type = schema.type;
+  }
+
+  if (schema.anyOf != null) {
+    result.anyOf = schema.anyOf.map(sanitizeDefinition);
+  } else if (schema.oneOf != null) {
+    result.anyOf = schema.oneOf.map(sanitizeDefinition);
+  }
+
+  if (schema.allOf != null) {
+    result.allOf = schema.allOf.map(sanitizeDefinition);
+  }
+
+  if (schema.definitions != null) {
+    result.definitions = Object.fromEntries(
+      Object.entries(schema.definitions).map(([name, definition]) => [
+        name,
+        sanitizeDefinition(definition),
+      ]),
+    );
+  }
+
+  if (schemaWithDefs.$defs != null) {
+    const resultWithDefs = result as JSONSchema7 & {
+      $defs?: Record<string, JSONSchema7Definition>;
+    };
+    resultWithDefs.$defs = Object.fromEntries(
+      Object.entries(schemaWithDefs.$defs).map(([name, definition]) => [
+        name,
+        sanitizeDefinition(definition),
+      ]),
+    );
+  }
+
+  if (schema.type === 'object' || schema.properties != null) {
+    if (schema.properties != null) {
+      result.properties = Object.fromEntries(
+        Object.entries(schema.properties).map(([name, definition]) => [
+          name,
+          sanitizeDefinition(definition),
+        ]),
+      );
+    }
+
+    result.additionalProperties = false;
+
+    if (schema.required != null) {
+      result.required = schema.required;
+    }
+  }
+
+  if (schema.items != null) {
+    result.items = Array.isArray(schema.items)
+      ? schema.items.map(sanitizeDefinition)
+      : sanitizeDefinition(schema.items);
+  }
+
+  if (
+    typeof schema.format === 'string' &&
+    SUPPORTED_STRING_FORMATS.has(schema.format)
+  ) {
+    result.format = schema.format;
+  }
+
+  const constraintDescription = getConstraintDescription(schema);
+  if (constraintDescription != null) {
+    result.description =
+      result.description == null
+        ? constraintDescription
+        : `${result.description}\n${constraintDescription}`;
+  }
+
+  return result;
+}
+
+function getConstraintDescription(schema: JSONSchema7): string | undefined {
+  const descriptions = DESCRIPTION_CONSTRAINT_KEYS.flatMap(key => {
+    const value = schema[key];
+
+    if (value == null || value === false) {
+      return [];
+    }
+
+    return `${formatConstraintName(key)}: ${formatConstraintValue(value)}`;
+  });
+
+  if (
+    typeof schema.format === 'string' &&
+    !SUPPORTED_STRING_FORMATS.has(schema.format)
+  ) {
+    descriptions.push(`format: ${schema.format}`);
+  }
+
+  return descriptions.length === 0 ? undefined : `${descriptions.join('; ')}.`;
+}
+
+function formatConstraintName(key: string): string {
+  return key.replace(/[A-Z]/g, match => ` ${match.toLowerCase()}`);
+}
+
+function formatConstraintValue(value: unknown): string {
+  if (typeof value === 'string') {
+    return value;
+  }
+
+  return JSON.stringify(value);
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}