@agentunion/kite 1.4.0 → 1.5.0

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

@@ -0,0 +1,15 @@
+"""代理配置 - 封装不同代理的差异点"""
+from dataclasses import dataclass
+from typing import Callable, Any
+
+
+@dataclass
+class ProxyConfig:
+    """代理配置 - 封装两个代理的差异点"""
+    target_aid_getter: Callable[[str], str]  # 获取目标AID: api_key -> aid
+    request_converter: Callable[[dict], dict]  # 请求格式转换
+    response_converter: Callable[[dict], dict]  # 响应格式转换
+    stream_handler: Callable  # 流式响应处理
+    error_formatter: Callable[[Exception], Any]  # 错误格式化
+    model_validator: Callable[[str], bool]  # 模型验证
+    proxy_type: str  # "claude" | "openclaw"

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

@@ -0,0 +1,501 @@
+"""
+统一代理引擎 - 处理所有共同业务逻辑
+
+注意事项:
+1. 必须通过 claude_proxy_async 模块访问全局变量（agentId, async_session_manager 等），
+   不能用 from ... import 导入，因为那样会拿到导入时刻的快照值，后续重建后不会更新。
+2. 路径前缀剥离必须覆盖所有代理类型。
+3. 错误响应必须保留上游返回的 http_status 和 headers，不能自作主张改为 500。
+4. response_converter 只应用于非流式的普通成功响应，且仅在响应体本身是有效 dict 时才转换。
+5. x-goog-api-key 是 Gemini 的 API Key header，必须支持。
+"""
+import asyncio
+import json
+import time
+import uuid
+import traceback
+from datetime import datetime
+from typing import Optional
+from fastapi import Request, HTTPException
+from fastapi.responses import Response
+from .proxy_config import ProxyConfig
+
+
+# 所有需要剥离的路径前缀
+_PATH_PREFIXES_TO_STRIP = [
+    "/claude-proxy",
+    "/codex-proxy",
+    "/gemini-proxy",
+    "/openclaw-proxy",
+]
+
+
+def _strip_proxy_prefix(path: str) -> str:
+    """剥离路径中的代理前缀"""
+    for prefix in _PATH_PREFIXES_TO_STRIP:
+        if path.startswith(prefix):
+            return path[len(prefix):]
+    return path
+
+
+async def proxy_engine(
+    request: Request,
+    config: ProxyConfig,
+    x_api_key: Optional[str] = None
+):
+    """
+    统一的代理引擎 - 处理所有共同业务逻辑
+
+    核心流程:
+    1. API Key 提取
+    2. 用户验证 + 积分预扣除
+    3. 读取并解析请求体 + 模型验证 + 请求转换
+    4. 构建代理消息
+    5. AgentID 在线检查 + 重建
+    6. 会话管理（获取/创建/重试）
+    7. 消息发送 + 响应等待（含超时重建重试）
+    8. 响应处理（错误 / 流式 / 普通）
+    9. 积分确认或释放
+    """
+    # ✅ 关键：通过模块引用访问全局变量，而非 from import（避免快照问题）
+    import evol.server.claude_proxy_async as _claude_mod
+    from ..presenter.agentIdPresenter import evol_agentId_online
+    from ..version import __version__, __cmp_version__
+
+    # 初始化变量
+    reserved_credits = 0
+    user_id = None
+    request_id = str(uuid.uuid4())
+    request_success = False
+    perf_start = time.time()
+    perf_timings = {}
+    proxy_logger = _claude_mod.get_proxy_logger()
+
+    # 检查 AsyncSessionManager 是否已初始化
+    if _claude_mod.async_session_manager is None:
+        raise HTTPException(status_code=503, detail="AsyncSessionManager 未初始化，请稍后重试")
+
+    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"{config.proxy_type.upper()} 代理请求开始 - {request.method} {request.url.path}")
+        proxy_logger.info(f"客户端IP: {client_ip}, 请求时间: {request_time}, 追踪ID: {request_id}")
+
+        # ========== 1. API Key 提取 ==========
+        # 兼容 x-api-key / Authorization: Bearer / x-goog-api-key (Gemini)
+        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
+
+        if not x_api_key:
+            x_api_key = request.headers.get("x-api-key")
+
+        if not x_api_key:
+            auth_header = request.headers.get("authorization", "")
+            if auth_header.startswith("Bearer "):
+                x_api_key = auth_header[7:]
+
+        if not x_api_key:
+            x_api_key = headers_dict.get("x-goog-api-key")
+
+        proxy_logger.info(f"API Key: {x_api_key[:20] if x_api_key else 'None'}... (已脱敏)")
+
+        # ========== 2. 积分余额检查 + 预扣除 ==========
+        try:
+            step_start = time.time()
+            user_info = await asyncio.to_thread(_claude_mod.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无效")
+
+            step_start = time.time()
+            required_credits = 20
+            reserve_result = await _claude_mod.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)
+
+                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="积分余额为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
+            proxy_logger.info(f"✅ 积分预扣除成功: {required_credits}")
+
+        except HTTPException:
+            raise
+        except Exception as e:
+            proxy_logger.error(f"❌ 积分余额检查异常: {str(e)}")
+            raise HTTPException(status_code=503, detail=f"积分余额检查服务异常，请稍后重试: {str(e)}")
+
+        # ========== 3. 读取请求体 + 解析 + 模型验证 ==========
+        step_start = time.time()
+        request_body = await request.body()
+        perf_timings['read_body'] = (time.time() - step_start) * 1000
+        proxy_logger.info(f"请求体大小: {len(request_body)} bytes")
+
+        step_start = time.time()
+        trace_id = str(uuid.uuid4())
+        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:
+            if model_name and "claude" not in model_name.lower():
+                raise HTTPException(status_code=400, detail=f"不支持该模型 {model_name}，请使用 Claude CLI 内置模型")
+        elif "/codex-proxy/" in request_path:
+            if model_name and "gpt" not in model_name.lower():
+                raise HTTPException(status_code=400, detail=f"不支持该模型 {model_name}，请使用 Codex CLI 内置模型")
+        elif "/gemini-proxy/" in request_path:
+            if model_name and "gemini" not in model_name.lower():
+                raise HTTPException(status_code=400, detail=f"不支持该模型 {model_name}，请使用 Gemini CLI 内置模型")
+        else:
+            # 其他代理类型使用 config 的模型验证器
+            if not config.model_validator(model_name):
+                raise HTTPException(status_code=400, detail=f"不支持该模型: {model_name}")
+
+        # 请求格式转换（Claude/Codex/Gemini 不转换，OpenClaw 转换 OpenAI→Claude）
+        converted_body = config.request_converter(bodyjson)
+
+        # ========== 4. 构建代理消息 ==========
+        proxy_message = {
+            "type": "claude_proxy",
+            "status": "success",
+            "timestamp": int(time.time() * 1000),
+            "trace_id": trace_id,
+            "content": {
+                "path": _strip_proxy_prefix(request_path),
+                "method": request.method,
+                "headers": headers_dict,
+                "body": converted_body,
+                "source": "evol",
+                "version": __version__,
+                "cmp_version": __cmp_version__
+            }
+        }
+
+        proxy_logger.info(f"代理消息构建完成，trace_id: {trace_id}")
+        proxy_logger.info(f"请求路径: {request_path}")
+
+        # ========== 5. 检查用户登录 ==========
+        if not _claude_mod.userPresenter.is_logged_in():
+            raise HTTPException(status_code=401, detail="用户未登录，请打开 Evol 登录")
+
+        # ========== 6. 检查 AgentID 是否在线 ==========
+        if _claude_mod.agentId is None or not _claude_mod.agentId.is_online_success:
+            proxy_logger.warning("AgentID 未连接，执行完全重建...")
+
+            time_since_last = time.time() - _claude_mod._last_full_agentcp_rebuild_time
+            if time_since_last < _claude_mod._full_agentcp_rebuild_cooldown:
+                remaining = (_claude_mod._full_agentcp_rebuild_cooldown - time_since_last) / 60
+                raise HTTPException(
+                    status_code=503,
+                    detail=f"连接异常，系统正在恢复中，请 {int(remaining)+1} 分钟后重试，或重启Evol"
+                )
+
+            rebuild_success = await asyncio.to_thread(_claude_mod._full_rebuild_agentcp_system)
+
+            if not rebuild_success:
+                raise HTTPException(status_code=503, detail="Service Unavailable: 连接恢复失败，请尝试重启Evol")
+
+            # 重建后重新检查
+            if _claude_mod.agentId is None or not _claude_mod.agentId.is_online_success:
+                raise HTTPException(status_code=503, detail="Service Unavailable: 连接恢复异常，请尝试重启Evol")
+
+            proxy_logger.info("AgentID 完全重建成功，继续处理请求")
+
+        # ========== 7. AgentID 在线，开始处理请求 ==========
+        if _claude_mod.agentId and _claude_mod.agentId.is_online_success:
+            proxy_logger.info("Agent在线，开始处理请求")
+
+            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 _claude_mod.async_session_manager.get_session(x_api_key, _claude_mod.agentId)
+                perf_timings['get_session'] = (time.time() - step_start) * 1000
+
+                if session_id:
+                    break
+                elif session_attempt < max_session_retries - 1:
+                    proxy_logger.warning("Session创建失败，尝试重新上线...")
+                    try:
+                        _claude_mod._clear_async_session_manager_cache()
+                        await asyncio.to_thread(_claude_mod.agentId.online)
+
+                        if _claude_mod.agentId.is_online_success:
+                            evol_agentId_online(_claude_mod.agentId)
+                            _claude_mod._register_disconnect_callback(_claude_mod.agentId, disable_auto_reconnect=True)
+                        else:
+                            proxy_logger.error("agentId.online() 后仍未上线")
+                            break
+                    except Exception as retry_error:
+                        proxy_logger.error(f"重新上线过程异常: {str(retry_error)}")
+                        break
+
+            if session_id:
+                proxy_logger.info(f"Session获取成功: {session_id}")
+
+                # 注册响应事件
+                response_event = asyncio.Event()
+                _claude_mod.async_session_manager._pending_requests[trace_id] = response_event
+                _claude_mod.async_session_manager.register_request_timestamp(trace_id)
+
+                try:
+                    # 发送消息
+                    claude_agent_name = await asyncio.to_thread(_claude_mod.configPresenter.get_claude_agent_name)
+                    proxy_logger.info(f"发送消息到Agent: {claude_agent_name}")
+
+                    step_start = time.time()
+                    await asyncio.to_thread(
+                        _claude_mod.agentId.send_message, session_id, [claude_agent_name], proxy_message
+                    )
+                    perf_timings['send_message'] = (time.time() - step_start) * 1000
+
+                    # 等待响应
+                    proxy_logger.info(f"等待响应, trace_id: {trace_id}")
+                    wait_start = time.time()
+
+                    try:
+                        await asyncio.wait_for(response_event.wait(), timeout=300)
+                        perf_timings['wait_response'] = (time.time() - wait_start) * 1000
+                        proxy_logger.info(f"收到响应，等待时间: {perf_timings['wait_response']:.2f}ms")
+                        _claude_mod._reset_no_response_count()
+                    except asyncio.TimeoutError:
+                        no_response_count = _claude_mod._increment_no_response_count()
+                        proxy_logger.warning(f"请求超时，连续无响应: {no_response_count}/{_claude_mod._consecutive_no_response_threshold}")
+
+                        if _claude_mod._should_trigger_rebuild():
+                            try:
+                                rebuild_result = await _claude_mod.force_rebuild_agentcp_system(bypass_cooldown=True)
+                                _claude_mod._reset_no_response_count()
+
+                                if rebuild_result["success"]:
+                                    if _claude_mod.agentId is None or not _claude_mod.agentId.is_online_success:
+                                        raise HTTPException(status_code=503, detail="连接重建后仍然离线，请稍后重试")
+
+                                    # 重试请求
+                                    retry_trace_id = f"retry_{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()
+                                    _claude_mod.async_session_manager._pending_requests[retry_trace_id] = retry_response_event
+                                    _claude_mod.async_session_manager.register_request_timestamp(retry_trace_id)
+
+                                    try:
+                                        claude_agent_name = await asyncio.to_thread(_claude_mod.configPresenter.get_claude_agent_name)
+                                        await asyncio.to_thread(
+                                            _claude_mod.agentId.send_message, session_id, [claude_agent_name], proxy_message
+                                        )
+
+                                        try:
+                                            await asyncio.wait_for(retry_response_event.wait(), timeout=300)
+                                        except asyncio.TimeoutError:
+                                            raise HTTPException(status_code=504, detail="自动重建并重试后仍然超时，请检查网络连接或联系技术支持")
+
+                                        retry_result_data = _claude_mod.async_session_manager._request_result_map.get(retry_trace_id)
+                                        if retry_result_data:
+                                            _claude_mod.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:
+                                            raise HTTPException(status_code=503, detail="自动重试后仍未收到响应数据，请稍后重试")
+                                    finally:
+                                        _claude_mod.async_session_manager._pending_requests.pop(retry_trace_id, None)
+                                        _claude_mod.async_session_manager._request_result_map.pop(retry_trace_id, None)
+                                        _claude_mod.async_session_manager.unregister_request_timestamp(retry_trace_id)
+                                else:
+                                    raise HTTPException(status_code=503, detail=f"连接自动重建失败: {rebuild_result['message']}，请尝试重启 Evol")
+
+                            except HTTPException:
+                                raise
+                            except Exception as rebuild_error:
+                                raise HTTPException(status_code=503, detail=f"连接自动重建异常: {str(rebuild_error)}，请尝试重启 Evol")
+                        else:
+                            raise HTTPException(
+                                status_code=504,
+                                detail=f"请求超时，请重试（连续超时 {no_response_count}/{_claude_mod._consecutive_no_response_threshold} 次）"
+                            )
+
+                    # ========== 8. 响应处理 ==========
+                    result_data = _claude_mod.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}")
+
+                    content = response_msg.get("content", {}) if isinstance(response_msg, dict) else response_msg
+
+                    # 8.1 处理错误响应 - 保留上游的 http_status 和 headers
+                    if result_type == "error":
+                        error_message = content if isinstance(content, str) else str(content)
+                        http_status = response_msg.get("http_status", 503) if isinstance(response_msg, dict) else 503
+                        resp_headers = response_msg.get("headers", {}) if isinstance(response_msg, dict) else {}
+                        proxy_logger.error(f"代理返回错误: {error_message}, trace_id: {trace_id}")
+                        return Response(
+                            content=error_message,
+                            status_code=http_status,
+                            headers=resp_headers,
+                            media_type=resp_headers.get('content-type', "application/json")
+                        )
+
+                    # 8.2 处理流式响应
+                    if result_type == "text/event-stream":
+                        stream_url = content if isinstance(content, str) else content.get("url", "")
+                        if stream_url:
+                            proxy_logger.info(f"开始流式响应: {stream_url}, trace_id: {trace_id}")
+                            request_success = True
+                            return await config.stream_handler(stream_url)
+                        else:
+                            proxy_logger.error(f"流式响应缺少URL, trace_id: {trace_id}")
+                            raise HTTPException(status_code=504, detail="Stream URL missing")
+
+                    # 8.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
+                        for header in ['Content-Encoding', 'Transfer-Encoding', 'Content-Length']:
+                            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
+
+                    # 响应格式转换（仅当 response_body 是 dict 时才交给 converter）
+                    if isinstance(response_body, dict):
+                        response_body = config.response_converter(response_body)
+
+                    # 确保 response_body 是可编码的类型
+                    if isinstance(response_body, dict):
+                        response_body = json.dumps(response_body, ensure_ascii=False)
+                    elif isinstance(response_body, (list, tuple)):
+                        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')
+
+                    # 性能统计
+                    total_time = (time.time() - perf_start) * 1000
+                    perf_timings['total'] = total_time
+
+                    proxy_logger.info("=" * 80)
+                    proxy_logger.info(f"代理请求处理完成 - 总耗时: {total_time:.2f}ms")
+                    for step_name, duration in perf_timings.items():
+                        if step_name != 'total' and isinstance(duration, (int, float)):
+                            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)
+
+                    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"代理请求超时: {trace_id}")
+                    raise HTTPException(status_code=504, detail="Gateway Timeout")
+                except HTTPException:
+                    raise
+                except Exception as e:
+                    error_details = {
+                        "error_type": type(e).__name__,
+                        "error_message": str(e),
+                        "trace_id": trace_id,
+                    }
+                    full_traceback = traceback.format_exc()
+                    proxy_logger.error(f"等待代理响应失败: {str(e)}")
+                    proxy_logger.error(f"错误详情: {error_details}")
+                    proxy_logger.error(f"完整堆栈跟踪:\n{full_traceback}")
+                    raise HTTPException(status_code=500, detail=f"Proxy Error: {str(e)}")
+                finally:
+                    # ✅ 延迟清理 trace_id，避免竞态条件
+                    try:
+                        await asyncio.sleep(0.1)
+                    except asyncio.CancelledError:
+                        pass
+                    _claude_mod.async_session_manager._pending_requests.pop(trace_id, None)
+                    _claude_mod.async_session_manager._request_result_map.pop(trace_id, None)
+                    _claude_mod.async_session_manager.unregister_request_timestamp(trace_id)
+
+            else:
+                # 循环重试后仍然失败
+                proxy_logger.error("获取或创建代理会话失败（已重试）")
+                raise HTTPException(status_code=503, detail="Service Unavailable: Cannot get or create session")
+        else:
+            proxy_logger.error("AgentID 未连接（兜底）")
+            raise HTTPException(status_code=503, detail="Service Unavailable: 连接失败，请尝试重新启动 Evol")
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        full_traceback = traceback.format_exc()
+        proxy_logger.error(f"代理请求处理失败: {str(e)}")
+        proxy_logger.error(f"异常堆栈:\n{full_traceback}")
+        raise HTTPException(status_code=500, detail=f"Proxy Error: {str(e)}")
+    finally:
+        # ========== 9. 积分预扣除的释放或确认 ==========
+        if reserved_credits > 0 and user_id:
+            try:
+                if request_success:
+                    await _claude_mod.credits_lock_manager.confirm_credits_usage(
+                        user_id=user_id,
+                        amount=reserved_credits,
+                        request_id=request_id
+                    )
+                    proxy_logger.info(f"✅ 积分使用已确认: {reserved_credits}")
+                else:
+                    await _claude_mod.credits_lock_manager.release_reserved_credits(
+                        user_id=user_id,
+                        amount=reserved_credits,
+                        request_id=request_id
+                    )
+                    proxy_logger.info(f"🔄 积分预扣除已释放: {reserved_credits}")
+            except Exception as e:
+                proxy_logger.error(f"❌ 积分处理失败: {str(e)}")

package/extensions/services/proxy/evol/version.py

@@ -0,0 +1,24 @@
+# 应用版本配置
+__version__ = "0.0.30"  # 与package.json保持一致
+__code__ = 135
+__cmp_version__ = "2.0.43"
+APP_NAME = "Evol"
+
+def get_version():
+    """获取当前版本"""
+    return __version__
+
+def get_version_info():
+    """获取详细版本信息"""
+    import sys
+    import platform
+
+    return {
+        "version": __version__,
+        "cmp_version": __cmp_version__,
+        "code": __code__,
+        "app_name": APP_NAME,
+        "python_version": sys.version,
+        "platform": platform.platform(),
+        "architecture": platform.machine()
+    }