@ai-sdk/anthropic 4.0.32 → 4.0.34

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/anthropic-provider.ts
 import {
-  InvalidArgumentError,
+  InvalidArgumentError as InvalidArgumentError2,
   NoSuchModelError
 } from "@ai-sdk/provider";
 import {
@@ -112,29 +112,29 @@ var AnthropicFiles = class {
   }
 };
 
-// src/anthropic-language-model.ts
+// src/anthropic-messages-batch.ts
 import {
-  APICallError,
-  InvalidResponseDataError
+  EmptyResponseBodyError,
+  InvalidArgumentError,
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError3
 } 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
+  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
 } from "@ai-sdk/provider-utils";
+import { z as z15 } from "zod/v4";
 
 // src/anthropic-api.ts
 import {
@@ -961,6 +961,30 @@ 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({
@@ -5837,18 +5861,561 @@ function mapAnthropicStopDetails(stopDetails) {
   };
 }
 
+// src/anthropic-messages-batch.ts
+var anthropicBatchRequestIdPattern = /^[A-Za-z0-9_-]{1,64}$/;
+var anthropicBatchProviderOptionsSchema = anthropicLanguageModelOptions.pick({
+  anthropicBeta: true
+});
+var anthropicBatchResponseSchema = 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()
+    })
+  )
+);
+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") })
+      ])
+    })
+  )
+);
+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
+    );
+  }
+  constructor(modelId, config) {
+    super(modelId, config);
+  }
+  async experimental_doStartBatch({
+    requests,
+    providerOptions,
+    headers,
+    abortSignal
+  }) {
+    validateRequestIds(requests);
+    const explicitBatchBetas = new Set(
+      await getAnthropicBatchProviderBetas({
+        provider: this.config.provider,
+        providerOptions
+      })
+    );
+    const batchBetas = new Set(explicitBatchBetas);
+    const preparedRequests = [];
+    const batchWarnings = [];
+    for (const request of requests) {
+      const requestBetas = await getAnthropicBatchProviderBetas({
+        provider: this.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.`
+        });
+      }
+      const prepared = await this.getArgs({
+        ...request.options,
+        stream: false,
+        userSuppliedBetas: new Set(explicitBatchBetas)
+      });
+      const body = this.transformRequestBody(prepared.args, prepared.betas);
+      validateAnthropicBatchBody({
+        body,
+        requestId: request.id
+      });
+      preparedRequests.push({ custom_id: request.id, params: body });
+      for (const beta of prepared.betas) {
+        batchBetas.add(beta);
+      }
+      for (const warning of prepared.warnings) {
+        batchWarnings.push({ requestId: request.id, warning });
+      }
+    }
+    const { value: batch } = await postJsonToApi2({
+      url: this.getBatchUrl(""),
+      headers: await this.getStartBatchHeaders({ betas: batchBetas, headers }),
+      body: { requests: preparedRequests },
+      failedResponseHandler: anthropicFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler3(
+        anthropicBatchResponseSchema
+      ),
+      abortSignal,
+      fetch: this.config.fetch
+    });
+    return {
+      batchId: batch.id,
+      ...convertAnthropicBatchStatus(batch),
+      warnings: batchWarnings
+    };
+  }
+  async experimental_doGetBatchStatus(options) {
+    return convertAnthropicBatchStatus(await this.retrieveBatch(options));
+  }
+  async experimental_doGetBatchResults(options) {
+    const batch = await this.retrieveBatch(options);
+    if (convertAnthropicBatchStatus(batch).status === "pending") {
+      throw new InvalidArgumentError({
+        argument: "batchId",
+        message: `Anthropic batch "${options.batchId}" is not complete.`
+      });
+    }
+    if (batch.archived_at != null) {
+      throw new InvalidArgumentError({
+        argument: "batchId",
+        message: `Anthropic batch "${options.batchId}" results are no longer available.`
+      });
+    }
+    if (batch.results_url == null) {
+      throw new InvalidArgumentError({
+        argument: "batchId",
+        message: `Anthropic batch "${options.batchId}" does not have a results URL.`
+      });
+    }
+    const { value: stream } = await getFromApi({
+      url: batch.results_url,
+      validateUrl: true,
+      credentialedOrigin: this.config.baseURL,
+      trustedOrigin: this.config.baseURL,
+      headers: await this.getBatchHeaders(options.headers),
+      failedResponseHandler: anthropicFailedResponseHandler,
+      successfulResponseHandler: rawStreamResponseHandler,
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    return convertAsyncIteratorToReadableStream(
+      this.iterateBatchResults(stream)
+    );
+  }
+  async retrieveBatch(options) {
+    const { value: batch } = await getFromApi({
+      url: this.getBatchUrl(`/${encodeURIComponent(options.batchId)}`),
+      validateUrl: false,
+      headers: await this.getBatchHeaders(options.headers),
+      failedResponseHandler: anthropicFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler3(
+        anthropicBatchResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    return batch;
+  }
+  async *iterateBatchResults(stream) {
+    for await (const line of parseJsonLines(stream)) {
+      yield await convertAnthropicBatchResult(line);
+    }
+  }
+  getBatchUrl(path) {
+    return `${this.config.baseURL}/messages/batches${path}`;
+  }
+  async getStartBatchHeaders({
+    betas,
+    headers
+  }) {
+    return combineHeaders3(
+      normalizeHeaders(await this.getBatchHeaders(headers)),
+      {
+        "anthropic-beta": betas.size > 0 ? Array.from(betas).join(",") : void 0
+      }
+    );
+  }
+  async getBatchHeaders(headers) {
+    return combineHeaders3(
+      this.config.headers ? await resolve2(this.config.headers) : void 0,
+      headers
+    );
+  }
+};
+async function getAnthropicBatchProviderBetas({
+  provider,
+  providerOptions
+}) {
+  var _a;
+  const providerOptionsName = provider.split(".")[0];
+  const canonicalOptions = await parseProviderOptions3({
+    provider: "anthropic",
+    providerOptions,
+    schema: anthropicBatchProviderOptionsSchema
+  });
+  const customOptions = providerOptionsName !== "anthropic" ? await parseProviderOptions3({
+    provider: providerOptionsName,
+    providerOptions,
+    schema: anthropicBatchProviderOptionsSchema
+  }) : void 0;
+  const anthropicOptions = Object.assign(
+    {},
+    canonicalOptions != null ? canonicalOptions : {},
+    customOptions != null ? customOptions : {}
+  );
+  return (_a = anthropicOptions.anthropicBeta) != null ? _a : [];
+}
+function validateRequestIds(requests) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const request of requests) {
+    if (!anthropicBatchRequestIdPattern.test(request.id)) {
+      throw new InvalidArgumentError({
+        argument: "requests",
+        message: `Anthropic batch request ID "${request.id}" must match ^[A-Za-z0-9_-]{1,64}$.`
+      });
+    }
+    if (ids.has(request.id)) {
+      throw new InvalidArgumentError({
+        argument: "requests",
+        message: `Anthropic batch request IDs must be unique; duplicate ID "${request.id}".`
+      });
+    }
+    ids.add(request.id);
+  }
+}
+function validateAnthropicBatchBody({
+  body,
+  requestId
+}) {
+  if (body.speed != null) {
+    throw new UnsupportedFunctionalityError3({
+      functionality: "providerOptions.anthropic.speed",
+      message: `Anthropic Message Batches do not support speed (request "${requestId}").`
+    });
+  }
+  if (Array.isArray(body.fallbacks) && body.fallbacks.some(
+    (fallback) => fallback != null && typeof fallback === "object" && "speed" in fallback && fallback.speed != null
+  )) {
+    throw new UnsupportedFunctionalityError3({
+      functionality: "providerOptions.anthropic.fallbacks[].speed",
+      message: `Anthropic Message Batches do not support fallback speed (request "${requestId}").`
+    });
+  }
+}
+function convertAnthropicBatchStatus(batch) {
+  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
+  };
+}
+function mapAnthropicBatchStatus(rawStatus) {
+  switch (rawStatus) {
+    case "ended":
+      return "completed";
+    case "in_progress":
+    case "canceling":
+    default:
+      return "pending";
+  }
+}
+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),
+    pending: counts.processing,
+    completed: counts.succeeded,
+    failed: counts.errored + counts.canceled + counts.expired
+  };
+}
+async function convertAnthropicBatchResult(line) {
+  switch (line.result.type) {
+    case "canceled":
+      return { id: line.custom_id, status: "cancelled" };
+    case "expired":
+      return { id: line.custom_id, status: "expired" };
+    case "errored": {
+      const requestId = line.result.error.request_id;
+      return {
+        id: line.custom_id,
+        status: "failed",
+        error: {
+          message: line.result.error.error.message,
+          type: line.result.error.error.type
+        },
+        ...requestId != null ? {
+          providerMetadata: {
+            anthropic: { requestId }
+          }
+        } : {}
+      };
+    }
+    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"
+          }
+        };
+      }
+      return {
+        id: line.custom_id,
+        status: "succeeded",
+        result: convertAnthropicBatchResponse(response)
+      };
+    }
+  }
+}
+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;
+  const content = [];
+  for (const part of response.content) {
+    switch (part.type) {
+      case "text":
+        content.push({ type: "text", text: part.text });
+        break;
+      case "thinking":
+        content.push({
+          type: "reasoning",
+          text: part.thinking,
+          providerMetadata: {
+            anthropic: {
+              signature: part.signature
+            }
+          }
+        });
+        break;
+      case "redacted_thinking":
+        content.push({
+          type: "reasoning",
+          text: "",
+          providerMetadata: {
+            anthropic: {
+              redactedData: part.data
+            }
+          }
+        });
+        break;
+      case "compaction":
+        content.push({
+          type: "text",
+          text: part.content,
+          providerMetadata: { anthropic: { type: "compaction" } }
+        });
+        break;
+    }
+  }
+  return {
+    content,
+    finishReason: {
+      unified: mapAnthropicStopReason({
+        finishReason: response.stop_reason
+      }),
+      raw: (_a = response.stop_reason) != null ? _a : void 0
+    },
+    usage: convertAnthropicUsage({ usage: response.usage }),
+    response: {
+      id: (_b = response.id) != null ? _b : void 0,
+      modelId: (_c = response.model) != null ? _c : void 0
+    },
+    warnings: [],
+    providerMetadata: {
+      anthropic: convertAnthropicMessageMetadata(response)
+    }
+  };
+}
+function convertAnthropicMessageMetadata(response) {
+  var _a, _b, _c;
+  const stopDetails = mapAnthropicStopDetails2(response.stop_details);
+  return {
+    usage: response.usage,
+    stopSequence: (_a = response.stop_sequence) != null ? _a : null,
+    ...stopDetails != null ? { stopDetails } : {},
+    iterations: response.usage.iterations ? response.usage.iterations.map(
+      (iteration) => ({
+        type: iteration.type,
+        ...iteration.model != null ? { model: iteration.model } : {},
+        inputTokens: iteration.input_tokens,
+        outputTokens: iteration.output_tokens,
+        ...iteration.cache_creation_input_tokens ? {
+          cacheCreationInputTokens: iteration.cache_creation_input_tokens
+        } : {},
+        ...iteration.cache_read_input_tokens ? { cacheReadInputTokens: iteration.cache_read_input_tokens } : {}
+      })
+    ) : null,
+    container: response.container ? {
+      expiresAt: response.container.expires_at,
+      id: response.container.id,
+      skills: (_c = (_b = response.container.skills) == null ? void 0 : _b.map((skill) => ({
+        type: skill.type,
+        skillId: skill.skill_id,
+        version: skill.version
+      }))) != null ? _c : null
+    } : null,
+    contextManagement: mapAnthropicResponseContextManagement2(
+      response.context_management
+    )
+  };
+}
+function mapAnthropicResponseContextManagement2(contextManagement) {
+  return contextManagement ? {
+    appliedEdits: contextManagement.applied_edits.map((edit) => {
+      switch (edit.type) {
+        case "clear_tool_uses_20250919":
+          return {
+            type: edit.type,
+            clearedToolUses: edit.cleared_tool_uses,
+            clearedInputTokens: edit.cleared_input_tokens
+          };
+        case "clear_thinking_20251015":
+          return {
+            type: edit.type,
+            clearedThinkingTurns: edit.cleared_thinking_turns,
+            clearedInputTokens: edit.cleared_input_tokens
+          };
+        case "compact_20260112":
+          return { type: edit.type };
+      }
+    })
+  } : null;
+}
+function mapAnthropicStopDetails2(stopDetails) {
+  if (stopDetails == null) {
+    return void 0;
+  }
+  return {
+    type: stopDetails.type,
+    ...stopDetails.category != null ? { category: stopDetails.category } : {},
+    ...stopDetails.explanation != null ? { explanation: stopDetails.explanation } : {},
+    ...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 {
   createProviderDefinedToolFactory as createProviderDefinedToolFactory2,
-  lazySchema as lazySchema14,
-  zodSchema as zodSchema14
+  lazySchema as lazySchema15,
+  zodSchema as zodSchema15
 } from "@ai-sdk/provider-utils";
-import { z as z15 } from "zod/v4";
-var bash_20241022InputSchema = lazySchema14(
-  () => zodSchema14(
-    z15.object({
-      command: z15.string(),
-      restart: z15.boolean().optional()
+import { z as z16 } from "zod/v4";
+var bash_20241022InputSchema = lazySchema15(
+  () => zodSchema15(
+    z16.object({
+      command: z16.string(),
+      restart: z16.boolean().optional()
     })
   )
 );
@@ -5881,15 +6448,15 @@ function bash_20241022(options = {}) {
 // src/tool/bash_20250124.ts
 import {
   createProviderDefinedToolFactory as createProviderDefinedToolFactory3,
-  lazySchema as lazySchema15,
-  zodSchema as zodSchema15
+  lazySchema as lazySchema16,
+  zodSchema as zodSchema16
 } from "@ai-sdk/provider-utils";
-import { z as z16 } from "zod/v4";
-var bash_20250124InputSchema = lazySchema15(
-  () => zodSchema15(
-    z16.object({
-      command: z16.string(),
-      restart: z16.boolean().optional()
+import { z as z17 } from "zod/v4";
+var bash_20250124InputSchema = lazySchema16(
+  () => zodSchema16(
+    z17.object({
+      command: z17.string(),
+      restart: z17.boolean().optional()
     })
   )
 );
@@ -5922,14 +6489,14 @@ function bash_20250124(options = {}) {
 // src/tool/computer_20241022.ts
 import {
   createProviderDefinedToolFactory as createProviderDefinedToolFactory4,
-  lazySchema as lazySchema16,
-  zodSchema as zodSchema16
+  lazySchema as lazySchema17,
+  zodSchema as zodSchema17
 } from "@ai-sdk/provider-utils";
-import { z as z17 } from "zod/v4";
-var computer_20241022InputSchema = lazySchema16(
-  () => zodSchema16(
-    z17.object({
-      action: z17.enum([
+import { z as z18 } from "zod/v4";
+var computer_20241022InputSchema = lazySchema17(
+  () => zodSchema17(
+    z18.object({
+      action: z18.enum([
         "key",
         "type",
         "mouse_move",
@@ -5941,8 +6508,8 @@ var computer_20241022InputSchema = lazySchema16(
         "screenshot",
         "cursor_position"
       ]),
-      coordinate: z17.array(z17.number().int()).optional(),
-      text: z17.string().optional()
+      coordinate: z18.array(z18.number().int()).optional(),
+      text: z18.string().optional()
     })
   )
 );
@@ -5954,14 +6521,14 @@ var computer_20241022 = createProviderDefinedToolFactory4({
 // src/tool/computer_20250124.ts
 import {
   createProviderDefinedToolFactory as createProviderDefinedToolFactory5,
-  lazySchema as lazySchema17,
-  zodSchema as zodSchema17
+  lazySchema as lazySchema18,
+  zodSchema as zodSchema18
 } from "@ai-sdk/provider-utils";
-import { z as z18 } from "zod/v4";
-var computer_20250124InputSchema = lazySchema17(
-  () => zodSchema17(
-    z18.object({
-      action: z18.enum([
+import { z as z19 } from "zod/v4";
+var computer_20250124InputSchema = lazySchema18(
+  () => zodSchema18(
+    z19.object({
+      action: z19.enum([
         "key",
         "hold_key",
         "type",
@@ -5979,12 +6546,12 @@ var computer_20250124InputSchema = lazySchema17(
         "wait",
         "screenshot"
       ]),
-      coordinate: z18.tuple([z18.number().int(), z18.number().int()]).optional(),
-      duration: z18.number().optional(),
-      scroll_amount: z18.number().optional(),
-      scroll_direction: z18.enum(["up", "down", "left", "right"]).optional(),
-      start_coordinate: z18.tuple([z18.number().int(), z18.number().int()]).optional(),
-      text: z18.string().optional()
+      coordinate: z19.tuple([z19.number().int(), z19.number().int()]).optional(),
+      duration: z19.number().optional(),
+      scroll_amount: z19.number().optional(),
+      scroll_direction: z19.enum(["up", "down", "left", "right"]).optional(),
+      start_coordinate: z19.tuple([z19.number().int(), z19.number().int()]).optional(),
+      text: z19.string().optional()
     })
   )
 );
@@ -5996,14 +6563,14 @@ var computer_20250124 = createProviderDefinedToolFactory5({
 // src/tool/computer_20251124.ts
 import {
   createProviderDefinedToolFactory as createProviderDefinedToolFactory6,
-  lazySchema as lazySchema18,
-  zodSchema as zodSchema18
+  lazySchema as lazySchema19,
+  zodSchema as zodSchema19
 } from "@ai-sdk/provider-utils";
-import { z as z19 } from "zod/v4";
-var computer_20251124InputSchema = lazySchema18(
-  () => zodSchema18(
-    z19.object({
-      action: z19.enum([
+import { z as z20 } from "zod/v4";
+var computer_20251124InputSchema = lazySchema19(
+  () => zodSchema19(
+    z20.object({
+      action: z20.enum([
         "key",
         "hold_key",
         "type",
@@ -6022,18 +6589,18 @@ var computer_20251124InputSchema = lazySchema18(
         "screenshot",
         "zoom"
       ]),
-      coordinate: z19.tuple([z19.number().int(), z19.number().int()]).optional(),
-      duration: z19.number().optional(),
-      region: z19.tuple([
-        z19.number().int(),
-        z19.number().int(),
-        z19.number().int(),
-        z19.number().int()
+      coordinate: z20.tuple([z20.number().int(), z20.number().int()]).optional(),
+      duration: z20.number().optional(),
+      region: z20.tuple([
+        z20.number().int(),
+        z20.number().int(),
+        z20.number().int(),
+        z20.number().int()
       ]).optional(),
-      scroll_amount: z19.number().optional(),
-      scroll_direction: z19.enum(["up", "down", "left", "right"]).optional(),
-      start_coordinate: z19.tuple([z19.number().int(), z19.number().int()]).optional(),
-      text: z19.string().optional()
+      scroll_amount: z20.number().optional(),
+      scroll_direction: z20.enum(["up", "down", "left", "right"]).optional(),
+      start_coordinate: z20.tuple([z20.number().int(), z20.number().int()]).optional(),
+      text: z20.string().optional()
     })
   )
 );
@@ -6045,43 +6612,43 @@ var computer_20251124 = createProviderDefinedToolFactory6({
 // src/tool/memory_20250818.ts
 import {
   createProviderDefinedToolFactory as createProviderDefinedToolFactory7,
-  lazySchema as lazySchema19,
-  zodSchema as zodSchema19
+  lazySchema as lazySchema20,
+  zodSchema as zodSchema20
 } from "@ai-sdk/provider-utils";
-import { z as z20 } from "zod/v4";
-var memory_20250818InputSchema = lazySchema19(
-  () => zodSchema19(
-    z20.discriminatedUnion("command", [
-      z20.object({
-        command: z20.literal("view"),
-        path: z20.string(),
-        view_range: z20.tuple([z20.number(), z20.number()]).optional()
+import { z as z21 } from "zod/v4";
+var memory_20250818InputSchema = lazySchema20(
+  () => zodSchema20(
+    z21.discriminatedUnion("command", [
+      z21.object({
+        command: z21.literal("view"),
+        path: z21.string(),
+        view_range: z21.tuple([z21.number(), z21.number()]).optional()
       }),
-      z20.object({
-        command: z20.literal("create"),
-        path: z20.string(),
-        file_text: z20.string()
+      z21.object({
+        command: z21.literal("create"),
+        path: z21.string(),
+        file_text: z21.string()
       }),
-      z20.object({
-        command: z20.literal("str_replace"),
-        path: z20.string(),
-        old_str: z20.string(),
-        new_str: z20.string()
+      z21.object({
+        command: z21.literal("str_replace"),
+        path: z21.string(),
+        old_str: z21.string(),
+        new_str: z21.string()
       }),
-      z20.object({
-        command: z20.literal("insert"),
-        path: z20.string(),
-        insert_line: z20.number(),
-        insert_text: z20.string()
+      z21.object({
+        command: z21.literal("insert"),
+        path: z21.string(),
+        insert_line: z21.number(),
+        insert_text: z21.string()
       }),
-      z20.object({
-        command: z20.literal("delete"),
-        path: z20.string()
+      z21.object({
+        command: z21.literal("delete"),
+        path: z21.string()
       }),
-      z20.object({
-        command: z20.literal("rename"),
-        old_path: z20.string(),
-        new_path: z20.string()
+      z21.object({
+        command: z21.literal("rename"),
+        old_path: z21.string(),
+        new_path: z21.string()
       })
     ])
   )
@@ -6094,37 +6661,11 @@ var memory_20250818 = createProviderDefinedToolFactory7({
 // src/tool/text-editor_20241022.ts
 import {
   createProviderDefinedToolFactory as createProviderDefinedToolFactory8,
-  lazySchema as lazySchema20,
-  zodSchema as zodSchema20
-} from "@ai-sdk/provider-utils";
-import { z as z21 } from "zod/v4";
-var textEditor_20241022InputSchema = lazySchema20(
-  () => zodSchema20(
-    z21.object({
-      command: z21.enum(["view", "create", "str_replace", "insert", "undo_edit"]),
-      path: z21.string(),
-      file_text: z21.string().optional(),
-      insert_line: z21.number().int().optional(),
-      new_str: z21.string().optional(),
-      insert_text: z21.string().optional(),
-      old_str: z21.string().optional(),
-      view_range: z21.array(z21.number().int()).optional()
-    })
-  )
-);
-var textEditor_20241022 = createProviderDefinedToolFactory8({
-  id: "anthropic.text_editor_20241022",
-  inputSchema: textEditor_20241022InputSchema
-});
-
-// src/tool/text-editor_20250124.ts
-import {
-  createProviderDefinedToolFactory as createProviderDefinedToolFactory9,
   lazySchema as lazySchema21,
   zodSchema as zodSchema21
 } from "@ai-sdk/provider-utils";
 import { z as z22 } from "zod/v4";
-var textEditor_20250124InputSchema = lazySchema21(
+var textEditor_20241022InputSchema = lazySchema21(
   () => zodSchema21(
     z22.object({
       command: z22.enum(["view", "create", "str_replace", "insert", "undo_edit"]),
@@ -6138,22 +6679,22 @@ var textEditor_20250124InputSchema = lazySchema21(
     })
   )
 );
-var textEditor_20250124 = createProviderDefinedToolFactory9({
-  id: "anthropic.text_editor_20250124",
-  inputSchema: textEditor_20250124InputSchema
+var textEditor_20241022 = createProviderDefinedToolFactory8({
+  id: "anthropic.text_editor_20241022",
+  inputSchema: textEditor_20241022InputSchema
 });
 
-// src/tool/text-editor_20250429.ts
+// src/tool/text-editor_20250124.ts
 import {
-  createProviderDefinedToolFactory as createProviderDefinedToolFactory10,
+  createProviderDefinedToolFactory as createProviderDefinedToolFactory9,
   lazySchema as lazySchema22,
   zodSchema as zodSchema22
 } from "@ai-sdk/provider-utils";
 import { z as z23 } from "zod/v4";
-var textEditor_20250429InputSchema = lazySchema22(
+var textEditor_20250124InputSchema = lazySchema22(
   () => zodSchema22(
     z23.object({
-      command: z23.enum(["view", "create", "str_replace", "insert"]),
+      command: z23.enum(["view", "create", "str_replace", "insert", "undo_edit"]),
       path: z23.string(),
       file_text: z23.string().optional(),
       insert_line: z23.number().int().optional(),
@@ -6164,6 +6705,32 @@ var textEditor_20250429InputSchema = lazySchema22(
     })
   )
 );
+var textEditor_20250124 = createProviderDefinedToolFactory9({
+  id: "anthropic.text_editor_20250124",
+  inputSchema: textEditor_20250124InputSchema
+});
+
+// src/tool/text-editor_20250429.ts
+import {
+  createProviderDefinedToolFactory as createProviderDefinedToolFactory10,
+  lazySchema as lazySchema23,
+  zodSchema as zodSchema23
+} from "@ai-sdk/provider-utils";
+import { z as z24 } from "zod/v4";
+var textEditor_20250429InputSchema = lazySchema23(
+  () => zodSchema23(
+    z24.object({
+      command: z24.enum(["view", "create", "str_replace", "insert"]),
+      path: z24.string(),
+      file_text: z24.string().optional(),
+      insert_line: z24.number().int().optional(),
+      new_str: z24.string().optional(),
+      insert_text: z24.string().optional(),
+      old_str: z24.string().optional(),
+      view_range: z24.array(z24.number().int()).optional()
+    })
+  )
+);
 var textEditor_20250429 = createProviderDefinedToolFactory10({
   id: "anthropic.text_editor_20250429",
   inputSchema: textEditor_20250429InputSchema
@@ -6172,32 +6739,32 @@ var textEditor_20250429 = createProviderDefinedToolFactory10({
 // src/tool/tool-search-bm25_20251119.ts
 import {
   createProviderExecutedToolFactory as createProviderExecutedToolFactory10,
-  lazySchema as lazySchema23,
-  zodSchema as zodSchema23
+  lazySchema as lazySchema24,
+  zodSchema as zodSchema24
 } from "@ai-sdk/provider-utils";
-import { z as z24 } from "zod/v4";
-var toolSearchBm25_20251119OutputSchema = lazySchema23(
-  () => zodSchema23(
-    z24.array(
-      z24.object({
-        type: z24.literal("tool_reference"),
-        toolName: z24.string()
+import { z as z25 } from "zod/v4";
+var toolSearchBm25_20251119OutputSchema = lazySchema24(
+  () => zodSchema24(
+    z25.array(
+      z25.object({
+        type: z25.literal("tool_reference"),
+        toolName: z25.string()
       })
     )
   )
 );
-var toolSearchBm25_20251119InputSchema = lazySchema23(
-  () => zodSchema23(
-    z24.object({
+var toolSearchBm25_20251119InputSchema = lazySchema24(
+  () => zodSchema24(
+    z25.object({
       /**
        * A natural language query to search for tools.
        * Claude will use BM25 text search to find relevant tools.
        */
-      query: z24.string(),
+      query: z25.string(),
       /**
        * Maximum number of tools to return. Optional.
        */
-      limit: z24.number().optional()
+      limit: z25.number().optional()
     })
   )
 );
@@ -6446,49 +7013,49 @@ var anthropicTools = {
 
 // src/skills/anthropic-skills.ts
 import {
-  combineHeaders as combineHeaders3,
+  combineHeaders as combineHeaders4,
   convertInlineFileDataToUint8Array as convertInlineFileDataToUint8Array2,
-  createJsonResponseHandler as createJsonResponseHandler3,
-  getFromApi,
+  createJsonResponseHandler as createJsonResponseHandler4,
+  getFromApi as getFromApi2,
   postFormDataToApi as postFormDataToApi2,
-  resolve as resolve2
+  resolve as resolve3
 } from "@ai-sdk/provider-utils";
 
 // src/skills/anthropic-skills-api.ts
-import { lazySchema as lazySchema24, zodSchema as zodSchema24 } from "@ai-sdk/provider-utils";
-import { z as z25 } from "zod/v4";
-var anthropicSkillResponseSchema = lazySchema24(
-  () => zodSchema24(
-    z25.object({
-      id: z25.string(),
-      display_title: z25.string().nullish(),
-      name: z25.string().nullish(),
-      description: z25.string().nullish(),
-      latest_version: z25.string().nullish(),
-      source: z25.string(),
-      created_at: z25.string(),
-      updated_at: z25.string()
+import { lazySchema as lazySchema25, zodSchema as zodSchema25 } from "@ai-sdk/provider-utils";
+import { z as z26 } from "zod/v4";
+var anthropicSkillResponseSchema = lazySchema25(
+  () => zodSchema25(
+    z26.object({
+      id: z26.string(),
+      display_title: z26.string().nullish(),
+      name: z26.string().nullish(),
+      description: z26.string().nullish(),
+      latest_version: z26.string().nullish(),
+      source: z26.string(),
+      created_at: z26.string(),
+      updated_at: z26.string()
     })
   )
 );
-var anthropicSkillVersionListResponseSchema = lazySchema24(
-  () => zodSchema24(
-    z25.object({
-      data: z25.array(
-        z25.object({
-          version: z25.string()
+var anthropicSkillVersionListResponseSchema = lazySchema25(
+  () => zodSchema25(
+    z26.object({
+      data: z26.array(
+        z26.object({
+          version: z26.string()
         })
       )
     })
   )
 );
-var anthropicSkillVersionResponseSchema = lazySchema24(
-  () => zodSchema24(
-    z25.object({
-      type: z25.string(),
-      skill_id: z25.string(),
-      name: z25.string().nullish(),
-      description: z25.string().nullish()
+var anthropicSkillVersionResponseSchema = lazySchema25(
+  () => zodSchema25(
+    z26.object({
+      type: z26.string(),
+      skill_id: z26.string(),
+      name: z26.string().nullish(),
+      description: z26.string().nullish()
     })
   )
 );
@@ -6503,7 +7070,7 @@ var AnthropicSkills = class {
     return this.config.provider;
   }
   async getHeaders() {
-    return combineHeaders3(await resolve2(this.config.headers), {
+    return combineHeaders4(await resolve3(this.config.headers), {
       "anthropic-beta": "skills-2025-10-02"
     });
   }
@@ -6512,12 +7079,12 @@ var AnthropicSkills = class {
     version,
     headers
   }) {
-    const { value: versionResponse } = await getFromApi({
+    const { value: versionResponse } = await getFromApi2({
       url: `${this.config.baseURL}/skills/${skillId}/versions/${version}`,
       validateUrl: false,
       headers,
       failedResponseHandler: anthropicFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler3(
+      successfulResponseHandler: createJsonResponseHandler4(
         anthropicSkillVersionResponseSchema
       ),
       fetch: this.config.fetch
@@ -6544,7 +7111,7 @@ var AnthropicSkills = class {
       headers,
       formData,
       failedResponseHandler: anthropicFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler3(
+      successfulResponseHandler: createJsonResponseHandler4(
         anthropicSkillResponseSchema
       ),
       fetch: this.config.fetch
@@ -6575,7 +7142,7 @@ var AnthropicSkills = class {
 };
 
 // src/version.ts
-var VERSION = true ? "4.0.32" : "0.0.0-test";
+var VERSION = true ? "4.0.34" : "0.0.0-test";
 
 // src/anthropic-provider.ts
 var ANTHROPIC_API_URL = "https://api.anthropic.com";
@@ -6596,7 +7163,7 @@ function createAnthropic(options = {}) {
   )) != null ? _a : ANTHROPIC_API_VERSIONED_URL;
   const providerName = (_b = options.name) != null ? _b : "anthropic.messages";
   if (options.apiKey && options.authToken) {
-    throw new InvalidArgumentError({
+    throw new InvalidArgumentError2({
       argument: "apiKey/authToken",
       message: "Both apiKey and authToken were provided. Please use only one authentication method."
     });
@@ -6620,7 +7187,7 @@ function createAnthropic(options = {}) {
   };
   const createChatModel = (modelId) => {
     var _a2;
-    return new AnthropicLanguageModel(modelId, {
+    return new AnthropicMessagesBatchLanguageModel(modelId, {
       provider: providerName,
       baseURL,
       headers: getHeaders,