Bedrock max-tokens UX: probe via inference profile, widen slider, fix layout

Issues fixed (reported by allquixotic):

1. The Detect probe failed with "on-demand throughput isn't supported" when
   the user selected an inference profile (e.g. `us.anthropic.claude-opus-4-7`).
   The probe was sending the bare base model id to AWS Bedrock. Now the probe
   uses a new `resolveBedrockInvokeTargetId` helper that mirrors the runtime's
   target resolution (system / application profile, custom ARN, or foundation
   model with optional global / cross-region prefix).

2. The Max Tokens slider was clamped to ~16K even when the model's static cap
   was much higher (e.g. Opus 4.7 at 128K). Root cause: `useSelectedModel`'s
   Bedrock branch was passing `modelMaxTokens` (the user's request-time slider
   value) to `resolveBedrockModelInfo`, which clobbered `info.maxTokens` and
   capped the slider at the user's previous selection. The webview now passes
   only `awsModelMaxOutputTokens` (the empirical Detect override) to widen the
   ceiling; the runtime path keeps applying `modelMaxTokens` for the actual
   API request via `getModelById`.

3. The "Detect max output tokens" button text was clipped by the numeric
   field. `MaxOutputTokensControl` now uses `flex-1 min-w-0` for the slider
   column and renders the provider-specific extra slot on its own line below
   the slider+input row, so wide labels can no longer be occluded by the
   text field's absolute focus border.

Bumps src/package.json to 3.53.13.

Co-Authored-By: Oz <oz-agent@warp.dev>

Author: allquixotic

packages/types/src/providers/bedrock.ts

@@ -792,6 +792,80 @@ export const usesBedrockDefault1MContext = (baseModelId?: string) =>
 	!!baseModelId &&
 	BEDROCK_1M_CONTEXT_DEFAULT_MODEL_IDS.includes(baseModelId as (typeof BEDROCK_1M_CONTEXT_DEFAULT_MODEL_IDS)[number])
 
