feat: 优化 Cooldown 机制和落雪视觉效果 (#136)

* feat: 优化 Cooldown 机制和前端交互体验

- 修复网络错误未正确触发 Cooldown 的问题
- 将默认 Cooldown 时间从 60s 改为 5s 起步
- 将 Cooldown 策略从分钟级改为秒级，支持更精细的控制
- Provider Row 点击 Unfreeze 按钮可立即解冻
- 手动解冻时清空失败计数器
- 修复倒计时到期后前端未正确恢复的问题
- 拖拽时全局设置 cursor 为 grab
- 优化倒计时使用递归 setTimeout 替代 setInterval

* feat: 优化 Cooldown 落雪效果视觉样式

- 雪花使用 radial-gradient 实现半透明柔和边缘效果
- Light 模式使用深灰色雪花，Dark 模式使用白色雪花
- Cooldown 行背景改为透明，保留可见边框
- 倒计时框背景改为透明
- Icon 框使用实色背景，Cooldown 时隐藏字母只显示雪花图标
- 雪花动画置于所有元素后面 (z-0)
- 增强 Cooldown 状态下 Row 的 hover 效果

Author: Bowl42

internal/cooldown/failure_tracker.go

@@ -91,11 +91,14 @@ func (ft *FailureTracker) GetFailureCount(providerID uint64, clientType string,
 }
 
 // ResetFailures resets all failure counts for a provider+clientType
+// If clientType is empty, resets ALL failure counts for the provider
 func (ft *FailureTracker) ResetFailures(providerID uint64, clientType string) {
 	// Clear failure counts for all reasons for this provider+clientType
 	keysToDelete := []FailureKey{}
 	for key := range ft.failureCounts {
-		if key.ProviderID == providerID && key.ClientType == clientType {
+		// If clientType is empty, match all clientTypes for this provider
+		// Otherwise, only match the specific clientType
+		if key.ProviderID == providerID && (clientType == "" || key.ClientType == clientType) {
 			keysToDelete = append(keysToDelete, key)
 		}
 	}

internal/cooldown/manager.go

@@ -109,9 +109,9 @@ func (m *Manager) RecordFailure(providerID uint64, clientType string, reason Coo
 	// Get policy for this reason
 	policy, ok := m.policies[reason]
 	if !ok {
-		// Fallback to fixed 1-minute cooldown if no policy found
-		policy = &FixedDurationPolicy{Duration: 1 * time.Minute}
-		log.Printf("[Cooldown] Warning: No policy found for reason=%s, using default 1-minute cooldown", reason)
+		// Fallback to fixed 5-second cooldown if no policy found
+		policy = &FixedDurationPolicy{Duration: 5 * time.Second}
+		log.Printf("[Cooldown] Warning: No policy found for reason=%s, using default 5-second cooldown", reason)
 	}
 
 	// Calculate cooldown duration

internal/cooldown/policy.go

@@ -20,42 +20,42 @@ func (p *FixedDurationPolicy) CalculateCooldown(failureCount int) time.Duration
 }
 
 // LinearIncrementalPolicy increases cooldown linearly with each failure
-// Formula: baseMinutes * failureCount
+// Formula: baseSeconds * failureCount
 type LinearIncrementalPolicy struct {
-	BaseMinutes int
-	MaxMinutes  int // Optional cap, 0 means no limit
+	BaseSeconds int
+	MaxSeconds  int // Optional cap, 0 means no limit
 }
 
 func (p *LinearIncrementalPolicy) CalculateCooldown(failureCount int) time.Duration {
-	minutes := p.BaseMinutes * failureCount
-	if p.MaxMinutes > 0 && minutes > p.MaxMinutes {
-		minutes = p.MaxMinutes
+	seconds := p.BaseSeconds * failureCount
+	if p.MaxSeconds > 0 && seconds > p.MaxSeconds {
+		seconds = p.MaxSeconds
 	}
-	return time.Duration(minutes) * time.Minute
+	return time.Duration(seconds) * time.Second
 }
 
 // ExponentialBackoffPolicy increases cooldown exponentially with each failure
-// Formula: baseMinutes * (2 ^ (failureCount - 1))
+// Formula: baseSeconds * (2 ^ (failureCount - 1))
 type ExponentialBackoffPolicy struct {
-	BaseMinutes int
-	MaxMinutes  int // Optional cap, 0 means no limit
+	BaseSeconds int
+	MaxSeconds  int // Optional cap, 0 means no limit
 }
 
 func (p *ExponentialBackoffPolicy) CalculateCooldown(failureCount int) time.Duration {
 	if failureCount == 0 {
 		return 0
 	}
 
-	minutes := p.BaseMinutes
+	seconds := p.BaseSeconds
 	for i := 1; i < failureCount; i++ {
-		minutes *= 2
-		if p.MaxMinutes > 0 && minutes > p.MaxMinutes {
-			minutes = p.MaxMinutes
+		seconds *= 2
+		if p.MaxSeconds > 0 && seconds > p.MaxSeconds {
+			seconds = p.MaxSeconds
 			break
 		}
 	}
 
-	return time.Duration(minutes) * time.Minute
+	return time.Duration(seconds) * time.Second
 }
 
 // CooldownReason represents the reason for cooldown
@@ -75,32 +75,32 @@ const (
 // those times will be used directly instead of these policies
 func DefaultPolicies() map[CooldownReason]CooldownPolicy {
 	return map[CooldownReason]CooldownPolicy{
-		// Server errors (5xx): linear increment (1min, 2min, 3min, ... max 10min)
+		// Server errors (5xx): linear increment (5s, 10s, 15s, ... max 10min)
 		ReasonServerError: &LinearIncrementalPolicy{
-			BaseMinutes: 1,
-			MaxMinutes:  10,
+			BaseSeconds: 5,
+			MaxSeconds:  600, // 10 minutes
 		},
-		// Network errors: exponential backoff (1min, 2min, 4min, 8min, ... max 30min)
+		// Network errors: exponential backoff (5s, 10s, 20s, 40s, ... max 30min)
 		ReasonNetworkError: &ExponentialBackoffPolicy{
-			BaseMinutes: 1,
-			MaxMinutes:  30,
+			BaseSeconds: 5,
+			MaxSeconds:  1800, // 30 minutes
 		},
 		// Quota exhausted: fixed 1 hour (only used as fallback when API doesn't return reset time)
 		ReasonQuotaExhausted: &FixedDurationPolicy{
 			Duration: 1 * time.Hour,
 		},
-		// Rate limit: fixed 1 minute (only used as fallback when API doesn't return Retry-After)
+		// Rate limit: fixed 5 seconds (only used as fallback when API doesn't return Retry-After)
 		ReasonRateLimit: &FixedDurationPolicy{
-			Duration: 1 * time.Minute,
+			Duration: 5 * time.Second,
 		},
-		// Concurrent limit: fixed 10 seconds (only used as fallback)
+		// Concurrent limit: fixed 5 seconds (only used as fallback)
 		ReasonConcurrentLimit: &FixedDurationPolicy{
-			Duration: 10 * time.Second,
+			Duration: 5 * time.Second,
 		},
-		// Unknown error: linear increment (1min, 2min, 3min, ... max 5min)
+		// Unknown error: linear increment (5s, 10s, 15s, ... max 5min)
 		ReasonUnknown: &LinearIncrementalPolicy{
-			BaseMinutes: 1,
-			MaxMinutes:  5,
+			BaseSeconds: 5,
+			MaxSeconds:  300, // 5 minutes
 		},
 	}
 }

internal/executor/executor.go

@@ -514,6 +514,24 @@ func (e *Executor) Execute(ctx context.Context, w http.ResponseWriter, req *http
 				e.broadcaster.BroadcastProxyRequest(proxyReq)
 			}
 
+			// Handle cooldown BEFORE checking context cancellation
+			// This ensures network errors trigger cooldown even if context is cancelled
+			proxyErr, ok := err.(*domain.ProxyError)
+			if ok {
+				log.Printf("[Executor] ProxyError - IsNetworkError: %v, IsServerError: %v, Retryable: %v, Provider: %d",
+					proxyErr.IsNetworkError, proxyErr.IsServerError, proxyErr.Retryable, matchedRoute.Provider.ID)
+				// Handle cooldown (unified cooldown logic for all providers)
+				e.handleCooldown(attemptCtx, proxyErr, matchedRoute.Provider)
+				// Broadcast cooldown update event to frontend
+				if e.broadcaster != nil {
+					e.broadcaster.BroadcastMessage("cooldown_update", map[string]interface{}{
+						"providerID": matchedRoute.Provider.ID,
+					})
+				}
+			} else {
+				log.Printf("[Executor] Error is not ProxyError, type: %T, error: %v", err, err)
+			}
+
 			// Check if it's a context cancellation (client disconnect)
 			if ctx.Err() != nil {
 				// Set final status before returning to ensure it's persisted
@@ -529,15 +547,11 @@ func (e *Executor) Execute(ctx context.Context, w http.ResponseWriter, req *http
 				return ctx.Err()
 			}
 
-			// Check if retryable
-			proxyErr, ok := err.(*domain.ProxyError)
+			// Check if retryable (proxyErr already checked above)
 			if !ok {
 				break // Move to next route
 			}
 
-			// Handle cooldown (unified cooldown logic for all providers)
-			e.handleCooldown(attemptCtx, proxyErr, matchedRoute.Provider)
-
 			if !proxyErr.Retryable {
 				break // Move to next route
 			}
@@ -665,9 +679,14 @@ func (e *Executor) handleCooldown(ctx context.Context, proxyErr *domain.ProxyErr
 	if proxyErr.RateLimitInfo != nil && proxyErr.RateLimitInfo.ClientType != "" {
 		clientType = proxyErr.RateLimitInfo.ClientType
 	}
-	// Fallback to current request's clientType if not specified
+	// Fallback to original client type (before format conversion) if not specified
 	if clientType == "" {
-		clientType = string(ctxutil.GetClientType(ctx))
+		// Prefer original client type over converted type
+		if origCT := ctxutil.GetOriginalClientType(ctx); origCT != "" {
+			clientType = string(origCT)
+		} else {
+			clientType = string(ctxutil.GetClientType(ctx))
+		}
 	}
 
 	// Determine cooldown reason and explicit time

internal/handler/admin.go

@@ -650,14 +650,20 @@ func (h *AdminHandler) handleRoutingStrategies(w http.ResponseWriter, r *http.Re
 }
 
 // ProxyRequest handlers
-// Routes: /admin/requests, /admin/requests/count, /admin/requests/{id}, /admin/requests/{id}/attempts
+// Routes: /admin/requests, /admin/requests/count, /admin/requests/active, /admin/requests/{id}, /admin/requests/{id}/attempts
 func (h *AdminHandler) handleProxyRequests(w http.ResponseWriter, r *http.Request, id uint64, parts []string) {
 	// Check for count endpoint: /admin/requests/count
 	if len(parts) > 2 && parts[2] == "count" {
 		h.handleProxyRequestsCount(w, r)
 		return
 	}
 
+	// Check for active endpoint: /admin/requests/active
+	if len(parts) > 2 && parts[2] == "active" {
+		h.handleActiveProxyRequests(w, r)
+		return
+	}
+
 	// Check for sub-resource: /admin/requests/{id}/attempts
 	if len(parts) > 3 && parts[3] == "attempts" && id > 0 {
 		h.handleProxyUpstreamAttempts(w, r, id)
@@ -712,6 +718,21 @@ func (h *AdminHandler) handleProxyRequestsCount(w http.ResponseWriter, r *http.R
 	writeJSON(w, http.StatusOK, count)
 }
 
+// ActiveProxyRequests handler - returns all requests with PENDING or IN_PROGRESS status
+func (h *AdminHandler) handleActiveProxyRequests(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		writeJSON(w, http.StatusMethodNotAllowed, map[string]string{"error": "method not allowed"})
+		return
+	}
+
+	requests, err := h.svc.GetActiveProxyRequests()
+	if err != nil {
+		writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
+		return
+	}
+	writeJSON(w, http.StatusOK, requests)
+}
+
 // ProxyUpstreamAttempt handlers
 func (h *AdminHandler) handleProxyUpstreamAttempts(w http.ResponseWriter, r *http.Request, proxyRequestID uint64) {
 	if r.Method != http.MethodGet {

internal/repository/interfaces.go

@@ -68,6 +68,8 @@ type ProxyRequestRepository interface {
 	// before: 获取 id < before 的记录 (向后翻页)
 	// after: 获取 id > after 的记录 (向前翻页/获取新数据)
 	ListCursor(limit int, before, after uint64) ([]*domain.ProxyRequest, error)
+	// ListActive 获取所有活跃请求 (PENDING 或 IN_PROGRESS 状态)
+	ListActive() ([]*domain.ProxyRequest, error)
 	Count() (int64, error)
 	// UpdateProjectIDBySessionID 批量更新指定 sessionID 的所有请求的 projectID
 	UpdateProjectIDBySessionID(sessionID string, projectID uint64) (int64, error)

internal/repository/sqlite/failure_count_repository.go

@@ -77,6 +77,11 @@ func (r *FailureCountRepository) Delete(providerID uint64, clientType string, re
 }
 
 func (r *FailureCountRepository) DeleteAll(providerID uint64, clientType string) error {
+	// If clientType is empty, delete ALL failure counts for this provider
+	if clientType == "" {
+		return r.db.gorm.Where("provider_id = ?", providerID).Delete(&FailureCount{}).Error
+	}
+	// Otherwise, delete only for the specific clientType
 	return r.db.gorm.Where("provider_id = ? AND client_type = ?", providerID, clientType).Delete(&FailureCount{}).Error
 }
 

internal/repository/sqlite/proxy_request.go

@@ -93,6 +93,19 @@ func (r *ProxyRequestRepository) ListCursor(limit int, before, after uint64) ([]
 	return r.toDomainList(models), nil
 }
 
+// ListActive 获取所有活跃请求 (PENDING 或 IN_PROGRESS 状态)
+func (r *ProxyRequestRepository) ListActive() ([]*domain.ProxyRequest, error) {
+	var models []ProxyRequest
+	if err := r.db.gorm.Model(&ProxyRequest{}).
+		Select("id, created_at, updated_at, instance_id, request_id, session_id, client_type, request_model, response_model, start_time, end_time, duration_ms, is_stream, status, status_code, error, proxy_upstream_attempt_count, final_proxy_upstream_attempt_id, route_id, provider_id, project_id, input_token_count, output_token_count, cache_read_count, cache_write_count, cache_5m_write_count, cache_1h_write_count, cost, api_token_id").
+		Where("status IN ?", []string{"PENDING", "IN_PROGRESS"}).
+		Order("id DESC").
+		Find(&models).Error; err != nil {
+		return nil, err
+	}
+	return r.toDomainList(models), nil
+}
+
 func (r *ProxyRequestRepository) Count() (int64, error) {
 	return atomic.LoadInt64(&r.count), nil
 }

internal/service/admin.go

@@ -392,6 +392,10 @@ func (s *AdminService) GetProxyRequest(id uint64) (*domain.ProxyRequest, error)
 	return s.proxyRequestRepo.GetByID(id)
 }
 
+func (s *AdminService) GetActiveProxyRequests() ([]*domain.ProxyRequest, error) {
+	return s.proxyRequestRepo.ListActive()
+}
+
 func (s *AdminService) GetProxyUpstreamAttempts(proxyRequestID uint64) ([]*domain.ProxyUpstreamAttempt, error) {
 	return s.attemptRepo.ListByProxyRequestID(proxyRequestID)
 }

web/src/components/cooldown-timer.tsx

@@ -0,0 +1,64 @@
+import { useState, useEffect } from 'react';
+import { useQueryClient } from '@tanstack/react-query';
+import type { Cooldown } from '@/lib/transport';
+
+interface CooldownTimerProps {
+  cooldown: Cooldown;
+  className?: string;
+}
+
+/**
+ * 实时倒计时组件，每秒更新显示
+ * 过期时自动触发 cooldowns 刷新
+ */
+export function CooldownTimer({ cooldown, className }: CooldownTimerProps) {
+  const queryClient = useQueryClient();
+  const [remainingSeconds, setRemainingSeconds] = useState(() => calculateRemaining(cooldown));
+
+  useEffect(() => {
+    // 每秒更新一次
+    const interval = setInterval(() => {
+      const remaining = calculateRemaining(cooldown);
+      setRemainingSeconds(remaining);
+
+      // 过期时刷新 cooldowns
+      if (remaining <= 0) {
+        queryClient.invalidateQueries({ queryKey: ['cooldowns'] });
+        clearInterval(interval);
+      }
+    }, 1000);
+
+    return () => clearInterval(interval);
+  }, [cooldown, queryClient]);
+
+  // 已过期，不显示
+  if (remainingSeconds <= 0) {
+    return null;
+  }
+
+  return <span className={className}>{formatSeconds(remainingSeconds)}</span>;
+}
+
+function calculateRemaining(cooldown: Cooldown): number {
+  const untilTime =
+    cooldown.untilTime || ((cooldown as unknown as Record<string, unknown>).until as string);
+  if (!untilTime) return 0;
+
+  const until = new Date(untilTime).getTime();
+  const now = Date.now();
+  return Math.max(0, Math.floor((until - now) / 1000));
+}
+
+function formatSeconds(seconds: number): string {
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  const secs = seconds % 60;
+
+  if (hours > 0) {
+    return `${String(hours).padStart(2, '0')}h ${String(minutes).padStart(2, '0')}m ${String(secs).padStart(2, '0')}s`;
+  } else if (minutes > 0) {
+    return `${String(minutes).padStart(2, '0')}m ${String(secs).padStart(2, '0')}s`;
+  } else {
+    return `${String(secs).padStart(2, '0')}s`;
+  }
+}