@ai-sdk/anthropic 4.0.41 → 4.0.44

package/docs/05-anthropic.mdx

@@ -155,12 +155,6 @@ Anthropic language models support asynchronous text generation through the
 Use the experimental text batch APIs to start a batch, poll its status, and
 stream its results:
 
-<Note>
-  Anthropic Message Batches do not support the `speed` option. Explicit
-  `anthropicBeta` values must be configured when starting the batch rather than
-  on an individual request.
-</Note>
-
 ```ts
 import { anthropic } from '@ai-sdk/anthropic';
 import {
@@ -175,8 +169,8 @@ const model = anthropic('claude-haiku-4-5');
 const batch = await startTextBatch({
   model,
   requests: [
-    { id: 'first', prompt: 'What is the capital of France?' },
-    { id: 'second', prompt: 'What is the capital of Germany?' },
+    { id: 'capital-france', prompt: 'What is the capital of France?' },
+    { id: 'capital-germany', prompt: 'What is the capital of Germany?' },
   ],
 });
 
@@ -195,6 +189,21 @@ for await (const item of getBatchResults({ model, batch })) {
 }
 ```
 
+`startTextBatch` returns a serializable batch reference. Persist this reference
+to check the batch status or retrieve its results from another process. Results
+can arrive in a different order from the input requests, so match each result by
+its `id`.
+
+#### Batch Limitations
+
+<Note>
+  Anthropic Message Batches do not support the `speed` option or completion
+  webhooks. Explicit `anthropicBeta` values must be configured when starting the
+  batch rather than on an individual request. When you provide a `webhookUrl`,
+  the provider returns an unsupported warning and starts the batch without a
+  webhook.
+</Note>
+
 ### Structured Outputs and Tool Input Streaming
 
 Tool call streaming is enabled by default. You can opt out by setting the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/anthropic",
