feat (provider/amazon-bedrock): Add reasoning support

.changeset/two-mayflies-shave.md

@@ -0,0 +1,5 @@
+---
+'@ai-sdk/amazon-bedrock': minor
+---
+
+feat (providers/amazon-bedrock): Add reasoning support to amazon-bedrock

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

@@ -316,6 +316,34 @@ console.log(
 // }
 ```
 
+## Reasoning
+
+Amazon Bedrock has reasoning support for the `claude-3-7-sonnet-20250219` model.
+
+You can enable it using the `reasoning_config` provider option and specifying a thinking budget in tokens (minimum: `1024`, maximum: `64000`).
+
+```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'),
+  prompt: 'How many people will live in the world in 2040?',
+  providerOptions: {
+    bedrock: {
+      reasoningConfig: { type: 'enabled', budgetTokens: 12000 },
+    },
+  },
+});
+
+console.log(reasoning); // reasoning text
+console.log(reasoningDetails); // reasoning details including redacted reasoning
+console.log(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.
+
 ### Model Capabilities
 
 | Model                                       | Image Input         | Object Generation   | Tool Usage          | Tool Streaming      |

examples/ai-core/src/generate-text/amazon-bedrock-reasoning-chatbot.ts

@@ -0,0 +1,58 @@
+import { bedrock } from '@ai-sdk/amazon-bedrock';
+import { CoreMessage, generateText } from 'ai';
+import 'dotenv/config';
+import * as readline from 'node:readline/promises';
+import { weatherTool } from '../tools/weather-tool';
+
+const terminal = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+const messages: CoreMessage[] = [];
+
+async function main() {
+  while (true) {
+    const userInput = await terminal.question('You: ');
+    messages.push({ role: 'user', content: userInput });
+
+    const { steps, response } = await generateText({
+      model: bedrock('us.anthropic.claude-3-7-sonnet-20250219-v1:0'),
+      tools: { weatherTool },
+      system: `You are a helpful, respectful and honest assistant.`,
+      messages,
+      maxSteps: 5,
+      providerOptions: {
+        bedrock: {
+          reasoning_config: { type: 'enabled', budget_tokens: 2048 },
+        },
+      },
+    });
+
+    for (const step of steps) {
+      console.log(step);
+      if (step.reasoning) {
+        console.log(`\x1b[36m${step.reasoning}\x1b[0m`);
+      }
+
+      if (step.text) {
+        console.log(step.text);
+      }
+
+      if (step.toolCalls) {
+        for (const toolCall of step.toolCalls) {
+          console.log(
+            `\x1b[33m${toolCall.toolName}\x1b[0m` +
+              JSON.stringify(toolCall.args),
+          );
+        }
+      }
+    }
+
+    console.log('\n');
+
+    messages.push(...response.messages);
+  }
+}
+
+main().catch(console.error);

examples/ai-core/src/generate-text/amazon-bedrock-reasoning.ts

@@ -0,0 +1,30 @@
+import { bedrock } from '@ai-sdk/amazon-bedrock';
+import { generateText } from 'ai';
+import 'dotenv/config';
+
+async function main() {
+  const result = await generateText({
+    model: bedrock('us.anthropic.claude-3-7-sonnet-20250219-v1:0'),
+    prompt: 'How many "r"s are in the word "strawberry"?',
+    temperature: 0.5, // should get ignored (warning)
+    providerOptions: {
+      bedrock: {
+        reasoning_config: { type: 'enabled', budget_tokens: 2048 },
+      },
+    },
+    maxRetries: 0,
+    maxSteps: 5,
+  });
+
+  console.log('Reasoning:');
+  console.log(result.reasoningDetails);
+  console.log();
+
+  console.log('Text:');
+  console.log(result.text);
+  console.log();
+
+  console.log('Warnings:', result.warnings);
+}
+
+main().catch(console.error);

examples/ai-core/src/stream-text/amazon-bedrock-fullstream.ts

@@ -1,5 +1,5 @@
 import { bedrock } from '@ai-sdk/amazon-bedrock';
-import { streamText } from 'ai';
+import { streamText, ToolCallPart, ToolResultPart } from 'ai';
 import 'dotenv/config';
 import { z } from 'zod';
 import { weatherTool } from '../tools/weather-tool';
@@ -14,57 +14,51 @@ async function main() {
       },
     },
     prompt: 'What is the weather in San Francisco?',
+    maxSteps: 5,
   });
 
+  let enteredReasoning = false;
+  let enteredText = false;
+  const toolCalls: ToolCallPart[] = [];
+  const toolResponses: ToolResultPart[] = [];
+
   for await (const part of result.fullStream) {
     switch (part.type) {
+      case 'reasoning': {
+        if (!enteredReasoning) {
+          enteredReasoning = true;
+          console.log('\nREASONING:\n');
+        }
+        process.stdout.write(part.textDelta);
+        break;
+      }
+
       case 'text-delta': {
-        console.log('Text delta:', part.textDelta);
+        if (!enteredText) {
+          enteredText = true;
+          console.log('\nTEXT:\n');
+        }
+        process.stdout.write(part.textDelta);
         break;
       }
 
       case 'tool-call': {
-        switch (part.toolName) {
-          case 'cityAttractions': {
-            console.log('TOOL CALL cityAttractions');
-            console.log(`city: ${part.args.city}`); // string
-            break;
-          }
-
-          case 'weather': {
-            console.log('TOOL CALL weather');
-            console.log(`location: ${part.args.location}`); // string
-            break;
-          }
-        }
+        toolCalls.push(part);
 
+        process.stdout.write(
+          `\nTool call: '${part.toolName}' ${JSON.stringify(part.args)}`,
+        );
         break;
       }
 
       case 'tool-result': {
-        switch (part.toolName) {
-          // NOT AVAILABLE (NO EXECUTE METHOD)
-          // case 'cityAttractions': {
-          //   console.log('TOOL RESULT cityAttractions');
-          //   console.log(`city: ${part.args.city}`); // string
-          //   console.log(`result: ${part.result}`);
-          //   break;
-          // }
-
-          case 'weather': {
-            console.log('TOOL RESULT weather');
-            console.log(`location: ${part.args.location}`); // string
-            console.log(`temperature: ${part.result.temperature}`); // number
-            break;
-          }
-        }
+        toolResponses.push(part);
 
+        process.stdout.write(
+          `\nTool response: '${part.toolName}' ${JSON.stringify(part.result)}`,
+        );
         break;
       }
-
-      case 'error':
-        console.error('Error:', part.error);
-        break;
     }
   }
 }

