maka-agent 0.2.0-dev.3.20260830 → 0.2.0-dev.30.20260912

package/node_modules/@ai-sdk/anthropic/dist/index.js

@@ -4,7 +4,7 @@ import {
   NoSuchModelError
 } from "@ai-sdk/provider";
 import {
-  generateId as generateId2,
+  generateId as generateId3,
   loadApiKey,
   loadOptionalSetting,
   validateBaseURL,
@@ -71,7 +71,9 @@ var AnthropicFiles = class {
   async uploadFile({
     data,
     mediaType,
-    filename
+    filename,
+    abortSignal,
+    headers
   }) {
     var _a, _b;
     const fileBytes = convertInlineFileDataToUint8Array(data);
@@ -84,14 +86,17 @@ var AnthropicFiles = class {
     }
     const { value: response } = await postFormDataToApi({
       url: `${this.config.baseURL}/files`,
-      headers: combineHeaders(this.config.headers(), {
-        "anthropic-beta": "files-api-2025-04-14"
-      }),
+      headers: combineHeaders(
+        this.config.headers(),
+        { "anthropic-beta": "files-api-2025-04-14" },
+        headers
+      ),
       formData,
       failedResponseHandler: anthropicFailedResponseHandler,
       successfulResponseHandler: createJsonResponseHandler(
         anthropicUploadFileResponseSchema
       ),
+      abortSignal,
       fetch: this.config.fetch
     });
     return {
@@ -112,29 +117,31 @@ var AnthropicFiles = class {
   }
 };
 
-// src/anthropic-messages-batch.ts
+// src/anthropic-language-model.ts
 import {
-  EmptyResponseBodyError,
-  InvalidArgumentError,
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError3
+  APICallError,
+  InvalidResponseDataError
 } from "@ai-sdk/provider";
 import {
-  combineHeaders as combineHeaders3,
-  convertAsyncIteratorToReadableStream,
-  createJsonResponseHandler as createJsonResponseHandler3,
-  getFromApi,
-  lazySchema as lazySchema14,
-  normalizeHeaders,
-  parseJSON,
-  parseProviderOptions as parseProviderOptions3,
-  postJsonToApi as postJsonToApi2,
-  resolve as resolve2,
-  safeValidateTypes,
-  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2,
-  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2,
-  zodSchema as zodSchema14
+  combineHeaders as combineHeaders2,
+  createEventSourceResponseHandler,
+  createJsonResponseHandler as createJsonResponseHandler2,
+  createProviderStreamError,
+  createToolNameMapping,
+  generateId,
+  isCustomReasoning,
+  isProviderStreamError,
+  mapReasoningToProviderBudget,
+  mapReasoningToProviderEffort,
+  parseProviderOptions as parseProviderOptions2,
+  postJsonToApi,
+  resolve,
+  resolveProviderReference as resolveProviderReference2,
+  secureJsonParse as secureJsonParse2,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE
 } from "@ai-sdk/provider-utils";
-import { z as z15 } from "zod/v4";
 
 // src/anthropic-api.ts
 import {
@@ -161,6 +168,71 @@ var anthropicToolCallCallerSchema = z3.union([
     type: z3.literal("direct")
   })
 ]);
+var anthropicCitationSchema = z3.discriminatedUnion("type", [
+  z3.object({
+    type: z3.literal("web_search_result_location"),
+    cited_text: z3.string(),
+    url: z3.string(),
+    title: z3.string().nullable(),
+    encrypted_index: z3.string()
+  }),
+  z3.object({
+    type: z3.literal("page_location"),
+    cited_text: z3.string(),
+    document_index: z3.number(),
+    document_title: z3.string().nullable(),
+    start_page_number: z3.number(),
+    end_page_number: z3.number(),
+    file_id: z3.string().nullish()
+  }),
+  z3.object({
+    type: z3.literal("char_location"),
+    cited_text: z3.string(),
+    document_index: z3.number(),
+    document_title: z3.string().nullable(),
+    start_char_index: z3.number(),
+    end_char_index: z3.number(),
+    file_id: z3.string().nullish()
+  }),
+  z3.object({
+    type: z3.literal("content_block_location"),
+    cited_text: z3.string(),
+    document_index: z3.number(),
+    document_title: z3.string().nullable(),
+    start_block_index: z3.number(),
+    end_block_index: z3.number(),
+    file_id: z3.string().nullable()
+  }),
+  z3.object({
+    type: z3.literal("search_result_location"),
+    cited_text: z3.string(),
+    search_result_index: z3.number(),
+    source: z3.string(),
+    title: z3.string().nullable(),
+    start_block_index: z3.number(),
+    end_block_index: z3.number()
+  })
+]);
+var anthropicMcpToolResultContentSchema = z3.union([
+  z3.string(),
+  z3.array(
+    z3.union([
+      z3.string(),
+      z3.object({
+        type: z3.literal("text"),
+        text: z3.string(),
+        // MCP tool-result citations are opaque third-party pass-through data.
+        // Keep them permissive so new shapes do not reject whole responses.
+        citations: z3.array(z3.json()).nullable().optional()
+      })
+    ])
+  )
+]);
+var anthropicInputTransformationSchema = z3.object({
+  type: z3.string(),
+  path: z3.string(),
+  reason: z3.string()
+});
 var anthropicResponseSchema = lazySchema3(
   () => zodSchema3(
     z3.object({
@@ -172,33 +244,7 @@ var anthropicResponseSchema = lazySchema3(
           z3.object({
             type: z3.literal("text"),
             text: z3.string(),
-            citations: z3.array(
-              z3.discriminatedUnion("type", [
-                z3.object({
-                  type: z3.literal("web_search_result_location"),
-                  cited_text: z3.string(),
-                  url: z3.string(),
-                  title: z3.string(),
-                  encrypted_index: z3.string()
-                }),
-                z3.object({
-                  type: z3.literal("page_location"),
-                  cited_text: z3.string(),
-                  document_index: z3.number(),
-                  document_title: z3.string().nullable(),
-                  start_page_number: z3.number(),
-                  end_page_number: z3.number()
-                }),
-                z3.object({
-                  type: z3.literal("char_location"),
-                  cited_text: z3.string(),
-                  document_index: z3.number(),
-                  document_title: z3.string().nullable(),
-                  start_char_index: z3.number(),
-                  end_char_index: z3.number()
-                })
-              ])
-            ).optional()
+            citations: z3.array(anthropicCitationSchema).nullable().optional()
           }),
           z3.object({
             type: z3.literal("thinking"),
@@ -239,12 +285,7 @@ var anthropicResponseSchema = lazySchema3(
             type: z3.literal("mcp_tool_result"),
             tool_use_id: z3.string(),
             is_error: z3.boolean(),
-            content: z3.array(
-              z3.union([
-                z3.string(),
-                z3.object({ type: z3.literal("text"), text: z3.string() })
-              ])
-            )
+            content: anthropicMcpToolResultContentSchema
           }),
           z3.object({
             type: z3.literal("web_fetch_tool_result"),
@@ -254,7 +295,7 @@ var anthropicResponseSchema = lazySchema3(
               z3.object({
                 type: z3.literal("web_fetch_result"),
                 url: z3.string(),
-                retrieved_at: z3.string(),
+                retrieved_at: z3.string().nullable(),
                 content: z3.object({
                   type: z3.literal("document"),
                   title: z3.string().nullable(),
@@ -288,7 +329,7 @@ var anthropicResponseSchema = lazySchema3(
                 z3.object({
                   type: z3.literal("web_search_result"),
                   url: z3.string(),
-                  title: z3.string(),
+                  title: z3.string().nullable(),
                   encrypted_content: z3.string(),
                   page_age: z3.string().nullish()
                 })
@@ -410,6 +451,10 @@ var anthropicResponseSchema = lazySchema3(
               })
             ])
           }),
+          z3.object({
+            type: z3.literal("container_upload"),
+            file_id: z3.string()
+          }),
           // advisor results for advisor_20260301:
           z3.object({
             type: z3.literal("advisor_tool_result"),
@@ -442,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(),
@@ -526,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()
@@ -579,12 +626,7 @@ var anthropicChunkSchema = lazySchema3(
             type: z3.literal("mcp_tool_result"),
             tool_use_id: z3.string(),
             is_error: z3.boolean(),
-            content: z3.array(
-              z3.union([
-                z3.string(),
-                z3.object({ type: z3.literal("text"), text: z3.string() })
-              ])
-            )
+            content: anthropicMcpToolResultContentSchema
           }),
           z3.object({
             type: z3.literal("web_fetch_tool_result"),
@@ -594,7 +636,7 @@ var anthropicChunkSchema = lazySchema3(
               z3.object({
                 type: z3.literal("web_fetch_result"),
                 url: z3.string(),
-                retrieved_at: z3.string(),
+                retrieved_at: z3.string().nullable(),
                 content: z3.object({
                   type: z3.literal("document"),
                   title: z3.string().nullable(),
@@ -628,7 +670,7 @@ var anthropicChunkSchema = lazySchema3(
                 z3.object({
                   type: z3.literal("web_search_result"),
                   url: z3.string(),
-                  title: z3.string(),
+                  title: z3.string().nullable(),
                   encrypted_content: z3.string(),
                   page_age: z3.string().nullish()
                 })
@@ -804,31 +846,7 @@ var anthropicChunkSchema = lazySchema3(
           }),
           z3.object({
             type: z3.literal("citations_delta"),
-            citation: z3.discriminatedUnion("type", [
-              z3.object({
-                type: z3.literal("web_search_result_location"),
-                cited_text: z3.string(),
-                url: z3.string(),
-                title: z3.string(),
-                encrypted_index: z3.string()
-              }),
-              z3.object({
-                type: z3.literal("page_location"),
-                cited_text: z3.string(),
-                document_index: z3.number(),
-                document_title: z3.string().nullable(),
-                start_page_number: z3.number(),
-                end_page_number: z3.number()
-              }),
-              z3.object({
-                type: z3.literal("char_location"),
-                cited_text: z3.string(),
-                document_index: z3.number(),
-                document_title: z3.string().nullable(),
-                start_char_index: z3.number(),
-                end_char_index: z3.number()
-              })
-            ])
+            citation: anthropicCitationSchema
           })
         ])
       }),
@@ -840,7 +858,11 @@ var anthropicChunkSchema = lazySchema3(
         type: z3.literal("error"),
         error: z3.object({
           type: z3.string(),
-          message: z3.string()
+          message: z3.string(),
+          code: z3.union([z3.string(), z3.number()]).nullish(),
+          statusCode: z3.number().nullish(),
+          isRetryable: z3.boolean().nullish(),
+          data: z3.unknown().nullish()
         })
       }),
       z3.object({
@@ -888,6 +910,7 @@ var anthropicChunkSchema = lazySchema3(
             })
           ).nullish()
         }),
+        input_transformations: z3.array(anthropicInputTransformationSchema).nullish(),
         context_management: z3.object({
           applied_edits: z3.array(
             z3.union([
@@ -926,30 +949,6 @@ var anthropicReasoningMetadataSchema = lazySchema3(
   )
 );
 
-// src/anthropic-language-model.ts
-import {
-  APICallError,
-  InvalidResponseDataError
-} from "@ai-sdk/provider";
-import {
-  combineHeaders as combineHeaders2,
-  createEventSourceResponseHandler,
-  createJsonResponseHandler as createJsonResponseHandler2,
-  createToolNameMapping,
-  generateId,
-  isCustomReasoning,
-  mapReasoningToProviderBudget,
-  mapReasoningToProviderEffort,
-  parseProviderOptions as parseProviderOptions2,
-  postJsonToApi,
-  resolve,
-  resolveProviderReference as resolveProviderReference2,
-  secureJsonParse as secureJsonParse2,
-  serializeModelOptions,
-  WORKFLOW_SERIALIZE,
-  WORKFLOW_DESERIALIZE
-} from "@ai-sdk/provider-utils";
-
 // src/anthropic-language-model-options.ts
 import { z as z4 } from "zod/v4";
 var anthropicFilePartProviderOptions = z4.object({
@@ -981,6 +980,20 @@ var anthropicFilePartProviderOptions = z4.object({
   context: z4.string().optional()
 });
 var anthropicSystemMessageProviderOptions = z4.object({
+  /**
+   * Controls when an ephemeral mid-conversation system message is cleared.
+   *
+   * Only supported on system messages that appear mid-conversation.
+   * The required `mid-conversation-system-clear-at-2026-08-21` beta is
+   * added automatically.
+   */
+  clearAt: z4.literal("next_user_message").optional(),
+  /**
+   * Sets the model effort for the turn that follows this mid-conversation
+   * system message. The required `mid-conversation-effort-2026-08-01` beta
+   * is added automatically.
+   */
+  effort: z4.enum(["low", "medium", "high", "xhigh", "max"]).optional(),
   /**
    * Mid-conversation tool changes. Adds or removes tools from the
    * conversation's tool set between turns without invalidating the prompt
@@ -1029,24 +1042,40 @@ var anthropicLanguageModelOptions = z4.object({
    * When enabled, responses include thinking content blocks showing Claude's thinking process before the final answer.
    * Requires a minimum budget of 1,024 tokens and counts towards the `max_tokens` limit.
    */
-  thinking: z4.discriminatedUnion("type", [
-    z4.object({
-      /** for Sonnet 4.6, Opus 4.6, and newer models */
-      type: z4.literal("adaptive"),
-      /**
-       * Controls whether thinking content is included in the response.
-       * - `"omitted"`: Thinking blocks are present but text is empty (default for Opus 4.7+).
-       * - `"summarized"`: Thinking content is returned. Required to see reasoning output.
-       */
-      display: z4.enum(["omitted", "summarized"]).optional()
-    }),
-    z4.object({
-      /** for models before Opus 4.6, except Sonnet 4.6 still supports it */
-      type: z4.literal("enabled"),
-      budgetTokens: z4.number().optional()
-    }),
+  thinking: z4.union([
+    z4.discriminatedUnion("type", [
+      z4.object({
+        /** for Sonnet 4.6, Opus 4.6, and newer models */
+        type: z4.literal("adaptive"),
+        /**
+         * Controls whether thinking content is included in the response.
+         * - `"omitted"`: Thinking blocks are present but text is empty (default for Opus 4.7+).
+         * - `"summarized"`: Thinking content is returned.
+         * - `"updates"`: Thinking updates are returned between tool calls.
+         */
+        display: z4.enum(["omitted", "summarized", "updates"]).optional(),
+        /**
+         * Controls how thinking blocks are bound to an existing thinking
+         * prefix. Requires the `thinking-binding-controls-2026-08-01` beta.
+         */
+        blockBinding: z4.object({
+          prefixMismatchBehavior: z4.enum(["error", "drop_block"])
+        }).optional()
+      }),
+      z4.object({
+        /** for models before Opus 4.6, except Sonnet 4.6 still supports it */
+        type: z4.literal("enabled"),
+        budgetTokens: z4.number().optional()
+      }),
+      z4.object({
+        type: z4.literal("disabled")
+      })
+    ]),
     z4.object({
-      type: z4.literal("disabled")
+      type: z4.never().optional(),
+      blockBinding: z4.object({
+        prefixMismatchBehavior: z4.enum(["error", "drop_block"])
+      })
     })
   ]).optional(),
   /**
@@ -1144,6 +1173,8 @@ var anthropicLanguageModelOptions = z4.object({
    * Only supported with claude-opus-4-6.
    */
   speed: z4.enum(["fast", "standard"]).optional(),
+  /** Selects Anthropic's service tier for the request. */
+  serviceTier: z4.enum(["auto", "standard_only"]).optional(),
   /**
    * Controls where model inference runs for this request.
    *
@@ -2461,8 +2492,7 @@ async function convertToAnthropicPrompt({
     const type = block.type;
     switch (type) {
       case "system": {
-        const content = [];
-        let toolChangeCount = 0;
+        const convertedMessages = [];
         for (const { content: text, providerOptions } of block.messages) {
           const systemMessageOptions = await parseProviderOptions({
             provider: "anthropic",
@@ -2470,7 +2500,8 @@ async function convertToAnthropicPrompt({
             schema: anthropicSystemMessageProviderOptions
           });
           const toolChanges = (_a = systemMessageOptions == null ? void 0 : systemMessageOptions.toolChanges) != null ? _a : [];
-          if (text !== "" || toolChanges.length === 0) {
+          const content = [];
+          if (text !== "" || toolChanges.length === 0 && (systemMessageOptions == null ? void 0 : systemMessageOptions.clearAt) == null && (systemMessageOptions == null ? void 0 : systemMessageOptions.effort) == null) {
             content.push({
               type: "text",
               text,
@@ -2481,7 +2512,6 @@ async function convertToAnthropicPrompt({
             });
           }
           for (const toolChange of toolChanges) {
-            toolChangeCount++;
             content.push({
               type: toolChange.type,
               tool: {
@@ -2490,22 +2520,60 @@ async function convertToAnthropicPrompt({
               }
             });
           }
+          convertedMessages.push({
+            content,
+            clearAt: systemMessageOptions == null ? void 0 : systemMessageOptions.clearAt,
+            effort: systemMessageOptions == null ? void 0 : systemMessageOptions.effort,
+            toolChangeCount: toolChanges.length
+          });
         }
-        if (i === 0 || system == null && toolChangeCount === 0) {
+        const toolChangeCount = convertedMessages.reduce(
+          (count, message) => count + message.toolChangeCount,
+          0
+        );
+        const hasInlineSystemOptions = convertedMessages.some(
+          (message) => message.clearAt != null || message.effort != null
+        );
+        if (i === 0 || system == null && toolChangeCount === 0 && !hasInlineSystemOptions) {
           if (toolChangeCount > 0) {
             warnings.push({
               type: "other",
               message: "tool changes on the initial system message are not supported by Anthropic. Configure the initial tool set via the tools option instead. The tool changes have been ignored."
             });
           }
-          system = content.filter(
-            (part) => part.type === "text"
+          for (const message of convertedMessages) {
+            if (message.clearAt != null || message.effort != null) {
+              warnings.push({
+                type: "other",
+                message: "clearAt and effort on the initial system message are not supported by Anthropic. These options have been ignored."
+              });
+            }
+          }
+          system = convertedMessages.flatMap(
+            (message) => message.content.filter(
+              (part) => part.type === "text"
+            )
           );
         } else {
-          messages.push({ role: "system", content });
           betas.add("mid-conversation-system-2026-04-07");
-          if (toolChangeCount > 0) {
-            betas.add("mid-conversation-tool-changes-2026-07-01");
+          for (const message of convertedMessages) {
+            messages.push({
+              role: "system",
+              content: message.content,
+              ...message.clearAt != null && { clear_at: message.clearAt },
+              ...message.effort != null && {
+                output_config: { effort: message.effort }
+              }
+            });
+            if (message.toolChangeCount > 0) {
+              betas.add("mid-conversation-tool-changes-2026-07-01");
+            }
+            if (message.clearAt != null) {
+              betas.add("mid-conversation-system-clear-at-2026-08-21");
+            }
+            if (message.effort != null) {
+              betas.add("mid-conversation-effort-2026-08-01");
+            }
           }
         }
         break;
@@ -3611,15 +3679,50 @@ function formatConstraintValue(value) {
 }
 
 // src/anthropic-language-model.ts
-function createCitationSource(citation, citationDocuments, generateId3) {
-  var _a;
+function createAnthropicStreamError(error) {
+  var _a, _b, _c;
+  const inferredMetadata = getAnthropicStreamErrorMetadata(error.type);
+  return createProviderStreamError({
+    message: error.message,
+    type: error.type,
+    code: (_a = error.code) != null ? _a : void 0,
+    statusCode: (_b = error.statusCode) != null ? _b : inferredMetadata.statusCode,
+    isRetryable: (_c = error.isRetryable) != null ? _c : inferredMetadata.isRetryable,
+    data: "data" in error ? error.data : error
+  });
+}
+function getAnthropicStreamErrorMetadata(type) {
+  switch (type) {
+    case "api_error":
+      return { statusCode: 500, isRetryable: true };
+    case "overloaded_error":
+      return { statusCode: 529, isRetryable: true };
+    case "rate_limit_error":
+      return { statusCode: 429, isRetryable: true };
+    case "request_too_large":
+      return { statusCode: 413, isRetryable: false };
+    case "authentication_error":
+      return { statusCode: 401, isRetryable: false };
+    case "permission_error":
+      return { statusCode: 403, isRetryable: false };
+    case "not_found_error":
+      return { statusCode: 404, isRetryable: false };
+    case "billing_error":
+    case "invalid_request_error":
+      return { statusCode: 400, isRetryable: false };
+    default:
+      return {};
+  }
+}
+function createCitationSource(citation, citationDocuments, generateId4) {
+  var _a, _b;
   if (citation.type === "web_search_result_location") {
     return {
       type: "source",
       sourceType: "url",
-      id: generateId3(),
+      id: generateId4(),
       url: citation.url,
-      title: citation.title,
+      title: (_a = citation.title) != null ? _a : void 0,
       providerMetadata: {
         anthropic: {
           citedText: citation.cited_text,
@@ -3638,9 +3741,9 @@ function createCitationSource(citation, citationDocuments, generateId3) {
   return {
     type: "source",
     sourceType: "document",
-    id: generateId3(),
+    id: generateId4(),
     mediaType: documentInfo.mediaType,
-    title: (_a = citation.document_title) != null ? _a : documentInfo.title,
+    title: (_b = citation.document_title) != null ? _b : documentInfo.title,
     filename: documentInfo.filename,
     providerMetadata: {
       anthropic: citation.type === "page_location" ? {
@@ -3665,6 +3768,10 @@ function getAnthropicCallerMetadata(caller) {
   const callerInfo = getAnthropicCallerInfo(caller);
   return callerInfo == null ? {} : { providerMetadata: { anthropic: { caller: callerInfo } } };
 }
+function getProviderOptionsName(provider) {
+  const dotIndex = provider.indexOf(".");
+  return dotIndex === -1 ? provider : provider.substring(0, dotIndex);
+}
 var AnthropicLanguageModel = class _AnthropicLanguageModel {
   constructor(modelId, config) {
     this.specificationVersion = "v4";
@@ -3688,36 +3795,31 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
   get provider() {
     return this.config.provider;
   }
-  /**
-   * Extracts the dynamic provider name from the config.provider string.
-   * e.g., 'my-custom-anthropic.messages' -> 'my-custom-anthropic'
-   */
-  get providerOptionsName() {
-    const provider = this.config.provider;
-    const dotIndex = provider.indexOf(".");
-    return dotIndex === -1 ? provider : provider.substring(0, dotIndex);
-  }
   get supportedUrls() {
     var _a, _b, _c;
     return (_c = (_b = (_a = this.config).supportedUrls) == null ? void 0 : _b.call(_a)) != null ? _c : {};
   }
-  async getArgs({
-    userSuppliedBetas,
-    prompt,
-    maxOutputTokens,
-    temperature,
-    topP,
-    topK,
-    frequencyPenalty,
-    presencePenalty,
-    stopSequences,
-    responseFormat,
-    seed,
-    tools,
-    toolChoice,
-    reasoning,
-    providerOptions,
-    stream
+  static async prepareRequest({
+    modelId,
+    config,
+    options: {
+      userSuppliedBetas,
+      prompt,
+      maxOutputTokens,
+      temperature,
+      topP,
+      topK,
+      frequencyPenalty,
+      presencePenalty,
+      stopSequences,
+      responseFormat,
+      seed,
+      tools,
+      toolChoice,
+      reasoning,
+      providerOptions,
+      stream
+    }
   }) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
     const warnings = [];
@@ -3754,7 +3856,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
         });
       }
     }
-    const providerOptionsName = this.providerOptionsName;
+    const providerOptionsName = getProviderOptionsName(config.provider);
     const canonicalOptions = await parseProviderOptions2({
       provider: "anthropic",
       providerOptions,
@@ -3779,12 +3881,12 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
       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 max output tokens have been limited to ${maxOutputTokensForModel}. Set maxOutputTokens explicitly to override this limit.`
+        details: `The model "${modelId}" is unknown. The max output tokens have been limited to ${maxOutputTokensForModel}. Set maxOutputTokens explicitly to override this limit.`
       });
     }
     if (rejectsSamplingParameters) {
@@ -3792,7 +3894,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
         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 = void 0;
       }
@@ -3800,7 +3902,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
         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 = void 0;
       }
@@ -3808,14 +3910,14 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
         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 = void 0;
       }
     }
-    const isAnthropicModel = isKnownModel || this.modelId.includes("claude-");
-    const supportsStructuredOutput = ((_a = this.config.supportsNativeStructuredOutput) != null ? _a : true) && modelSupportsStructuredOutput;
-    const supportsStrictTools = ((_b = this.config.supportsStrictTools) != null ? _b : true) && modelSupportsStructuredOutput;
+    const isAnthropicModel = isKnownModel || modelId.includes("claude-");
+    const supportsStructuredOutput = ((_a = config.supportsNativeStructuredOutput) != null ? _a : true) && modelSupportsStructuredOutput;
+    const supportsStrictTools = ((_b = config.supportsStrictTools) != null ? _b : true) && modelSupportsStructuredOutput;
     const structureOutputMode = (_c = anthropicOptions == null ? void 0 : anthropicOptions.structuredOutputMode) != null ? _c : "auto";
     const useStructuredOutput = structureOutputMode === "outputFormat" || structureOutputMode === "auto" && supportsStructuredOutput;
     const jsonResponseTool = (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && !useStructuredOutput ? {
@@ -3885,19 +3987,20 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
       warnings.push({
         type: "unsupported",
         feature: "providerOptions.anthropic.effort",
-        details: `effort '${anthropicOptions.effort}' is not supported by ${this.modelId} when thinking is disabled. The effort has been lowered to 'high'.`
+        details: `effort '${anthropicOptions.effort}' is not supported by ${modelId} when thinking is disabled. The effort has been lowered to 'high'.`
       });
       anthropicOptions.effort = "high";
     }
     const thinkingType = (_g = anthropicOptions == null ? void 0 : anthropicOptions.thinking) == null ? void 0 : _g.type;
     const isThinking = thinkingType === "enabled" || thinkingType === "adaptive";
-    const sendThinking = isThinking || thinkingType === "disabled";
+    const thinkingBlockBinding = (anthropicOptions == null ? void 0 : anthropicOptions.thinking) != null && "blockBinding" in anthropicOptions.thinking ? anthropicOptions.thinking.blockBinding : void 0;
+    const sendThinking = isThinking || thinkingType === "disabled" || thinkingBlockBinding != null;
     let thinkingBudget = thinkingType === "enabled" ? (_h = anthropicOptions == null ? void 0 : anthropicOptions.thinking) == null ? void 0 : _h.budgetTokens : void 0;
     const thinkingDisplay = thinkingType === "adaptive" ? (_i = anthropicOptions == null ? void 0 : anthropicOptions.thinking) == null ? void 0 : _i.display : void 0;
     const maxTokens = maxOutputTokens != null ? maxOutputTokens : maxOutputTokensForModel;
     const baseArgs = {
       // model id:
-      model: this.modelId,
+      model: modelId,
       // standardized settings:
       max_tokens: maxTokens,
       temperature,
@@ -3907,9 +4010,14 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
       // provider specific settings:
       ...sendThinking && {
         thinking: {
-          type: thinkingType,
+          ...thinkingType != null && { type: thinkingType },
           ...thinkingBudget != null && { budget_tokens: thinkingBudget },
-          ...thinkingDisplay != null && { display: thinkingDisplay }
+          ...thinkingDisplay != null && { display: thinkingDisplay },
+          ...thinkingBlockBinding != null && {
+            block_binding: {
+              prefix_mismatch_behavior: thinkingBlockBinding.prefixMismatchBehavior
+            }
+          }
         }
       },
       ...((anthropicOptions == null ? void 0 : anthropicOptions.effort) || (anthropicOptions == null ? void 0 : anthropicOptions.taskBudget) || useStructuredOutput && (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null) && {
@@ -3937,6 +4045,9 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
       ...(anthropicOptions == null ? void 0 : anthropicOptions.speed) && {
         speed: anthropicOptions.speed
       },
+      ...(anthropicOptions == null ? void 0 : anthropicOptions.serviceTier) && {
+        service_tier: anthropicOptions.serviceTier
+      },
       ...(anthropicOptions == null ? void 0 : anthropicOptions.inferenceGeo) && {
         inference_geo: anthropicOptions.inferenceGeo
       },
@@ -4089,7 +4200,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
         warnings.push({
           type: "unsupported",
           feature: "maxOutputTokens",
-          details: `${baseArgs.max_tokens} (maxOutputTokens + thinkingBudget) is greater than ${this.modelId} ${maxOutputTokensForModel} max output tokens. The max output tokens have been limited to ${maxOutputTokensForModel}.`
+          details: `${baseArgs.max_tokens} (maxOutputTokens + thinkingBudget) is greater than ${modelId} ${maxOutputTokensForModel} max output tokens. The max output tokens have been limited to ${maxOutputTokensForModel}.`
         });
       }
       baseArgs.max_tokens = maxOutputTokensForModel;
@@ -4122,6 +4233,12 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
     if ((anthropicOptions == null ? void 0 : anthropicOptions.speed) === "fast") {
       betas.add("fast-mode-2026-02-01");
     }
+    if (thinkingDisplay === "updates") {
+      betas.add("thinking-display-updates-2026-08-18");
+    }
+    if (thinkingBlockBinding != null) {
+      betas.add("thinking-binding-controls-2026-08-01");
+    }
     if ((anthropicOptions == null ? void 0 : anthropicOptions.fallbacks) === "default") {
       betas.add("server-side-fallback-2026-07-01");
     } else if ((anthropicOptions == null ? void 0 : anthropicOptions.fallbacks) && anthropicOptions.fallbacks.length > 0) {
@@ -4174,6 +4291,13 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
       usedCustomProviderKey
     };
   }
+  getArgs(options) {
+    return _AnthropicLanguageModel.prepareRequest({
+      modelId: this.modelId,
+      config: this.config,
+      options
+    });
+  }
   async getHeaders({
     betas,
     headers
@@ -4324,6 +4448,14 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
           });
           break;
         }
+        case "container_upload": {
+          content.push({
+            type: "custom",
+            kind: "anthropic.container_upload",
+            providerMetadata: { anthropic: { fileId: part.file_id } }
+          });
+          break;
+        }
         case "compaction": {
           content.push({
             type: "text",
@@ -4490,7 +4622,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                 var _a2;
                 return {
                   url: result.url,
-                  title: result.title,
+                  ...result.title != null ? { title: result.title } : {},
                   pageAge: (_a2 = result.page_age) != null ? _a2 : null,
                   encryptedContent: result.encrypted_content,
                   type: result.type
@@ -4504,7 +4636,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                 sourceType: "url",
                 id: this.generateId(),
                 url: result.url,
-                title: result.title,
+                ...result.title != null ? { title: result.title } : {},
                 providerMetadata: {
                   anthropic: {
                     pageAge: (_c = result.page_age) != null ? _c : null
@@ -4698,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,
@@ -4737,7 +4870,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
   }
   async doStream(options) {
     "use step";
-    var _a, _b;
+    var _a, _b, _c, _d;
     const {
       args: body,
       warnings,
@@ -4785,20 +4918,21 @@ 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;
     let activeMessageId;
     let hasInvalidMessageSequence = false;
     let blockType = void 0;
-    const generateId3 = this.generateId;
+    const generateId4 = this.generateId;
     const transformedStream = response.pipeThrough(
       new TransformStream({
         start(controller) {
           controller.enqueue({ type: "stream-start", warnings });
         },
         transform(chunk, controller) {
-          var _a2, _b2, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+          var _a2, _b2, _c2, _d2, _e, _f, _g, _h, _i, _j, _k, _l, _m;
           if (hasInvalidMessageSequence) {
             return;
           }
@@ -5042,7 +5176,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                         var _a3;
                         return {
                           url: result.url,
-                          title: result.title,
+                          ...result.title != null ? { title: result.title } : {},
                           pageAge: (_a3 = result.page_age) != null ? _a3 : null,
                           encryptedContent: result.encrypted_content,
                           type: result.type
@@ -5054,9 +5188,9 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                       controller.enqueue({
                         type: "source",
                         sourceType: "url",
-                        id: generateId3(),
+                        id: generateId4(),
                         url: result.url,
-                        title: result.title,
+                        ...result.title != null ? { title: result.title } : {},
                         providerMetadata: {
                           anthropic: {
                             pageAge: (_b2 = result.page_age) != null ? _b2 : null
@@ -5091,7 +5225,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                         stdout: part.content.stdout,
                         stderr: part.content.stderr,
                         return_code: part.content.return_code,
-                        content: (_c = part.content.content) != null ? _c : []
+                        content: (_c2 = part.content.content) != null ? _c2 : []
                       }
                     });
                   } else if (part.content.type === "encrypted_code_execution_result") {
@@ -5104,7 +5238,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                         encrypted_stdout: part.content.encrypted_stdout,
                         stderr: part.content.stderr,
                         return_code: part.content.return_code,
-                        content: (_d = part.content.content) != null ? _d : []
+                        content: (_d2 = part.content.content) != null ? _d2 : []
                       }
                     });
                   } else if (part.content.type === "code_execution_tool_result_error") {
@@ -5416,7 +5550,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                   const source = createCitationSource(
                     citation,
                     citationDocuments,
-                    generateId3
+                    generateId4
                   );
                   if (source) {
                     controller.enqueue(source);
@@ -5454,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,
@@ -5553,6 +5690,9 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                   value.context_management
                 );
               }
+              if (value.input_transformations != null) {
+                inputTransformations = value.input_transformations;
+              }
               rawUsage = {
                 ...rawUsage,
                 ...value.usage
@@ -5566,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,
@@ -5598,7 +5739,10 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
               return;
             }
             case "error": {
-              controller.enqueue({ type: "error", error: value.error });
+              controller.enqueue({
+                type: "error",
+                error: createAnthropicStreamError(value.error)
+              });
               return;
             }
             default: {
@@ -5619,14 +5763,17 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
       }
       if (((_b = result.value) == null ? void 0 : _b.type) === "error") {
         const error = result.value.error;
+        if (!isProviderStreamError(error)) {
+          throw new Error("Expected a normalized Anthropic stream error");
+        }
         throw new APICallError({
           message: error.message,
           url,
           requestBodyValues: body,
-          statusCode: error.type === "overloaded_error" ? 529 : 500,
+          statusCode: (_c = error.statusCode) != null ? _c : 500,
           responseHeaders,
-          responseBody: JSON.stringify(error),
-          isRetryable: error.type === "overloaded_error"
+          responseBody: JSON.stringify(error.data),
+          isRetryable: (_d = error.isRetryable) != null ? _d : false
         });
       }
     } finally {
@@ -5692,7 +5839,7 @@ function getModelCapabilities(modelId) {
       rejectsThinkingDisabledAboveHighEffort: false,
       isKnownModel: true
     };
-  } else if (modelId.includes("claude-sonnet-4-")) {
+  } else if (/claude-sonnet-4(?:-|@)/.test(modelId)) {
     return {
       maxOutputTokens: 64e3,
       supportsStructuredOutput: false,
@@ -5702,7 +5849,7 @@ function getModelCapabilities(modelId) {
       rejectsThinkingDisabledAboveHighEffort: false,
       isKnownModel: true
     };
-  } else if (modelId.includes("claude-opus-4-")) {
+  } else if (/claude-opus-4(?:-|@)/.test(modelId)) {
     return {
       maxOutputTokens: 32e3,
       supportsStructuredOutput: false,
@@ -5765,7 +5912,7 @@ function hasWebTool20260209WithoutCodeExecution(tools) {
       hasWebTool20260209 = true;
       continue;
     }
-    if (tool.name === "code_execution") {
+    if ("type" in tool && (tool.type === "code_execution_20250522" || tool.type === "code_execution_20250825" || tool.type === "code_execution_20260120")) {
       hasCodeExecutionTool = true;
       break;
     }
@@ -5850,103 +5997,201 @@ function mapAnthropicStopDetails(stopDetails) {
   };
 }
 
-// src/anthropic-messages-batch.ts
+// src/anthropic-batch.ts
+import {
+  InvalidArgumentError,
+  InvalidResponseDataError as InvalidResponseDataError2,
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError3
+} from "@ai-sdk/provider";
+import {
+  combineHeaders as combineHeaders3,
+  convertAsyncIteratorToReadableStream,
+  createJsonLinesResponseHandler,
+  createJsonResponseHandler as createJsonResponseHandler3,
+  generateId as generateId2,
+  getFromApi,
+  isRecord as isRecord2,
+  lazySchema as lazySchema14,
+  normalizeBatchRequestCounts,
+  normalizeHeaders,
+  parseProviderOptions as parseProviderOptions3,
+  postJsonToApi as postJsonToApi2,
+  resolve as resolve2,
+  safeValidateTypes,
+  zodSchema as zodSchema14
+} from "@ai-sdk/provider-utils";
+import { z as z15 } from "zod/v4";
 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(),
-      results_url: z15.string().nullish()
+      data: z15.array(anthropicBatchResponseZodSchema()),
+      has_more: z15.boolean(),
+      last_id: z15.string().nullish()
     })
   )
 );
+var knownAnthropicBatchContentTypes = /* @__PURE__ */ new Set([
+  "advisor_tool_result",
+  "bash_code_execution_tool_result",
+  "code_execution_tool_result",
+  "compaction",
+  "container_upload",
+  "fallback",
+  "mcp_tool_result",
+  "mcp_tool_use",
+  "redacted_thinking",
+  "server_tool_use",
+  "text",
+  "text_editor_code_execution_tool_result",
+  "thinking",
+  "tool_search_tool_result",
+  "tool_use",
+  "web_fetch_tool_result",
+  "web_search_tool_result"
+]);
+var anthropicBatchResultSchema = lazySchema14(
+  () => zodSchema14(
+    z15.discriminatedUnion("type", [
+      z15.object({
+        type: z15.literal("succeeded"),
+        message: z15.unknown()
+      }),
+      z15.object({
+        type: z15.literal("errored"),
+        error: z15.object({
+          type: z15.literal("error"),
+          error: z15.object({
+            type: z15.string(),
+            message: z15.string()
+          }),
+          request_id: z15.string().nullish()
+        })
+      }),
+      z15.object({ type: z15.literal("canceled") }),
+      z15.object({ type: z15.literal("expired") })
+    ])
+  )
+);
 var anthropicBatchResultLineSchema = lazySchema14(
   () => zodSchema14(
     z15.object({
       custom_id: z15.string(),
-      result: z15.discriminatedUnion("type", [
-        z15.object({
-          type: z15.literal("succeeded"),
-          message: z15.unknown()
-        }),
-        z15.object({
-          type: z15.literal("errored"),
-          error: z15.object({
-            type: z15.literal("error"),
-            error: z15.object({
-              type: z15.string(),
-              message: z15.string()
-            }),
-            request_id: z15.string().nullish()
-          })
-        }),
-        z15.object({ type: z15.literal("canceled") }),
-        z15.object({ type: z15.literal("expired") })
-      ])
+      result: z15.unknown()
     })
   )
 );
-var AnthropicMessagesBatchLanguageModel = class _AnthropicMessagesBatchLanguageModel extends AnthropicLanguageModel {
-  static [WORKFLOW_SERIALIZE2](model) {
-    return AnthropicLanguageModel[WORKFLOW_SERIALIZE2](model);
-  }
-  static [WORKFLOW_DESERIALIZE2](options) {
-    return new _AnthropicMessagesBatchLanguageModel(
-      options.modelId,
-      options.config
-    );
+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}".`
+      });
+    }
   }
-  constructor(modelId, config) {
-    super(modelId, config);
+}
+var AnthropicBatch = class {
+  constructor(options) {
+    this.options = options;
+    this.specificationVersion = "v4";
+    var _a;
+    this.provider = options.provider;
+    this.supportedUrls = options.supportedUrls;
+    this.generateId = (_a = options.config.generateId) != null ? _a : generateId2;
   }
-  async experimental_doStartBatch({
+  async doStartBatch({
     requests,
     providerOptions,
     headers,
-    abortSignal
+    abortSignal,
+    webhookUrl
   }) {
+    var _a, _b, _c, _d;
+    assertTextBatchRequests(requests);
     validateRequestIds(requests);
     const explicitBatchBetas = new Set(
       await getAnthropicBatchProviderBetas({
-        provider: this.config.provider,
+        provider: this.options.config.provider,
         providerOptions
       })
     );
     const batchBetas = new Set(explicitBatchBetas);
     const preparedRequests = [];
-    const batchWarnings = [];
+    const batchWarnings = webhookUrl == null ? [] : [
+      {
+        warning: {
+          type: "unsupported",
+          feature: "webhookUrl",
+          details: "The Anthropic Message Batches API does not support completion webhooks."
+        }
+      }
+    ];
     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) {
         throw new UnsupportedFunctionalityError3({
           functionality: "per-request providerOptions.anthropic.anthropicBeta",
-          message: `Anthropic Message Batches do not support per-request betas (request "${request.id}"). Set providerOptions.anthropic.anthropicBeta on startTextBatch instead.`
+          message: `Anthropic Message Batches do not support per-request betas (request "${request.id}"). Set providerOptions.anthropic.anthropicBeta 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)
+        }
       });
-      const body = this.transformRequestBody(prepared.args, prepared.betas);
+      if (prepared.usesJsonResponseTool) {
+        throw new UnsupportedFunctionalityError3({
+          functionality: "batch responseFormat JSON-tool fallback",
+          message: `Anthropic Message Batches cannot decode the JSON-tool structured-output fallback (request "${request.id}") because batch results are retrieved independently of the start call. Use a model that supports native output_format structured outputs.`
+        });
+      }
+      const aliasedProviderTool = (_a = request.options.tools) == null ? void 0 : _a.find(
+        (tool) => tool.type === "provider" && prepared.toolNameMapping.toProviderToolName(tool.name) !== tool.name
+      );
+      if (aliasedProviderTool != null) {
+        throw new UnsupportedFunctionalityError3({
+          functionality: "aliased provider tool names in batches",
+          message: `Anthropic Message Batches cannot restore the custom provider-tool name "${aliasedProviderTool.name}" when results are retrieved independently of the start call (request "${request.id}"). Use the provider's canonical tool name.`
+        });
+      }
+      const body = (_d = (_c = (_b = this.options.config).transformRequestBody) == null ? void 0 : _c.call(
+        _b,
+        prepared.args,
+        prepared.betas
+      )) != null ? _d : prepared.args;
       validateAnthropicBatchBody({
         body,
         requestId: request.id
@@ -5968,7 +6213,7 @@ var AnthropicMessagesBatchLanguageModel = class _AnthropicMessagesBatchLanguageM
         anthropicBatchResponseSchema
       ),
       abortSignal,
-      fetch: this.config.fetch
+      fetch: this.options.config.fetch
     });
     return {
       batchId: batch.id,
@@ -5976,10 +6221,51 @@ var AnthropicMessagesBatchLanguageModel = class _AnthropicMessagesBatchLanguageM
       warnings: batchWarnings
     };
   }
-  async experimental_doGetBatchStatus(options) {
+  async doGetBatchStatus(options) {
     return convertAnthropicBatchStatus(await this.retrieveBatch(options));
   }
-  async experimental_doGetBatchResults(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") {
       throw new InvalidArgumentError({
@@ -5994,24 +6280,26 @@ var AnthropicMessagesBatchLanguageModel = class _AnthropicMessagesBatchLanguageM
       });
     }
     if (batch.results_url == null) {
-      throw new InvalidArgumentError({
-        argument: "batchId",
-        message: `Anthropic batch "${options.batchId}" does not have a results URL.`
+      throw new InvalidResponseDataError2({
+        data: batch,
+        message: `Anthropic batch "${options.batchId}" completed without batch output.`
       });
     }
-    const { value: stream } = await getFromApi({
+    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: rawStreamResponseHandler,
+      successfulResponseHandler: createJsonLinesResponseHandler(
+        anthropicBatchResultLineSchema
+      ),
       abortSignal: options.abortSignal,
-      fetch: this.config.fetch
+      fetch: this.options.config.fetch
     });
     return convertAsyncIteratorToReadableStream(
-      this.iterateBatchResults(stream)
+      this.iterateBatchResults(lines)
     );
   }
   async retrieveBatch(options) {
@@ -6024,17 +6312,17 @@ var AnthropicMessagesBatchLanguageModel = class _AnthropicMessagesBatchLanguageM
         anthropicBatchResponseSchema
       ),
       abortSignal: options.abortSignal,
-      fetch: this.config.fetch
+      fetch: this.options.config.fetch
     });
     return batch;
   }
-  async *iterateBatchResults(stream) {
-    for await (const line of parseJsonLines(stream)) {
-      yield await convertAnthropicBatchResult(line);
+  async *iterateBatchResults(lines) {
+    for await (const line of lines) {
+      yield await convertAnthropicBatchResult(line, this.generateId);
     }
   }
   getBatchUrl(path) {
-    return `${this.config.baseURL}/messages/batches${path}`;
+    return `${this.options.config.baseURL}/messages/batches${path}`;
   }
   async getStartBatchHeaders({
     betas,
@@ -6049,7 +6337,7 @@ var AnthropicMessagesBatchLanguageModel = class _AnthropicMessagesBatchLanguageM
   }
   async getBatchHeaders(headers) {
     return combineHeaders3(
-      this.config.headers ? await resolve2(this.config.headers) : void 0,
+      this.options.config.headers ? await resolve2(this.options.config.headers) : void 0,
       headers
     );
   }
@@ -6115,13 +6403,23 @@ function validateAnthropicBatchBody({
   }
 }
 function convertAnthropicBatchStatus(batch) {
+  var _a, _b, _c, _d;
   const requestCounts = convertAnthropicRequestCounts(batch.request_counts);
   return {
     status: mapAnthropicBatchStatus(batch.processing_status),
     rawStatus: batch.processing_status,
     ...requestCounts != null ? { requestCounts } : {},
     createdAt: batch.created_at,
-    expiresAt: batch.expires_at
+    expiresAt: batch.expires_at,
+    providerMetadata: {
+      anthropic: {
+        archivedAt: (_a = batch.archived_at) != null ? _a : null,
+        cancelInitiatedAt: (_b = batch.cancel_initiated_at) != null ? _b : null,
+        endedAt: (_c = batch.ended_at) != null ? _c : null,
+        requestCounts: batch.request_counts,
+        resultsUrl: (_d = batch.results_url) != null ? _d : null
+      }
+    }
   };
 }
 function mapAnthropicBatchStatus(rawStatus) {
@@ -6135,37 +6433,36 @@ function mapAnthropicBatchStatus(rawStatus) {
   }
 }
 function convertAnthropicRequestCounts(counts) {
-  const values = [
-    counts.processing,
-    counts.succeeded,
-    counts.errored,
-    counts.canceled,
-    counts.expired
-  ];
-  if (values.some((value) => !Number.isFinite(value) || value < 0)) {
-    return void 0;
-  }
-  return {
-    total: values.reduce((total, value) => total + value, 0),
+  return normalizeBatchRequestCounts({
+    total: counts.processing + counts.succeeded + counts.errored + counts.canceled + counts.expired,
     pending: counts.processing,
     completed: counts.succeeded,
     failed: counts.errored + counts.canceled + counts.expired
-  };
+  });
 }
-async function convertAnthropicBatchResult(line) {
-  switch (line.result.type) {
+async function convertAnthropicBatchResult(line, generateId4) {
+  const resultValidation = await safeValidateTypes({
+    value: line.result,
+    schema: anthropicBatchResultSchema
+  });
+  if (!resultValidation.success) {
+    return invalidAnthropicBatchResult(line.custom_id);
+  }
+  const result = resultValidation.value;
+  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 = line.result.error.request_id;
+      const requestId = result.error.request_id;
       return {
+        type: "text",
         id: line.custom_id,
         status: "failed",
         error: {
-          message: line.result.error.error.message,
-          type: line.result.error.error.type
+          message: result.error.error.message,
+          type: result.error.error.type
         },
         ...requestId != null ? {
           providerMetadata: {
@@ -6175,58 +6472,86 @@ async function convertAnthropicBatchResult(line) {
       };
     }
     case "succeeded": {
-      const validation = await safeValidateTypes({
-        value: line.result.message,
-        schema: anthropicResponseSchema
-      });
-      if (!validation.success) {
-        return {
-          id: line.custom_id,
-          status: "failed",
-          error: {
-            message: "Anthropic returned an invalid Message batch result.",
-            code: "invalid_response"
-          }
-        };
-      }
-      const response = validation.value;
-      const unsupportedPart = response.content.find(
-        (part) => !supportedBatchContentTypes.has(part.type)
-      );
-      if (unsupportedPart != null) {
-        return {
-          id: line.custom_id,
-          status: "failed",
-          error: {
-            message: `Anthropic returned a "${unsupportedPart.type}" content block, but tool content is not supported in AI SDK text batches.`,
-            code: "unsupported_tool_content"
-          }
-        };
+      const response = await parseAnthropicBatchResponse(result.message);
+      if (response == null) {
+        return invalidAnthropicBatchResult(line.custom_id);
       }
       return {
+        type: "text",
         id: line.custom_id,
         status: "succeeded",
-        result: convertAnthropicBatchResponse(response)
+        result: convertAnthropicBatchResponse(response, generateId4)
       };
     }
   }
 }
-var supportedBatchContentTypes = /* @__PURE__ */ new Set([
-  "text",
-  "thinking",
-  "redacted_thinking",
-  "compaction",
-  // The normal Anthropic response conversion intentionally drops this marker;
-  // the fallback hop remains available through usage.iterations metadata.
-  "fallback"
-]);
-function convertAnthropicBatchResponse(response) {
-  var _a, _b, _c;
+function invalidAnthropicBatchResult(id) {
+  return {
+    type: "text",
+    id,
+    status: "failed",
+    error: {
+      message: "Anthropic returned an invalid Message batch result.",
+      code: "invalid_response"
+    }
+  };
+}
+async function parseAnthropicBatchResponse(message) {
+  const validation = await safeValidateTypes({
+    value: message,
+    schema: anthropicResponseSchema
+  });
+  if (validation.success) {
+    return validation.value;
+  }
+  if (!isRecord2(message) || !Array.isArray(message.content)) {
+    return void 0;
+  }
+  const content = [];
+  for (const part of message.content) {
+    const partValidation = await safeValidateTypes({
+      value: { ...message, content: [part] },
+      schema: anthropicResponseSchema
+    });
+    if (partValidation.success) {
+      const [validatedPart] = partValidation.value.content;
+      if (validatedPart != null) {
+        content.push(validatedPart);
+      }
+    } else if (!isRecord2(part) || typeof part.type !== "string" || knownAnthropicBatchContentTypes.has(part.type)) {
+      return void 0;
+    }
+  }
+  const recovered = await safeValidateTypes({
+    value: { ...message, content },
+    schema: anthropicResponseSchema
+  });
+  return recovered.success ? recovered.value : void 0;
+}
+function convertAnthropicBatchResponse(response, generateId4) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
   const content = [];
+  const mcpToolCalls = {};
+  const serverToolCalls = {};
   for (const part of response.content) {
     switch (part.type) {
       case "text":
-        content.push({ type: "text", text: part.text });
+        const citations = part.citations;
+        content.push({
+          type: "text",
+          text: part.text,
+          ...citations != null && citations.length > 0 && {
+            providerMetadata: {
+              anthropic: { citations }
+            }
+          }
+        });
+        for (const citation of (_a = part.citations) != null ? _a : []) {
+          const source = createCitationSource(citation, [], generateId4);
+          if (source != null) {
+            content.push(source);
+          }
+        }
         break;
       case "thinking":
         content.push({
@@ -6250,6 +6575,13 @@ function convertAnthropicBatchResponse(response) {
           }
         });
         break;
+      case "container_upload":
+        content.push({
+          type: "custom",
+          kind: "anthropic.container_upload",
+          providerMetadata: { anthropic: { fileId: part.file_id } }
+        });
+        break;
       case "compaction":
         content.push({
           type: "text",
@@ -6257,6 +6589,226 @@ function convertAnthropicBatchResponse(response) {
           providerMetadata: { anthropic: { type: "compaction" } }
         });
         break;
+      case "tool_use":
+        content.push({
+          type: "tool-call",
+          toolCallId: part.id,
+          toolName: part.name,
+          input: JSON.stringify(part.input),
+          ...anthropicCallerMetadata(part.caller)
+        });
+        break;
+      case "server_tool_use": {
+        const isCodeExecutionAlias = part.name === "bash_code_execution" || part.name === "text_editor_code_execution";
+        const isCodeExecution = isCodeExecutionAlias || part.name === "code_execution";
+        const toolName = isCodeExecutionAlias ? "code_execution" : part.name;
+        if (part.name === "tool_search_tool_bm25" || part.name === "tool_search_tool_regex") {
+          serverToolCalls[part.id] = part.name;
+        }
+        content.push({
+          type: "tool-call",
+          toolCallId: part.id,
+          toolName,
+          input: JSON.stringify(
+            isCodeExecutionAlias ? { type: part.name, ...(_b = part.input) != null ? _b : {} } : part.name === "code_execution" && part.input != null && "code" in part.input && !("type" in part.input) ? { type: "programmatic-tool-call", ...part.input } : part.input
+          ),
+          providerExecuted: true,
+          // Batch results are retrieved without the original request tools, so
+          // implicitly provisioned code execution must remain self-describing.
+          ...isCodeExecution ? { dynamic: true } : {},
+          ...anthropicCallerMetadata(part.caller)
+        });
+        break;
+      }
+      case "mcp_tool_use": {
+        const toolCall = {
+          type: "tool-call",
+          toolCallId: part.id,
+          toolName: part.name,
+          input: JSON.stringify(part.input),
+          providerExecuted: true,
+          dynamic: true,
+          providerMetadata: {
+            anthropic: {
+              serverName: part.server_name,
+              type: "mcp-tool-use"
+            }
+          }
+        };
+        mcpToolCalls[part.id] = toolCall;
+        content.push(toolCall);
+        break;
+      }
+      case "mcp_tool_result": {
+        const toolCall = mcpToolCalls[part.tool_use_id];
+        content.push({
+          type: "tool-result",
+          toolCallId: part.tool_use_id,
+          toolName: (_c = toolCall == null ? void 0 : toolCall.toolName) != null ? _c : "mcp",
+          isError: part.is_error,
+          result: part.content,
+          dynamic: true,
+          ...(toolCall == null ? void 0 : toolCall.providerMetadata) != null && {
+            providerMetadata: toolCall.providerMetadata
+          }
+        });
+        break;
+      }
+      case "web_fetch_tool_result":
+        content.push({
+          type: "tool-result",
+          toolCallId: part.tool_use_id,
+          toolName: "web_fetch",
+          ...part.content.type === "web_fetch_tool_result_error" ? {
+            isError: true,
+            result: {
+              errorCode: part.content.error_code,
+              type: part.content.type
+            }
+          } : {
+            result: {
+              content: {
+                citations: part.content.content.citations,
+                source: {
+                  data: part.content.content.source.data,
+                  mediaType: part.content.content.source.media_type,
+                  type: part.content.content.source.type
+                },
+                title: part.content.content.title,
+                type: part.content.content.type
+              },
+              retrievedAt: part.content.retrieved_at,
+              type: part.content.type,
+              url: part.content.url
+            }
+          },
+          ...anthropicCallerMetadata(part.caller)
+        });
+        break;
+      case "web_search_tool_result":
+        content.push({
+          type: "tool-result",
+          toolCallId: part.tool_use_id,
+          toolName: "web_search",
+          ...Array.isArray(part.content) ? {
+            result: part.content.map((result) => {
+              var _a2;
+              return {
+                encryptedContent: result.encrypted_content,
+                pageAge: (_a2 = result.page_age) != null ? _a2 : null,
+                ...result.title != null ? { title: result.title } : {},
+                type: result.type,
+                url: result.url
+              };
+            })
+          } : {
+            isError: true,
+            result: {
+              errorCode: part.content.error_code,
+              type: part.content.type
+            }
+          },
+          ...anthropicCallerMetadata(part.caller)
+        });
+        if (Array.isArray(part.content)) {
+          for (const result of part.content) {
+            content.push({
+              type: "source",
+              sourceType: "url",
+              id: generateId4(),
+              url: result.url,
+              ...result.title != null ? { title: result.title } : {},
+              providerMetadata: {
+                anthropic: {
+                  pageAge: (_d = result.page_age) != null ? _d : null
+                }
+              }
+            });
+          }
+        }
+        break;
+      case "code_execution_tool_result":
+        content.push({
+          type: "tool-result",
+          toolCallId: part.tool_use_id,
+          toolName: "code_execution",
+          ...part.content.type === "code_execution_tool_result_error" ? {
+            isError: true,
+            result: {
+              errorCode: part.content.error_code,
+              type: part.content.type
+            }
+          } : { result: part.content }
+        });
+        break;
+      case "bash_code_execution_tool_result":
+      case "text_editor_code_execution_tool_result":
+        content.push({
+          type: "tool-result",
+          toolCallId: part.tool_use_id,
+          toolName: "code_execution",
+          result: part.content
+        });
+        break;
+      case "tool_search_tool_result": {
+        const toolName = (_e = serverToolCalls[part.tool_use_id]) != null ? _e : "tool_search_tool_regex";
+        content.push({
+          type: "tool-result",
+          toolCallId: part.tool_use_id,
+          toolName,
+          ...part.content.type === "tool_search_tool_result_error" ? {
+            isError: true,
+            result: {
+              errorCode: part.content.error_code,
+              type: part.content.type
+            }
+          } : {
+            result: part.content.tool_references.map((reference) => ({
+              toolName: reference.tool_name,
+              type: reference.type
+            }))
+          }
+        });
+        break;
+      }
+      case "advisor_tool_result":
+        if (part.content.type === "advisor_result") {
+          content.push({
+            type: "tool-result",
+            toolCallId: part.tool_use_id,
+            toolName: "advisor",
+            result: {
+              type: part.content.type,
+              text: part.content.text,
+              ...part.content.stop_reason != null ? { stopReason: part.content.stop_reason } : {}
+            }
+          });
+        } else if (part.content.type === "advisor_redacted_result") {
+          content.push({
+            type: "tool-result",
+            toolCallId: part.tool_use_id,
+            toolName: "advisor",
+            result: {
+              type: part.content.type,
+              encryptedContent: part.content.encrypted_content,
+              ...part.content.stop_reason != null ? { stopReason: part.content.stop_reason } : {}
+            }
+          });
+        } else {
+          content.push({
+            type: "tool-result",
+            toolCallId: part.tool_use_id,
+            toolName: "advisor",
+            isError: true,
+            result: {
+              errorCode: part.content.error_code,
+              type: part.content.type
+            }
+          });
+        }
+        break;
+      case "fallback":
+        break;
     }
   }
   return {
@@ -6265,12 +6817,12 @@ function convertAnthropicBatchResponse(response) {
       unified: mapAnthropicStopReason({
         finishReason: response.stop_reason
       }),
-      raw: (_a = response.stop_reason) != null ? _a : void 0
+      raw: (_f = response.stop_reason) != null ? _f : void 0
     },
     usage: convertAnthropicUsage({ usage: response.usage }),
     response: {
-      id: (_b = response.id) != null ? _b : void 0,
-      modelId: (_c = response.model) != null ? _c : void 0
+      id: (_g = response.id) != null ? _g : void 0,
+      modelId: (_h = response.model) != null ? _h : void 0
     },
     warnings: [],
     providerMetadata: {
@@ -6278,6 +6830,18 @@ function convertAnthropicBatchResponse(response) {
     }
   };
 }
+function anthropicCallerMetadata(caller) {
+  return caller == null ? {} : {
+    providerMetadata: {
+      anthropic: {
+        caller: {
+          type: caller.type,
+          toolId: caller.tool_id
+        }
+      }
+    }
+  };
+}
 function convertAnthropicMessageMetadata(response) {
   var _a, _b, _c;
   const stopDetails = mapAnthropicStopDetails2(response.stop_details);
@@ -6285,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,
@@ -6344,54 +6909,6 @@ function mapAnthropicStopDetails2(stopDetails) {
     ...stopDetails.recommended_model != null ? { recommendedModel: stopDetails.recommended_model } : {}
   };
 }
-var rawStreamResponseHandler = async ({ response }) => {
-  if (response.body == null) {
-    throw new EmptyResponseBodyError();
-  }
-  return { value: response.body };
-};
-async function* parseJsonLines(stream) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let finished = false;
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) {
-        finished = true;
-        buffer += decoder.decode();
-        break;
-      }
-      buffer += decoder.decode(value, { stream: true });
-      let lineEnd = buffer.indexOf("\n");
-      while (lineEnd !== -1) {
-        const line = buffer.slice(0, lineEnd).replace(/\r$/, "");
-        buffer = buffer.slice(lineEnd + 1);
-        if (line.trim().length > 0) {
-          yield await parseJSON({
-            text: line,
-            schema: anthropicBatchResultLineSchema
-          });
-        }
-        lineEnd = buffer.indexOf("\n");
-      }
-    }
-    const finalLine = buffer.replace(/\r$/, "");
-    if (finalLine.trim().length > 0) {
-      yield await parseJSON({
-        text: finalLine,
-        schema: anthropicBatchResultLineSchema
-      });
-    }
-  } finally {
-    if (!finished) {
-      await reader.cancel().catch(() => {
-      });
-    }
-    reader.releaseLock();
-  }
-}
 
 // src/tool/bash_20241022.ts
 import {
@@ -7050,6 +7567,10 @@ var anthropicSkillVersionResponseSchema = lazySchema25(
 );
 
 // src/skills/anthropic-skills.ts
+function encodePathSegment(value) {
+  const encodedValue = encodeURIComponent(value);
+  return encodedValue === "." ? "%252E" : encodedValue === ".." ? "%252E%252E" : encodedValue;
+}
 var AnthropicSkills = class {
   constructor(config) {
     this.config = config;
@@ -7069,7 +7590,7 @@ var AnthropicSkills = class {
     headers
   }) {
     const { value: versionResponse } = await getFromApi2({
-      url: `${this.config.baseURL}/skills/${skillId}/versions/${version}`,
+      url: `${this.config.baseURL}/skills/${encodePathSegment(skillId)}/versions/${encodePathSegment(version)}`,
       validateUrl: false,
       headers,
       failedResponseHandler: anthropicFailedResponseHandler,
@@ -7131,7 +7652,7 @@ var AnthropicSkills = class {
 };
 
 // src/version.ts
-var VERSION = true ? "4.0.40" : "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";
@@ -7143,7 +7664,7 @@ function normalizeBaseURL(baseURL) {
   return baseURLWithoutTrailingSlash === ANTHROPIC_API_URL ? ANTHROPIC_API_VERSIONED_URL : baseURLWithoutTrailingSlash;
 }
 function createAnthropic(options = {}) {
-  var _a, _b;
+  var _a, _b, _c;
   const baseURL = (_a = normalizeBaseURL(
     loadOptionalSetting({
       settingValue: options.baseURL,
@@ -7151,6 +7672,10 @@ function createAnthropic(options = {}) {
     })
   )) != null ? _a : ANTHROPIC_API_VERSIONED_URL;
   const providerName = (_b = options.name) != null ? _b : "anthropic.messages";
+  const supportedUrls = {
+    "image/*": [/^https?:\/\/.*$/],
+    "application/pdf": [/^https?:\/\/.*$/]
+  };
   if (options.apiKey && options.authToken) {
     throw new InvalidArgumentError2({
       argument: "apiKey/authToken",
@@ -7174,20 +7699,20 @@ function createAnthropic(options = {}) {
       `ai-sdk/anthropic/${VERSION}`
     );
   };
-  const createChatModel = (modelId) => {
-    var _a2;
-    return new AnthropicMessagesBatchLanguageModel(modelId, {
-      provider: providerName,
-      baseURL,
-      headers: getHeaders,
-      fetch: options.fetch,
-      generateId: (_a2 = options.generateId) != null ? _a2 : generateId2,
-      supportedUrls: () => ({
-        "image/*": [/^https?:\/\/.*$/],
-        "application/pdf": [/^https?:\/\/.*$/]
-      })
-    });
+  const languageModelConfig = {
+    provider: providerName,
+    baseURL,
+    headers: getHeaders,
+    fetch: options.fetch,
+    generateId: (_c = options.generateId) != null ? _c : generateId3,
+    supportedUrls: () => supportedUrls
   };
+  const createChatModel = (modelId) => new AnthropicLanguageModel(modelId, languageModelConfig);
+  const createBatch = () => new AnthropicBatch({
+    provider: `${providerName.replace(/\.messages$/, "")}.batch`,
+    config: languageModelConfig,
+    supportedUrls
+  });
   const createSkills = () => new AnthropicSkills({
     provider: `${providerName.replace(".messages", "")}.skills`,
     baseURL,
@@ -7206,6 +7731,7 @@ function createAnthropic(options = {}) {
   provider.languageModel = createChatModel;
   provider.chat = createChatModel;
   provider.messages = createChatModel;
+  provider.experimental_batch = createBatch;
   provider.embeddingModel = (modelId) => {
     throw new NoSuchModelError({ modelId, modelType: "embeddingModel" });
   };