-  "version": "4.0.41",
+  "version": "4.0.44",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -35,16 +35,16 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.7",
-    "@ai-sdk/provider-utils": "5.0.29"
+    "@ai-sdk/provider": "4.0.8",
+    "@ai-sdk/provider-utils": "5.0.32"
   },
   "devDependencies": {
+    "@ai-sdk/test-server": "2.0.1",
     "@types/node": "22.19.19",
+    "@vercel/ai-tsconfig": "0.0.0",
     "tsup": "^8.5.1",
     "typescript": "5.8.3",
-    "zod": "3.25.76",
-    "@ai-sdk/test-server": "2.0.1",
-    "@vercel/ai-tsconfig": "0.0.0"
+    "zod": "3.25.76"
   },
   "peerDependencies": {
     "zod": "^3.25.76 || ^4.1.8"

package/src/anthropic-api.ts

@@ -1368,6 +1368,10 @@ export const anthropicChunkSchema = lazySchema(() =>
         error: z.object({
           type: z.string(),
           message: z.string(),
+          code: z.union([z.string(), z.number()]).nullish(),
+          statusCode: z.number().nullish(),
+          isRetryable: z.boolean().nullish(),
+          data: z.unknown().nullish(),
         }),
       }),
       z.object({

package/src/anthropic-language-model.ts

@@ -20,9 +20,11 @@ import {
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonResponseHandler,
+  createProviderStreamError,
   createToolNameMapping,
   generateId,
   isCustomReasoning,
+  isProviderStreamError,
   mapReasoningToProviderBudget,
   mapReasoningToProviderEffort,
   parseProviderOptions,
@@ -69,6 +71,53 @@ import { CacheControlValidator } from './get-cache-control';
 import { mapAnthropicStopReason } from './map-anthropic-stop-reason';
 import { sanitizeJsonSchema } from './sanitize-json-schema';
 
+function createAnthropicStreamError(error: {
+  message: string;
+  type: string;
+  code?: string | number | null;
+  statusCode?: number | null;
+  isRetryable?: boolean | null;
+  data?: unknown;
+}) {
+  const inferredMetadata = getAnthropicStreamErrorMetadata(error.type);
+
+  return createProviderStreamError({
+    message: error.message,
+    type: error.type,
+    code: error.code ?? undefined,
+    statusCode: error.statusCode ?? inferredMetadata.statusCode,
+    isRetryable: error.isRetryable ?? inferredMetadata.isRetryable,
+    data: 'data' in error ? error.data : error,
+  });
+}
+
+function getAnthropicStreamErrorMetadata(type: string): {
+  statusCode?: number;
+  isRetryable?: boolean;
+} {
+  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: Citation,
   citationDocuments: Array<{
@@ -2662,7 +2711,10 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
             }
 
             case 'error': {
-              controller.enqueue({ type: 'error', error: value.error });
+              controller.enqueue({
+                type: 'error',
+                error: createAnthropicStreamError(value.error),
+              });
               return;
             }
 
@@ -2693,16 +2745,20 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
       // We handle the case where the first chunk is an error here and transform
       // it into an APICallError.
       if (result.value?.type === 'error') {
-        const error = result.value.error as { message: string; type: string };
+        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: error.statusCode ?? 500,
           responseHeaders,
-          responseBody: JSON.stringify(error),
-          isRetryable: error.type === 'overloaded_error',
+          responseBody: JSON.stringify(error.data),
+          isRetryable: error.isRetryable ?? false,
         });
       }
     } finally {

package/src/anthropic-messages-batch.ts

@@ -1,6 +1,6 @@
 import {
-  EmptyResponseBodyError,
   InvalidArgumentError,
+  InvalidResponseDataError,
   UnsupportedFunctionalityError,
   type Experimental_BatchLanguageModelV4 as BatchLanguageModelV4,
   type Experimental_BatchV4ItemResult as BatchV4ItemResult,
@@ -14,11 +14,12 @@ import {
 import {
   combineHeaders,
   convertAsyncIteratorToReadableStream,
+  createJsonLinesResponseHandler,
   createJsonResponseHandler,
   getFromApi,
   lazySchema,
+  normalizeBatchRequestCounts,
   normalizeHeaders,
-  parseJSON,
   parseProviderOptions,
   postJsonToApi,
   resolve,
@@ -27,7 +28,6 @@ import {
   WORKFLOW_SERIALIZE,
   zodSchema,
   type InferSchema,
-  type ResponseHandler,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 import {
@@ -145,6 +145,7 @@ export class AnthropicMessagesBatchLanguageModel
     providerOptions,
     headers,
     abortSignal,
+    webhookUrl,
   }: Parameters<
     BatchLanguageModelV4['experimental_doStartBatch']
   >[0]): Promise<BatchV4StartResult> {
@@ -161,7 +162,19 @@ export class AnthropicMessagesBatchLanguageModel
       custom_id: string;
       params: Record<string, unknown>;
     }> = [];
-    const batchWarnings: BatchV4StartResult['warnings'] = [];
+    const batchWarnings: BatchV4StartResult['warnings'] =
+      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({
@@ -243,26 +256,28 @@ export class AnthropicMessagesBatchLanguageModel
     }
 
     if (batch.results_url == null) {
-      throw new InvalidArgumentError({
-        argument: 'batchId',
-        message: `Anthropic batch "${options.batchId}" does not have a results URL.`,
+      throw new InvalidResponseDataError({
+        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,
       headers: await this.getBatchHeaders(options.headers),
       failedResponseHandler: anthropicFailedResponseHandler,
-      successfulResponseHandler: rawStreamResponseHandler,
+      successfulResponseHandler: createJsonLinesResponseHandler(
+        anthropicBatchResultLineSchema,
+      ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch,
     });
 
     return convertAsyncIteratorToReadableStream(
-      this.iterateBatchResults(stream),
+      this.iterateBatchResults(lines),
     );
   }
 
@@ -285,9 +300,9 @@ export class AnthropicMessagesBatchLanguageModel
   }
 
   private async *iterateBatchResults(
-    stream: ReadableStream<Uint8Array>,
+    lines: AsyncIterable<AnthropicBatchResultLine>,
   ): AsyncGenerator<BatchV4ItemResult<LanguageModelV4GenerateResult>> {
-    for await (const line of parseJsonLines(stream)) {
+    for await (const line of lines) {
       yield await convertAnthropicBatchResult(line);
     }
   }
@@ -440,24 +455,17 @@ function mapAnthropicBatchStatus(rawStatus: string): BatchV4Status['status'] {
 function convertAnthropicRequestCounts(
   counts: AnthropicBatchResponse['request_counts'],
 ): BatchV4Status['requestCounts'] | undefined {
-  const values = [
-    counts.processing,
-    counts.succeeded,
-    counts.errored,
-    counts.canceled,
-    counts.expired,
-  ];
-
-  if (values.some(value => !Number.isFinite(value) || value < 0)) {
-    return undefined;
-  }
-
-  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(
@@ -517,7 +525,7 @@ async function convertAnthropicBatchResult(
             message:
               `Anthropic returned a "${unsupportedPart.type}" content block, ` +
               'but tool content is not supported in AI SDK text batches.',
-            code: 'unsupported_tool_content',
+            code: 'unsupported_content',
           },
         };
       }
@@ -693,64 +701,3 @@ function mapAnthropicStopDetails(
       : {}),
   };
 }
-
-const rawStreamResponseHandler: ResponseHandler<
-  ReadableStream<Uint8Array>
-> = async ({ response }) => {
-  if (response.body == null) {
-    throw new EmptyResponseBodyError();
-  }
-
-  return { value: response.body };
-};
-
-async function* parseJsonLines(
-  stream: ReadableStream<Uint8Array>,
-): AsyncGenerator<AnthropicBatchResultLine> {
-  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();
-  }
-}

package/src/skills/anthropic-skills.ts

@@ -22,6 +22,17 @@ interface AnthropicSkillsConfig {
   fetch?: FetchFunction;
 }
 
+function encodePathSegment(value: string): string {
+  const encodedValue = encodeURIComponent(value);
+
+  // URL parsing normalizes both literal and percent-encoded dot segments.
+  return encodedValue === '.'
+    ? '%252E'
+    : encodedValue === '..'
+      ? '%252E%252E'
+      : encodedValue;
+}
+
 export class AnthropicSkills implements SkillsV4 {
   readonly specificationVersion = 'v4';
 
@@ -47,7 +58,7 @@ export class AnthropicSkills implements SkillsV4 {
     headers: Record<string, string | undefined>;
   }): Promise<{ name?: string; description?: string }> {
     const { value: versionResponse } = await getFromApi({
-      url: `${this.config.baseURL}/skills/${skillId}/versions/${version}`,
+      url: `${this.config.baseURL}/skills/${encodePathSegment(skillId)}/versions/${encodePathSegment(version)}`,
       validateUrl: false,
       headers,
       failedResponseHandler: anthropicFailedResponseHandler,