@agentunion/kite 1.4.0 → 1.6.0

package/extensions/services/evol/evol_api.py

@@ -0,0 +1,969 @@
+"""
+Evol API 调用封装
+"""
+
+import asyncio
+import json
+import httpx
+from typing import Optional
+
+
+class EvolAPI:
+    """Evol API 客户端"""
+
+    def __init__(self, base_url: str = "https://api.evolai.cn:8550"):
+        self.base_url = base_url
+        self.timeout = 30.0
+
+    def _log_request(self, method: str, url: str, **kwargs):
+        """记录请求日志"""
+        log_data = {
+            "method": method,
+            "url": url,
+        }
+        if "json" in kwargs:
+            # 隐藏敏感信息
+            data = kwargs["json"].copy()
+            if "code" in data:
+                data["code"] = "***"
+            log_data["body"] = data
+        if "headers" in kwargs:
+            headers = kwargs["headers"].copy()
+            if "Authorization" in headers:
+                headers["Authorization"] = "Bearer ***"
+            log_data["headers"] = headers
+
+        print(f"[evol-api] → {method} {url}")
+        print(f"[evol-api]   Request: {json.dumps(log_data, ensure_ascii=False)}")
+
+    def _log_response(self, url: str, status_code: int, response_data: dict):
+        """记录响应日志"""
+        if isinstance(response_data, dict):
+            msg = response_data.get("msg", "")
+
+            # 如果是用户信息接口，提取关键字段
+            if "userInfo" in url or "data" in response_data:
+                data = response_data.get("data", {})
+                if not isinstance(data, dict):
+                    # data 是 list 或其他非 dict 类型（如 apikey/list 返回的数组）
+                    print(f"[evol-api] {msg} (data items: {len(data) if isinstance(data, list) else type(data).__name__})")
+                    return
+                user_info = data.get("userInfo", {})
+                gateway_info = data.get("gatewayInfo", {})
+
+                if user_info or gateway_info:
+                    nick_name = user_info.get("nickName", "")
+                    api_url = gateway_info.get("modelBaseUrl", "")
+                    api_key_enabled = "已启用" if gateway_info.get("apiKeyEnabled") else "未启用"
+                    print(f"[evol-api] {msg} - {nick_name} 登录成功，网关: {api_url}，API Key: {api_key_enabled}")
+                    return
+
+            # 其他接口只显示 msg
+            print(f"[evol-api] {msg}")
+
+    def _log_error(self, url: str, error: Exception):
+        """记录错误日志"""
+        print(f"[evol-api] ✗ Error {url}: {type(error).__name__}: {str(error)}")
+
+    async def send_sms(self, phone: str) -> dict:
+        """发送短信验证码"""
+        url = f"{self.base_url}/api/auth/sms/send"
+        data = {
+            "phone": phone,
+            "codeType": "LOGIN"
+        }
+
+        self._log_request("POST", url, json=data)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.post(url, json=data)
+                result = response.json()
+
+                self._log_response(url, response.status_code, result)
+
+                if result.get("code") == 200:
+                    return {"success": True, "msg": result.get("msg", "验证码发送成功")}
+                else:
+                    return {"success": False, "msg": result.get("msg", "发送失败")}
+
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    async def verify_sms(self, phone: str, code: str) -> dict:
+        """验证短信并登录"""
+        url = f"{self.base_url}/api/auth/sms/login"
+        data = {
+            "phone": phone,
+            "code": code,
+            "source": "WEB"
+        }
+
+        self._log_request("POST", url, json=data)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.post(url, json=data)
+                result = response.json()
+
+                self._log_response(url, response.status_code, result)
+
+                if result.get("code") == 200:
+                    return {
+                        "success": True,
+                        "data": result.get("data", {})
+                    }
+                else:
+                    return {"success": False, "msg": result.get("msg", "验证失败")}
+
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    async def get_user_info(self, token: str) -> dict:
+        """获取用户信息（带指数退避重试）"""
+        url = f"{self.base_url}/api/auth/sms/userInfo"
+        headers = {
+            "Authorization": f"Bearer {token}"
+        }
+
+        max_retries = 6
+        base_delay = 0.5  # 第一次重试间隔 0.5 秒
+
+        for attempt in range(max_retries):
+            self._log_request("GET", url, headers=headers)
+
+            try:
+                async with httpx.AsyncClient(timeout=self.timeout) as client:
+                    response = await client.get(url, headers=headers)
+                    result = response.json()
+
+                    self._log_response(url, response.status_code, result)
+
+                    if result.get("code") == 200:
+                        data = result.get("data", {})
+                        # API Key 在 gatewayInfo 中
+                        gateway_info = data.get("gatewayInfo", {})
+                        api_key = gateway_info.get("apiKey", "")
+
+                        if api_key:
+                            # 有 API Key，直接返回
+                            return {
+                                "success": True,
+                                "data": data
+                            }
+                        else:
+                            # 没有 API Key，重试几次后也返回（不阻塞登录）
+                            if attempt < 3:  # 只重试 3 次
+                                delay = base_delay * (2 ** attempt)
+                                print(f"[evol-api] API Key not ready, retry {attempt + 1}/3 after {delay}s")
+                                await asyncio.sleep(delay)
+                                continue
+                            else:
+                                # 3 次后放弃等待，返回没有 API Key 的数据
+                                print(f"[evol-api] API Key not available after 3 retries, proceeding without it")
+                                return {
+                                    "success": True,
+                                    "data": data
+                                }
+                    else:
+                        return {"success": False, "msg": result.get("msg", "获取失败")}
+
+            except Exception as e:
+                self._log_error(url, e)
+                if attempt < max_retries - 1:
+                    delay = base_delay * (2 ** attempt)
+                    print(f"[evol-api] Network error, retry {attempt + 1}/{max_retries} after {delay}s: {e}")
+                    await asyncio.sleep(delay)
+                    continue
+                else:
+                    return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+        return {"success": False, "msg": "获取用户信息失败，已达最大重试次数"}
+
+    async def switch_team(self, token: str, team_id: Optional[int] = None) -> dict:
+        """切换团队"""
+        url = f"{self.base_url}/api/team/switch"
+        headers = {
+            "Authorization": f"Bearer {token}"
+        }
+        data = {
+            "teamId": team_id
+        }
+
+        self._log_request("POST", url, headers=headers, json=data)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.post(url, headers=headers, json=data)
+                result = response.json()
+
+                self._log_response(url, response.status_code, result)
+
+                if result.get("code") == 200:
+                    return {
+                        "status": "success",
+                        "data": result
+                    }
+                else:
+                    return {
+                        "status": "error",
+                        "error": result.get("msg", "切换团队失败")
+                    }
+
+        except Exception as e:
+            self._log_error(url, e)
+            return {
+                "status": "error",
+                "error": f"网络错误: {str(e)}"
+            }
+
+    # ==================== 积分模块 ====================
+
+    async def get_credits_balance(self, token: str, aid: Optional[str] = None) -> dict:
+        """获取积分余额"""
+        url = f"{self.base_url}/api/account/credits/balance"
+        if aid:
+            url += f"?aid={aid}"
+        headers = {"Authorization": f"Bearer {token}"}
+
+        self._log_request("GET", url, headers=headers)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.get(url, headers=headers)
+                result = response.json()
+                self._log_response(url, response.status_code, result)
+                return {"success": result.get("code") == 200, "data": result.get("data"), "msg": result.get("msg")}
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    async def get_credits_reset_info(self, token: str) -> dict:
+        """获取积分重置信息"""
+        url = f"{self.base_url}/api/account/credits/reset/info"
+        headers = {"Authorization": f"Bearer {token}"}
+
+        self._log_request("GET", url, headers=headers)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.get(url, headers=headers)
+                result = response.json()
+                self._log_response(url, response.status_code, result)
+                return {"success": result.get("code") == 200, "data": result.get("data"), "msg": result.get("msg")}
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    async def reset_credits(self, token: str) -> dict:
+        """手动重置积分"""
+        url = f"{self.base_url}/api/account/credits/reset"
+        headers = {"Authorization": f"Bearer {token}"}
+
+        self._log_request("POST", url, headers=headers)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.post(url, headers=headers)
+                result = response.json()
+                self._log_response(url, response.status_code, result)
+                return {"success": result.get("code") == 200, "data": result.get("data"), "msg": result.get("msg")}
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    async def get_credits_usage_stats(self, token: str, hours: int = 24) -> dict:
+        """获取积分使用统计"""
+        url = f"{self.base_url}/api/credits/stats/usage?hours={hours}"
+        headers = {"Authorization": f"Bearer {token}"}
+
+        self._log_request("GET", url, headers=headers)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.get(url, headers=headers)
+                result = response.json()
+                self._log_response(url, response.status_code, result)
+                return {"success": result.get("code") == 200, "data": result.get("data"), "msg": result.get("msg")}
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    async def get_credits_change_records(self, token: str, page: int = 1, page_size: int = 20,
+                                        change_type: Optional[int] = None) -> dict:
+        """获取积分变动记录"""
+        url = f"{self.base_url}/api/credits/change/records?pageNum={page}&pageSize={page_size}"
+        if change_type is not None:
+            url += f"&changeType={change_type}"
+        headers = {"Authorization": f"Bearer {token}"}
+
+        self._log_request("GET", url, headers=headers)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.get(url, headers=headers)
+                result = response.json()
+                self._log_response(url, response.status_code, result)
+                return {"success": result.get("code") == 200, "data": result.get("data"), "msg": result.get("msg")}
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    async def get_credits_package_list(self, token: str) -> dict:
+        """获取积分包列表"""
+        url = f"{self.base_url}/api/credits-package/list"
+        headers = {"Authorization": f"Bearer {token}"}
+
+        self._log_request("GET", url, headers=headers)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.get(url, headers=headers)
+                result = response.json()
+                self._log_response(url, response.status_code, result)
+                return {"success": result.get("code") == 200, "data": result.get("data"), "msg": result.get("msg")}
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    # ==================== 个人积分趋势 ====================
+
+    async def get_user_hourly_trend(self, token: str, date: str) -> dict:
+        """获取个人24小时消耗趋势"""
+        url = f"{self.base_url}/api/stats/user/hourly-trend?date={date}"
+        headers = {"Authorization": f"Bearer {token}"}
+
+        self._log_request("GET", url, headers=headers)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.get(url, headers=headers)
+                result = response.json()
+                self._log_response(url, response.status_code, result)
+                return {"success": result.get("code") == 200, "data": result.get("data"), "msg": result.get("msg")}
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    async def get_user_daily_trend(self, token: str, start_date: str, end_date: str) -> dict:
+        """获取个人日消耗趋势"""
+        url = f"{self.base_url}/api/stats/user/daily-trend?startDate={start_date}&endDate={end_date}"
+        headers = {"Authorization": f"Bearer {token}"}
+
+        self._log_request("GET", url, headers=headers)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.get(url, headers=headers)
+                result = response.json()
+                self._log_response(url, response.status_code, result)
+                return {"success": result.get("code") == 200, "data": result.get("data"), "msg": result.get("msg")}
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    async def get_user_summary(self, token: str, start_date: str, end_date: str) -> dict:
+        """获取个人时间段汇总"""
+        url = f"{self.base_url}/api/stats/user/summary?startDate={start_date}&endDate={end_date}"
+        headers = {"Authorization": f"Bearer {token}"}
+
+        self._log_request("GET", url, headers=headers)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.get(url, headers=headers)
+                result = response.json()
+                self._log_response(url, response.status_code, result)
+                return {"success": result.get("code") == 200, "data": result.get("data"), "msg": result.get("msg")}
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    async def get_credits_list(self, token: str, page_num: int = 1, page_size: int = 20,
+                               start_time: Optional[str] = None, end_time: Optional[str] = None) -> dict:
+        """获取积分变动列表（分页，支持时间范围）"""
+        url = f"{self.base_url}/api/credits/list?pageNum={page_num}&pageSize={page_size}"
+        if start_time:
+            url += f"&startTime={start_time}"
+        if end_time:
+            url += f"&endTime={end_time}"
+        headers = {"Authorization": f"Bearer {token}"}
+
+        self._log_request("GET", url, headers=headers)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.get(url, headers=headers)
+                result = response.json()
+                self._log_response(url, response.status_code, result)
+                return {"success": result.get("code") == 200, "data": result.get("data"), "msg": result.get("msg")}
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    # ==================== VIP 订阅模块 ====================
+
+    async def get_vip_packages(self, token: str) -> dict:
+        """获取 VIP 套餐列表"""
+        url = f"{self.base_url}/api/vip/packages"
+        headers = {"Authorization": f"Bearer {token}"}
+
+        self._log_request("GET", url, headers=headers)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.get(url, headers=headers)
+                result = response.json()
+                self._log_response(url, response.status_code, result)
+                return {"success": result.get("code") == 200, "data": result.get("data"), "msg": result.get("msg")}
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    async def create_vip_order(self, token: str, package_id: int, payment_method: str = "alipay") -> dict:
+        """创建 VIP 订单"""
+        url = f"{self.base_url}/api/vip/order/create"
+        headers = {"Authorization": f"Bearer {token}"}
+        data = {"packageId": package_id, "paymentMethod": payment_method}
+
+        self._log_request("POST", url, headers=headers, json=data)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.post(url, headers=headers, json=data)
+                result = response.json()
+                self._log_response(url, response.status_code, result)
+                return {"success": result.get("code") == 200, "data": result.get("data"), "msg": result.get("msg")}
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    async def get_order_list(self, token: str, page: int = 1, page_size: int = 20,
+                            order_type: Optional[int] = None) -> dict:
+        """获取订单列表"""
+        url = f"{self.base_url}/api/payment/order/list?pageNum={page}&pageSize={page_size}"
+        if order_type is not None:
+            url += f"&orderType={order_type}"
+        headers = {"Authorization": f"Bearer {token}"}
+
+        self._log_request("GET", url, headers=headers)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.get(url, headers=headers)
+                result = response.json()
+                self._log_response(url, response.status_code, result)
+                return {"success": result.get("code") == 200, "data": result.get("data"), "msg": result.get("msg")}
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    async def cancel_order(self, token: str, order_id: str) -> dict:
+        """取消订单"""
+        url = f"{self.base_url}/api/payment/order/cancel"
+        headers = {"Authorization": f"Bearer {token}"}
+        data = {"orderId": order_id}
+
+        self._log_request("POST", url, headers=headers, json=data)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.post(url, headers=headers, json=data)
+                result = response.json()
+                self._log_response(url, response.status_code, result)
+                return {"success": result.get("code") == 200, "data": result.get("data"), "msg": result.get("msg")}
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    # ==================== 发票模块 ====================
+
+    async def get_invoice_list(self, token: str, page: int = 1, page_size: int = 20) -> dict:
+        """获取发票列表"""
+        url = f"{self.base_url}/api/invoice/list?pageNum={page}&pageSize={page_size}"
+        headers = {"Authorization": f"Bearer {token}"}
+
+        self._log_request("GET", url, headers=headers)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.get(url, headers=headers)
+                result = response.json()
+                self._log_response(url, response.status_code, result)
+                return {"success": result.get("code") == 200, "data": result.get("data"), "msg": result.get("msg")}
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    async def apply_invoice(self, token: str, order_id: str, invoice_type: int,
+                           title_type: int, title: str, tax_number: str = "",
+                           email: str = "") -> dict:
+        """申请发票"""
+        url = f"{self.base_url}/api/invoice/apply"
+        headers = {"Authorization": f"Bearer {token}"}
+        data = {
+            "orderId": order_id,
+            "invoiceType": invoice_type,
+            "titleType": title_type,
+            "title": title,
+            "taxNumber": tax_number,
+            "email": email
+        }
+
+        self._log_request("POST", url, headers=headers, json=data)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.post(url, headers=headers, json=data)
+                result = response.json()
+                self._log_response(url, response.status_code, result)
+                return {"success": result.get("code") == 200, "data": result.get("data"), "msg": result.get("msg")}
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    # ==================== API Key 模块 ====================
+
+    async def get_apikey_list(self, token: str) -> dict:
+        """获取 API Key 列表"""
+        url = f"{self.base_url}/api/apikey/list"
+        headers = {"Authorization": f"Bearer {token}"}
+
+        self._log_request("GET", url, headers=headers)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.get(url, headers=headers)
+                result = response.json()
+                self._log_response(url, response.status_code, result)
+                # 后端可能返回 list 或 {code, data, msg} 格式
+                if isinstance(result, list):
+                    return {"success": True, "data": result}
+                return {"success": result.get("code") == 200, "data": result.get("data"), "msg": result.get("msg")}
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    async def create_apikey(self, token: str, name: str, remark: str = "") -> dict:
+        """创建 API Key"""
+        url = f"{self.base_url}/api/apikey/create"
+        headers = {"Authorization": f"Bearer {token}"}
+        data = {"name": name, "remark": remark}
+
+        self._log_request("POST", url, headers=headers, json=data)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.post(url, headers=headers, json=data)
+                result = response.json()
+                self._log_response(url, response.status_code, result)
+                return {"success": result.get("code") == 200, "data": result.get("data"), "msg": result.get("msg")}
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    async def update_apikey(self, token: str, key_id: int, name: str = "",
+                           remark: str = "", status: Optional[int] = None) -> dict:
+        """更新 API Key"""
+        url = f"{self.base_url}/api/apikey/update"
+        headers = {"Authorization": f"Bearer {token}"}
+        data = {"id": key_id}
+        if name:
+            data["name"] = name
+        if remark:
+            data["remark"] = remark
+        if status is not None:
+            data["status"] = status
+
+        self._log_request("PUT", url, headers=headers, json=data)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.put(url, headers=headers, json=data)
+                result = response.json()
+                self._log_response(url, response.status_code, result)
+                return {"success": result.get("code") == 200, "data": result.get("data"), "msg": result.get("msg")}
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    async def delete_apikey(self, token: str, key_id: int) -> dict:
+        """删除 API Key"""
+        url = f"{self.base_url}/api/apikey/delete/{key_id}"
+        headers = {"Authorization": f"Bearer {token}"}
+
+        self._log_request("DELETE", url, headers=headers)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.delete(url, headers=headers)
+                result = response.json()
+                self._log_response(url, response.status_code, result)
+                return {"success": result.get("code") == 200, "data": result.get("data"), "msg": result.get("msg")}
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    async def get_apikey_usage(self, token: str, key_id: int, start_date: str, end_date: str) -> dict:
+        """获取 API Key 使用统计"""
+        url = f"{self.base_url}/api/apikey/usage/{key_id}?startDate={start_date}&endDate={end_date}"
+        headers = {"Authorization": f"Bearer {token}"}
+
+        self._log_request("GET", url, headers=headers)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.get(url, headers=headers)
+                result = response.json()
+                self._log_response(url, response.status_code, result)
+                return {"success": result.get("code") == 200, "data": result.get("data"), "msg": result.get("msg")}
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    # ==================== 团队模块 ====================
+
+    async def get_team_list(self, token: str) -> dict:
+        """获取团队列表"""
+        url = f"{self.base_url}/api/team/list"
+        headers = {"Authorization": f"Bearer {token}"}
+
+        self._log_request("GET", url, headers=headers)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.get(url, headers=headers)
+                result = response.json()
+                self._log_response(url, response.status_code, result)
+                return {"success": result.get("code") == 200, "data": result.get("data"), "msg": result.get("msg")}
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    async def get_team_members(self, token: str, team_id: int, page: int = 1, page_size: int = 20) -> dict:
+        """获取团队成员列表"""
+        url = f"{self.base_url}/api/team/{team_id}/members?pageNum={page}&pageSize={page_size}"
+        headers = {"Authorization": f"Bearer {token}"}
+
+        self._log_request("GET", url, headers=headers)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.get(url, headers=headers)
+                result = response.json()
+                self._log_response(url, response.status_code, result)
+                # Java 分页接口返回 { code, rows, total } 而非 { code, data }
+                data = result.get("data")
+                if data is None and "rows" in result:
+                    data = {"list": result.get("rows", []), "total": result.get("total", 0)}
+                return {"success": result.get("code") == 200, "data": data, "msg": result.get("msg")}
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    # ---- 团队管理通用请求辅助 ----
+
+    async def _team_request(self, method: str, path: str, token: str, **kwargs) -> dict:
+        """团队模块通用请求封装"""
+        url = f"{self.base_url}{path}"
+        headers = {"Authorization": f"Bearer {token}"}
+        self._log_request(method, url, headers=headers, **kwargs)
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                resp = await getattr(client, method.lower())(url, headers=headers, **kwargs)
+                result = resp.json()
+                self._log_response(url, resp.status_code, result)
+                return {"success": result.get("code") == 200, "data": result.get("data"), "msg": result.get("msg")}
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    # ---- 团队基础 ----
+
+    async def create_team(self, token: str, name: str) -> dict:
+        return await self._team_request("POST", "/api/team/create", token, json={"name": name})
+
+    async def get_team_detail(self, token: str, team_id: int) -> dict:
+        return await self._team_request("GET", f"/api/team/{team_id}", token)
+
+    async def delete_team(self, token: str, team_id: int) -> dict:
+        return await self._team_request("DELETE", f"/api/team/{team_id}", token)
+
+    async def quit_team(self, token: str, team_id: int) -> dict:
+        return await self._team_request("POST", f"/api/team/{team_id}/quit", token)
+
+    async def get_team_account(self, token: str, team_id: int) -> dict:
+        return await self._team_request("GET", f"/api/team/{team_id}/account", token)
+
+    async def search_user(self, token: str, phonenumber: str, team_id: int) -> dict:
+        return await self._team_request("GET", f"/api/team/searchUser?phonenumber={phonenumber}&teamId={team_id}", token)
+
+    # ---- 成员管理 ----
+
+    async def add_team_member(self, token: str, team_id: int, data: dict) -> dict:
+        return await self._team_request("POST", f"/api/team/{team_id}/member/add", token, json=data)
+
+    async def batch_add_members(self, token: str, team_id: int, data: dict) -> dict:
+        return await self._team_request("POST", f"/api/team/{team_id}/member/batchAdd", token, json=data)
+
+    async def update_member(self, token: str, team_id: int, member_id: int, data: dict) -> dict:
+        return await self._team_request("PUT", f"/api/team/{team_id}/member/{member_id}", token, json=data)
+
+    async def remove_member(self, token: str, team_id: int, member_id: int) -> dict:
+        return await self._team_request("DELETE", f"/api/team/{team_id}/member/{member_id}", token)
+
+    async def set_member_as_admin(self, token: str, team_id: int, member_id: int) -> dict:
+        return await self._team_request("POST", f"/api/team/{team_id}/member/{member_id}/setAdmin", token)
+
+    async def remove_member_admin(self, token: str, team_id: int, member_id: int) -> dict:
+        return await self._team_request("POST", f"/api/team/{team_id}/member/{member_id}/removeAdmin", token)
+
+    async def set_member_credits_limit(self, token: str, team_id: int, member_id: int, data: dict) -> dict:
+        return await self._team_request("PUT", f"/api/team/{team_id}/member/{member_id}/creditsLimit", token, json=data)
+
+    async def batch_set_credits_limit(self, token: str, team_id: int, data: dict) -> dict:
+        return await self._team_request("PUT", f"/api/team/{team_id}/members/creditsLimit", token, json=data)
+
+    async def get_member_quota_info(self, token: str, team_id: int, member_id: int) -> dict:
+        return await self._team_request("GET", f"/api/team/{team_id}/member/{member_id}/quotaInfo", token)
+
+    async def reset_member_quota(self, token: str, team_id: int, member_id: int) -> dict:
+        return await self._team_request("POST", f"/api/team/{team_id}/member/{member_id}/resetQuota", token)
+
+    async def convert_member_credits(self, token: str, team_id: int, data: dict) -> dict:
+        return await self._team_request("POST", f"/api/team/{team_id}/member/convertCredits", token, json=data)
+
+    # ---- 团队设置 ----
+
+    async def update_share_creator_credits(self, token: str, team_id: int, data: dict) -> dict:
+        return await self._team_request("PUT", f"/api/team/{team_id}/shareCreatorCredits", token, json=data)
+
+    async def update_analyze_member_data(self, token: str, team_id: int, data: dict) -> dict:
+        return await self._team_request("PUT", f"/api/team/{team_id}/analyzeTeamMemberData", token, json=data)
+
+    # ---- 积分统计 ----
+
+    async def get_team_credits_stats(self, token: str, team_id: int, **params) -> dict:
+        qs = "&".join(f"{k}={v}" for k, v in params.items() if v is not None)
+        path = f"/api/stats/team/{team_id}/credits" + (f"?{qs}" if qs else "")
+        return await self._team_request("GET", path, token)
+
+    async def get_team_members_ranking(self, token: str, team_id: int, **params) -> dict:
+        qs = "&".join(f"{k}={v}" for k, v in params.items() if v is not None)
+        path = f"/api/stats/team/{team_id}/members/ranking" + (f"?{qs}" if qs else "")
+        return await self._team_request("GET", path, token)
+
+    async def get_team_trend(self, token: str, team_id: int, **params) -> dict:
+        qs = "&".join(f"{k}={v}" for k, v in params.items() if v is not None)
+        path = f"/api/stats/team/{team_id}/trend" + (f"?{qs}" if qs else "")
+        return await self._team_request("GET", path, token)
+
+    async def get_today_team_stats(self, token: str, team_id: int) -> dict:
+        return await self._team_request("GET", f"/api/stats/team/{team_id}/today", token)
+
+    async def get_today_members_stats(self, token: str, team_id: int) -> dict:
+        return await self._team_request("GET", f"/api/stats/team/{team_id}/members/today", token)
+
+    async def get_team_hourly_stats(self, token: str, team_id: int, **params) -> dict:
+        qs = "&".join(f"{k}={v}" for k, v in params.items() if v is not None)
+        path = f"/api/stats/team/{team_id}/hourly" + (f"?{qs}" if qs else "")
+        return await self._team_request("GET", path, token)
+
+    async def get_team_weekly_stats(self, token: str, team_id: int, **params) -> dict:
+        qs = "&".join(f"{k}={v}" for k, v in params.items() if v is not None)
+        path = f"/api/stats/team/{team_id}/weekly" + (f"?{qs}" if qs else "")
+        return await self._team_request("GET", path, token)
+
+    async def get_team_monthly_stats(self, token: str, team_id: int, **params) -> dict:
+        qs = "&".join(f"{k}={v}" for k, v in params.items() if v is not None)
+        path = f"/api/stats/team/{team_id}/monthly" + (f"?{qs}" if qs else "")
+        return await self._team_request("GET", path, token)
+
+    async def get_team_credits_logs(self, token: str, team_id: int, **params) -> dict:
+        qs = "&".join(f"{k}={v}" for k, v in params.items() if v is not None)
+        path = f"/api/stats/team/{team_id}/logs" + (f"?{qs}" if qs else "")
+        return await self._team_request("GET", path, token)
+
+    async def get_user_today_models(self, token: str, team_id: int, user_id: int) -> dict:
+        return await self._team_request("GET", f"/api/stats/team/{team_id}/user/{user_id}/models/today", token)
+
+    async def statistics_history_30days(self, token: str, team_id: int, data: dict = None) -> dict:
+        return await self._team_request("POST", f"/api/stats/team/{team_id}/history30days", token, json=data or {})
+
+    # ---- 分组统计 ----
+
+    async def get_today_group_stats(self, token: str, team_id: int) -> dict:
+        return await self._team_request("GET", f"/api/stats/team/{team_id}/groups/today", token)
+
+    async def get_history_group_stats(self, token: str, team_id: int, **params) -> dict:
+        qs = "&".join(f"{k}={v}" for k, v in params.items() if v is not None)
+        path = f"/api/stats/team/{team_id}/groups/history" + (f"?{qs}" if qs else "")
+        return await self._team_request("GET", path, token)
+
+    # ---- 模型管理 ----
+
+    async def update_team_models(self, token: str, team_id: int, data: dict) -> dict:
+        return await self._team_request("POST", f"/api/team/{team_id}/models", token, json=data)
+
+    async def get_member_model_settings(self, token: str, team_id: int, member_id: int) -> dict:
+        return await self._team_request("GET", f"/api/team/{team_id}/member/{member_id}/models", token)
+
+    async def set_member_model_settings(self, token: str, team_id: int, member_id: int, data: dict) -> dict:
+        return await self._team_request("POST", f"/api/team/{team_id}/member/{member_id}/models", token, json=data)
+
+    # ---- 分组管理 ----
+
+    async def create_group(self, token: str, team_id: int, data: dict) -> dict:
+        return await self._team_request("POST", f"/api/team/{team_id}/group/create", token, json=data)
+
+    async def get_group_tree(self, token: str, team_id: int) -> dict:
+        return await self._team_request("GET", f"/api/team/{team_id}/group/tree", token)
+
+    async def get_group_detail(self, token: str, team_id: int, group_id: int) -> dict:
+        return await self._team_request("GET", f"/api/team/{team_id}/group/{group_id}", token)
+
+    async def update_group(self, token: str, team_id: int, group_id: int, data: dict) -> dict:
+        return await self._team_request("PUT", f"/api/team/{team_id}/group/{group_id}", token, json=data)
+
+    async def delete_group(self, token: str, team_id: int, group_id: int) -> dict:
+        return await self._team_request("DELETE", f"/api/team/{team_id}/group/{group_id}", token)
+
+    async def move_group(self, token: str, team_id: int, group_id: int, data: dict) -> dict:
+        return await self._team_request("PUT", f"/api/team/{team_id}/group/{group_id}/move", token, json=data)
+
+    async def add_members_to_group(self, token: str, team_id: int, group_id: int, data: dict) -> dict:
+        return await self._team_request("POST", f"/api/team/{team_id}/group/{group_id}/member/add", token, json=data)
+
+    async def remove_members_from_group(self, token: str, team_id: int, group_id: int, data: dict) -> dict:
+        return await self._team_request("POST", f"/api/team/{team_id}/group/{group_id}/member/remove", token, json=data)
+
+    async def get_group_members(self, token: str, team_id: int, group_id: int, **params) -> dict:
+        qs = "&".join(f"{k}={v}" for k, v in params.items() if v is not None)
+        path = f"/api/team/{team_id}/group/{group_id}/members" + (f"?{qs}" if qs else "")
+        return await self._team_request("GET", path, token)
+
+    async def get_ungrouped_members(self, token: str, team_id: int, **params) -> dict:
+        qs = "&".join(f"{k}={v}" for k, v in params.items() if v is not None)
+        path = f"/api/team/{team_id}/group/ungrouped/members" + (f"?{qs}" if qs else "")
+        return await self._team_request("GET", path, token)
+
+    async def get_my_group_scope(self, token: str, team_id: int) -> dict:
+        return await self._team_request("GET", f"/api/team/{team_id}/group/my-scope", token)
+
+    # ---- 分组管理员 ----
+
+    async def set_group_admin(self, token: str, team_id: int, group_id: int, data: dict) -> dict:
+        return await self._team_request("POST", f"/api/team/{team_id}/group/{group_id}/admin/set", token, json=data)
+
+    async def remove_group_admin(self, token: str, team_id: int, group_id: int, data: dict) -> dict:
+        return await self._team_request("POST", f"/api/team/{team_id}/group/{group_id}/admin/remove", token, json=data)
+
+    async def get_group_admins(self, token: str, team_id: int, group_id: int) -> dict:
+        return await self._team_request("GET", f"/api/team/{team_id}/group/{group_id}/admins", token)
+
+    # ---- 账单 ----
+
+    async def get_team_bill_range(self, token: str, team_id: int, **params) -> dict:
+        qs = "&".join(f"{k}={v}" for k, v in params.items() if v is not None)
+        path = f"/api/team/{team_id}/bill/range" + (f"?{qs}" if qs else "")
+        return await self._team_request("GET", path, token)
+
+    # ---- 洞察报告 ----
+
+    async def get_insight_reports(self, token: str, team_id: int, **params) -> dict:
+        qs = "&".join(f"{k}={v}" for k, v in params.items() if v is not None)
+        path = f"/api/team/{team_id}/insightReports/byDate" + (f"?{qs}" if qs else "")
+        return await self._team_request("GET", path, token)
+
+    async def get_insight_report_detail(self, token: str, team_id: int, report_id: int) -> dict:
+        return await self._team_request("GET", f"/api/team/{team_id}/insightReports/{report_id}", token)
+
+    async def update_insight_config(self, token: str, team_id: int, data: dict) -> dict:
+        return await self._team_request("PUT", f"/api/team/{team_id}/insightConfig", token, json=data)
+
+    async def generate_member_insight_report(self, token: str, team_id: int, user_id: int, date: str = None) -> dict:
+        path = f"/api/team/{team_id}/insightReports/generate/member/{user_id}"
+        if date:
+            path += f"?date={date}"
+        return await self._team_request("POST", path, token)
+
+    # ---- 预警 ----
+
+    async def get_alert_config(self, token: str, team_id: int) -> dict:
+        return await self._team_request("GET", f"/api/team/alert/config/{team_id}", token)
+
+    async def update_alert_config(self, token: str, team_id: int, data: dict) -> dict:
+        return await self._team_request("POST", f"/api/team/alert/config/{team_id}", token, json=data)
+
+    async def test_alert(self, token: str, team_id: int) -> dict:
+        return await self._team_request("POST", f"/api/team/alert/test/{team_id}", token)
+
+    async def reset_alert_status(self, token: str, team_id: int) -> dict:
+        return await self._team_request("POST", f"/api/team/alert/reset/{team_id}", token)
+
+    # ==================== 邀请分润模块 ====================
+
+    async def _commission_request(self, method: str, path: str, token: str, **kwargs) -> dict:
+        """分润模块通用请求封装"""
+        url = f"{self.base_url}{path}"
+        headers = {"Authorization": f"Bearer {token}"}
+        self._log_request(method, url, headers=headers, **kwargs)
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                resp = await getattr(client, method.lower())(url, headers=headers, **kwargs)
+                result = resp.json()
+                self._log_response(url, resp.status_code, result)
+                return {"success": result.get("code") == 200, "data": result.get("data"), "msg": result.get("msg")}
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    async def get_commission_activities(self, token: str) -> dict:
+        """获取可参与的分润活动列表"""
+        return await self._commission_request("GET", "/api/commission/my/activities", token)
+
+    async def join_commission_activity(self, token: str, activity_id: int, invite_code: str = None) -> dict:
+        """参与分润活动"""
+        data = {"activityId": activity_id}
+        if invite_code:
+            data["inviteCode"] = invite_code
+        return await self._commission_request("POST", "/api/commission/my/join", token, json=data)
+
+    async def quit_commission_activity(self, token: str) -> dict:
+        """退出分润活动"""
+        return await self._commission_request("POST", "/api/commission/my/quit", token)
+
+    async def get_commission_participation(self, token: str) -> dict:
+        """查询当前参与的活动"""
+        return await self._commission_request("GET", "/api/commission/my/participation", token)
+
+    async def get_commission_account(self, token: str) -> dict:
+        """查询分润结算账户"""
+        return await self._commission_request("GET", "/api/commission/my/account", token)
+
+    async def get_commission_summary(self, token: str) -> dict:
+        """查询分润汇总"""
+        return await self._commission_request("GET", "/api/commission/my/summary", token)
+
+    async def get_commission_records(self, token: str, start_date: str = None, end_date: str = None) -> dict:
+        """查询分润明细"""
+        qs = "&".join(f"{k}={v}" for k, v in {"startDate": start_date, "endDate": end_date}.items() if v)
+        path = "/api/commission/my/records" + (f"?{qs}" if qs else "")
+        return await self._commission_request("GET", path, token)
+
+    async def transfer_commission(self, token: str, credits_amount: int) -> dict:
+        """划转为可用积分"""
+        return await self._commission_request("POST", "/api/commission/my/transfer", token, json={"creditsAmount": credits_amount})
+
+    async def withdraw_commission(self, token: str, credits_amount: int) -> dict:
+        """提现为人民币"""
+        return await self._commission_request("POST", "/api/commission/my/withdraw", token, json={"creditsAmount": credits_amount})
+
+    async def get_commission_withdrawals(self, token: str, start_date: str = None, end_date: str = None) -> dict:
+        """查询提现/划转记录"""
+        qs = "&".join(f"{k}={v}" for k, v in {"startDate": start_date, "endDate": end_date}.items() if v)
+        path = "/api/commission/my/withdrawals" + (f"?{qs}" if qs else "")
+        return await self._commission_request("GET", path, token)
+