@ai-sdk/amazon-bedrock 5.0.125 → 5.0.126

package/dist/mantle/index.cjs

@@ -4,7 +4,7 @@ let _ai_sdk_provider = require("@ai-sdk/provider");
 let _ai_sdk_provider_utils = require("@ai-sdk/provider-utils");
 let aws4fetch = require("aws4fetch");
 //#region src/version.ts
-const VERSION = "5.0.125";
+const VERSION = "5.0.126";
 //#endregion
 //#region src/amazon-bedrock-sigv4-fetch.ts
 /**

package/dist/mantle/index.js

@@ -3,7 +3,7 @@ import { InvalidArgumentError, NoSuchModelError } from "@ai-sdk/provider";
 import { combineHeaders, getRuntimeEnvironmentUserAgent, isValidHostnamePart, loadOptionalSetting, loadSetting, normalizeHeaders, withUserAgentSuffix, withoutTrailingSlash } from "@ai-sdk/provider-utils";
 import { AwsV4Signer } from "aws4fetch";
 //#region src/version.ts
-const VERSION = "5.0.125";
+const VERSION = "5.0.126";
 //#endregion
 //#region src/amazon-bedrock-sigv4-fetch.ts
 /**

package/docs/08-amazon-bedrock.mdx

@@ -695,12 +695,24 @@ display-only, and empty configurations also retain portable reasoning.
 
 Effort-based Anthropic models can combine portable effort with an explicit
 thinking configuration. A disabled type prevents effort/budget derivation;
-portable `reasoning: 'none'` disables thinking on Anthropic models even when an
-enabled type or budget is supplied. Omitting portable reasoning or using
-`'provider-default'` leaves the provider configuration unchanged. The legacy
+portable `reasoning: 'none'` requests disabled thinking on Anthropic models even
+when an enabled type or budget is supplied. Omitting portable reasoning or using
+`'provider-default'` uses the provider configuration. The legacy
 `bedrock` provider options key follows the same rules. See the
 [reasoning guide](/docs/ai-sdk-core/reasoning#precedence-rules) for precedence details.
 
+Both `reasoning: 'none'` and `reasoningConfig: { type: 'disabled' }` explicitly
+send `thinking: { type: 'disabled' }` for Anthropic models that support it.
+For Claude 3.5 and earlier, the provider omits `thinking` because these models
+do not support the field.
+Models that require thinking use `between_tools` when supported, or adaptive
+thinking otherwise. For the adaptive fallback, portable `reasoning: 'none'`
+uses explicit `maxReasoningEffort`, then raw `output_config.effort`, and defaults
+to low effort when neither is supplied. Unsupported disabled settings produce warnings.
+If a model rejects disabled or `between_tools`
+thinking at `xhigh` or `max` effort, the provider lowers the effort to `high`
+with a warning.
+
 ```ts
 import {
   amazonBedrock,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/amazon-bedrock",
-  "version": "5.0.125",
+  "version": "5.0.126",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -41,10 +41,10 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/anthropic": "4.0.89",
-    "@ai-sdk/openai": "4.0.103",
+    "@ai-sdk/anthropic": "4.0.90",
+    "@ai-sdk/openai": "4.0.104",
     "@ai-sdk/provider": "4.0.34",
-    "@ai-sdk/provider-utils": "5.0.69",
+    "@ai-sdk/provider-utils": "5.0.70",
     "@smithy/eventstream-codec": "^4.3.3",
     "@smithy/util-utf8": "^4.3.3",
     "aws4fetch": "^1.0.20"

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

@@ -186,6 +186,9 @@ export class AmazonBedrockChatLanguageModel implements LanguageModelV4 {
       supportsStructuredOutput: modelSupportsStructuredOutput,
       rejectsSamplingParameters,
       rejectsForcedToolUse,
+      rejectsThinkingDisabled,
+      rejectsThinkingDisabledAboveHighEffort,
+      supportsBetweenToolsThinking,
       isKnownModel,
     } = getModelCapabilities(this.modelId);
 
@@ -284,6 +287,11 @@ export class AmazonBedrockChatLanguageModel implements LanguageModelV4 {
       reasoningBudgetTokens: amazonBedrockOptions.reasoningConfig?.budgetTokens,
     });
 
+    const hasExplicitDisabledThinking =
+      amazonBedrockOptions.reasoningConfig?.type === 'disabled';
+    const explicitReasoningEffort =
+      amazonBedrockOptions.reasoningConfig?.maxReasoningEffort;
+
     amazonBedrockOptions = resolveAmazonBedrockReasoningConfig({
       reasoning,
       amazonBedrockOptions,
@@ -293,9 +301,82 @@ export class AmazonBedrockChatLanguageModel implements LanguageModelV4 {
       modelId: this.modelId,
     });
 
+    let thinkingType:
+      | 'enabled'
+      | 'disabled'
+      | 'adaptive'
+      | 'between_tools'
+      | undefined = amazonBedrockOptions.reasoningConfig?.type;
+    let maxReasoningEffort =
+      amazonBedrockOptions.reasoningConfig?.maxReasoningEffort;
+
+    if (isAnthropicModel && thinkingType === 'disabled') {
+      if (
+        /claude-(?:instant|v?2|3-(?:5-)?(?:haiku|sonnet|opus))(?=[-.:]|$)/.test(
+          this.modelId,
+        )
+      ) {
+        // Claude 3.5 and earlier do not accept a thinking field, even disabled.
+        thinkingType = undefined;
+      } else if (rejectsThinkingDisabled) {
+        thinkingType = supportsBetweenToolsThinking
+          ? 'between_tools'
+          : 'adaptive';
+
+        if (!hasExplicitDisabledThinking && thinkingType === 'adaptive') {
+          maxReasoningEffort ??= explicitReasoningEffort;
+
+          if (
+            maxReasoningEffort == null &&
+            amazonBedrockOptions.additionalModelRequestFields?.output_config
+              ?.effort == null
+          ) {
+            maxReasoningEffort = 'low';
+          }
+        }
+
+        if (hasExplicitDisabledThinking || thinkingType === 'adaptive') {
+          warnings.push({
+            type: hasExplicitDisabledThinking ? 'unsupported' : 'compatibility',
+            feature: hasExplicitDisabledThinking
+              ? 'providerOptions.amazonBedrock.reasoningConfig'
+              : 'reasoning',
+            details:
+              `thinking cannot be disabled for ${this.modelId}. ` +
+              `Using '${thinkingType}' thinking instead.`,
+          });
+        }
+      }
+
+      const effort =
+        maxReasoningEffort ??
+        amazonBedrockOptions.additionalModelRequestFields?.output_config
+          ?.effort;
+
+      if (
+        ((thinkingType === 'disabled' &&
+          rejectsThinkingDisabledAboveHighEffort) ||
+          thinkingType === 'between_tools') &&
+        (effort === 'xhigh' || effort === 'max')
+      ) {
+        warnings.push({
+          type: 'unsupported',
+          feature:
+            maxReasoningEffort != null
+              ? 'providerOptions.amazonBedrock.reasoningConfig.maxReasoningEffort'
+              : 'providerOptions.amazonBedrock.additionalModelRequestFields.output_config.effort',
+          details:
+            `effort '${effort}' is not supported by ${this.modelId} with '${thinkingType}' thinking. ` +
+            `The effort has been lowered to 'high'.`,
+        });
+        maxReasoningEffort = 'high';
+      }
+    }
+
     const isThinkingEnabled =
-      amazonBedrockOptions.reasoningConfig?.type === 'enabled' ||
-      amazonBedrockOptions.reasoningConfig?.type === 'adaptive';
+      thinkingType === 'enabled' ||
+      thinkingType === 'adaptive' ||
+      thinkingType === 'between_tools';
 
     const structuredOutputMode =
       amazonBedrockOptions.structuredOutputMode ??
@@ -407,7 +488,6 @@ export class AmazonBedrockChatLanguageModel implements LanguageModelV4 {
       };
     }
 
-    const thinkingType = amazonBedrockOptions.reasoningConfig?.type;
     const thinkingBudget =
       thinkingType === 'enabled'
         ? amazonBedrockOptions.reasoningConfig?.budgetTokens
@@ -426,7 +506,7 @@ export class AmazonBedrockChatLanguageModel implements LanguageModelV4 {
       ...(stopSequences != null && { stopSequences }),
     };
 
-    if (isAnthropicThinkingEnabled) {
+    if (isAnthropicModel) {
       if (thinkingBudget != null) {
         if (inferenceConfig.maxTokens != null) {
           inferenceConfig.maxTokens += thinkingBudget;
@@ -448,8 +528,16 @@ export class AmazonBedrockChatLanguageModel implements LanguageModelV4 {
             ...(thinkingDisplay != null && { display: thinkingDisplay }),
           },
         };
+      } else if (
+        thinkingType === 'disabled' ||
+        thinkingType === 'between_tools'
+      ) {
+        amazonBedrockOptions.additionalModelRequestFields = {
+          ...amazonBedrockOptions.additionalModelRequestFields,
+          thinking: { type: thinkingType },
+        };
       }
-    } else if (!isAnthropicModel) {
+    } else {
       if (amazonBedrockOptions.reasoningConfig?.budgetTokens != null) {
         warnings.push({
           type: 'unsupported',
@@ -468,9 +556,6 @@ export class AmazonBedrockChatLanguageModel implements LanguageModelV4 {
       }
     }
 
-    const maxReasoningEffort =
-      amazonBedrockOptions.reasoningConfig?.maxReasoningEffort;
-
     if (maxReasoningEffort != null) {
       if (isAnthropicModel) {
         amazonBedrockOptions.additionalModelRequestFields = {
@@ -1685,8 +1770,8 @@ function resolveAmazonBedrockReasoningConfig({
 
   const result = { ...amazonBedrockOptions };
 
-  // Preserve disabled thinking without deriving settings or warnings that will
-  // not be sent. Clone the configuration before removing effort and budget.
+  // Do not derive effort or budget from portable reasoning when thinking is
+  // explicitly disabled. Clone the configuration before removing those fields.
   if (reasoningConfig?.type === 'disabled') {
     result.reasoningConfig = { ...reasoningConfig };
     delete result.reasoningConfig.maxReasoningEffort;

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

@@ -173,8 +173,21 @@ export async function convertToAmazonBedrockChatMessages(
 
   let documentCounter = 0;
   const generateDocumentName = () => `document-${++documentCounter}`;
-  const getDocumentName = (filename: string | undefined) =>
-    (filename && sanitizeDocumentName(filename)) || generateDocumentName();
+  // Bedrock rejects requests that contain duplicate document names:
+  const usedDocumentNames = new Set<string>();
+  const getDocumentName = (filename: string | undefined) => {
+    const baseName =
+      (filename && sanitizeDocumentName(filename)) || generateDocumentName();
+
+    let name = baseName;
+    for (let suffix = 2; usedDocumentNames.has(name); suffix++) {
+      const suffixText = ` (${suffix})`;
+      name = `${baseName.slice(0, 200 - suffixText.length).trim()}${suffixText}`;
+    }
+
+    usedDocumentNames.add(name);
+    return name;
+  };
 
   for (let i = 0; i < blocks.length; i++) {
     const block = blocks[i];