🤖 fix(proxy): address provider-scoped routing review issues

What:
- split provider-scoped proxy handling into a dedicated ProviderProxyHandler instead of extending the project-scoped handler
- route /project/... and /provider/... through separate handlers in both server wiring and static fallback dispatch
- make provider-scoped matches bypass project custom-route selection and use provider-filtered global routes only
- add handler and router regression coverage for the separated scope flow

Why:
- keep provider scope independent from project semantics and avoid reusing project-specific control flow for a new proxy surface
- make the scoped proxy routing easier to reason about, review, and extend without hidden coupling between scopes
- preserve the existing provider-scope fixes while aligning the implementation with the intended architecture

Tests:
- go test ./internal/handler ./internal/router ./tests/e2e/... (pass)

Author: awsl233777

cmd/maxx/main.go

@@ -375,7 +375,8 @@ func main() {
 
 	// Use already-created cached project repository for project proxy handler
 	modelsHandler := handler.NewModelsHandler(responseModelRepo, cachedProviderRepo, cachedModelMappingRepo)
-	projectProxyHandler := handler.NewProjectProxyHandler(proxyHandler, modelsHandler, cachedProjectRepo, cachedProviderRepo)
+	projectProxyHandler := handler.NewProjectProxyHandler(proxyHandler, modelsHandler, cachedProjectRepo)
+	providerProxyHandler := handler.NewProviderProxyHandler(proxyHandler, modelsHandler, cachedProviderRepo)
 
 	// Setup routes
 	mux := http.NewServeMux()
@@ -420,9 +421,9 @@ func main() {
 	// WebSocket endpoint
 	mux.HandleFunc("/ws", wsHub.HandleWebSocket)
 
-	// Serve static files (Web UI) with project proxy support - must be last (default route)
+	// Serve static files (Web UI) with scoped proxy support - must be last (default route)
 	staticHandler := handler.NewStaticHandler()
-	combinedHandler := handler.NewCombinedHandler(projectProxyHandler, staticHandler)
+	combinedHandler := handler.NewCombinedHandler(projectProxyHandler, providerProxyHandler, staticHandler)
 	mux.Handle("/", combinedHandler)
 
 	// Wrap with logging middleware
@@ -530,7 +531,8 @@ func main() {
 	log.Printf("  OpenAI: http://localhost%s/v1/chat/completions", *addr)
 	log.Printf("  Codex:  http://localhost%s/v1/responses", *addr)
 	log.Printf("  Gemini: http://localhost%s/v1beta/models/{model}:generateContent", *addr)
-	log.Printf("Project proxy: http://localhost%s/project/{project-slug}/v1/messages (etc.)", *addr)
+	log.Printf("Project proxy:  http://localhost%s/project/{project-slug}/v1/messages (etc.)", *addr)
+	log.Printf("Provider proxy: http://localhost%s/provider/{provider-id}/v1/messages (etc.)", *addr)
 
 	go func() {
 		if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {

internal/core/database.go

@@ -73,27 +73,28 @@ type DatabaseRepos struct {
 
 // ServerComponents 包含服务器运行所需的所有组件
 type ServerComponents struct {
-	Router              *router.Router
-	WebSocketHub        *handler.WebSocketHub
-	WailsBroadcaster    *event.WailsBroadcaster
-	Executor            *executor.Executor
-	ClientAdapter       *client.Adapter
-	AdminService        *service.AdminService
-	ProxyHandler        *handler.ProxyHandler
-	ModelsHandler       *handler.ModelsHandler
-	AdminHandler        *handler.AdminHandler
-	AntigravityHandler  *handler.AntigravityHandler
-	KiroHandler         *handler.KiroHandler
-	CodexHandler        *handler.CodexHandler
-	CodexOAuthServer    *CodexOAuthServer
-	ClaudeHandler       *handler.ClaudeHandler
-	ClaudeOAuthServer   *ClaudeOAuthServer
-	ProjectProxyHandler *handler.ProjectProxyHandler
-	RequestTracker      *RequestTracker
-	PprofManager        *PprofManager
-	AuthMiddleware      *handler.AuthMiddleware
-	AuthHandler         *handler.AuthHandler
-	BackupService       *service.BackupService
+	Router               *router.Router
+	WebSocketHub         *handler.WebSocketHub
+	WailsBroadcaster     *event.WailsBroadcaster
+	Executor             *executor.Executor
+	ClientAdapter        *client.Adapter
+	AdminService         *service.AdminService
+	ProxyHandler         *handler.ProxyHandler
+	ModelsHandler        *handler.ModelsHandler
+	AdminHandler         *handler.AdminHandler
+	AntigravityHandler   *handler.AntigravityHandler
+	KiroHandler          *handler.KiroHandler
+	CodexHandler         *handler.CodexHandler
+	CodexOAuthServer     *CodexOAuthServer
+	ClaudeHandler        *handler.ClaudeHandler
+	ClaudeOAuthServer    *ClaudeOAuthServer
+	ProjectProxyHandler  *handler.ProjectProxyHandler
+	ProviderProxyHandler *handler.ProviderProxyHandler
+	RequestTracker       *RequestTracker
+	PprofManager         *PprofManager
+	AuthMiddleware       *handler.AuthMiddleware
+	AuthHandler          *handler.AuthHandler
+	BackupService        *service.BackupService
 }
 
 // InitializeDatabase 初始化数据库和所有仓库
@@ -408,34 +409,36 @@ func InitializeServerComponents(
 	claudeHandler := handler.NewClaudeHandler(adminService, wailsBroadcaster)
 	claudeOAuthServer := NewClaudeOAuthServer(claudeHandler)
 	claudeHandler.SetOAuthServer(claudeOAuthServer)
-	projectProxyHandler := handler.NewProjectProxyHandler(proxyHandler, modelsHandler, repos.CachedProjectRepo, repos.CachedProviderRepo)
+	projectProxyHandler := handler.NewProjectProxyHandler(proxyHandler, modelsHandler, repos.CachedProjectRepo)
+	providerProxyHandler := handler.NewProviderProxyHandler(proxyHandler, modelsHandler, repos.CachedProviderRepo)
 
 	log.Printf("[Core] Creating request tracker for graceful shutdown")
 	requestTracker := NewRequestTracker()
 	proxyHandler.SetRequestTracker(requestTracker)
 
 	components := &ServerComponents{
-		Router:              r,
-		WebSocketHub:        wsHub,
-		WailsBroadcaster:    wailsBroadcaster,
-		Executor:            exec,
-		ClientAdapter:       clientAdapter,
-		AdminService:        adminService,
-		ProxyHandler:        proxyHandler,
-		ModelsHandler:       modelsHandler,
-		AdminHandler:        adminHandler,
-		AntigravityHandler:  antigravityHandler,
-		KiroHandler:         kiroHandler,
-		CodexHandler:        codexHandler,
-		CodexOAuthServer:    codexOAuthServer,
-		ClaudeHandler:       claudeHandler,
-		ClaudeOAuthServer:   claudeOAuthServer,
-		ProjectProxyHandler: projectProxyHandler,
-		RequestTracker:      requestTracker,
-		PprofManager:        pprofMgr,
-		AuthMiddleware:      authMiddleware,
-		AuthHandler:         authHandler,
-		BackupService:       backupService,
+		Router:               r,
+		WebSocketHub:         wsHub,
+		WailsBroadcaster:     wailsBroadcaster,
+		Executor:             exec,
+		ClientAdapter:        clientAdapter,
+		AdminService:         adminService,
+		ProxyHandler:         proxyHandler,
+		ModelsHandler:        modelsHandler,
+		AdminHandler:         adminHandler,
+		AntigravityHandler:   antigravityHandler,
+		KiroHandler:          kiroHandler,
+		CodexHandler:         codexHandler,
+		CodexOAuthServer:     codexOAuthServer,
+		ClaudeHandler:        claudeHandler,
+		ClaudeOAuthServer:    claudeOAuthServer,
+		ProjectProxyHandler:  projectProxyHandler,
+		ProviderProxyHandler: providerProxyHandler,
+		RequestTracker:       requestTracker,
+		PprofManager:         pprofMgr,
+		AuthMiddleware:       authMiddleware,
+		AuthHandler:          authHandler,
+		BackupService:        backupService,
 	}
 
 	log.Printf("[Core] Server components initialized successfully")

internal/core/server.go

@@ -106,11 +106,12 @@ func (s *ManagedServer) setupRoutes() *http.ServeMux {
 
 	if s.config.ServeStatic {
 		staticHandler := handler.NewStaticHandler()
-		combinedHandler := handler.NewCombinedHandler(components.ProjectProxyHandler, staticHandler)
+		combinedHandler := handler.NewCombinedHandler(components.ProjectProxyHandler, components.ProviderProxyHandler, staticHandler)
 		mux.Handle("/", combinedHandler)
 		log.Printf("[Server] Static file serving enabled")
 	} else {
-		mux.Handle("/", components.ProjectProxyHandler)
+		mux.Handle("/project/", components.ProjectProxyHandler)
+		mux.Handle("/provider/", components.ProviderProxyHandler)
 		log.Printf("[Server] Static file serving disabled (Wails mode)")
 	}
 

internal/handler/project_proxy.go

@@ -3,131 +3,100 @@ package handler
 import (
 	"log"
 	"net/http"
-	"strconv"
 	"strings"
 
 	maxxctx "github.com/awsl-project/maxx/internal/context"
 	"github.com/awsl-project/maxx/internal/repository"
 )
 
-// ProjectProxyHandler wraps ProxyHandler to handle scoped proxy requests
-// like /project/{slug}/v1/messages and /provider/{id}/v1/messages.
+// ProjectProxyHandler wraps ProxyHandler to handle project-scoped proxy requests
+// like /project/{slug}/v1/messages.
 type ProjectProxyHandler struct {
 	proxyHandler  *ProxyHandler
 	modelsHandler *ModelsHandler
 	projectRepo   repository.ProjectRepository
-	providerRepo  repository.ProviderRepository
 }
 
-// NewProjectProxyHandler creates a new scoped proxy handler.
+// NewProjectProxyHandler creates a new project-scoped proxy handler.
 func NewProjectProxyHandler(
 	proxyHandler *ProxyHandler,
 	modelsHandler *ModelsHandler,
 	projectRepo repository.ProjectRepository,
-	providerRepo repository.ProviderRepository,
 ) *ProjectProxyHandler {
 	return &ProjectProxyHandler{
 		proxyHandler:  proxyHandler,
 		modelsHandler: modelsHandler,
 		projectRepo:   projectRepo,
-		providerRepo:  providerRepo,
 	}
 }
 
-// ServeHTTP handles scoped proxy requests.
+// ServeHTTP handles project-scoped proxy requests.
 func (h *ProjectProxyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	scopeType, scopeValue, apiPath, ok := h.parseScopedPath(r.URL.Path)
+	projectSlug, apiPath, ok := h.parseScopedPath(r.URL.Path)
 	if !ok {
-		writeError(w, http.StatusNotFound, "invalid scoped proxy path")
+		writeError(w, http.StatusNotFound, "invalid project proxy path")
 		return
 	}
 
 	tenantID := maxxctx.GetTenantID(r.Context())
-
-	switch scopeType {
-	case "project":
-		project, err := h.projectRepo.GetBySlug(tenantID, scopeValue)
-		if err != nil {
-			log.Printf("[ScopedProxy] Project not found for slug: %s", scopeValue)
-			writeError(w, http.StatusNotFound, "project not found")
-			return
-		}
-		log.Printf("[ScopedProxy] Routing request through project: %s (ID: %d)", project.Name, project.ID)
-		r.Header.Set("X-Maxx-Project-ID", strings.TrimSpace(itoa(project.ID)))
-	case "provider":
-		providerID, err := strconv.ParseUint(scopeValue, 10, 64)
-		if err != nil || providerID == 0 {
-			writeError(w, http.StatusBadRequest, "invalid provider id")
-			return
-		}
-		provider, err := h.providerRepo.GetByID(tenantID, providerID)
-		if err != nil || provider == nil {
-			log.Printf("[ScopedProxy] Provider not found for id: %s", scopeValue)
-			writeError(w, http.StatusNotFound, "provider not found")
-			return
-		}
-		log.Printf("[ScopedProxy] Routing request through provider: %s (ID: %d)", provider.Name, provider.ID)
-		r.Header.Set("X-Maxx-Provider-ID", strings.TrimSpace(itoa(provider.ID)))
-	default:
-		writeError(w, http.StatusNotFound, "unknown scope type")
+	project, err := h.projectRepo.GetBySlug(tenantID, projectSlug)
+	if err != nil {
+		log.Printf("[ProjectProxy] Project not found for slug: %s", projectSlug)
+		writeError(w, http.StatusNotFound, "project not found")
 		return
 	}
 
+	log.Printf("[ProjectProxy] Routing request through project: %s (ID: %d)", project.Name, project.ID)
+	r.Header.Set("X-Maxx-Project-ID", strings.TrimSpace(itoa(project.ID)))
 	r.URL.Path = apiPath
 	if apiPath == "/v1/models" {
 		h.modelsHandler.ServeHTTP(w, r)
 		return
 	}
+
 	h.proxyHandler.ServeHTTP(w, r)
 }
 
-// parseScopedPath extracts scope type/value and API path.
-// Input: /project/my-project/v1/messages or /provider/1/v1/messages
-func (h *ProjectProxyHandler) parseScopedPath(path string) (scopeType, scopeValue, apiPath string, ok bool) {
-	if strings.HasPrefix(path, "/project/") {
-		return parseScopePath("project", strings.TrimPrefix(path, "/project/"))
-	}
-	if strings.HasPrefix(path, "/provider/") {
-		return parseScopePath("provider", strings.TrimPrefix(path, "/provider/"))
-	}
-	return "", "", "", false
+// parseScopedPath extracts project slug and API path.
+// Input: /project/my-project/v1/messages
+func (h *ProjectProxyHandler) parseScopedPath(path string) (projectSlug, apiPath string, ok bool) {
+	if !strings.HasPrefix(path, "/project/") {
+		return "", "", false
+	}
+	_, projectSlug, apiPath, ok = parseScopePath("project", strings.TrimPrefix(path, "/project/"))
+	return projectSlug, apiPath, ok
 }
 
 func parseScopePath(scopeType, path string) (resolvedType, scopeValue, apiPath string, ok bool) {
 	parts := strings.SplitN(path, "/", 2)
-	if len(parts) < 2 || strings.TrimSpace(parts[0]) == "" {
+	if len(parts) < 2 {
+		return "", "", "", false
+	}
+
+	trimmed := strings.TrimSpace(parts[0])
+	if trimmed == "" {
 		return "", "", "", false
 	}
 
-	scopeValue = parts[0]
 	apiPath = "/" + parts[1]
 	if !isValidAPIPath(apiPath) {
 		return "", "", "", false
 	}
-	return scopeType, scopeValue, apiPath, true
+	return scopeType, trimmed, apiPath, true
 }
 
 // isValidAPIPath checks if the path is a known proxy API endpoint.
 func isValidAPIPath(path string) bool {
-	if strings.HasPrefix(path, "/v1/messages") {
-		return true
-	}
-	if strings.HasPrefix(path, "/v1/chat/completions") {
-		return true
-	}
-	if strings.HasPrefix(path, "/responses") {
-		return true
-	}
-	if strings.HasPrefix(path, "/v1/responses") {
-		return true
-	}
-	if strings.HasPrefix(path, "/v1/models") {
-		return true
-	}
-	if strings.HasPrefix(path, "/v1beta/models/") {
-		return true
-	}
-	return false
+	return matchesEndpointPath(path, "/v1/messages") ||
+		matchesEndpointPath(path, "/v1/chat/completions") ||
+		matchesEndpointPath(path, "/responses") ||
+		matchesEndpointPath(path, "/v1/responses") ||
+		matchesEndpointPath(path, "/v1/models") ||
+		matchesEndpointPath(path, "/v1beta/models")
+}
+
+func matchesEndpointPath(path, endpoint string) bool {
+	return path == endpoint || strings.HasPrefix(path, endpoint+"/")
 }
 
 func itoa(n uint64) string {