fix(gateway): AI网关中低危修复——熔断器语义/探活超时/JWKS安全/Key冷却/重试策略/错误脱敏/Redis重连/限流原子化

- GW-M1: 熔断器 CLOSED 成功重置失败计数（分散失败不再误熔断）；仅 HALF_OPEN 允许恢复（冷却期不可绕过）
- GW-M2: 健康探活独立 10s 超时（原最长 900s）+ 冷却期内探活成功不恢复
- GW-M3: JWKS 共享 AsyncClient 连接池 + asyncio.Lock 防击穿 + 网络失败 fail-closed（不再返回过期缓存）
- GW-M4: KeyPool 全冷却返回 None（不再打必失败的冷却 Key）；429 时自动标记当前 Key 冷却（熔断联动接线）
- GW-M5: with_retry_and_timeout 仅重试可重试错误，401/400/429/内容审核直接上抛（消除 9 连发重试风暴）
- GW-M6: 上游错误脱敏——响应仅返回通用文案与结构化字段，不再透传 provider 内部信息
- GW-M7: Redis 惰性重连——连接失效后下次操作自动恢复，限流/缓存不再静默失效至重启
- GW-M8: chunked 编码请求体流式计数限流（无 Content-Length 时逐块累计超限 413）
- GW-M9: Prompt 防护移除 >1000 字符跳过 + 数组全量检测（长文注入不再绕过）
- GW-M10: AI 响应缓存键前缀 user_id，杜绝跨用户隐私内容交叉泄漏
- GW-M11: 匿名用户按 IP 分桶限流，防止共享配额被污染
- GW-M12: 限流 Lua 脚本原子化（INCR+超限自动回滚），消除计数竞态与负数
- GW-M13: balance 共享 HTTP 客户端 + asyncio.Lock 防缓存击穿
- GW-M14: Key 轮换加 asyncio.Lock + 旧客户端 aclose 释放连接池
- GW-M15: 转写请求 base64 max_length + 参数范围校验；ASR confidence 不再硬编码 0.9（无数据源时返回 0.0）
- GW-L1: 删除无调用者的 semantic_cache 死代码
- GW-L2: text_dedup 长度预过滤降低 O(n²) 实际开销
- GW-L3: _FEATURE_CONTEXT 成功路径 try/finally 重置
- GW-L5: 虚拟 Key 随机熵 64 位 → 128 位

测试: python -m pytest tests/ -q → 193 passed

Author: Aparencia

server/ai-gateway/cache/redis_cache.py

@@ -62,12 +62,16 @@ async def disconnect(self) -> None:
 
     async def get(self, key: str) -> str | None:
         """获取缓存值，Redis 不可用时返回 None"""
+        if not self._client:
+            await self._maybe_reconnect()  # GW-M7: 惰性重连
         if not self._client:
             return None
         try:
             return await self._client.get(key)
         except Exception as exc:
             logger.warning("Redis GET 失败 key=%s: %s", key, exc)
+            # 连接可能已失效，尝试重连供下次使用
+            await self._maybe_reconnect()
             return None
 
     async def set(self, key: str, value: str, expire: int = 0) -> bool:
@@ -76,6 +80,8 @@ async def set(self, key: str, value: str, expire: int = 0) -> bool:
 
         Redis 不可用时静默跳过。返回是否设置成功。
         """
+        if not self._client:
+            await self._maybe_reconnect()  # GW-M7: 惰性重连
         if not self._client:
             return False
         try:
@@ -86,6 +92,7 @@ async def set(self, key: str, value: str, expire: int = 0) -> bool:
             return True
         except Exception as exc:
             logger.warning("Redis SET 失败 key=%s: %s", key, exc)
+            await self._maybe_reconnect()
             return False
 
     async def increment(self, key: str, expire: int = 86400) -> int:
@@ -102,6 +109,8 @@ async def increment(self, key: str, expire: int = 86400) -> int:
         Returns:
             int: 递增后的值；Redis 不可用时返回 0
         """
+        if not self._client:
+            await self._maybe_reconnect()  # GW-M7: 惰性重连
         if not self._client:
             return 0
         try:
@@ -112,8 +121,20 @@ async def increment(self, key: str, expire: int = 86400) -> int:
             return results[0]
         except Exception as exc:
             logger.warning("Redis INCR 失败 key=%s: %s", key, exc)
+            await self._maybe_reconnect()
             return 0
 
+    async def _maybe_reconnect(self) -> None:
+        """
+        GW-M7: 惰性重连——Redis 重启/网络抖动后连接失效，
+        下次操作时自动尝试恢复，避免限流/缓存静默失效至进程重启。
+        connect() 内部已捕获异常，此处不会向上抛出。
+        """
+        try:
+            await self.connect()
+        except Exception:
+            pass
+
     async def get_ai_cache(self, prompt_hash: str) -> dict[str, Any] | None:
         """
         获取 AI 响应缓存

server/ai-gateway/cache/semantic_cache.py

@@ -197,7 +197,12 @@ async def _run_fallback_chain():
             try:
                 async def _do_call():
                     _FEATURE_CONTEXT.set(feature)
-                    return await fn(provider, model_name)
+                    try:
+                        return await fn(provider, model_name)
+                    finally:
+                        # GW-L3: 成功路径也重置 context——避免同任务后续
+                        # 无 _feature 的 provider 调用继承上次 feature
+                        _FEATURE_CONTEXT.set("")
 
                 # Phase3: 并发信号量保护（视频/多模态走 heavy 上限）
                 result = await _run_under_semaphore(app, feature, _do_call)

server/ai-gateway/config/fallback.py

@@ -60,7 +60,7 @@ async def next_key(self) -> str | None:
         """轮询获取下一个可用 Key
 
         Returns:
-            可用的 API Key，全部不可用时返回 None
+            可用的 API Key，全部不可用时返回 None（调用方据此跳过该 Provider）
         """
         if not self._keys:
             return None
@@ -73,12 +73,13 @@ async def next_key(self) -> str | None:
                 self._index += 1
                 if self._disabled_until.get(key, 0) <= now:
                     return key
-            # 全部不可用，返回第一个（让上层决定是否重试）
+            # GW-M4: 全部不可用时返回 None 而非冷却中的 Key——
+            # 返回冷却 Key 会让调用方对必失败的 Key 发起请求（429 重试风暴）
             logger.warning(
                 "KeyPool [%s]: 所有 %d 个 Key 均处于冷却期",
                 self.provider, len(self._keys),
             )
-            return self._keys[0]
+            return None
 
     def mark_unavailable(self, key: str, cooldown: int = _KEY_COOLDOWN_SECONDS) -> None:
         """标记 Key 暂时不可用（供应商返回 429/401 时调用）"""

server/ai-gateway/config/key_pool.py

@@ -214,15 +214,30 @@ async def ai_error_handler(request: Request, exc: AIError) -> JSONResponse:
         "AIError: %s (status=%d, path=%s)",
         exc.message, exc.status_code, request.url.path,
     )
+    # GW-M6: 不向客户端透传上游错误细节——exc.message/reason 可能含
+    # provider 内部信息、prompt 片段、配额详情，仅返回通用文案与结构化字段
+    safe_detail = {
+        k: v for k, v in exc.detail.items()
+        if k in ("provider", "feature", "limit", "model")
+    }
     return JSONResponse(
         status_code=exc.status_code,
         content={
-            "detail": exc.message,
-            **exc.detail,
+            "detail": _GENERIC_ERROR_MESSAGES.get(exc.status_code, "AI 服务暂时不可用"),
+            **safe_detail,
         },
     )
 
 
+# 上游错误脱敏后的通用错误文案（GW-M6）
+_GENERIC_ERROR_MESSAGES: dict[int, str] = {
+    401: "认证失败，请重新登录",
+    429: "请求过于频繁，请稍后重试",
+    502: "模型服务响应异常，请稍后重试",
+    503: "AI 服务暂时不可用，请稍后重试",
+}
+
+
 # ============================================================
 # 注册路由
 # ============================================================

server/ai-gateway/main.py

@@ -119,6 +119,17 @@ def _normalize_pem_key(raw: str) -> str:
 _jwks_cache: Optional[dict] = None
 _jwks_cache_time: float = 0.0
 _JWKS_CACHE_TTL: int = 3600  # 缓存有效期（秒），默认 1 小时
+# GW-M3: 防缓存击穿锁 + 共享连接池客户端（避免每次请求新建 TCP/TLS 连接）
+_jwks_lock: asyncio.Lock = asyncio.Lock()
+_jwks_client: Optional[httpx.AsyncClient] = None
+
+
+def _get_jwks_client() -> httpx.AsyncClient:
+    """获取共享 JWKS HTTP 客户端（懒初始化，连接池复用）"""
+    global _jwks_client
+    if _jwks_client is None:
+        _jwks_client = httpx.AsyncClient(timeout=10)
+    return _jwks_client
 
 
 def _resolve_jwks_url() -> str:
@@ -136,26 +147,29 @@ async def _fetch_jwks(jwks_url: str) -> dict:
     """
     获取 JWKS（带 TTL 缓存，默认 1 小时刷新一次）。
 
-    网络失败时若已有缓存，则返回过期缓存以保证服务可用性。
+    GW-M3: 网络失败时 fail-closed（拒绝验证）而非返回过期缓存——
+    密钥轮换后过期缓存会让旧 token 在验证窗口内继续有效（越权窗口）。
+    asyncio.Lock 防止冷启动多请求并发刷新（缓存击穿）。
     """
     global _jwks_cache, _jwks_cache_time
     now = time.time()
     if _jwks_cache is not None and (now - _jwks_cache_time) < _JWKS_CACHE_TTL:
         return _jwks_cache
-    try:
-        resp = await asyncio.to_thread(httpx.get, jwks_url, timeout=10)
-        resp.raise_for_status()
-        _jwks_cache = resp.json()
-        _jwks_cache_time = now
-        logger.info("JWKS 获取成功，缓存已更新: %s", jwks_url)
-        return _jwks_cache
-    except Exception as e:
-        logger.error("JWKS 获取失败: %s, error=%s", jwks_url, str(e))
-        # 降级：返回过期缓存（若有），避免单次网络抖动导致验签全失败
-        if _jwks_cache is not None:
-            logger.warning("JWKS 获取失败，使用过期缓存（可能已过期）")
+    async with _jwks_lock:
+        # 双重检查：等待锁期间其他协程可能已刷新缓存
+        now = time.time()
+        if _jwks_cache is not None and (now - _jwks_cache_time) < _JWKS_CACHE_TTL:
             return _jwks_cache
-        raise
+        try:
+            resp = await _get_jwks_client().get(jwks_url)
+            resp.raise_for_status()
+            _jwks_cache = resp.json()
+            _jwks_cache_time = time.time()
+            logger.info("JWKS 获取成功，缓存已更新: %s", jwks_url)
+            return _jwks_cache
+        except Exception as e:
+            logger.error("JWKS 获取失败: %s, error=%s", jwks_url, str(e))
+            raise
 
 
 def _b64url_to_int(val: str) -> int: