fix(amazon-bedrock): handle empty activeTools with tool conversation history (#7600)

## background

Users integrating Amazon Bedrock with multi-step agents hit validation
errors when setting `activeTools: []` or `toolChoice: 'none'` in
conversations that previously used tools. Bedrock requires toolConfig to
be present when conversation contains tool content, but rejects empty
tools arrays.

## summary

- add placeholder tool when activeTools is empty but conversation has
tool content
- handle both `activeTools: []` and `toolChoice: 'none'` scenarios
- include helpful warning about workaround

## tasks

- [x] placeholder tool logic in bedrock-prepare-tools.ts
- [x] updated test expectations for both scenarios
- [x] warning messages for user awareness

## future work
* remove workaround if Amazon Bedrock API supports empty tools with
conversation history

related issue #7528

Author: dancer

.changeset/khaki-walls-train.md

@@ -0,0 +1,5 @@
+---
+'@ai-sdk/amazon-bedrock': patch
+---
+
+fix(amazon-bedrock): handle empty activeTools with tool conversation history

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

@@ -0,0 +1,61 @@
+import { bedrock } from '@ai-sdk/amazon-bedrock';
+import { streamText, tool, stepCountIs } from 'ai';
+import { z } from 'zod';
+import 'dotenv/config';
+
+async function main() {
+  const result = streamText({
+    model: bedrock('anthropic.claude-3-5-sonnet-20241022-v2:0'),
+    tools: {
+      weather: tool({
+        description: 'Get the weather in a location',
+        inputSchema: z.object({ city: z.string() }),
+        execute: async ({ city }) => ({
+          result: `The weather in ${city} is 20°C.`,
+        }),
+      }),
+    },
+    stopWhen: [stepCountIs(5)],
+    prepareStep: ({ stepNumber }) => {
+      if (stepNumber > 0) {
+        console.log(`Setting activeTools: [] for step ${stepNumber}`);
+        return {
+          activeTools: [],
+        };
+      }
+      return undefined;
+    },
+    toolChoice: 'auto',
+    prompt: 'What is the weather in Toronto, Calgary, and Vancouver?',
+  });
+
+  for await (const part of result.fullStream) {
+    switch (part.type) {
+      case 'start-step':
+        console.log('Step started');
+        break;
+      case 'tool-call':
+        console.log(
+          `Tool call: ${part.toolName}(${JSON.stringify(part.input)})`,
+        );
+        break;
+      case 'tool-result':
+        console.log(`Tool result: ${JSON.stringify(part.output)}`);
+        break;
+      case 'text-delta':
+        process.stdout.write(part.text);
+        break;
+      case 'finish-step':
+        console.log('Step finished');
+        break;
+      case 'finish':
+        console.log('Stream finished');
+        break;
+    }
+  }
+
+  console.log();
+  console.log('Usage:', await result.usage);
+}
+
+main().catch(console.error);

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

@@ -2091,7 +2091,7 @@ describe('doGenerate', () => {
     `);
   });
 
-  it('should include toolConfig when conversation has tool calls but no active tools', async () => {
+  it('should omit toolConfig and filter tool content when conversation has tool calls but no active tools', async () => {
     prepareJsonResponse({});
 
     const conversationWithToolCalls: LanguageModelV2Prompt = [
@@ -2130,17 +2130,39 @@ describe('doGenerate', () => {
       },
     ];
 
-    await model.doGenerate({
+    const result = await model.doGenerate({
       prompt: conversationWithToolCalls,
       tools: [],
     });
 
     const requestBody = await server.calls[0].requestBodyJson;
 
-    expect(requestBody.toolConfig).toMatchInlineSnapshot(`
-      {
-        "tools": [],
-      }
+    expect(requestBody.toolConfig).toMatchInlineSnapshot(`undefined`);
+
+    expect(requestBody.messages).toMatchInlineSnapshot(`
+      [
+        {
+          "content": [
+            {
+              "text": "What is the weather in Toronto?",
+            },
+            {
+              "text": "Now give me a summary.",
+            },
+          ],
+          "role": "user",
+        },
+      ]
+    `);
+
+    expect(result.warnings).toMatchInlineSnapshot(`
+      [
+        {
+          "details": "Tool calls and results removed from conversation because Bedrock does not support tool content without active tools.",
+          "setting": "toolContent",
+          "type": "unsupported-setting",
+        },
+      ]
     `);
   });
 
@@ -2256,7 +2278,7 @@ describe('doGenerate', () => {
     ]);
   });
 
