refactor(config): rename prioritize-model-mappings to force-model-mappings

config.example.yaml

@@ -134,6 +134,8 @@ ws-auth: false
 #   upstream-api-key: ""
 #   # Restrict Amp management routes (/api/auth, /api/user, etc.) to localhost only (recommended)
 #   restrict-management-to-localhost: true
+#   # Force model mappings to run before checking local API keys (default: false)
+#   force-model-mappings: false
 #   # Amp Model Mappings
 #   # Route unavailable Amp models to alternative models available in your local proxy.
 #   # Useful when Amp CLI requests models you don't have access to (e.g., Claude Opus 4.5)

internal/api/handlers/management/config_basic.go

@@ -242,10 +242,10 @@ func (h *Handler) DeleteProxyURL(c *gin.Context) {
 	h.persist(c)
 }
 
-// Prioritize Model Mappings (for Amp CLI)
-func (h *Handler) GetPrioritizeModelMappings(c *gin.Context) {
-	c.JSON(200, gin.H{"prioritize-model-mappings": h.cfg.AmpCode.PrioritizeModelMappings})
+// Force Model Mappings (for Amp CLI)
+func (h *Handler) GetForceModelMappings(c *gin.Context) {
+	c.JSON(200, gin.H{"force-model-mappings": h.cfg.AmpCode.ForceModelMappings})
 }
-func (h *Handler) PutPrioritizeModelMappings(c *gin.Context) {
-	h.updateBoolField(c, func(v bool) { h.cfg.AmpCode.PrioritizeModelMappings = v })
+func (h *Handler) PutForceModelMappings(c *gin.Context) {
+	h.updateBoolField(c, func(v bool) { h.cfg.AmpCode.ForceModelMappings = v })
 }

internal/api/modules/amp/amp.go

@@ -100,14 +100,14 @@ func (m *AmpModule) Name() string {
 	return "amp-routing"
 }
 
-// getPrioritizeModelMappings returns whether model mappings should take precedence over local API keys
-func (m *AmpModule) getPrioritizeModelMappings() bool {
+// forceModelMappings returns whether model mappings should take precedence over local API keys
+func (m *AmpModule) forceModelMappings() bool {
 	m.configMu.RLock()
 	defer m.configMu.RUnlock()
 	if m.lastConfig == nil {
 		return false
 	}
-	return m.lastConfig.PrioritizeModelMappings
+	return m.lastConfig.ForceModelMappings
 }
 
 // Register sets up Amp routes if configured.

internal/api/modules/amp/fallback_handlers.go

@@ -77,29 +77,29 @@ func logAmpRouting(routeType AmpRouteType, requestedModel, resolvedModel, provid
 // FallbackHandler wraps a standard handler with fallback logic to ampcode.com
 // when the model's provider is not available in CLIProxyAPI
 type FallbackHandler struct {
-	getProxy                   func() *httputil.ReverseProxy
-	modelMapper                ModelMapper
-	getPrioritizeModelMappings func() bool
+	getProxy           func() *httputil.ReverseProxy
+	modelMapper        ModelMapper
+	forceModelMappings func() bool
 }
 
 // NewFallbackHandler creates a new fallback handler wrapper
 // The getProxy function allows lazy evaluation of the proxy (useful when proxy is created after routes)
 func NewFallbackHandler(getProxy func() *httputil.ReverseProxy) *FallbackHandler {
 	return &FallbackHandler{
-		getProxy:                   getProxy,
-		getPrioritizeModelMappings: func() bool { return false },
+		getProxy:           getProxy,
+		forceModelMappings: func() bool { return false },
 	}
 }
 
 // NewFallbackHandlerWithMapper creates a new fallback handler with model mapping support
-func NewFallbackHandlerWithMapper(getProxy func() *httputil.ReverseProxy, mapper ModelMapper, getPrioritize func() bool) *FallbackHandler {
-	if getPrioritize == nil {
-		getPrioritize = func() bool { return false }
+func NewFallbackHandlerWithMapper(getProxy func() *httputil.ReverseProxy, mapper ModelMapper, forceModelMappings func() bool) *FallbackHandler {
+	if forceModelMappings == nil {
+		forceModelMappings = func() bool { return false }
 	}
 	return &FallbackHandler{
-		getProxy:                   getProxy,
-		modelMapper:                mapper,
-		getPrioritizeModelMappings: getPrioritize,
+		getProxy:           getProxy,
+		modelMapper:        mapper,
+		forceModelMappings: forceModelMappings,
 	}
 }
 
@@ -141,11 +141,11 @@ func (fh *FallbackHandler) WrapHandler(handler gin.HandlerFunc) gin.HandlerFunc
 		usedMapping := false
 		var providers []string
 
-		// Check if model mappings should take priority over local API keys
-		prioritizeMappings := fh.getPrioritizeModelMappings != nil && fh.getPrioritizeModelMappings()
+		// Check if model mappings should be forced ahead of local API keys
+		forceMappings := fh.forceModelMappings != nil && fh.forceModelMappings()
 
-		if prioritizeMappings {
-			// PRIORITY MODE: Check model mappings FIRST (takes precedence over local API keys)
+		if forceMappings {
+			// FORCE MODE: Check model mappings FIRST (takes precedence over local API keys)
 			// This allows users to route Amp requests to their preferred OAuth providers
 			if fh.modelMapper != nil {
 				if mappedModel := fh.modelMapper.MapModel(normalizedModel); mappedModel != "" {

internal/api/modules/amp/routes.go

@@ -171,7 +171,7 @@ func (m *AmpModule) registerManagementRoutes(engine *gin.Engine, baseHandler *ha
 	geminiBridge := createGeminiBridgeHandler(geminiHandlers.GeminiHandler)
 	geminiV1Beta1Fallback := NewFallbackHandlerWithMapper(func() *httputil.ReverseProxy {
 		return m.getProxy()
-	}, m.modelMapper, m.getPrioritizeModelMappings)
+	}, m.modelMapper, m.forceModelMappings)
 	geminiV1Beta1Handler := geminiV1Beta1Fallback.WrapHandler(geminiBridge)
 
 	// Route POST model calls through Gemini bridge with FallbackHandler.
@@ -209,7 +209,7 @@ func (m *AmpModule) registerProviderAliases(engine *gin.Engine, baseHandler *han
 	// Also includes model mapping support for routing unavailable models to alternatives
 	fallbackHandler := NewFallbackHandlerWithMapper(func() *httputil.ReverseProxy {
 		return m.getProxy()
-	}, m.modelMapper, m.getPrioritizeModelMappings)
+	}, m.modelMapper, m.forceModelMappings)
 
 	// Provider-specific routes under /api/provider/:provider
 	ampProviders := engine.Group("/api/provider")

internal/api/server.go

@@ -520,9 +520,9 @@ func (s *Server) registerManagementRoutes() {
 		mgmt.PUT("/ws-auth", s.mgmt.PutWebsocketAuth)
 		mgmt.PATCH("/ws-auth", s.mgmt.PutWebsocketAuth)
 
-		mgmt.GET("/prioritize-model-mappings", s.mgmt.GetPrioritizeModelMappings)
-		mgmt.PUT("/prioritize-model-mappings", s.mgmt.PutPrioritizeModelMappings)
-		mgmt.PATCH("/prioritize-model-mappings", s.mgmt.PutPrioritizeModelMappings)
+		mgmt.GET("/force-model-mappings", s.mgmt.GetForceModelMappings)
+		mgmt.PUT("/force-model-mappings", s.mgmt.PutForceModelMappings)
+		mgmt.PATCH("/force-model-mappings", s.mgmt.PutForceModelMappings)
 
 		mgmt.GET("/request-retry", s.mgmt.GetRequestRetry)
 		mgmt.PUT("/request-retry", s.mgmt.PutRequestRetry)

internal/config/config.go

@@ -144,9 +144,9 @@ type AmpCode struct {
 	// allow routing to an alternative model that IS available.
 	ModelMappings []AmpModelMapping `yaml:"model-mappings" json:"model-mappings"`
 
-	// PrioritizeModelMappings when true, model mappings take precedence over local API keys.
+	// ForceModelMappings when true, model mappings take precedence over local API keys.
 	// When false (default), local API keys are used first if available.
-	PrioritizeModelMappings bool `yaml:"prioritize-model-mappings" json:"prioritize-model-mappings"`
+	ForceModelMappings bool `yaml:"force-model-mappings" json:"force-model-mappings"`
 }
 
 // PayloadConfig defines default and override parameter rules applied to provider payloads.