Merge pull request #111 from xunxun1982/xxdev

feat: 优化集中管理路由逻辑说明和优先级提示

Author: xunxun1982

internal/centralizedmgmt/channel_compatibility.go

@@ -15,7 +15,15 @@ type ChannelCompatibility struct {
 // channelCompatibilityMap maps relay formats to their compatible channel types.
 // Priority order: Native channel first, then compatible channels.
 // Note: CC (Claude Code) support only converts Claude format to other formats (one-way conversion).
+// Unknown formats fallback to OpenAI for maximum compatibility.
 var channelCompatibilityMap = map[types.RelayFormat]ChannelCompatibility{
+	// Unknown format - fallback to OpenAI for unrecognized paths
+	// This ensures requests with unknown paths can still be routed instead of failing
+	types.RelayFormatUnknown: {
+		Native:     "openai",
+		Compatible: []string{},
+	},
+
 	// OpenAI formats - native to OpenAI only (no Azure in this project)
 	types.RelayFormatOpenAIChat: {
 		Native:     "openai",
@@ -79,10 +87,14 @@ var channelCompatibilityMap = map[types.RelayFormat]ChannelCompatibility{
 
 // GetCompatibleChannels returns all compatible channel types for a given relay format.
 // Returns native channel first, followed by compatible channels in priority order.
+// For unknown formats, returns ["openai"] as a fallback to ensure maximum compatibility.
 func GetCompatibleChannels(format types.RelayFormat) []string {
 	compat, exists := channelCompatibilityMap[format]
 	if !exists {
-		return []string{} // Unknown format, no compatible channels
+		// Fallback to OpenAI for formats not defined in the map
+		// This handles edge cases like typos or future formats not yet added to the map
+		// The defensive fallback ensures requests with unknown paths can still be routed
+		return []string{"openai"}
 	}
 
 	// Build result: native first, then compatible channels
@@ -93,19 +105,23 @@ func GetCompatibleChannels(format types.RelayFormat) []string {
 }
 
 // GetNativeChannel returns the native (preferred) channel type for a given relay format.
+// For unknown formats, returns "openai" as a fallback.
 func GetNativeChannel(format types.RelayFormat) string {
 	compat, exists := channelCompatibilityMap[format]
 	if !exists {
-		return "" // Unknown format
+		return "openai" // Fallback to OpenAI for unknown formats
 	}
 	return compat.Native
 }
 
 // IsChannelCompatible checks if a channel type is compatible with a relay format.
+// For unknown formats not in the map, returns true only for "openai" to match
+// the fallback behavior of GetCompatibleChannels/GetNativeChannel.
 func IsChannelCompatible(channelType string, format types.RelayFormat) bool {
 	compat, exists := channelCompatibilityMap[format]
 	if !exists {
-		return false
+		// Fallback: only openai is compatible with truly unknown formats
+		return channelType == "openai"
 	}
 
 	// Check native channel
@@ -126,9 +142,14 @@ func IsChannelCompatible(channelType string, format types.RelayFormat) bool {
 // GetChannelPriority returns the priority of a channel type for a given relay format.
 // Lower number = higher priority. Returns -1 if not compatible.
 // Priority: 0 = native, 1+ = compatible channels in order.
+// For unknown formats not in the map, returns 0 for "openai" to match fallback behavior.
 func GetChannelPriority(channelType string, format types.RelayFormat) int {
 	compat, exists := channelCompatibilityMap[format]
 	if !exists {
+		// Fallback: openai has priority 0 for truly unknown formats
+		if channelType == "openai" {
+			return 0
+		}
 		return -1
 	}
 

internal/centralizedmgmt/channel_compatibility_test.go

@@ -45,25 +45,17 @@ func TestGetCompatibleChannels(t *testing.T) {
 			wantCompatible: []string{},
 		},
 		{
-			name:           "Unknown format",
-			format:         types.RelayFormat("unknown"),
-			wantNative:     "",
-			wantCompatible: nil,
+			name:           "Unknown format (fallback to OpenAI)",
+			format:         types.RelayFormatUnknown,
+			wantNative:     "openai",
+			wantCompatible: []string{},
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			got := GetCompatibleChannels(tt.format)
 
-			if tt.wantNative == "" {
-				// Unknown format should return empty slice
-				if len(got) != 0 {
-					t.Errorf("GetCompatibleChannels() = %v, want empty slice", got)
-				}
-				return
-			}
-
 			// Check native channel (first element)
 			if len(got) == 0 {
 				t.Fatalf("GetCompatibleChannels() returned empty slice, want native=%s", tt.wantNative)
@@ -102,7 +94,7 @@ func TestGetNativeChannel(t *testing.T) {
 		{"Claude", types.RelayFormatClaude, "anthropic"},
 		{"Gemini", types.RelayFormatGemini, "gemini"},
 		{"Codex", types.RelayFormatCodex, "codex"},
-		{"Unknown", types.RelayFormat("unknown"), ""},
+		{"Unknown (fallback to OpenAI)", types.RelayFormatUnknown, "openai"},
 	}
 
 	for _, tt := range tests {
@@ -150,8 +142,9 @@ func TestIsChannelCompatible(t *testing.T) {
 		{"Codex native", "codex", types.RelayFormatCodex, true},
 		{"OpenAI NOT compatible for Codex", "openai", types.RelayFormatCodex, false},
 
-		// Unknown format
-		{"Unknown format", "openai", types.RelayFormat("unknown"), false},
+		// Unknown format (fallback to OpenAI)
+		{"Unknown format fallback to OpenAI", "openai", types.RelayFormatUnknown, true},
+		{"Unknown format NOT compatible with Anthropic", "anthropic", types.RelayFormatUnknown, false},
 	}
 
 	for _, tt := range tests {
@@ -189,8 +182,9 @@ func TestGetChannelPriority(t *testing.T) {
 		{"Anthropic NOT compatible for embedding", "anthropic", types.RelayFormatOpenAIEmbedding, -1},
 		{"OpenAI NOT compatible for Gemini", "openai", types.RelayFormatGemini, -1},
 
-		// Unknown format
-		{"Unknown format", "openai", types.RelayFormat("unknown"), -1},
+		// Unknown format (fallback to OpenAI)
+		{"Unknown format fallback to OpenAI", "openai", types.RelayFormatUnknown, 0},
+		{"Unknown format NOT compatible with Anthropic", "anthropic", types.RelayFormatUnknown, -1},
 	}
 
 	for _, tt := range tests {