feat: 实现反检测速率限制器，模拟人类行为模式避免被 Google 封禁

Dockerfile

@@ -44,11 +44,19 @@ ENV GEMINI_COOKIE_PATH="/home/user/src/cache"
 # 设置图片存储路径（持久化生成的图片）
 ENV GEMINI_IMAGE_STORE_PATH="/home/user/src/cache"
 
-# 设置并发限制（可根据需要调整）
-# IDE 场景建议：max_concurrent=15-20, queue_size=50-100
-ENV GEMINI_MAX_CONCURRENT_REQUESTS="15"
-ENV GEMINI_QUEUE_TIMEOUT="30.0"
-ENV GEMINI_MAX_QUEUE_SIZE="100"
+# 反检测速率限制配置（重要：避免被 Google 封禁）
+# 安全值（推荐）：
+#   - max_concurrent: 1-5（模拟人类行为）
+#   - requests_per_minute: 10-30
+#   - requests_per_hour: 100-300
+#   - requests_per_day: 1000-3000
+ENV GEMINI_MAX_CONCURRENT_REQUESTS="3"
+ENV GEMINI_QUEUE_TIMEOUT="60.0"
+ENV GEMINI_MAX_QUEUE_SIZE="50"
+ENV GEMINI_REQUESTS_PER_MINUTE="20"
+ENV GEMINI_REQUESTS_PER_HOUR="200"
+ENV GEMINI_REQUESTS_PER_DAY="2000"
+ENV GEMINI_BURST_COOLDOWN="30.0"
 
 # 启动命令
 # 确保 run.py 里的 uvicorn 监听的是 0.0.0.0 和 7860 端口

app/server/rate_limiter.py

@@ -1,9 +1,10 @@
 """
-Intelligent rate limiter middleware for high-concurrency scenarios.
-Optimized for code IDE integration with adaptive queuing and retry-after hints.
+Anti-detection rate limiter for Gemini Web API.
+Mimics human browsing patterns to avoid detection by Google.
 """
 
 import asyncio
+import random
 import time
 from typing import Callable, Optional
 
@@ -13,79 +14,183 @@ from loguru import logger
 
 class RateLimiter:
     """
-    Adaptive rate limiter with smart queuing for IDE workloads.
+    Human-like rate limiter with anti-detection features.
     
-    Features:
-    - Configurable concurrent limit
-    - Adaptive timeout based on queue length
-    - Retry-After header for client guidance
-    - Metrics tracking for monitoring
+    Anti-detection strategies:
+    - Low concurrent limit (1-3 to mimic human behavior)
+    - Randomized request delays (jitter)
+    - Per-client rate limiting
+    - Daily quota per account
+    - Cooldown periods after burst usage
     """
 
     def __init__(
         self,
-        max_concurrent: int = 10,
-        base_timeout: float = 30.0,
-        max_queue_size: int = 100,
+        max_concurrent: int = 3,
+        base_timeout: float = 60.0,
+        max_queue_size: int = 50,
+        requests_per_minute: int = 20,
+        requests_per_hour: int = 200,
+        requests_per_day: int = 2000,
+        burst_cooldown: float = 30.0,
     ):
         """
-        Initialize rate limiter.
+        Initialize rate limiter with human-like patterns.
         
         Args:
-            max_concurrent: Maximum simultaneous requests (IDE: 10-20 recommended)
-            base_timeout: Base timeout in seconds (actual timeout adapts to queue)
-            max_queue_size: Maximum queued requests before immediate rejection
+            max_concurrent: Max simultaneous requests (keep low: 1-5 for safety)
+            base_timeout: Base timeout in seconds
+            max_queue_size: Maximum queued requests
+            requests_per_minute: Soft limit per minute (with jitter)
+            requests_per_hour: Soft limit per hour
+            requests_per_day: Hard limit per day (account safety)
+            burst_cooldown: Cooldown seconds after burst usage
         """
         self.max_concurrent = max_concurrent
         self.base_timeout = base_timeout
         self.max_queue_size = max_queue_size
