@ai-sdk/anthropic 4.0.51 → 4.0.53

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @ai-sdk/anthropic
 
+## 4.0.53
+
+### Patch Changes
+
+- 5ec21a6: fix: reject unsupported batch request types
+- 7469a3b: feat: support image generation requests in batches
+- e4292e7: feat(anthropic): expand preserved thinking support to cover `prefix_mismatch_behavior: 'error'`
+- Updated dependencies [5ec21a6]
+- Updated dependencies [7469a3b]
+- Updated dependencies [813bb36]
+- Updated dependencies [c43e4b7]
+  - @ai-sdk/provider@4.0.14
+  - @ai-sdk/provider-utils@5.0.40
+
+## 4.0.52
+
+### Patch Changes
+
+- 5a7e647: feat(anthropic): add batch cancellation and listing
+- Updated dependencies [9942196]
+  - @ai-sdk/provider@4.0.13
+  - @ai-sdk/provider-utils@5.0.39
+
 ## 4.0.51
 
 ### Patch Changes

package/dist/index.d.ts

@@ -46,6 +46,17 @@ type AnthropicUsageIteration = {
 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
@@ -220,7 +231,10 @@ declare const anthropicLanguageModelOptions: z.ZodObject<{
             updates: "updates";
         }>>;
         blockBinding: z.ZodOptional<z.ZodObject<{
-            prefixMismatchBehavior: z.ZodLiteral<"drop_block">;
+            prefixMismatchBehavior: z.ZodEnum<{
+                error: "error";
+                drop_block: "drop_block";
+            }>;
         }, z.core.$strip>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"enabled">;
@@ -230,7 +244,10 @@ declare const anthropicLanguageModelOptions: z.ZodObject<{
     }, z.core.$strip>]>, z.ZodObject<{
         type: z.ZodOptional<z.ZodNever>;
         blockBinding: z.ZodObject<{
-            prefixMismatchBehavior: z.ZodLiteral<"drop_block">;
+            prefixMismatchBehavior: z.ZodEnum<{
+                error: "error";
+                drop_block: "drop_block";
+            }>;
         }, z.core.$strip>;
     }, z.core.$strip>]>>;
     disableParallelToolUse: z.ZodOptional<z.ZodBoolean>;

package/dist/index.js

@@ -228,6 +228,11 @@ var anthropicMcpToolResultContentSchema = z3.union([
     ])
   )
 ]);
+var anthropicInputTransformationSchema = z3.object({
+  type: z3.string(),
+  path: z3.string(),
+  reason: z3.string()
+});
 var anthropicResponseSchema = lazySchema3(
   () => zodSchema3(
     z3.object({
@@ -482,6 +487,7 @@ var anthropicResponseSchema = lazySchema3(
       stop_reason: z3.string().nullish(),
       stop_sequence: z3.string().nullish(),
       stop_details: anthropicStopDetailsSchema.nullish(),
+      input_transformations: z3.array(anthropicInputTransformationSchema).nullish(),
       usage: z3.looseObject({
         input_tokens: z3.number(),
         output_tokens: z3.number(),
@@ -566,6 +572,7 @@ var anthropicChunkSchema = lazySchema3(
             ])
           ).nullish(),
           stop_reason: z3.string().nullish(),
+          input_transformations: z3.array(anthropicInputTransformationSchema).nullish(),
           container: z3.object({
             expires_at: z3.string(),
             id: z3.string()
@@ -903,6 +910,7 @@ var anthropicChunkSchema = lazySchema3(
             })
           ).nullish()
         }),
+        input_transformations: z3.array(anthropicInputTransformationSchema).nullish(),
         context_management: z3.object({
           applied_edits: z3.array(
             z3.union([
@@ -1051,7 +1059,7 @@ var anthropicLanguageModelOptions = z4.object({
          * prefix. Requires the `thinking-binding-controls-2026-08-01` beta.
          */
         blockBinding: z4.object({
-          prefixMismatchBehavior: z4.literal("drop_block")
+          prefixMismatchBehavior: z4.enum(["error", "drop_block"])
         }).optional()
       }),
       z4.object({
@@ -1066,7 +1074,7 @@ var anthropicLanguageModelOptions = z4.object({
     z4.object({
       type: z4.never().optional(),
       blockBinding: z4.object({
-        prefixMismatchBehavior: z4.literal("drop_block")
+        prefixMismatchBehavior: z4.enum(["error", "drop_block"])
       })
     })
   ]).optional(),
@@ -4822,6 +4830,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
           usage: response.usage,
           stopSequence: (_a2 = response.stop_sequence) != null ? _a2 : null,
           ...stopDetails != null ? { stopDetails } : {},
+          ...response.input_transformations != null ? { inputTransformations: response.input_transformations } : {},
           iterations: response.usage.iterations ? response.usage.iterations.map(
             (iter) => ({
               type: iter.type,
@@ -4909,6 +4918,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
     let rawUsage = void 0;
     let stopSequence = null;
     let stopDetails = void 0;
+    let inputTransformations;
     let container = null;
     let isJsonResponseFromTool = false;
     let isMessageOpen = false;
@@ -5578,6 +5588,9 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
               rawUsage = {
                 ...value.message.usage
               };
+              if (value.message.input_transformations != null) {
+                inputTransformations = value.message.input_transformations;
+              }
               if (value.message.container != null) {
                 container = {
                   expiresAt: value.message.container.expires_at,
@@ -5677,6 +5690,9 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                   value.context_management
                 );
               }
+              if (value.input_transformations != null) {
+                inputTransformations = value.input_transformations;
+              }
               rawUsage = {
                 ...rawUsage,
                 ...value.usage
@@ -5690,6 +5706,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                 usage: rawUsage != null ? rawUsage : null,
                 stopSequence,
                 ...stopDetails != null ? { stopDetails } : {},
+                ...inputTransformations != null ? { inputTransformations } : {},
                 iterations: usage.iterations ? usage.iterations.map(
                   (iter) => ({
                     type: iter.type,
@@ -6008,25 +6025,33 @@ var anthropicBatchRequestIdPattern = /^[A-Za-z0-9_-]{1,64}$/;
 var anthropicBatchProviderOptionsSchema = anthropicLanguageModelOptions.pick({
   anthropicBeta: true
 });
+var anthropicBatchResponseZodSchema = () => z15.object({
+  id: z15.string(),
+  type: z15.literal("message_batch"),
+  processing_status: z15.string(),
+  request_counts: z15.object({
+    processing: z15.number(),
+    succeeded: z15.number(),
+    errored: z15.number(),
+    canceled: z15.number(),
+    expired: z15.number()
+  }),
+  created_at: z15.string(),
+  expires_at: z15.string(),
+  archived_at: z15.string().nullish(),
+  cancel_initiated_at: z15.string().nullish(),
+  ended_at: z15.string().nullish(),
+  results_url: z15.string().nullish()
+});
 var anthropicBatchResponseSchema = lazySchema14(
+  () => zodSchema14(anthropicBatchResponseZodSchema())
+);
+var anthropicBatchListResponseSchema = lazySchema14(
   () => zodSchema14(
     z15.object({
-      id: z15.string(),
-      type: z15.literal("message_batch"),
-      processing_status: z15.string(),
-      request_counts: z15.object({
-        processing: z15.number(),
-        succeeded: z15.number(),
-        errored: z15.number(),
-        canceled: z15.number(),
-        expired: z15.number()
-      }),
-      created_at: z15.string(),
-      expires_at: z15.string(),
-      archived_at: z15.string().nullish(),
-      cancel_initiated_at: z15.string().nullish(),
-      ended_at: z15.string().nullish(),
-      results_url: z15.string().nullish()
+      data: z15.array(anthropicBatchResponseZodSchema()),
+      has_more: z15.boolean(),
+      last_id: z15.string().nullish()
     })
   )
 );
@@ -6080,6 +6105,17 @@ var anthropicBatchResultLineSchema = lazySchema14(
     })
   )
 );
+function assertTextBatchRequests(requests) {
+  for (const request of requests) {
+    const requestType = request.type;
+    if (requestType !== "text") {
+      throw new UnsupportedFunctionalityError3({
+        functionality: `batch request type: ${requestType}`,
+        message: `The Anthropic Message Batches API does not support batch requests with type "${requestType}".`
+      });
+    }
+  }
+}
 var AnthropicBatch = class {
   constructor(options) {
     this.options = options;
@@ -6097,6 +6133,7 @@ var AnthropicBatch = class {
     webhookUrl
   }) {
     var _a, _b, _c, _d;
+    assertTextBatchRequests(requests);
     validateRequestIds(requests);
     const explicitBatchBetas = new Set(
       await getAnthropicBatchProviderBetas({
@@ -6187,6 +6224,47 @@ var AnthropicBatch = class {
   async doGetBatchStatus(options) {
     return convertAnthropicBatchStatus(await this.retrieveBatch(options));
   }
+  async doCancelBatch(options) {
+    await postJsonToApi2({
+      url: this.getBatchUrl(`/${encodeURIComponent(options.batchId)}/cancel`),
+      headers: await this.getBatchHeaders(options.headers),
+      body: {},
+      failedResponseHandler: anthropicFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler3(
+        anthropicBatchResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.options.config.fetch
+    });
+    return {};
+  }
+  async doListBatches(options) {
+    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: createJsonResponseHandler3(
+        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) {
     const batch = await this.retrieveBatch(options);
     if (convertAnthropicBatchStatus(batch).status === "pending") {
@@ -6771,6 +6849,7 @@ function convertAnthropicMessageMetadata(response) {
     usage: response.usage,
     stopSequence: (_a = response.stop_sequence) != null ? _a : null,
     ...stopDetails != null ? { stopDetails } : {},
+    ...response.input_transformations != null ? { inputTransformations: response.input_transformations } : {},
     iterations: response.usage.iterations ? response.usage.iterations.map(
       (iteration) => ({
         type: iteration.type,
@@ -7573,7 +7652,7 @@ var AnthropicSkills = class {
 };
 
 // src/version.ts
-var VERSION = true ? "4.0.51" : "0.0.0-test";
+var VERSION = true ? "4.0.53" : "0.0.0-test";
 
 // src/anthropic-provider.ts
 var ANTHROPIC_API_URL = "https://api.anthropic.com";