coder · evgeniy-scherbina · Sep 11, 2026 · Sep 8, 2026 · Sep 8, 2026 · Sep 8, 2026
diff --git a/aibridge/config/config.go b/aibridge/config/config.go
@@ -69,6 +69,12 @@ type AWSBedrock struct {
 	// Protocol selects the Bedrock wire protocol. The zero value behaves as
 	// BedrockProtocolInvokeModel.
 	Protocol BedrockProtocol
+	// ResolvedModel is the model ID behind Model, which differs from it only
+	// when Model is an application inference profile ARN. coderd resolves it
+	// when the provider is written, so the gateway never calls AWS for it.
+	ResolvedModel string
+	// ResolvedSmallFastModel is ResolvedModel for SmallFastModel.
+	ResolvedSmallFastModel string
 }
 
 // ResolvedProtocol returns the configured protocol, mapping the empty value to
@@ -81,6 +87,20 @@ func (c AWSBedrock) ResolvedProtocol() BedrockProtocol {
 	return c.Protocol
 }
 
+func (c AWSBedrock) ResolvedModelWithFallback() string {
+	if c.ResolvedModel != "" {
+		return c.ResolvedModel
+	}
+	return c.Model
+}
+
+func (c AWSBedrock) ResolvedSmallFastModelWithFallback() string {
+	if c.ResolvedSmallFastModel != "" {
+		return c.ResolvedSmallFastModel
+	}
+	return c.SmallFastModel
+}
+
 // Validate verifies protocol-specific Bedrock configuration.
 func (c AWSBedrock) Validate() error {
 	switch c.ResolvedProtocol() {

diff --git a/aibridge/intercept/messages/base.go b/aibridge/intercept/messages/base.go
@@ -72,22 +72,13 @@ var bedrockSupportedBetaFlags = map[string]bool{
 type BedrockRuntime struct {
 	Cfg   aibconfig.AWSBedrock
 	Creds aws.CredentialsProvider
-
-	resolvedModel          string
-	resolvedSmallFastModel string
 }
 
-// NewBedrockRuntime bundles the Bedrock config and credentials with the model
-// IDs behind the configured identifiers. The resolved IDs differ from the
-// configured ones only when those are application inference profile ARNs, which
-// are opaque and must be resolved through AWS; every other identifier resolves
-// to itself.
-func NewBedrockRuntime(cfg aibconfig.AWSBedrock, creds aws.CredentialsProvider, resolvedModel, resolvedSmallFastModel string) *BedrockRuntime {
+// NewBedrockRuntime bundles the Bedrock config and credentials.
+func NewBedrockRuntime(cfg aibconfig.AWSBedrock, creds aws.CredentialsProvider) *BedrockRuntime {
 	return &BedrockRuntime{
-		Cfg:                    cfg,
-		Creds:                  creds,
-		resolvedModel:          resolvedModel,
-		resolvedSmallFastModel: resolvedSmallFastModel,
+		Cfg:   cfg,
+		Creds: creds,
 	}
 }
 
@@ -108,13 +99,13 @@ func (b *BedrockRuntime) ConfiguredSmallFastModel() string {
 // Model capabilities, usage records, pricing, and metrics all key off this
 // rather than the configured identifier.
 func (b *BedrockRuntime) ResolvedModel() string {
-	return b.resolvedModel
+	return b.Cfg.ResolvedModelWithFallback()
 }
 
 // ResolvedSmallFastModel is [BedrockRuntime.ResolvedModel] for the small/fast
 // model.
 func (b *BedrockRuntime) ResolvedSmallFastModel() string {
-	return b.resolvedSmallFastModel
+	return b.Cfg.ResolvedSmallFastModelWithFallback()
 }
 
 type interceptionBase struct {

diff --git a/aibridge/intercept/messages/base_internal_test.go b/aibridge/intercept/messages/base_internal_test.go
@@ -179,7 +179,7 @@ func TestAWSBedrockValidation(t *testing.T) {
 			t.Parallel()
 
 			base := &interceptionBase{
-				bedrock: NewBedrockRuntime(tt.cfg, credentials.NewStaticCredentialsProvider("test-key", "test-secret", ""), "", ""),
+				bedrock: NewBedrockRuntime(tt.cfg, credentials.NewStaticCredentialsProvider("test-key", "test-secret", "")),
 			}
 			opts, err := base.withBedrockInvokeModelOptions(context.Background())
 
@@ -217,9 +217,11 @@ func TestModelForBedrockInvokeModel(t *testing.T) {
 	)
 
 	runtime := NewBedrockRuntime(config.AWSBedrock{
-		Model:          profileARN,
-		SmallFastModel: smallFastProfileARN,
-	}, nil, "anthropic.claude-opus-4-8", "anthropic.claude-haiku-4-5")
+		Model:                  profileARN,
+		SmallFastModel:         smallFastProfileARN,
+		ResolvedModel:          "anthropic.claude-opus-4-8",
+		ResolvedSmallFastModel: "anthropic.claude-haiku-4-5",
+	}, nil)
 
 	tests := []struct {
 		name             string
@@ -274,9 +276,11 @@ func TestSmallFastModelCapturedAtConstruction(t *testing.T) {
 	)
 
 	runtime := NewBedrockRuntime(config.AWSBedrock{
-		Model:          profileARN,
-		SmallFastModel: smallFastProfileARN,
-	}, nil, "anthropic.claude-opus-4-8", "anthropic.claude-haiku-4-5")
+		Model:                  profileARN,
+		SmallFastModel:         smallFastProfileARN,
+		ResolvedModel:          "anthropic.claude-opus-4-8",
+		ResolvedSmallFastModel: "anthropic.claude-haiku-4-5",
+	}, nil)
 
 	const haikuPayload = `{"model":"claude-haiku-4-5","max_tokens":10000}`
 	const opusPayload = `{"model":"claude-opus-4-8","max_tokens":10000}`
@@ -336,7 +340,7 @@ func TestModelForPlainBedrockModelID(t *testing.T) {
 		bedrock: NewBedrockRuntime(config.AWSBedrock{
 			Model:          "eu.anthropic.claude-opus-4-8",
 			SmallFastModel: "anthropic.claude-haiku-4-5",
-		}, nil, "eu.anthropic.claude-opus-4-8", "anthropic.claude-haiku-4-5"),
+		}, nil),
 		logger: slog.Make(),
 	}
 
@@ -958,18 +962,14 @@ func TestAugmentRequestForBedrock_AdaptiveThinking(t *testing.T) {
 			}
 
 			// Plain model IDs resolve to themselves; an application inference
-			// profile ARN resolves to the model behind it.
-			resolvedModel := tc.resolvedModel
-			if resolvedModel == "" {
-				resolvedModel = tc.bedrockModel
-			}
-
 			i := &interceptionBase{
 				reqPayload: mustMessagesPayload(t, tc.requestBody),
 				bedrock: NewBedrockRuntime(config.AWSBedrock{
-					Model:          tc.bedrockModel,
-					SmallFastModel: "anthropic.claude-haiku-3-5",
-				}, nil, resolvedModel, "anthropic.claude-haiku-3-5"),
+					Model:                  tc.bedrockModel,
+					SmallFastModel:         "anthropic.claude-haiku-3-5",
+					ResolvedModel:          tc.resolvedModel,
+					ResolvedSmallFastModel: "anthropic.claude-haiku-3-5",
+				}, nil),
 				clientHeaders: clientHeaders,
 				logger:        slog.Make(),
 			}
