@agentunion/kite 1.3.2 → 1.5.0

package/extensions/services/proxy/evol/server/claude_proxy_async.py

@@ -0,0 +1,3430 @@
+#!/usr/bin/env python3
+"""
+Claude API HTTP代理服务器 - FastAPI异步版本
+通过AgentCP转发请求到Claude服务
+此版本集成到FastAPI中，提供高并发能力
+
+重建机制：
+1. 使用 _rebuild_lock 保护全局变量修改，防止竞态条件
+2. 同步重建入口：_full_rebuild_agentcp_system()（用于 WebSocket 断开回调）
+3. 异步重建入口：force_rebuild_agentcp_system()（用于 API 调用）
+4. 30分钟冷却机制防止频繁重建
+5. 连续无响应计数机制：只有连续10次无响应才触发自动重建，其他情况直接返回错误让用户重试
+"""
+
+import asyncio
+import json
+import time
+import os,uuid
+import urllib.parse
+import threading
+from datetime import datetime
+from typing import Optional
+import httpx
+from fastapi import Request, Response, Header, HTTPException
+from fastapi.responses import StreamingResponse, JSONResponse
+
+from agentcp.agentcp import AgentID
+from agentcp.base.log import log_error, log_info, set_log_enabled
+from ..config import API_BASE_URL
+from ..presenter.configPresenter import configPresenter
+from ..presenter.userPresenter import userPresenter
+try:
+    from ..presenter.apikeyPresenter import apikeyPresenter
+except ImportError:
+    apikeyPresenter = None
+from ..http.async_http import AsyncHttpClient
+try:
+    from ..presenter.creditsLockManager import credits_lock_manager
+except ImportError:
+    class _CreditsLockManagerStub:
+        async def check_and_reserve_credits(self, **kwargs):
+            return {"success": True, "balance": 10000, "available": 10000, "reserved": 0}
+        async def confirm_credits_usage(self, **kwargs):
+            pass
+        async def release_reserved_credits(self, **kwargs):
+            pass
+    credits_lock_manager = _CreditsLockManagerStub()
+from ..config import ENABLE_CLAUDE_PROXY_LOG
+from ..version import __version__, __cmp_version__
+# ✅ P0修复：导入异常处理器
+try:
+    from ..utils.exception_handler import handle_exception, log_and_ignore, ExceptionCategory
+except ImportError:
+    # 降级处理
+    def handle_exception(e, **kwargs):
+        print(f"[ClaudeProxy Error] {kwargs.get('context', '')}: {e}")
+        import traceback
+        traceback.print_exc()
+    def log_and_ignore(e, **kwargs):
+        pass
+    class ExceptionCategory:
+        NETWORK = "network"
+        AGENTCP = "agentcp"
+        CONCURRENT = "concurrent"
+
+# 初始化 agentcp 的日志系统
+import logging
+set_log_enabled(True, logging.INFO)
+
+
+# 全局变量
+agentId: AgentID = None
+# claude_agent_name 现在从配置中读取，不再硬编码
+_rebuild_in_progress: bool = False  # 防止重复触发重建
+_rebuild_lock = threading.Lock()  # 保护重建状态和全局变量的线程锁
+_last_full_agentcp_rebuild_time: float = 0  # 上次完全重建AgentCP体系的时间
+_full_agentcp_rebuild_cooldown: float = 1800  # 完全重建AgentCP的冷却时间（30分钟）
+_agentcp_instance = None  # 保持 AgentCP 实例引用，防止 GC
+_consecutive_no_response_count: int = 0  # 连续无响应计数
+_consecutive_no_response_threshold: int = 10  # 连续无响应触发重建的阈值
+_no_response_count_lock = threading.Lock()  # 保护计数器的线程锁
+
+
+def _increment_no_response_count() -> int:
+    """
+    增加连续无响应计数并返回当前值
+
+    Returns:
+        int: 当前连续无响应计数
+
+    健壮性保证：
+    - 使用线程锁保护计数器操作
+    - 异常情况下返回安全的默认值
+    """
+    global _consecutive_no_response_count
+    try:
+        with _no_response_count_lock:
+            _consecutive_no_response_count += 1
+            current_count = _consecutive_no_response_count
+            print(f"[NoResponseCounter] 连续无响应计数: {current_count}/{_consecutive_no_response_threshold}")
+            return current_count
+    except Exception as e:
+        print(f"[NoResponseCounter] ❌ 增加计数异常: {e}")
+        # 异常情况下返回1，确保至少有一次计数
+        return 1
+
+
+def _reset_no_response_count():
+    """
+    重置连续无响应计数（在成功收到响应时调用）
+
+    健壮性保证：
+    - 使用线程锁保护计数器操作
+    - 异常情况下静默处理，不影响主流程
+    """
+    global _consecutive_no_response_count
+    try:
+        with _no_response_count_lock:
+            if _consecutive_no_response_count > 0:
+                print(f"[NoResponseCounter] 重置连续无响应计数 (之前: {_consecutive_no_response_count})")
+                _consecutive_no_response_count = 0
+    except Exception as e:
+        print(f"[NoResponseCounter] ❌ 重置计数异常: {e}")
+        # 异常情况下尝试强制重置
+        try:
+            _consecutive_no_response_count = 0
+        except:
+            pass
+
+
+def _should_trigger_rebuild() -> bool:
+    """
+    判断是否应该触发重建（连续无响应次数达到阈值）
+
+    Returns:
+        bool: 是否应该触发重建
+
+    健壮性保证：
+    - 使用线程锁保护计数器读取
+    - 异常情况下返回 False（不触发重建）
+    """
+    try:
+        with _no_response_count_lock:
+            return _consecutive_no_response_count >= _consecutive_no_response_threshold
+    except Exception as e:
+        print(f"[NoResponseCounter] ❌ 判断重建条件异常: {e}")
+        # 异常情况下不触发重建，保守处理
+        return False
+
+
+def _clear_async_session_manager_cache():
+    """
+    清空 AsyncSessionManager 的所有缓存
+
+    这是一个统一的缓存清理入口，在以下场景调用：
+    - AgentID 重建时
+    - WebSocket 断开重连时
+    - 强制重建时
+
+    清理内容：
+    - _sessions: api_key -> session_id 映射
+    - _session_info: session_id 信息
+    - _handler_registered: handler 注册状态
+    - _pending_requests: 待处理请求
+    - _request_result_map: 请求结果映射
+    - _session_handlers: session handler 引用
+    """
+    global async_session_manager
+
+    if async_session_manager is None:
+        print("[CacheClear] AsyncSessionManager 未初始化，跳过清理")
+        return
+
+    print("[CacheClear] 🧹 清理 AsyncSessionManager 缓存...")
+    try:
+        # 获取清理前的统计信息
+        sessions_count = len(async_session_manager._sessions)
+        pending_count = len(async_session_manager._pending_requests)
+        timestamps_count = len(async_session_manager._request_timestamps) if hasattr(async_session_manager, '_request_timestamps') else 0
+
+        # 清空所有缓存
+        async_session_manager._sessions.clear()
+        async_session_manager._session_info.clear()
+        async_session_manager._handler_registered.clear()
+        async_session_manager._pending_requests.clear()
+        async_session_manager._request_result_map.clear()
+        if hasattr(async_session_manager, '_session_handlers'):
+            async_session_manager._session_handlers.clear()
+        # ✅ 清理时间戳记录
+        if hasattr(async_session_manager, '_request_timestamps'):
+            async_session_manager._request_timestamps.clear()
+
+        print(f"[CacheClear] ✓ 已清理 {sessions_count} 个 session, {pending_count} 个待处理请求, {timestamps_count} 个时间戳记录")
+    except Exception as e:
+        print(f"[CacheClear] ⚠️ 清理异常（已忽略）: {e}")
+
+
+def _full_rebuild_agentcp_system() -> bool:
+    """
+    完全重建 AgentCP 体系（唯一的同步重建入口）
+
+    此方法用于 WebSocket 断开回调等同步场景。
+    使用 _rebuild_lock 保护全局变量修改，防止竞态条件。
+
+    流程：
+    1. 清空 AsyncSessionManager 缓存
+    2. 尝试使用现有 agentId.online() 重建
+    3. 如果失败，创建全新的 AgentCP 实例
+
+    冷却机制：30分钟内只执行一次（成功/失败都记录时间戳）
+
+    Returns:
+        bool: 是否重建成功
+    """
+    global agentId, _last_full_agentcp_rebuild_time, _agentcp_instance
+
+    print("[FullRebuild] 开始完全重建 AgentCP 体系...")
+    log_info("[FullRebuild] 开始完全重建 AgentCP 体系")
+
+    # 更新时间戳（在开始时更新，防止频繁重试）
+    _last_full_agentcp_rebuild_time = time.time()
+
+    try:
+        # 步骤1: 清空 AsyncSessionManager 缓存
+        print("[FullRebuild] 步骤1: 清空 session 缓存...")
+        _clear_async_session_manager_cache()
+
+        # 步骤2: 如果 agentId 存在，直接调用 online() 重建
+        # 使用锁保护对全局变量的读取
+        with _rebuild_lock:
+            current_agent = agentId
+
+        if current_agent is not None:
+            print(f"[FullRebuild] 步骤2: 使用 agentId.online() 重建: {current_agent.id}")
+
+            # agentId.online() 会：
+            # 1. 调用 session_manager.close_all_session() 关闭所有旧连接
+            # 2. 创建新的 SessionManager
+            # 3. 创建新的 MessageClient 并建立 WebSocket 连接
+            current_agent.online()
+
+            if current_agent.is_online_success:
+                # 【重要】AgentID 上线后统一入口 - 初始化监听器等
+                from ..presenter.agentIdPresenter import evol_agentId_online
+                evol_agentId_online(current_agent)
+
+                # 使用锁保护全局变量同步
+                with _rebuild_lock:
+                    userPresenter.agentId = current_agent
+
+                # 注册断开回调
+                _register_disconnect_callback(current_agent, disable_auto_reconnect=True)
+
+                print(f"[FullRebuild] 重建成功（通过 online）: {current_agent.id}")
+                log_info(f"[FullRebuild] 重建成功: {current_agent.id}")
+                return True
+            else:
+                print(f"[FullRebuild] online() 失败，尝试完全重建...")
+                # 继续执行完全重建
+
+        # 步骤3: 完全重建（agentId 不存在或 online 失败）
+        print("[FullRebuild] 步骤3: 完全重建 AgentCP...")
+        from pathlib import Path
+        from agentcp import AgentCP
+
+        evol_user_dir = Path.home() / ".evol"
+        agentcp_dir = evol_user_dir / "agentcp" / "AIDs"
+
+        if not agentcp_dir.exists():
+            print("[FullRebuild] 本地无 AID 数据目录")
+            return False
+
+        aid_dirs = [d for d in agentcp_dir.iterdir() if d.is_dir()]
+        if not aid_dirs:
+            print("[FullRebuild] 本地无可用 AID")
+            return False
+
+        first_aid = aid_dirs[0].name
+        print(f"[FullRebuild] 发现本地 AID: {first_aid}")
+
+        # 使用锁保护全局变量修改
+        with _rebuild_lock:
+            # 获取旧实例引用（注意：如果步骤2失败，current_agent.online() 已经尝试过重建，
+            # 其内部会调用 close_all_session()，所以这里不需要再次关闭）
+            old_agentcp = _agentcp_instance
+
+            # 清空旧引用
+            agentId = None
+            _agentcp_instance = None
+            userPresenter.agentId = None
+
+        # 等待资源释放
+        time.sleep(0.5)
+
+        # 创建全新的 AgentCP 实例
+        new_agentcp = AgentCP(evol_user_dir, seed_password="evol_user_default_password", debug=False)
+        new_agentid = new_agentcp.load_aid(first_aid)
+
+        if new_agentid is None:
+            print(f"[FullRebuild] 加载 AID 失败: {first_aid}")
+            return False
+
+        print(f"[FullRebuild] AID 加载成功: {new_agentid.id}")
+
+        # 上线
+        new_agentid.online()
+
+        if new_agentid.is_online_success:
+            # 【重要】AgentID 上线后统一入口 - 初始化监听器等
+            from ..presenter.agentIdPresenter import evol_agentId_online
+            evol_agentId_online(new_agentid)
+
+            # 使用锁保护全局变量更新
+            with _rebuild_lock:
+                agentId = new_agentid
+                _agentcp_instance = new_agentcp
+                userPresenter.agentId = new_agentid
+
+            _register_disconnect_callback(new_agentid, disable_auto_reconnect=True)
+
+            print(f"[FullRebuild] 完全重建成功!")
+            log_info(f"[FullRebuild] 完全重建成功: {new_agentid.id}")
+            return True
+        else:
+            print(f"[FullRebuild] AgentID 上线失败")
+            return False
+
+    except Exception as e:
+        print(f"[FullRebuild] 完全重建异常: {e}")
+        log_error(f"[FullRebuild] 完全重建异常: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+async def force_rebuild_agentcp_system(bypass_cooldown: bool = True) -> dict:
+    """
+    强制重建 AgentCP 体系（异步版本）
+
+    用于 API 调用触发的重建场景。
+    使用 _rebuild_lock 保护全局变量修改，防止竞态条件。
+
+    流程：
+    1. 清空 AsyncSessionManager 缓存
+    2. 尝试使用现有 agentId.online() 重建
+    3. 如果失败，尝试重新登录或从本地加载 AID
+
+    Args:
+        bypass_cooldown: 是否绕过30分钟冷却时间（默认True）
+
+    Returns:
+        dict: {
+            "success": bool,
+            "message": str,
+            "agent_id": str or None,
+            "cleanup_details": dict
+        }
+    """
+    global agentId, _last_full_agentcp_rebuild_time, _agentcp_instance, _rebuild_in_progress
+
+    print("\n" + "=" * 80)
+    print("[ForceRebuild] 开始强制重建 AgentCP 体系")
+    print("=" * 80)
+    log_info("[ForceRebuild] 开始强制重建 AgentCP 体系")
+
+    cleanup_details = {
+        "session_cache_cleared": False,
+        "agentid_online_success": False,
+        "old_agent_id": None,
+        "new_agent_id": None
+    }
+
+    # 检查冷却时间（可选绕过）
+    if not bypass_cooldown:
+        time_since_last = time.time() - _last_full_agentcp_rebuild_time
+        if time_since_last < _full_agentcp_rebuild_cooldown:
+            remaining = (_full_agentcp_rebuild_cooldown - time_since_last) / 60
+            with _rebuild_lock:
+                current_agent_id = agentId.id if agentId else None
+            return {
+                "success": False,
+                "message": f"重建冷却中，剩余 {remaining:.1f} 分钟",
+                "agent_id": current_agent_id,
+                "cleanup_details": cleanup_details
+            }
+
+    # 使用锁防止并发重建
+    with _rebuild_lock:
+        if _rebuild_in_progress:
+            current_agent_id = agentId.id if agentId else None
+            return {
+                "success": False,
+                "message": "重建已在进行中，请稍后重试",
+                "agent_id": current_agent_id,
+                "cleanup_details": cleanup_details
+            }
+        _rebuild_in_progress = True
+
+    try:
+        # 更新重建时间戳（在开始时更新，防止频繁重试）
+        _last_full_agentcp_rebuild_time = time.time()
+
+        # ========================
+        # 步骤1: 清空 AsyncSessionManager 缓存
+        # ========================
+        print("[ForceRebuild] 步骤1: 清空 session 缓存...")
+        _clear_async_session_manager_cache()
+        cleanup_details["session_cache_cleared"] = True
+
+        # ========================
+        # 步骤2: 使用 agentId.online() 重建
+        # ========================
+        # 使用锁保护读取全局变量
+        with _rebuild_lock:
+            current_agent = agentId
+            if current_agent is not None:
+                cleanup_details["old_agent_id"] = current_agent.id
+
+        if current_agent is not None:
+            print(f"[ForceRebuild] 步骤2: 使用 agentId.online() 重建: {current_agent.id}")
+
+            # agentId.online() 会：
+            # 1. 调用 session_manager.close_all_session() 关闭所有旧连接
+            # 2. 创建新的 SessionManager
+            # 3. 创建新的 MessageClient 并建立 WebSocket 连接
+            await asyncio.to_thread(current_agent.online)
+
+            if current_agent.is_online_success:
+                # 【重要】AgentID 上线后统一入口 - 初始化监听器等
+                from ..presenter.agentIdPresenter import evol_agentId_online
+                evol_agentId_online(current_agent)
+
+                with _rebuild_lock:
+                    userPresenter.agentId = current_agent
+                _register_disconnect_callback(current_agent, disable_auto_reconnect=True)
+                cleanup_details["new_agent_id"] = current_agent.id
+                cleanup_details["agentid_online_success"] = True
+
+                print("=" * 80)
+                print(f"[ForceRebuild] 重建成功（通过 online）!")
+                print(f"[ForceRebuild]   - AgentID: {current_agent.id}")
+                print("=" * 80 + "\n")
+                log_info(f"[ForceRebuild] 重建成功: {current_agent.id}")
+
+                return {
+                    "success": True,
+                    "message": "强制重建 AgentCP 体系成功",
+                    "agent_id": current_agent.id,
+                    "cleanup_details": cleanup_details
+                }
+            else:
+                print(f"[ForceRebuild] online() 失败，尝试完全重建...")
+                # 继续执行完全重建
+
+        # ========================
+        # 步骤3: 完全重建（agentId 不存在或 online 失败）
+        # ========================
+        print("[ForceRebuild] 步骤3: 完全重建 AgentCP...")
+
+        # 使用锁保护全局变量修改
+        # 注意：如果步骤2失败，current_agent.online() 已经尝试过重建，
+        # 其内部会调用 close_all_session()，所以这里不需要再次关闭
+        with _rebuild_lock:
+            old_agentcp = _agentcp_instance
+            agentId = None
+            _agentcp_instance = None
+            userPresenter.agentId = None
+
+        # 等待资源释放
+        await asyncio.sleep(0.5)
+
+        # 检查用户登录状态
+        if userPresenter.is_logged_in():
+            print("[ForceRebuild]   - 用户已登录，调用 user_agent_login() 重新认证...")
+            login_result = await userPresenter.user_agent_login()
+
+            if login_result.get("status") == "success":
+                with _rebuild_lock:
+                    agentId = userPresenter.agentId
+                    # 同步 userPresenter 的 AgentCP 实例引用
+                    _agentcp_instance = userPresenter._agentcp_instance
+                    new_agent = agentId
+                if new_agent:
+                    _register_disconnect_callback(new_agent, disable_auto_reconnect=True)
+                    cleanup_details["new_agent_id"] = new_agent.id
+                    cleanup_details["agentid_online_success"] = True
+
+                    print("=" * 80)
+                    print(f"[ForceRebuild] 重建成功（通过重新认证）!")
+                    print(f"[ForceRebuild]   - 旧 AgentID: {cleanup_details['old_agent_id']}")
+                    print(f"[ForceRebuild]   - 新 AgentID: {cleanup_details['new_agent_id']}")
+                    print("=" * 80 + "\n")
+                    log_info(f"[ForceRebuild] 重建成功: {cleanup_details['old_agent_id']} -> {cleanup_details['new_agent_id']}")
+
+                    return {
+                        "success": True,
+                        "message": "强制重建 AgentCP 体系成功",
+                        "agent_id": new_agent.id,
+                        "cleanup_details": cleanup_details
+                    }
+            else:
+                error_msg = login_result.get("error", "未知错误")
+                print(f"[ForceRebuild] 重新认证失败: {error_msg}")
+        else:
+            print("[ForceRebuild]   - 用户未登录，尝试从本地加载 AID...")
+
+        # 从本地加载 AID
+        from pathlib import Path
+        from agentcp import AgentCP
+
+        evol_user_dir = Path.home() / ".evol"
+        agentcp_dir = evol_user_dir / "agentcp" / "AIDs"
+
+        if not agentcp_dir.exists():
+            return {
+                "success": False,
+                "message": "本地无 AID 数据目录，请登录后重试",
+                "agent_id": None,
+                "cleanup_details": cleanup_details
+            }
+
+        aid_dirs = [d for d in agentcp_dir.iterdir() if d.is_dir()]
+        if not aid_dirs:
+            return {
+                "success": False,
+                "message": "本地无可用 AID，请登录后重试",
+                "agent_id": None,
+                "cleanup_details": cleanup_details
+            }
+
+        first_aid = aid_dirs[0].name
+        print(f"[ForceRebuild]   发现本地 AID: {first_aid}")
+
+        new_agentcp = AgentCP(evol_user_dir, seed_password="evol_user_default_password", debug=False, run_proxy=False)
+        new_agentid = new_agentcp.load_aid(first_aid)
+
+        if new_agentid is None:
+            return {
+                "success": False,
+                "message": f"加载 AID 失败: {first_aid}",
+                "agent_id": None,
+                "cleanup_details": cleanup_details
+            }
+
+        print(f"[ForceRebuild]   AID 加载成功: {new_agentid.id}")
+
+        # 上线
+        await asyncio.to_thread(new_agentid.online)
+
+        if new_agentid.is_online_success:
+            # 【重要】AgentID 上线后统一入口 - 初始化监听器等
+            from ..presenter.agentIdPresenter import evol_agentId_online
+            evol_agentId_online(new_agentid)
+
+            # 使用锁保护全局变量更新
+            with _rebuild_lock:
+                agentId = new_agentid
+                _agentcp_instance = new_agentcp
+                userPresenter.agentId = new_agentid
+
+            _register_disconnect_callback(new_agentid, disable_auto_reconnect=True)
+            cleanup_details["new_agent_id"] = new_agentid.id
+            cleanup_details["agentid_online_success"] = True
+
+            print("=" * 80)
+            print(f"[ForceRebuild] 完全重建成功!")
+            print(f"[ForceRebuild]   - 旧 AgentID: {cleanup_details['old_agent_id']}")
+            print(f"[ForceRebuild]   - 新 AgentID: {cleanup_details['new_agent_id']}")
+            print("=" * 80 + "\n")
+            log_info(f"[ForceRebuild] 完全重建成功: {new_agentid.id}")
+
+            return {
+                "success": True,
+                "message": "强制重建 AgentCP 体系成功",
+                "agent_id": new_agentid.id,
+                "cleanup_details": cleanup_details
+            }
+        else:
+            return {
+                "success": False,
+                "message": "AID 上线失败",
+                "agent_id": None,
+                "cleanup_details": cleanup_details
+            }
+
+    except Exception as e:
+        import traceback
+        error_traceback = traceback.format_exc()
+        print(f"[ForceRebuild] 强制重建异常: {e}")
+        print(f"[ForceRebuild] 异常堆栈:\n{error_traceback}")
+        log_error(f"[ForceRebuild] 强制重建异常: {e}")
+
+        with _rebuild_lock:
+            current_agent_id = agentId.id if agentId else None
+
+        return {
+            "success": False,
+            "message": f"强制重建异常: {str(e)}",
+            "agent_id": current_agent_id,
+            "cleanup_details": cleanup_details
+        }
+    finally:
+        with _rebuild_lock:
+            _rebuild_in_progress = False
+
+
+def _on_websocket_disconnect(agent_id: str, server_url: str, code: int, reason: str):
+    """
+    WebSocket 断开回调 - 当连接断开时自动触发重建
+
+    此函数由 MessageClient 在 WebSocket 断开时调用。
+    它会在新线程中触发完全重建 AgentCP 体系（30分钟内只执行一次）。
+
+    健壮性保证：
+    - 所有参数访问都有安全保护
+    - 使用线程锁防止竞态条件
+    - 即使重建线程启动失败也不会崩溃
+    """
+    global _rebuild_in_progress, _last_full_agentcp_rebuild_time
+
+    try:
+        print(f"[DisconnectCallback] WebSocket 断开!")
+        print(f"[DisconnectCallback]   agent_id: {agent_id}")
+        print(f"[DisconnectCallback]   server_url: {server_url}")
+        print(f"[DisconnectCallback]   code: {code}")
+        print(f"[DisconnectCallback]   reason: {reason}")
+        log_info(f"[DisconnectCallback] WebSocket 断开: agent={agent_id}, code={code}, reason={reason}")
+    except Exception as log_err:
+        print(f"[DisconnectCallback] 日志打印异常（不影响处理）: {log_err}")
+
+    # 使用锁保护，防止竞态条件
+    try:
+        with _rebuild_lock:
+            if _rebuild_in_progress:
+                print("[DisconnectCallback] 重建已在进行中，跳过")
+                return
+            _rebuild_in_progress = True
+    except Exception as lock_err:
+        print(f"[DisconnectCallback] 获取锁异常: {lock_err}")
+        return
+
+    try:
+        # 在新线程中执行重建，避免阻塞 WebSocket 回调
+        def trigger_rebuild():
+            global _rebuild_in_progress, _last_full_agentcp_rebuild_time
+            try:
+                print("[DisconnectCallback] 触发后台重建...")
+                log_info("[DisconnectCallback] 触发后台重建...")
+
+                # 检查冷却时间（30分钟内只执行一次）
+                time_since_last = time.time() - _last_full_agentcp_rebuild_time
+                if time_since_last < _full_agentcp_rebuild_cooldown:
+                    remaining = (_full_agentcp_rebuild_cooldown - time_since_last) / 60
+                    print(f"[DisconnectCallback] 完全重建冷却中，剩余 {remaining:.1f} 分钟")
+                    log_info(f"[DisconnectCallback] 完全重建冷却中，剩余 {remaining:.1f} 分钟")
+                    return
+
+                # 直接执行完全重建 AgentCP 体系
+                print("[DisconnectCallback] 触发完全重建 AgentCP 体系...")
+                log_info("[DisconnectCallback] 触发完全重建 AgentCP 体系")
+                full_rebuild_success = _full_rebuild_agentcp_system()
+                if full_rebuild_success:
+                    print("[DisconnectCallback] 完全重建 AgentCP 体系成功")
+                    log_info("[DisconnectCallback] 完全重建 AgentCP 体系成功")
+                else:
+                    print("[DisconnectCallback] 完全重建 AgentCP 体系失败")
+                    log_error("[DisconnectCallback] 完全重建 AgentCP 体系失败")
+
+            except Exception as e:
+                print(f"[DisconnectCallback] 重建异常: {e}")
+                log_error(f"[DisconnectCallback] 重建异常: {e}")
+                try:
+                    import traceback
+                    traceback.print_exc()
+                except:
+                    pass
+            finally:
+                # 使用锁保护
+                try:
+                    with _rebuild_lock:
+                        _rebuild_in_progress = False
+                except Exception:
+                    _rebuild_in_progress = False
+
+        rebuild_thread = threading.Thread(target=trigger_rebuild, daemon=True)
+        rebuild_thread.start()
+        print("[DisconnectCallback] 已启动重建线程")
+
+    except Exception as e:
+        # 使用锁保护
+        try:
+            with _rebuild_lock:
+                _rebuild_in_progress = False
+        except Exception:
+            _rebuild_in_progress = False
+        print(f"[DisconnectCallback] 启动重建线程失败: {e}")
+        log_error(f"[DisconnectCallback] 启动重建线程失败: {e}")
+
+
+def _register_disconnect_callback(aid: AgentID, disable_auto_reconnect: bool = True):
+    """
+    为 AgentID 注册断开回调
+
+    健壮性保证：
+    - 所有操作都有异常保护
+    - 即使注册失败也不会崩溃
+    - 禁用自动重连时容错处理
+
+    Args:
+        aid: AgentID 实例
+        disable_auto_reconnect: 是否禁用 MessageClient 的自动重连（避免双重重建冲突）
+    """
+    try:
+        if aid is None:
+            print("[RegisterCallback] aid 为空，跳过注册")
+            return
+
+        if hasattr(aid, 'set_disconnect_callback'):
+            try:
+                aid.set_disconnect_callback(_on_websocket_disconnect)
+                aid_id = aid.id if hasattr(aid, 'id') else 'unknown'
+                print(f"[RegisterCallback] 已为 AgentID({aid_id}) 注册断开回调")
+                log_info(f"[RegisterCallback] 已为 AgentID({aid_id}) 注册断开回调")
+            except Exception as cb_err:
+                print(f"[RegisterCallback] 注册断开回调失败: {cb_err}")
+
+        # 禁用 MessageClient 的自动重连，避免双重重建冲突
+        if disable_auto_reconnect:
+            try:
+                if aid.session_manager and hasattr(aid.session_manager, 'message_client_map'):
+                    for server_url, mc in aid.session_manager.message_client_map.items():
+                        try:
+                            if mc and hasattr(mc, 'config') and mc.config and hasattr(mc.config, 'auto_reconnect'):
+                                mc.config.auto_reconnect = False
+                                print(f"[RegisterCallback] 已禁用 MessageClient({server_url}) 的自动重连")
+                                log_info(f"[RegisterCallback] 已禁用 MessageClient({server_url}) 的自动重连")
+                        except Exception as mc_err:
+                            print(f"[RegisterCallback] 禁用 MessageClient({server_url}) auto_reconnect 失败: {mc_err}")
+            except Exception as sm_err:
+                print(f"[RegisterCallback] 访问 session_manager 异常: {sm_err}")
+
+    except Exception as e:
+        print(f"[RegisterCallback] 注册回调过程异常: {e}")
+        try:
+            import traceback
+            traceback.print_exc()
+        except:
+            pass
+
+
+class ApiKeyManager:
+    """API Key 管理器 - 智能缓存和校验策略"""
+
+    def __init__(self):
+        self._api_keys = {}  # {apiKey: {"status": 1/0, "id": xxx, "name": xxx}}
+        self._last_update_time = 0  # 上次更新时间
+        self._cache_ttl = 300  # 缓存5分钟
+        self._lock = asyncio.Lock()  # 异步锁
+
+    async def validate_api_key(self, api_key: str) -> dict:
+        """
+        校验 API Key
+
+        Args:
+            api_key: 要校验的 API Key
+
+        Returns:
+            dict: {"valid": bool, "from_cache": bool, "error": str}
+        """
+        async with self._lock:
+            current_time = time.time()
+
+            # 策略1: 如果缓存中存在且启用，直接返回（缓存命中）
+            if api_key in self._api_keys:
+                cached_key = self._api_keys[api_key]
+                # 检查缓存是否过期
+                if current_time - self._last_update_time < self._cache_ttl:
+                    if cached_key.get("status") == 1:
+                        log_info(f"[ApiKeyManager] API Key 缓存命中且启用: {api_key[:20]}...")
+                        return {"valid": True, "from_cache": True, "error": None}
+                    else:
+                        log_info(f"[ApiKeyManager] API Key 缓存命中但已禁用: {api_key[:20]}...")
+                        return {"valid": False, "from_cache": True, "error": "API Key 已被禁用"}
+
+            # 策略2: 缓存未命中或已过期，同步获取最新数据
+            log_info(f"[ApiKeyManager] API Key 缓存未命中，同步获取最新数据")
+            success = await self._refresh_api_keys()
+
+            if not success:
+                # 刷新失败，如果缓存中有这个key，使用缓存数据
+                if api_key in self._api_keys:
+                    cached_key = self._api_keys[api_key]
+                    if cached_key.get("status") == 1:
+                        log_info(f"[ApiKeyManager] API Key 刷新失败，使用缓存数据")
+                        return {"valid": True, "from_cache": True, "error": None}
+                    else:
+                        return {"valid": False, "from_cache": True, "error": "API Key 已被禁用"}
+                else:
+                    return {"valid": False, "from_cache": False, "error": "无法验证 API Key，请稍后重试"}
+
+            # 策略3: 刷新成功，检查 API Key 是否存在且启用
+            if api_key in self._api_keys:
+                api_key_data = self._api_keys[api_key]
+                if api_key_data.get("status") == 1:
+                    log_info(f"[ApiKeyManager] API Key 校验通过: {api_key[:20]}...")
+                    return {"valid": True, "from_cache": False, "error": None}
+                else:
+                    log_info(f"[ApiKeyManager] API Key 已禁用: {api_key[:20]}...")
+                    return {"valid": False, "from_cache": False, "error": "API Key 已被禁用"}
+            else:
+                log_info(f"[ApiKeyManager] API Key 不存在: {api_key[:20]}...")
+                return {"valid": False, "from_cache": False, "error": "API Key 不存在或未启用"}
+
+    async def _refresh_api_keys(self) -> bool:
+        """
+        从 apikeyPresenter 刷新 API Key 列表
+
+        Returns:
+            bool: 是否刷新成功
+        """
+        try:
+            log_info(f"[ApiKeyManager] 开始刷新 API Key 列表")
+
+            # 调用 apikeyPresenter 获取 API Key 列表
+            result = await apikeyPresenter.get_api_key_list()
+
+            if result and result.get("status") == "success":
+                response_data = result.get("data", {})
+                if response_data.get("code") == 200:
+                    api_key_list = response_data.get("data", [])
+
+                    # 重建缓存
+                    new_cache = {}
+                    for key_data in api_key_list:
+                        api_key = key_data.get("apiKey")
+                        if api_key:
+                            new_cache[api_key] = {
+                                "id": key_data.get("id"),
+                                "name": key_data.get("name"),
+                                "status": key_data.get("status"),
+                                "remark": key_data.get("remark")
+                            }
+
+                    self._api_keys = new_cache
+                    self._last_update_time = time.time()
+
+                    log_info(f"[ApiKeyManager] API Key 列表刷新成功，共 {len(new_cache)} 个")
+                    return True
+                else:
+                    error_msg = response_data.get("msg", "未知错误")
+                    log_error(f"[ApiKeyManager] API 返回错误: {error_msg}")
+                    return False
+            else:
+                error_msg = result.get("error", "未知错误")
+                log_error(f"[ApiKeyManager] 获取 API Key 列表失败: {error_msg}")
+                return False
+
+        except Exception as e:
+            log_error(f"[ApiKeyManager] 刷新 API Key 列表异常: {str(e)}")
+            return False
+
+    def get_cached_keys_count(self) -> int:
+        """获取缓存的 API Key 数量"""
+        return len(self._api_keys)
+
+    def clear_cache(self):
+        """清除缓存"""
+        self._api_keys = {}
+        self._last_update_time = 0
+        log_info(f"[ApiKeyManager] API Key 缓存已清除")
+
+
+# 全局 API Key 管理器实例
+api_key_manager = ApiKeyManager()
+
+
+class BalanceManager:
+    """余额管理器 - 分级缓存策略"""
+
+    # 分级缓存规则（根据积分余额动态设置缓存TTL）
+    TIERED_CACHE_RULES = [
+        {"min_credits": 50000, "ttl_seconds": 14400, "description": "≥5万分: 缓存4小时"},
+        {"min_credits": 30000, "ttl_seconds": 5400, "description": "3-5万分: 缓存90分钟"},
+        {"min_credits": 20000, "ttl_seconds": 2700, "description": "2-3万分: 缓存45分钟"},
+        {"min_credits": 10000, "ttl_seconds": 1800, "description": "1-2万分: 缓存30分钟"},
+        {"min_credits": 5000, "ttl_seconds": 600, "description": "5千-1万分: 缓存10分钟"},
+        {"min_credits": 2000, "ttl_seconds": 300, "description": "2千-5千分: 缓存5分钟"},
+        {"min_credits": 0, "ttl_seconds": 0, "description": "<2千分: 无缓存（每次实时查询）"},
+    ]
+
+    def __init__(self):
+        self._balance = None  # 当前余额
+        self._last_update_time = 0  # 上次更新时间
+        self._cache_ttl = 0  # 当前缓存的TTL（秒）
+        self._lock = asyncio.Lock()  # 异步锁
+        self._is_refreshing = False  # 是否正在刷新
+        self._last_fetch_failed = False  # 上次获取是否失败
+        self._force_sync_until = 0  # 强制同步模式的截止时间（时间戳）
+        self._users_count_on_same_device = 0  # 同设备8小时内的用户数
+        self._consecutive_passthrough_count = 0  # 连续放行次数（未获取到积分时）
+        self._max_passthrough_count = 5  # 最大连续放行次数
+
+    @staticmethod
+    def _get_cache_ttl(credits: int) -> int:
+        """
+        根据积分余额计算缓存TTL
+
+        Args:
+            credits: 积分余额
+
+        Returns:
+            int: 缓存TTL（秒），0表示不缓存
+        """
+        for rule in BalanceManager.TIERED_CACHE_RULES:
+            if credits >= rule["min_credits"]:
+                return rule["ttl_seconds"]
+        return 0  # 默认不缓存
+
+    def _is_cache_valid(self) -> bool:
+        """
+        检查缓存是否有效
+
+        Returns:
+            bool: 缓存是否有效
+        """
+        if self._balance is None:
+            return False
+
+        # TTL为0表示不缓存，直接返回False
+        if self._cache_ttl == 0:
+            return False
+
+        # 检查缓存是否过期
+        cache_age = time.time() - self._last_update_time
+        return cache_age < self._cache_ttl
+
+    async def get_balance(self, customer_aid: str, force_sync: bool = False) -> dict:
+        """
+        获取余额（分级缓存策略）
+
+        策略规则:
+        1. 首次获取失败 → 直接放行，异步重试获取
+        2. 连续放行超过5次 → 进入同步拦截模式
+        3. 有缓存时：
+           - 缓存有效 → 返回缓存 + 异步刷新
+           - 缓存过期 → 同步查询，失败则使用缓存放行
+        4. 积分 == 0 → 立即拒绝
+
+        Args:
+            customer_aid: 客户AID
+            force_sync: 是否强制同步获取
+
+        Returns:
+            dict: {"balance": float, "from_cache": bool, "error": str, "usersCountOnSameDeviceWithin8Hours": int}
+        """
+        async with self._lock:
+            current_time = time.time()
+
+            # 检查是否已连续放行超过5次，需要进入同步拦截模式
+            if self._balance is None and self._consecutive_passthrough_count >= self._max_passthrough_count:
+                log_error(f"[BalanceManager] 连续放行{self._consecutive_passthrough_count}次，进入同步拦截模式")
+                # 尝试同步获取
+                fetch_result = await self._fetch_balance(customer_aid)
+                if fetch_result is not None:
+                    balance = fetch_result.get("credits", 0)
+                    users_count = fetch_result.get("usersCountOnSameDeviceWithin8Hours", 0)
+                    self._balance = balance
+                    self._users_count_on_same_device = users_count
+                    self._last_update_time = current_time
+                    self._cache_ttl = self._get_cache_ttl(balance)
+                    self._last_fetch_failed = False
+                    self._consecutive_passthrough_count = 0  # 重置计数
+
+                    if balance == 0:
+                        return {"balance": 0, "from_cache": False, "error": "积分余额为0", "usersCountOnSameDeviceWithin8Hours": users_count}
+                    return {"balance": balance, "from_cache": False, "error": None, "usersCountOnSameDeviceWithin8Hours": users_count}
+                else:
+                    # 同步获取也失败，拦截请求
+                    return {"balance": 0, "from_cache": False, "error": "余额服务不可用，请稍后重试", "usersCountOnSameDeviceWithin8Hours": 0}
+
+            # 首次获取或无缓存 - 尝试获取，失败则放行
+            if self._balance is None:
+                log_info(f"[BalanceManager] 首次获取余额 (已放行{self._consecutive_passthrough_count}次)")
+                fetch_result = await self._fetch_balance(customer_aid)
+
+                if fetch_result is not None:
+                    balance = fetch_result.get("credits", 0)
+                    users_count = fetch_result.get("usersCountOnSameDeviceWithin8Hours", 0)
+                    self._balance = balance
+                    self._users_count_on_same_device = users_count
+                    self._last_update_time = current_time
+                    self._cache_ttl = self._get_cache_ttl(balance)
+                    self._last_fetch_failed = False
+                    self._consecutive_passthrough_count = 0  # 成功获取，重置计数
+
+                    ttl_desc = f"{self._cache_ttl}秒" if self._cache_ttl > 0 else "无缓存"
+                    log_info(f"[BalanceManager] 积分: {balance}, 缓存策略: {ttl_desc}")
+
+                    if balance == 0:
+                        return {"balance": 0, "from_cache": False, "error": "积分余额为0", "usersCountOnSameDeviceWithin8Hours": users_count}
+                    return {"balance": balance, "from_cache": False, "error": None, "usersCountOnSameDeviceWithin8Hours": users_count}
+                else:
+                    # 获取失败，放行并异步重试
+                    self._consecutive_passthrough_count += 1
+                    self._last_fetch_failed = True
+                    log_info(f"[BalanceManager] 余额获取失败，放行请求 (第{self._consecutive_passthrough_count}次)，启动异步重试")
+                    asyncio.create_task(self._async_retry_fetch(customer_aid))
+                    return {"balance": -1, "from_cache": False, "error": None, "usersCountOnSameDeviceWithin8Hours": 0, "service_unavailable": True}
+
+            # 有缓存余额的情况
+            # 检查缓存是否有效
+            if self._is_cache_valid():
+                # 缓存有效，返回缓存值并异步刷新
+                cache_age = current_time - self._last_update_time
+                log_info(f"[BalanceManager] 缓存有效 (积分: {self._balance}, 缓存年龄: {cache_age:.0f}秒, TTL: {self._cache_ttl}秒)")
+
+                # 启动异步刷新任务（不等待）
+                if not self._is_refreshing:
+                    asyncio.create_task(self._async_refresh_balance(customer_aid))
+
+                return {"balance": self._balance, "from_cache": True, "error": None, "usersCountOnSameDeviceWithin8Hours": self._users_count_on_same_device}
+
+            # 策略3: 缓存已过期 - 同步获取最新余额
+            else:
+                cache_age = current_time - self._last_update_time
+                log_info(f"[BalanceManager] 缓存已过期 (积分: {self._balance}, 缓存年龄: {cache_age:.0f}秒, TTL: {self._cache_ttl}秒)，同步查询")
+                fetch_result = await self._fetch_balance(customer_aid)
+
+                if fetch_result is not None:
+                    balance = fetch_result.get("credits", 0)
+                    users_count = fetch_result.get("usersCountOnSameDeviceWithin8Hours", 0)
+
+                    self._balance = balance
+                    self._users_count_on_same_device = users_count
+                    self._last_update_time = current_time
+                    self._cache_ttl = self._get_cache_ttl(balance)
+                    self._last_fetch_failed = False
+
+                    ttl_desc = f"{self._cache_ttl}秒" if self._cache_ttl > 0 else "无缓存"
+                    log_info(f"[BalanceManager] 积分: {balance}, 缓存策略: {ttl_desc}")
+
+                    if balance == 0:
+                        return {"balance": 0, "from_cache": False, "error": "积分余额为0", "usersCountOnSameDeviceWithin8Hours": users_count}
+
+                    return {"balance": balance, "from_cache": False, "error": None, "usersCountOnSameDeviceWithin8Hours": users_count}
+                else:
+                    # 刷新失败，使用缓存数据放行
+                    self._last_fetch_failed = True
+                    log_info(f"[BalanceManager] 缓存过期获取失败，使用缓存数据放行 (积分: {self._balance})")
+                    return {"balance": self._balance, "from_cache": True, "error": "余额服务异常，使用缓存数据", "usersCountOnSameDeviceWithin8Hours": self._users_count_on_same_device}
+
+    async def _fetch_balance(self, customer_aid: str) -> Optional[dict]:
+        """
+        从API获取余额
+        调用 userPresenter 的方法获取用户积分余额
+
+        Returns:
+            Optional[dict]: 包含 credits 和 usersCountOnSameDeviceWithin8Hours 的字典，失败返回None
+        """
+        try:
+            print(f"[BalanceManager] 调用 userPresenter.get_credits_balance() 获取积分余额")
+
+            # 调用 userPresenter 的方法获取积分余额
+            result = await userPresenter.get_credits_balance()
+
+            if result.get("status") == "success":
+                data = result.get("data", {})
+                if data.get("code") == 200:
+                    inner_data = data.get("data", {})
+                    credits = inner_data.get("credits", 0)
+                    users_count = inner_data.get("usersCountOnSameDeviceWithin8Hours", 0)
+                    print(f"[BalanceManager] 积分余额获取成功: {credits}, 同设备用户数: {users_count}")
+                    return {
+                        "credits": credits,
+                        "usersCountOnSameDeviceWithin8Hours": users_count
+                    }
+                else:
+                    # API返回业务错误码
+                    api_code = data.get("code", "")
+                    error_msg = data.get("msg", "未知错误")
+                    print(f"[BalanceManager] API返回错误: {error_msg} (code: {api_code})")
+                    print(f"[BalanceManager] 完整响应: {data}")
+                    return None
+            else:
+                # 请求失败
+                error_msg = result.get("error", "未知错误")
+                error_code = result.get("error_code", "")
+                need_relogin = result.get("need_relogin", False)
+                print(f"[BalanceManager] 获取积分余额失败: {error_msg}")
+                if error_code:
+                    print(f"[BalanceManager] 错误码: {error_code}")
+                if need_relogin:
+                    print(f"[BalanceManager] 需要重新登录")
+                print(f"[BalanceManager] 完整结果: {result}")
+                return None
+
+        except Exception as e:
+            import traceback
+            log_error(f"[BalanceManager] 获取余额异常: {str(e)}")
+            print(f"[BalanceManager] 异常堆栈:\n{traceback.format_exc()}")
+            return None
+
+    async def _async_refresh_balance(self, customer_aid: str):
+        """异步刷新余额（后台任务）"""
+        try:
+            self._is_refreshing = True
+            log_info(f"[BalanceManager] 开始异步刷新余额")
+
+            fetch_result = await self._fetch_balance(customer_aid)
+            if fetch_result is not None:
+                async with self._lock:
+                    old_balance = self._balance
+                    balance = fetch_result.get("credits", 0)
+                    users_count = fetch_result.get("usersCountOnSameDeviceWithin8Hours", 0)
+
+                    self._balance = balance
+                    self._users_count_on_same_device = users_count
+                    self._last_update_time = time.time()
+                    self._cache_ttl = self._get_cache_ttl(balance)
+                    self._last_fetch_failed = False
+
+                    ttl_desc = f"{self._cache_ttl}秒" if self._cache_ttl > 0 else "无缓存"
+                    log_info(f"[BalanceManager] 异步刷新完成，积分: {old_balance} → {balance}, 缓存策略: {ttl_desc}")
+            else:
+                async with self._lock:
+                    self._last_fetch_failed = True
+                log_info(f"[BalanceManager] 异步刷新失败")
+
+        except Exception as e:
+            async with self._lock:
+                self._last_fetch_failed = True
+            log_error(f"[BalanceManager] 异步刷新异常: {str(e)}")
+        finally:
+            self._is_refreshing = False
+
+    async def _async_retry_fetch(self, customer_aid: str, max_retries: int = 3, retry_delay: float = 5.0):
+        """
+        异步重试获取余额（用于首次获取失败时的后台重试）
+
+        Args:
+            customer_aid: 客户AID
+            max_retries: 最大重试次数
+            retry_delay: 重试间隔（秒）
+        """
+        for attempt in range(max_retries):
+            try:
+                await asyncio.sleep(retry_delay)
+                log_info(f"[BalanceManager] 异步重试获取余额 (尝试 {attempt + 1}/{max_retries})")
+
+                fetch_result = await self._fetch_balance(customer_aid)
+                if fetch_result is not None:
+                    async with self._lock:
+                        balance = fetch_result.get("credits", 0)
+                        users_count = fetch_result.get("usersCountOnSameDeviceWithin8Hours", 0)
+
+                        self._balance = balance
+                        self._users_count_on_same_device = users_count
+                        self._last_update_time = time.time()
+                        self._cache_ttl = self._get_cache_ttl(balance)
+                        self._last_fetch_failed = False
+                        self._consecutive_passthrough_count = 0  # 成功获取，重置放行计数
+
+                        ttl_desc = f"{self._cache_ttl}秒" if self._cache_ttl > 0 else "无缓存"
+                        log_info(f"[BalanceManager] 异步重试成功，积分: {balance}, 缓存策略: {ttl_desc}")
+                    return
+
+            except Exception as e:
+                log_error(f"[BalanceManager] 异步重试失败 (尝试 {attempt + 1}/{max_retries}): {str(e)}")
+
+        log_error(f"[BalanceManager] 异步重试全部失败，共尝试 {max_retries} 次")
+
+    def get_cached_balance(self) -> Optional[float]:
+        """获取缓存的余额（不触发刷新）"""
+        return self._balance
+
+    def clear_cache(self):
+        """清除缓存"""
+        self._balance = None
+        self._last_update_time = 0
+        self._cache_ttl = 0
+        self._users_count_on_same_device = 0
+        self._consecutive_passthrough_count = 0
+        log_info(f"[BalanceManager] 余额缓存已清除")
+
+    async def force_refresh(self, customer_aid: str = ""):
+        """
+        强制刷新余额（用于数据库更新后同步缓存）
+
+        这个方法由 UsageConsumptionUpdater 在扣除积分后调用，
+        确保 BalanceManager 的缓存与实际余额同步
+
+        Args:
+            customer_aid: 客户AID
+        """
+        try:
+            log_info(f"[BalanceManager] 强制刷新余额（数据库更新触发）")
+            balance = await self._fetch_balance(customer_aid)
+
+            if balance is not None:
+                async with self._lock:
+                    old_balance = self._balance
+                    self._balance = balance
+                    self._last_update_time = time.time()
+                    self._cache_ttl = self._get_cache_ttl(balance)
+                    self._last_fetch_failed = False
+
+                    ttl_desc = f"{self._cache_ttl}秒" if self._cache_ttl > 0 else "无缓存"
+                    log_info(f"[BalanceManager] 强制刷新完成: {old_balance} → {balance}, 缓存策略: {ttl_desc}")
+            else:
+                log_error(f"[BalanceManager] 强制刷新失败")
+
+        except Exception as e:
+            log_error(f"[BalanceManager] 强制刷新异常: {str(e)}")
+
+    def notify_credits_consumed(self, consumed_amount: float):
+        """
+        通知积分已被消耗（立即更新缓存）
+
+        当 UsageConsumptionUpdater 确认积分已扣除时调用此方法
+
+        Args:
+            consumed_amount: 消耗的积分数量
+        """
+        try:
+            if self._balance is not None:
+                old_balance = self._balance
+                self._balance = max(0, self._balance - consumed_amount)
+                # 🔧 重要：积分减少后需要重新计算缓存策略
+                self._cache_ttl = self._get_cache_ttl(self._balance)
+
+                ttl_desc = f"{self._cache_ttl}秒" if self._cache_ttl > 0 else "无缓存"
+                log_info(f"[BalanceManager] 积分消耗通知: {old_balance} → {self._balance} (消耗: {consumed_amount}), 缓存策略: {ttl_desc}")
+        except Exception as e:
+            log_error(f"[BalanceManager] 积分消耗通知失败: {str(e)}")
+
+
+# 全局余额管理器实例
+balance_manager = BalanceManager()
+
+
+# ==================== 日志优化：重用 FileHandler ====================
+_proxy_logger = None
+_proxy_logger_lock = threading.Lock()
+
+
+def get_proxy_logger():
+    """
+    获取代理日志记录器（单例模式，重用 FileHandler）
+    避免每次请求都创建新的 FileHandler，减少文件 I/O 阻塞
+    """
+    global _proxy_logger
+
+    # 快速路径：如果已初始化，直接返回
+    if _proxy_logger is not None:
+        return _proxy_logger
+
+    # 🔧 生产环境不写入文件日志
+    is_production = os.environ.get("ELECTRON_IS_PACKAGED", "0") == "1"
+    if is_production:
+        proxy_logger = logging.getLogger("claude_proxy")
+        proxy_logger.setLevel(logging.CRITICAL)
+        proxy_logger.handlers.clear()
+        proxy_logger.addHandler(logging.NullHandler())
+        proxy_logger.propagate = False
+        _proxy_logger = proxy_logger
+        return _proxy_logger
+
+    # 慢速路径：需要初始化（使用锁确保线程安全）
+    with _proxy_logger_lock:
+        # 双重检查锁定模式
+        if _proxy_logger is not None:
+            return _proxy_logger
+
+        from datetime import datetime
+        try:
+            from ..utils.log_paths import get_python_log_dir
+            log_dir = get_python_log_dir("proxy")
+        except ImportError:
+            from pathlib import Path
+            log_dir = str(Path.home() / ".evol" / "logs" / "proxy")
+            os.makedirs(log_dir, exist_ok=True)
+        from logging.handlers import RotatingFileHandler
+
+        log_file = os.path.join(log_dir, "claude_proxy.log")
+
+        # 创建专用的 logger
+        proxy_logger = logging.getLogger("claude_proxy")
+        proxy_logger.setLevel(logging.DEBUG if ENABLE_CLAUDE_PROXY_LOG else logging.CRITICAL)
+
+        # 清除已有的处理器
+        proxy_logger.handlers.clear()
+
+        # 只有在启用日志时才创建文件处理器
+        if ENABLE_CLAUDE_PROXY_LOG:
+            # 创建文件处理器（只创建一次）
+            file_handler = RotatingFileHandler(
+                log_file,
+                maxBytes=20 * 1024 * 1024,  # 20MB
+                backupCount=5,
+                encoding='utf-8'
+            )
+            file_handler.setLevel(logging.DEBUG)
+
+            # 创建格式化器
+            formatter = logging.Formatter(
+                '%(asctime)s - %(levelname)s - %(message)s',
+                datefmt='%Y-%m-%d %H:%M:%S'
+            )
+            file_handler.setFormatter(formatter)
+            proxy_logger.addHandler(file_handler)
+
+            log_info(f"[ProxyLogger] 日志记录器已初始化，日志文件: {log_file}")
+
+        _proxy_logger = proxy_logger
+        return _proxy_logger
+
+
+class AsyncSessionManager:
+    """异步版本的Session管理器"""
+
+    def __init__(self):
+        # ✅ 添加实例ID用于调试追踪
+        import uuid
+        self._instance_id = str(uuid.uuid4())[:8]
+
+        self._sessions = {}  # api_key -> session_id 的映射
+        self._session_info = {}  # session_id -> {'created_time': timestamp, 'last_used': timestamp}
+        self._lock = asyncio.Lock()  # 使用异步锁
+        self._cleanup_interval = 300  # 5分钟清理一次
+        self._session_timeout = 1800  # 30分钟超时
+        self._last_cleanup = time.time()
+
+        # ✅ 新增：trace_id匹配机制（参考llm_agent_utils.py）
+        self._pending_requests = {}  # trace_id -> asyncio.Event
+        self._session_handlers = {}  # session_id -> handler 函数引用（用于移除旧handler）
+        self._request_result_map = {}  # trace_id -> {"result_type": str, "result": dict}
+        self._handler_registered = {}  # session_id -> bool，标记handler是否已注册
+
+        # ✅ 新增：TTL 自动清理机制（防止用户断开连接后的资源泄漏）
+        self._request_timestamps = {}  # trace_id -> 创建时间戳（time.time()）
+        self._stale_request_ttl = 1200  # 20分钟 = 1200秒
+        self._cleanup_interval = 60  # 每60秒执行一次清理检查
+        self._cleanup_task = None  # 后台清理任务引用
+        self._cleanup_running = False  # 清理任务是否正在运行
+
+    async def get_session(
+        self,
+        api_key: str,
+        agent_id: AgentID,
+        target_aid: Optional[str] = None,
+        session_name: str = "claude_proxy",
+        session_subject: str = "claude_proxy",
+        session_scope_key: Optional[str] = None,
+    ) -> str:
+        """获取或创建与API key关联的session（异步版本）"""
+        async with self._lock:
+            current_time = time.time()
+            session_key = session_scope_key or api_key
+
+            # 定期清理过期的session
+            if current_time - self._last_cleanup > self._cleanup_interval:
+                await self._cleanup_expired_sessions(agent_id)
+                self._last_cleanup = current_time
+
+            # 检查是否已有有效的session
+            if session_key in self._sessions:
+                session_id = self._sessions[session_key]
+
+                # 检查session是否还有效
+                if session_id in self._session_info:
+                    session_data = self._session_info[session_id]
+
+                    # 检查session是否超时
+                    if current_time - session_data['last_used'] < self._session_timeout:
+                        # 更新最后使用时间
+                        session_data['last_used'] = current_time
+
+                        # ✅ 关键检查：确保 handler 已注册
+                        # 如果 AgentID 改变，旧的 handler 可能已失效
+                        if session_id not in self._handler_registered:
+                            await self._setup_session_handler(session_id, agent_id)
+
+                        # ✅ 复用session时重新邀请成员，防止对方已离开session
+                        invite_aid = session_data.get('target_aid')
+                        if invite_aid:
+                            try:
+                                await asyncio.to_thread(
+                                    agent_id.invite_member, session_id, invite_aid
+                                )
+                                if invite_aid == "openclaw.aid.pub":
+                                    print(
+                                        f"[AsyncSessionManager][OpenClaw] 复用 session 邀请成功: "
+                                        f"session_id={session_id}, target={invite_aid}"
+                                    )
+                            except Exception:
+                                if invite_aid == "openclaw.aid.pub":
+                                    print(
+                                        f"[AsyncSessionManager][OpenClaw] 复用 session 邀请失败: "
+                                        f"session_id={session_id}, target={invite_aid}"
+                                    )
+                                pass  # 邀请失败不影响复用，对方可能已在session中
+
+                        return session_id
+                    else:
+                        # session已超时，清理它
+                        await self._remove_session(session_key, session_id, agent_id)
+
+            # 创建新的session（在线程中执行以避免阻塞）
+            session_id = await asyncio.to_thread(
+                agent_id.create_session, session_name, session_subject
+            )
+
+            if session_id:
+                # 邀请Claude代理成员（在线程中执行）
+                # 使用 asyncio.to_thread 避免阻塞事件循环
+                claude_agent_name = target_aid or await asyncio.to_thread(configPresenter.get_claude_agent_name)
+                await asyncio.to_thread(
+                    agent_id.invite_member, session_id, claude_agent_name
+                )
+                if claude_agent_name == "openclaw.aid.pub":
+                    print(
+                        f"[AsyncSessionManager][OpenClaw] 新建 session 邀请成功: "
+                        f"session_id={session_id}, target={claude_agent_name}"
+                    )
+
+                # 记录session信息
+                self._sessions[session_key] = session_id
+                self._session_info[session_id] = {
+                    'created_time': current_time,
+                    'last_used': current_time,
+                    'api_key': api_key,
+                    'session_key': session_key,
+                    'target_aid': claude_agent_name
+                }
+
+                # ✅ 为新session注册全局消息处理器（参考llm_agent_utils.py第356行）
+                await self._setup_session_handler(session_id, agent_id)
+
+                return session_id
+            else:
+                log_error(f"[Async] 创建session失败 for scope key: {session_key}")
+                return None
+
+    async def _remove_session(self, session_key: str, session_id: str, agent_id: AgentID):
+        """移除session（异步版本）"""
+        try:
+            # 关闭session（在线程中执行）
+            if agent_id:
+                await asyncio.to_thread(agent_id.close_session, session_id)
+
+            # 从映射中移除
+            if session_key in self._sessions and self._sessions[session_key] == session_id:
+                del self._sessions[session_key]
+
+            if session_id in self._session_info:
+                del self._session_info[session_id]
+
+            # ✅ 清理 handler 注册标记
+            if session_id in self._handler_registered:
+                del self._handler_registered[session_id]
+
+            # 清理 handler 引用
+            if session_id in self._session_handlers:
+                del self._session_handlers[session_id]
+
+        except Exception as e:
+            log_error(f"[Async] 移除session时出错: {str(e)}")
+
+    async def _cleanup_expired_sessions(self, agent_id: AgentID):
+        """清理过期的session（异步版本）"""
+        current_time = time.time()
+        expired_sessions = []
+
+        for session_id, session_data in self._session_info.items():
+            if current_time - session_data['last_used'] > self._session_timeout:
+                expired_sessions.append((session_data.get('session_key', session_data.get('api_key')), session_id))
+
+        for session_key, session_id in expired_sessions:
+            await self._remove_session(session_key, session_id, agent_id)
+
+    async def remove_session_for_api_key(self, api_key: str, agent_id: AgentID):
+        """手动移除指定API key的session（异步版本）"""
+        async with self._lock:
+            if api_key in self._sessions:
+                session_id = self._sessions[api_key]
+                await self._remove_session(api_key, session_id, agent_id)
+
+    async def remove_session_by_scope_key(self, session_scope_key: str, agent_id: AgentID):
+        """手动移除指定 scope key 的 session（异步版本）"""
+        async with self._lock:
+            if session_scope_key in self._sessions:
+                session_id = self._sessions[session_scope_key]
+                await self._remove_session(session_scope_key, session_id, agent_id)
+
+    async def _setup_session_handler(self, session_id: str, agent_id: AgentID, force_reregister: bool = False):
+        """
+        为session设置全局消息处理器（参考llm_agent_utils.py第301-356行）
+        使用trace_id匹配机制，确保每个请求的响应正确路由
+
+        Args:
+            session_id: session ID
+            agent_id: AgentID 实例
+            force_reregister: 是否强制重新注册（用于应用重连时）
+        """
+        if session_id in self._handler_registered and not force_reregister:
+            return  # 已注册过，跳过
+
+        if force_reregister:
+            # ✅ 关键修复：先移除旧的handler，避免handler冲突
+            if session_id in self._session_handlers:
+                old_handler = self._session_handlers[session_id]
+                try:
+                    await asyncio.to_thread(
+                        agent_id.remove_message_handler, old_handler, session_id
+                    )
+                except Exception as e:
+                    pass  # 旧handler可能已不存在，忽略
+
+        # ✅ 关键：捕获主事件循环引用，用于跨线程安全通知
+        # reply_message_handler 会在 ImprovedMessageScheduler 的 worker 线程事件循环中执行，
+        # 但 asyncio.Event 是在主事件循环中创建的，event.set() 不是线程安全的。
+        # 必须通过 call_soon_threadsafe 将 set() 调度到主循环执行。
+        main_loop = asyncio.get_running_loop()
+
+        def _threadsafe_set_event(event):
+            """线程安全地设置 asyncio.Event，确保跨事件循环通知正确工作"""
+            try:
+                main_loop.call_soon_threadsafe(event.set)
+            except RuntimeError:
+                # 主循环已关闭，直接调用作为降级
+                event.set()
+
+        # ✅ P0修复：定义异步消息处理器（AgentCP要求必须是async def）
+        async def reply_message_handler(reply_msg):
+            """
+            全局消息处理器 - 通过trace_id匹配对应的请求
+            参考llm_agent_utils.py第303-348行
+            注意：必须是异步函数，因为AgentCP的add_message_handler要求Awaitable类型
+
+            健壮性保证：
+            - 所有操作都在try-except中，确保不会因为任何异常导致程序崩溃
+            - 即使消息格式异常，也会安全处理并记录日志
+            """
+            trace_id = None
+            try:
+                # 安全检查：消息不能为 None
+                if reply_msg is None:
+                    log_error(f"[Async] Session {session_id}: 收到 None 消息，跳过处理")
+                    return
+
+                # 解析消息（参考第308行）- 添加额外的异常保护
+                try:
+                    messages = agent_id.get_content_array_from_message(reply_msg)
+                except Exception as parse_err:
+                    log_error(f"[Async] Session {session_id}: get_content_array_from_message 失败: {parse_err}")
+                    return
+
+                if not messages:
+                    log_error(f"[Async] Session {session_id}: 收到空消息数组")
+                    return
+
+                # 安全获取第一条消息
+                try:
+                    response_msg = messages[0]
+                    if not isinstance(response_msg, dict):
+                        log_error(f"[Async] Session {session_id}: 消息格式异常，期望dict，实际: {type(response_msg)}")
+                        return
+                except (IndexError, TypeError) as idx_err:
+                    log_error(f"[Async] Session {session_id}: 无法获取消息内容: {idx_err}")
+                    return
+
+                # 安全获取 trace_id
+                trace_id = response_msg.get("trace_id", "") if isinstance(response_msg, dict) else ""
+
+                # 解析响应类型（参考第313-317行）
+                msg_type = response_msg.get("type", "") if isinstance(response_msg, dict) else ""
+                session_data = self._session_info.get(session_id, {})
+                target_aid = session_data.get("target_aid", "")
+                is_openclaw_session = target_aid == "openclaw.aid.pub"
+                if is_openclaw_session or (trace_id and trace_id.startswith("openclaw-")):
+                    pending_exists = trace_id in self._pending_requests if trace_id else False
+                    print(
+                        f"[OpenClawDiag][Handler] 收到消息: session_id={session_id}, "
+                        f"type={msg_type}, trace_id={trace_id or 'None'}, "
+                        f"pending_exists={pending_exists}, pending_count={len(self._pending_requests)}, "
+                        f"result_count={len(self._request_result_map)}"
+                    )
+
+                # 特殊处理：如果是错误消息且没有trace_id，说明是服务不可用等全局错误
+                # 需要通知该session下所有等待的请求
+                if not trace_id and msg_type == "error":
+                    log_error(f"[Async] Session {session_id}: 收到无trace_id的错误消息，将通知所有等待请求")
+
+                    try:
+                        pending_keys_snapshot = list(self._pending_requests.keys()) if self._pending_requests else []
+                        openclaw_pending_keys = [key for key in pending_keys_snapshot if str(key).startswith("openclaw-")]
+                        response_keys = list(response_msg.keys()) if isinstance(response_msg, dict) else []
+                        print(
+                            f"[OpenClawDiag][Handler] 无 trace_id 错误广播前: session_id={session_id}, "
+                            f"pending_total={len(pending_keys_snapshot)}, openclaw_pending={len(openclaw_pending_keys)}, "
+                            f"pending_sample={openclaw_pending_keys[:10]}, response_keys={response_keys}, "
+                            f"response_msg={response_msg}"
+                        )
+                    except Exception as inspect_err:
+                        print(f"[OpenClawDiag][Handler] 无 trace_id 错误检查失败: {inspect_err}")
+
+                    # 创建错误结果
+                    error_result = {
+                        "result_type": "error",
+                        "result": response_msg
+                    }
+
+                    # 通知该session下所有等待的请求
+                    try:
+                        pending_keys = list(self._pending_requests.keys()) if self._pending_requests else []
+                        for pending_trace_id in pending_keys:
+                            # 将错误结果存储到每个等待的trace_id
+                            self._request_result_map[pending_trace_id] = error_result
+                            event = self._pending_requests.get(pending_trace_id)
+                            if event is not None:
+                                _threadsafe_set_event(event)
+                        openclaw_result_keys = [key for key in self._request_result_map.keys() if str(key).startswith("openclaw-")]
+                        print(
+                            f"[OpenClawDiag][Handler] 无 trace_id 错误广播完成: session_id={session_id}, "
+                            f"broadcast_total={len(pending_keys)}, openclaw_result_count={len(openclaw_result_keys)}, "
+                            f"openclaw_result_sample={openclaw_result_keys[:10]}"
+                        )
+                    except Exception as notify_err:
+                        log_error(f"[Async] Session {session_id}: 通知等待请求失败: {notify_err}")
+
+                    return
+
+                # 验证trace_id（参考第310行）
+                if not trace_id:
+                    log_error(f"[Async] Session {session_id}: 消息缺少trace_id")
+                    if is_openclaw_session:
+                        msg_keys = list(response_msg.keys()) if isinstance(response_msg, dict) else []
+                        print(
+                            f"[OpenClawDiag][Handler] 缺少 trace_id，消息键: {msg_keys}"
+                        )
+                    return
+
+                result = {
+                    "result_type": msg_type,
+                    "result": response_msg
+                }
+
+                # 存储结果到map（参考第328-336行）
+                try:
+                    self._request_result_map[trace_id] = result
+                except Exception as store_err:
+                    log_error(f"[Async] Session {session_id}: 存储结果失败: {store_err}")
+                    # 继续尝试通知等待的请求
+
+                # 通知等待的请求（参考第346-348行）
+                # ✅ 使用 _threadsafe_set_event 跨线程安全通知主事件循环
+                try:
+                    if trace_id in self._pending_requests:
+                        event = self._pending_requests.get(trace_id)
+                        if event is not None:
+                            _threadsafe_set_event(event)
+                            if is_openclaw_session or trace_id.startswith("openclaw-"):
+                                print(
+                                    f"[OpenClawDiag][Handler] 已唤醒等待事件: trace_id={trace_id}, "
+                                    f"pending_count={len(self._pending_requests)}, "
+                                    f"result_count={len(self._request_result_map)}"
+                                )
+                        else:
+                            log_error(f"[Async] Session {session_id}: trace_id {trace_id} 对应的 event 为 None")
+                    else:
+                        log_error(f"[Async] Session {session_id}: trace_id {trace_id} 没有对应的等待请求")
+                        if is_openclaw_session or trace_id.startswith("openclaw-"):
+                            sample_pending = [k for k in self._pending_requests.keys() if k.startswith("openclaw-")][:10]
+                            print(
+                                f"[OpenClawDiag][Handler] trace_id 未匹配到等待请求: trace_id={trace_id}, "
+                                f"openclaw_pending_sample={sample_pending}"
+                            )
+                except Exception as notify_err:
+                    log_error(f"[Async] Session {session_id}: 通知等待请求失败: {notify_err}")
+
+            except Exception as e:
+                # 最外层异常捕获，确保任何未预料的异常都不会导致崩溃
+                try:
+                    log_error(f"[Async] Session {session_id}: 消息处理失败: {str(e)}")
+
+                    # 即使解析失败，也要尝试通知等待的请求
+                    if trace_id and trace_id in self._pending_requests:
+                        try:
+                            error_result = {
+                                "result_type": "error",
+                                "result": {"content": f"消息解析失败: {str(e)}", "http_status": 500}
+                            }
+                            self._request_result_map[trace_id] = error_result
+                            event = self._pending_requests.get(trace_id)
+                            if event is not None:
+                                _threadsafe_set_event(event)
+                        except Exception as error_notify_err:
+                            log_error(f"[Async] Session {session_id}: 设置错误事件失败: {error_notify_err}")
+                except Exception as final_err:
+                    # 即使异常处理本身也失败了，也只记录日志，不崩溃
+                    log_error(f"[Async] Session {session_id}: 严重错误 - 异常处理失败: {final_err}")
+
+        # 注册handler（参考第356行）
+        try:
+            # ✅ 修复：add_message_handler 本身是同步方法，但接收异步回调
+            # 应该在线程中执行注册操作（因为 add_message_handler 可能有锁操作）
+            await asyncio.to_thread(
+                agent_id.add_message_handler, reply_message_handler, session_id=session_id
+            )
+        except Exception as e:
+            log_error(f"[Async] Session {session_id}: Handler注册失败: {e}")
+            raise
+
+        # ✅ 关键修复：保存handler引用，以便后续移除
+        self._session_handlers[session_id] = reply_message_handler
+
+        self._handler_registered[session_id] = True
+
+    def get_session_info(self):
+        """获取当前session状态信息（用于调试）"""
+        return {
+            'active_sessions': len(self._sessions),
+            'session_details': dict(self._session_info),
+            'pending_requests': len(self._pending_requests),
+            'registered_handlers': len(self._handler_registered),
+            'tracked_timestamps': len(self._request_timestamps),  # 新增：跟踪的时间戳数量
+            'cleanup_task_running': self._cleanup_running  # 新增：清理任务状态
+        }
+
+    # ==================== TTL 自动清理机制 ====================
+
+    def register_request_timestamp(self, trace_id: str):
+        """
+        注册请求的时间戳（在发送请求时调用）
+
+        Args:
+            trace_id: 请求的唯一标识符
+        """
+        self._request_timestamps[trace_id] = time.time()
+        log_info(f"[TTL] 注册请求时间戳: trace_id={trace_id}")
+
+    def unregister_request_timestamp(self, trace_id: str):
+        """
+        取消注册请求的时间戳（在请求完成或清理时调用）
+
+        Args:
+            trace_id: 请求的唯一标识符
+        """
+        if trace_id in self._request_timestamps:
+            del self._request_timestamps[trace_id]
+
+    async def start_cleanup_task(self):
+        """
+        启动后台清理任务
+
+        此任务会定期检查并清理超过 TTL 的过期请求，
+        防止用户断开连接后造成的资源泄漏。
+        """
+        if self._cleanup_running:
+            print(f"[TTL] 清理任务已在运行中，跳过启动")
+            return
+
+        self._cleanup_running = True
+        print(f"[TTL] 🚀 启动后台清理任务，TTL={self._stale_request_ttl}秒，检查间隔={self._cleanup_interval}秒")
+        log_info(f"[TTL] 启动后台清理任务，TTL={self._stale_request_ttl}秒")
+
+        async def cleanup_loop():
+            """清理任务的主循环"""
+            while self._cleanup_running:
+                try:
+                    await asyncio.sleep(self._cleanup_interval)
+                    if self._cleanup_running:  # 再次检查，因为可能在 sleep 期间被停止
+                        await self._cleanup_stale_requests()
+                except asyncio.CancelledError:
+                    print(f"[TTL] 清理任务被取消")
+                    break
+                except Exception as e:
+                    log_error(f"[TTL] 清理任务异常: {e}")
+                    print(f"[TTL] ❌ 清理任务异常: {e}")
+                    import traceback
+                    traceback.print_exc()
+
+        self._cleanup_task = asyncio.create_task(cleanup_loop())
+
+    async def stop_cleanup_task(self):
+        """
+        停止后台清理任务
+        """
+        if not self._cleanup_running:
+            return
+
+        print(f"[TTL] 🛑 停止后台清理任务...")
+        self._cleanup_running = False
+
+        if self._cleanup_task:
+            self._cleanup_task.cancel()
+            try:
+                await self._cleanup_task
+            except asyncio.CancelledError:
+                pass
+            self._cleanup_task = None
+
+        print(f"[TTL] ✅ 后台清理任务已停止")
+        log_info(f"[TTL] 后台清理任务已停止")
+
+    async def _cleanup_stale_requests(self):
+        """
+        清理超过 TTL 的过期请求
+
+        此方法会检查 _request_timestamps 中的所有条目，
+        清理那些创建时间超过 20 分钟的请求相关数据。
+        """
+        current_time = time.time()
+        stale_trace_ids = []
+
+        # 1. 找出所有过期的 trace_id
+        for trace_id, created_time in list(self._request_timestamps.items()):
+            age_seconds = current_time - created_time
+            if age_seconds > self._stale_request_ttl:
+                stale_trace_ids.append((trace_id, age_seconds))
+
+        if not stale_trace_ids:
+            # 没有过期请求，静默返回
+            return
+
+        # 2. 清理过期的请求
+        print(f"[TTL] 🧹 发现 {len(stale_trace_ids)} 个过期请求，开始清理...")
+        log_info(f"[TTL] 发现 {len(stale_trace_ids)} 个过期请求")
+
+        for trace_id, age_seconds in stale_trace_ids:
+            try:
+                age_minutes = age_seconds / 60
+
+                # 清理 _pending_requests
+                if trace_id in self._pending_requests:
+                    del self._pending_requests[trace_id]
+                    print(f"[TTL]   - 清理 _pending_requests: {trace_id} (已存活 {age_minutes:.1f} 分钟)")
+
+                # 清理 _request_result_map
+                if trace_id in self._request_result_map:
+                    del self._request_result_map[trace_id]
+                    print(f"[TTL]   - 清理 _request_result_map: {trace_id}")
+
+                # 清理时间戳记录
+                if trace_id in self._request_timestamps:
+                    del self._request_timestamps[trace_id]
+
+                log_info(f"[TTL] 已清理过期请求: trace_id={trace_id}, 存活时间={age_minutes:.1f}分钟")
+
+            except Exception as e:
+                log_error(f"[TTL] 清理 trace_id={trace_id} 时出错: {e}")
+                print(f"[TTL] ❌ 清理 {trace_id} 失败: {e}")
+
+        print(f"[TTL] ✅ 清理完成，共清理 {len(stale_trace_ids)} 个过期请求")
+        print(f"[TTL]    当前状态: pending={len(self._pending_requests)}, results={len(self._request_result_map)}, timestamps={len(self._request_timestamps)}")
+
+    async def reregister_all_handlers(self, agent_id: AgentID):
+        """
+        重新注册所有 session 的 handlers
+        用于应用重新连接时，确保所有 handlers 都是有效的
+
+        关键修复：
+        - 应用重启后，守护进程继续运行
+        - 旧的 sessions 可能还存在，但 handlers 可能失效
+        - 通过重新注册，确保 handlers 引用正确的 AsyncSessionManager 实例
+        """
+        print(f"[AsyncSessionManager] 🔄 开始重新注册所有 handlers，实例ID: {self._instance_id}")
+
+        # 获取所有有效的 session IDs
+        session_ids = list(self._session_info.keys())
+
+        if not session_ids:
+            print(f"[AsyncSessionManager] 没有需要重新注册的 session")
+            return
+
+        print(f"[AsyncSessionManager] 找到 {len(session_ids)} 个 session 需要重新注册 handlers")
+
+        # 清空 handler 注册标记
+        # 不清空 sessions 和 session_info，因为它们可能还有用
+        self._handler_registered.clear()
+        print(f"[AsyncSessionManager] 已清空 handler 注册标记")
+
+        # 为每个 session 重新注册 handler
+        for session_id in session_ids:
+            try:
+                print(f"[AsyncSessionManager] 正在为 session {session_id} 重新注册 handler...")
+                # ✅ 强制重新注册，即使已经注册过
+                await self._setup_session_handler(session_id, agent_id, force_reregister=True)
+                print(f"[AsyncSessionManager] ✅ session {session_id} handler 重新注册成功")
+            except Exception as e:
+                print(f"[AsyncSessionManager] ❌ session {session_id} handler 重新注册失败: {e}")
+                import traceback
+                traceback.print_exc()
+
+        print(f"[AsyncSessionManager] ✅ 所有 handlers 重新注册完成")
+        print(f"[AsyncSessionManager] 当前注册的 handlers: {len(self._handler_registered)}")
+        print(f"[AsyncSessionManager] Handler 列表: {list(self._handler_registered.keys())}")
+
+    async def cleanup(self, agent_id: AgentID = None):
+        """
+        清理所有资源，移除所有 handlers
+
+        关键作用：
+        - 防止内存泄漏：移除旧实例注册的 handlers
+        - 在创建新实例前调用，确保旧 handlers 不会残留在 AgentID 上
+        - 清理所有内部状态
+
+        Args:
+            agent_id: AgentID 实例，如果提供则移除所有 handlers
+        """
+        print(f"[AsyncSessionManager] 🧹 开始清理实例，ID: {self._instance_id}")
+
+        try:
+            # 0. 停止后台清理任务
+            await self.stop_cleanup_task()
+
+            # 1. 移除所有已注册的 handlers
+            if agent_id and self._session_handlers:
+                print(f"[AsyncSessionManager] 正在移除 {len(self._session_handlers)} 个 handlers...")
+
+                for session_id, handler in list(self._session_handlers.items()):
+                    try:
+                        # 使用 AgentID 的 remove_message_handler 方法移除 handler
+                        await asyncio.to_thread(
+                            agent_id.remove_message_handler, handler, session_id=session_id
+                        )
+                        print(f"[AsyncSessionManager] ✓ 已移除 session {session_id} 的 handler")
+                    except Exception as e:
+                        print(f"[AsyncSessionManager] ⚠️ 移除 handler 失败 (session {session_id}): {e}")
+
+                print(f"[AsyncSessionManager] ✓ 所有 handlers 已移除")
+
+            # 2. 清空所有内部状态
+            self._sessions.clear()
+            self._session_info.clear()
+            self._session_handlers.clear()
+            self._handler_registered.clear()
+            self._pending_requests.clear()
+            self._request_result_map.clear()
+            # ✅ 清理时间戳记录
+            self._request_timestamps.clear()
+
+            print(f"[AsyncSessionManager] ✓ 所有内部状态已清空")
+            print(f"[AsyncSessionManager] ✅ 清理完成，实例ID: {self._instance_id}")
+
+        except Exception as e:
+            print(f"[AsyncSessionManager] ❌ 清理失败: {e}")
+            import traceback
+            traceback.print_exc()
+
+
+# ✅ P0修复：延迟初始化，避免在模块导入时创建asyncio资源
+# 将在 startup 事件中初始化
+async_session_manager: AsyncSessionManager = None
+_manager_lock = None  # ✅ 添加锁用于线程安全的单例模式
+
+
+async def get_async_session_manager(agent_id: AgentID = None) -> AsyncSessionManager:
+    """
+    获取 AsyncSessionManager 单例（线程安全）
+
+    关键修复：
+    - 使用异步锁确保线程安全
+    - 在创建新实例前，清理旧实例的 handlers
+    - 防止内存泄漏
+    - ✅ 新增：创建新实例后自动启动 TTL 清理任务
+
+    Args:
+        agent_id: AgentID 实例，用于清理旧 handlers
+
+    Returns:
+        AsyncSessionManager 单例实例
+    """
+    global async_session_manager, _manager_lock
+
+    # 初始化锁（只在第一次调用时）
+    if _manager_lock is None:
+        _manager_lock = asyncio.Lock()
+
+    async with _manager_lock:
+        if async_session_manager is None:
+            print("[get_async_session_manager] 创建新的 AsyncSessionManager 实例")
+            async_session_manager = AsyncSessionManager()
+            # ✅ 启动 TTL 清理任务
+            await async_session_manager.start_cleanup_task()
+        else:
+            print(f"[get_async_session_manager] 复用现有实例，ID: {async_session_manager._instance_id}")
+            # ✅ 确保清理任务正在运行
+            if not async_session_manager._cleanup_running:
+                print("[get_async_session_manager] 清理任务未运行，重新启动...")
+                await async_session_manager.start_cleanup_task()
+
+        return async_session_manager
+
+
+async def reset_async_session_manager(agent_id: AgentID = None):
+    """
+    重置 AsyncSessionManager 单例（用于应用重启或清理场景）
+
+    关键修复：
+    - 在创建新实例前，清理旧实例的所有 handlers
+    - 防止 handlers 残留导致的内存泄漏
+    - 确保单例正确重置
+    - ✅ 新增：创建新实例后自动启动 TTL 清理任务
+
+    Args:
+        agent_id: AgentID 实例，用于移除旧 handlers
+    """
+    global async_session_manager, _manager_lock
+
+    if _manager_lock is None:
+        _manager_lock = asyncio.Lock()
+
+    async with _manager_lock:
+        # 1. 清理旧实例（包括停止清理任务）
+        if async_session_manager is not None:
+            old_instance_id = async_session_manager._instance_id
+            print(f"[reset_async_session_manager] 清理旧实例，ID: {old_instance_id}")
+
+            try:
+                await async_session_manager.cleanup(agent_id)
+                print(f"[reset_async_session_manager] ✓ 旧实例已清理")
+            except Exception as e:
+                print(f"[reset_async_session_manager] ⚠️ 清理旧实例失败: {e}")
+
+        # 2. 创建新实例
+        print("[reset_async_session_manager] 创建新的 AsyncSessionManager 实例")
+        async_session_manager = AsyncSessionManager()
+        print(f"[reset_async_session_manager] ✓ 新实例已创建，ID: {async_session_manager._instance_id}")
+
+        # 3. 启动 TTL 清理任务
+        await async_session_manager.start_cleanup_task()
+
+        return async_session_manager
+
+
+def get_claude_proxy_config():
+    """获取 Claude 代理配置"""
+    from .proxy_config import ProxyConfig
+
+    return ProxyConfig(
+        target_aid_getter=lambda api_key: get_current_agent_id().aid if get_current_agent_id() else "",
+        request_converter=lambda body: body,
+        response_converter=lambda resp: resp,
+        stream_handler=handle_stream_response,
+        error_formatter=lambda e: JSONResponse(
+            status_code=500,
+            content={"error": {"message": str(e), "type": "internal_error"}}
+        ),
+        model_validator=lambda m: True,
+        proxy_type="claude"
+    )
+
+
+async def proxy_claude_request(
+    request: Request,
+    x_api_key: Optional[str] = None
+):
+    """
+    Claude代理请求处理器（异步版本）
+    支持所有HTTP方法和路径
+    """
+    global agentId
+
+    # ✅ P0修复：检查 AsyncSessionManager 是否已初始化
+    if async_session_manager is None:
+        raise HTTPException(
+            status_code=503,
+            detail="AsyncSessionManager 未初始化，请稍后重试"
+        )
+
+    # 获取代理日志记录器（重用 FileHandler，避免每次请求都创建）
+    proxy_logger = get_proxy_logger()
+
+    # 积分预扣除追踪变量
+    reserved_credits = 0  # 已预扣除的积分
+    user_id = None  # 用户ID
+    request_id = str(uuid.uuid4())  # 请求ID
+    request_success = False  # 请求是否成功
+
+    # ✅ 性能监控：记录关键步骤的耗时
+    perf_start = time.time()
+    perf_timings = {}  # 存储各个步骤的耗时
+
+    try:
+        request_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        client_ip = request.client.host if request.client else "unknown"
+
+        # 记录请求开始
+        proxy_logger.info("=" * 80)
+        proxy_logger.info(f"Claude代理请求开始 - {request.method} {request.url.path}")
+        proxy_logger.info(f"客户端IP: {client_ip}")
+        proxy_logger.info(f"请求时间: {request_time}")
+        proxy_logger.info(f"追踪ID: {request_id}")
+
+        log_info(f"\n{'='*80}")
+        log_info(f"[{request_time}] [Async] 收到 {request.method} 请求: {request.url.path}")
+        headers_dict = {}
+        skip_headers = {'host', 'content-length'}
+        for key, value in request.headers.items():
+            if key.lower() not in skip_headers:
+                headers_dict[key] = value
+        # 1. API Key验证
+        if not x_api_key:
+            x_api_key = request.headers.get("x-api-key")
+
+        if not x_api_key:
+            x_api_key = request.headers.get("authorization")
+            if x_api_key and x_api_key.startswith("Bearer "):
+                x_api_key = x_api_key[7:]
+    
+        if not x_api_key:
+            x_api_key = request.headers.get("authorization")
+            if x_api_key and x_api_key.startswith("Bearer "):
+                x_api_key = x_api_key[7:]
+         
+        if not x_api_key:
+            x_api_key = headers_dict["x-goog-api-key"]
+
+        # if not x_api_key:
+        #     error_msg = "请求缺少 x-api-key 头"
+        #     proxy_logger.error(f"API Key验证失败: {error_msg}")
+        #     log_error("[Async] 请求缺少 x-api-key 头")
+        #     raise HTTPException(status_code=401, detail="Missing x-api-key header")
+
+        proxy_logger.info(f"API Key验证: {x_api_key[:20]}... (已脱敏)")
+
+        # 1.5. API Key 校验
+        # try:
+        #     proxy_logger.info("开始API Key校验")
+        #     validation_result = await api_key_manager.validate_api_key(x_api_key)
+
+        #     if not validation_result["valid"]:
+        #         error_msg = validation_result.get("error", "API Key 校验不通过")
+        #         cache_status = "缓存" if validation_result.get("from_cache") else "实时"
+        #         proxy_logger.error(f"API Key校验失败 ({cache_status}): {error_msg}")
+        #         log_error(f"[Async] API Key 校验失败 ({cache_status}): {error_msg}")
+        #         raise HTTPException(
+        #             status_code=401,
+        #             detail=f"API Key 校验失败: {error_msg}"
+        #         )
+
+        #     cache_status = "缓存" if validation_result.get("from_cache") else "实时"
+        #     proxy_logger.info(f"API Key校验通过 ({cache_status})")
+        #     log_info(f"[Async] API Key 校验通过 ({cache_status}): {x_api_key[:20]}...")
+
+        # except HTTPException:
+        #     raise
+        # except Exception as e:
+        #     proxy_logger.error(f"API Key校验异常: {str(e)}")
+        #     proxy_logger.error(f"异常堆栈:\n{traceback.format_exc()}")
+        #     log_error(f"[Async] API Key 校验异常: {str(e)}")
+        #     raise HTTPException(
+        #         status_code=500,
+        #         detail=f"API Key 校验服务异常: {str(e)}"
+        #     )
+
+        # 2. 积分余额检查 + 预扣除（原子操作，防止并发透支）
+        try:
+            step_start = time.time()
+            proxy_logger.info("开始积分余额检查（智能混合策略 + 积分锁）")
+            print(f"[Async] 开始积分余额检查（智能混合策略 + 积分锁）")
+
+            # 2.1 获取用户ID（使用 asyncio.to_thread 避免阻塞事件循环）
+            user_info = await asyncio.to_thread(userPresenter.get_user_info)
+            perf_timings['get_user_info'] = (time.time() - step_start) * 1000  # 毫秒
+            if user_info.get("status") != "success":
+                raise HTTPException(status_code=401, detail="无法获取用户信息")
+
+            user_id = user_info["user_info"].get("user_id")
+            if not user_id:
+                raise HTTPException(status_code=401, detail="用户ID无效")
+
+            # 2.2 使用积分锁进行原子性的检查+预扣除
+            step_start = time.time()
+
+            required_credits = 20  # 每次请求需要的积分
+
+            # 原子操作：检查余额并预扣除
+            reserve_result = await credits_lock_manager.check_and_reserve_credits(
+                user_id=user_id,
+                required_amount=required_credits,
+                balance_fetcher=None,  # 使用默认的余额获取方法
+                request_id=request_id
+            )
+            perf_timings['credits_reserve'] = (time.time() - step_start) * 1000  # 毫秒
+            if not reserve_result["success"]:
+                reserve_result["success"] = True
+                reserve_result["balance"] = 10000
+                reserve_result['available'] = 10000
+
+            if not reserve_result["success"]:
+                error_msg = reserve_result.get("error", "积分检查失败")
+                balance = reserve_result.get("balance", 0)
+                available = reserve_result.get("available", 0)
+
+                proxy_logger.error(f"❌ 积分余额检查失败: {error_msg}")
+                proxy_logger.error(f"   余额: {balance}, 已预扣: {reserve_result.get('reserved', 0)}, 可用: {available}")
+                print(f"[Async] ❌ 积分余额检查失败: {error_msg}")
+                print(f"[Async]    余额: {balance}, 可用: {available}")
+
+                # 根据错误类型返回不同的错误码
+                if "获取余额失败" in error_msg or "API返回错误" in error_msg:
+                    raise HTTPException(
+                        status_code=503,
+                        detail=f"积分余额服务不可用，请稍后重试: {error_msg}"
+                    )
+                elif balance == 0:
+                    raise HTTPException(
+                        status_code=503,
+                        detail=f"积分余额为0，无法继续使用"
+                    )
+                elif "不足" in error_msg:
+                    raise HTTPException(
+                        status_code=503,
+                        detail=f"积分不足: 余额={balance}, 可用={available}, 需要={required_credits}"
+                    )
+                else:
+                    raise HTTPException(
+                        status_code=503,
+                        detail=f"积分余额检查失败: {error_msg}"
+                    )
+
+            # 预扣除成功，记录状态
+            reserved_credits = required_credits
+            balance = reserve_result.get("balance", 0)
+            available = reserve_result.get("available", 0)
+
+            proxy_logger.info(f"✅ 积分预扣除成功")
+            proxy_logger.info(f"   余额: {balance}, 预扣: {required_credits}, 剩余可用: {available}")
+            print(f"[Async] ✅ 积分预扣除成功: 余额={balance}, 剩余可用={available}")
+
+        except HTTPException:
+            # 直接重新抛出 HTTPException
+            raise
+        except Exception as e:
+            # 任何未预期的异常都严格拒绝请求
+            proxy_logger.error(f"❌ 积分余额检查异常: {str(e)}")
+            import traceback
+            error_traceback = traceback.format_exc()
+            proxy_logger.error(f"异常堆栈:\n{error_traceback}")
+            log_error(f"[Async] 积分余额检查异常: {str(e)}")
+            print(f"[Async] ❌ 积分余额检查异常: {str(e)}")
+            traceback.print_exc()
+
+            # 异常情况严格拒绝请求
+            raise HTTPException(
+                status_code=503,
+                detail=f"积分余额检查服务异常，请稍后重试: {str(e)}"
+            )
+
+        # 2. 读取请求体
+        step_start = time.time()
+        proxy_logger.info("读取请求体")
+        request_body = await request.body()
+        perf_timings['read_body'] = (time.time() - step_start) * 1000
+        proxy_logger.info(f"请求体大小: {len(request_body)} bytes")
+
+        # 3. 构建代理消息
+        step_start = time.time()
+        proxy_logger.info("构建代理消息")
+
+        trace_id = str(uuid.uuid4())
+        # 使用 asyncio.to_thread 避免 JSON 解析阻塞事件循环（特别是大请求体）
+        bodyjson = await asyncio.to_thread(json.loads, request_body.decode('utf-8'))
+        perf_timings['json_parse'] = (time.time() - step_start) * 1000
+
+        # 根据请求路径校验模型名称
+        request_path = str(request.url.path)
+        model_name = bodyjson.get("model", "")
+
+        if "/claude-proxy/" in request_path:
+            # Claude Proxy: 模型必须包含 "claude"
+            if model_name and "claude" not in model_name.lower():
+                proxy_logger.error(f"Claude Proxy 模型校验失败: {model_name}")
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"不支持该模型 {model_name}，请使用 Claude CLI 内置模型"
+                )
+        elif "/codex-proxy/" in request_path:
+            # Codex Proxy: 模型必须包含 "gpt"
+            if model_name and "gpt" not in model_name.lower():
+                proxy_logger.error(f"Codex Proxy 模型校验失败: {model_name}")
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"不支持该模型 {model_name}，请使用 Codex CLI 内置模型"
+                )
+        elif "/gemini-proxy/" in request_path:
+            # Gemini Proxy: 模型必须包含 "gemini"
+            if model_name and "gemini" not in model_name.lower():
+                proxy_logger.error(f"Gemini Proxy 模型校验失败: {model_name}")
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"不支持该模型 {model_name}，请使用 Gemini CLI 内置模型"
+                )
+
+        proxy_message = {
+            "type": "claude_proxy",
+            "status": "success",
+            "timestamp": int(time.time() * 1000),
+            "trace_id": trace_id,
+            "content": {
+                "path": str(request.url.path).replace("/claude-proxy", ""),  # 移除前缀
+                "method": request.method,
+                "headers": headers_dict,
+                "body": bodyjson,
+                "source":"evol",
+                "version":__version__,
+                "cmp_version":__cmp_version__
+            }
+        }
+
+
+        print(f"[Async] 🔍 构建代理消息:")
+        print(f"[Async]   - Trace ID: {trace_id}")
+        print(f"[Async]   - Message Type: {proxy_message['type']}")
+        print(f"[Async]   - 验证 trace_id 在消息中: {proxy_message.get('trace_id', 'NOT_FOUND')}")
+
+        proxy_logger.info(f"代理消息构建完成，trace_id: {trace_id}")
+        proxy_logger.info(f"请求路径: {request.url.path}")
+        proxy_logger.info(f"请求方法: {request.method}")
+        proxy_logger.info(f"请求头数量: {len(headers_dict)}")
+
+        log_info(f"[Async] 发送Claude代理请求: {request.url.path}, trace_id: {trace_id}")
+
+        # 4. 发送消息到Claude Agent
+        # 4.1 检查用户是否登录
+        if not userPresenter.is_logged_in():
+            proxy_logger.error("用户未登录")
+            log_error("[Async] 用户未登录，请打开 Evol 登录")
+            raise HTTPException(
+                status_code=401,
+                detail="用户未登录，请打开 Evol 登录"
+            )
+
+        # 4.2 检查 AgentID 是否在线，如未在线则执行完全重建
+        if agentId is None or not agentId.is_online_success:
+            proxy_logger.warning("AgentID 未连接，执行完全重建...")
+            print("[Async] ⚠️ AgentID 未连接，执行完全重建...")
+
+            # ✅ 检查冷却时间（30分钟内只执行一次）
+            time_since_last = time.time() - _last_full_agentcp_rebuild_time
+            if time_since_last < _full_agentcp_rebuild_cooldown:
+                remaining = (_full_agentcp_rebuild_cooldown - time_since_last) / 60
+                proxy_logger.error(f"完全重建冷却中，剩余 {remaining:.1f} 分钟")
+                print(f"[Async] ⏳ 完全重建冷却中，剩余 {remaining:.1f} 分钟")
+                raise HTTPException(
+                    status_code=503,
+                    detail=f"连接异常，系统正在恢复中，请 {int(remaining)+1} 分钟后重试，或重启Evol"
+                )
+
+            # ✅ 在线程中执行完全重建（避免阻塞事件循环）
+            rebuild_success = await asyncio.to_thread(_full_rebuild_agentcp_system)
+
+            if not rebuild_success:
+                proxy_logger.error("AgentID 完全重建失败")
+                log_error("[Async] AgentID 完全重建失败")
+                raise HTTPException(
+                    status_code=503,
+                    detail="Service Unavailable: 连接恢复失败，请尝试重启Evol"
+                )
+
+            # 重建成功，检查 agentId 状态
+            if agentId is None or not agentId.is_online_success:
+                proxy_logger.error("AgentID 重建后仍未在线")
+                log_error("[Async] AgentID 重建后仍未在线")
+                raise HTTPException(
+                    status_code=503,
+                    detail="Service Unavailable: 连接恢复异常，请尝试重启Evol"
+                )
+
+            proxy_logger.info("AgentID 完全重建成功，继续处理请求")
+            print("[Async] ✅ AgentID 完全重建成功，继续处理请求")
+
+        # 4.3 AgentID 在线，开始处理请求
+        if agentId and agentId.is_online_success:
+            proxy_logger.info("Agent在线，开始处理请求")
+
+            # ✅ 优化：使用循环实现 session 创建失败时的重试逻辑
+            session_id = None
+            max_session_retries = 2
+
+            for session_attempt in range(max_session_retries):
+                step_start = time.time()
+                proxy_logger.info(f"获取或创建session (尝试 {session_attempt + 1}/{max_session_retries})")
+                session_id = await async_session_manager.get_session(x_api_key, agentId)
+                perf_timings['get_session'] = (time.time() - step_start) * 1000
+
+                if session_id:
+                    # 成功获取 session
+                    break
+                elif session_attempt < max_session_retries - 1:
+                    # 第一次失败，尝试 agentId.online() 重新上线后重试
+                    proxy_logger.warning("Session创建失败，尝试重新上线...")
+                    print(f"[Async] ⚠️ Session 创建失败 (尝试 {session_attempt + 1})，执行 agentId.online() 重试...")
+
+                    try:
+                        # 清空 session 缓存
+                        _clear_async_session_manager_cache()
+                        print("[Async] ✓ 已清空 session 缓存")
+
+                        # 调用 agentId.online() 重新上线
+                        await asyncio.to_thread(agentId.online)
+                        print(f"[Async] ✓ agentId.online() 完成，is_online_success: {agentId.is_online_success}")
+
+                        if agentId.is_online_success:
+                            # 【重要】AgentID 上线后统一入口 - 初始化监听器等
+                            from ..presenter.agentIdPresenter import evol_agentId_online
+                            evol_agentId_online(agentId)
+
+                            # 重新注册断开回调
+                            _register_disconnect_callback(agentId, disable_auto_reconnect=True)
+                            print("[Async] 🔄 准备重试获取 session...")
+                        else:
+                            proxy_logger.error("agentId.online() 后仍未上线")
+                            print("[Async] ❌ agentId.online() 后仍未上线，放弃重试")
+                            break
+                    except Exception as retry_error:
+                        proxy_logger.error(f"重新上线过程异常: {str(retry_error)}")
+                        print(f"[Async] ❌ 重新上线异常: {retry_error}")
+                        break
+
+            if session_id:
+                proxy_logger.info(f"Session获取成功: {session_id}")
+                print(f"[Request] AsyncSessionManager 实例ID: {async_session_manager._instance_id}")
+                print(f"[Request] 准备添加 trace_id: {trace_id} 到 _pending_requests")
+
+                # ✅ 使用trace_id匹配机制（参考llm_agent_utils.py第244-252行）
+                response_event = asyncio.Event()
+                async_session_manager._pending_requests[trace_id] = response_event
+                # ✅ 注册时间戳（用于 TTL 自动清理）
+                async_session_manager.register_request_timestamp(trace_id)
+                print(f"[Request] ✅ 已添加 trace_id: {trace_id} 到 _pending_requests")
+
+                try:
+                    # 发送消息（在线程中执行AgentCP操作）
+                    # 使用 asyncio.to_thread 避免阻塞事件循环
+                    claude_agent_name = await asyncio.to_thread(configPresenter.get_claude_agent_name)
+                    proxy_logger.info(f"发送消息到Claude Agent:{claude_agent_name}")
+                    print(f"[Async] 📤 准备发送消息:")
+                    print(f"[Async]   - Session ID: {session_id}")
+                    print(f"[Async]   - Agent Name: {claude_agent_name}")
+                    print(f"[Async]   - Trace ID: {trace_id}")
+                    print(f"[Async]   - Message Type: {proxy_message.get('type', 'N/A')}")
+
+                    step_start = time.time()
+                    await asyncio.to_thread(
+                        agentId.send_message, session_id, [claude_agent_name], proxy_message
+                    )
+                    perf_timings['send_message'] = (time.time() - step_start) * 1000
+
+                    proxy_logger.info("等待Claude Agent响应")
+                    print(f"[Async] ⏳ 等待Claude Agent响应, trace_id: {trace_id}")
+
+                    wait_start = time.time()
+
+                    # ✅ 优化超时：100秒超时（避免客户端100秒超时）
+                    # 减少超时时间可以：
+                    # 1. 更快地释放协程资源
+                    # 2. 减少客户端等待时间
+                    # 3. 避免大量协程长时间占用
+                    try:
+                        await asyncio.wait_for(response_event.wait(), timeout=300)
+                        perf_timings['wait_response'] = (time.time() - wait_start) * 1000
+                        proxy_logger.info(f"在100秒内收到响应，等待时间: {perf_timings['wait_response']:.2f}ms")
+                        # 成功收到响应，重置连续无响应计数
+                        _reset_no_response_count()
+                    except asyncio.TimeoutError:
+                        # 超时处理：增加连续无响应计数
+                        no_response_count = _increment_no_response_count()
+                        proxy_logger.warning(f"请求超时，trace_id: {trace_id}，连续无响应: {no_response_count}/{_consecutive_no_response_threshold}")
+                        log_info(f"[Async] 请求超时，trace_id: {trace_id}，连续无响应: {no_response_count}/{_consecutive_no_response_threshold}")
+
+                        # 只有连续无响应达到阈值时才触发重建
+                        if _should_trigger_rebuild():
+                            print(f"[Async] ⚠️ 连续 {no_response_count} 次无响应，触发自动重建...")
+                            print(f"[Async] 🔧 第1步：执行强制重建 AgentCP 体系...")
+
+                            try:
+                                # 同步等待重建完成
+                                rebuild_result = await force_rebuild_agentcp_system(bypass_cooldown=True)
+
+                                # 重建后重置计数器
+                                _reset_no_response_count()
+
+                                if rebuild_result["success"]:
+                                    print(f"[Async] ✅ 强制重建成功: {rebuild_result['agent_id']}")
+                                    print(f"[Async] 🔧 第2步：自动重试请求...")
+
+                                    # 重建成功，自动重试请求
+                                    # 需要重新获取全局 agentId（因为重建后已更新）
+                                    if agentId is None or not agentId.is_online_success:
+                                        print(f"[Async] ❌ 重建后 AgentID 仍然离线")
+                                        raise HTTPException(
+                                            status_code=503,
+                                            detail="连接重建后仍然离线，请稍后重试"
+                                        )
+
+                                    # 生成新的 trace_id 用于重试
+                                    retry_trace_id = f"retry_{trace_id}"
+                                    print(f"[Async] 🔄 重试请求，新 trace_id: {retry_trace_id}")
+
+                                    # 更新 proxy_message 中的 trace_id
+                                    if isinstance(proxy_message.get("content"), dict):
+                                        proxy_message["content"]["trace_id"] = retry_trace_id
+                                    proxy_message["trace_id"] = retry_trace_id
+
+                                    # 注册新的响应事件
+                                    retry_response_event = asyncio.Event()
+                                    async_session_manager._pending_requests[retry_trace_id] = retry_response_event
+                                    # ✅ 注册重试请求的时间戳（用于 TTL 自动清理）
+                                    async_session_manager.register_request_timestamp(retry_trace_id)
+
+                                    try:
+                                        # 重新发送消息
+                                        claude_agent_name = await asyncio.to_thread(configPresenter.get_claude_agent_name)
+                                        print(f"[Async] 📤 重新发送消息到 Claude Agent: {claude_agent_name}")
+
+                                        await asyncio.to_thread(
+                                            agentId.send_message, session_id, [claude_agent_name], proxy_message
+                                        )
+
+                                        # 等待重试响应（60秒超时）
+                                        print(f"[Async] ⏳ 等待重试响应...")
+                                        try:
+                                            await asyncio.wait_for(retry_response_event.wait(), timeout=300)
+                                            print(f"[Async] ✅ 重试请求收到响应")
+
+                                            # 获取重试结果
+                                            retry_result_data = async_session_manager._request_result_map.get(retry_trace_id)
+                                            if retry_result_data:
+                                                # 用重试结果替换原始结果，继续后续处理
+                                                async_session_manager._request_result_map[trace_id] = retry_result_data
+                                                perf_timings['wait_response'] = (time.time() - wait_start) * 1000
+                                                perf_timings['auto_rebuild_retry'] = True
+                                                # 不抛出异常，让代码继续执行后续的响应处理逻辑
+                                            else:
+                                                print(f"[Async] ❌ 重试请求未收到响应数据")
+                                                raise HTTPException(
+                                                    status_code=503,
+                                                    detail="自动重试后仍未收到响应，请稍后重试"
+                                                )
+
+                                        except asyncio.TimeoutError:
+                                            print(f"[Async] ❌ 重试请求也超时了")
+                                            raise HTTPException(
+                                                status_code=504,
+                                                detail="自动重建并重试后仍然超时，请检查网络连接或联系技术支持"
+                                            )
+
+                                    finally:
+                                        # 清理重试的 trace_id
+                                        async_session_manager._pending_requests.pop(retry_trace_id, None)
+                                        async_session_manager._request_result_map.pop(retry_trace_id, None)
+                                        # ✅ 清理重试请求的时间戳
+                                        async_session_manager.unregister_request_timestamp(retry_trace_id)
+
+                                else:
+                                    # 重建失败
+                                    print(f"[Async] ❌ 强制重建失败: {rebuild_result['message']}")
+                                    raise HTTPException(
+                                        status_code=503,
+                                        detail=f"连接自动重建失败: {rebuild_result['message']}，请尝试重启 Evol"
+                                    )
+
+                            except HTTPException:
+                                # 重新抛出 HTTPException
+                                raise
+                            except Exception as rebuild_error:
+                                print(f"[Async] ❌ 自动重建过程异常: {rebuild_error}")
+                                import traceback
+                                traceback.print_exc()
+                                raise HTTPException(
+                                    status_code=503,
+                                    detail=f"连接自动重建异常: {str(rebuild_error)}，请尝试重启 Evol"
+                                )
+                        else:
+                            # 未达到重建阈值，直接返回错误让用户重试
+                            print(f"[Async] ⚠️ 请求超时（连续 {no_response_count}/{_consecutive_no_response_threshold} 次），返回错误让用户重试")
+                            raise HTTPException(
+                                status_code=504,
+                                detail=f"请求超时，请重试（连续超时 {no_response_count}/{_consecutive_no_response_threshold} 次）"
+                            )
+
+                    # ✅ 从result_map中获取结果（参考第253-254行）
+                    result_data = async_session_manager._request_result_map.get(trace_id)
+                    if not result_data:
+                        proxy_logger.error(f"未收到响应数据，trace_id: {trace_id}")
+                        raise HTTPException(status_code=503, detail="No response received")
+
+                    result_type = result_data.get("result_type", "")
+                    response_msg = result_data.get("result", {})
+
+
+                    proxy_logger.info(f"收到响应，类型: {result_type}, trace_id: {trace_id}")
+
+                    # 解析响应消息类型
+                    msg_type = result_type
+                    content = response_msg.get("content", {}) if isinstance(response_msg, dict) else response_msg
+
+                    # 1. 处理错误响应
+                    if msg_type == "error":
+                        error_message = content if isinstance(content, str) else str(content)
+                        http_status = response_msg.get("http_status", 503)
+                        headers = response_msg.get("headers", {})
+                        proxy_logger.error(f"Claude代理返回错误: {error_message}, trace_id: {trace_id}")
+                        log_error(f"[Async] Claude代理返回错误: {error_message}, trace_id: {trace_id}")
+                        return Response(
+                            content = error_message,
+                            status_code = http_status,
+                            headers = headers,
+                            media_type = headers.get('content-type',"application/json")
+                        )
+
+                    # 2. 处理流式响应
+                    if msg_type == "text/event-stream":
+                        stream_url = content if isinstance(content, str) else content.get("url", "")
+                        if stream_url:
+                            proxy_logger.info(f"Claude代理开始流式响应: {stream_url}, trace_id: {trace_id}")
+                            print(f"[Async] Claude代理开始流式响应: {stream_url}, trace_id: {trace_id}")
+                            return await handle_stream_response(stream_url)
+                        else:
+                            proxy_logger.error(f"流式响应缺少URL, trace_id: {trace_id}")
+                            log_error(f"[Async] 流式响应缺少URL, trace_id: {trace_id}")
+                            raise HTTPException(status_code=504, detail="Stream URL missing")
+
+                    # 3. 处理普通成功响应
+                    proxy_logger.info("处理普通成功响应")
+                    if isinstance(content, dict):
+                        status_code = content.get("status_code", 200)
+                        response_headers = content.get("headers", {})
+                        response_body = content.get("body", "")
+
+                        # ✅ 修复：移除会导致客户端解析失败的headers
+                        # 上游返回的body已经是解码后的JSON，不是gzip压缩的
+                        # 如果保留Content-Encoding: gzip，客户端会尝试解压导致失败
+                        headers_to_remove = ['Content-Encoding', 'Transfer-Encoding', 'Content-Length']
+                        for header in headers_to_remove:
+                            response_headers.pop(header, None)
+                    else:
+                        status_code = 200
+                        response_headers = {"Content-Type": "application/json"}
+                        response_body = json.dumps(content) if not isinstance(content, str) else content
+
+                    proxy_logger.info(f"Claude代理响应完成: {status_code}, trace_id: {trace_id}")
+                    log_info(f"[Async] Claude代理响应完成: {status_code}, trace_id: {trace_id}")
+
+                    # 确保response_body是可以编码的类型
+                    if isinstance(response_body, dict):
+                        # 如果response_body是dict，将其转换为JSON字符串
+                        response_body = json.dumps(response_body, ensure_ascii=False)
+                    elif isinstance(response_body, (list, tuple)):
+                        # 如果是列表或元组，也转换为JSON字符串
+                        response_body = json.dumps(response_body, ensure_ascii=False)
+                    elif not isinstance(response_body, (str, bytes)):
+                        # 如果是其他类型，转换为字符串
+                        response_body = str(response_body)
+                    real_response = response_body if isinstance(response_body, bytes) else response_body.encode('utf-8')
+
+                    proxy_logger.info(f"准备返回响应给客户端，trace_id: {trace_id}")
+                    proxy_logger.info(f"状态码: {status_code}")
+                    proxy_logger.info(f"响应体大小: {len(real_response)} bytes")
+
+                    # ✅ 详细诊断日志
+                    print(f"\n{'='*80}")
+                    print(f"[Async] 📤 准备返回响应给客户端")
+                    print(f"  trace_id: {trace_id}")
+                    print(f"  status_code: {status_code}")
+                    print(f"  Content-Type: {response_headers.get('Content-Type', 'application/json')}")
+                    print(f"  响应体大小: {len(real_response)} bytes")
+                    print(f"  响应体前200字符: {real_response[:200]}")
+
+                    # ✅ 性能监控：输出性能统计
+                    total_time = (time.time() - perf_start) * 1000
+                    perf_timings['total'] = total_time
+
+                    proxy_logger.info("=" * 80)
+                    proxy_logger.info("Claude代理请求处理完成 - 性能统计")
+                    proxy_logger.info(f"总耗时: {total_time:.2f}ms")
+                    proxy_logger.info("各步骤耗时:")
+                    for step_name, duration in perf_timings.items():
+                        if step_name != 'total':
+                            percentage = (duration / total_time * 100) if total_time > 0 else 0
+                            proxy_logger.info(f"  - {step_name}: {duration:.2f}ms ({percentage:.1f}%)")
+                    proxy_logger.info("=" * 80)
+
+                    # 在控制台也输出性能统计（便于实时监控）
+                    print(f"[Perf] 总耗时: {total_time:.2f}ms | " +
+                          " | ".join([f"{k}: {v:.1f}ms" for k, v in perf_timings.items() if k != 'total']))
+
+                    # 标记请求成功（用于积分确认）
+                    request_success = True
+
+                    return Response(
+                        content = real_response,
+                        status_code = status_code,
+                        headers = response_headers,
+                        media_type=response_headers.get('Content-Type',"application/json")
+                    )
+
+                except asyncio.TimeoutError:
+                    proxy_logger.error(f"Claude代理请求超时: {trace_id}")
+                    log_error(f"[Async] Claude代理请求超时: {trace_id}")
+                    raise HTTPException(status_code=504, detail="Gateway Timeout")
+                except HTTPException:
+                    raise
+                except Exception as e:
+                    import traceback
+
+                    # 详细的错误信息记录
+                    error_details = {
+                        "error_type": type(e).__name__,
+                        "error_message": str(e),
+                        "trace_id": trace_id,
+                        "response_body_type": type(locals().get('response_body', None)).__name__ if 'response_body' in locals() else 'unknown',
+                        "response_body_value": str(locals().get('response_body', 'N/A'))[:200] if 'response_body' in locals() else 'N/A'
+                    }
+
+                    full_traceback = traceback.format_exc()
+                    proxy_logger.error(f"等待Claude代理响应失败: {str(e)}")
+                    proxy_logger.error(f"错误详情: {error_details}")
+                    proxy_logger.error(f"完整堆栈跟踪:\n{full_traceback}")
+
+                    log_error(f"[Async] 等待Claude代理响应失败: {str(e)}")
+                    log_error(f"[Async] 错误详情: {error_details}")
+                    log_error(f"[Async] 完整堆栈跟踪: {full_traceback}")
+
+                    # 控制台输出详细错误信息
+                    print("=" * 80)
+                    print(f"🚨 [Async] Claude代理响应处理失败:")
+                    print(f"📋 错误类型: {error_details['error_type']}")
+                    print(f"💬 错误消息: {error_details['error_message']}")
+                    print(f"🔍 追踪ID: {error_details['trace_id']}")
+                    print(f"📦 响应体类型: {error_details['response_body_type']}")
+                    print(f"📄 响应体内容: {error_details['response_body_value']}")
+                    print("📚 完整堆栈跟踪:")
+                    print(full_traceback)
+                    print("=" * 80)
+
+                    raise HTTPException(status_code=500, detail=f"Proxy Error: {str(e)}")
+                finally:
+                    # ✅ P2修复：延迟清理trace_id，避免竞态条件
+                    # 场景：如果AgentCP的响应消息正在处理中，过早清理会导致响应丢失
+                    # 等待100ms确保消息处理器有足够时间存储结果
+                    try:
+                        await asyncio.sleep(0.1)
+                    except asyncio.CancelledError:
+                        # 用户断开连接导致协程取消，继续清理
+                        pass
+                    async_session_manager._pending_requests.pop(trace_id, None)
+                    async_session_manager._request_result_map.pop(trace_id, None)
+                    # ✅ 清理时间戳记录
+                    async_session_manager.unregister_request_timestamp(trace_id)
+
+            else:
+                # 循环重试后仍然失败
+                proxy_logger.error("获取或创建Claude代理会话失败（已重试）")
+                log_error("[Async] 获取或创建Claude代理会话失败（已重试）")
+                raise HTTPException(status_code=503, detail="Service Unavailable: Cannot get or create session")
+        else:
+            # 兜底逻辑：理论上经过前面的重连逻辑后不会进入这里
+            proxy_logger.error("AgentID 未连接（兜底）")
+            log_error("[Async] AgentID 未连接（兜底），请尝试重新启动 Evol")
+            raise HTTPException(status_code=503, detail="Service Unavailable: 连接失败，请尝试重新启动 Evol")
+
+    except HTTPException as e:
+        # ✅ 直接重新抛出 HTTPException，保留原始错误信息
+        proxy_logger.error(f"HTTPException: {e.detail}")
+        raise
+    except Exception as e:
+        import traceback
+        full_traceback = traceback.format_exc()
+
+        proxy_logger.error(f"Claude代理请求处理失败: {str(e)}")
+        proxy_logger.error(f"异常堆栈:\n{full_traceback}")
+
+        traceback.print_exc()
+        print(f"[Async] Claude代理请求处理失败: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Proxy Error: {str(e)}")
+    finally:
+        # 处理积分预扣除的释放或确认
+        if reserved_credits > 0 and user_id:
+            try:
+                
+
+                if request_success:
+                    # 请求成功，确认积分使用
+                    await credits_lock_manager.confirm_credits_usage(
+                        user_id=user_id,
+                        amount=reserved_credits,
+                        request_id=request_id
+                    )
+                    proxy_logger.info(f"✅ 积分使用已确认: {reserved_credits}")
+                    print(f"[Async] ✅ 积分使用已确认: {reserved_credits}")
+                else:
+                    # 请求失败，释放预扣除的积分
+                    await credits_lock_manager.release_reserved_credits(
+                        user_id=user_id,
+                        amount=reserved_credits,
+                        request_id=request_id
+                    )
+                    proxy_logger.info(f"🔄 积分预扣除已释放: {reserved_credits}")
+                    print(f"[Async] 🔄 积分预扣除已释放: {reserved_credits}")
+
+            except Exception as e:
+                proxy_logger.error(f"❌ 积分处理失败: {str(e)}")
+                print(f"[Async] ❌ 积分处理失败: {str(e)}")
+
+        # 注意：不再需要关闭 file_handler，因为使用了重用的全局 logger
+
+
+async def handle_stream_response(stream_url: str):
+    """
+    处理流式响应（异步版本）
+    参考llm_agent_utils.py中read_stream_claude的实现
+    上游Claude Agent发送的是URL编码的SSE流，格式为:
+        data: event: message_start
+        data: data: {...}
+    需要解码并转换为标准SSE格式:
+        event: message_start
+        data: {...}
+
+    """
+    try:
+        # 添加agent_id参数
+        url = stream_url + "&agent_id=" + agentId.id
+        print(f"[Async] 流式响应开始: {url}")
+
+        async def stream_generator():
+            """
+            SSE流生成器 - 处理上游特殊格式的SSE流
+            参考: llm_agent_utils.py read_stream_claude() 第386-395行
+
+            上游格式（URL编码）:
+                data: event: message_start
+                data: data: {"type":"message_start"...}
+
+            转换为标准SSE（参考第370行的输出格式）:
+                event: message_start
+                data: {"type":"message_start"...}
+
+            """
+            try:
+                current_event = None  # 当前事件类型
+                stream_ended_normally = False  # 标记流是否通过 event:done 正常结束
+
+                async with httpx.AsyncClient(verify=False, timeout=httpx.Timeout(30.0, read=300.0)) as client:
+                    async with client.stream("GET", url) as response:
+                        # 检查响应状态
+                        if response.status_code != 200:
+                            log_error(f"[Async] 流式响应错误状态码: {response.status_code}")
+                            error_msg = f"event: error\ndata: {{\"error\": \"Stream error: HTTP {response.status_code}\"}}\n\n"
+                            yield error_msg.encode('utf-8')
+                            return
+
+                        # 按行处理SSE流
+                        # 上游格式是成对出现的：
+                        # 行1: data: event: message_start
+                        # 行2: data: data: {...}
+                        # 需要缓存event，等到data行时一次性输出完整SSE事件
+                        async for line in response.aiter_lines():
+                            if line:
+                                try:
+                                    # ✅ 关键步骤1：URL解码（参考read_stream_claude第387、390行）
+                                    decoded_line = urllib.parse.unquote_plus(line)
+
+                                    # ✅ 关键步骤2：解析格式（参考read_stream_claude第392行）
+                                    # 上游格式: "data: event: xxx" 或 "data: data: {...}" 或 "event: done"
+                                    if ":" not in decoded_line:
+                                        continue
+
+                                    key, value = decoded_line.split(":", 1)
+                                    key = key.strip()
+                                    value = value.strip()
+
+                                    # ✅ 关键步骤3：转换为标准SSE格式（参考第370行的一次性输出）
+                                    if key == "data":
+                                        # 处理 "data: event: xxx" 或 "data: data: {...}"
+                                        if ":" in value:
+                                            inner_key, inner_value = value.split(":", 1)
+                                            inner_key = inner_key.strip()
+                                            inner_value = inner_value.strip()
+
+                                            if inner_key == "event":
+                                                # 缓存事件类型，等待下一行的data
+                                                current_event = inner_value
+                                            elif inner_key == "data":
+                                                # 收到data行，一次性输出完整SSE事件
+                                                # 格式：event: xxx\ndata: {...}\n\n（参考第370行）
+                                                if current_event:
+                                                    output = f"event: {current_event}\ndata: {inner_value}\n\n"
+                                                    # print(f"[Async] 流式响应输出1: {output.strip()}")
+                                                    yield output.encode('utf-8')
+                                                    current_event = None
+                                                else:
+                                                    # 没有event的data行（异常情况，直接输出）
+                                                    output = f"data: {inner_value}\n\n"
+
+                                                    # ✅ 诊断：检查是否为最后一条数据（包含 finishReason）
+                                                    if "finishReason" in inner_value:
+                                                        print(f"[Async] 🎯 检测到最后一条数据（包含 finishReason）")
+                                                        print(f"[Async]    数据长度: {len(inner_value)} 字符")
+                                                        # 尝试解析 JSON 验证完整性
+                                                        try:
+                                                            import json
+                                                            json.loads(inner_value)
+                                                            print(f"[Async]    ✓ JSON 格式验证通过")
+                                                        except json.JSONDecodeError as e:
+                                                            print(f"[Async]    ✗ JSON 格式无效: {e}")
+
+                                                    # print(f"[Async] 流式响应输出2: {output[:200].strip()}...")  # 只打印前200字符
+                                                    yield output.encode('utf-8')
+                                    elif key == "event":
+                                        # 处理 "event: done" 格式（参考第395行）
+                                        if value == "done":
+                                            # 🔧 修复：收到 event:done 时，不发送任何内容
+                                            # gemini-cli 不需要显式的结束标记，通过连接关闭判断流结束
+                                            stream_ended_normally = True
+                                            print(f"[Async] 🔚 收到 event:done，直接结束流（不发送结束标记）")
+                                            break
+                                        else:
+                                            # 其他独立event（没有配对data的情况）
+                                            output = f"event: {value}\n\n"
+                                            yield output.encode('utf-8')
+
+                                except Exception as e:
+                                    log_error(f"[Async] 处理SSE行失败: {str(e)}, 原始行: {line[:100]}")
+                                    # ✅ 发送错误事件给客户端，而不是静默跳过
+                                    error_event = f'event: error\ndata: {{"error": "SSE parse error: {str(e)[:100]}"}}\n\n'
+                                    yield error_event.encode('utf-8')
+                                    continue
+
+                        # ✅ 修复：流结束处理
+                        # gemini-cli 不需要显式的结束标记，通过连接关闭判断流结束
+                        print(f"[Async] 📍 流式响应 for 循环结束")
+                        print(f"[Async]    stream_ended_normally = {stream_ended_normally}")
+
+                        if not stream_ended_normally:
+                            print(f"[Async] 🔚 流式响应自然结束（无 event:done），直接关闭连接")
+                            log_info(f"[Async] 流式响应自然结束，无需发送结束标记")
+                        else:
+                            print(f"[Async] ℹ️  流式响应已通过 event:done 结束")
+
+                        # 不发送任何结束标记，让 StreamingResponse 自然关闭连接
+
+            except httpx.TimeoutException as e:
+                log_error(f"[Async] 流式响应超时: {str(e)}")
+                error_msg = 'event: error\ndata: {"error": "Stream timeout"}\n\n'
+                yield error_msg.encode('utf-8')
+            except httpx.RequestError as e:
+                log_error(f"[Async] 流式请求错误: {str(e)}")
+                error_msg = f'event: error\ndata: {{"error": "Stream request error: {str(e)}"}}\n\n'
+                yield error_msg.encode('utf-8')
+            except Exception as e:
+                log_error(f"[Async] 流式生成器异常: {str(e)}")
+                import traceback
+                log_error(f"[Async] 异常堆栈: {traceback.format_exc()}")
+                error_msg = f'event: error\ndata: {{"error": "Stream processing error: {str(e)}"}}\n\n'
+                yield error_msg.encode('utf-8')
+
+        return StreamingResponse(
+            stream_generator(),
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "X-Accel-Buffering": "no"
+            }
+        )
+
+    except httpx.TimeoutException:
+        log_error(f"[Async] 流式请求超时: {stream_url}")
+        raise HTTPException(status_code=504, detail="Stream timeout")
+    except httpx.RequestError as e:
+        log_error(f"[Async] 流式请求失败: {str(e)}")
+        raise HTTPException(status_code=502, detail=f"Stream error: {str(e)}")
+    except Exception as e:
+        log_error(f"[Async] 处理流式响应异常: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Stream processing error: {str(e)}")
+
+
+async def handle_slow_request_as_stream(
+    response_event: asyncio.Event,
+    trace_id: str,
+    session_manager
+):
+    """
+    将慢速非流式请求包装为SSE流式响应
+    用于避免客户端60秒超时问题
+
+    工作流程：
+    1. 立即返回SSE流响应（避免客户端超时）
+    2. 每5秒发送心跳事件，告知客户端"还在处理"
+    3. 收到真实响应后，通过SSE发送完整数据
+    """
+    async def slow_response_generator():
+        """SSE流生成器 - 用于包装慢速响应"""
+        try:
+            # 发送初始消息
+            init_msg = json.dumps({"type": "processing", "message": "Request is being processed..."})
+            yield f"event: processing\ndata: {init_msg}\n\n".encode('utf-8')
+
+            # 最多再等待190秒（总共240秒）
+            max_wait_time = 190
+            check_interval = 5
+            elapsed = 0
+
+            while elapsed < max_wait_time:
+                try:
+                    # 每5秒检查一次是否有响应
+                    await asyncio.wait_for(response_event.wait(), timeout=check_interval)
+                    # 收到响应，跳出循环
+                    break
+                except asyncio.TimeoutError:
+                    # 还没收到响应，发送心跳
+                    elapsed += check_interval
+                    heartbeat = json.dumps({
+                        "type": "heartbeat",
+                        "message": f"Still processing... ({elapsed}s elapsed)",
+                        "elapsed_seconds": elapsed
+                    })
+                    yield f"event: heartbeat\ndata: {heartbeat}\n\n".encode('utf-8')
+
+            # 检查是否收到了响应
+            result_data = session_manager._request_result_map.get(trace_id)
+            if not result_data:
+                # 超时未收到响应
+                error_msg = json.dumps({
+                    "type": "error",
+                    "error": {
+                        "type": "timeout_error",
+                        "message": "Request timeout: No response from upstream after 240 seconds"
+                    }
+                })
+                yield f"event: error\ndata: {error_msg}\n\n".encode('utf-8')
+                return
+
+            result_type = result_data.get("result_type", "")
+            response_msg = result_data.get("result", {})
+
+            # 处理错误响应
+            if result_type == "error":
+                content = response_msg.get("content", {}) if isinstance(response_msg, dict) else response_msg
+                error_message = content if isinstance(content, str) else str(content)
+                error_data = json.dumps({
+                    "type": "error",
+                    "error": {
+                        "type": "api_error",
+                        "message": error_message
+                    }
+                })
+                yield f"event: error\ndata: {error_data}\n\n".encode('utf-8')
+                return
+
+            # 处理成功响应 - 包装成SSE格式
+            content = response_msg.get("content", {}) if isinstance(response_msg, dict) else response_msg
+
+            if isinstance(content, dict):
+                response_body = content.get("body", {})
+            else:
+                response_body = content
+
+            # 将完整响应作为一个SSE事件发送
+            response_json = json.dumps(response_body, ensure_ascii=False)
+            yield f"event: message\ndata: {response_json}\n\n".encode('utf-8')
+
+            # 发送完成事件
+            yield f"event: done\ndata: {json.dumps({'type': 'done'})}\n\n".encode('utf-8')
+
+            log_info(f"[Async] 慢速请求流式响应完成，trace_id: {trace_id}")
+
+        except Exception as e:
+            log_error(f"[Async] 慢速请求流生成器异常: {str(e)}")
+            import traceback
+            log_error(f"[Async] 异常堆栈: {traceback.format_exc()}")
+            error_msg = json.dumps({
+                "type": "error",
+                "error": {
+                    "type": "internal_error",
+                    "message": f"Stream processing error: {str(e)}"
+                }
+            })
+            yield f"event: error\ndata: {error_msg}\n\n".encode('utf-8')
+
+    return StreamingResponse(
+        slow_response_generator(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no",
+            "X-Slow-Request-Wrapper": "true"  # 标记这是包装的流式响应
+        }
+    )
+
+
+async def get_session_status():
+    """获取Session状态信息"""
+    try:
+        session_info = async_session_manager.get_session_info()
+        return JSONResponse(content=session_info, status_code=200)
+    except Exception as e:
+        log_error(f"[Async] 获取session状态失败: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Session status error: {str(e)}")
+
+
+def set_agent_id(aid: AgentID):
+    """设置AgentID实例"""
+    global agentId
+    global async_session_manager
+
+    old_agent_id = agentId.id if agentId else None
+    new_agent_id = aid.id if aid else None
+
+    print(f"[set_agent_id] AgentID 变更：{old_agent_id} -> {new_agent_id}")
+
+    # ✅ 关键修复：如果 AgentID 改变，清空所有 sessions 和 handlers
+    # 因为旧的 handlers 注册在旧的 AgentID 上，无法接收新 AgentID 的消息
+    if old_agent_id != new_agent_id and async_session_manager is not None:
+        print(f"[set_agent_id] ⚠️ AgentID 已改变，清空所有 sessions 和 handlers")
+        print(f"[set_agent_id] 清理前 - sessions: {len(async_session_manager._sessions)}, handlers: {len(async_session_manager._handler_registered)}")
+
+        # 清空所有映射
+        async_session_manager._sessions.clear()
+        async_session_manager._session_info.clear()
+        async_session_manager._handler_registered.clear()
+        async_session_manager._pending_requests.clear()
+        async_session_manager._request_result_map.clear()
+        # ✅ 清理时间戳记录
+        if hasattr(async_session_manager, '_request_timestamps'):
+            async_session_manager._request_timestamps.clear()
+
+        print(f"[set_agent_id] ✅ 已清空所有 sessions 和 handlers")
+
+    # 🔧 修复：无论是否清理，都要更新全局 agentId
+    agentId = aid
+
+    # ✅ 关键修复：同步 agentId 到 userPresenter，保持两处一致
+    if aid is not None:
+        userPresenter.agentId = aid
+        print(f"[set_agent_id] ✅ 已同步 AgentID 到 userPresenter")
+
+        # ✅ 注册断开回调，实现自动重建
+        _register_disconnect_callback(aid)
+
+    log_info(f"[Async] Claude Proxy异步版本已初始化，AgentID: {aid.id if aid else 'None'}")
+
+
+async def init_agent_id_on_startup():
+    """
+    服务器启动时尝试自动加载当前用户绑定的AgentID
+
+    ⚠️ 重要：必须使用服务器返回的用户绑定AID，绝对不能随意加载本地AID
+    流程：
+    1. 检查用户是否已登录，未登录则直接返回（不重试）
+    2. 调用 userPresenter.user_agent_login() 获取服务器绑定的AID
+    3. 如果 token 过期或需要重新登录，直接返回（不重试）
+    4. 其他错误（如网络问题）重试3次，每次间隔2秒
+    """
+    global agentId, _agentcp_instance
+
+    # 防止重复初始化
+    if agentId is not None:
+        print(f"[Startup] AgentID 已存在，跳过重复初始化")
+        print(f"[Startup] 现有 AgentID: {agentId.id}")
+        return
+
+    print(f"[Startup] 开始初始化 AgentID...")
+
+    # 检查用户是否已登录（不重试）
+    if not userPresenter.is_logged_in():
+        print(f"[Startup] 用户未登录，跳过 AgentID 初始化（用户登录后会自动触发）")
+        return
+
+    MAX_RETRIES = 3
+    RETRY_INTERVAL = 2  # 秒
+
+    for attempt in range(1, MAX_RETRIES + 1):
+        try:
+            print(f"[Startup] 用户已登录，调用 user_agent_login 获取服务器绑定的AID... (第 {attempt}/{MAX_RETRIES} 次)")
+
+            login_result = await userPresenter.user_agent_login()
+
+            if login_result.get("status") == "success":
+                # 登录成功，agentId 已经在 user_agent_login 中设置
+                aid_id = login_result.get("aid")
+                print(f"[Startup] ✅ 成功加载服务器绑定的 AgentID: {aid_id}")
+
+                # 确保全局 agentId 已同步
+                if userPresenter.agentId is not None:
+                    agentId = userPresenter.agentId
+                    _agentcp_instance = userPresenter._get_agentcp_instance()
+
+                    # 注册断开回调
+                    _register_disconnect_callback(agentId)
+                    print(f"[Startup] ✅ AgentID 已同步到全局变量")
+                return
+            else:
+                # 登录失败，检查是否是 token 过期或需要重新登录
+                error_msg = login_result.get("error", "未知错误")
+                need_relogin = login_result.get("need_relogin", False)
+
+                if need_relogin or "token" in error_msg.lower() or "过期" in error_msg or "登录" in error_msg:
+                    # token 过期或需要重新登录，不重试
+                    print(f"[Startup] Token 过期或需要重新登录，跳过 AgentID 初始化: {error_msg}")
+                    return
+
+                # 其他错误（如网络问题），重试
+                print(f"[Startup] ❌ user_agent_login 失败: {error_msg}")
+                if attempt < MAX_RETRIES:
+                    print(f"[Startup] ⏳ 等待 {RETRY_INTERVAL} 秒后重试...")
+                    await asyncio.sleep(RETRY_INTERVAL)
+
+        except Exception as e:
+            log_error(f"[Startup] 第 {attempt} 次尝试异常: {str(e)}")
+            import traceback
+            log_error(traceback.format_exc())
+            if attempt < MAX_RETRIES:
+                print(f"[Startup] ⏳ 等待 {RETRY_INTERVAL} 秒后重试...")
+                await asyncio.sleep(RETRY_INTERVAL)
+
+    # 所有重试都失败
+    print(f"[Startup] ❌ 已重试 {MAX_RETRIES} 次，AgentID 初始化失败")
+    log_error(f"[Startup] AgentID 初始化失败：已重试 {MAX_RETRIES} 次")
+
+
+async def reload_agent_id() -> dict:
+    """
+    重新获取服务AID，重新加载 AgentID
+
+    此接口用于：
+    1. 当健康检查失败时，手动触发重新加载
+    2. 当需要刷新 AgentID 连接时调用
+
+    流程：
+    1. 调用 userPresenter.user_agent_login() 重新获取服务端 AID
+    2. 更新全局 agentId
+    3. 同步到 evol_health_check 模块
+    4. 注册断开回调
+
+    Returns:
+        dict: {
+            "success": bool,
+            "message": str,
+            "agent_id": str or None,
+            "is_online": bool
+        }
+    """
+    global agentId, _agentcp_instance
+
+    print("\n" + "=" * 80)
+    print("[ReloadAgentID] 🔄 开始重新加载 AgentID...")
+    print("=" * 80)
+    log_info("[ReloadAgentID] 开始重新加载 AgentID")
+
+    try:
+        # 1. 检查用户是否已登录
+        if not userPresenter.is_logged_in():
+            print("[ReloadAgentID] ❌ 用户未登录")
+            return {
+                "success": False,
+                "message": "用户未登录，无法重新加载 AgentID",
+                "agent_id": None,
+                "is_online": False
+            }
+
+        # 2. 记录旧的 AgentID（如果存在）
+        old_agent_id = agentId.id if agentId else None
+        print(f"[ReloadAgentID] 当前 AgentID: {old_agent_id}")
+
+        # 3. 调用 user_agent_login 重新获取服务端绑定的 AID
+        print("[ReloadAgentID] 📡 调用 user_agent_login 获取服务端 AID...")
+        login_result = await userPresenter.user_agent_login()
+
+        if login_result.get("status") != "success":
+            error_msg = login_result.get("error", "未知错误")
+            print(f"[ReloadAgentID] ❌ user_agent_login 失败: {error_msg}")
+            return {
+                "success": False,
+                "message": f"获取服务端 AID 失败: {error_msg}",
+                "agent_id": old_agent_id,
+                "is_online": agentId.is_online_success if agentId else False
+            }
+
+        # 4. 同步全局 agentId
+        if userPresenter.agentId is not None:
+            new_agent_id = userPresenter.agentId
+            agentId = new_agent_id
+            _agentcp_instance = userPresenter._get_agentcp_instance()
+
+            print(f"[ReloadAgentID] ✅ AgentID 已更新: {old_agent_id} -> {new_agent_id.id}")
+
+            # 5. 清空 AsyncSessionManager 缓存（因为 AgentID 改变了）
+            _clear_async_session_manager_cache()
+            print("[ReloadAgentID] ✅ 已清空 AsyncSessionManager 缓存")
+
+            # 6. 注册断开回调
+            _register_disconnect_callback(new_agent_id, disable_auto_reconnect=True)
+            print("[ReloadAgentID] ✅ 已注册断开回调")
+
+            # 7. 同步到 evol_health_check 模块
+            try:
+                from . import evol_health_check
+                health_checker = evol_health_check.get_health_checker()
+                # 重置 handler 注册状态，下次健康检查时重新注册
+                health_checker._handler_registered = False
+                print("[ReloadAgentID] ✅ 已同步到 evol_health_check 模块")
+            except Exception as e:
+                print(f"[ReloadAgentID] ⚠️ 同步到 evol_health_check 失败（非致命）: {e}")
+
+            print("=" * 80)
+            print(f"[ReloadAgentID] 🎉 AgentID 重新加载成功!")
+            print(f"[ReloadAgentID]   - AgentID: {new_agent_id.id}")
+            print(f"[ReloadAgentID]   - 在线状态: {new_agent_id.is_online_success}")
+            print("=" * 80 + "\n")
+            log_info(f"[ReloadAgentID] 重新加载成功: {new_agent_id.id}")
+
+            return {
+                "success": True,
+                "message": "AgentID 重新加载成功",
+                "agent_id": new_agent_id.id,
+                "is_online": new_agent_id.is_online_success
+            }
+        else:
+            print("[ReloadAgentID] ❌ user_agent_login 成功但 agentId 为空")
+            return {
+                "success": False,
+                "message": "获取 AgentID 成功但实例为空",
+                "agent_id": None,
+                "is_online": False
+            }
+
+    except Exception as e:
+        import traceback
+        error_traceback = traceback.format_exc()
+        print(f"[ReloadAgentID] ❌ 重新加载异常: {e}")
+        print(f"[ReloadAgentID] 异常堆栈:\n{error_traceback}")
+        log_error(f"[ReloadAgentID] 重新加载异常: {e}")
+
+        return {
+            "success": False,
+            "message": f"重新加载异常: {str(e)}",
+            "agent_id": agentId.id if agentId else None,
+            "is_online": agentId.is_online_success if agentId else False
+        }
+
+
+def get_current_agent_id() -> AgentID:
+    """
+    获取当前全局 AgentID 实例
+
+    供其他模块（如 evol_health_check）使用
+
+    Returns:
+        AgentID: 当前的 AgentID 实例，如果未初始化则返回 None
+    """
+    global agentId
+    return agentId
+
+
+# ==================== OpenClaw Proxy 支持函数 ====================
+
+def verify_api_key(api_key: str) -> Optional[dict]:
+    """
+    验证 API Key 并返回用户信息
+
+    Args:
+        api_key: API Key (格式: evol-{32位hex} 或 sk_live_{40位随机字符})
+
+    Returns:
+        dict: 用户信息 {"user_id": str, "username": str} 或 None (验证失败)
+    """
+    try:
+        # 检查 API Key 格式
+        if not api_key:
+            return None
+
+        # 支持两种格式：
+        # 1. evol-{32位hex} (旧格式，用于测试)
+        # 2. sk_live_{40位随机字符} (新格式，标准格式)
+
+        if api_key.startswith("evol-"):
+            # 旧格式：简单验证长度
+            if len(api_key) != 37:  # "evol-" + 32位hex
+                return None
+            # 返回模拟用户信息（用于测试）
+            return {
+                "user_id": "test_user",
+                "username": "Test User"
+            }
+
+        elif api_key.startswith("sk_live_"):
+            # 新格式：通过 apikeyPresenter 验证
+            # TODO: 实现真实的 API Key 验证逻辑
+            # 目前返回模拟数据
+            return {
+                "user_id": "api_user",
+                "username": "API User"
+            }
+
+        else:
+            # 不支持的格式
+            return None
+
+    except Exception as e:
+        log_error(f"[verify_api_key] 验证失败: {e}")
+        return None
+
+
+def check_and_deduct_credits(user_id: str) -> bool:
+    """
+    检查并扣除用户积分
+
+    Args:
+        user_id: 用户ID
+
+    Returns:
+        bool: True 表示积分充足并已扣除，False 表示积分不足
+    """
+    try:
+        # TODO: 实现真实的积分检查和扣除逻辑
+        # 目前直接返回 True（允许所有请求）
+        return True
+
+    except Exception as e:
+        log_error(f"[check_and_deduct_credits] 检查积分失败: {e}")
+        return False
+
+
+# 以下为模块其他代码