feat: implement circuit breaker, fix auth vulnerability

internal/middleware/auth.go

@@ -2,6 +2,7 @@ package middleware
 
 import (
 	"log"
+	"net/http"
 	"strings"
 
 	"gophergate/internal/db"
@@ -27,26 +28,16 @@ func AuthMiddleware(database *db.DB) gin.HandlerFunc {
 		// Try to resolve client from database
 		var clientID string
 		err := database.Get(&clientID, "UPDATE client_tokens SET last_used_at = CURRENT_TIMESTAMP WHERE token = ? AND is_active = 1 RETURNING client_id", token)
-		
+
 		if err == nil {
 			c.Set("auth", models.AuthInfo{
 				Token:    token,
 				ClientID: clientID,
 			})
+			c.Next()
 		} else {
-			// Fallback to token-prefix derivation (matches Rust behavior)
-			prefixLen := len(token)
-			if prefixLen > 8 {
-				prefixLen = 8
-			}
-			clientID = "client_" + token[:prefixLen]
-			c.Set("auth", models.AuthInfo{
-				Token:    token,
-				ClientID: clientID,
-			})
-			log.Printf("Token not found in DB, using fallback client ID: %s", clientID)
+			log.Printf("Token not found or inactive in DB: %s", token)
+			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "invalid or inactive token"})
 		}
-
-		c.Next()
 	}
 }

internal/providers/circuit_breaker.go

@@ -0,0 +1,44 @@
+package providers
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/sony/gobreaker"
+	"gophergate/internal/models"
+)
+
+type CircuitBreakerProvider struct {
+	provider Provider
+	cb       *gobreaker.CircuitBreaker
+}
+
+func NewCircuitBreakerProvider(p Provider) Provider {
+	settings := gobreaker.Settings{
+		Name: p.Name(),
+	}
+	return &CircuitBreakerProvider{
+		provider: p,
+		cb:       gobreaker.NewCircuitBreaker(settings),
+	}
+}
+
+func (cbp *CircuitBreakerProvider) Name() string {
+	return cbp.provider.Name()
+}
+
+func (cbp *CircuitBreakerProvider) ChatCompletion(ctx context.Context, req *models.UnifiedRequest) (*models.ChatCompletionResponse, error) {
+	result, err := cbp.cb.Execute(func() (interface{}, error) {
+		return cbp.provider.ChatCompletion(ctx, req)
+	})
+	if err != nil {
+		return nil, err
+	}
+	return result.(*models.ChatCompletionResponse), nil
+}
+
+func (cbp *CircuitBreakerProvider) ChatCompletionStream(ctx context.Context, req *models.UnifiedRequest) (<-chan *models.ChatCompletionStreamResponse, error) {
+	// Circuit breaker for streaming is tricky. We'll just call the provider directly.
+	// Future: Implement a way to track stream failures in the circuit breaker.
+	return cbp.provider.ChatCompletionStream(ctx, req)
+}

internal/server/server.go

@@ -131,32 +131,36 @@ func (s *Server) RefreshProviders() error {
 		}
 
 		// Initialize provider
+		var p providers.Provider
 		switch id {
 		case "openai":
 			cfg := s.cfg.Providers.OpenAI
 			cfg.BaseURL = baseURL
-			s.providers["openai"] = providers.NewOpenAIProvider(cfg, apiKey)
+			p = providers.NewOpenAIProvider(cfg, apiKey)
 		case "gemini":
 			cfg := s.cfg.Providers.Gemini
 			cfg.BaseURL = baseURL
-			s.providers["gemini"] = providers.NewGeminiProvider(cfg, apiKey)
+			p = providers.NewGeminiProvider(cfg, apiKey)
 		case "deepseek":
 			cfg := s.cfg.Providers.DeepSeek
 			cfg.BaseURL = baseURL
-			s.providers["deepseek"] = providers.NewDeepSeekProvider(cfg, apiKey)
+			p = providers.NewDeepSeekProvider(cfg, apiKey)
 		case "moonshot":
 			cfg := s.cfg.Providers.Moonshot
 			cfg.BaseURL = baseURL
-			s.providers["moonshot"] = providers.NewMoonshotProvider(cfg, apiKey)
+			p = providers.NewMoonshotProvider(cfg, apiKey)
 		case "grok":
 			cfg := s.cfg.Providers.Grok
 			cfg.BaseURL = baseURL
-			s.providers["grok"] = providers.NewGrokProvider(cfg, apiKey)
+			p = providers.NewGrokProvider(cfg, apiKey)
 		case "ollama":
 			cfg := s.cfg.Providers.Ollama
-			fmt.Printf("[DEBUG] Ollama config: Enabled=%v, BaseURL=%s, Models=%v\n", cfg.Enabled, baseURL, cfg.Models)
 			cfg.BaseURL = baseURL
-			s.providers["ollama"] = providers.NewOllamaProvider(cfg)
+			p = providers.NewOllamaProvider(cfg)
+		}
+
+		if p != nil {
+			s.providers[id] = providers.NewCircuitBreakerProvider(p)
 		}
 	}
 
@@ -182,6 +186,7 @@ func (s *Server) setupRoutes() {
 	{
 		v1.POST("/chat/completions", s.handleChatCompletions)
 		v1.GET("/models", s.handleListModels)
+		v1.GET("/responses", s.handleListResponses)
 	}
 
 	// Dashboard API Group
@@ -238,6 +243,11 @@ func (s *Server) setupRoutes() {
 	})
 }
 
+func (s *Server) handleListResponses(c *gin.Context) {
+	// This is a placeholder for the /v1/responses endpoint
+	c.JSON(http.StatusOK, gin.H{"data": []interface{}{}})
+}
+
 func (s *Server) handleListModels(c *gin.Context) {
 	type OpenAIModel struct {
 		ID      string `json:"id"`