@@ -1322,7 +1322,7 @@ func TestBedrockMantleIsPassthrough(t *testing.T) {
 			Region:   "us-east-1",
 			BaseURL:  "https://bedrock-mantle.us-east-1.api.aws/anthropic",
 			Protocol: config.BedrockProtocolMantle,
-		}, credentials.NewStaticCredentialsProvider("test-key", "test-secret", ""), "", ""),
+		}, credentials.NewStaticCredentialsProvider("test-key", "test-secret", "")),
 		logger: slog.Make(),
 	}
 
@@ -1373,7 +1373,7 @@ func TestAWSMantleOptionsValidation(t *testing.T) {
 			t.Parallel()
 
 			base := &interceptionBase{
-				bedrock: NewBedrockRuntime(tt.cfg, credentials.NewStaticCredentialsProvider("test-key", "test-secret", ""), "", ""),
+				bedrock: NewBedrockRuntime(tt.cfg, credentials.NewStaticCredentialsProvider("test-key", "test-secret", "")),
 			}
 			opts, err := base.withBedrockMantleOptions(t.Context())
 			if tt.errorMsg != "" {

diff --git a/aibridge/provider/anthropic.go b/aibridge/provider/anthropic.go
@@ -83,16 +83,7 @@ func NewAnthropic(ctx context.Context, cfg config.Anthropic, bedrockCfg *config.
 			return nil, xerrors.Errorf("bedrock config: %w", err)
 		}
 
-		// Resolution only calls AWS for application inference profile ARNs, so
-		// deployments configured with plain model IDs need no extra permission.
-		resolveCtx, cancel := context.WithTimeout(ctx, inferenceProfileResolutionTimeout)
-		defer cancel()
-		model, smallFastModel, err := resolveBedrockModels(resolveCtx, runtimeCfg, awsCfg)
-		if err != nil {
-			return nil, xerrors.Errorf("resolve bedrock models: %w", err)
-		}
-
-		bedrock = messages.NewBedrockRuntime(runtimeCfg, awsCfg.Credentials, model, smallFastModel)
+		bedrock = messages.NewBedrockRuntime(runtimeCfg, awsCfg.Credentials)
 	}
 
 	return &Anthropic{

diff --git a/aibridge/provider/bedrock_inference_profile.go b/aibridge/provider/bedrock_inference_profile.go
@@ -88,25 +88,42 @@ func modelIDFromARN(modelARN string) (string, error) {
 	return model, nil
 }
 
-// resolveBedrockModels resolves the configured model identifiers to the model
-// IDs used for capability detection, usage recording, and pricing. Identifiers
-// that are not application inference profile ARNs are returned unchanged and
-// cost no AWS call.
-func resolveBedrockModels(ctx context.Context, cfg config.AWSBedrock, awsCfg aws.Config) (model, smallFastModel string, err error) {
-	resolveOne := func(configured string) (string, error) {
-		if !isApplicationInferenceProfileARN(configured) {
-			return configured, nil
+// ResolveBedrockModels resolves the application inference profile ARNs among
+// the configured model identifiers, returning what each ARN refers to. The
+// result is empty when neither identifier is an ARN, which costs no AWS call.
+//
+// The identity comes from cfg, including any role assumed via config.AWSBedrock.RoleARN,
+// so the required bedrock:GetInferenceProfile permission belongs to that identity.
+func ResolveBedrockModels(ctx context.Context, cfg config.AWSBedrock) (map[string]string, error) {
+	resolved := make(map[string]string, 2)
+
+	var profiles []string
+	for _, configured := range []string{cfg.Model, cfg.SmallFastModel} {
+		if isApplicationInferenceProfileARN(configured) {
+			profiles = append(profiles, configured)
 		}
-		return resolveInferenceProfile(ctx, awsCfg, configured)
+	}
+	if len(profiles) == 0 {
+		return resolved, nil
 	}
 
-	model, err = resolveOne(cfg.Model)
+	awsCfg, err := buildBedrockCredentials(ctx, cfg)
 	if err != nil {
-		return "", "", xerrors.Errorf("resolve model: %w", err)
+		return nil, xerrors.Errorf("build bedrock credentials: %w", err)
 	}
-	smallFastModel, err = resolveOne(cfg.SmallFastModel)
-	if err != nil {
-		return "", "", xerrors.Errorf("resolve small fast model: %w", err)
+
+	resolveCtx, cancel := context.WithTimeout(ctx, inferenceProfileResolutionTimeout)
+	defer cancel()
+
+	for _, profileARN := range profiles {
+		if _, ok := resolved[profileARN]; ok {
+			continue
+		}
+		model, err := resolveInferenceProfile(resolveCtx, awsCfg, profileARN)
+		if err != nil {
+			return nil, err
+		}
+		resolved[profileARN] = model
 	}
-	return model, smallFastModel, nil
+	return resolved, nil
 }