@ai-sdk/amazon-bedrock 5.0.0-beta.3 → 5.0.0-beta.30

package/docs/08-amazon-bedrock.mdx

@@ -514,6 +514,37 @@ console.log(amazonResult.text); // text response
 See [AI SDK UI: Chatbot](/docs/ai-sdk-ui/chatbot#reasoning) for more details
 on how to integrate reasoning into your chatbot.
 
+## Service Tiers
+
+Amazon Bedrock supports selecting an inference service tier per request via the `serviceTier` provider option.
+
+```ts
+import {
+  bedrock,
+  type AmazonBedrockLanguageModelOptions,
+} from '@ai-sdk/amazon-bedrock';
+import { generateText } from 'ai';
+
+const result = await generateText({
+  model: bedrock('us.anthropic.claude-sonnet-4-20250514-v1:0'),
+  prompt: 'Summarize this support ticket backlog.',
+  providerOptions: {
+    bedrock: {
+      serviceTier: 'priority',
+    } satisfies AmazonBedrockLanguageModelOptions,
+  },
+});
+```
+
+Supported values are:
+
+- `reserved`
+- `priority`
+- `default`
+- `flex`
+
+See the [Amazon Bedrock service tiers documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/service-tiers-inference.html) for model availability and behavior.
+
 ## Extended Context Window
 
 Claude Sonnet 4 models on Amazon Bedrock support an extended context window of up to 1 million tokens when using the `context-1m-2025-08-07` beta feature.
@@ -546,6 +577,11 @@ Via Anthropic, Amazon Bedrock provides three provider-defined tools that can be
 
 They are available via the `tools` property of the provider instance.
 
+<Note>
+  Amazon Bedrock does not support strict mode on tool definitions. Setting
+  `strict: true` on a tool will be ignored and a warning will be emitted.
+</Note>
+
 ### Bash Tool
 
 The Bash Tool allows running bash commands. Here's how to create and use it:
@@ -1375,6 +1411,16 @@ const { text } = await generateText({
 });
 ```
 
+### Provider Options
+
+The following optional provider options are available for Bedrock Anthropic models:
+
+- `metadata` _object_
+
+  Optional. Metadata to include with the request. See the [Anthropic API documentation](https://platform.claude.com/docs/en/api/messages/create) for details.
+
+  - `userId` _string_ - An external identifier for the end-user.
+
 ### Cache Control
 
 In the messages and message parts, you can use the `providerOptions` property to set cache control breakpoints.
@@ -1428,7 +1474,7 @@ They are available via the `tools` property of the provider instance.
 
 ```ts
 import { bedrockAnthropic } from '@ai-sdk/amazon-bedrock/anthropic';
-import { generateText, stepCountIs } from 'ai';
+import { generateText, isStepCount } from 'ai';
 
 const result = await generateText({
   model: bedrockAnthropic('us.anthropic.claude-sonnet-4-5-20250929-v1:0'),
@@ -1441,7 +1487,7 @@ const result = await generateText({
     }),
   },
   prompt: 'List the files in my directory.',
-  stopWhen: stepCountIs(2),
+  stopWhen: isStepCount(2),
 });
 ```
 
@@ -1449,7 +1495,7 @@ const result = await generateText({
 
 ```ts
 import { bedrockAnthropic } from '@ai-sdk/amazon-bedrock/anthropic';
-import { generateText, stepCountIs } from 'ai';
+import { generateText, isStepCount } from 'ai';
 
 const result = await generateText({
   model: bedrockAnthropic('us.anthropic.claude-sonnet-4-5-20250929-v1:0'),
@@ -1462,7 +1508,7 @@ const result = await generateText({
     }),
   },
   prompt: 'Update my README file.',
-  stopWhen: stepCountIs(5),
+  stopWhen: isStepCount(5),
 });
 ```
 
@@ -1470,7 +1516,7 @@ const result = await generateText({
 
 ```ts
 import { bedrockAnthropic } from '@ai-sdk/amazon-bedrock/anthropic';
