@ai-sdk/anthropic 4.0.0-beta.3 → 4.0.0-beta.32

package/src/anthropic-provider.ts

@@ -1,8 +1,10 @@
 import {
+  FilesV4,
   InvalidArgumentError,
   LanguageModelV4,
   NoSuchModelError,
   ProviderV4,
+  SkillsV4,
 } from '@ai-sdk/provider';
 import {
   FetchFunction,
@@ -12,10 +14,12 @@ 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 { AnthropicSkills } from './skills/anthropic-skills';
+import { VERSION } from './version';
 
 export interface AnthropicProvider extends ProviderV4 {
   /**
@@ -37,6 +41,13 @@ export interface AnthropicProvider extends ProviderV4 {
    */
   textEmbeddingModel(modelId: string): never;
 
+  files(): FilesV4;
+
+  /**
+   * Returns a SkillsV4 interface for uploading skills to Anthropic.
+   */
+  skills(): SkillsV4;
+
   /**
    * Anthropic-specific computer use tool.
    */
@@ -143,6 +154,14 @@ export function createAnthropic(
       }),
     });
 
+  const createSkills = () =>
+    new AnthropicSkills({
+      provider: `${providerName.replace('.messages', '')}.skills`,
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
   const provider = function (modelId: AnthropicMessagesModelId) {
     if (new.target) {
       throw new Error(
@@ -166,6 +185,16 @@ export function createAnthropic(
     throw new NoSuchModelError({ modelId, modelType: 'imageModel' });
   };
 
+  provider.files = () =>
+    new AnthropicFiles({
+      provider: providerName,
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
+  provider.skills = createSkills;
+
   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)
@@ -309,26 +331,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 +350,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 {

package/src/internal/index.ts

@@ -1,4 +1,7 @@
-export { AnthropicMessagesLanguageModel } from '../anthropic-messages-language-model';
+export {
+  AnthropicMessagesLanguageModel,
+  getModelCapabilities,
+} from '../anthropic-messages-language-model';
 export { anthropicTools } from '../anthropic-tools';
 export type { AnthropicMessagesModelId } from '../anthropic-messages-options';
 export { prepareTools } from '../anthropic-prepare-tools';

package/src/skills/anthropic-skills-api.ts

@@ -0,0 +1,44 @@
+import { lazySchema, zodSchema } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export const anthropicSkillResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      id: z.string(),
+      display_title: z.string().nullish(),
+      name: z.string().nullish(),
+      description: z.string().nullish(),
+      latest_version: z.string().nullish(),
+      source: z.string(),
+      created_at: z.string(),
+      updated_at: z.string(),
+    }),
+  ),
+);
+
+export type AnthropicSkillResponse = ReturnType<
+  typeof anthropicSkillResponseSchema
+>['_type'];
+
+export const anthropicSkillVersionListResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      data: z.array(
+        z.object({
+          version: z.string(),
+        }),
+      ),
+    }),
+  ),
+);
+
+export const anthropicSkillVersionResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      type: z.string(),
+      skill_id: z.string(),
+      name: z.string().nullish(),
+      description: z.string().nullish(),
+    }),
+  ),
+);

package/src/skills/anthropic-skills.ts

@@ -0,0 +1,136 @@
+import { SkillsV4, SharedV4Warning } from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  convertBase64ToUint8Array,
+  createJsonResponseHandler,
+  FetchFunction,
+  getFromApi,
+  postFormDataToApi,
+  Resolvable,
+  resolve,
+} from '@ai-sdk/provider-utils';
+import { anthropicFailedResponseHandler } from '../anthropic-error';
+import {
+  anthropicSkillResponseSchema,
+  anthropicSkillVersionResponseSchema,
+} from './anthropic-skills-api';
+
+interface AnthropicSkillsConfig {
+  provider: string;
+  baseURL: string;
+  headers: Resolvable<Record<string, string | undefined>>;
+  fetch?: FetchFunction;
+}
+
+export class AnthropicSkills implements SkillsV4 {
+  readonly specificationVersion = 'v4';
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  constructor(private readonly config: AnthropicSkillsConfig) {}
+
+  private async getHeaders(): Promise<Record<string, string | undefined>> {
+    return combineHeaders(await resolve(this.config.headers), {
+      'anthropic-beta': 'skills-2025-10-02',
+    });
+  }
+
+  private async fetchVersionMetadata({
+    skillId,
+    version,
+    headers,
+  }: {
+    skillId: string;
+    version: string;
+    headers: Record<string, string | undefined>;
+  }): Promise<{ name?: string; description?: string }> {
+    const { value: versionResponse } = await getFromApi({
+      url: `${this.config.baseURL}/skills/${skillId}/versions/${version}`,
+      headers,
+      failedResponseHandler: anthropicFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        anthropicSkillVersionResponseSchema,
+      ),
+      fetch: this.config.fetch,
+    });
+
+    return {
+      ...(versionResponse.name != null ? { name: versionResponse.name } : {}),
+      ...(versionResponse.description != null
+        ? { description: versionResponse.description }
+        : {}),
+    };
+  }
+
+  async uploadSkill(
+    params: Parameters<SkillsV4['uploadSkill']>[0],
+  ): Promise<Awaited<ReturnType<SkillsV4['uploadSkill']>>> {
+    const warnings: SharedV4Warning[] = [];
+
+    const formData = new FormData();
+
+    if (params.displayTitle != null) {
+      formData.append('display_title', params.displayTitle);
+    }
+
+    for (const file of params.files) {
+      const content =
+        typeof file.content === 'string'
+          ? convertBase64ToUint8Array(file.content)
+          : file.content;
+
+      formData.append('files[]', new Blob([content]), file.path);
+    }
+
+    const headers = await this.getHeaders();
+
+    const { value: response } = await postFormDataToApi({
+      url: `${this.config.baseURL}/skills`,
+      headers,
+      formData,
+      failedResponseHandler: anthropicFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        anthropicSkillResponseSchema,
+      ),
+      fetch: this.config.fetch,
+    });
+
+    const versionMetadata =
+      response.latest_version != null
+        ? await this.fetchVersionMetadata({
+            skillId: response.id,
+            version: response.latest_version,
+            headers,
+          })
+        : {};
+
+    const name = versionMetadata.name ?? response.name;
+    const description = versionMetadata.description ?? response.description;
+
+    return {
+      providerReference: { anthropic: response.id },
+      ...(response.display_title != null
+        ? { displayTitle: response.display_title }
+        : {}),
+      ...(name != null ? { name } : {}),
+      ...(description != null ? { description } : {}),
+      ...(response.latest_version != null
+        ? { latestVersion: response.latest_version }
+        : {}),
+      providerMetadata: {
+        anthropic: {
+          ...(response.source != null ? { source: response.source } : {}),
+          ...(response.created_at != null
+            ? { createdAt: response.created_at }
+            : {}),
+          ...(response.updated_at != null
+            ? { updatedAt: response.updated_at }
+            : {}),
+        },
+      },
+      warnings,
+    };
+  }
+}