-  it('should include toolConfig when conversation has tool calls but toolChoice is none', async () => {
+  it('should omit toolConfig when conversation has tool calls but toolChoice is none', async () => {
     prepareJsonResponse({});
 
     const conversationWithToolCalls: LanguageModelV2Prompt = [
@@ -2315,10 +2337,6 @@ describe('doGenerate', () => {
 
     const requestBody = await server.calls[0].requestBodyJson;
 
-    expect(requestBody.toolConfig).toMatchInlineSnapshot(`
-      {
-        "tools": [],
-      }
-    `);
+    expect(requestBody.toolConfig).toMatchInlineSnapshot(`undefined`);
   });
 });

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

@@ -143,8 +143,6 @@ export class BedrockChatLanguageModel implements LanguageModelV2 {
           }
         : undefined;
 
-    const { system, messages } = await convertToBedrockChatMessages(prompt);
-
     const isThinking = bedrockOptions.reasoningConfig?.type === 'enabled';
     const thinkingBudget = bedrockOptions.reasoningConfig?.budgetTokens;
 
@@ -193,13 +191,57 @@ export class BedrockChatLanguageModel implements LanguageModelV2 {
       });
     }
 
+    // Filter tool content from prompt when no tools are available
+    const activeTools =
+      jsonResponseTool != null ? [jsonResponseTool] : (tools ?? []);
+    let filteredPrompt = prompt;
+
+    if (activeTools.length === 0) {
+      const hasToolContent = prompt.some(
+        message =>
+          'content' in message &&
+          Array.isArray(message.content) &&
+          message.content.some(
+            part => part.type === 'tool-call' || part.type === 'tool-result',
+          ),
+      );
+
+      if (hasToolContent) {
+        filteredPrompt = prompt
+          .map(message =>
+            message.role === 'system'
+              ? message
+              : {
+                  ...message,
+                  content: message.content.filter(
+                    part =>
+                      part.type !== 'tool-call' && part.type !== 'tool-result',
+                  ),
+                },
+          )
+          .filter(
+            message => message.role === 'system' || message.content.length > 0,
+          ) as typeof prompt;
+
+        warnings.push({
+          type: 'unsupported-setting',
+          setting: 'toolContent',
+          details:
+            'Tool calls and results removed from conversation because Bedrock does not support tool content without active tools.',
+        });
+      }
+    }
+
+    const { system, messages } =
+      await convertToBedrockChatMessages(filteredPrompt);
+
     const { toolConfig, toolWarnings } = prepareTools({
-      tools: jsonResponseTool != null ? [jsonResponseTool] : (tools ?? []),
+      tools: activeTools,
       toolChoice:
         jsonResponseTool != null
           ? { type: 'tool', toolName: jsonResponseTool.name }
           : toolChoice,
-      prompt,
+      prompt: filteredPrompt,
     });
 
     // Filter out reasoningConfig from providerOptions.bedrock to prevent sending it to Bedrock API

packages/amazon-bedrock/src/bedrock-prepare-tools.ts

@@ -9,7 +9,6 @@ import { BedrockTool, BedrockToolConfiguration } from './bedrock-api-types';
 
 /**
  * Check if the conversation contains any tool calls or tool results.
- * Bedrock requires toolConfig to be present when messages contain toolUse or toolResult blocks.
  */
 function promptContainsToolContent(prompt: LanguageModelV2Prompt): boolean {
   return prompt.some(message => {
@@ -39,9 +38,11 @@ export function prepareTools({
   const hasToolContent = promptContainsToolContent(prompt);
 
   if (tools == null) {
+    // When no tools are provided, completely omit toolConfig from the request.
+    // This works regardless of conversation history - Bedrock handles it gracefully.
     return {
       toolConfig: {
-        tools: hasToolContent ? [] : undefined,
+        tools: undefined,
         toolChoice: undefined,
       },
       toolWarnings: [],
@@ -88,11 +89,11 @@ export function prepareTools({
         toolWarnings,
       };
     case 'none':
-      // Bedrock does not support 'none' tool choice, so we remove the tools.
-      // However, if conversation contains tool content, we need empty tools array for API.
+      // Bedrock does not support 'none' tool choice, so we omit toolConfig entirely.
+      // This works regardless of conversation history - Bedrock handles it gracefully.
       return {
         toolConfig: {
-          tools: hasToolContent ? [] : undefined,
+          tools: undefined,
           toolChoice: undefined,
         },
         toolWarnings,