-import { generateText, stepCountIs } from 'ai';
+import { generateText, isStepCount } from 'ai';
 import fs from 'fs';
 
 const result = await generateText({
@@ -1505,7 +1551,7 @@ const result = await generateText({
     }),
   },
   prompt: 'Take a screenshot.',
-  stopWhen: stepCountIs(3),
+  stopWhen: isStepCount(3),
 });
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/amazon-bedrock",
-  "version": "5.0.0-beta.3",
+  "version": "5.0.0-beta.30",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -38,9 +38,9 @@
     "@smithy/eventstream-codec": "^4.0.1",
     "@smithy/util-utf8": "^4.0.0",
     "aws4fetch": "^1.0.20",
-    "@ai-sdk/anthropic": "4.0.0-beta.3",
-    "@ai-sdk/provider": "4.0.0-beta.0",
-    "@ai-sdk/provider-utils": "5.0.0-beta.1"
+    "@ai-sdk/anthropic": "4.0.0-beta.26",
+    "@ai-sdk/provider": "4.0.0-beta.10",
+    "@ai-sdk/provider-utils": "5.0.0-beta.18"
   },
   "devDependencies": {
     "@types/node": "20.17.24",
@@ -74,9 +74,7 @@
     "build": "pnpm clean && tsup --tsconfig tsconfig.build.json",
     "build:watch": "pnpm clean && tsup --watch",
     "clean": "del-cli dist docs *.tsbuildinfo",
-    "lint": "eslint \"./**/*.ts*\"",
     "type-check": "tsc --build",
-    "prettier-check": "prettier --check \"./**/*.ts*\"",
     "test": "pnpm test:node && pnpm test:edge",
     "test:update": "pnpm test:node -u",
     "test:watch": "vitest --config vitest.node.config.js",

package/src/anthropic/bedrock-anthropic-fetch.ts

@@ -3,14 +3,40 @@ import {
   FetchFunction,
   safeParseJSON,
 } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
 import { createBedrockEventStreamDecoder } from '../bedrock-event-stream-decoder';
 
+const bedrockErrorSchema = z.looseObject({
+  message: z.string().optional(),
+});
+
 export function createBedrockAnthropicFetch(
   baseFetch: FetchFunction,
 ): FetchFunction {
   return async (url, options) => {
     const response = await baseFetch(url, options);
 
+    // Transform Bedrock error responses into Anthropic error format
+    // so that anthropicFailedResponseHandler can extract the message.
+    if (!response.ok) {
+      const text = await response.text();
+      const parsed = await safeParseJSON({ text, schema: bedrockErrorSchema });
+
+      const message =
+        parsed.success && parsed.value.message ? parsed.value.message : text;
+
+      const anthropicError = JSON.stringify({
+        type: 'error',
+        error: { type: 'error', message },
+      });
+
+      return new Response(anthropicError, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+      });
+    }
+
     const contentType = response.headers.get('content-type');
     if (
       contentType?.includes('application/vnd.amazon.eventstream') &&

package/src/anthropic/bedrock-anthropic-provider.ts

@@ -47,6 +47,10 @@ const BEDROCK_TOOL_BETA_MAP: Record<string, string> = {
   text_editor_20250728: 'computer-use-2025-01-24',
   computer_20250124: 'computer-use-2025-01-24',
   computer_20241022: 'computer-use-2024-10-22',
+  tool_search_tool_regex_20251119: 'tool-search-tool-2025-10-19',
+  // BM25 is not currently supported on Bedrock, but including the beta flag
+  // so that Bedrock returns a more useful error message if it's used.
+  tool_search_tool_bm25_20251119: 'tool-search-tool-2025-10-19',
 };
 
 export interface BedrockAnthropicProvider extends ProviderV4 {
@@ -257,7 +261,13 @@ export function createBedrockAnthropic(
         }`,
 
       transformRequestBody: (args, betas) => {
-        const { model, stream, tool_choice, tools, ...rest } = args;
+        const {
+          model: _model,
+          stream: _stream,
+          tool_choice,
+          tools,
+          ...rest
+        } = args;
 
         const transformedToolChoice =
           tool_choice != null

package/src/bedrock-api-types.ts

@@ -13,6 +13,9 @@ export interface BedrockConverseInput {
   };
   additionalModelRequestFields?: Record<string, unknown>;
   additionalModelResponseFieldPaths?: string[];
+  serviceTier?: {
+    type: string;
+  };
   guardrailConfig?:
     | BedrockGuardrailConfiguration
     | BedrockGuardrailStreamConfiguration

package/src/bedrock-chat-language-model.ts

@@ -19,10 +19,14 @@ import {
   combineHeaders,
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
+  isCustomReasoning,
+  mapReasoningToProviderBudget,
+  mapReasoningToProviderEffort,
   parseProviderOptions,
   postJsonToApi,
   resolve,
 } from '@ai-sdk/provider-utils';
+import { getModelCapabilities } from '@ai-sdk/anthropic/internal';
 import { z } from 'zod/v4';
 import {
   BEDROCK_STOP_REASONS,
@@ -30,6 +34,7 @@ import {
   BedrockStopReason,
 } from './bedrock-api-types';
 import {
+  AmazonBedrockLanguageModelOptions,
   BedrockChatModelId,
   amazonBedrockLanguageModelOptions,
 } from './bedrock-chat-options';
@@ -70,6 +75,7 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
     seed,
     tools,
     toolChoice,
+    reasoning,
     providerOptions,
   }: LanguageModelV4CallOptions): Promise<{
     command: BedrockConverseInput;
@@ -78,7 +84,7 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
     betas: Set<string>;
   }> {
     // Parse provider options
-    const bedrockOptions =
+    let bedrockOptions =
       (await parseProviderOptions({
         provider: 'bedrock',
         providerOptions,
@@ -137,13 +143,26 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
     }
 
     const isAnthropicModel = this.modelId.includes('anthropic');
+    const isOpenAIModel = this.modelId.startsWith('openai.');
+
+    bedrockOptions = resolveBedrockReasoningConfig({
+      reasoning,
+      bedrockOptions,
+      warnings,
+      isAnthropicModel,
+      modelId: this.modelId,
+    });
+
     const isThinkingEnabled =
       bedrockOptions.reasoningConfig?.type === 'enabled' ||
       bedrockOptions.reasoningConfig?.type === 'adaptive';
 
+    const { supportsStructuredOutput: modelSupportsStructuredOutput } =
+      getModelCapabilities(this.modelId);
+
     const useNativeStructuredOutput =
       isAnthropicModel &&
-      isThinkingEnabled &&
+      (modelSupportsStructuredOutput || isThinkingEnabled) &&
       responseFormat?.type === 'json' &&
       responseFormat.schema != null;
 
@@ -247,7 +266,6 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
 
     const maxReasoningEffort =
       bedrockOptions.reasoningConfig?.maxReasoningEffort;
-    const isOpenAIModel = this.modelId.startsWith('openai.');
 
     if (maxReasoningEffort != null) {
       if (isAnthropicModel) {
@@ -368,6 +386,7 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
     const {
       reasoningConfig: _,
       additionalModelRequestFields: __,
+      serviceTier: ___,
       ...filteredBedrockOptions
     } = providerOptions?.bedrock || {};
 
@@ -387,6 +406,11 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
         ...(Object.keys(inferenceConfig).length > 0 && {
           inferenceConfig,
         }),
+        ...(bedrockOptions.serviceTier != null && {
+          serviceTier: {
+            type: bedrockOptions.serviceTier,
+          },
+        }),
         ...filteredBedrockOptions,
         ...(toolConfig.tools !== undefined && toolConfig.tools.length > 0
           ? { toolConfig }
@@ -441,7 +465,7 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
     // map response content to content array
     for (const part of response.output.message.content) {
       // text
-      if (part.text) {
+      if (part.text != null) {
         content.push({ type: 'text', text: part.text });
       }
 
@@ -1122,3 +1146,73 @@ export const bedrockReasoningMetadataSchema = z.object({
 export type BedrockReasoningMetadata = z.infer<
   typeof bedrockReasoningMetadataSchema
 >;
+
+const bedrockReasoningEffortMap: Partial<
+  Record<string, 'low' | 'medium' | 'high' | 'max'>
+> = {
+  minimal: 'low',
+  low: 'low',
+  medium: 'medium',
+  high: 'high',
+  xhigh: 'max',
+};
+
+function resolveBedrockReasoningConfig({
+  reasoning,
+  bedrockOptions,
+  warnings,
+  isAnthropicModel,
+  modelId,
+}: {
+  reasoning: LanguageModelV4CallOptions['reasoning'];
+  bedrockOptions: AmazonBedrockLanguageModelOptions;
+  warnings: SharedV4Warning[];
+  isAnthropicModel: boolean;
+  modelId: string;
+}): AmazonBedrockLanguageModelOptions {
+  if (!isCustomReasoning(reasoning) || bedrockOptions.reasoningConfig != null) {
+    return bedrockOptions;
+  }
+
+  const result = { ...bedrockOptions };
+
+  if (isAnthropicModel) {
+    const capabilities = getModelCapabilities(modelId);
+
+    if (reasoning === 'none') {
+      result.reasoningConfig = { type: 'disabled' };
+    } else if (capabilities.supportsAdaptiveThinking) {
+      const effort = mapReasoningToProviderEffort({
+        reasoning,
+        effortMap: bedrockReasoningEffortMap,
+        warnings,
+      });
+      result.reasoningConfig = {
+        type: 'adaptive',
+        maxReasoningEffort: effort,
+      };
+    } else {
+      const budgetTokens = mapReasoningToProviderBudget({
+        reasoning,
+        maxOutputTokens: capabilities.maxOutputTokens,
+        maxReasoningBudget: capabilities.maxOutputTokens,
+        warnings,
+      });
+      if (budgetTokens != null) {
+        result.reasoningConfig = {
+          type: 'enabled',
+          budgetTokens,
+        };
+      }
+    }
+  } else if (reasoning !== 'none') {
+    const effort = mapReasoningToProviderEffort({
+      reasoning,
+      effortMap: bedrockReasoningEffortMap,
+      warnings,
+    });
+    result.reasoningConfig = { maxReasoningEffort: effort };
+  }
+
+  return result;
+}

package/src/bedrock-chat-options.ts

@@ -122,6 +122,16 @@ export const amazonBedrockLanguageModelOptions = z.object({
    * Anthropic beta features to enable
    */
   anthropicBeta: z.array(z.string()).optional(),
+  /**
+   * Service tier for the request.
+   * @see https://docs.aws.amazon.com/bedrock/latest/userguide/service-tiers-inference.html
+   *
+   * - 'reserved': Uses provisioned throughput capacity
+   * - 'priority': Prioritizes low-latency inference when capacity is available
+   * - 'default': Standard on-demand tier
+   * - 'flex': Lower-cost tier for flexible latency workloads
+   */
+  serviceTier: z.enum(['reserved', 'priority', 'default', 'flex']).optional(),
 });
 
 export type AmazonBedrockLanguageModelOptions = z.infer<

package/src/bedrock-prepare-tools.ts

@@ -82,6 +82,7 @@ export async function prepareTools({
       tools: ProviderTools,
       toolChoice,
       supportsStructuredOutput: false,
+      supportsStrictTools: false,
     });
 
     toolWarnings.push(...anthropicToolWarnings);

package/src/convert-to-bedrock-chat-messages.ts

@@ -7,6 +7,7 @@ import {
 } from '@ai-sdk/provider';
 import {
   convertToBase64,
+  isProviderReference,
   parseProviderOptions,
   stripFileExtension,
 } from '@ai-sdk/provider-utils';
@@ -112,6 +113,12 @@ export async function convertToBedrockChatMessages(
                   }
 
                   case 'file': {
+                    if (isProviderReference(part.data)) {
+                      throw new UnsupportedFunctionalityError({
+                        functionality: 'file parts with provider references',
+                      });
+                    }
+
                     if (part.data instanceof URL) {
                       // The AI SDK automatically downloads files for user file parts with URLs
                       throw new UnsupportedFunctionalityError({
@@ -253,6 +260,9 @@ export async function convertToBedrockChatMessages(
           const message = block.messages[j];
           const isLastMessage = j === block.messages.length - 1;
           const { content } = message;
+          const hasReasoningBlocks = content.some(
+            part => part.type === 'reasoning',
+          );
 
           for (let k = 0; k < content.length; k++) {
             const part = content[k];
@@ -260,8 +270,8 @@ export async function convertToBedrockChatMessages(
 
             switch (part.type) {
               case 'text': {
-                // Skip empty text blocks
-                if (!part.text.trim()) {
+                // Skip empty text blocks unless reasoning blocks are present
+                if (!part.text.trim() && !hasReasoningBlocks) {
                   break;
                 }
 
@@ -287,33 +297,41 @@ export async function convertToBedrockChatMessages(
                   schema: bedrockReasoningMetadataSchema,
                 });
 
-                if (reasoningMetadata != null) {
-                  if (reasoningMetadata.signature != null) {
-                    bedrockContent.push({
-                      reasoningContent: {
-                        reasoningText: {
-                          // trim the last text part if it's the last message in the block
-                          // because Bedrock does not allow trailing whitespace
-                          // in pre-filled assistant responses
-                          text: trimIfLast(
-                            isLastBlock,
-                            isLastMessage,
-                            isLastContentPart,
-                            part.text,
-                          ),
-                          signature: reasoningMetadata.signature,
-                        },
+                if (reasoningMetadata?.signature != null) {
+                  // do not trim reasoning text when a signature is present:
+                  // the signature validates the exact original bytes
+                  bedrockContent.push({
+                    reasoningContent: {
+                      reasoningText: {
+                        text: part.text,
+                        signature: reasoningMetadata.signature,
                       },
-                    });
-                  } else if (reasoningMetadata.redactedData != null) {
-                    bedrockContent.push({
-                      reasoningContent: {
-                        redactedReasoning: {
-                          data: reasoningMetadata.redactedData,
-                        },
+                    },
+                  });
+                } else if (reasoningMetadata?.redactedData != null) {
+                  bedrockContent.push({
+                    reasoningContent: {
+                      redactedReasoning: {
+                        data: reasoningMetadata.redactedData,
                       },
-                    });
-                  }
+                    },
+                  });
+                } else {
+                  // trim the last text part if it's the last message in the block
+                  // because Bedrock does not allow trailing whitespace
+                  // in pre-filled assistant responses
+                  bedrockContent.push({
+                    reasoningContent: {
+                      reasoningText: {
+                        text: trimIfLast(
+                          isLastBlock,
+                          isLastMessage,
+                          isLastContentPart,
+                          part.text,
+                        ),
+                      },
+                    },
+                  });
                 }
 
                 break;
@@ -352,12 +370,6 @@ export async function convertToBedrockChatMessages(
   return { system, messages };
 }
 
-function isBedrockImageFormat(format: string): format is BedrockImageFormat {
-  return Object.values(BEDROCK_IMAGE_MIME_TYPES).includes(
-    format as BedrockImageFormat,
-  );
-}
-
 function getBedrockImageFormat(mimeType?: string): BedrockImageFormat {
   if (!mimeType) {
     throw new UnsupportedFunctionalityError({