+        self.requests_per_minute = requests_per_minute
+        self.requests_per_hour = requests_per_hour
+        self.requests_per_day = requests_per_day
+        self.burst_cooldown = burst_cooldown
+        
         self._semaphore = asyncio.Semaphore(max_concurrent)
         self._current_count = 0
         self._queued_count = 0
         self._lock = asyncio.Lock()
         
+        # Rate tracking (sliding windows)
+        self._minute_requests: list[float] = []
+        self._hour_requests: list[float] = []
+        self._day_requests: list[float] = []
+        self._last_burst_time: Optional[float] = None
+        
         # Metrics
         self._total_requests = 0
         self._rejected_requests = 0
         self._last_reset = time.time()
 
+    def _cleanup_old_records(self, now: float) -> None:
+        """Remove records older than tracking windows."""
+        # Keep last 60 seconds for minute window
+        self._minute_requests = [t for t in self._minute_requests if now - t < 60]
+        # Keep last 3600 seconds for hour window
+        self._hour_requests = [t for t in self._hour_requests if now - t < 3600]
+        # Keep last 86400 seconds for day window
+        self._day_requests = [t for t in self._day_requests if now - t < 86400]
+
+    def _get_random_delay(self) -> float:
+        """
+        Generate human-like random delay (0.5-3 seconds).
+        Mimics natural thinking/typing patterns.
+        """
+        # Most delays: 0.5-2 seconds (70%)
+        # Some delays: 2-5 seconds (25%)
+        # Rare delays: 5-10 seconds (5%)
+        rand = random.random()
+        if rand < 0.70:
+            return random.uniform(0.5, 2.0)
+        elif rand < 0.95:
+            return random.uniform(2.0, 5.0)
+        else:
+            return random.uniform(5.0, 10.0)
+
+    def _check_rate_limits(self, now: float) -> Optional[str]:
+        """
+        Check if request exceeds rate limits.
+        Returns error message if limit exceeded, None otherwise.
+        """
+        self._cleanup_old_records(now)
+        
+        # Check for burst cooldown
+        if self._last_burst_time and (now - self._last_burst_time) < self.burst_cooldown:
+            remaining = self.burst_cooldown - (now - self._last_burst_time)
+            return f"Burst cooldown active. Retry after {int(remaining)}s"
+        
+        # Check daily limit (hard limit)
+        if len(self._day_requests) >= self.requests_per_day:
+            return "Daily limit reached. Try again tomorrow."
+        
+        # Check hourly limit (soft limit with jitter)
+        if len(self._hour_requests) >= self.requests_per_hour:
+            # Add random jitter (0-5 minutes) to avoid pattern detection
+            jitter = random.randint(0, 300)
+            return f"Hourly limit reached. Retry after {60 + jitter}s"
+        
+        # Check minute limit (soft limit with jitter)
+        if len(self._minute_requests) >= self.requests_per_minute:
+            jitter = random.randint(5, 30)
+            return f"Too many requests. Retry after {jitter}s"
+        
+        return None
+
+    def _record_request(self, now: float) -> None:
+        """Record a new request in tracking windows."""
+        self._minute_requests.append(now)
+        self._hour_requests.append(now)
+        self._day_requests.append(now)
+        
+        # Check if we're in burst mode (>80% of minute limit in last minute)
+        if len(self._minute_requests) >= int(self.requests_per_minute * 0.8):
+            self._last_burst_time = now
+            logger.info(f"Rate limiter: burst usage detected, entering cooldown")
+
     async def acquire(self, request: Optional[Request] = None) -> None:
         """
-        Acquire permission to process a request with adaptive timeout.
+        Acquire permission with human-like delays and anti-detection.
         
         Args:
-            request: Optional FastAPI request for context-aware limiting
+            request: Optional FastAPI request for context
             
         Raises:
-            HTTPException: 503 when queue is full or timeout exceeded
+            HTTPException: 503 when rate limited or queue full
         """