+const getBedrockRegionPrefix = (region?: string): string | undefined => {
+	if (!region) return undefined
+	for (const [pattern, prefix] of AWS_INFERENCE_PROFILE_MAPPING) {
+		if (region.startsWith(pattern)) return prefix
+	}
+	return undefined
+}
+
+/**
+ * Returns the AWS-side target id that the Bedrock runtime would invoke against, given a
+ * provider-settings snapshot. Mirrors the resolution `AwsBedrockHandler.getModel()` does
+ * before sending a Converse command, so that callers outside the runtime (e.g. the
+ * settings-page max-tokens probe) can hit the exact same target the user's profile is
+ * configured to invoke.
+ *
+ * Resolution order:
+ *  1. `awsCustomArn` wins if present (the user provided a literal ARN).
+ *  2. If `awsBedrockTargetKind` (or the inferred kind) is an explicit profile / prompt
+ *     router selection, use `awsBedrockInvokeTarget` verbatim, stripping the synthetic
+ *     `:1m` UI suffix.
+ *  3. Otherwise we have a foundation-model selection. Apply Global Inference (`global.`)
+ *     when enabled and supported, else apply the regional cross-region inference prefix
+ *     (`us.`, `eu.`, etc.) when enabled.
+ */
+export interface ResolveBedrockInvokeTargetIdOptions {
+	awsCustomArn?: string
+	awsBedrockInvokeTarget?: string
+	awsBedrockTargetKind?: BedrockInvokeTargetKind
+	apiModelId?: string
+	awsUseGlobalInference?: boolean
+	awsUseCrossRegionInference?: boolean
+	awsRegion?: string
+}
+
+export const resolveBedrockInvokeTargetId = (options: ResolveBedrockInvokeTargetIdOptions): string => {
+	if (options.awsCustomArn) {
+		return options.awsCustomArn
+	}
+
+	const configuredTargetId = options.awsBedrockInvokeTarget || options.apiModelId || ""
+	const explicitKind = options.awsBedrockTargetKind
+	const targetKind = inferBedrockInvokeTargetKind({
+		targetId: configuredTargetId,
+		explicitKind,
+	})
+
+	if (
+		targetKind === "system-profile" ||
+		targetKind === "application-profile" ||
+		targetKind === "prompt-router" ||
+		targetKind === "custom-arn"
+	) {
+		return stripBedrock1MContextSuffix(configuredTargetId)
+	}
+
+	const baseModelId = parseBedrockBaseModelId(configuredTargetId)
+
+	if (
+		options.awsUseGlobalInference &&
+		BEDROCK_GLOBAL_INFERENCE_MODEL_IDS.includes(baseModelId as (typeof BEDROCK_GLOBAL_INFERENCE_MODEL_IDS)[number])
+	) {
+		return `global.${baseModelId}`
+	}
+
+	if (options.awsUseCrossRegionInference) {
+		const prefix = getBedrockRegionPrefix(options.awsRegion)
+		if (prefix) {
+			return `${prefix}${baseModelId}`
+		}
+	}
+
+	return baseModelId
+}
+
 export const shouldUseBedrock1MContext = ({
 	targetId,
 	baseModelId,

src/package.json

@@ -3,7 +3,7 @@
 	"displayName": "%extension.displayName%",
 	"description": "%extension.description%",
 	"publisher": "allquixotic",
-	"version": "3.53.12",
+	"version": "3.53.13",
 	"icon": "assets/icons/icon.png",
 	"galleryBanner": {
 		"color": "#617A91",

webview-ui/src/components/settings/MaxOutputTokensControl.tsx

@@ -82,29 +82,40 @@ export const MaxOutputTokensControl = ({
 
 	return (
 		<div className="flex flex-col gap-2">
+			{/*
+			 * Row 1: slider + numeric input. Slider gets `flex-1 min-w-0` so it can shrink without
+			 * pushing siblings off-screen; the number field is a fixed-width flex-shrink-0 column.
+			 */}
 			<div className="flex items-center gap-3">
-				<Slider
-					min={min}
-					max={sliderMax}
-					step={step}
-					value={[sliderValue]}
-					onValueChange={handleSliderChange}
-					disabled={disabled}
-					data-testid="max-output-tokens-slider"
-				/>
-				<div className="flex-shrink-0">
+				<div className="flex-1 min-w-0">
+					<Slider
+						min={min}
+						max={sliderMax}
+						step={step}
+						value={[sliderValue]}
+						onValueChange={handleSliderChange}
+						disabled={disabled}
+						data-testid="max-output-tokens-slider"
+					/>
+				</div>
+				<div className="flex-shrink-0" style={{ width: "10ch" }}>
 					<FormattedTextField
 						value={effectiveValue}
 						onValueChange={handleInputChange}
 						formatter={unlimitedIntegerFormatter}
 						disabled={disabled}
 						aria-label={inputAriaLabel}
-						style={{ width: "9ch" }}
+						style={{ width: "100%" }}
 						data-testid="max-output-tokens-input"
 					/>
 				</div>
-				{extraSlot}
 			</div>
+			{/*
+			 * Row 2: provider-specific actions (e.g. the Bedrock probe button). Rendered on its own
+			 * line so wide button labels can't be clipped by the absolutely-positioned focus border
+			 * of the VSCode text field above.
+			 */}
+			{extraSlot ? <div className="flex flex-wrap items-center gap-2">{extraSlot}</div> : null}
 			{helperText ? <div className="text-sm text-vscode-descriptionForeground">{helperText}</div> : null}
 		</div>
 	)

webview-ui/src/components/settings/providers/BedrockMaxTokensProbeButton.tsx

@@ -1,6 +1,6 @@
 import { useCallback, type ReactNode } from "react"
 
-import type { ProviderSettings } from "@roo-code/types"
+import { resolveBedrockInvokeTargetId, type ProviderSettings } from "@roo-code/types"
 
 import { Button, StandardTooltip } from "@src/components/ui"
 import { useAppTranslation } from "@src/i18n/TranslationContext"
@@ -16,7 +16,12 @@ interface BedrockMaxTokensProbeButtonProps {
 		value: ProviderSettings[K],
 		isUserAction?: boolean,
 	) => void
-	/** Resolved model id (may differ from `apiConfiguration.apiModelId` for inference-profile targets). */
+	/**
+	 * Optional UI hint of the resolved base model id (only used as a fallback when no AWS-side
+	 * invoke target can be derived from `apiConfiguration`). The probe always sends the actual
+	 * AWS target id (system profile, application profile, ARN, or prefixed foundation model)
+	 * computed via {@link resolveBedrockInvokeTargetId}.
+	 */
 	modelId?: string
 }
 
@@ -80,7 +85,14 @@ export const useBedrockMaxTokensProbeUi = ({
 	const { probe, isProbing, lastResult, lastError } = useBedrockMaxTokensProbe()
 
 	const onDetect = useCallback(async () => {
-		const targetModelId = modelId || apiConfiguration.apiModelId || ""
+		// Mirror the runtime's invoke-target resolution (system/application profile id,
+		// custom ARN, or foundation model with optional cross-region/global prefix) so the
+		// probe hits the same AWS target the actual chat requests would. Without this we'd
+		// send the bare base model id (e.g. `anthropic.claude-opus-4-7`) and AWS rejects
+		// it with "on-demand throughput isn't supported" for models that require an
+		// inference profile.
+		const resolvedTargetId = resolveBedrockInvokeTargetId(apiConfiguration)
+		const targetModelId = resolvedTargetId || modelId || apiConfiguration.apiModelId || ""
 		if (!targetModelId) {
 			return
 		}

webview-ui/src/components/ui/hooks/useSelectedModel.ts

@@ -188,7 +188,13 @@ function getSelectedModel({
 				baseModelId: apiConfiguration.apiModelId,
 				targetId,
 				optIn1MContext: apiConfiguration.awsBedrock1MContext,
-				modelMaxTokens: apiConfiguration.modelMaxTokens,
+				// Intentionally NOT passing `modelMaxTokens` here. That's the user's request-time
+				// slider value; passing it would clamp `info.maxTokens` to the user's current
+				// preference and prevent the slider's upper bound from showing the model's true
+				// ceiling. The runtime path (AwsBedrockHandler.getModelById) still applies it for
+				// the actual API request. The empirical detect-button override is honored via
+				// `maxOutputTokensOverride` so a user-confirmed cap widens the slider as expected.
+				maxOutputTokensOverride: apiConfiguration.awsModelMaxOutputTokens,
 				contextWindowOverride: apiConfiguration.awsModelContextWindow,
 			})
 			const displayId = apiConfiguration.apiModelId ?? resolved.baseModelId