examples/ai-core/src/stream-text/amazon-bedrock-reasoning-chatbot.ts

@@ -0,0 +1,77 @@
+import { createAmazonBedrock } from '@ai-sdk/amazon-bedrock';
+import { CoreMessage, streamText, tool } from 'ai';
+import 'dotenv/config';
+import * as readline from 'node:readline/promises';
+import { z } from 'zod';
+
+const bedrock = createAmazonBedrock({
+  // example fetch wrapper that logs the input to the API call:
+  fetch: async (url, options) => {
+    console.log('URL', url);
+    console.log('Headers', JSON.stringify(options!.headers, null, 2));
+    console.log(
+      `Body ${JSON.stringify(JSON.parse(options!.body! as string), null, 2)}`,
+    );
+    return await fetch(url, options);
+  },
+});
+
+const terminal = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+const messages: CoreMessage[] = [];
+
+async function main() {
+  while (true) {
+    const userInput = await terminal.question('You: ');
+
+    messages.push({ role: 'user', content: userInput });
+
+    const result = streamText({
+      model: bedrock('us.anthropic.claude-3-7-sonnet-20250219-v1:0'),
+      messages,
+      tools: {
+        weather: tool({
+          description: 'Get the weather in a location',
+          parameters: z.object({
+            location: z
+              .string()
+              .describe('The location to get the weather for'),
+          }),
+          execute: async ({ location }) => ({
+            location,
+            temperature: 72 + Math.floor(Math.random() * 21) - 10,
+          }),
+        }),
+      },
+      maxSteps: 5,
+      maxRetries: 0,
+      providerOptions: {
+        bedrock: {
+          reasoning_config: { type: 'enabled', budget_tokens: 2048 },
+        },
+      },
+      onError: error => {
+        console.error(error);
+      },
+    });
+
+    process.stdout.write('\nAssistant: ');
+    for await (const part of result.fullStream) {
+      if (part.type === 'reasoning') {
+        process.stdout.write('\x1b[34m' + part.textDelta + '\x1b[0m');
+      } else if (part.type === 'redacted-reasoning') {
+        process.stdout.write('\x1b[31m' + '<redacted>' + '\x1b[0m');
+      } else if (part.type === 'text-delta') {
+        process.stdout.write(part.textDelta);
+      }
+    }
+    process.stdout.write('\n\n');
+
+    messages.push(...(await result.response).messages);
+  }
+}
+
+main().catch(console.error);

examples/ai-core/src/stream-text/amazon-bedrock-reasoning-fullstream.ts

@@ -0,0 +1,67 @@
+import { bedrock } from '@ai-sdk/amazon-bedrock';
+import { streamText, ToolCallPart, ToolResultPart } from 'ai';
+import 'dotenv/config';
+import { weatherTool } from '../tools/weather-tool';
+
+async function main() {
+  const result = streamText({
+    model: bedrock('us.anthropic.claude-3-7-sonnet-20250219-v1:0'),
+    tools: {
+      weather: weatherTool,
+    },
+    prompt: 'What is the weather in San Francisco?',
+    providerOptions: {
+      bedrock: {
+        reasoning_config: { type: 'enabled', budget_tokens: 12000 },
+      },
+    },
+    maxSteps: 5,
+  });
+
+  let enteredReasoning = false;
+  let enteredText = false;
+  const toolCalls: ToolCallPart[] = [];
+  const toolResponses: ToolResultPart[] = [];
+
+  for await (const part of result.fullStream) {
+    switch (part.type) {
+      case 'reasoning': {
+        if (!enteredReasoning) {
+          enteredReasoning = true;
+          console.log('\nREASONING:\n');
+        }
+        process.stdout.write(part.textDelta);
+        break;
+      }
+
+      case 'text-delta': {
+        if (!enteredText) {
+          enteredText = true;
+          console.log('\nTEXT:\n');
+        }
+        process.stdout.write(part.textDelta);
+        break;
+      }
+
+      case 'tool-call': {
+        toolCalls.push(part);
+
+        process.stdout.write(
+          `\nTool call: '${part.toolName}' ${JSON.stringify(part.args)}`,
+        );
+        break;
+      }
+
+      case 'tool-result': {
+        toolResponses.push(part);
+
+        process.stdout.write(
+          `\nTool response: '${part.toolName}' ${JSON.stringify(part.result)}`,
+        );
+        break;
+      }
+    }
+  }
+}
+
+main().catch(console.error);