+        now = time.time()
+        
         async with self._lock:
             self._total_requests += 1
             
+            # Check rate limits first
+            rate_limit_error = self._check_rate_limits(now)
+            if rate_limit_error:
+                self._rejected_requests += 1
+                retry_after = int(random.uniform(30, 120))
+                logger.warning(f"Rate limiter: {rate_limit_error}")
+                raise HTTPException(
+                    status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+                    detail=rate_limit_error,
+                    headers={"Retry-After": str(retry_after)},
+                )
+            
             # Fast rejection if queue is full
             if self._queued_count >= self.max_queue_size:
                 self._rejected_requests += 1
+                retry_after = int(random.uniform(10, 30))
                 logger.warning(
                     f"Rate limiter: queue full ({self._queued_count}/{self.max_queue_size}), "
-                    f"rejecting immediately"
+                    f"rejecting with jittered retry"
                 )
                 raise HTTPException(
                     status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-                    detail="Server is at capacity. Please try again in a few seconds.",
-                    headers={"Retry-After": "5"},
+                    detail="Server is at capacity. Please try again shortly.",
+                    headers={"Retry-After": str(retry_after)},
                 )
             
             self._queued_count += 1
             current_queue_position = self._queued_count
         
-        # Calculate adaptive timeout based on queue position
-        # Each position in queue adds ~2 seconds (estimated avg request time)
-        estimated_wait = current_queue_position * 2.0
+        # Add human-like delay before acquiring slot
+        human_delay = self._get_random_delay()
+        logger.debug(f"Rate limiter: adding human-like delay {human_delay:.1f}s")
+        await asyncio.sleep(human_delay)
+        
+        # Calculate adaptive timeout with jitter
+        estimated_wait = current_queue_position * random.uniform(1.5, 3.0)
         adaptive_timeout = min(estimated_wait, self.base_timeout)
         
         try:
             logger.debug(
-                f"Rate limiter: request queued at position {current_queue_position}, "
+                f"Rate limiter: request queued (position={current_queue_position}), "
                 f"timeout={adaptive_timeout:.1f}s"
             )
             
@@ -97,9 +202,13 @@ class RateLimiter:
             async with self._lock:
                 self._queued_count -= 1
                 self._current_count += 1
+                self._record_request(now)
                 logger.info(
                     f"Rate limiter: acquired slot ({self._current_count}/{self.max_concurrent}), "
-                    f"queue={self._queued_count}"
+                    f"queue={self._queued_count}, "
+                    f"minute={len(self._minute_requests)}, "
+                    f"hour={len(self._hour_requests)}, "
+                    f"day={len(self._day_requests)}"
                 )
                 
         except asyncio.TimeoutError:
@@ -107,16 +216,15 @@ class RateLimiter:
                 self._queued_count -= 1
                 self._rejected_requests += 1
             
-            retry_after = min(int(adaptive_timeout * 1.5), 30)
+            retry_after = int(random.uniform(30, 90))
             logger.warning(
-                f"Rate limiter: request timed out after {adaptive_timeout:.1f}s "
-                f"(queue was at position {current_queue_position}), "
+                f"Rate limiter: request timed out after {adaptive_timeout:.1f}s, "
                 f"suggesting retry after {retry_after}s"
             )
             
             raise HTTPException(
                 status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-                detail=f"Server is busy. Please retry after {retry_after} seconds.",
+                detail="Request timed out. Please try again.",
                 headers={"Retry-After": str(retry_after)},
             )
 
@@ -130,12 +238,38 @@ class RateLimiter:
         logger.debug(f"Rate limiter: released slot ({current_count}/{self.max_concurrent})")
 
     def get_metrics(self) -> dict:
