@ai-sdk/amazon-bedrock 5.0.105 → 5.0.107

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # @ai-sdk/amazon-bedrock
 
+## 5.0.107
+
+### Patch Changes
+
+- 268225c: feat(provider): add a portable `max` reasoning level with native provider mappings, compatibility coercions, and budget-based fallback support.
+
+  Compatibility notes:
+
+  - **TypeScript source compatibility:** Adding `max` widens `LanguageModelV4CallOptions['reasoning']` and the derived `ReasoningLevel` type. Third-party providers and consumers with exhaustive switches or `Record<ReasoningLevel, ...>` mappings must handle `max` before upgrading. Ordinary calls using existing reasoning levels remain accepted.
+  - **Amazon Bedrock:** Existing Nova 2 calls using portable `reasoning: 'xhigh'` now send `maxReasoningEffort: 'high'` instead of the unsupported `'max'`, and return a compatibility warning. Anthropic and OpenAI Bedrock effort mappings retain their existing `xhigh` behavior. Partial Bedrock reasoning configurations continue to preserve explicit values and derive missing fields; explicit effort/budget overrides and disabled thinking no longer emit warnings for portable mappings that are not sent.
+  - **Fireworks:** Existing portable `minimal` and `xhigh` calls keep their request mappings to `low` and `high`, respectively, and now return compatibility warnings in generation and streaming results. Portable `max` maps to `high` with the same warning behavior.
+
+  **Release classification:** This remains a patch changeset under the repository's explicit release policy, which uses patch releases for both fixes and features. The TypeScript source-compatibility caveat for exhaustive consumers is disclosed above. Maintainers can override this classification with a `major` label if they decide to align the provider-spec addition with a future AI SDK major release.
+
+- Updated dependencies [fc1e19e]
+- Updated dependencies [5094ebd]
+- Updated dependencies [99bdcd2]
+- Updated dependencies [268225c]
+- Updated dependencies [0af2f7c]
+  - @ai-sdk/provider-utils@5.0.55
+  - @ai-sdk/openai@4.0.85
+  - @ai-sdk/anthropic@4.0.73
+  - @ai-sdk/provider@4.0.23
+
+## 5.0.106
+
+### Patch Changes
+
+- Updated dependencies [2959d35]
+- Updated dependencies [b5dfea1]
+- Updated dependencies [686cca9]
+- Updated dependencies [5b8e63b]
+- Updated dependencies [59116e6]
+  - @ai-sdk/provider@4.0.22
+  - @ai-sdk/provider-utils@5.0.54
+  - @ai-sdk/openai@4.0.84
+  - @ai-sdk/anthropic@4.0.72
+
 ## 5.0.105
 
 ### Patch Changes

package/dist/anthropic/index.js

@@ -6,7 +6,7 @@ import { z } from "zod/v4";
 import { EventStreamCodec } from "@smithy/eventstream-codec";
 import { fromUtf8, toUtf8 } from "@smithy/util-utf8";
 //#region src/version.ts
-const VERSION = "5.0.105";
+const VERSION = "5.0.107";
 //#endregion
 //#region src/amazon-bedrock-sigv4-fetch.ts
 /**

package/dist/index.js

@@ -1882,54 +1882,71 @@ const amazonBedrockReasoningEffortMap = {
 	low: "low",
 	medium: "medium",
 	high: "high",
-	xhigh: "max"
+	xhigh: "max",
+	max: "max"
+};
+const amazonNovaReasoningEffortMap = {
+	minimal: "low",
+	low: "low",
+	medium: "medium",
+	high: "high",
+	xhigh: "high",
+	max: "high"
 };
 function isNova2ReasoningModel(modelId) {
 	return modelId.includes("amazon.nova-2-lite-v1:0");
 }
 function resolveAmazonBedrockReasoningConfig({ reasoning, amazonBedrockOptions, warnings, isAnthropicModel, isOpenAIModel, modelId }) {
+	const reasoningConfig = amazonBedrockOptions.reasoningConfig;
 	if (!isCustomReasoning(reasoning)) return amazonBedrockOptions;
 	const result = { ...amazonBedrockOptions };
+	if (reasoningConfig?.type === "disabled") {
+		result.reasoningConfig = { ...reasoningConfig };
+		delete result.reasoningConfig.maxReasoningEffort;
+		delete result.reasoningConfig.budgetTokens;
+		return result;
+	}
 	const hasPortableReasoning = reasoning !== "none";
-	const hasExplicitReasoningConfig = amazonBedrockOptions.reasoningConfig != null;
 	const isNovaReasoningModel = isNova2ReasoningModel(modelId);
-	const supportsPortableReasoning = isOpenAIModel || isNovaReasoningModel;
+	const supportsPortableReasoning = isOpenAIModel || isNovaReasoningModel || reasoningConfig != null;
 	if (isAnthropicModel) {
 		const capabilities = getModelCapabilities(modelId);
 		if (reasoning === "none") result.reasoningConfig = { type: "disabled" };
-		else if (capabilities.supportsAdaptiveThinking) result.reasoningConfig = {
-			type: "adaptive",
-			maxReasoningEffort: mapReasoningToProviderEffort({
+		else if (capabilities.supportsAdaptiveThinking) {
+			const effort = reasoningConfig?.maxReasoningEffort ?? mapReasoningToProviderEffort({
 				reasoning,
 				effortMap: amazonBedrockReasoningEffortMap,
 				warnings
-			}),
-			...amazonBedrockOptions.reasoningConfig
-		};
-		else {
-			const budgetTokens = mapReasoningToProviderBudget({
+			});
+			result.reasoningConfig = {
+				...reasoningConfig,
+				type: reasoningConfig?.type ?? "adaptive",
+				maxReasoningEffort: effort
+			};
+		} else {
+			const budgetTokens = reasoningConfig?.budgetTokens ?? mapReasoningToProviderBudget({
 				reasoning,
 				maxOutputTokens: capabilities.maxOutputTokens,
 				maxReasoningBudget: capabilities.maxOutputTokens,
 				warnings
 			});
 			if (budgetTokens != null) result.reasoningConfig = {
-				type: "enabled",
-				budgetTokens,
-				...amazonBedrockOptions.reasoningConfig
+				...reasoningConfig,
+				type: reasoningConfig?.type ?? "enabled",
+				budgetTokens
 			};
 		}
 	} else if (hasPortableReasoning) {
-		if (supportsPortableReasoning || hasExplicitReasoningConfig) {
-			const effort = mapReasoningToProviderEffort({
+		if (supportsPortableReasoning) {
+			const effort = reasoningConfig?.maxReasoningEffort ?? mapReasoningToProviderEffort({
 				reasoning,
-				effortMap: amazonBedrockReasoningEffortMap,
+				effortMap: isNovaReasoningModel ? amazonNovaReasoningEffortMap : amazonBedrockReasoningEffortMap,
 				warnings
 			});
 			result.reasoningConfig = {
-				...isNovaReasoningModel && { type: "enabled" },
-				maxReasoningEffort: effort,
-				...amazonBedrockOptions.reasoningConfig
+				...reasoningConfig,
+				...isNovaReasoningModel && { type: reasoningConfig?.type ?? "enabled" },
+				maxReasoningEffort: effort
 			};
 		} else warnings.push({
 			type: "unsupported",
@@ -1937,10 +1954,6 @@ function resolveAmazonBedrockReasoningConfig({ reasoning, amazonBedrockOptions,
 			details: "Portable reasoning is not supported for this model and will be ignored. If the model supports a provider-specific reasoning configuration, use providerOptions.amazonBedrock.reasoningConfig."
 		});
 	}
-	if (result.reasoningConfig?.type === "disabled") {
-		delete result.reasoningConfig.maxReasoningEffort;
-		delete result.reasoningConfig.budgetTokens;
-	}
 	return result;
 }
 //#endregion
@@ -2329,7 +2342,7 @@ const amazonBedrockImageResponseSchema = z.object({
 });
 //#endregion
 //#region src/version.ts
-const VERSION = "5.0.105";
+const VERSION = "5.0.107";
 //#endregion
 //#region src/amazon-bedrock-sigv4-fetch.ts
 /**