krisyotam/proxy

config.example.yaml+33−29

 #     headers:
 #       X-Custom-Header: "custom-value"
 #     models:                                     # optional: map aliases to upstream model names
-#       - name: "gemini-2.0-flash"                # upstream model name
+#       - name: "gemini-2.5-flash"                # upstream model name
 #         alias: "vertex-flash"                   # client-visible alias
-#       - name: "gemini-1.5-pro"
+#       - name: "gemini-2.5-pro"
 #         alias: "vertex-pro"
 # Amp Integration
 #   # Useful when Amp CLI requests models you don't have access to (e.g., Claude Opus 4.5)
 #   # but you have a similar model available (e.g., Claude Sonnet 4).
 #   model-mappings:
-#     - from: "claude-opus-4.5"       # Model requested by Amp CLI
+#     - from: "claude-opus-4-5-20251101"          # Model requested by Amp CLI
-#       to: "claude-sonnet-4"         # Route to this available model instead
+#       to: "gemini-claude-opus-4-5-thinking"     # Route to this available model instead
-#     - from: "gpt-5"
+#     - from: "claude-sonnet-4-5-20250929"
-#       to: "gemini-2.5-pro"
+#       to: "gemini-claude-sonnet-4-5-thinking"
-#     - from: "claude-3-opus-20240229"
+#     - from: "claude-haiku-4-5-20251001"
-#       to: "claude-3-5-sonnet-20241022"
+#       to: "gemini-2.5-flash"
-# Global model name mappings (per channel)
+# Global OAuth model name mappings (per channel)
 # These mappings rename model IDs for both model listing and request routing.
-# NOTE: Mappings do not apply to codex-api-key, claude-api-key, openai-compatibility, vertex-api-key, or ampcode.
+# Supported channels: gemini-cli, vertex, aistudio, antigravity, claude, codex, qwen, iflow.
-# model-name-mappings:
+# NOTE: Mappings do not apply to gemini-api-key, codex-api-key, claude-api-key, openai-compatibility, vertex-api-key, or ampcode.
-#   gemini:
+# oauth-model-mappings:
-#     - from: "gemini-2.5-pro"          # original model name under this channel
+#   gemini-cli:
-#       to: "gpt-5"                     # client-visible alias
+#     - name: "gemini-2.5-pro"          # original model name under this channel
-#   apikey-gemini:
+#       alias: "g2.5p"                  # client-visible alias
-#     - from: "gemini-2.5-pro"
-#       to: "gpt-5"
-#   claude:
-#     - from: "claude-sonnet-4"
-#       to: "gpt-4o"
 #   vertex:
-#     - from: "gemini-2.5-pro"
+#     - name: "gemini-2.5-pro"
-#       to: "gpt-5"
+#       alias: "g2.5p"
+#   aistudio:
+#     - name: "gemini-2.5-pro"
+#       alias: "g2.5p"
+#   antigravity:
+#     - name: "gemini-3-pro-preview"
+#       alias: "g3p"
+#   claude:
+#     - name: "claude-sonnet-4-5-20250929"
+#       alias: "cs4.5"
+#   codex:
+#     - name: "gpt-5"
+#       alias: "g5"
 #   qwen:
-#     - from: "qwen3-coder-plus"
+#     - name: "qwen3-coder-plus"
-#       to: "gpt-4o-mini"
+#       alias: "qwen-plus"
 #   iflow:
-#     - from: "glm-4.7"
+#     - name: "glm-4.7"
-#       to: "gpt-5.1-mini"
+#       alias: "glm-god"
-#   antigravity:
-#     - from: "gemini-3-pro-preview"
-#       to: "gpt-5"
 # OAuth provider excluded models
 # oauth-excluded-models:

internal/config/config.go+29−28

 	// OAuthExcludedModels defines per-provider global model exclusions applied to OAuth/file-backed auth entries.
 	OAuthExcludedModels map[string][]string `yaml:"oauth-excluded-models,omitempty" json:"oauth-excluded-models,omitempty"`
-	// ModelNameMappings defines global per-channel model name mappings.
+	// OAuthModelMappings defines global model name mappings for OAuth/file-backed auth channels.
-	// These mappings affect both model listing and model routing for supported channels.
+	// These mappings affect both model listing and model routing for supported channels:
+	// gemini-cli, vertex, aistudio, antigravity, claude, codex, qwen, iflow.
 	//
 	// NOTE: This does not apply to existing per-credential model alias features under:
-	// codex-api-key, claude-api-key, openai-compatibility, vertex-api-key, and ampcode.
+	// gemini-api-key, codex-api-key, claude-api-key, openai-compatibility, vertex-api-key, and ampcode.
-	ModelNameMappings map[string][]ModelNameMapping `yaml:"model-name-mappings,omitempty" json:"model-name-mappings,omitempty"`
+	OAuthModelMappings map[string][]ModelNameMapping `yaml:"oauth-model-mappings,omitempty" json:"oauth-model-mappings,omitempty"`
 	// Payload defines default and override rules for provider payload parameters.
 	Payload PayloadConfig `yaml:"payload" json:"payload"`
 }
 // ModelNameMapping defines a model ID rename mapping for a specific channel.
-// It maps the original model name (From) to the client-visible alias (To).
+// It maps the original model name (Name) to the client-visible alias (Alias).
 type ModelNameMapping struct {
-	From string `yaml:"from" json:"from"`
+	Name  string `yaml:"name" json:"name"`
-	To   string `yaml:"to" json:"to"`
+	Alias string `yaml:"alias" json:"alias"`
 }
 // AmpModelMapping defines a model name mapping for Amp CLI requests.
 	// Normalize OAuth provider model exclusion map.
 	cfg.OAuthExcludedModels = NormalizeOAuthExcludedModels(cfg.OAuthExcludedModels)
-	// Normalize global model name mappings.
+	// Normalize global OAuth model name mappings.
-	cfg.SanitizeModelNameMappings()
+	cfg.SanitizeOAuthModelMappings()
 	if cfg.legacyMigrationPending {
 		fmt.Println("Detected legacy configuration keys, attempting to persist the normalized config...")
 	return &cfg, nil
 }
-// SanitizeModelNameMappings normalizes and deduplicates global model name mappings.
+// SanitizeOAuthModelMappings normalizes and deduplicates global OAuth model name mappings.
 // It trims whitespace, normalizes channel keys to lower-case, drops empty entries,
 // and ensures (From, To) pairs are unique within each channel.