-        """Get current rate limiter metrics."""
+        """Get current rate limiter metrics including anti-detection stats."""
+        now = time.time()
+        self._cleanup_old_records(now)
+        
         return {
+            # Current state
             "current_requests": self._current_count,
             "queued_requests": self._queued_count,
+            
+            # Configuration
             "max_concurrent": self.max_concurrent,
             "max_queue_size": self.max_queue_size,
+            "limits": {
+                "per_minute": self.requests_per_minute,
+                "per_hour": self.requests_per_hour,
+                "per_day": self.requests_per_day,
+            },
+            
+            # Rate tracking (current usage)
+            "usage": {
+                "last_minute": len(self._minute_requests),
+                "last_hour": len(self._hour_requests),
+                "last_day": len(self._day_requests),
+            },
+            
+            # Cooldown status
+            "burst_cooldown": {
+                "active": self._last_burst_time is not None and (now - self._last_burst_time) < self.burst_cooldown,
+                "remaining_seconds": max(0, self.burst_cooldown - (now - self._last_burst_time)) if self._last_burst_time else 0,
+            },
+            
+            # Overall metrics
             "total_requests": self._total_requests,
             "rejected_requests": self._rejected_requests,
             "rejection_rate": (
@@ -143,7 +277,7 @@ class RateLimiter:
                 if self._total_requests > 0
                 else 0.0
             ),
-            "uptime_seconds": time.time() - self._last_reset,
+            "uptime_seconds": now - self._last_reset,
         }
 
     def reset_metrics(self) -> None:
@@ -158,24 +292,40 @@ _rate_limiter: RateLimiter | None = None
 
 
 def get_rate_limiter() -> RateLimiter:
-    """Get or create the global rate limiter."""
+    """Get or create the global rate limiter with anti-detection defaults."""
     global _rate_limiter
     if _rate_limiter is None:
         # Configure based on environment or use defaults
+        # IMPORTANT: Keep concurrent low to avoid detection!
         import os
-        max_concurrent = int(os.getenv("GEMINI_MAX_CONCURRENT_REQUESTS", "10"))
-        base_timeout = float(os.getenv("GEMINI_QUEUE_TIMEOUT", "30.0"))
-        max_queue_size = int(os.getenv("GEMINI_MAX_QUEUE_SIZE", "100"))
+        
+        max_concurrent = int(os.getenv("GEMINI_MAX_CONCURRENT_REQUESTS", "3"))
+        base_timeout = float(os.getenv("GEMINI_QUEUE_TIMEOUT", "60.0"))
+        max_queue_size = int(os.getenv("GEMINI_MAX_QUEUE_SIZE", "50"))
+        
+        # Anti-detection rate limits (conservative defaults)
+        requests_per_minute = int(os.getenv("GEMINI_REQUESTS_PER_MINUTE", "20"))
+        requests_per_hour = int(os.getenv("GEMINI_REQUESTS_PER_HOUR", "200"))
+        requests_per_day = int(os.getenv("GEMINI_REQUESTS_PER_DAY", "2000"))
+        burst_cooldown = float(os.getenv("GEMINI_BURST_COOLDOWN", "30.0"))
         
         logger.info(
-            f"Rate limiter initialized: max_concurrent={max_concurrent}, "
-            f"base_timeout={base_timeout}s, max_queue_size={max_queue_size}"
+            f"Rate limiter initialized with ANTI-DETECTION settings:\n"
+            f"  max_concurrent={max_concurrent} (keep low!)\n"
+            f"  requests/minute={requests_per_minute}\n"
+            f"  requests/hour={requests_per_hour}\n"
+            f"  requests/day={requests_per_day}\n"
+            f"  burst_cooldown={burst_cooldown}s"
         )
         
         _rate_limiter = RateLimiter(
             max_concurrent=max_concurrent,
             base_timeout=base_timeout,
             max_queue_size=max_queue_size,
+            requests_per_minute=requests_per_minute,
+            requests_per_hour=requests_per_hour,
+            requests_per_day=requests_per_day,
+            burst_cooldown=burst_cooldown,
         )
     return _rate_limiter