Upload 6 files

Dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.11-slim
+
+# 设置用户为root
+USER root
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+# 设置环境变量
+ENV HOST=0.0.0.0
+ENV PORT=7860
+
+# 删除敏感文件
+RUN rm -f config.json password.txt
+
+# 暴露端口（Hugging Face默认使用7860端口）
+EXPOSE 7860
+
+# 启动命令
+CMD ["python", "app.py"] 

README.md

@@ -1,11 +1,121 @@
 ---
-title: Abacus Procy
-emoji: 🦀
-colorFrom: red
-colorTo: indigo
+title: Abacus Chat Proxy
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
 sdk: docker
+sdk_version: "3.9"
+app_file: app.py
 pinned: false
-license: mit
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# Abacus Chat Proxy
+
+> 📢 本项目基于 [orbitoo/abacus_chat_proxy](https://github.com/orbitoo/abacus_chat_proxy) 改进
+> 
+> 特别感谢 orbitoo 大佬提供的原始项目！
+> 
+> 本项目增加了：Docker部署支持、Hugging Face一键部署、自动保活功能等
+
+一个用于中转API请求的代理服务器。
+
+#### 注意创建space的时候把private改为public，因为不改为public导致的错误别来找我
+
+[![Deploy to Hugging Face Spaces](https://huggingface.co/datasets/huggingface/badges/raw/main/deploy-to-spaces-lg.svg)](https://huggingface.co/spaces/malt666/abacus_chat_proxy?duplicate=true)
+
+## ⚠️ 警告
+
+**本地部署方式已失效！**为了适配hugging face，本项目的本地部署方式已不再可用。目前只能通过Hugging Face Spaces部署来使用本代理服务。请使用下方的Hugging Face一键部署方法。
+
+## 🚀 快速开始
+
+### Hugging Face一键部署
+
+#### 注意创建space的时候把private改为public，因为不改为public导致的错误别来找我
+
+1. 点击上方的"Deploy to Hugging Face Spaces"按钮
+2. 登录你的Hugging Face账号（如果还没有，需要注册一个）
+3. 在弹出的页面中设置你的Space名称，注意创建space的时候把private改为public，因为不改为为public导致的错误别来找我
+4. 创建完Space后，在Space的Settings -> Repository Secrets中添加以下配置：
+   - `cookie_1`: 第一个cookie
+   - `cookie_2`: 第二个cookie（如果有）
+   - 以此类推...
+   - `password`: （必填，最好超过8位数，不然被盗用api导致点数用光，损失自负）api调用密码，也是dashboard登录密码
+5. 等待自动部署完成即可
+6. 登录dashboard查看使用情况，space里面是没办法登录的，点击弹出的登录页面的小窗口提示“请点击 https://xyz-abacus-chat-proxy.hf.space 来登录并查看使用情况”的链接来登录，登录密码是你设置的password
+7. **获取API链接**：部署成功后，网络的登录页面会显示api接口链接；或者你点击右上角的三个点按钮，在弹出的选项卡里面点击"Embed this Space"，然后在弹出的"Embed this Space"界面里的"Direct URL"就是你的访问链接，你可以用这个链接调用API和查看使用情况
+8. api调用：api调用的时候注意密钥填写你的password，不然没办法调用
+### 本地运行（已失效）
+
+> ⚠️ 以下本地运行方法已失效，仅作参考。请使用Hugging Face部署方式。
+
+#### Windows用户
+
+1. 双击运行 `start.bat`
+2. 首次运行选择 `0` 进行配置
+3. 配置完成后选择 `Y` 直接启动，或 `N` 返回菜单
+4. 之后可直接选择 `1` 启动代理
+5. 代理服务器默认运行在 `http://127.0.0.1:9876/`
+
+#### Linux/macOS用户
+
+```bash
+# 赋予脚本执行权限
+chmod +x start.sh
+
+# 运行脚本
+./start.sh
+```
+
+选项说明同Windows。
+
+### 🌐 Hugging Face部署
+
+1. Fork本仓库到你的GitHub账号
+2. 在Hugging Face上创建新的Space（选择Docker类型）
+3. 在Space的设置中连接你的GitHub仓库
+4. 在Space的设置中添加以下Secrets：
+   - 第1组配置：
+     - `cookie_1`: 第1个cookies字符串
+   - 第2组配置（如果需要）：
+     - `cookie_2`: 第2个cookies字符串
+   - 更多配置以此类推（`cookie_3`...）
+   - `password`: （可选）访问密码
+5. Space会自动部署，服务将在 `https://你的空间名-你的用户名.hf.space` 上运行
+
+## ⚙️ 环境要求
+
+- Python 3.8+
+- pip
+
+## 📦 依赖
+
+```bash
+Flask==3.1.0
+requests==2.32.3
+PyJWT==2.8.0
+```
+
+## 📝 配置说明
+
+### 本地配置
+
+首次运行时，请选择 `0` 进行配置，按照提示填写相关信息。配置文件将保存在 `config.json` 中。
+
+### 环境变量配置
+
+在Docker或云平台部署时，需要配置以下环境变量：
+
+- 必需的配置（至少需要一组）：
+  - `cookie_1`: 第1组配置
+  - `cookie_2`: 第2组配置（可选）
+  - 以此类推...
+- 可选配置：
+  - `password`: 访问密码
+
+## 🔒 安全说明
+
+- 建议在部署到Hugging Face时设置访问密码
+- 在Hugging Face上配置时，请使用Secrets来存储敏感信息 

app.py

@@ -0,0 +1,1792 @@
+from flask import Flask, request, jsonify, Response, render_template_string, render_template, redirect, url_for, session as flask_session
+import requests
+import time
+import json
+import uuid
+import random
+import io
+import re
+from functools import wraps
+import hashlib
+import jwt  
+import os
+import threading
+from datetime import datetime, timedelta
+
+app = Flask(__name__, template_folder='templates')
+app.secret_key = os.environ.get("SECRET_KEY", "abacus_chat_proxy_secret_key")
+app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(days=7)
+
+# 添加tokenizer服务URL
+TOKENIZER_SERVICE_URL = "https://malt666-tokenizer.hf.space/count_tokens"
+
+API_ENDPOINT_URL = "https://abacus.ai/api/v0/describeDeployment"
+MODEL_LIST_URL = "https://abacus.ai/api/v0/listExternalApplications"
+CHAT_URL = "https://apps.abacus.ai/api/_chatLLMSendMessageSSE"
+USER_INFO_URL = "https://abacus.ai/api/v0/_getUserInfo"
+COMPUTE_POINTS_URL = "https://apps.abacus.ai/api/_getOrganizationComputePoints"
+COMPUTE_POINTS_LOG_URL = "https://abacus.ai/api/v0/_getOrganizationComputePointLog"
+CREATE_CONVERSATION_URL = "https://apps.abacus.ai/api/createDeploymentConversation"
+DELETE_CONVERSATION_URL = "https://apps.abacus.ai/api/deleteDeploymentConversation"
+GET_CONVERSATION_URL = "https://apps.abacus.ai/api/getDeploymentConversation"
+COMPUTE_POINT_TOGGLE_URL = "https://abacus.ai/api/v0/_updateOrganizationComputePointToggle"
+
+# 添加编辑聊天消息的URL
+EDIT_CHAT_RESPONSE_URL = "https://apps.abacus.ai/api/_editChatResponse"
+
+USER_AGENTS = [
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36"
+]
+
+
+PASSWORD = None
+USER_NUM = 0
+USER_DATA = []
+CURRENT_USER = -1
+MODELS = set()
+
+TRACE_ID = "3042e28b3abf475d8d973c7e904935af"
+SENTRY_TRACE = f"{TRACE_ID}-80d9d2538b2682d0"
+
+
+# 添加一个计数器记录健康检查次数
+health_check_counter = 0
+
+
+# 添加统计变量
+model_usage_stats = {}  # 模型使用次数统计
+total_tokens = {
+    "prompt": 0,       # 输入token统计
+    "completion": 0,   # 输出token统计
+    "total": 0         # 总token统计
+}
+
+# 模型调用记录
+model_usage_records = []  # 每次调用详细记录
+MODEL_USAGE_RECORDS_FILE = "model_usage_records.json"  # 调用记录保存文件
+
+# 计算点信息
+compute_points = {
+    "left": 0,          # 剩余计算点
+    "total": 0,         # 总计算点
+    "used": 0,          # 已使用计算点
+    "percentage": 0,    # 使用百分比
+    "last_update": None # 最后更新时间
+}
+
+# 计算点使用日志
+compute_points_log = {
+    "columns": {},      # 列名
+    "log": []           # 日志数据
+}
+
+# 多用户计算点信息
+users_compute_points = []
+
+# 记录启动时间
+START_TIME = datetime.utcnow() + timedelta(hours=8)  # 北京时间
+
+
+# 自定义JSON编码器，处理datetime对象
+class DateTimeEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, datetime):
+            return obj.strftime('%Y-%m-%d %H:%M:%S')
+        return super(DateTimeEncoder, self).default(obj)
+
+
+# 加载模型调用记录
+def load_model_usage_records():
+    global model_usage_records
+    try:
+        if os.path.exists(MODEL_USAGE_RECORDS_FILE):
+            with open(MODEL_USAGE_RECORDS_FILE, 'r', encoding='utf-8') as f:
+                records = json.load(f)
+                if isinstance(records, list):
+                    model_usage_records = records
+                    print(f"成功加载 {len(model_usage_records)} 条模型调用记录")
+                else:
+                    print("调用记录文件格式不正确，初始化为空列表")
+    except Exception as e:
+        print(f"加载模型调用记录失败: {e}")
+        model_usage_records = []
+
+# 保存模型调用记录
+def save_model_usage_records():
+    try:
+        with open(MODEL_USAGE_RECORDS_FILE, 'w', encoding='utf-8') as f:
+            json.dump(model_usage_records, f, ensure_ascii=False, indent=2, cls=DateTimeEncoder)
+        print(f"成功保存 {len(model_usage_records)} 条模型调用记录")
+    except Exception as e:
+        print(f"保存模型调用记录失败: {e}")
+
+
+def update_conversation_id(user_index, conversation_id):
+    """更新用户的conversation_id并保存到配置文件"""
+    try:
+        with open("config.json", "r") as f:
+            config = json.load(f)
+        
+        if "config" in config and user_index < len(config["config"]):
+            config["config"][user_index]["conversation_id"] = conversation_id
+            
+            # 保存到配置文件
+            with open("config.json", "w") as f:
+                json.dump(config, f, indent=4)
+                
+            print(f"已将用户 {user_index+1} 的conversation_id更新为: {conversation_id}")
+        else:
+            print(f"更新conversation_id失败: 配置文件格式错误或用户索引越界")
+    except Exception as e:
+        print(f"更新conversation_id失败: {e}")
+
+
+def resolve_config():
+    # 从环境变量读取多组配置
+    config_list = []
+    i = 1
+    while True:
+        cookie = os.environ.get(f"cookie_{i}")
+        if not cookie:
+            break
+        
+        # 为每个cookie创建一个配置项，conversation_id初始为空
+        config_list.append({
+            "conversation_id": "",  # 初始为空，将通过get_or_create_conversation自动创建
+            "cookies": cookie
+        })
+        i += 1
+    
+    # 如果环境变量存在配置，使用环境变量的配置
+    if config_list:
+        print(f"从环境变量加载了 {len(config_list)} 个配置")
+        return config_list
+    
+    # 如果环境变量不存在，从文件读取
+    try:
+        with open("config.json", "r") as f:
+            config = json.load(f)
+        config_list = config.get("config")
+        return config_list
+    except FileNotFoundError:
+        print("未找到config.json文件")
+        return []
+    except json.JSONDecodeError:
+        print("config.json格式错误")
+        return []
+
+
+def get_password():
+    global PASSWORD
+    # 从环境变量读取密码
+    env_password = os.environ.get("password")
+    if env_password:
+        PASSWORD = hashlib.sha256(env_password.encode()).hexdigest()
+        return
+
+    # 如果环境变量不存在，从文件读取
+    try:
+        with open("password.txt", "r") as f:
+            PASSWORD = f.read().strip()
+    except FileNotFoundError:
+        with open("password.txt", "w") as f:
+            PASSWORD = None
+
+
+def require_auth(f):
+    @wraps(f)
+    def decorated(*args, **kwargs):
+        if not PASSWORD:
+            return f(*args, **kwargs)
+        
+        # 检查Flask会话是否已登录
+        if flask_session.get('logged_in'):
+            return f(*args, **kwargs)
+            
+        # 如果是API请求，检查Authorization头
+        auth = request.authorization
+        if not auth or not check_auth(auth.token):
+            # 如果是浏览器请求，重定向到登录页面
+            if request.headers.get('Accept', '').find('text/html') >= 0:
+                return redirect(url_for('login'))
+            return jsonify({"error": "Unauthorized access"}), 401
+        return f(*args, **kwargs)
+
+    return decorated
+
+
+def check_auth(token):
+    return hashlib.sha256(token.encode()).hexdigest() == PASSWORD
+
+
+def is_token_expired(token):
+    if not token:
+        return True
+    
+    try:
+        # Malkodi tokenon sen validigo de subskribo
+        payload = jwt.decode(token, options={"verify_signature": False})
+        # Akiru eksvalidiĝan tempon, konsideru eksvalidiĝinta 5 minutojn antaŭe
+        return payload.get('exp', 0) - time.time() < 300
+    except:
+        return True
+
+
+def refresh_token(session, cookies):
+    """Uzu kuketon por refreŝigi session token, nur revenigu novan tokenon"""
+    headers = {
+        "accept": "application/json, text/plain, */*",
+        "accept-language": "zh-CN,zh;q=0.9",
+        "content-type": "application/json",
+        "reai-ui": "1",
+        "sec-ch-ua": "\"Chromium\";v=\"116\", \"Not)A;Brand\";v=\"24\", \"Google Chrome\";v=\"116\"",
+        "sec-ch-ua-mobile": "?0",
+        "sec-ch-ua-platform": "\"Windows\"",
+        "sec-fetch-dest": "empty",
+        "sec-fetch-mode": "cors",
+        "sec-fetch-site": "same-site",
+        "x-abacus-org-host": "apps",
+        "user-agent": random.choice(USER_AGENTS),
+        "origin": "https://apps.abacus.ai",
+        "referer": "https://apps.abacus.ai/",
+        "cookie": cookies
+    }
+    
+    try:
+        response = session.post(
+            USER_INFO_URL,
+            headers=headers,
+            json={},
+            cookies=None
+        )
+        
+        if response.status_code == 200:
+            response_data = response.json()
+            if response_data.get('success') and 'sessionToken' in response_data.get('result', {}):
+                return response_data['result']['sessionToken']
+            else:
+                print(f"刷新token失败: {response_data.get('error', '未知错误')}")
+                return None
+        else:
+            print(f"刷新token失败，状态码: {response.status_code}")
+            return None
+    except Exception as e:
+        print(f"刷新token异常: {e}")
+        return None
+
+
+def get_model_map(session, cookies, session_token):
+    """Akiru disponeblan modelan liston kaj ĝiajn mapajn rilatojn"""
+    headers = {
+        "accept": "application/json, text/plain, */*",
+        "accept-language": "zh-CN,zh;q=0.9",
+        "content-type": "application/json",
+        "reai-ui": "1",
+        "sec-ch-ua": "\"Chromium\";v=\"116\", \"Not)A;Brand\";v=\"24\", \"Google Chrome\";v=\"116\"",
+        "sec-ch-ua-mobile": "?0",
+        "sec-ch-ua-platform": "\"Windows\"",
+        "sec-fetch-dest": "empty",
+        "sec-fetch-mode": "cors",
+        "sec-fetch-site": "same-site",
+        "x-abacus-org-host": "apps",
+        "user-agent": random.choice(USER_AGENTS),
+        "origin": "https://apps.abacus.ai",
+        "referer": "https://apps.abacus.ai/",
+        "cookie": cookies
+    }
+    
+    if session_token:
+        headers["session-token"] = session_token
+    
+    model_map = {}
+    models_set = set()
+    
+    try:
+        response = session.post(
+            MODEL_LIST_URL,
+            headers=headers,
+            json={},
+            cookies=None
+        )
+        
+        if response.status_code != 200:
+            print(f"获取模型列表失败，状态码: {response.status_code}")
+            raise Exception("API请求失败")
+        
+        data = response.json()
+        if not data.get('success'):
+            print(f"获取模型列表失败: {data.get('error', '未知错误')}")
+            raise Exception("API返回错误")
+        
+        applications = []
+        if isinstance(data.get('result'), dict):
+            applications = data.get('result', {}).get('externalApplications', [])
+        elif isinstance(data.get('result'), list):
+            applications = data.get('result', [])
+        
+        for app in applications:
+            app_name = app.get('name', '')
+            app_id = app.get('externalApplicationId', '')
+            prediction_overrides = app.get('predictionOverrides', {})
+            llm_name = prediction_overrides.get('llmName', '') if prediction_overrides else ''
+            
+            if not (app_name and app_id and llm_name):
+                continue
+                
+            model_name = app_name
+            model_map[model_name] = (app_id, llm_name)
+            models_set.add(model_name)
+        
+        if not model_map:
+            raise Exception("未找到任何可用模型")
+        
+        return model_map, models_set
+    
+    except Exception as e:
+        print(f"获取模型列表异常: {e}")
+        raise
+
+
+def init_session():
+    get_password()
+    global USER_NUM, MODELS, USER_DATA
+    
+    config_list = resolve_config()
+    user_num = len(config_list)
+    all_models = set()
+    
+    for i in range(user_num):
+        user = config_list[i]
+        cookies = user.get("cookies")
+        conversation_id = user.get("conversation_id")
+        session = requests.Session()
+        
+        session_token = refresh_token(session, cookies)
+        if not session_token:
+            print(f"无法获取cookie {i+1}的token")
+            continue
+        
+        try:
+            model_map, models_set = get_model_map(session, cookies, session_token)
+            all_models.update(models_set)
+            USER_DATA.append((session, cookies, session_token, conversation_id, model_map, i))
+            
+            # 对第一个成功配置的用户，初始化计算点数记录功能
+            if i == 0:
+                try:
+                    headers = {
+                        "accept": "application/json, text/plain, */*",
+                        "accept-language": "zh-CN,zh;q=0.9",
+                        "content-type": "application/json",
+                        "reai-ui": "1",
+                        "sec-ch-ua": "\"Chromium\";v=\"116\", \"Not)A;Brand\";v=\"24\", \"Google Chrome\";v=\"116\"",
+                        "sec-ch-ua-mobile": "?0",
+                        "sec-ch-ua-platform": "\"Windows\"",
+                        "sec-fetch-dest": "empty",
+                        "sec-fetch-mode": "cors",
+                        "sec-fetch-site": "same-site",
+                        "x-abacus-org-host": "apps",
+                        "session-token": session_token
+                    }
+                    
+                    response = session.post(
+                        COMPUTE_POINT_TOGGLE_URL,
+                        headers=headers,
+                        json={"alwaysDisplay": True},
+                        cookies=None
+                    )
+                    
+                    if response.status_code == 200:
+                        result = response.json()
+                        if result.get("success"):
+                            print("成功初始化计算点数记录功能为开启状态")
+                        else:
+                            print(f"初始化计算点数记录功能失败: {result.get('error', '未知错误')}")
+                    else:
+                        print(f"初始化计算点数记录功能失败，状态码: {response.status_code}")
+                except Exception as e:
+                    print(f"初始化计算点数记录功能时出错: {e}")
+        except Exception as e:
+            print(f"配置用户 {i+1} 失败: {e}")
+            continue
+    
+    USER_NUM = len(USER_DATA)
+    if USER_NUM == 0:
+        print("No user available, exiting...")
+        exit(1)
+    
+    MODELS = all_models
+    print(f"启动完成，共配置 {USER_NUM} 个用户")
+
+
+def update_cookie(session, cookies):
+    cookie_jar = {}
+    for key, value in session.cookies.items():
+        cookie_jar[key] = value
+    cookie_dict = {}
+    for item in cookies.split(";"):
+        key, value = item.strip().split("=", 1)
+        cookie_dict[key] = value
+    cookie_dict.update(cookie_jar)
+    cookies = "; ".join([f"{key}={value}" for key, value in cookie_dict.items()])
+    return cookies
+
+
+user_data = init_session()
+
+
+@app.route("/v1/models", methods=["GET"])
+@require_auth
+def get_models():
+    if len(MODELS) == 0:
+        return jsonify({"error": "No models available"}), 500
+    model_list = []
+    for model in MODELS:
+        model_list.append(
+            {
+                "id": model,
+                "object": "model",
+                "created": int(time.time()),
+                "owned_by": "Elbert",
+                "name": model,
+            }
+        )
+    return jsonify({"object": "list", "data": model_list})
+
+
+@app.route("/v1/chat/completions", methods=["POST"])
+@require_auth
+def chat_completions():
+    openai_request = request.get_json()
+    stream = openai_request.get("stream", False)
+    messages = openai_request.get("messages")
+    if messages is None:
+        return jsonify({"error": "Messages is required", "status": 400}), 400
+    model = openai_request.get("model")
+    if model not in MODELS:
+        return (
+            jsonify(
+                {
+                    "error": "Model not available, check if it is configured properly",
+                    "status": 404,
+                }
+            ),
+            404,
+        )
+    message = format_message(messages)
+    think = (
+        openai_request.get("think", False) if model == "Claude Sonnet 3.7" else False
+    )
+    return (
+        send_message(message, model, think)
+        if stream
+        else send_message_non_stream(message, model, think)
+    )
+
+
+def get_user_data():
+    global CURRENT_USER
+    CURRENT_USER = (CURRENT_USER + 1) % USER_NUM
+    print(f"使用配置 {CURRENT_USER+1}")
+    
+    # Akiru uzantajn datumojn
+    session, cookies, session_token, conversation_id, model_map, user_index = USER_DATA[CURRENT_USER]
+    
+    # Kontrolu ĉu la tokeno eksvalidiĝis, se jes, refreŝigu ĝin
+    if is_token_expired(session_token):
+        print(f"Cookie {CURRENT_USER+1}的token已过期或即将过期，正在刷新...")
+        new_token = refresh_token(session, cookies)
+        if new_token:
+            # Ĝisdatigu la globale konservitan tokenon
+            USER_DATA[CURRENT_USER] = (session, cookies, new_token, conversation_id, model_map, user_index)
+            session_token = new_token
+            print(f"成功更新token: {session_token[:15]}...{session_token[-15:]}")
+        else:
+            print(f"警告：无法刷新Cookie {CURRENT_USER+1}的token，继续使用当前token")
+    
+    return (session, cookies, session_token, conversation_id, model_map, user_index)
+
+
+def create_conversation(session, cookies, session_token, external_application_id=None, deployment_id=None):
+    """创建新的会话"""
+    if not (external_application_id and deployment_id):
+        print("无法创建新会话: 缺少必要参数")
+        return None
+    
+    headers = {
+        "accept": "application/json, text/plain, */*",
+        "accept-language": "zh-CN,zh;q=0.9",
+        "content-type": "application/json",
+        "cookie": cookies,
+        "user-agent": random.choice(USER_AGENTS),
+        "x-abacus-org-host": "apps"
+    }
+    
+    if session_token:
+        headers["session-token"] = session_token
+    
+    create_payload = {
+        "deploymentId": deployment_id,
+        "name": "New Chat",
+        "externalApplicationId": external_application_id
+    }
+    
+    try:
+        response = session.post(
+            CREATE_CONVERSATION_URL,
+            headers=headers,
+            json=create_payload
+        )
+        
+        if response.status_code == 200:
+            data = response.json()
+            if data.get("success", False):
+                new_conversation_id = data.get("result", {}).get("deploymentConversationId")
+                if new_conversation_id:
+                    print(f"成功创建新的conversation: {new_conversation_id}")
+                    return new_conversation_id
+        
+        print(f"创建会话失败: {response.status_code} - {response.text[:100]}")
+        return None
+    except Exception as e:
+        print(f"创建会话时出错: {e}")
+        return None
+
+
+def delete_conversation(session, cookies, session_token, conversation_id, deployment_id="14b2a314cc"):
+    """删除指定的对话"""
+    if not conversation_id:
+        print("无法删除对话: 缺少conversation_id")
+        return False
+    
+    headers = {
+        "accept": "application/json, text/plain, */*",
+        "accept-language": "zh-CN,zh;q=0.9",
+        "content-type": "application/json",
+        "cookie": cookies,
+        "user-agent": random.choice(USER_AGENTS),
+        "x-abacus-org-host": "apps"
+    }
+    
+    if session_token:
+        headers["session-token"] = session_token
+    
+    delete_payload = {
+        "deploymentId": deployment_id,
+        "deploymentConversationId": conversation_id
+    }
+    
+    try:
+        response = session.post(
+            DELETE_CONVERSATION_URL,
+            headers=headers,
+            json=delete_payload
+        )
+        
+        if response.status_code == 200:
+            data = response.json()
+            if data.get("success", False):
+                print(f"成功删除对话: {conversation_id}")
+                return True
+        
+        print(f"删除对话失败: {response.status_code} - {response.text[:100]}")
+        return False
+    except Exception as e:
+        print(f"删除对话时出错: {e}")
+        return False
+
+
+def get_or_create_conversation(session, cookies, session_token, conversation_id, model_map, model, user_index):
+    """获取对话ID，如果不存在则创建并初始化"""
+    print(f"\n----- 获取会话ID (用户 {user_index+1}) -----")
+    
+    # 如果有现有的会话ID，直接使用
+    if conversation_id:
+        print(f"使用现有会话ID: {conversation_id}")
+        return conversation_id
+    
+    # 如果没有会话ID，创建新的并初始化
+    print("没有会话ID，创建并初始化新会话...")
+    
+    new_conversation_id = create_and_initialize_conversation(
+        session, cookies, session_token, model_map, model, user_index
+    )
+    
+    if not new_conversation_id:
+        print("创建并初始化新会话失败")
+        return None
+    
+    return new_conversation_id
+
+
+def generate_trace_id():
+    """Generu novan trace_id kaj sentry_trace"""
+    trace_id = str(uuid.uuid4()).replace('-', '')
+    sentry_trace = f"{trace_id}-{str(uuid.uuid4())[:16]}"
+    return trace_id, sentry_trace
+
+
+def send_message(message, model, think=False):
+    """发送消息，流式响应
+    
+    流程：
+    1. 获取对话ID（若不存在则创建并初始化）
+    2. 编辑索引为1的助手消息为处理好的message
+    3. 发送占位符消息"Now, the internal test begins."并获取响应
+    4. 如果失败，尝试重新创建对话并重试一次
+    """
+    print("\n===== 开始处理消息 =====")
+    print(f"模型: {model}")
+    print(f"思考模式: {think}")
+    
+    (session, cookies, session_token, conversation_id, model_map, user_index) = get_user_data()
+    print(f"使用用户配置: {user_index + 1}")
+    
+    # 计算输入token
+    print("\n----- 计算输入token -----")
+    prompt_tokens, calculation_method = num_tokens_from_string(message, model)
+    print(f"输入token数: {prompt_tokens}")
+    print(f"计算方法: {calculation_method}")
+    
+    # 使用新的流程
+    def process_with_conversation(current_conversation_id, is_retry=False):
+        # 如果是重试，需要先初始化对话
+        if is_retry:
+            current_conversation_id = create_and_initialize_conversation(
+                session, cookies, session_token, model_map, model, user_index
+            )
+            if not current_conversation_id:
+                return jsonify({"error": "Failed to create a new conversation for retry"}), 500
+        
+        # 编辑索引为1的助手消息
+        edit_success = edit_assistant_message(
+            session, cookies, session_token, 
+            current_conversation_id, message, model_map, model
+        )
+        
+        if not edit_success:
+            if is_retry:
+                return jsonify({"error": "Failed to edit assistant message even after retry"}), 500
+            else:
+                print("编辑助手消息失败，尝试重新创建对话...")
+                return process_with_conversation(None, True)
+        
+        # 发送占位符消息并获取响应
+        trace_id, sentry_trace = generate_trace_id()
+        completion_buffer = io.StringIO()  # 收集所有输出用于计算token
+        
+        headers = {
+            "accept": "text/event-stream",
+            "accept-language": "zh-CN,zh;q=0.9",
+            "baggage": f"sentry-environment=production,sentry-release=975eec6685013679c139fc88db2c48e123d5c604,sentry-public_key=3476ea6df1585dd10e92cdae3a66ff49,sentry-trace_id={trace_id}",
+            "content-type": "text/plain;charset=UTF-8",
+            "cookie": cookies,
+            "sec-ch-ua": "\"Chromium\";v=\"116\", \"Not)A;Brand\";v=\"24\", \"Google Chrome\";v=\"116\"",
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": "\"Windows\"",
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+            "sentry-trace": sentry_trace,
+            "user-agent": random.choice(USER_AGENTS),
+            "x-abacus-org-host": "apps"
+        }
+        
+        if session_token:
+            headers["session-token"] = session_token
+        
+        # 构建请求
+        payload = {
+            "requestId": str(uuid.uuid4()),
+            "deploymentConversationId": current_conversation_id,
+            "message": "Now, the internal test begins.",  # 占位符消息
+            "isDesktop": False,
+            "chatConfig": {
+                "timezone": "Asia/Shanghai",
+                "language": "zh-CN"
+            },
+            "llmName": model_map[model][1],
+            "externalApplicationId": model_map[model][0],
+            "regenerate": True,
+            "editPrompt": True
+        }
+        
+        if think:
+            payload["useThinking"] = think
+        
+        try:
+            print(f"发送占位符消息: \"Now, the internal test begins.\"")
+            response = session.post(
+                CHAT_URL,
+                headers=headers,
+                data=json.dumps(payload),
+                stream=True,
+                cookies=None
+            )
+            
+            response.raise_for_status()
+            
+            def extract_segment(line_data):
+                try:
+                    data = json.loads(line_data)
+                    if "segment" in data:
+                        if isinstance(data["segment"], str):
+                            return data["segment"]
+                        elif isinstance(data["segment"], dict) and "segment" in data["segment"]:
+                            return data["segment"]["segment"]
+                    return ""
+                except:
+                    return ""
+            
+            def generate():
+                id = ""
+                think_state = 2
+                
+                yield "data: " + json.dumps({"object": "chat.completion.chunk", "choices": [{"delta": {"role": "assistant"}}]}) + "\n\n"
+                
+                for line in response.iter_lines():
+                    if line:
+                        decoded_line = line.decode("utf-8")
+                        try:
+                            if think:
+                                data = json.loads(decoded_line)
+                                if data.get("type") != "text":
+                                    continue
+                                elif think_state == 2:
+                                    id = data.get("messageId")
+                                    segment = "<think>\n" + data.get("segment", "")
+                                    completion_buffer.write(segment)  # 收集输出
+                                    yield f"data: {json.dumps({'object': 'chat.completion.chunk', 'choices': [{'delta': {'content': segment}}]})}\n\n"
+                                    think_state = 1
+                                elif think_state == 1:
+                                    if data.get("messageId") != id:
+                                        segment = data.get("segment", "")
+                                        completion_buffer.write(segment)  # 收集输出
+                                        yield f"data: {json.dumps({'object': 'chat.completion.chunk', 'choices': [{'delta': {'content': segment}}]})}\n\n"
+                                    else:
+                                        segment = "\n</think>\n" + data.get("segment", "")
+                                        completion_buffer.write(segment)  # 收集输出
+                                        yield f"data: {json.dumps({'object': 'chat.completion.chunk', 'choices': [{'delta': {'content': segment}}]})}\n\n"
+                                        think_state = 0
+                                else:
+                                    segment = data.get("segment", "")
+                                    completion_buffer.write(segment)  # 收集输出
+                                    yield f"data: {json.dumps({'object': 'chat.completion.chunk', 'choices': [{'delta': {'content': segment}}]})}\n\n"
+                            else:
+                                segment = extract_segment(decoded_line)
+                                if segment:
+                                    completion_buffer.write(segment)  # 收集输出
+                                    yield f"data: {json.dumps({'object': 'chat.completion.chunk', 'choices': [{'delta': {'content': segment}}]})}\n\n"
+                        except Exception as e:
+                            print(f"处理响应出错: {e}")
+                
+                yield "data: " + json.dumps({"object": "chat.completion.chunk", "choices": [{"delta": {}, "finish_reason": "stop"}]}) + "\n\n"
+                yield "data: [DONE]\n\n"
+                
+                # 在流式传输完成后计算token并更新统计
+                completion_result, _ = num_tokens_from_string(completion_buffer.getvalue(), model)
+                
+                # 保存对话历史并获取计算点数
+                _, compute_points_used = save_conversation_history(session, cookies, session_token, current_conversation_id)
+                
+                # 更新统计信息
+                update_model_stats(model, prompt_tokens, completion_result, calculation_method, compute_points_used)
+            
+            return Response(generate(), mimetype="text/event-stream")
+        
+        except requests.exceptions.RequestException as e:
+            error_details = str(e)
+            if hasattr(e, 'response') and e.response is not None:
+                if hasattr(e.response, 'text'):
+                    error_details += f" - Response: {e.response.text[:200]}"
+            print(f"发送消息失败: {error_details}")
+            
+            # 如果不是重试，尝试重新创建对话重试一次
+            if not is_retry:
+                print("尝试重新创建对话...")
+                return process_with_conversation(None, True)
+            
+            return jsonify({"error": f"Failed to send message: {error_details}"}), 500
+    
+    # 获取会话ID
+    conversation_id = get_or_create_conversation(
+        session, cookies, session_token, conversation_id, model_map, model, user_index
+    )
+    
+    # 如果没有有效的会话ID，返回错误
+    if not conversation_id:
+        return jsonify({"error": "Failed to get a valid conversation ID"}), 500
+    
+    print(f"会话ID: {conversation_id}")
+    
+    # 使用上面定义的流程处理消息
+    return process_with_conversation(conversation_id)
+
+
+def send_message_non_stream(message, model, think=False):
+    """发送消息，非流式响应
+    
+    流程：
+    1. 获取对话ID（若不存在则创建并初始化）
+    2. 编辑索引为1的助手消息为处理好的message
+    3. 发送占位符消息"Now, the internal test begins."并获取响应
+    4. 如果失败，尝试重新创建对话并重试一次
+    """
+    print("\n===== 开始处理消息（非流式） =====")
+    print(f"模型: {model}")
+    print(f"思考模式: {think}")
+    
+    (session, cookies, session_token, conversation_id, model_map, user_index) = get_user_data()
+    print(f"使用用户配置: {user_index + 1}")
+    
+    # 计算输入token
+    print("\n----- 计算输入token -----")
+    prompt_tokens, calculation_method = num_tokens_from_string(message, model)
+    print(f"输入token数: {prompt_tokens}")
+    print(f"计算方法: {calculation_method}")
+    
+    # 使用新的流程
+    def process_with_conversation(current_conversation_id, is_retry=False):
+        # 如果是重试，需要先初始化对话
+        if is_retry:
+            current_conversation_id = create_and_initialize_conversation(
+                session, cookies, session_token, model_map, model, user_index
+            )
+            if not current_conversation_id:
+                return jsonify({"error": "Failed to create a new conversation for retry"}), 500
+        
+        # 编辑索引为1的助手消息
+        edit_success = edit_assistant_message(
+            session, cookies, session_token, 
+            current_conversation_id, message, model_map, model
+        )
+        
+        if not edit_success:
+            if is_retry:
+                return jsonify({"error": "Failed to edit assistant message even after retry"}), 500
+            else:
+                print("编辑助手消息失败，尝试重新创建对话...")
+                return process_with_conversation(None, True)
+        
+        # 发送占位符消息并获取响应
+        trace_id, sentry_trace = generate_trace_id()
+        
+        headers = {
+            "accept": "text/event-stream",
+            "accept-language": "zh-CN,zh;q=0.9",
+            "baggage": f"sentry-environment=production,sentry-release=975eec6685013679c139fc88db2c48e123d5c604,sentry-public_key=3476ea6df1585dd10e92cdae3a66ff49,sentry-trace_id={trace_id}",
+            "content-type": "text/plain;charset=UTF-8",
+            "cookie": cookies,
+            "sec-ch-ua": "\"Chromium\";v=\"116\", \"Not)A;Brand\";v=\"24\", \"Google Chrome\";v=\"116\"",
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": "\"Windows\"",
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+            "sentry-trace": sentry_trace,
+            "user-agent": random.choice(USER_AGENTS),
+            "x-abacus-org-host": "apps"
+        }
+        
+        if session_token:
+            headers["session-token"] = session_token
+        
+        # 构建请求
+        payload = {
+            "requestId": str(uuid.uuid4()),
+            "deploymentConversationId": current_conversation_id,
+            "message": "Now, the internal test begins.",  # 占位符消息
+            "isDesktop": False,
+            "chatConfig": {
+                "timezone": "Asia/Shanghai",
+                "language": "zh-CN"
+            },
+            "llmName": model_map[model][1],
+            "externalApplicationId": model_map[model][0],
+            "regenerate": True,
+            "editPrompt": True
+        }
+        
+        if think:
+            payload["useThinking"] = think
+        
+        try:
+            print(f"发送占位符消息: \"Now, the internal test begins.\"")
+            response = session.post(
+                CHAT_URL,
+                headers=headers,
+                data=json.dumps(payload),
+                stream=True,
+                cookies=None
+            )
+            
+            response.raise_for_status()
+            
+            def extract_segment(line_data):
+                try:
+                    data = json.loads(line_data)
+                    if "segment" in data:
+                        if isinstance(data["segment"], str):
+                            return data["segment"]
+                        elif isinstance(data["segment"], dict) and "segment" in data["segment"]:
+                            return data["segment"]["segment"]
+                    return ""
+                except:
+                    return ""
+            
+            if think:
+                id = ""
+                think_state = 2
+                think_buffer = io.StringIO()
+                content_buffer = io.StringIO()
+                
+                for line in response.iter_lines():
+                    if line:
+                        decoded_line = line.decode("utf-8")
+                        try:
+                            data = json.loads(decoded_line)
+                            if data.get("type") != "text":
+                                continue
+                            elif think_state == 2:
+                                id = data.get("messageId")
+                                segment = data.get("segment", "")
+                                think_buffer.write(segment)
+                                think_state = 1
+                            elif think_state == 1:
+                                if data.get("messageId") != id:
+                                    segment = data.get("segment", "")
+                                    content_buffer.write(segment)
+                                else:
+                                    segment = data.get("segment", "")
+                                    think_buffer.write(segment)
+                                    think_state = 0
+                            else:
+                                segment = data.get("segment", "")
+                                content_buffer.write(segment)
+                        except Exception as e:
+                            print(f"处理响应出错: {e}")
+                
+                think_content = think_buffer.getvalue()
+                response_content = content_buffer.getvalue()
+                
+                # 计算输出token并更新统计信息
+                completion_result, _ = num_tokens_from_string(think_content + response_content, model)
+                
+                # 保存对话历史并获取计算点数
+                _, compute_points_used = save_conversation_history(session, cookies, session_token, current_conversation_id)
+                
+                # 更新统计信息
+                update_model_stats(model, prompt_tokens, completion_result, calculation_method, compute_points_used)
+                
+                return jsonify({
+                    "id": f"chatcmpl-{str(uuid.uuid4())}",
+                    "object": "chat.completion",
+                    "created": int(time.time()),
+                    "model": model,
+                    "choices": [{
+                        "index": 0,
+                        "message": {
+                            "role": "assistant",
+                            "content": f"<think>\n{think_content}\n</think>\n{response_content}"
+                        },
+                        "finish_reason": "stop"
+                    }],
+                    "usage": {
+                        "prompt_tokens": prompt_tokens,
+                        "completion_tokens": completion_result,
+                        "total_tokens": prompt_tokens + completion_result
+                    }
+                })
+            else:
+                buffer = io.StringIO()
+                for line in response.iter_lines():
+                    if line:
+                        decoded_line = line.decode("utf-8")
+                        segment = extract_segment(decoded_line)
+                        if segment:
+                            buffer.write(segment)
+                
+                response_content = buffer.getvalue()
+                
+                # 计算输出token并更新统计信息
+                completion_result, _ = num_tokens_from_string(response_content, model)
+                
+                # 保存对话历史并获取计算点数
+                _, compute_points_used = save_conversation_history(session, cookies, session_token, current_conversation_id)
+                
+                # 更新统计信息
+                update_model_stats(model, prompt_tokens, completion_result, calculation_method, compute_points_used)
+                
+                return jsonify({
+                    "id": f"chatcmpl-{str(uuid.uuid4())}",
+                    "object": "chat.completion",
+                    "created": int(time.time()),
+                    "model": model,
+                    "choices": [{
+                        "index": 0,
+                        "message": {
+                            "role": "assistant",
+                            "content": response_content
+                        },
+                        "finish_reason": "stop"
+                    }],
+                    "usage": {
+                        "prompt_tokens": prompt_tokens,
+                        "completion_tokens": completion_result,
+                        "total_tokens": prompt_tokens + completion_result
+                    }
+                })
+        
+        except requests.exceptions.RequestException as e:
+            error_details = str(e)
+            if hasattr(e, 'response') and e.response is not None:
+                if hasattr(e.response, 'text'):
+                    error_details += f" - Response: {e.response.text[:200]}"
+            print(f"发送消息失败: {error_details}")
+            
+            # 如果不是重试，尝试重新创建对话重试一次
+            if not is_retry:
+                print("尝试重新创建对话...")
+                return process_with_conversation(None, True)
+            
+            return jsonify({"error": f"Failed to send message: {error_details}"}), 500
+    
+    # 获取会话ID
+    conversation_id = get_or_create_conversation(
+        session, cookies, session_token, conversation_id, model_map, model, user_index
+    )
+    
+    # 如果没有有效的会话ID，返回错误
+    if not conversation_id:
+        return jsonify({"error": "Failed to get a valid conversation ID"}), 500
+    
+    print(f"会话ID: {conversation_id}")
+    
+    # 使用上面定义的流程处理消息
+    return process_with_conversation(conversation_id)
+
+
+def format_message(messages):
+    buffer = io.StringIO()
+    role_map, prefix, messages = extract_role(messages)
+    for message in messages:
+        role = message.get("role")
+        role = "\b" + role_map[role] if prefix else role_map[role]
+        content = message.get("content").replace("\\n", "\n")
+        pattern = re.compile(r"<\|removeRole\|>\n")
+        if pattern.match(content):
+            content = pattern.sub("", content)
+            buffer.write(f"{content}\n")
+        else:
+            buffer.write(f"{role}: {content}\n\n")
+    formatted_message = buffer.getvalue()
+    return formatted_message
+
+
+def extract_role(messages):
+    role_map = {"user": "Human", "assistant": "Assistant", "system": "System"}
+    prefix = True  # 默认添加前缀
+    first_message = messages[0]["content"]
+    pattern = re.compile(
+        r"""
+        <roleInfo>\s*
+        (?:user:\s*(?P<user>[^\n]*)\s*)?        # Make user optional
+        (?:assistant:\s*(?P<assistant>[^\n]*)\s*)? # Make assistant optional
+        (?:system:\s*(?P<system>[^\n]*)\s*)?     # Make system optional
+        (?:prefix:\s*(?P<prefix>[^\n]*)\s*)?     # Make prefix optional
+        </roleInfo>\n
+    """,
+        re.VERBOSE,
+    )
+    match = pattern.search(first_message)
+    if match:
+        # 更新 role_map 如果提供了值
+        user_role = match.group("user")
+        assistant_role = match.group("assistant")
+        system_role = match.group("system")
+        if user_role: role_map["user"] = user_role
+        if assistant_role: role_map["assistant"] = assistant_role
+        if system_role: role_map["system"] = system_role
+
+        # 检查 prefix 值：仅当显式设置为非 "1" 时才将 prefix 设为 False
+        prefix_value = match.group("prefix")
+        if prefix_value is not None and prefix_value != "1":
+            prefix = False
+        # 如果 prefix_value 是 None (标签不存在) 或 "1", prefix 保持 True
+
+        messages[0]["content"] = pattern.sub("", first_message)
+        print(f"Extracted role map:")
+        print(
+            f"User: {role_map['user']}, Assistant: {role_map['assistant']}, System: {role_map['system']}"
+        )
+        print(f"Using prefix: {prefix}") # 打印语句保持不变，反映最终结果
+    # 如果没有匹配到 <roleInfo>，prefix 保持默认值 True
+    return (role_map, prefix, messages)
+
+
+@app.route("/health", methods=["GET"])
+def health_check():
+    global health_check_counter
+    health_check_counter += 1
+    return jsonify({
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "checks": health_check_counter
+    })
+
+
+def keep_alive():
+    """每20分钟进行一次自我健康检查"""
+    while True:
+        try:
+            requests.get("http://127.0.0.1:7860/health")
+            time.sleep(1200)  # 20分钟
+        except:
+            pass  # 忽略错误，保持运行
+
+
+@app.route("/", methods=["GET"])
+def index():
+    # 如果需要密码且用户未登录，重定向到登录页面
+    if PASSWORD and not flask_session.get('logged_in'):
+        return redirect(url_for('login'))
+    
+    # 否则重定向到仪表盘
+    return redirect(url_for('dashboard'))
+
+
+def num_tokens_from_string(string, model=""):
+    try:
+        print("\n===================== 开始计算token =====================")
+        print(f"模型: {model}")
+        print(f"输���内容长度: {len(string)} 字符")
+        
+        request_data = {
+            "model": model,
+            "messages": [{"role": "user", "content": string}]
+        }
+        print(f"发送请求到tokenizer服务: {TOKENIZER_SERVICE_URL}")
+        print(f"请求数据: {json.dumps(request_data, ensure_ascii=False)}")
+        
+        response = requests.post(
+            TOKENIZER_SERVICE_URL,
+            json=request_data,
+            timeout=10
+        )
+        
+        print(f"\nTokenizer响应状态码: {response.status_code}")
+        print(f"Tokenizer响应内容: {response.text}")
+        
+        if response.status_code == 200:
+            result = response.json()
+            input_tokens = result.get("input_tokens", 0)
+            print(f"\n成功获取token数: {input_tokens}")
+            print(f"使用计算方法: 精确")
+            print("===================== 计算完成 =====================\n")
+            return input_tokens, "精确"
+        else:
+            estimated_tokens = len(string) // 4
+            print(f"\nTokenizer服务错误: {response.status_code}")
+            print(f"错误响应: {response.text}")
+            print(f"使用估算token数: {estimated_tokens}")
+            print(f"使用计算方法: 估算")
+            print("===================== 计算完成 =====================\n")
+            return estimated_tokens, "估算"
+    except Exception as e:
+        estimated_tokens = len(string) // 4
+        print(f"\n计算token时发生错误: {str(e)}")
+        print(f"使用估算token数: {estimated_tokens}")
+        print(f"使用计算方法: 估算")
+        print("===================== 计算完成 =====================\n")
+        return estimated_tokens, "估算"
+
+
+# 更新模型使用统计
+def update_model_stats(model, prompt_tokens, completion_tokens, calculation_method="estimate", compute_points=None):
+    global model_usage_stats, total_tokens, model_usage_records
+    
+    # 添加调用记录
+    # 获取UTC时间
+    utc_now = datetime.utcnow()
+    # 转换为北京时间 (UTC+8)
+    beijing_time = utc_now + timedelta(hours=8)
+    call_time = beijing_time.strftime('%Y-%m-%d %H:%M:%S')  # 北京时间
+    
+    record = {
+        "model": model,
+        "call_time": call_time,
+        "prompt_tokens": prompt_tokens,
+        "completion_tokens": completion_tokens,
+        "calculation_method": calculation_method,  # 直接使用传入的值
+        "compute_points": compute_points
+    }
+    model_usage_records.append(record)
+    
+    # 限制记录数量，保留最新的500条
+    if len(model_usage_records) > 500:
+        model_usage_records.pop(0)
+    
+    # 保存调用记录到本地文件
+    save_model_usage_records()
+    
+    # 更新聚合统计
+    if model not in model_usage_stats:
+        model_usage_stats[model] = {
+            "count": 0,
+            "prompt_tokens": 0,
+            "completion_tokens": 0,
+            "total_tokens": 0
+        }
+    
+    model_usage_stats[model]["count"] += 1
+    model_usage_stats[model]["prompt_tokens"] += prompt_tokens
+    model_usage_stats[model]["completion_tokens"] += completion_tokens
+    model_usage_stats[model]["total_tokens"] += (prompt_tokens + completion_tokens)
+    
+    total_tokens["prompt"] += prompt_tokens
+    total_tokens["completion"] += completion_tokens
+    total_tokens["total"] += (prompt_tokens + completion_tokens)
+
+
+# 获取计算点信息
+def get_compute_points():
+    global compute_points, USER_DATA, users_compute_points
+    
+    if USER_NUM == 0:
+        return
+    
+    # 清空用户计算点列表
+    users_compute_points = []
+    
+    # 累计总计算点
+    total_left = 0
+    total_points = 0
+    
+    # 获取每个用户的计算点信息
+    for i, user_data in enumerate(USER_DATA):
+        try:
+            session, cookies, session_token, _, _, _ = user_data
+            
+            # 检查token是否有效
+            if is_token_expired(session_token):
+                session_token = refresh_token(session, cookies)
+                if not session_token:
+                    print(f"用户{i+1}刷新token失败，无法获取计算点信息")
+                    continue
+                USER_DATA[i] = (session, cookies, session_token, user_data[3], user_data[4], i)
+            
+            headers = {
+                "accept": "application/json, text/plain, */*",
+                "accept-language": "zh-CN,zh;q=0.9",
+                "baggage": f"sentry-environment=production,sentry-release=93da8385541a6ce339b1f41b0c94428c70657e22,sentry-public_key=3476ea6df1585dd10e92cdae3a66ff49,sentry-trace_id={TRACE_ID}",
+                "reai-ui": "1",
+                "sec-ch-ua": "\"Chromium\";v=\"116\", \"Not)A;Brand\";v=\"24\", \"Google Chrome\";v=\"116\"",
+                "sec-ch-ua-mobile": "?0",
+                "sec-ch-ua-platform": "\"Windows\"",
+                "sec-fetch-dest": "empty",
+                "sec-fetch-mode": "cors",
+                "sec-fetch-site": "same-origin",
+                "sentry-trace": SENTRY_TRACE,
+                "session-token": session_token,
+                "x-abacus-org-host": "apps",
+                "cookie": cookies
+            }
+            
+            response = session.get(
+                COMPUTE_POINTS_URL,
+                headers=headers
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                if result.get("success") and "result" in result:
+                    data = result["result"]
+                    left = data.get("computePointsLeft", 0)
+                    total = data.get("totalComputePoints", 0)
+                    used = total - left
+                    percentage = round((used / total) * 100, 2) if total > 0 else 0
+                    
+                    # 获取北京时间
+                    beijing_now = datetime.utcnow() + timedelta(hours=8)
+                    
+                    # 添加到用户列表
+                    user_points = {
+                        "user_id": i + 1,  # 用户ID从1开始
+                        "left": left,
+                        "total": total,
+                        "used": used,
+                        "percentage": percentage,
+                        "last_update": beijing_now
+                    }
+                    users_compute_points.append(user_points)
+                    
+                    # 累计总数
+                    total_left += left
+                    total_points += total
+                    
+                    print(f"用户{i+1}计算点信息更新成功: 剩余 {left}, 总计 {total}")
+                    
+                    # 对于第一个用户，获取计算点使用日志
+                    if i == 0:
+                        get_compute_points_log(session, cookies, session_token)
+                else:
+                    print(f"获取用户{i+1}计算点信息失败: {result.get('error', '未知错误')}")
+            else:
+                print(f"获取用户{i+1}计算点信息失败，状态码: {response.status_code}")
+        except Exception as e:
+            print(f"获取用户{i+1}计算点信息异常: {e}")
+    
+    # 更新全局计算点信息（所有用户总和）
+    if users_compute_points:
+        compute_points["left"] = total_left
+        compute_points["total"] = total_points
+        compute_points["used"] = total_points - total_left
+        compute_points["percentage"] = round((compute_points["used"] / compute_points["total"]) * 100, 2) if compute_points["total"] > 0 else 0
+        compute_points["last_update"] = datetime.utcnow() + timedelta(hours=8)  # 北京时间
+        print(f"所有用户计算点总计: 剩余 {total_left}, 总计 {total_points}")
+
+# 获取计算点使用日志
+def get_compute_points_log(session, cookies, session_token):
+    global compute_points_log
+    
+    try:
+        headers = {
+            "accept": "application/json, text/plain, */*",
+            "accept-language": "zh-CN,zh;q=0.9",
+            "content-type": "application/json",
+            "reai-ui": "1",
+            "sec-ch-ua": "\"Chromium\";v=\"116\", \"Not)A;Brand\";v=\"24\", \"Google Chrome\";v=\"116\"",
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": "\"Windows\"",
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-site",
+            "session-token": session_token,
+            "x-abacus-org-host": "apps",
+            "cookie": cookies
+        }
+        
+        response = session.post(
+            COMPUTE_POINTS_LOG_URL,
+            headers=headers,
+            json={"byLlm": True}
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            if result.get("success") and "result" in result:
+                data = result["result"]
+                compute_points_log["columns"] = data.get("columns", {})
+                compute_points_log["log"] = data.get("log", [])
+                print(f"计算点使用日志更新成功，获取到 {len(compute_points_log['log'])} 条记录")
+            else:
+                print(f"获取计算点使用日志失败: {result.get('error', '未知错误')}")
+        else:
+            print(f"获取计算点使用日志失败，状态码: {response.status_code}")
+    except Exception as e:
+        print(f"获取计算点使用日志异常: {e}")
+
+
+# 添加登录相关路由
+@app.route("/login", methods=["GET", "POST"])
+def login():
+    error = None
+    if request.method == "POST":
+        password = request.form.get("password")
+        if password and hashlib.sha256(password.encode()).hexdigest() == PASSWORD:
+            flask_session['logged_in'] = True
+            flask_session.permanent = True
+            return redirect(url_for('dashboard'))
+        else:
+            # 密码错误时提示使用环境变量密码
+            error = "密码不正确。请使用设置的环境变量 password 或 password.txt 中的值作为密码和API认证密钥。"
+    
+    # 传递空间URL给模板
+    return render_template('login.html', error=error, space_url=SPACE_URL)
+
+
+@app.route("/logout")
+def logout():
+    flask_session.clear()
+    return redirect(url_for('login'))
+
+
+@app.route("/dashboard")
+@require_auth
+def dashboard():
+    # 在每次访问仪表盘时更新计算点信息
+    get_compute_points()
+    
+    # 计算运行时间（使用北京时间）
+    beijing_now = datetime.utcnow() + timedelta(hours=8)
+    uptime = beijing_now - START_TIME
+    days = uptime.days
+    hours, remainder = divmod(uptime.seconds, 3600)
+    minutes, seconds = divmod(remainder, 60)
+    
+    if days > 0:
+        uptime_str = f"{days}天 {hours}小时 {minutes}分钟"
+    elif hours > 0:
+        uptime_str = f"{hours}小时 {minutes}分钟"
+    else:
+        uptime_str = f"{minutes}分钟 {seconds}秒"
+
+    # 当前北京年份
+    beijing_year = beijing_now.year
+
+    return render_template(
+        'dashboard.html',
+        uptime=uptime_str,
+        health_checks=health_check_counter,
+        user_count=USER_NUM,
+        models=sorted(list(MODELS)),
+        year=beijing_year,
+        model_stats=model_usage_stats,
+        total_tokens=total_tokens,
+        compute_points=compute_points,
+        compute_points_log=compute_points_log,
+        space_url=SPACE_URL,  # 传递空间URL
+        users_compute_points=users_compute_points,  # 传递用户计算点信息
+        model_usage_records=model_usage_records,  # 传递模型使用记录
+    )
+
+
+# 添加更新计算点数记录设置的路由
+@app.route("/update_compute_point_toggle", methods=["POST"])
+@require_auth
+def update_compute_point_toggle():
+    try:
+        (session, cookies, session_token, conversation_id, model_map, user_index) = get_user_data()
+        data = request.get_json()
+        if data and "always_display" in data:
+            headers = {
+                "accept": "application/json, text/plain, */*",
+                "accept-language": "zh-CN,zh;q=0.9",
+                "content-type": "application/json",
+                "reai-ui": "1",
+                "sec-ch-ua": "\"Chromium\";v=\"116\", \"Not)A;Brand\";v=\"24\", \"Google Chrome\";v=\"116\"",
+                "sec-ch-ua-mobile": "?0",
+                "sec-ch-ua-platform": "\"Windows\"",
+                "sec-fetch-dest": "empty",
+                "sec-fetch-mode": "cors",
+                "sec-fetch-site": "same-site",
+                "x-abacus-org-host": "apps"
+            }
+            
+            if session_token:
+                headers["session-token"] = session_token
+            
+            response = session.post(
+                COMPUTE_POINT_TOGGLE_URL,
+                headers=headers,
+                json={"alwaysDisplay": data["always_display"]},
+                cookies=None
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                if result.get("success"):
+                    print(f"更新计算点数记录设置为: {data['always_display']}")
+                    return jsonify({"success": True})
+            
+            return jsonify({"success": False, "error": "API调用失败"})
+        else:
+            return jsonify({"success": False, "error": "缺少always_display参数"})
+    except Exception as e:
+        print(f"更新计算点数记录设置失败: {e}")
+        return jsonify({"success": False, "error": str(e)})
+
+
+# 获取Hugging Face Space URL
+def get_space_url():
+    # 尝试从环境变量获取
+    space_url = os.environ.get("SPACE_URL")
+    if space_url:
+        return space_url
+    
+    # 如果SPACE_URL不存在，尝试从SPACE_ID构建
+    space_id = os.environ.get("SPACE_ID")
+    if space_id:
+        username, space_name = space_id.split("/")
+        # 将空间名称中的下划线替换为连字符
+        # 注意：Hugging Face生成的URL会自动将空间名称中的下划线(_)替换为连字符(-)
+        # 例如："abacus_chat_proxy" 会变成 "abacus-chat-proxy"
+        space_name = space_name.replace("_", "-")
+        return f"https://{username}-{space_name}.hf.space"
+    
+    # 如果以上都不存在，尝试从单独的用户名和空间名构建
+    username = os.environ.get("SPACE_USERNAME")
+    space_name = os.environ.get("SPACE_NAME")
+    if username and space_name:
+        # 将空间名称中的下划线替换为连字符
+        # 同上，Hugging Face会自动进行此转换
+        space_name = space_name.replace("_", "-")
+        return f"https://{username}-{space_name}.hf.space"
+    
+    # 默认返回None
+    return None
+
+# 获取空间URL
+SPACE_URL = get_space_url()
+if SPACE_URL:
+    print(f"Space URL: {SPACE_URL}")
+    print("注意：Hugging Face生成的URL会自动将空间名称中的下划线(_)替换为连字符(-)")
+
+
+def save_conversation_history(session, cookies, session_token, conversation_id, deployment_id="14b2a314cc"):
+    """保存对话历史，返回使用的计算点数"""
+    if not conversation_id:
+        return False, None
+        
+    headers = {
+        "accept": "application/json, text/plain, */*",
+        "accept-language": "zh-CN,zh;q=0.9",
+        "baggage": f"sentry-environment=production,sentry-release=946244517de08b08598b94f18098411f5a5352d5,sentry-public_key=3476ea6df1585dd10e92cdae3a66ff49,sentry-trace_id={TRACE_ID}",
+        "reai-ui": "1",
+        "sec-ch-ua": "\"Chromium\";v=\"116\", \"Not)A;Brand\";v=\"24\", \"Google Chrome\";v=\"116\"",
+        "sec-ch-ua-mobile": "?0",
+        "sec-ch-ua-platform": "\"Windows\"",
+        "sec-fetch-dest": "empty",
+        "sec-fetch-mode": "cors",
+        "sec-fetch-site": "same-origin",
+        "sentry-trace": f"{TRACE_ID}-800cb7f4613dec52",
+        "x-abacus-org-host": "apps"
+    }
+    
+    if session_token:
+        headers["session-token"] = session_token
+        
+    params = {
+        "deploymentId": deployment_id,
+        "deploymentConversationId": conversation_id,
+        "skipDocumentBoundingBoxes": "true",
+        "filterIntermediateConversationEvents": "false",
+        "getUnusedDocumentUploads": "false"
+    }
+    
+    try:
+        response = session.get(
+            GET_CONVERSATION_URL,
+            headers=headers,
+            params=params,
+            cookies=None
+        )
+        
+        if response.status_code == 200:
+            data = response.json()
+            if data.get("success"):
+                # 从最后一条BOT消息中获取计算点数
+                history = data.get("result", {}).get("history", [])
+                compute_points = None
+                for msg in reversed(history):
+                    if msg.get("role") == "BOT":
+                        compute_points = msg.get("computePointsUsed")
+                        break
+                print(f"成功保存对话历史: {conversation_id}, 使用计算点: {compute_points}")
+                return True, compute_points
+            else:
+                print(f"保存对话历史失败: {data.get('error', '未知错误')}")
+        else:
+            print(f"保存对话历史失败，状态码: {response.status_code}")
+        return False, None
+    except Exception as e:
+        print(f"保存对话历史时出错: {e}")
+        return False, None
+
+
+def create_and_initialize_conversation(session, cookies, session_token, model_map, model, user_index):
+    """创建新的对话ID并初始化
+    
+    创建新的对话ID
+    使用新对话ID发送"Repeat \"123\""作为第一条消息
+    休息五秒等待系统自动生成第二条消息
+    
+    注意：初始化必须使用Abacus.AI Smaug模型
+    """
+    print("\n===== 创建并初始化新对话 =====")
+    
+    deployment_id = "14b2a314cc"
+    
+    # 查找Abacus.AI Smaug模型
+    smaug_model_name = "Abacus.AI Smaug"
+    
+    # 如果找不到Smaug，尝试找带Smaug的模型
+    if smaug_model_name not in model_map:
+        for m_name in model_map.keys():
+            if "Smaug" in m_name:
+                smaug_model_name = m_name
+                print(f"未找到精确的Abacus.AI Smaug模型名称，使用: {smaug_model_name}")
+                break
+    
+    # 仍然找不到，使用传入的模型作为后备
+    if smaug_model_name not in model_map:
+        print(f"警告: 未找到任何Smaug模型，尝试使用传入的模型: {model}")
+        smaug_model_name = model
+    
+    # 确保模型信息存在
+    if smaug_model_name not in model_map or len(model_map[smaug_model_name]) < 2:
+        print(f"错误: 无法获取模型 {smaug_model_name} 的信息")
+        return None
+    
+    smaug_app_id = model_map[smaug_model_name][0]
+    smaug_llm_name = model_map[smaug_model_name][1]
+    
+    print(f"使用Smaug模型初始化对话: {smaug_model_name}, app_id: {smaug_app_id}, llm_name: {smaug_llm_name}")
+    
+    # 创建新会话
+    new_conversation_id = create_conversation(
+        session, cookies, session_token, 
+        external_application_id=smaug_app_id,
+        deployment_id=deployment_id
+    )
+    
+    if not new_conversation_id:
+        print("创建新会话失败")
+        return None
+    
+    print(f"成功创建新会话ID: {new_conversation_id}")
+    
+    # 发送初始消息 "Repeat \"123\""
+    trace_id, sentry_trace = generate_trace_id()
+    
+    headers = {
+        "accept": "text/event-stream",
+        "accept-language": "zh-CN,zh;q=0.9",
+        "baggage": f"sentry-environment=production,sentry-release=975eec6685013679c139fc88db2c48e123d5c604,sentry-public_key=3476ea6df1585dd10e92cdae3a66ff49,sentry-trace_id={trace_id}",
+        "content-type": "text/plain;charset=UTF-8",
+        "cookie": cookies,
+        "sec-ch-ua": "\"Chromium\";v=\"116\", \"Not)A;Brand\";v=\"24\", \"Google Chrome\";v=\"116\"",
+        "sec-ch-ua-mobile": "?0",
+        "sec-ch-ua-platform": "\"Windows\"",
+        "sec-fetch-dest": "empty",
+        "sec-fetch-mode": "cors",
+        "sec-fetch-site": "same-origin",
+        "sentry-trace": sentry_trace,
+        "user-agent": random.choice(USER_AGENTS),
+        "x-abacus-org-host": "apps"
+    }
+    
+    if session_token:
+        headers["session-token"] = session_token
+    
+    # 构建初始化请求 - 使用Smaug模型
+    init_payload = {
+        "requestId": str(uuid.uuid4()),
+        "deploymentConversationId": new_conversation_id,
+        "message": "Repeat \"123\"",
+        "isDesktop": False,
+        "chatConfig": {
+            "timezone": "Asia/Shanghai",
+            "language": "zh-CN"
+        },
+        "llmName": smaug_llm_name,
+        "externalApplicationId": smaug_app_id
+    }
+    
+    try:
+        print(f"发送初始化消息: \"Repeat \\\"123\\\"\"")
+        response = session.post(
+            CHAT_URL,
+            headers=headers,
+            data=json.dumps(init_payload),
+            stream=True,
+            cookies=None
+        )
+        
+        # 不处理响应，只确认成功发送
+        if response.status_code != 200:
+            print(f"发送初始化消息失败: {response.status_code}")
+            return None
+        
+        # 关闭响应流
+        response.close()
+        
+        # 等待5秒，让系统生成响应
+        print("等待5秒，让系统生成响应...")
+        time.sleep(5)
+        
+        # 更新全局存储的会话ID
+        global USER_DATA, CURRENT_USER
+        session, cookies, session_token, _, model_map, _ = USER_DATA[CURRENT_USER]
+        USER_DATA[CURRENT_USER] = (session, cookies, session_token, new_conversation_id, model_map, user_index)
+        
+        # 保存到配置文件
+        update_conversation_id(user_index, new_conversation_id)
+        
+        print(f"对话初始化完成: {new_conversation_id}")
+        return new_conversation_id
+        
+    except Exception as e:
+        print(f"初始化对话失败: {e}")
+        return None
+
+def edit_assistant_message(session, cookies, session_token, conversation_id, message, model_map, model):
+    """编辑对话中索引为1的助手消息"""
+    print("\n===== 编辑助手消息 =====")
+    
+    trace_id, sentry_trace = generate_trace_id()
+    
+    headers = {
+        "accept": "application/json, text/plain, */*",
+        "accept-language": "zh-CN,zh;q=0.9",
+        "baggage": f"sentry-environment=production,sentry-release=975eec6685013679c139fc88db2c48e123d5c604,sentry-public_key=3476ea6df1585dd10e92cdae3a66ff49,sentry-trace_id={trace_id}",
+        "content-type": "application/json",
+        "cookie": cookies,
+        "sec-ch-ua": "\"Chromium\";v=\"116\", \"Not)A;Brand\";v=\"24\", \"Google Chrome\";v=\"116\"",
+        "sec-ch-ua-mobile": "?0",
+        "sec-ch-ua-platform": "\"Windows\"",
+        "sec-fetch-dest": "empty",
+        "sec-fetch-mode": "cors",
+        "sec-fetch-site": "same-origin",
+        "sentry-trace": sentry_trace,
+        "user-agent": random.choice(USER_AGENTS),
+        "x-abacus-org-host": "apps"
+    }
+    
+    if session_token:
+        headers["session-token"] = session_token
+    
+    # 编辑消息负载
+    edit_payload = {
+        "deploymentConversationId": conversation_id,
+        "text": message,
+        "messageIndex": 1,
+        "segmentCounter": 0
+    }
+    
+    try:
+        print(f"编辑助手消息，索引: 1, 对话ID: {conversation_id}")
+        response = session.post(
+            EDIT_CHAT_RESPONSE_URL,
+            headers=headers,
+            json=edit_payload
+        )
+        
+        if response.status_code == 200:
+            data = response.json()
+            if data.get("success", False):
+                print("成功编辑助手消息")
+                return True
+            else:
+                print(f"编辑助手消息失败: {data.get('error', '未知错误')}")
+        else:
+            print(f"编辑助手消息失败，状态码: {response.status_code}")
+        
+        return False
+    except Exception as e:
+        print(f"编辑助手消息时出错: {e}")
+        return False
+
+
+if __name__ == "__main__":
+    # 启动保活线程
+    threading.Thread(target=keep_alive, daemon=True).start()
+    
+    # 加载历史模型调用记录
+    load_model_usage_records()
+    
+    # 获取初始计算点信息
+    get_compute_points()
+    
+    port = int(os.environ.get("PORT", 9876))
+    app.run(port=port, host="0.0.0.0")

templates/dashboard.html

@@ -0,0 +1,1032 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Abacus Chat Proxy - 仪表盘</title>
+    <style>
+        :root {
+            --primary-color: #6f42c1;
+            --secondary-color: #4a32a8;
+            --accent-color: #5e85f1;
+            --bg-color: #0a0a1a;
+            --text-color: #e6e6ff;
+            --card-bg: rgba(30, 30, 60, 0.7);
+            --input-bg: rgba(40, 40, 80, 0.6);
+            --success-color: #36d399;
+            --warning-color: #fbbd23;
+            --error-color: #f87272;
+        }
+        
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+        }
+        
+        body {
+            min-height: 100vh;
+            background-color: var(--bg-color);
+            background-image: 
+                radial-gradient(circle at 20% 35%, rgba(111, 66, 193, 0.15) 0%, transparent 40%),
+                radial-gradient(circle at 80% 10%, rgba(70, 111, 171, 0.1) 0%, transparent 40%);
+            color: var(--text-color);
+            position: relative;
+            overflow-x: hidden;
+        }
+        
+        /* 动态背景网格 */
+        .grid-background {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background-image: linear-gradient(rgba(50, 50, 100, 0.05) 1px, transparent 1px),
+                            linear-gradient(90deg, rgba(50, 50, 100, 0.05) 1px, transparent 1px);
+            background-size: 30px 30px;
+            z-index: -1;
+            animation: grid-move 20s linear infinite;
+        }
+        
+        @keyframes grid-move {
+            0% {
+                transform: translateY(0);
+            }
+            100% {
+                transform: translateY(30px);
+            }
+        }
+        
+        /* 顶部导航栏 */
+        .navbar {
+            padding: 1rem 2rem;
+            background: rgba(15, 15, 30, 0.8);
+            backdrop-filter: blur(10px);
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+            position: sticky;
+            top: 0;
+            z-index: 100;
+        }
+        
+        .navbar-brand {
+            display: flex;
+            align-items: center;
+            text-decoration: none;
+            color: var(--text-color);
+        }
+        
+        .navbar-logo {
+            font-size: 1.5rem;
+            margin-right: 0.75rem;
+            animation: pulse 2s infinite alternate;
+        }
+        
+        @keyframes pulse {
+            0% {
+                transform: scale(1);
+                text-shadow: 0 0 5px rgba(111, 66, 193, 0.5);
+            }
+            100% {
+                transform: scale(1.05);
+                text-shadow: 0 0 15px rgba(111, 66, 193, 0.8);
+            }
+        }
+        
+        .navbar-title {
+            font-size: 1.25rem;
+            font-weight: 600;
+            background: linear-gradient(45deg, #6f42c1, #5181f1);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+        }
+        
+        .navbar-actions {
+            display: flex;
+            gap: 1rem;
+        }
+        
+        .btn-logout {
+            background: rgba(255, 255, 255, 0.1);
+            color: var(--text-color);
+            border: none;
+            padding: 0.5rem 1rem;
+            border-radius: 6px;
+            cursor: pointer;
+            transition: all 0.2s;
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+        }
+        
+        .btn-logout:hover {
+            background: rgba(255, 255, 255, 0.2);
+        }
+        
+        /* 主内容区域 */
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 2rem;
+        }
+        
+        /* 信息卡片样式 */
+        .card {
+            background: var(--card-bg);
+            border-radius: 12px;
+            padding: 1.5rem;
+            margin-bottom: 2rem;
+            box-shadow: 0 8px 32px rgba(0, 0, 0, 0.2);
+            backdrop-filter: blur(8px);
+            border: 1px solid rgba(255, 255, 255, 0.1);
+            animation: card-fade-in 0.6s ease-out;
+        }
+        
+        @keyframes card-fade-in {
+            from {
+                opacity: 0;
+                transform: translateY(20px);
+            }
+            to {
+                opacity: 1;
+                transform: translateY(0);
+            }
+        }
+        
+        .card-header {
+            margin-bottom: 1rem;
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+        }
+        
+        .card-title {
+            font-size: 1.25rem;
+            font-weight: 600;
+            display: flex;
+            align-items: center;
+            gap: 0.75rem;
+        }
+        
+        .card-icon {
+            width: 32px;
+            height: 32px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            background: linear-gradient(45deg, rgba(111, 66, 193, 0.2), rgba(94, 133, 241, 0.2));
+            border-radius: 8px;
+            font-size: 1.25rem;
+        }
+        
+        /* 状态项样式 */
+        .status-item {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            padding: 0.75rem 0;
+            border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+        }
+        
+        .status-item:last-child {
+            border-bottom: none;
+        }
+        
+        .status-label {
+            color: rgba(230, 230, 255, 0.7);
+            font-weight: 500;
+        }
+        
+        .status-value {
+            color: var(--text-color);
+            font-weight: 600;
+        }
+        
+        .status-value.success {
+            color: var(--success-color);
+        }
+        
+        .status-value.warning {
+            color: var(--warning-color);
+        }
+        
+        .status-value.danger {
+            color: var(--error-color);
+        }
+        
+        /* 模型标签 */
+        .models-list {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 0.5rem;
+        }
+        
+        .model-tag {
+            background: rgba(111, 66, 193, 0.2);
+            padding: 0.25rem 0.75rem;
+            border-radius: 16px;
+            font-size: 0.875rem;
+            color: var(--text-color);
+            border: 1px solid rgba(111, 66, 193, 0.3);
+        }
+        
+        /* 表格样式 */
+        .table-container {
+            overflow-x: auto;
+            margin-top: 1rem;
+        }
+        
+        .data-table {
+            width: 100%;
+            border-collapse: collapse;
+            text-align: left;
+        }
+        
+        .data-table th {
+            background-color: rgba(50, 50, 100, 0.3);
+            padding: 0.75rem 1rem;
+            font-weight: 600;
+            color: rgba(230, 230, 255, 0.9);
+            border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+        }
+        
+        .data-table td {
+            padding: 0.75rem 1rem;
+            border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+        }
+        
+        .data-table tbody tr {
+            transition: background-color 0.2s;
+        }
+        
+        .data-table tbody tr:hover {
+            background-color: rgba(50, 50, 100, 0.2);
+        }
+        
+        /* 特殊值样式 */
+        .token-count {
+            font-family: 'Consolas', monospace;
+            color: var(--accent-color);
+            font-weight: bold;
+        }
+        
+        .call-count {
+            font-family: 'Consolas', monospace;
+            color: var(--success-color);
+            font-weight: bold;
+        }
+        
+        .compute-points {
+            font-family: 'Consolas', monospace;
+            color: var(--primary-color);
+            font-weight: bold;
+        }
+        
+        /* 进度条 */
+        .progress-container {
+            width: 100%;
+            height: 8px;
+            background-color: rgba(100, 100, 150, 0.2);
+            border-radius: 4px;
+            margin-top: 0.5rem;
+            overflow: hidden;
+            position: relative;
+        }
+        
+        .progress-bar {
+            height: 100%;
+            border-radius: 4px;
+            background: linear-gradient(90deg, var(--primary-color), var(--accent-color));
+            position: relative;
+            overflow: hidden;
+        }
+        
+        .progress-bar.warning {
+            background: linear-gradient(90deg, #fbbd23, #f59e0b);
+        }
+        
+        .progress-bar.danger {
+            background: linear-gradient(90deg, #f87272, #ef4444);
+        }
+        
+        /* 添加进度条闪光效果 */
+        .progress-bar::after {
+            content: '';
+            position: absolute;
+            top: 0;
+            left: -100%;
+            width: 100%;
+            height: 100%;
+            background: linear-gradient(90deg, 
+                transparent, 
+                rgba(255, 255, 255, 0.2), 
+                transparent);
+            animation: progress-shine 3s infinite;
+        }
+        
+        @keyframes progress-shine {
+            0% {
+                left: -100%;
+            }
+            50%, 100% {
+                left: 100%;
+            }
+        }
+        
+        /* API端点卡片 */
+        .endpoint-item {
+            background: rgba(50, 50, 100, 0.2);
+            padding: 1rem;
+            border-radius: 8px;
+            margin-bottom: 1rem;
+            border-left: 3px solid var(--primary-color);
+        }
+        
+        .endpoint-url {
+            font-family: 'Consolas', monospace;
+            background: rgba(0, 0, 0, 0.2);
+            padding: 0.5rem;
+            border-radius: 4px;
+            margin-top: 0.25rem;
+            display: inline-block;
+            color: var(--text-color);
+            text-decoration: none;
+            transition: all 0.2s;
+        }
+        
+        .endpoint-url:hover {
+            background: rgba(111, 66, 193, 0.3);
+            color: var(--text-color);
+        }
+        
+        /* 响应式布局 */
+        .grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(350px, 1fr));
+            gap: 1.5rem;
+        }
+        
+        /* 页脚 */
+        .footer {
+            text-align: center;
+            padding: 2rem 0;
+            color: rgba(230, 230, 255, 0.5);
+            font-size: 0.9rem;
+            border-top: 1px solid rgba(255, 255, 255, 0.05);
+            margin-top: 2rem;
+        }
+        
+        /* 悬浮图标按钮 */
+        .float-btn {
+            position: fixed;
+            bottom: 2rem;
+            right: 2rem;
+            width: 50px;
+            height: 50px;
+            border-radius: 50%;
+            background: linear-gradient(45deg, var(--primary-color), var(--accent-color));
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            color: white;
+            font-size: 1.5rem;
+            box-shadow: 0 4px 20px rgba(111, 66, 193, 0.4);
+            cursor: pointer;
+            transition: all 0.3s;
+            z-index: 50;
+        }
+        
+        .float-btn:hover {
+            transform: translateY(-5px);
+            box-shadow: 0 8px 25px rgba(111, 66, 193, 0.5);
+        }
+        
+        /* 滚动条美化 */
+        ::-webkit-scrollbar {
+            width: 8px;
+            height: 8px;
+        }
+        
+        ::-webkit-scrollbar-track {
+            background: rgba(50, 50, 100, 0.1);
+        }
+        
+        ::-webkit-scrollbar-thumb {
+            background: rgba(111, 66, 193, 0.5);
+            border-radius: 4px;
+        }
+        
+        ::-webkit-scrollbar-thumb:hover {
+            background: rgba(111, 66, 193, 0.7);
+        }
+        
+        /* 模型统计折叠样式 */
+        .hidden-model {
+            display: none;
+        }
+        
+        .btn-toggle {
+            background: rgba(111, 66, 193, 0.2);
+            border: 1px solid rgba(111, 66, 193, 0.3);
+            border-radius: 4px;
+            padding: 0.3rem 0.7rem;
+            color: rgba(230, 230, 255, 0.9);
+            cursor: pointer;
+            transition: all 0.2s;
+            font-size: 0.85rem;
+            margin-left: auto;
+        }
+        
+        .btn-toggle:hover {
+            background: rgba(111, 66, 193, 0.4);
+        }
+        
+        /* Token注释样式 */
+        .token-note {
+            margin-top: 0.75rem;
+            color: rgba(230, 230, 255, 0.6);
+            font-style: italic;
+            line-height: 1.4;
+            padding: 0.5rem;
+            border-top: 1px dashed rgba(255, 255, 255, 0.1);
+        }
+        
+        .token-model-table {
+            margin-top: 1rem;
+        }
+        
+        /* Token计算方法标签样式 */
+        .token-method {
+            padding: 4px 8px;
+            border-radius: 4px;
+            font-size: 0.85rem;
+            font-weight: 500;
+        }
+        
+        .token-method-exact {
+            background-color: rgba(54, 211, 153, 0.2);
+            color: #36d399;
+        }
+        
+        .token-method-estimate {
+            background-color: rgba(251, 189, 35, 0.2);
+            color: #fbbd23;
+        }
+        
+        /* 时间日期样式 */
+        .datetime {
+            font-family: 'Consolas', monospace;
+            color: rgba(230, 230, 255, 0.8);
+            font-size: 0.9rem;
+        }
+        
+        /* 媒体查询 */
+        @media (max-width: 768px) {
+            .container {
+                padding: 1rem;
+            }
+            
+            .navbar {
+                padding: 1rem;
+            }
+            
+            .card {
+                padding: 1rem;
+            }
+            
+            .grid {
+                grid-template-columns: 1fr;
+            }
+        }
+        
+        .token-model-table td, .token-model-table th {
+            white-space: nowrap;
+        }
+        
+        /* 开关按钮样式 */
+        .toggle-switch-container {
+            display: flex;
+            align-items: center;
+            gap: 10px;
+        }
+        
+        .toggle-switch {
+            position: relative;
+            display: inline-block;
+            width: 50px;
+            height: 24px;
+        }
+        
+        .toggle-switch input {
+            opacity: 0;
+            width: 0;
+            height: 0;
+        }
+        
+        .toggle-slider {
+            position: absolute;
+            cursor: pointer;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            background-color: rgba(100, 100, 150, 0.3);
+            transition: .4s;
+            border-radius: 24px;
+        }
+        
+        .toggle-slider:before {
+            position: absolute;
+            content: "";
+            height: 18px;
+            width: 18px;
+            left: 3px;
+            bottom: 3px;
+            background-color: #e6e6ff;
+            transition: .4s;
+            border-radius: 50%;
+        }
+        
+        input:checked + .toggle-slider {
+            background-color: var(--primary-color);
+        }
+        
+        input:checked + .toggle-slider:before {
+            transform: translateX(26px);
+        }
+        
+        .toggle-status {
+            font-weight: 600;
+        }
+        
+        .info-text {
+            font-size: 0.85rem;
+            color: rgba(230, 230, 255, 0.7);
+        }
+        
+        /* 通知样式 */
+        .notification {
+            position: fixed;
+            top: 20px;
+            right: 20px;
+            padding: 12px 20px;
+            border-radius: 8px;
+            color: white;
+            font-weight: 500;
+            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.3);
+            z-index: 1000;
+            transform: translateY(-20px);
+            opacity: 0;
+            transition: all 0.3s ease;
+            max-width: 300px;
+        }
+        
+        .notification.show {
+            transform: translateY(0);
+            opacity: 1;
+        }
+        
+        .notification.success {
+            background-color: var(--success-color);
+        }
+        
+        .notification.error {
+            background-color: var(--error-color);
+        }
+        
+        .notification.info {
+            background-color: var(--accent-color);
+        }
+        
+        /* 响应式样式 */
+        @media (max-width: 768px) {
+            .container {
+                padding: 1rem;
+            }
+            
+            .navbar {
+                padding: 1rem;
+            }
+            
+            .card {
+                padding: 1rem;
+            }
+            
+            .grid {
+                grid-template-columns: 1fr;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="grid-background"></div>
+    
+    <nav class="navbar">
+        <a href="/" class="navbar-brand">
+            <span class="navbar-logo">🤖</span>
+            <span class="navbar-title">Abacus Chat Proxy</span>
+        </a>
+        <div class="navbar-actions">
+            <a href="/logout" class="btn-logout">
+                <span>退出</span>
+                <span>↗</span>
+            </a>
+        </div>
+    </nav>
+    
+    <div class="container">
+        <div class="card">
+            <div class="card-header">
+                <h2 class="card-title">
+                    <span class="card-icon">📊</span>
+                    系统状态
+                </h2>
+            </div>
+            <div class="status-item">
+                <span class="status-label">服务状态</span>
+                <span class="status-value success">运行中</span>
+            </div>
+            <div class="status-item">
+                <span class="status-label">运行时间</span>
+                <span class="status-value">{{ uptime }}</span>
+            </div>
+            <div class="status-item">
+                <span class="status-label">健康检查次数</span>
+                <span class="status-value">{{ health_checks }}</span>
+            </div>
+            <div class="status-item">
+                <span class="status-label">已配置用户数</span>
+                <span class="status-value">{{ user_count }}</span>
+            </div>
+            <div class="status-item">
+                <span class="status-label">可用模型</span>
+                <div class="models-list">
+                    {% for model in models %}
+                    <span class="model-tag">{{ model }}</span>
+                    {% endfor %}
+                </div>
+            </div>
+        </div>
+        
+        <div class="grid">
+            <div class="card">
+                <div class="card-header">
+                    <h2 class="card-title">
+                        <span class="card-icon">💰</span>
+                        计算点总计
+                    </h2>
+                </div>
+                <div class="status-item">
+                    <span class="status-label">总计算点</span>
+                    <span class="status-value compute-points">{{ compute_points.total|int }}</span>
+                </div>
+                <div class="status-item">
+                    <span class="status-label">已使用</span>
+                    <span class="status-value compute-points">{{ compute_points.used|int }}</span>
+                </div>
+                <div class="status-item">
+                    <span class="status-label">剩余</span>
+                    <span class="status-value compute-points">{{ compute_points.left|int }}</span>
+                </div>
+                <div class="status-item">
+                    <span class="status-label">使用比例</span>
+                    <div style="width: 100%; text-align: right;">
+                        <span class="status-value compute-points {% if compute_points.percentage > 80 %}danger{% elif compute_points.percentage > 50 %}warning{% endif %}">
+                            {{ compute_points.percentage }}%
+                        </span>
+                        <div class="progress-container">
+                            <div class="progress-bar {% if compute_points.percentage > 80 %}danger{% elif compute_points.percentage > 50 %}warning{% endif %}" style="width: {{ compute_points.percentage }}%"></div>
+                        </div>
+                    </div>
+                </div>
+                {% if compute_points.last_update %}
+                <div class="status-item">
+                    <span class="status-label">最后更新时间</span>
+                    <span class="status-value">{{ compute_points.last_update.strftime('%Y-%m-%d %H:%M:%S') }}</span>
+                </div>
+                {% endif %}
+            </div>
+            
+            <div class="card">
+                <div class="card-header">
+                    <h2 class="card-title">
+                        <span class="card-icon">🔍</span>
+                        Token 使用统计
+                    </h2>
+                </div>
+                <div class="status-item">
+                    <span class="status-label">总输入Token</span>
+                    <span class="status-value token-count">{{ total_tokens.prompt|int }}</span>
+                </div>
+                <div class="status-item">
+                    <span class="status-label">总输出Token</span>
+                    <span class="status-value token-count">{{ total_tokens.completion|int }}</span>
+                </div>
+                <div class="token-note">
+                    <small>* 以上数据仅统计通过本代理使用的token数量，不包含在Abacus官网直接使用的token。数值为粗略估计，可能与实际计费有差异。</small>
+                </div>
+                <div class="table-container">
+                    <table class="data-table token-model-table">
+                        <thead>
+                            <tr>
+                                <th>模型</th>
+                                <th>调用次数</th>
+                                <th>输入Token</th>
+                                <th>输出Token</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            {% for model, stats in model_stats.items() %}
+                            <tr>
+                                <td>{{ model }}</td>
+                                <td class="call-count">{{ stats.count }}</td>
+                                <td class="token-count">{{ stats.prompt_tokens|int }}</td>
+                                <td class="token-count">{{ stats.completion_tokens|int }}</td>
+                            </tr>
+                            {% endfor %}
+                        </tbody>
+                    </table>
+                </div>
+            </div>
+        </div>
+        
+        {% if users_compute_points|length > 0 %}
+        <div class="card">
+            <div class="card-header">
+                <h2 class="card-title">
+                    <span class="card-icon">👥</span>
+                    用户计算点详情
+                </h2>
+            </div>
+            <div class="table-container">
+                <table class="data-table">
+                    <thead>
+                        <tr>
+                            <th>用户</th>
+                            <th>总计算点</th>
+                            <th>已使用</th>
+                            <th>剩余</th>
+                            <th>使用比例</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        {% for user in users_compute_points %}
+                        <tr>
+                            <td>用户 {{ user.user_id }}</td>
+                            <td class="compute-points">{{ user.total|int }}</td>
+                            <td class="compute-points">{{ user.used|int }}</td>
+                            <td class="compute-points">{{ user.left|int }}</td>
+                            <td>
+                                <div style="width: 100%; position: relative;">
+                                    <span class="status-value compute-points {% if user.percentage > 80 %}danger{% elif user.percentage > 50 %}warning{% endif %}">
+                                        {{ user.percentage }}%
+                                    </span>
+                                    <div class="progress-container">
+                                        <div class="progress-bar {% if user.percentage > 80 %}danger{% elif user.percentage > 50 %}warning{% endif %}" style="width: {{ user.percentage }}%"></div>
+                                    </div>
+                                </div>
+                            </td>
+                        </tr>
+                        {% endfor %}
+                    </tbody>
+                </table>
+            </div>
+        </div>
+        {% endif %}
+        
+        <div class="card">
+            <div class="card-header">
+                <h2 class="card-title">
+                    <span class="card-icon">📊</span>
+                    计算点使用日志
+                </h2>
+            </div>
+            <div class="table-container">
+                <table class="data-table">
+                    <thead>
+                        <tr>
+                            {% for key, value in compute_points_log.columns.items() %}
+                            <th>{{ value }}</th>
+                            {% endfor %}
+                        </tr>
+                    </thead>
+                    <tbody>
+                        {% for entry in compute_points_log.log %}
+                        <tr>
+                            {% for key, value in compute_points_log.columns.items() %}
+                            <td class="compute-points">{{ entry.get(key, 0) }}</td>
+                            {% endfor %}
+                        </tr>
+                        {% endfor %}
+                    </tbody>
+                </table>
+            </div>
+        </div>
+        
+        <div class="card">
+            <div class="card-header">
+                <h2 class="card-title">
+                    <span class="card-icon">📈</span>
+                    模型调用记录
+                </h2>
+                <button id="toggleModelStats" class="btn-toggle">显示全部</button>
+            </div>
+            <div class="table-container">
+                <table class="data-table">
+                    <thead>
+                        <tr>
+                            <th>调用时间 (北京时间)</th>
+                            <th>模型</th>
+                            <th>输入Token</th>
+                            <th>输出Token</th>
+                            <th>总Token</th>
+                            <th>计算方式</th>
+                            <th>计算点数</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        {% for record in model_usage_records|reverse %}
+                        <tr class="model-row {% if loop.index > 10 %}hidden-model{% endif %}">
+                            <td class="datetime">{{ record.call_time }}</td>
+                            <td>{{ record.model }}</td>
+                            <td class="token-count">{{ record.prompt_tokens }}</td>
+                            <td class="token-count">{{ record.completion_tokens }}</td>
+                            <td>{{ record.prompt_tokens + record.completion_tokens }}</td>
+                            <td>
+                                {% if record.calculation_method == "精确" %}
+                                    <span class="token-method token-method-exact">精确</span>
+                                {% else %}
+                                    <span class="token-method token-method-estimate">估算</span>
+                                {% endif %}
+                            </td>
+                            <td>{{ record.compute_points if record.compute_points is not none and record.compute_points != 0 else 'null' }}</td>
+                        </tr>
+                        {% endfor %}
+                    </tbody>
+                </table>
+                <div class="token-note">
+                    <small>* Token计算方式：<span class="token-method token-method-exact">精确</span> 表示调用官方API精确计算，<span class="token-method token-method-estimate">估算</span> 表示使用gpt-4o模型估算。所有统计数据仅供参考，不代表实际计费标准。</small>
+                </div>
+            </div>
+        </div>
+        
+        <div class="card">
+            <div class="card-header">
+                <h2 class="card-title">
+                    <span class="card-icon">📡</span>
+                    API 端点
+                </h2>
+            </div>
+            <div class="endpoint-item">
+                <p>获取模型列表：</p>
+                {% if space_url %}
+                <a href="{{ space_url }}/v1/models" class="endpoint-url" target="_blank">GET {{ space_url }}/v1/models</a>
+                {% else %}
+                <a href="/v1/models" class="endpoint-url" target="_blank">GET /v1/models</a>
+                {% endif %}
+            </div>
+            <div class="endpoint-item">
+                <p>聊天补全：</p>
+                {% if space_url %}
+                <code class="endpoint-url">POST {{ space_url }}/v1/chat/completions</code>
+                {% else %}
+                <code class="endpoint-url">POST /v1/chat/completions</code>
+                {% endif %}
+            </div>
+            <div class="endpoint-item">
+                <p>健康检查：</p>
+                {% if space_url %}
+                <a href="{{ space_url }}/health" class="endpoint-url" target="_blank">GET {{ space_url }}/health</a>
+                {% else %}
+                <a href="/health" class="endpoint-url" target="_blank">GET /health</a>
+                {% endif %}
+            </div>
+        </div>
+        
+        <div class="footer">
+            <p>© {{ year }} Abacus Chat Proxy. 保持简单，保持可靠。</p>
+        </div>
+    </div>
+    
+    <a href="#" class="float-btn" title="回到顶部">↑</a>
+    
+    <script>
+        // 回到顶部按钮
+        document.querySelector('.float-btn').addEventListener('click', (e) => {
+            e.preventDefault();
+            window.scrollTo({ top: 0, behavior: 'smooth' });
+        });
+        
+        // 显示/隐藏回到顶部按钮
+        window.addEventListener('scroll', () => {
+            const floatBtn = document.querySelector('.float-btn');
+            if (window.pageYOffset > 300) {
+                floatBtn.style.opacity = '1';
+            } else {
+                floatBtn.style.opacity = '0';
+            }
+        });
+        
+        // 初始化隐藏回到顶部按钮
+        document.querySelector('.float-btn').style.opacity = '0';
+        
+        // 模型统计折叠功能
+        const toggleBtn = document.getElementById('toggleModelStats');
+        const hiddenModels = document.querySelectorAll('.hidden-model');
+        let isExpanded = false;
+        
+        if (toggleBtn) {
+            toggleBtn.addEventListener('click', () => {
+                hiddenModels.forEach(model => {
+                    model.classList.toggle('hidden-model');
+                });
+                
+                isExpanded = !isExpanded;
+                toggleBtn.textContent = isExpanded ? '隐藏部分' : '显示全部';
+            });
+        }
+        
+        document.addEventListener('DOMContentLoaded', function() {
+            initCharts();
+            
+            // 显示/隐藏更多模型使用记录
+            const toggleModelStats = document.getElementById('toggleModelStats');
+            if (toggleModelStats) {
+                toggleModelStats.addEventListener('click', function() {
+                    const hiddenRows = document.querySelectorAll('.hidden-model');
+                    hiddenRows.forEach(row => {
+                        row.classList.toggle('show-model');
+                    });
+                    toggleModelStats.textContent = toggleModelStats.textContent === '显示全部' ? '隐藏部分' : '显示全部';
+                });
+            }
+            
+            // 处理计算点数记录开关
+            const computePointToggle = document.getElementById('compute-point-toggle');
+            const computePointStatus = document.getElementById('compute-point-status');
+            
+            if (computePointToggle && computePointStatus) {
+                computePointToggle.addEventListener('change', function() {
+                    const isChecked = this.checked;
+                    computePointStatus.textContent = isChecked ? '开启' : '关闭';
+                    
+                    // 发送更新请求到后端
+                    fetch('/update_compute_point_toggle', {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                        },
+                        body: JSON.stringify({ always_display: isChecked })
+                    })
+                    .then(response => response.json())
+                    .then(data => {
+                        if (data.success) {
+                            // 显示成功提示
+                            showNotification(isChecked ? '已开启计算点数记录功能' : '已关闭计算点数记录功能', 'success');
+                        } else {
+                            // 显示错误提示
+                            showNotification('设置更新失败: ' + data.error, 'error');
+                            // 回滚UI状态
+                            computePointToggle.checked = !isChecked;
+                            computePointStatus.textContent = !isChecked ? '开启' : '关闭';
+                        }
+                    })
+                    .catch(error => {
+                        console.error('更新设置出错:', error);
+                        showNotification('更新设置失败，请重试', 'error');
+                        // 回滚UI状态
+                        computePointToggle.checked = !isChecked;
+                        computePointStatus.textContent = !isChecked ? '开启' : '关闭';
+                    });
+                });
+            }
+        });
+        
+        // 通知函数
+        function showNotification(message, type = 'info') {
+            const notification = document.createElement('div');
+            notification.className = `notification ${type}`;
+            notification.textContent = message;
+            
+            document.body.appendChild(notification);
+            
+            // 显示动画
+            setTimeout(() => {
+                notification.classList.add('show');
+            }, 10);
+            
+            // 3秒后淡出
+            setTimeout(() => {
+                notification.classList.remove('show');
+                setTimeout(() => {
+                    notification.remove();
+                }, 300);
+            }, 3000);
+        }
+    </script>
+</body>
+</html> 

templates/login.html

@@ -0,0 +1,462 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Abacus Chat Proxy - 登录</title>
+    <style>
+        :root {
+            --primary-color: #6f42c1;
+            --secondary-color: #4a32a8;
+            --bg-color: #0a0a1a;
+            --text-color: #e6e6ff;
+            --card-bg: rgba(30, 30, 60, 0.7);
+            --input-bg: rgba(40, 40, 80, 0.6);
+            --success-color: #36d399;
+            --error-color: #f87272;
+        }
+        
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+        }
+        
+        body {
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            background-color: var(--bg-color);
+            background-image: 
+                radial-gradient(circle at 20% 35%, rgba(111, 66, 193, 0.15) 0%, transparent 40%),
+                radial-gradient(circle at 80% 10%, rgba(70, 111, 171, 0.1) 0%, transparent 40%);
+            color: var(--text-color);
+            position: relative;
+            overflow: hidden;
+        }
+        
+        /* 科幻蜘蛛网动画 */
+        .web-container {
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            z-index: -2;
+            opacity: 0.6;
+        }
+        
+        .web {
+            width: 100%;
+            height: 100%;
+        }
+        
+        /* 动态背景网格 */
+        .grid-background {
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background-image: linear-gradient(rgba(50, 50, 100, 0.05) 1px, transparent 1px),
+                              linear-gradient(90deg, rgba(50, 50, 100, 0.05) 1px, transparent 1px);
+            background-size: 30px 30px;
+            z-index: -1;
+            animation: grid-move 20s linear infinite;
+        }
+        
+        @keyframes grid-move {
+            0% {
+                transform: translateY(0);
+            }
+            100% {
+                transform: translateY(30px);
+            }
+        }
+        
+        /* 浮动粒子效果 */
+        .particles {
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            overflow: hidden;
+            z-index: -1;
+        }
+        
+        .particle {
+            position: absolute;
+            display: block;
+            pointer-events: none;
+            width: 6px;
+            height: 6px;
+            background-color: rgba(111, 66, 193, 0.2);
+            border-radius: 50%;
+            animation: float 20s infinite ease-in-out;
+        }
+        
+        @keyframes float {
+            0%, 100% {
+                transform: translateY(0) translateX(0);
+                opacity: 0;
+            }
+            50% {
+                opacity: 0.5;
+            }
+            25%, 75% {
+                transform: translateY(-100px) translateX(50px);
+            }
+        }
+        
+        .login-card {
+            width: 420px;
+            padding: 2.5rem;
+            border-radius: 16px;
+            background: var(--card-bg);
+            box-shadow: 0 8px 32px rgba(0, 0, 0, 0.2);
+            backdrop-filter: blur(8px);
+            border: 1px solid rgba(255, 255, 255, 0.1);
+            z-index: 10;
+            animation: card-fade-in 0.6s ease-out;
+        }
+        
+        @keyframes card-fade-in {
+            from {
+                opacity: 0;
+                transform: translateY(20px);
+            }
+            to {
+                opacity: 1;
+                transform: translateY(0);
+            }
+        }
+        
+        .login-header {
+            text-align: center;
+            margin-bottom: 2rem;
+        }
+        
+        .login-header h1 {
+            font-size: 2rem;
+            font-weight: 600;
+            margin-bottom: 0.5rem;
+            background: linear-gradient(45deg, #6f42c1, #5181f1);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            letter-spacing: 0.5px;
+        }
+        
+        .login-header p {
+            color: rgba(230, 230, 255, 0.7);
+            font-size: 0.95rem;
+        }
+        
+        .space-info {
+            text-align: center;
+            background: rgba(50, 50, 150, 0.2);
+            padding: 0.75rem;
+            border-radius: 8px;
+            margin-bottom: 1.5rem;
+            font-size: 0.9rem;
+            border: 1px solid rgba(111, 66, 193, 0.3);
+        }
+        
+        .space-info a {
+            color: var(--primary-color);
+            text-decoration: none;
+            font-weight: bold;
+            transition: all 0.2s;
+        }
+        
+        .space-info a:hover {
+            text-decoration: underline;
+            color: var(--secondary-color);
+        }
+        
+        .login-form {
+            display: flex;
+            flex-direction: column;
+        }
+        
+        .form-group {
+            margin-bottom: 1.5rem;
+            position: relative;
+        }
+        
+        .form-group label {
+            display: block;
+            margin-bottom: 0.5rem;
+            font-size: 0.9rem;
+            font-weight: 500;
+            color: rgba(230, 230, 255, 0.9);
+        }
+        
+        .form-control {
+            width: 100%;
+            padding: 0.75rem 1rem;
+            font-size: 1rem;
+            line-height: 1.5;
+            color: var(--text-color);
+            background-color: var(--input-bg);
+            border: 1px solid rgba(255, 255, 255, 0.1);
+            border-radius: 8px;
+            transition: all 0.2s ease;
+            outline: none;
+        }
+        
+        .form-control:focus {
+            border-color: var(--primary-color);
+            box-shadow: 0 0 0 3px rgba(111, 66, 193, 0.2);
+        }
+        
+        .btn {
+            display: inline-block;
+            font-weight: 500;
+            text-align: center;
+            vertical-align: middle;
+            cursor: pointer;
+            padding: 0.75rem 1rem;
+            font-size: 1rem;
+            line-height: 1.5;
+            border-radius: 8px;
+            transition: all 0.15s ease-in-out;
+            border: none;
+        }
+        
+        .btn-primary {
+            color: #fff;
+            background: linear-gradient(45deg, var(--primary-color), var(--secondary-color));
+            box-shadow: 0 4px 10px rgba(111, 66, 193, 0.3);
+            position: relative;
+            overflow: hidden;
+        }
+        
+        .btn-primary:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 6px 15px rgba(111, 66, 193, 0.4);
+        }
+        
+        .btn-primary:active {
+            transform: translateY(0);
+        }
+        
+        /* 添加光效效果 */
+        .btn-primary::before {
+            content: '';
+            position: absolute;
+            top: -50%;
+            left: -50%;
+            width: 200%;
+            height: 200%;
+            background: linear-gradient(
+                to bottom right,
+                rgba(255, 255, 255, 0) 0%,
+                rgba(255, 255, 255, 0.1) 50%,
+                rgba(255, 255, 255, 0) 100%
+            );
+            transform: rotate(45deg);
+            animation: btn-shine 3s infinite;
+        }
+        
+        @keyframes btn-shine {
+            0% {
+                left: -50%;
+            }
+            100% {
+                left: 150%;
+            }
+        }
+        
+        .error-message {
+            background-color: rgba(248, 114, 114, 0.2);
+            color: var(--error-color);
+            padding: 0.75rem;
+            border-radius: 6px;
+            margin-bottom: 1.5rem;
+            font-size: 0.9rem;
+            border-left: 3px solid var(--error-color);
+            display: {{ 'block' if error else 'none' }};
+        }
+        
+        .logo {
+            margin-bottom: 1rem;
+            font-size: 3rem;
+            animation: glow 2s infinite alternate;
+        }
+        
+        @keyframes glow {
+            from {
+                text-shadow: 0 0 5px rgba(111, 66, 193, 0.5), 0 0 10px rgba(111, 66, 193, 0.5);
+            }
+            to {
+                text-shadow: 0 0 10px rgba(111, 66, 193, 0.8), 0 0 20px rgba(111, 66, 193, 0.8);
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="grid-background"></div>
+    <div class="particles">
+        <!-- 粒子元素会由JS生成 -->
+    </div>
+    <div class="web-container">
+        <canvas class="web" id="webCanvas"></canvas>
+    </div>
+    
+    <div class="login-card">
+        <div class="login-header">
+            <div class="logo">🤖</div>
+            <h1>Abacus Chat Proxy</h1>
+            <p>请输入访问密码</p>
+        </div>
+        
+        {% if space_url %}
+        <div class="space-info">
+            api接口为{{ space_url }}/v1，请点击 <a href="{{ space_url }}" target="_blank">{{ space_url }}</a> 来登录并查看使用情况，
+        </div>
+        {% endif %}
+        
+        <div class="error-message" id="error-message">
+            {{ error }}
+        </div>
+        
+        <form class="login-form" method="post" action="/login">
+            <div class="form-group">
+                <label for="password">密码</label>
+                <input type="password" class="form-control" id="password" name="password" placeholder="请输入访问密码" required>
+            </div>
+            
+            <button type="submit" class="btn btn-primary">登录</button>
+        </form>
+    </div>
+    
+    <script>
+        // 创建浮动粒子
+        function createParticles() {
+            const particlesContainer = document.querySelector('.particles');
+            const particleCount = 20;
+            
+            for (let i = 0; i < particleCount; i++) {
+                const particle = document.createElement('div');
+                particle.className = 'particle';
+                
+                // 随机位置和大小
+                const size = Math.random() * 5 + 2;
+                const x = Math.random() * 100;
+                const y = Math.random() * 100;
+                
+                particle.style.width = `${size}px`;
+                particle.style.height = `${size}px`;
+                particle.style.left = `${x}%`;
+                particle.style.top = `${y}%`;
+                
+                // 随机动画延迟
+                particle.style.animationDelay = `${Math.random() * 10}s`;
+                particle.style.animationDuration = `${Math.random() * 10 + 10}s`;
+                
+                // 随机透明度
+                particle.style.opacity = Math.random() * 0.5;
+                
+                particlesContainer.appendChild(particle);
+            }
+        }
+        
+        // 科幻蜘蛛网效果
+        function initWebCanvas() {
+            const canvas = document.getElementById('webCanvas');
+            const ctx = canvas.getContext('2d');
+            let width = window.innerWidth;
+            let height = window.innerHeight;
+            
+            // 设置canvas尺寸
+            canvas.width = width;
+            canvas.height = height;
+            
+            // 节点类
+            class Node {
+                constructor(x, y) {
+                    this.x = x;
+                    this.y = y;
+                    this.vx = (Math.random() - 0.5) * 0.5;
+                    this.vy = (Math.random() - 0.5) * 0.5;
+                    this.radius = Math.random() * 2 + 1;
+                }
+                
+                update() {
+                    if (this.x < 0 || this.x > width) this.vx = -this.vx;
+                    if (this.y < 0 || this.y > height) this.vy = -this.vy;
+                    
+                    this.x += this.vx;
+                    this.y += this.vy;
+                }
+                
+                draw() {
+                    ctx.beginPath();
+                    ctx.arc(this.x, this.y, this.radius, 0, Math.PI * 2);
+                    ctx.fillStyle = 'rgba(111, 66, 193, 0.4)';
+                    ctx.fill();
+                }
+            }
+            
+            // 创建节点
+            const nodeCount = Math.floor(width * height / 15000);
+            const nodes = [];
+            
+            for (let i = 0; i < nodeCount; i++) {
+                nodes.push(new Node(Math.random() * width, Math.random() * height));
+            }
+            
+            // 绘制线条
+            function drawWeb() {
+                ctx.clearRect(0, 0, width, height);
+                
+                // 更新节点
+                nodes.forEach(node => {
+                    node.update();
+                    node.draw();
+                });
+                
+                // 绘制连线
+                for (let i = 0; i < nodes.length; i++) {
+                    for (let j = i + 1; j < nodes.length; j++) {
+                        const dx = nodes[i].x - nodes[j].x;
+                        const dy = nodes[i].y - nodes[j].y;
+                        const distance = Math.sqrt(dx * dx + dy * dy);
+                        
+                        if (distance < 150) {
+                            ctx.beginPath();
+                            ctx.moveTo(nodes[i].x, nodes[i].y);
+                            ctx.lineTo(nodes[j].x, nodes[j].y);
+                            ctx.strokeStyle = `rgba(111, 66, 193, ${0.2 * (1 - distance / 150)})`;
+                            ctx.lineWidth = 0.5;
+                            ctx.stroke();
+                        }
+                    }
+                }
+                
+                requestAnimationFrame(drawWeb);
+            }
+            
+            // 监听窗口大小变化
+            window.addEventListener('resize', () => {
+                width = window.innerWidth;
+                height = window.innerHeight;
+                canvas.width = width;
+                canvas.height = height;
+            });
+            
+            // 开始动画
+            drawWeb();
+        }
+        
+        // 页面加载时初始化效果
+        window.addEventListener('load', () => {
+            createParticles();
+            initWebCanvas();
+        });
+    </script>
+</body>
+</html>