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

package/docs/05-anthropic.mdx

@@ -843,7 +843,7 @@ const computerTool = anthropic.tools.computer_20251124({
   toModelOutput({ output }) {
     return typeof output === 'string'
       ? [{ type: 'text', text: output }]
-      : [{ type: 'image', data: output.data, mediaType: 'image/png' }];
+      : [{ type: 'file-data', data: output.data, mediaType: 'image/png' }];
   },
 });
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/anthropic",
-  "version": "4.0.0-beta.40",
+  "version": "4.0.0-beta.41",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -35,15 +35,15 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.0-beta.13",
-    "@ai-sdk/provider-utils": "5.0.0-beta.28"
+    "@ai-sdk/provider": "4.0.0-beta.14",
+    "@ai-sdk/provider-utils": "5.0.0-beta.29"
   },
   "devDependencies": {
     "@types/node": "20.17.24",
     "tsup": "^8",
     "typescript": "5.8.3",
     "zod": "3.25.76",
-    "@ai-sdk/test-server": "2.0.0-beta.2",
+    "@ai-sdk/test-server": "2.0.0-beta.3",
     "@vercel/ai-tsconfig": "0.0.0"
   },
   "peerDependencies": {

package/src/anthropic-api.ts

@@ -1,5 +1,9 @@
-import { JSONSchema7 } from '@ai-sdk/provider';
-import { InferSchema, lazySchema, zodSchema } from '@ai-sdk/provider-utils';
+import type { JSONSchema7 } from '@ai-sdk/provider';
+import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
+} from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
 export type AnthropicPrompt = {

package/src/anthropic-error.ts

@@ -1,8 +1,8 @@
 import {
   createJsonErrorResponseHandler,
-  InferSchema,
   lazySchema,
   zodSchema,
+  type InferSchema,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 

package/src/anthropic-files.ts

@@ -1,16 +1,16 @@
-import {
+import type {
   FilesV4,
   FilesV4UploadFileCallOptions,
   FilesV4UploadFileResult,
 } from '@ai-sdk/provider';
 import {
   combineHeaders,
-  convertBase64ToUint8Array,
+  convertInlineFileDataToUint8Array,
   createJsonResponseHandler,
-  FetchFunction,
   lazySchema,
   postFormDataToApi,
   zodSchema,
+  type FetchFunction,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 import { anthropicFailedResponseHandler } from './anthropic-error';
@@ -50,8 +50,7 @@ export class AnthropicFiles implements FilesV4 {
     mediaType,
     filename,
   }: FilesV4UploadFileCallOptions): Promise<FilesV4UploadFileResult> {
-    const fileBytes =
-      data instanceof Uint8Array ? data : convertBase64ToUint8Array(data);
+    const fileBytes = convertInlineFileDataToUint8Array(data);
 
     const blob = new Blob([fileBytes], { type: mediaType });
 

package/src/anthropic-language-model.ts

@@ -1,61 +1,61 @@
 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 } from './anthropic-message-metadata';
 import {
-  AnthropicContainer,
   anthropicChunkSchema,
   anthropicResponseSchema,
-  AnthropicReasoningMetadata,
-  AnthropicResponseContextManagement,
-  AnthropicTool,
-  Citation,
+  type AnthropicContainer,
+  type AnthropicReasoningMetadata,
+  type AnthropicResponseContextManagement,
+  type AnthropicTool,
+  type Citation,
 } from './anthropic-api';
 import {
-  AnthropicModelId,
-  AnthropicLanguageModelOptions,
   anthropicLanguageModelOptions,
+  type AnthropicModelId,
+  type AnthropicLanguageModelOptions,
 } from './anthropic-options';
 import { prepareTools } from './anthropic-prepare-tools';
 import {
-  AnthropicUsage,
   convertAnthropicUsage,
+  type AnthropicUsage,
 } from './convert-anthropic-usage';
 import { convertToAnthropicPrompt } from './convert-to-anthropic-prompt';
 import { CacheControlValidator } from './get-cache-control';

package/src/anthropic-message-metadata.ts

@@ -1,4 +1,4 @@
-import { JSONObject } from '@ai-sdk/provider';
+import type { JSONObject } from '@ai-sdk/provider';
 
 /**
  * Represents a single iteration in the usage breakdown.

package/src/anthropic-prepare-tools.ts

@@ -1,9 +1,9 @@
 import {
-  LanguageModelV4CallOptions,
-  SharedV4Warning,
   UnsupportedFunctionalityError,
+  type LanguageModelV4CallOptions,
+  type SharedV4Warning,
 } from '@ai-sdk/provider';
-import { AnthropicTool, AnthropicToolChoice } from './anthropic-api';
+import type { AnthropicTool, AnthropicToolChoice } from './anthropic-api';
 import { CacheControlValidator } from './get-cache-control';
 import { textEditor_20250728ArgsSchema } from './tool/text-editor_20250728';
 import { webSearch_20260209ArgsSchema } from './tool/web-search_20260209';

package/src/anthropic-provider.ts

@@ -1,22 +1,22 @@
 import {
-  FilesV4,
   InvalidArgumentError,
-  LanguageModelV4,
   NoSuchModelError,
-  ProviderV4,
-  SkillsV4,
+  type FilesV4,
+  type LanguageModelV4,
+  type ProviderV4,
+  type SkillsV4,
 } from '@ai-sdk/provider';
 import {
-  FetchFunction,
   generateId,
   loadApiKey,
   loadOptionalSetting,
   withoutTrailingSlash,
   withUserAgentSuffix,
+  type FetchFunction,
 } from '@ai-sdk/provider-utils';
 import { AnthropicFiles } from './anthropic-files';
 import { AnthropicLanguageModel } from './anthropic-language-model';
-import { AnthropicModelId } from './anthropic-options';
+import type { AnthropicModelId } from './anthropic-options';
 import { anthropicTools } from './anthropic-tools';
 import { AnthropicSkills } from './skills/anthropic-skills';
 import { VERSION } from './version';

package/src/convert-anthropic-usage.ts

@@ -1,4 +1,4 @@
-import { JSONObject, LanguageModelV4Usage } from '@ai-sdk/provider';
+import type { JSONObject, LanguageModelV4Usage } from '@ai-sdk/provider';
 
 /**
  * Represents a single iteration in the usage breakdown.

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

@@ -1,28 +1,28 @@
 import {
-  SharedV4Warning,
-  LanguageModelV4DataContent,
-  LanguageModelV4Message,
-  LanguageModelV4Prompt,
-  SharedV4ProviderMetadata,
   UnsupportedFunctionalityError,
+  type SharedV4Warning,
+  type LanguageModelV4Message,
+  type LanguageModelV4Prompt,
+  type SharedV4ProviderMetadata,
 } from '@ai-sdk/provider';
 import {
   convertBase64ToUint8Array,
   convertToBase64,
-  isProviderReference,
+  getTopLevelMediaType,
   parseProviderOptions,
+  resolveFullMediaType,
   resolveProviderReference,
   validateTypes,
   isNonNullable,
-  ToolNameMapping,
+  type ToolNameMapping,
 } from '@ai-sdk/provider-utils';
 import {
-  AnthropicAssistantMessage,
-  AnthropicPrompt,
   anthropicReasoningMetadataSchema,
-  AnthropicToolResultContent,
-  AnthropicUserMessage,
-  AnthropicWebFetchToolResultContent,
+  type AnthropicAssistantMessage,
+  type AnthropicPrompt,
+  type AnthropicToolResultContent,
+  type AnthropicUserMessage,
+  type AnthropicWebFetchToolResultContent,
 } from './anthropic-api';
 import { anthropicFilePartProviderOptions } from './anthropic-options';
 import { CacheControlValidator } from './get-cache-control';
@@ -33,41 +33,11 @@ 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);
-}
-
-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);
+  return new TextDecoder().decode(data);
 }
 
 export async function convertToAnthropicPrompt({
@@ -185,106 +155,154 @@ export async function convertToAnthropicPrompt({
                   }
 
                   case 'file': {
-                    if (isProviderReference(part.data)) {
-                      const fileId = resolveProviderReference({
-                        reference: part.data,
-                        provider: 'anthropic',
-                      });
-                      betas.add('files-api-2025-04-14');
-
-                      if (part.mediaType.startsWith('image/')) {
-                        anthropicContent.push({
-                          type: 'image',
-                          source: { type: 'file', file_id: fileId },
-                          cache_control: cacheControl,
+                    switch (part.data.type) {
+                      case 'reference': {
+                        const fileId = resolveProviderReference({
+                          reference: part.data.reference,
+                          provider: 'anthropic',
                         });
-                      } else {
+                        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: 'file', file_id: fileId },
+                          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;
                       }
-                    } else 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}`,
-                      });
                     }
 
                     break;

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-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/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/skills/anthropic-skills.ts

@@ -1,13 +1,13 @@
-import { SkillsV4, SharedV4Warning } from '@ai-sdk/provider';
+import type { SkillsV4, SharedV4Warning } from '@ai-sdk/provider';
 import {
   combineHeaders,
-  convertBase64ToUint8Array,
+  convertInlineFileDataToUint8Array,
   createJsonResponseHandler,
-  FetchFunction,
   getFromApi,
   postFormDataToApi,
-  Resolvable,
   resolve,
+  type FetchFunction,
+  type Resolvable,
 } from '@ai-sdk/provider-utils';
 import { anthropicFailedResponseHandler } from '../anthropic-error';
 import {
@@ -76,11 +76,7 @@ export class AnthropicSkills implements SkillsV4 {
     }
 
     for (const file of params.files) {
-      const content =
-        typeof file.content === 'string'
-          ? convertBase64ToUint8Array(file.content)
-          : file.content;
-
+      const content = convertInlineFileDataToUint8Array(file.data);
       formData.append('files[]', new Blob([content]), file.path);
     }
 

package/src/tool/text-editor_20250728.ts

@@ -1,6 +1,9 @@
-import { createProviderDefinedToolFactory } from '@ai-sdk/provider-utils';
+import {
+  createProviderDefinedToolFactory,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
-import { lazySchema, zodSchema } from '@ai-sdk/provider-utils';
 
 export const textEditor_20250728ArgsSchema = lazySchema(() =>
   zodSchema(