@ai-sdk/anthropic 4.0.0-beta.16 → 4.0.0-beta.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/anthropic",
-  "version": "4.0.0-beta.16",
+  "version": "4.0.0-beta.17",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -36,8 +36,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.0-beta.5",
-    "@ai-sdk/provider-utils": "5.0.0-beta.9"
+    "@ai-sdk/provider": "4.0.0-beta.6",
+    "@ai-sdk/provider-utils": "5.0.0-beta.10"
   },
   "devDependencies": {
     "@types/node": "20.17.24",

package/src/anthropic-files.ts

@@ -0,0 +1,106 @@
+import {
+  FilesV4,
+  FilesV4UploadFileCallOptions,
+  FilesV4UploadFileResult,
+} from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  convertBase64ToUint8Array,
+  createJsonResponseHandler,
+  FetchFunction,
+  lazySchema,
+  parseProviderOptions,
+  postFormDataToApi,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { anthropicFailedResponseHandler } from './anthropic-error';
+
+const anthropicUploadFileProviderOptions = z.object({});
+
+const anthropicUploadFileResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      id: z.string(),
+      type: z.literal('file'),
+      filename: z.string(),
+      mime_type: z.string(),
+      size_bytes: z.number(),
+      created_at: z.string(),
+      downloadable: z.boolean().nullish(),
+    }),
+  ),
+);
+
+interface AnthropicFilesConfig {
+  provider: string;
+  baseURL: string;
+  headers: () => Record<string, string | undefined>;
+  fetch?: FetchFunction;
+}
+
+export class AnthropicFiles implements FilesV4 {
+  readonly specificationVersion = 'v4';
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  constructor(private readonly config: AnthropicFilesConfig) {}
+
+  async uploadFile({
+    data,
+    mediaType,
+    filename,
+    providerOptions,
+  }: FilesV4UploadFileCallOptions): Promise<FilesV4UploadFileResult> {
+    const anthropicOptions = await parseProviderOptions({
+      provider: 'anthropic',
+      providerOptions,
+      schema: zodSchema(anthropicUploadFileProviderOptions),
+    });
+
+    const fileBytes =
+      data instanceof Uint8Array ? data : convertBase64ToUint8Array(data);
+
+    const blob = new Blob([fileBytes], { type: mediaType });
+
+    const formData = new FormData();
+    if (filename != null) {
+      formData.append('file', blob, filename);
+    } else {
+      formData.append('file', blob);
+    }
+
+    const { value: response } = await postFormDataToApi({
+      url: `${this.config.baseURL}/files`,
+      headers: combineHeaders(this.config.headers(), {
+        'anthropic-beta': 'files-api-2025-04-14',
+      }),
+      formData,
+      failedResponseHandler: anthropicFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        anthropicUploadFileResponseSchema,
+      ),
+      fetch: this.config.fetch,
+    });
+
+    return {
+      warnings: [],
+      providerReference: { anthropic: response.id },
+      mediaType: response.mime_type ?? mediaType,
+      filename: response.filename ?? filename,
+      providerMetadata: {
+        anthropic: {
+          filename: response.filename,
+          mimeType: response.mime_type,
+          sizeBytes: response.size_bytes,
+          createdAt: response.created_at,
+          ...(response.downloadable != null
+            ? { downloadable: response.downloadable }
+            : {}),
+        },
+      },
+    };
+  }
+}

package/src/anthropic-messages-api.ts

@@ -87,6 +87,10 @@ type AnthropicContentSource =
       type: 'text';
       media_type: 'text/plain';
       data: string;
+    }
+  | {
+      type: 'file';
+      file_id: string;
     };
 
 export interface AnthropicImageContent {

package/src/anthropic-provider.ts

@@ -1,4 +1,5 @@
 import {
+  FilesV4,
   InvalidArgumentError,
   LanguageModelV4,
   NoSuchModelError,
@@ -12,10 +13,11 @@ import {
   withoutTrailingSlash,
   withUserAgentSuffix,
 } from '@ai-sdk/provider-utils';
-import { VERSION } from './version';
+import { AnthropicFiles } from './anthropic-files';
 import { AnthropicMessagesLanguageModel } from './anthropic-messages-language-model';
 import { AnthropicMessagesModelId } from './anthropic-messages-options';
 import { anthropicTools } from './anthropic-tools';
+import { VERSION } from './version';
 
 export interface AnthropicProvider extends ProviderV4 {
   /**
@@ -37,6 +39,8 @@ export interface AnthropicProvider extends ProviderV4 {
    */
   textEmbeddingModel(modelId: string): never;
 
+  files(): FilesV4;
+
   /**
    * Anthropic-specific computer use tool.
    */
@@ -166,6 +170,14 @@ export function createAnthropic(
     throw new NoSuchModelError({ modelId, modelType: 'imageModel' });
   };
 
+  provider.files = () =>
+    new AnthropicFiles({
+      provider: providerName,
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
   provider.tools = anthropicTools;
 
   return provider;

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

@@ -9,7 +9,9 @@ import {
 import {
   convertBase64ToUint8Array,
   convertToBase64,
+  isProviderReference,
   parseProviderOptions,
+  resolveProviderReference,
   validateTypes,
   isNonNullable,
   ToolNameMapping,
@@ -183,7 +185,27 @@ export async function convertToAnthropicMessagesPrompt({
                   }
 
                   case 'file': {
-                    if (part.mediaType.startsWith('image/')) {
+                    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,
+                        });
+                      } else {
+                        anthropicContent.push({
+                          type: 'document',
+                          source: { type: 'file', file_id: fileId },
+                          cache_control: cacheControl,
+                        });
+                      }
+                    } else if (part.mediaType.startsWith('image/')) {
                       anthropicContent.push({
                         type: 'image',
                         source: isUrlData(part.data)