-func (cfg *Config) SanitizeModelNameMappings() {
+func (cfg *Config) SanitizeOAuthModelMappings() {
-	if cfg == nil || len(cfg.ModelNameMappings) == 0 {
+	if cfg == nil || len(cfg.OAuthModelMappings) == 0 {
 		return
 	}
-	out := make(map[string][]ModelNameMapping, len(cfg.ModelNameMappings))
+	out := make(map[string][]ModelNameMapping, len(cfg.OAuthModelMappings))
-	for rawChannel, mappings := range cfg.ModelNameMappings {
+	for rawChannel, mappings := range cfg.OAuthModelMappings {
 		channel := strings.ToLower(strings.TrimSpace(rawChannel))
 		if channel == "" || len(mappings) == 0 {
 			continue
 		}
-		seenFrom := make(map[string]struct{}, len(mappings))
+		seenName := make(map[string]struct{}, len(mappings))
-		seenTo := make(map[string]struct{}, len(mappings))
+		seenAlias := make(map[string]struct{}, len(mappings))
 		clean := make([]ModelNameMapping, 0, len(mappings))
 		for _, mapping := range mappings {
-			from := strings.TrimSpace(mapping.From)
+			name := strings.TrimSpace(mapping.Name)
-			to := strings.TrimSpace(mapping.To)
+			alias := strings.TrimSpace(mapping.Alias)
-			if from == "" || to == "" {
+			if name == "" || alias == "" {
 				continue
 			}
-			if strings.EqualFold(from, to) {
+			if strings.EqualFold(name, alias) {
 				continue
 			}
-			fromKey := strings.ToLower(from)
+			nameKey := strings.ToLower(name)
-			toKey := strings.ToLower(to)
+			aliasKey := strings.ToLower(alias)
-			if _, ok := seenFrom[fromKey]; ok {
+			if _, ok := seenName[nameKey]; ok {
 				continue
 			}
-			if _, ok := seenTo[toKey]; ok {
+			if _, ok := seenAlias[aliasKey]; ok {
 				continue
 			}
-			seenFrom[fromKey] = struct{}{}
+			seenName[nameKey] = struct{}{}
-			seenTo[toKey] = struct{}{}
+			seenAlias[aliasKey] = struct{}{}
-			clean = append(clean, ModelNameMapping{From: from, To: to})
+			clean = append(clean, ModelNameMapping{Name: name, Alias: alias})
 		}
 		if len(clean) > 0 {
 			out[channel] = clean
 		}
 	}
-	cfg.ModelNameMappings = out
+	cfg.OAuthModelMappings = out
 }
 // SanitizeOpenAICompatibility removes OpenAI-compatibility provider entries that are

internal/watcher/config_reload.go+1−1

@@ -127,7 +127,7 @@ func (w *Watcher) reloadConfig() bool { · 126 unmodified lines
127	}	127	}
128		128
129	authDirChanged := oldConfig == nil \|\| oldConfig.AuthDir != newConfig.AuthDir	129	authDirChanged := oldConfig == nil \|\| oldConfig.AuthDir != newConfig.AuthDir
130	forceAuthRefresh := oldConfig != nil && (oldConfig.ForceModelPrefix != newConfig.ForceModelPrefix \|\| !reflect.DeepEqual(oldConfig.ModelNameMappings, newConfig.ModelNameMappings))	130	forceAuthRefresh := oldConfig != nil && (oldConfig.ForceModelPrefix != newConfig.ForceModelPrefix \|\| !reflect.DeepEqual(oldConfig.OAuthModelMappings, newConfig.OAuthModelMappings))
131		131
132	log.Infof("config successfully reloaded, triggering client reload")	132	log.Infof("config successfully reloaded, triggering client reload")
133	w.reloadClients(authDirChanged, affectedOAuthProviders, forceAuthRefresh)	133	w.reloadClients(authDirChanged, affectedOAuthProviders, forceAuthRefresh)

sdk/cliproxy/auth/conductor.go+3−3

@@ -413,7 +413,7 @@ func (m *Manager) executeWithProvider(ctx context.Context, provider string, req · 412 unmodified lines
413	}	413	}
414	execReq := req	414	execReq := req
415	execReq.Model, execReq.Metadata = rewriteModelForAuth(routeModel, req.Metadata, auth)	415	execReq.Model, execReq.Metadata = rewriteModelForAuth(routeModel, req.Metadata, auth)
416	execReq.Metadata = m.applyGlobalModelNameMappingMetadata(auth, execReq.Model, execReq.Metadata)	416	execReq.Metadata = m.applyOAuthModelMappingMetadata(auth, execReq.Model, execReq.Metadata)
417	resp, errExec := executor.Execute(execCtx, auth, execReq, opts)	417	resp, errExec := executor.Execute(execCtx, auth, execReq, opts)
418	result := Result{AuthID: auth.ID, Provider: provider, Model: routeModel, Success: errExec == nil}	418	result := Result{AuthID: auth.ID, Provider: provider, Model: routeModel, Success: errExec == nil}
419	if errExec != nil {	419	if errExec != nil {
@@ -475,7 +475,7 @@ func (m *Manager) executeCountWithProvider(ctx context.Context, provider string, · 55 unmodified lines
475	}	475	}
476	execReq := req	476	execReq := req
477	execReq.Model, execReq.Metadata = rewriteModelForAuth(routeModel, req.Metadata, auth)	477	execReq.Model, execReq.Metadata = rewriteModelForAuth(routeModel, req.Metadata, auth)
478	execReq.Metadata = m.applyGlobalModelNameMappingMetadata(auth, execReq.Model, execReq.Metadata)	478	execReq.Metadata = m.applyOAuthModelMappingMetadata(auth, execReq.Model, execReq.Metadata)
479	resp, errExec := executor.CountTokens(execCtx, auth, execReq, opts)	479	resp, errExec := executor.CountTokens(execCtx, auth, execReq, opts)
480	result := Result{AuthID: auth.ID, Provider: provider, Model: routeModel, Success: errExec == nil}	480	result := Result{AuthID: auth.ID, Provider: provider, Model: routeModel, Success: errExec == nil}
481	if errExec != nil {	481	if errExec != nil {
@@ -537,7 +537,7 @@ func (m *Manager) executeStreamWithProvider(ctx context.Context, provider string · 55 unmodified lines
537	}	537	}
538	execReq := req	538	execReq := req
539	execReq.Model, execReq.Metadata = rewriteModelForAuth(routeModel, req.Metadata, auth)	539	execReq.Model, execReq.Metadata = rewriteModelForAuth(routeModel, req.Metadata, auth)
540	execReq.Metadata = m.applyGlobalModelNameMappingMetadata(auth, execReq.Model, execReq.Metadata)	540	execReq.Metadata = m.applyOAuthModelMappingMetadata(auth, execReq.Model, execReq.Metadata)
541	chunks, errStream := executor.ExecuteStream(execCtx, auth, execReq, opts)	541	chunks, errStream := executor.ExecuteStream(execCtx, auth, execReq, opts)
542	if errStream != nil {	542	if errStream != nil {
543	rerr := &Error{Message: errStream.Error()}	543	rerr := &Error{Message: errStream.Error()}

sdk/cliproxy/auth/model_name_mappings.go+33−24

 		}
 		rev := make(map[string]string, len(entries))
 		for _, entry := range entries {
-			from := strings.TrimSpace(entry.From)
+			name := strings.TrimSpace(entry.Name)
-			to := strings.TrimSpace(entry.To)
+			alias := strings.TrimSpace(entry.Alias)
-			if from == "" || to == "" {
+			if name == "" || alias == "" {
 				continue
 			}
-			if strings.EqualFold(from, to) {
+			if strings.EqualFold(name, alias) {
 				continue
 			}
-			aliasKey := strings.ToLower(to)
+			aliasKey := strings.ToLower(alias)
 			if _, exists := rev[aliasKey]; exists {
 				continue
 			}
-			rev[aliasKey] = from
+			rev[aliasKey] = name
 		}
 		if len(rev) > 0 {
 			out.reverse[channel] = rev
 	return out
 }
-// SetGlobalModelNameMappings updates the global model name mapping table used during execution.
+// SetOAuthModelMappings updates the OAuth model name mapping table used during execution.
 // The mapping is applied per-auth channel to resolve the upstream model name while keeping the
 // client-visible model name unchanged for translation/response formatting.
-func (m *Manager) SetGlobalModelNameMappings(mappings map[string][]internalconfig.ModelNameMapping) {
+func (m *Manager) SetOAuthModelMappings(mappings map[string][]internalconfig.ModelNameMapping) {
 	if m == nil {
 		return
 	}
 	m.modelNameMappings.Store(table)
 }
-func (m *Manager) applyGlobalModelNameMappingMetadata(auth *Auth, requestedModel string, metadata map[string]any) map[string]any {
+func (m *Manager) applyOAuthModelMappingMetadata(auth *Auth, requestedModel string, metadata map[string]any) map[string]any {
-	original := m.resolveGlobalUpstreamModelForAuth(auth, requestedModel)
+	original := m.resolveOAuthUpstreamModel(auth, requestedModel)
 	if original == "" {
 		return metadata
 	}
 	return out
 }
-func (m *Manager) resolveGlobalUpstreamModelForAuth(auth *Auth, requestedModel string) string {
+func (m *Manager) resolveOAuthUpstreamModel(auth *Auth, requestedModel string) string {
 	if m == nil || auth == nil {
 		return ""
 	}
-	channel := globalModelMappingChannelForAuth(auth)
+	channel := modelMappingChannel(auth)
 	if channel == "" {
 		return ""
 	}
 	return original
 }
-func globalModelMappingChannelForAuth(auth *Auth) string {
+// modelMappingChannel extracts the OAuth model mapping channel from an Auth object.
+// It determines the provider and auth kind from the Auth's attributes and delegates
+// to OAuthModelMappingChannel for the actual channel resolution.
+func modelMappingChannel(auth *Auth) string {
 	if auth == nil {
 		return ""
 	}
 			authKind = "apikey"
 		}
 	}
-	return globalModelMappingChannel(provider, authKind)
+	return OAuthModelMappingChannel(provider, authKind)
 }
-func globalModelMappingChannel(provider, authKind string) string {
+// OAuthModelMappingChannel returns the OAuth model mapping channel name for a given provider
+// and auth kind. Returns empty string if the provider/authKind combination doesn't support
+// OAuth model mappings (e.g., API key authentication).
+//
+// Supported channels: gemini-cli, vertex, aistudio, antigravity, claude, codex, qwen, iflow.
+func OAuthModelMappingChannel(provider, authKind string) string {
+	provider = strings.ToLower(strings.TrimSpace(provider))
+	authKind = strings.ToLower(strings.TrimSpace(authKind))
 	switch provider {
 	case "gemini":
-		if authKind == "apikey" {
+		// gemini provider uses gemini-api-key config, not oauth-model-mappings.
-			return "apikey-gemini"
+		// OAuth-based gemini auth is converted to "gemini-cli" by the synthesizer.
-		}
+		return ""
-		return "gemini"
+	case "vertex":
-	case "codex":
 		if authKind == "apikey" {
 			return ""
 		}
-		return "codex"
+		return "vertex"
 	case "claude":
 		if authKind == "apikey" {
 			return ""
 		}
 		return "claude"
-	case "vertex":
+	case "codex":
 		if authKind == "apikey" {
 			return ""
 		}
-		return "vertex"
+		return "codex"
-	case "antigravity", "qwen", "iflow":
+	case "gemini-cli", "aistudio", "antigravity", "qwen", "iflow":
 		return provider
 	default:
 		return ""

sdk/cliproxy/builder.go+1−1

@@ -215,7 +215,7 @@ func (b Builder) Build() (Service, error) { · 214 unmodified lines
215	}	215	}
216	// Attach a default RoundTripper provider so providers can opt-in per-auth transports.	216	// Attach a default RoundTripper provider so providers can opt-in per-auth transports.
217	coreManager.SetRoundTripperProvider(newDefaultRoundTripperProvider())	217	coreManager.SetRoundTripperProvider(newDefaultRoundTripperProvider())
218	coreManager.SetGlobalModelNameMappings(b.cfg.ModelNameMappings)	218	coreManager.SetOAuthModelMappings(b.cfg.OAuthModelMappings)
219		219
220	service := &Service{	220	service := &Service{
221	cfg: b.cfg,	221	cfg: b.cfg,

sdk/cliproxy/service.go+12−43

 		s.cfg = newCfg
 		s.cfgMu.Unlock()
 		if s.coreManager != nil {
-			s.coreManager.SetGlobalModelNameMappings(newCfg.ModelNameMappings)
+			s.coreManager.SetOAuthModelMappings(newCfg.OAuthModelMappings)
 		}
 		s.rebindExecutors()
 	}
 			}
 		}
 	}
-	models = applyGlobalModelNameMappings(s.cfg, provider, authKind, models)
+	models = applyOAuthModelMappings(s.cfg, provider, authKind, models)
 	if len(models) > 0 {
 		key := provider
 		if key == "" {
 	return out
 }
-func globalModelMappingChannel(provider, authKind string) string {
-	provider = strings.ToLower(strings.TrimSpace(provider))
-	authKind = strings.ToLower(strings.TrimSpace(authKind))
-	switch provider {
-	case "gemini":
-		if authKind == "apikey" {
-			return "apikey-gemini"
-		}
-		return "gemini"
-	case "codex":
-		if authKind == "apikey" {
-			return ""
-		}
-		return "codex"
-	case "claude":
-		if authKind == "apikey" {
-			return ""
-		}
-		return "claude"
-	case "vertex":
-		if authKind == "apikey" {
-			return ""
-		}
-		return "vertex"
-	case "antigravity", "qwen", "iflow":
-		return provider
-	default:
-		return ""
-	}
-}
 func rewriteModelInfoName(name, oldID, newID string) string {
 	trimmed := strings.TrimSpace(name)
 	if trimmed == "" {
 	return name
 }
-func applyGlobalModelNameMappings(cfg *config.Config, provider, authKind string, models []*ModelInfo) []*ModelInfo {
+func applyOAuthModelMappings(cfg *config.Config, provider, authKind string, models []*ModelInfo) []*ModelInfo {
 	if cfg == nil || len(models) == 0 {
 		return models
 	}
-	channel := globalModelMappingChannel(provider, authKind)
+	channel := coreauth.OAuthModelMappingChannel(provider, authKind)
-	if channel == "" || len(cfg.ModelNameMappings) == 0 {
+	if channel == "" || len(cfg.OAuthModelMappings) == 0 {
 		return models
 	}
-	mappings := cfg.ModelNameMappings[channel]
+	mappings := cfg.OAuthModelMappings[channel]
 	if len(mappings) == 0 {
 		return models
 	}
 	forward := make(map[string]string, len(mappings))
 	for i := range mappings {
-		from := strings.TrimSpace(mappings[i].From)
+		name := strings.TrimSpace(mappings[i].Name)
-		to := strings.TrimSpace(mappings[i].To)
+		alias := strings.TrimSpace(mappings[i].Alias)
-		if from == "" || to == "" {
+		if name == "" || alias == "" {
 			continue
 		}
-		if strings.EqualFold(from, to) {
+		if strings.EqualFold(name, alias) {
 			continue
 		}
-		key := strings.ToLower(from)
+		key := strings.ToLower(name)
 		if _, exists := forward[key]; exists {
 			continue
 		}
-		forward[key] = to
+		forward[key] = alias
 	}
 	if len(forward) == 0 {
 		return models