Backport: feat(provider/bedrock): Support Nova 2 extended reasoning maxReasoningEffort field (#10846)

This is an automated backport of #10839 to the release-v5.0 branch. FYI @R-Taneja --------- Co-authored-by: Rohan Taneja <47066511+R-Taneja@users.noreply.github.com>

Author: vercel-ai-sdk[bot]

.changeset/violet-otters-compete.md

@@ -0,0 +1,5 @@
+---
+'@ai-sdk/amazon-bedrock': patch
+---
+
+feat(provider/bedrock): Support Nova 2 extended reasoning `maxReasoningEffort` field

content/providers/01-ai-sdk-providers/08-amazon-bedrock.mdx

@@ -416,16 +416,18 @@ console.log(
 
 ## Reasoning
 
-Amazon Bedrock has reasoning support for the `claude-3-7-sonnet-20250219` model.
+Amazon Bedrock supports model creator-specific reasoning features:
 
-You can enable it using the `reasoningConfig` provider option and specifying a thinking budget in tokens (minimum: `1024`, maximum: `64000`).
+- Anthropic (e.g. `claude-3-7-sonnet-20250219`): enable via the `reasoningConfig` provider option and specifying a thinking budget in tokens (minimum: `1024`, maximum: `64000`).
+- Amazon (e.g. `us.amazon.nova-2-lite-v1:0`): enable via the `reasoningConfig` provider option and specifying a maximum reasoning effort level (`'low' | 'medium' | 'high'`).
 
 ```ts
 import { bedrock } from '@ai-sdk/amazon-bedrock';
 import { generateText } from 'ai';
 
-const { text, reasoning, reasoningDetails } = await generateText({
- model: bedrock('us.anthropic.claude-3-7-sonnet-20250219-v1:0'),
+// Anthropic example
+const anthropicResult = await generateText({
+ model: bedrock('us.anthropclaude-3-7-sonnet-20250219-v1:0'),
  prompt: 'How many people will live in the world in 2040?',
  providerOptions: {
  bedrock: {
@@ -434,9 +436,22 @@ const { text, reasoning, reasoningDetails } = await generateText({
  },
 });
 
-console.log(reasoning); // reasoning text
-console.log(reasoningDetails); // reasoning details including redacted reasoning
-console.log(text); // text response
+console.log(anthropicResult.reasoning); // reasoning text
+console.log(anthropicResult.text); // text response
+
+// Nova 2 example
+const amazonResult = await generateText({
+ model: bedrock('us.amazon.nova-2-lite-v1:0'),
+ prompt: 'How many people will live in the world in 2040?',
+ providerOptions: {
+ bedrock: {
+ reasoningConfig: { type: 'enabled', maxReasoningEffort: 'medium' },
+ },
+ },
+});
+
+console.log(amazonResult.reasoning); // reasoning text
+console.log(amazonResult.text); // text response
 ```
 
 See [AI SDK UI: Chatbot](/docs/ai-sdk-ui/chatbot#reasoning) for more details

packages/amazon-bedrock/src/bedrock-chat-language-model.test.ts

@@ -82,6 +82,11 @@ const anthropicGenerateUrl = `${baseUrl}/model/${encodeURIComponent(
  anthropicModelId,
 )}/converse`;
 
+const novaModelId = 'us.amazon.nova-2-lite-v1:0';
+const novaGenerateUrl = `${baseUrl}/model/${encodeURIComponent(
+ novaModelId,
+)}/converse`;
+
 const server = createTestServer({
  [generateUrl]: {},
  [streamUrl]: {
@@ -92,6 +97,7 @@ const server = createTestServer({
  },
  // Configure the server for the Anthropic model from the start
  [anthropicGenerateUrl]: {},
+ [novaGenerateUrl]: {},
 });
 
 function prepareJsonFixtureResponse(filename: string) {
@@ -138,6 +144,13 @@ const model = new BedrockChatLanguageModel(modelId, {
  generateId: () => 'test-id',
 });
 
+const novaModel = new BedrockChatLanguageModel(novaModelId, {
+ baseUrl: () => baseUrl,
+ headers: {},
+ fetch: fakeFetchWithAuth,
+ generateId: () => 'test-id',
+});
+
 let mockOptions: { success: boolean; errorValue?: any } = { success: true };
 
 describe('doStream', () => {
@@ -2162,6 +2175,40 @@ describe('doStream', () => {
  ]
  `);
  });
+
+ it('should warn when Anthropic model receives maxReasoningEffort in stream', async () => {
+ setupMockEventStreamHandler();
+ server.urls[streamUrl].response = {
+ type: 'stream-chunks',
+ chunks: [
+ JSON.stringify({
+ messageStop: {
+ stopReason: 'stop_sequence',
+ },
+ }) + '\n',
+ ],
+ };
+
+ const result = await model.doStream({
+ prompt: TEST_PROMPT,
+ includeRawChunks: false,
+ providerOptions: {
+ bedrock: {
+ reasoningConfig: {
+ type: 'enabled',
+ maxReasoningEffort: 'medium',
+ },
+ },
+ },
+ });
+
+ await convertReadableStreamToArray(result.stream);
+
+ const requestBody = await server.calls[0].requestBodyJson;
+ expect(
+ requestBody.additionalModelRequestFields?.reasoningConfig,
+ ).toBeUndefined();
+ });
 });
 
 describe('doGenerate', () => {
@@ -2917,6 +2964,71 @@ describe('doGenerate', () => {
  });
  });
 
+ it('maps maxReasoningEffort for Nova without thinking (generate)', async () => {
+ server.urls[novaGenerateUrl].response = {
+ type: 'json-value',
+ body: {
+ output: {
+ message: { content: [{ text: 'Hello' }], role: 'assistant' },
+ },
+ stopReason: 'stop_sequence',
+ usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+ },
+ };
+
+ await novaModel.doGenerate({
+ prompt: TEST_PROMPT,
+ providerOptions: {
+ bedrock: {
+ reasoningConfig: {
+ type: 'enabled',
+ maxReasoningEffort: 'medium',
+ budgetTokens: 2048,
+ },
+ },
+ },
+ });
+
+ const requestBody = await server.calls[0].requestBodyJson;
+ expect(requestBody).toMatchObject({
+ additionalModelRequestFields: {
+ reasoningConfig: {
+ type: 'enabled',
+ maxReasoningEffort: 'medium',
+ },
+ },
+ });
+ expect(requestBody.additionalModelRequestFields?.thinking).toBeUndefined();
+ });
+
+ it('should warn when Anthropic model receives maxReasoningEffort (generate)', async () => {
+ prepareJsonResponse({});
+
+ const result = await model.doGenerate({
+ prompt: TEST_PROMPT,
+ providerOptions: {
+ bedrock: {
+ reasoningConfig: {
+ type: 'enabled',
+ maxReasoningEffort: 'medium',
+ },
+ },
+ },
+ });
+
+ const requestBody = await server.calls[0].requestBodyJson;
+ expect(
+ requestBody.additionalModelRequestFields?.reasoningConfig,
+ ).toBeUndefined();
+
+ expect(result.warnings).toContainEqual({
+ type: 'unsupported-setting',
+ setting: 'providerOptions',
+ details:
+ 'maxReasoningEffort applies only to Amazon Nova models on Bedrock and will be ignored for this model.',
+ });
+ });
+
  it('should extract reasoning text with signature', async () => {
  const reasoningText = 'I need to think about this problem carefully...';
  const signature = 'abc123signature';

packages/amazon-bedrock/src/bedrock-chat-language-model.ts

@@ -172,8 +172,11 @@ export class BedrockChatLanguageModel implements LanguageModelV2 {
  };
  }
 
- const isThinking = bedrockOptions.reasoningConfig?.type === 'enabled';
+ const isAnthropicModel = this.modelId.includes('anthropic');
+ const isThinkingRequested =
+ bedrockOptions.reasoningConfig?.type === 'enabled';
  const thinkingBudget = bedrockOptions.reasoningConfig?.budgetTokens;
+ const isAnthropicThinkingEnabled = isAnthropicModel && isThinkingRequested;
 
  const inferenceConfig = {
  ...(maxOutputTokens != null && { maxTokens: maxOutputTokens }),
@@ -183,8 +186,7 @@ export class BedrockChatLanguageModel implements LanguageModelV2 {
  ...(stopSequences != null && { stopSequences }),
  };
 
- // Adjust maxTokens if thinking is enabled
- if (isThinking && thinkingBudget != null) {
+ if (isAnthropicThinkingEnabled && thinkingBudget != null) {
  if (inferenceConfig.maxTokens != null) {
  inferenceConfig.maxTokens += thinkingBudget;
  } else {
@@ -199,10 +201,37 @@ export class BedrockChatLanguageModel implements LanguageModelV2 {
  budget_tokens: thinkingBudget,
  },
  };
+ } else if (!isAnthropicModel && thinkingBudget != null) {
+ warnings.push({
+ type: 'unsupported-setting',
+ setting: 'providerOptions',
+ details:
+ 'budgetTokens applies only to Anthropic models on Bedrock and will be ignored for this model.',
+ });
+ }
+
+ const maxReasoningEffort =
+ bedrockOptions.reasoningConfig?.maxReasoningEffort;
+ if (maxReasoningEffort != null && !isAnthropicModel) {
+ bedrockOptions.additionalModelRequestFields = {
+ ...bedrockOptions.additionalModelRequestFields,
+ reasoningConfig: {
+ ...(bedrockOptions.reasoningConfig?.type != null && {
+ type: bedrockOptions.reasoningConfig.type,
+ }),
+ maxReasoningEffort,
+ },
+ };
+ } else if (maxReasoningEffort != null && isAnthropicModel) {
+ warnings.push({
+ type: 'unsupported-setting',
+ setting: 'providerOptions',
+ details:
+ 'maxReasoningEffort applies only to Amazon Nova models on Bedrock and will be ignored for this model.',
+ });
  }
 
- // Remove temperature if thinking is enabled
- if (isThinking && inferenceConfig.temperature != null) {
+ if (isAnthropicThinkingEnabled && inferenceConfig.temperature != null) {
  delete inferenceConfig.temperature;
  warnings.push({
  type: 'unsupported-setting',
@@ -211,8 +240,7 @@ export class BedrockChatLanguageModel implements LanguageModelV2 {
  });
  }
 
- // Remove topP if thinking is enabled
- if (isThinking && inferenceConfig.topP != null) {
+ if (isAnthropicThinkingEnabled && inferenceConfig.topP != null) {
  delete inferenceConfig.topP;
  warnings.push({
  type: 'unsupported-setting',
@@ -221,7 +249,7 @@ export class BedrockChatLanguageModel implements LanguageModelV2 {
  });
  }
 
- if (isThinking && inferenceConfig.topK != null) {
+ if (isAnthropicThinkingEnabled && inferenceConfig.topK != null) {
  delete inferenceConfig.topK;
  warnings.push({
  type: 'unsupported-setting',

packages/amazon-bedrock/src/bedrock-chat-options.ts

@@ -102,6 +102,7 @@ export const bedrockProviderOptions = z.object({
  .object({
  type: z.union([z.literal('enabled'), z.literal('disabled')]).optional(),
  budgetTokens: z.number().optional(),
+ maxReasoningEffort: z.enum(['low', 'medium', 'high']).optional(),
  })
  .optional(),
  /**