@ai-sdk/anthropic 4.0.51 → 4.0.53

package/docs/05-anthropic.mdx

@@ -483,12 +483,13 @@ const result = streamText({
 ##### Thinking Binding Controls
 
 Fable 5.1 can recover from a thinking-block prefix mismatch by dropping the
-mismatched block. Set `blockBinding.prefixMismatchBehavior` to `drop_block`.
-You can provide block binding by itself to preserve the model's default
-thinking mode, or combine it with adaptive thinking.
+mismatched block. Set `blockBinding.prefixMismatchBehavior` to `drop_block`, or
+set it to `error` to reject the request. You can provide block binding by itself
+to preserve the model's default thinking mode, or combine it with adaptive
+thinking.
 
 ```ts highlight="7-11"
-const { text } = await generateText({
+const result = await generateText({
   model: anthropic('claude-fable-5-1'),
   prompt: 'Continue from this conversation.',
   providerOptions: {
@@ -501,8 +502,14 @@ const { text } = await generateText({
     } satisfies AnthropicLanguageModelOptions,
   },
 });
+
+console.log(result.providerMetadata?.anthropic?.inputTransformations);
 ```
 
+Dropped blocks are reported in
+`providerMetadata.anthropic.inputTransformations` with their `type`, `path`, and
+`reason`.
+
 #### Budget-Based Thinking
 
 For earlier models (`claude-opus-4-20250514`, `claude-sonnet-4-20250514`, `claude-sonnet-4-5-20250929`),

package/package.json

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

package/src/anthropic-api.ts

@@ -727,6 +727,12 @@ const anthropicMcpToolResultContentSchema = z.union([
   ),
 ]);
 
+const anthropicInputTransformationSchema = z.object({
+  type: z.string(),
+  path: z.string(),
+  reason: z.string(),
+});
+
 // limited version of the schema, focussed on what is needed for the implementation
 // this approach limits breakages when the API changes and increases efficiency
 export const anthropicResponseSchema = lazySchema(() =>
@@ -989,6 +995,9 @@ export const anthropicResponseSchema = lazySchema(() =>
       stop_reason: z.string().nullish(),
       stop_sequence: z.string().nullish(),
       stop_details: anthropicStopDetailsSchema.nullish(),
+      input_transformations: z
+        .array(anthropicInputTransformationSchema)
+        .nullish(),
       usage: z.looseObject({
         input_tokens: z.number(),
         output_tokens: z.number(),
@@ -1088,6 +1097,9 @@ export const anthropicChunkSchema = lazySchema(() =>
             )
             .nullish(),
           stop_reason: z.string().nullish(),
+          input_transformations: z
+            .array(anthropicInputTransformationSchema)
+            .nullish(),
           container: z
             .object({
               expires_at: z.string(),
@@ -1441,6 +1453,9 @@ export const anthropicChunkSchema = lazySchema(() =>
             )
             .nullish(),
         }),
+        input_transformations: z
+          .array(anthropicInputTransformationSchema)
+          .nullish(),
         context_management: z
           .object({
             applied_edits: z.array(

package/src/anthropic-batch.ts

@@ -3,7 +3,10 @@ import {
   InvalidResponseDataError,
   UnsupportedFunctionalityError,
   type Experimental_BatchV4 as BatchV4,
+  type Experimental_BatchV4CancelResult as BatchV4CancelResult,
   type Experimental_BatchV4ItemResult as BatchV4ItemResult,
+  type Experimental_BatchV4ListOptions as BatchV4ListOptions,
+  type Experimental_BatchV4ListResult as BatchV4ListResult,
   type Experimental_BatchV4OperationOptions as BatchV4OperationOptions,
   type Experimental_BatchV4StartResult as BatchV4StartResult,
   type Experimental_BatchV4Status as BatchV4Status,
@@ -64,25 +67,36 @@ const anthropicBatchProviderOptionsSchema = anthropicLanguageModelOptions.pick({
 
 type AnthropicBatchRequest = TextBatchV4Request<AnthropicModelId>;
 
+const anthropicBatchResponseZodSchema = () =>
+  z.object({
+    id: z.string(),
+    type: z.literal('message_batch'),
+    processing_status: z.string(),
+    request_counts: z.object({
+      processing: z.number(),
+      succeeded: z.number(),
+      errored: z.number(),
+      canceled: z.number(),
+      expired: z.number(),
+    }),
+    created_at: z.string(),
+    expires_at: z.string(),
+    archived_at: z.string().nullish(),
+    cancel_initiated_at: z.string().nullish(),
+    ended_at: z.string().nullish(),
+    results_url: z.string().nullish(),
+  });
+
 const anthropicBatchResponseSchema = lazySchema(() =>
+  zodSchema(anthropicBatchResponseZodSchema()),
+);
+
+const anthropicBatchListResponseSchema = lazySchema(() =>
   zodSchema(
     z.object({
-      id: z.string(),
-      type: z.literal('message_batch'),
-      processing_status: z.string(),
-      request_counts: z.object({
-        processing: z.number(),
-        succeeded: z.number(),
-        errored: z.number(),
-        canceled: z.number(),
-        expired: z.number(),
-      }),
-      created_at: z.string(),
-      expires_at: z.string(),
-      archived_at: z.string().nullish(),
-      cancel_initiated_at: z.string().nullish(),
-      ended_at: z.string().nullish(),
-      results_url: z.string().nullish(),
+      data: z.array(anthropicBatchResponseZodSchema()),
+      has_more: z.boolean(),
+      last_id: z.string().nullish(),
     }),
   ),
 );
@@ -148,6 +162,20 @@ type AnthropicBatchResultLine = InferSchema<
 
 type AnthropicResponse = InferSchema<typeof anthropicResponseSchema>;
 
+function assertTextBatchRequests(
+  requests: BatchV4StartOptions['requests'],
+): asserts requests is ReadonlyArray<AnthropicBatchRequest> {
+  for (const request of requests) {
+    const requestType = request.type;
+    if (requestType !== 'text') {
+      throw new UnsupportedFunctionalityError({
+        functionality: `batch request type: ${requestType}`,
+        message: `The Anthropic Message Batches API does not support batch requests with type "${requestType}".`,
+      });
+    }
+  }
+}
+
 export class AnthropicBatch implements BatchV4<{
   readonly text: AnthropicModelId;
 }> {
@@ -177,6 +205,7 @@ export class AnthropicBatch implements BatchV4<{
   }: BatchV4StartOptions<{
     text: AnthropicModelId;
   }>): Promise<BatchV4StartResult> {
+    assertTextBatchRequests(requests);
     validateRequestIds(requests);
 
     const explicitBatchBetas = new Set(
@@ -295,6 +324,56 @@ export class AnthropicBatch implements BatchV4<{
     return convertAnthropicBatchStatus(await this.retrieveBatch(options));
   }
 
+  async doCancelBatch(
+    options: BatchV4OperationOptions,
+  ): Promise<BatchV4CancelResult> {
+    await postJsonToApi({
+      url: this.getBatchUrl(`/${encodeURIComponent(options.batchId)}/cancel`),
+      headers: await this.getBatchHeaders(options.headers),
+      body: {},
+      failedResponseHandler: anthropicFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        anthropicBatchResponseSchema,
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.options.config.fetch,
+    });
+
+    return {};
+  }
+
+  async doListBatches(options: BatchV4ListOptions): Promise<BatchV4ListResult> {
+    const url = new URL(this.getBatchUrl(''));
+    if (options.limit != null) {
+      url.searchParams.set('limit', String(options.limit));
+    }
+    if (options.cursor != null) {
+      url.searchParams.set('after_id', options.cursor);
+    }
+
+    const { value: page } = await getFromApi({
+      url: url.toString(),
+      validateUrl: false,
+      headers: await this.getBatchHeaders(options.headers),
+      failedResponseHandler: anthropicFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        anthropicBatchListResponseSchema,
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.options.config.fetch,
+    });
+
+    return {
+      batches: page.data.map(batch => ({
+        batchId: batch.id,
+        ...convertAnthropicBatchStatus(batch),
+      })),
+      ...(page.has_more && page.last_id != null
+        ? { nextCursor: page.last_id }
+        : {}),
+    };
+  }
+
   async doGetBatchResults(
     options: BatchV4OperationOptions,
   ): Promise<ReadableStream<BatchV4ItemResult>> {
@@ -1016,6 +1095,9 @@ function convertAnthropicMessageMetadata(response: AnthropicResponse) {
     usage: response.usage as JSONObject,
     stopSequence: response.stop_sequence ?? null,
     ...(stopDetails != null ? { stopDetails } : {}),
+    ...(response.input_transformations != null
+      ? { inputTransformations: response.input_transformations }
+      : {}),
     iterations: response.usage.iterations
       ? response.usage.iterations.map(
           iteration =>

package/src/anthropic-language-model-options.ts

@@ -163,7 +163,7 @@ export const anthropicLanguageModelOptions = z.object({
            */
           blockBinding: z
             .object({
-              prefixMismatchBehavior: z.literal('drop_block'),
+              prefixMismatchBehavior: z.enum(['error', 'drop_block']),
             })
             .optional(),
         }),
@@ -179,7 +179,7 @@ export const anthropicLanguageModelOptions = z.object({
       z.object({
         type: z.never().optional(),
         blockBinding: z.object({
-          prefixMismatchBehavior: z.literal('drop_block'),
+          prefixMismatchBehavior: z.enum(['error', 'drop_block']),
         }),
       }),
     ])

package/src/anthropic-language-model.ts

@@ -1556,6 +1556,9 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
           usage: response.usage as JSONObject,
           stopSequence: response.stop_sequence ?? null,
           ...(stopDetails != null ? { stopDetails } : {}),
+          ...(response.input_transformations != null
+            ? { inputTransformations: response.input_transformations }
+            : {}),
 
           iterations: response.usage.iterations
             ? response.usage.iterations.map(
@@ -1693,6 +1696,7 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
     let rawUsage: JSONObject | undefined = undefined;
     let stopSequence: string | null = null;
     let stopDetails: AnthropicMessageMetadata['stopDetails'] = undefined;
+    let inputTransformations: AnthropicMessageMetadata['inputTransformations'];
     let container: AnthropicMessageMetadata['container'] | null = null;
     let isJsonResponseFromTool = false;
     let isMessageOpen = false;
@@ -2561,6 +2565,10 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
                 ...(value.message.usage as JSONObject),
               };
 
+              if (value.message.input_transformations != null) {
+                inputTransformations = value.message.input_transformations;
+              }
+
               if (value.message.container != null) {
                 container = {
                   expiresAt: value.message.container.expires_at,
@@ -2689,6 +2697,10 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
                 );
               }
 
+              if (value.input_transformations != null) {
+                inputTransformations = value.input_transformations;
+              }
+
               rawUsage = {
                 ...rawUsage,
                 ...(value.usage as JSONObject),
@@ -2705,6 +2717,9 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
                 usage: (rawUsage as JSONObject) ?? null,
                 stopSequence,
                 ...(stopDetails != null ? { stopDetails } : {}),
+                ...(inputTransformations != null
+                  ? { inputTransformations }
+                  : {}),
                 iterations: usage.iterations
                   ? usage.iterations.map(
                       iter =>

package/src/anthropic-message-metadata.ts

@@ -50,6 +50,18 @@ export interface AnthropicMessageMetadata {
   usage: JSONObject;
   stopSequence: string | null;
 
+  /**
+   * Input blocks that Anthropic transformed before inference. This is
+   * populated when thinking binding controls drop a mismatched thinking block.
+   * Values are intentionally open-ended so new transformation types and
+   * reasons remain forward compatible.
+   */
+  inputTransformations?: Array<{
+    type: string;
+    path: string;
+    reason: string;
+  }>;
+
   /**
    * Details about why the request stopped. Present only when the API returns
    * a `refusal` stop reason together with a `stop_details` object (a