@ai-sdk/anthropic 4.0.49 → 4.0.51

package/docs/05-anthropic.mdx

@@ -144,55 +144,19 @@ The following optional provider options are available for Anthropic models:
   Optional. Metadata to include with the request. See the [Anthropic API documentation](https://platform.claude.com/docs/en/api/messages/create) for details.
   - `userId` _string_ - An external identifier for the end-user. Should be a UUID, hash, or other opaque identifier. Must not contain PII.
 
-### Text Batches
+### Batch
 
 <Note type="warning">
-  Text batch support is experimental and the API may change in patch releases.
+  Batch support is experimental and the API may change in patch releases.
 </Note>
 
 Anthropic language models support asynchronous text generation through the
 [Message Batches API](https://platform.claude.com/docs/en/build-with-claude/batch-processing).
-Use the experimental text batch APIs to start a batch, poll its status, and
-stream its results:
+Pass the Anthropic provider to the AI SDK's [Batch](/docs/ai-sdk-core/batch)
+API for the complete workflow, including polling, persistence, and result handling.
 
-```ts
-import { anthropic } from '@ai-sdk/anthropic';
-import {
-  experimental_getBatchResults as getBatchResults,
-  experimental_getBatchStatus as getBatchStatus,
-  experimental_startTextBatch as startTextBatch,
-} from 'ai';
-import { setTimeout } from 'node:timers/promises';
-
-const model = anthropic('claude-haiku-4-5');
-
-const batch = await startTextBatch({
-  model,
-  requests: [
-    { id: 'capital-france', prompt: 'What is the capital of France?' },
-    { id: 'capital-germany', prompt: 'What is the capital of Germany?' },
-  ],
-});
-
-let status = batch.status;
-while (status === 'pending') {
-  await setTimeout(60_000);
-  ({ status } = await getBatchStatus({ model, batch }));
-}
-
-for await (const item of getBatchResults({ model, batch })) {
-  if (item.status === 'succeeded') {
-    console.log(item.id, item.text);
-  } else {
-    console.error(item.id, item.error);
-  }
-}
-```
-
-`startTextBatch` returns a serializable batch reference. Persist this reference
-to check the batch status or retrieve its results from another process. Results
-can arrive in a different order from the input requests, so match each result by
-its `id`.
+Each request specifies its `type` and `model`. Anthropic supports using
+different text models within the same batch.
 
 #### Batch Limitations
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/anthropic",
-  "version": "4.0.49",
+  "version": "4.0.51",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -35,8 +35,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.10",
-    "@ai-sdk/provider-utils": "5.0.36"
+    "@ai-sdk/provider": "4.0.12",
+    "@ai-sdk/provider-utils": "5.0.38"
   },
   "devDependencies": {
     "@ai-sdk/test-server": "2.0.1",

package/src/{anthropic-messages-batch.ts → anthropic-batch.ts}

@@ -2,11 +2,14 @@ import {
   InvalidArgumentError,
   InvalidResponseDataError,
   UnsupportedFunctionalityError,
-  type Experimental_BatchLanguageModelV4 as BatchLanguageModelV4,
+  type Experimental_BatchV4 as BatchV4,
   type Experimental_BatchV4ItemResult as BatchV4ItemResult,
   type Experimental_BatchV4OperationOptions as BatchV4OperationOptions,
   type Experimental_BatchV4StartResult as BatchV4StartResult,
   type Experimental_BatchV4Status as BatchV4Status,
+  type Experimental_TextBatchV4Request as TextBatchV4Request,
+  type Experimental_TextBatchV4ItemResult as TextBatchV4ItemResult,
+  type Experimental_BatchV4StartOptions as BatchV4StartOptions,
   type JSONObject,
   type LanguageModelV4GenerateResult,
   type SharedV4ProviderMetadata,
@@ -16,6 +19,7 @@ import {
   convertAsyncIteratorToReadableStream,
   createJsonLinesResponseHandler,
   createJsonResponseHandler,
+  generateId,
   getFromApi,
   isRecord,
   lazySchema,
@@ -25,8 +29,6 @@ import {
   postJsonToApi,
   resolve,
   safeValidateTypes,
-  WORKFLOW_DESERIALIZE,
-  WORKFLOW_SERIALIZE,
   zodSchema,
   type InferSchema,
 } from '@ai-sdk/provider-utils';
@@ -60,9 +62,7 @@ const anthropicBatchProviderOptionsSchema = anthropicLanguageModelOptions.pick({
   anthropicBeta: true,
 });
 
-type AnthropicBatchRequest = Parameters<
-  BatchLanguageModelV4['experimental_doStartBatch']
->[0]['requests'][number];
+type AnthropicBatchRequest = TextBatchV4Request<AnthropicModelId>;
 
 const anthropicBatchResponseSchema = lazySchema(() =>
   zodSchema(
@@ -148,42 +148,40 @@ type AnthropicBatchResultLine = InferSchema<
 
 type AnthropicResponse = InferSchema<typeof anthropicResponseSchema>;
 
-export class AnthropicMessagesBatchLanguageModel
-  extends AnthropicLanguageModel
-  implements BatchLanguageModelV4
-{
-  static [WORKFLOW_SERIALIZE](model: AnthropicMessagesBatchLanguageModel) {
-    return AnthropicLanguageModel[WORKFLOW_SERIALIZE](model);
-  }
-
-  static [WORKFLOW_DESERIALIZE](options: {
-    modelId: AnthropicModelId;
-    config: AnthropicLanguageModelConfig;
-  }) {
-    return new AnthropicMessagesBatchLanguageModel(
-      options.modelId,
-      options.config,
-    );
-  }
-
-  constructor(modelId: AnthropicModelId, config: AnthropicLanguageModelConfig) {
-    super(modelId, config);
+export class AnthropicBatch implements BatchV4<{
+  readonly text: AnthropicModelId;
+}> {
+  readonly specificationVersion = 'v4' as const;
+  readonly provider: string;
+  readonly supportedUrls: Record<string, RegExp[]>;
+  private readonly generateId: () => string;
+
+  constructor(
+    private readonly options: {
+      provider: string;
+      config: AnthropicLanguageModelConfig;
+      supportedUrls: Record<string, RegExp[]>;
+    },
+  ) {
+    this.provider = options.provider;
+    this.supportedUrls = options.supportedUrls;
+    this.generateId = options.config.generateId ?? generateId;
   }
 
-  async experimental_doStartBatch({
+  async doStartBatch({
     requests,
     providerOptions,
     headers,
     abortSignal,
     webhookUrl,
-  }: Parameters<
-    BatchLanguageModelV4['experimental_doStartBatch']
-  >[0]): Promise<BatchV4StartResult> {
+  }: BatchV4StartOptions<{
+    text: AnthropicModelId;
+  }>): Promise<BatchV4StartResult> {
     validateRequestIds(requests);
 
     const explicitBatchBetas = new Set(
       await getAnthropicBatchProviderBetas({
-        provider: this.config.provider,
+        provider: this.options.config.provider,
         providerOptions,
       }),
     );
@@ -208,7 +206,7 @@ export class AnthropicMessagesBatchLanguageModel
 
     for (const request of requests) {
       const requestBetas = await getAnthropicBatchProviderBetas({
-        provider: this.config.provider,
+        provider: this.options.config.provider,
         providerOptions: request.options.providerOptions,
       });
       if (requestBetas.length > 0) {
@@ -217,14 +215,18 @@ export class AnthropicMessagesBatchLanguageModel
           message:
             `Anthropic Message Batches do not support per-request betas ` +
             `(request "${request.id}"). Set providerOptions.anthropic.anthropicBeta ` +
-            `on startTextBatch instead.`,
+            `on startBatch instead.`,
         });
       }
 
-      const prepared = await this.getArgs({
-        ...request.options,
-        stream: false,
-        userSuppliedBetas: new Set(explicitBatchBetas),
+      const prepared = await AnthropicLanguageModel.prepareRequest({
+        modelId: request.modelId,
+        config: this.options.config,
+        options: {
+          ...request.options,
+          stream: false,
+          userSuppliedBetas: new Set(explicitBatchBetas),
+        },
       });
       if (prepared.usesJsonResponseTool) {
         throw new UnsupportedFunctionalityError({
@@ -249,7 +251,11 @@ export class AnthropicMessagesBatchLanguageModel
             `(request "${request.id}"). Use the provider's canonical tool name.`,
         });
       }
-      const body = this.transformRequestBody(prepared.args, prepared.betas);
+      const body =
+        this.options.config.transformRequestBody?.(
+          prepared.args,
+          prepared.betas,
+        ) ?? prepared.args;
       validateAnthropicBatchBody({
         body,
         requestId: request.id,
@@ -273,7 +279,7 @@ export class AnthropicMessagesBatchLanguageModel
         anthropicBatchResponseSchema,
       ),
       abortSignal,
-      fetch: this.config.fetch,
+      fetch: this.options.config.fetch,
     });
 
     return {
@@ -283,15 +289,15 @@ export class AnthropicMessagesBatchLanguageModel
     };
   }
 
-  async experimental_doGetBatchStatus(
+  async doGetBatchStatus(
     options: BatchV4OperationOptions,
   ): Promise<BatchV4Status> {
     return convertAnthropicBatchStatus(await this.retrieveBatch(options));
   }
 
-  async experimental_doGetBatchResults(
+  async doGetBatchResults(
     options: BatchV4OperationOptions,
-  ): Promise<ReadableStream<BatchV4ItemResult<LanguageModelV4GenerateResult>>> {
+  ): Promise<ReadableStream<BatchV4ItemResult>> {
     const batch = await this.retrieveBatch(options);
 
     if (convertAnthropicBatchStatus(batch).status === 'pending') {
@@ -318,15 +324,15 @@ export class AnthropicMessagesBatchLanguageModel
     const { value: lines } = await getFromApi({
       url: batch.results_url,
       validateUrl: true,
-      credentialedOrigin: this.config.baseURL,
-      trustedOrigin: this.config.baseURL,
+      credentialedOrigin: this.options.config.baseURL,
+      trustedOrigin: this.options.config.baseURL,
       headers: await this.getBatchHeaders(options.headers),
       failedResponseHandler: anthropicFailedResponseHandler,
       successfulResponseHandler: createJsonLinesResponseHandler(
         anthropicBatchResultLineSchema,
       ),
       abortSignal: options.abortSignal,
-      fetch: this.config.fetch,
+      fetch: this.options.config.fetch,
     });
 
     return convertAsyncIteratorToReadableStream(
@@ -346,7 +352,7 @@ export class AnthropicMessagesBatchLanguageModel
         anthropicBatchResponseSchema,
       ),
       abortSignal: options.abortSignal,
-      fetch: this.config.fetch,
+      fetch: this.options.config.fetch,
     });
 
     return batch;
@@ -354,14 +360,14 @@ export class AnthropicMessagesBatchLanguageModel
 
   private async *iterateBatchResults(
     lines: AsyncIterable<AnthropicBatchResultLine>,
-  ): AsyncGenerator<BatchV4ItemResult<LanguageModelV4GenerateResult>> {
+  ): AsyncGenerator<BatchV4ItemResult> {
     for await (const line of lines) {
       yield await convertAnthropicBatchResult(line, this.generateId);
     }
   }
 
   private getBatchUrl(path: string) {
-    return `${this.config.baseURL}/messages/batches${path}`;
+    return `${this.options.config.baseURL}/messages/batches${path}`;
   }
 
   private async getStartBatchHeaders({
@@ -384,7 +390,9 @@ export class AnthropicMessagesBatchLanguageModel
     headers: Record<string, string | undefined> | undefined,
   ) {
     return combineHeaders(
-      this.config.headers ? await resolve(this.config.headers) : undefined,
+      this.options.config.headers
+        ? await resolve(this.options.config.headers)
+        : undefined,
       headers,
     );
   }
@@ -533,7 +541,7 @@ function convertAnthropicRequestCounts(
 async function convertAnthropicBatchResult(
   line: AnthropicBatchResultLine,
   generateId: () => string,
-): Promise<BatchV4ItemResult<LanguageModelV4GenerateResult>> {
+): Promise<TextBatchV4ItemResult> {
   const resultValidation = await safeValidateTypes({
     value: line.result,
     schema: anthropicBatchResultSchema,
@@ -547,12 +555,13 @@ async function convertAnthropicBatchResult(
 
   switch (result.type) {
     case 'canceled':
-      return { id: line.custom_id, status: 'cancelled' };
+      return { type: 'text', id: line.custom_id, status: 'cancelled' };
     case 'expired':
-      return { id: line.custom_id, status: 'expired' };
+      return { type: 'text', id: line.custom_id, status: 'expired' };
     case 'errored': {
       const requestId = result.error.request_id;
       return {
+        type: 'text',
         id: line.custom_id,
         status: 'failed',
         error: {
@@ -576,6 +585,7 @@ async function convertAnthropicBatchResult(
       }
 
       return {
+        type: 'text',
         id: line.custom_id,
         status: 'succeeded',
         result: convertAnthropicBatchResponse(response, generateId),
@@ -584,10 +594,9 @@ async function convertAnthropicBatchResult(
   }
 }
 
-function invalidAnthropicBatchResult(
-  id: string,
-): BatchV4ItemResult<LanguageModelV4GenerateResult> {
+function invalidAnthropicBatchResult(id: string): TextBatchV4ItemResult {
   return {
+    type: 'text',
     id,
     status: 'failed',
     error: {

package/src/anthropic-language-model.ts

@@ -195,6 +195,11 @@ function getAnthropicCallerMetadata(
     : { providerMetadata: { anthropic: { caller: callerInfo } } };
 }
 
+function getProviderOptionsName(provider: string): string {
+  const dotIndex = provider.indexOf('.');
+  return dotIndex === -1 ? provider : provider.substring(0, dotIndex);
+}
+
 export type AnthropicLanguageModelConfig = {
   provider: string;
   baseURL: string;
@@ -207,16 +212,7 @@ export type AnthropicLanguageModelConfig = {
   ) => Record<string, any>;
   supportedUrls?: () => LanguageModelV4['supportedUrls'];
   generateId?: () => string;
-
-  /**
-   * When false, the model will use JSON tool fallback for structured outputs.
-   */
   supportsNativeStructuredOutput?: boolean;
-
-  /**
-   * When false, `strict` on tool definitions will be ignored and a warning emitted.
-   * Defaults to true.
-   */
   supportsStrictTools?: boolean;
 };
 
@@ -256,40 +252,38 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
     return this.config.provider;
   }
 
-  /**
-   * Extracts the dynamic provider name from the config.provider string.
-   * e.g., 'my-custom-anthropic.messages' -> 'my-custom-anthropic'
-   */
-  private get providerOptionsName(): string {
-    const provider = this.config.provider;
-    const dotIndex = provider.indexOf('.');
-    return dotIndex === -1 ? provider : provider.substring(0, dotIndex);
-  }
-
   get supportedUrls() {
     return this.config.supportedUrls?.() ?? {};
   }
 
-  protected async getArgs({
-    userSuppliedBetas,
-    prompt,
-    maxOutputTokens,
-    temperature,
-    topP,
-    topK,
-    frequencyPenalty,
-    presencePenalty,
-    stopSequences,
-    responseFormat,
-    seed,
-    tools,
-    toolChoice,
-    reasoning,
-    providerOptions,
-    stream,
-  }: LanguageModelV4CallOptions & {
-    stream: boolean;
-    userSuppliedBetas: Set<string>;
+  static async prepareRequest({
+    modelId,
+    config,
+    options: {
+      userSuppliedBetas,
+      prompt,
+      maxOutputTokens,
+      temperature,
+      topP,
+      topK,
+      frequencyPenalty,
+      presencePenalty,
+      stopSequences,
+      responseFormat,
+      seed,
+      tools,
+      toolChoice,
+      reasoning,
+      providerOptions,
+      stream,
+    },
+  }: {
+    modelId: AnthropicModelId;
+    config: AnthropicLanguageModelConfig;
+    options: LanguageModelV4CallOptions & {
+      stream: boolean;
+      userSuppliedBetas: Set<string>;
+    };
   }) {
     const warnings: SharedV4Warning[] = [];
 
@@ -333,7 +327,7 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
       }
     }
 
-    const providerOptionsName = this.providerOptionsName;
+    const providerOptionsName = getProviderOptionsName(config.provider);
 
     // Parse provider options from both canonical 'anthropic' key and custom key
     const canonicalOptions = await parseProviderOptions({
@@ -369,14 +363,14 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
       supportsXhighEffort,
       rejectsThinkingDisabledAboveHighEffort,
       isKnownModel,
-    } = getModelCapabilities(this.modelId);
+    } = getModelCapabilities(modelId);
 
     if (!isKnownModel && maxOutputTokens == null) {
       warnings.push({
         type: 'compatibility',
         feature: 'maxOutputTokens',
         details:
-          `The model "${this.modelId}" is unknown. ` +
+          `The model "${modelId}" is unknown. ` +
           `The max output tokens have been limited to ${maxOutputTokensForModel}. ` +
           `Set maxOutputTokens explicitly to override this limit.`,
       });
@@ -387,7 +381,7 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
         warnings.push({
           type: 'unsupported',
           feature: 'temperature',
-          details: `temperature is not supported by ${this.modelId} and will be ignored`,
+          details: `temperature is not supported by ${modelId} and will be ignored`,
         });
         temperature = undefined;
       }
@@ -395,7 +389,7 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
         warnings.push({
           type: 'unsupported',
           feature: 'topK',
-          details: `topK is not supported by ${this.modelId} and will be ignored`,
+          details: `topK is not supported by ${modelId} and will be ignored`,
         });
         topK = undefined;
       }
@@ -403,21 +397,20 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
         warnings.push({
           type: 'unsupported',
           feature: 'topP',
-          details: `topP is not supported by ${this.modelId} and will be ignored`,
+          details: `topP is not supported by ${modelId} and will be ignored`,
         });
         topP = undefined;
       }
     }
 
-    const isAnthropicModel = isKnownModel || this.modelId.includes('claude-');
+    const isAnthropicModel = isKnownModel || modelId.includes('claude-');
 
     const supportsStructuredOutput =
-      (this.config.supportsNativeStructuredOutput ?? true) &&
+      (config.supportsNativeStructuredOutput ?? true) &&
       modelSupportsStructuredOutput;
 
     const supportsStrictTools =
-      (this.config.supportsStrictTools ?? true) &&
-      modelSupportsStructuredOutput;
+      (config.supportsStrictTools ?? true) && modelSupportsStructuredOutput;
 
     const structureOutputMode =
       anthropicOptions?.structuredOutputMode ?? 'auto';
@@ -526,7 +519,7 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
         type: 'unsupported',
         feature: 'providerOptions.anthropic.effort',
         details:
-          `effort '${anthropicOptions.effort}' is not supported by ${this.modelId} when thinking is disabled. ` +
+          `effort '${anthropicOptions.effort}' is not supported by ${modelId} when thinking is disabled. ` +
           `The effort has been lowered to 'high'.`,
       });
       anthropicOptions.effort = 'high';
@@ -559,7 +552,7 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
 
     const baseArgs = {
       // model id:
-      model: this.modelId,
+      model: modelId,
 
       // standardized settings:
       max_tokens: maxTokens,
@@ -801,7 +794,7 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
           type: 'unsupported',
           feature: 'maxOutputTokens',
           details:
-            `${baseArgs.max_tokens} (maxOutputTokens + thinkingBudget) is greater than ${this.modelId} ${maxOutputTokensForModel} max output tokens. ` +
+            `${baseArgs.max_tokens} (maxOutputTokens + thinkingBudget) is greater than ${modelId} ${maxOutputTokensForModel} max output tokens. ` +
             `The max output tokens have been limited to ${maxOutputTokensForModel}.`,
         });
       }
@@ -927,6 +920,19 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
     };
   }
 
+  private getArgs(
+    options: LanguageModelV4CallOptions & {
+      stream: boolean;
+      userSuppliedBetas: Set<string>;
+    },
+  ) {
+    return AnthropicLanguageModel.prepareRequest({
+      modelId: this.modelId,
+      config: this.config,
+      options,
+    });
+  }
+
   private async getHeaders({
     betas,
     headers,

package/src/anthropic-provider.ts

@@ -1,8 +1,9 @@
 import {
   InvalidArgumentError,
   NoSuchModelError,
-  type Experimental_BatchLanguageModelV4 as BatchLanguageModelV4,
+  type Experimental_BatchV4 as BatchV4,
   type FilesV4,
+  type LanguageModelV4,
   type ProviderV4,
   type SkillsV4,
 } from '@ai-sdk/provider';
@@ -16,7 +17,8 @@ import {
   type FetchFunction,
 } from '@ai-sdk/provider-utils';
 import { AnthropicFiles } from './anthropic-files';
-import { AnthropicMessagesBatchLanguageModel } from './anthropic-messages-batch';
+import { AnthropicLanguageModel } from './anthropic-language-model';
+import { AnthropicBatch } from './anthropic-batch';
 import type { AnthropicModelId } from './anthropic-language-model-options';
 import { anthropicTools } from './anthropic-tools';
 import { AnthropicSkills } from './skills/anthropic-skills';
@@ -39,16 +41,18 @@ export interface AnthropicProvider extends ProviderV4 {
   /**
    * Creates a model for text generation.
    */
-  (modelId: AnthropicModelId): BatchLanguageModelV4;
+  (modelId: AnthropicModelId): LanguageModelV4;
 
   /**
    * Creates a model for text generation.
    */
-  languageModel(modelId: AnthropicModelId): BatchLanguageModelV4;
+  languageModel(modelId: AnthropicModelId): LanguageModelV4;
 
-  chat(modelId: AnthropicModelId): BatchLanguageModelV4;
+  chat(modelId: AnthropicModelId): LanguageModelV4;
 
-  messages(modelId: AnthropicModelId): BatchLanguageModelV4;
+  messages(modelId: AnthropicModelId): LanguageModelV4;
+
+  experimental_batch(): BatchV4<{ text: AnthropicModelId }>;
 
   /**
    * @deprecated Use `embeddingModel` instead.
@@ -124,6 +128,10 @@ export function createAnthropic(
     ) ?? ANTHROPIC_API_VERSIONED_URL;
 
   const providerName = options.name ?? 'anthropic.messages';
+  const supportedUrls = {
+    'image/*': [/^https?:\/\/.*$/],
+    'application/pdf': [/^https?:\/\/.*$/],
+  };
 
   // Only error if both are explicitly provided in options
   if (options.apiKey && options.authToken) {
@@ -155,17 +163,23 @@ export function createAnthropic(
     );
   };
 
+  const languageModelConfig = {
+    provider: providerName,
+    baseURL,
+    headers: getHeaders,
+    fetch: options.fetch,
+    generateId: options.generateId ?? generateId,
+    supportedUrls: () => supportedUrls,
+  };
+
   const createChatModel = (modelId: AnthropicModelId) =>
-    new AnthropicMessagesBatchLanguageModel(modelId, {
-      provider: providerName,
-      baseURL,
-      headers: getHeaders,
-      fetch: options.fetch,
-      generateId: options.generateId ?? generateId,
-      supportedUrls: () => ({
-        'image/*': [/^https?:\/\/.*$/],
-        'application/pdf': [/^https?:\/\/.*$/],
-      }),
+    new AnthropicLanguageModel(modelId, languageModelConfig);
+
+  const createBatch = () =>
+    new AnthropicBatch({
+      provider: `${providerName.replace(/\.messages$/, '')}.batch`,
+      config: languageModelConfig,
+      supportedUrls,
     });
 
   const createSkills = () =>
@@ -190,6 +204,7 @@ export function createAnthropic(
   provider.languageModel = createChatModel;
   provider.chat = createChatModel;
   provider.messages = createChatModel;
+  provider.experimental_batch = createBatch;
 
   provider.embeddingModel = (modelId: string) => {
     throw new NoSuchModelError({ modelId, modelType: 'embeddingModel' });