Upload 6 files

Dockerfile

@@ -1,24 +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
-
-# 启动命令
+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,114 +1,121 @@
----
-title: Abacus Chat Proxy
-emoji: 🤖
-colorFrom: blue
-colorTo: purple
-sdk: docker
-sdk_version: "3.9"
-app_file: app.py
-pinned: false
----
-
-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请求的代理服务器。
-
-[![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一键部署
-
-1. 点击上方的"Deploy to Hugging Face Spaces"按钮
-2. 登录你的Hugging Face账号（如果还没有，需要注册一个）
-3. 在弹出的页面中设置你的Space名称
-4. 创建完Space后，在Space的Settings -> Repository Secrets中添加以下配置：
-   - `cookie_1`: 你的cookies字符串
-   - `password`: （可选）访问密码
-5. 等待自动部署完成即可
-6. **获取API链接**：部署成功后，点击右上角的三个点按钮，在弹出的选项卡里面点击"Embed this Space"，然后在弹出的"Embed this Space"界面里的"Direct URL"就是你的访问链接，你可以用这个链接调用API和查看使用情况
-
-### 本地运行（已失效）
-
-> ⚠️ 以下本地运行方法已失效，仅作参考。请使用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来存储敏感信息 
+---
+title: Abacus Chat Proxy
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
+sdk: docker
+sdk_version: "3.9"
+app_file: app.py
+pinned: false
+---
+
+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

@@ -39,10 +39,10 @@ USER_NUM = 0
 USER_DATA = []
 CURRENT_USER = -1
 MODELS = set()
-# 添加变量跟踪是否删除上一个对话以及上一个对话ID
-DELETE_CHAT = True # 默认启用删除功能
-PREVIOUS_CONVERSATION_IDS = {} # 用于跟踪每个用户的上一个conversation_id
 
+# 添加记录上一个conversation_id的变量和删除标记
+LAST_CONVERSATION_IDS = [None] * 100  # 为每个用户记录上一个conversation_id
+DELETE_CHAT = True  # 是否在对话结束后删除上一个对话
 
 TRACE_ID = "3042e28b3abf475d8d973c7e904935af"
 SENTRY_TRACE = f"{TRACE_ID}-80d9d2538b2682d0"
@@ -62,7 +62,7 @@ total_tokens = {
 
 # 模型调用记录
 model_usage_records = []  # 每次调用详细记录
-MODEL_USAGE_RECORDS_FILE = "/app/model_usage_records.json"  # 调用记录保存文件，使用/app目录确保HF中持久化
+MODEL_USAGE_RECORDS_FILE = "model_usage_records.json"  # 调用记录保存文件
 
 # 计算点信息
 compute_points = {
@@ -85,6 +85,7 @@ users_compute_points = []
 # 记录启动时间
 START_TIME = datetime.utcnow() + timedelta(hours=8)  # 北京时间
 
+
 # 自定义JSON编码器，处理datetime对象
 class DateTimeEncoder(json.JSONEncoder):
     def default(self, obj):
@@ -93,6 +94,32 @@ class DateTimeEncoder(json.JSONEncoder):
         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:
@@ -113,59 +140,39 @@ def update_conversation_id(user_index, conversation_id):
         print(f"更新conversation_id失败: {e}")
 
 
-def load_config():
-    """从配置文件加载配置"""
-    global USER_DATA, CURRENT_USER
+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:
+        with open("config.json", "r") as f:
             config = json.load(f)
-        
-        # 确保USER_DATA为空列表
-        USER_DATA = []
-        
-        # 如果配置文件中有配置项，则加载
-        if "config" in config and isinstance(config["config"], list):
-            for i, user_config in enumerate(config["config"]):
-                # 获取必要的配置项
-                cookies = user_config.get("cookies", "")
-                models = user_config.get("models", {})
-                
-                # 不再从配置文件读取conversation_id，确保每次启动都使用新会话
-                conversation_id = None
-                
-                # 创建会话对象
-                session = requests.Session()
-                
-                # 刷新token
-                session_token = refresh_token(session, cookies)
-                if not session_token:
-                    print(f"无法获取用户 {i+1} 的token，跳过该用户")
-                    continue
-                
-                try:
-                    # 获取模型映射
-                    model_map, models_set = get_model_map(session, cookies, session_token)
-                    
-                    # 添加到USER_DATA
-                    USER_DATA.append((session, cookies, session_token, conversation_id, model_map, i))
-                    print(f"用户 {i+1} 配置成功，可用模型: {', '.join(models_set)}")
-                except Exception as e:
-                    print(f"配置用户 {i+1} 失败: {e}")
-                    continue
-                
-            print(f"成功加载了 {len(USER_DATA)} 个用户配置")
-            
-            # 设置当前用户为第一个用户
-            CURRENT_USER = 0
-            
-            return True
-        else:
-            print("配置文件格式错误")
-            return False
-    except Exception as e:
-        print(f"加载配置失败: {e}")
-        return False
+        config_list = config.get("config")
+        return config_list
+    except FileNotFoundError:
+        print("未找到config.json文件")
+        return []
+    except json.JSONDecodeError:
+        print("config.json格式错误")
+        return []
 
 
 def get_password():
@@ -245,10 +252,11 @@ def refresh_token(session, cookies):
     }
     
     try:
-        response = requests.post(
+        response = session.post(
             USER_INFO_URL,
             headers=headers,
-            json={}
+            json={},
+            cookies=None
         )
         
         if response.status_code == 200:
@@ -293,10 +301,11 @@ def get_model_map(session, cookies, session_token):
     models_set = set()
     
     try:
-        response = requests.post(
+        response = session.post(
             MODEL_LIST_URL,
             headers=headers,
-            json={}
+            json={},
+            cookies=None
         )
         
         if response.status_code != 200:
@@ -337,56 +346,43 @@ def get_model_map(session, cookies, session_token):
         raise
 
 
-# 获取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
-
-
 def init_session():
     get_password()
-    global USER_NUM, MODELS, USER_DATA
+    global USER_NUM, MODELS, USER_DATA, DELETE_CHAT
     
-    # 调用load_config代替resolve_config
-    if not load_config():
-        print("配置加载失败，退出...")
-        exit(1)
+    # 从环境变量读取是否删除上一个对话的设置
+    delete_chat_env = os.environ.get("DELETE_CHAT", "true").lower()
+    DELETE_CHAT = delete_chat_env in ["true", "1", "yes", "y"]
+    print(f"删除上一个对话设置: {DELETE_CHAT}")
+    
+    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))
+        except Exception as e:
+            print(f"配置用户 {i+1} 失败: {e}")
+            continue
     
-    # 更新USER_NUM和MODELS
     USER_NUM = len(USER_DATA)
     if USER_NUM == 0:
         print("No user available, exiting...")
         exit(1)
     
-    # 获取所有可用模型
-    all_models = set()
-    for session, cookies, session_token, conversation_id, model_map, i in USER_DATA:
-        all_models.update(model_map.keys())
-    
     MODELS = all_models
     print(f"启动完成，共配置 {USER_NUM} 个用户")
 
@@ -404,8 +400,7 @@ def update_cookie(session, cookies):
     return cookies
 
 
-# 初始化会话
-init_session()
+user_data = init_session()
 
 
 @app.route("/v1/models", methods=["GET"])
@@ -505,7 +500,7 @@ def create_conversation(session, cookies, session_token, external_application_id
     }
     
     try:
-        response = requests.post(
+        response = session.post(
             CREATE_CONVERSATION_URL,
             headers=headers,
             json=create_payload
@@ -526,10 +521,10 @@ def create_conversation(session, cookies, session_token, external_application_id
         return None
 
 
-def delete_conversation(session, cookies, session_token, conversation_id):
-    """删除指定的会话"""
+def delete_conversation(session, cookies, session_token, conversation_id, deployment_id="14b2a314cc"):
+    """删除指定的对话"""
     if not conversation_id:
-        print("无法删除会话: conversation_id为空")
+        print("无法删除对话: 缺少conversation_id")
         return False
     
     headers = {
@@ -545,12 +540,12 @@ def delete_conversation(session, cookies, session_token, conversation_id):
         headers["session-token"] = session_token
     
     delete_payload = {
-        "deploymentId": "14b2a314cc",
+        "deploymentId": deployment_id,
         "deploymentConversationId": conversation_id
     }
     
     try:
-        response = requests.post(
+        response = session.post(
             DELETE_CONVERSATION_URL,
             headers=headers,
             json=delete_payload
@@ -559,13 +554,13 @@ def delete_conversation(session, cookies, session_token, conversation_id):
         if response.status_code == 200:
             data = response.json()
             if data.get("success", False):
-                print(f"成功删除conversation: {conversation_id}")
+                print(f"成功删除对话: {conversation_id}")
                 return True
         
-        print(f"删除会话失败: {response.status_code} - {response.text[:100]}")
+        print(f"删除对话失败: {response.status_code} - {response.text[:100]}")
         return False
     except Exception as e:
-        print(f"删除会话时出错: {e}")
+        print(f"删除对话时出错: {e}")
         return False
 
 
@@ -600,8 +595,7 @@ def is_conversation_valid(session, cookies, session_token, conversation_id, mode
     }
     
     try:
-        # 直接发送请求
-        response = requests.post(
+        response = session.post(
             CHAT_URL,
             headers=headers,
             data=json.dumps(payload),
@@ -625,33 +619,42 @@ def is_conversation_valid(session, cookies, session_token, conversation_id, mode
 
 def get_or_create_conversation(session, cookies, session_token, conversation_id, model_map, model, user_index):
     """获取有效的会话ID，如果无效则创建新会话"""
-    # 始终创建新会话，不再检查现有会话是否有效
-    print("正在创建新会话...")
-    
-    if model in model_map and len(model_map[model]) >= 2:
-        external_app_id = model_map[model][0]
-        # 创建会话时需要deployment_id，我们先使用一个固定值
-        # 在实际应用中应从API响应中获取
-        deployment_id = "14b2a314cc"  # 这是从您提供的请求中获取的
-        
-        new_conversation_id = create_conversation(
-            session, cookies, session_token, 
-            external_application_id=external_app_id,
-            deployment_id=deployment_id
-        )
-        
-        if new_conversation_id:
-            # 更新全局存储的会话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)
+    # 修改为总是创建新的conversation_id
+    print("将为每次对话创建新会话")
+    need_create = True
+    
+    # 如果需要创建新会话
+    if need_create:
+        if model in model_map and len(model_map[model]) >= 2:
+            external_app_id = model_map[model][0]
+            # 创建会话时需要deployment_id，我们先使用一个固定值
+            # 在实际应用中应从API响应中获取
+            deployment_id = "14b2a314cc"  # 这是从您提供的请求中获取的
             
-            # 不再保存到配置文件，确保每次都创建新会话
-            # update_conversation_id(user_index, new_conversation_id)
+            new_conversation_id = create_conversation(
+                session, cookies, session_token, 
+                external_application_id=external_app_id,
+                deployment_id=deployment_id
+            )
             
-            return new_conversation_id
+            if new_conversation_id:
+                # 获取当前用户的上一个conversation_id
+                global USER_DATA, CURRENT_USER, LAST_CONVERSATION_IDS, DELETE_CHAT
+                last_conversation_id = LAST_CONVERSATION_IDS[user_index]
+                
+                # 更新全局存储的会话ID
+                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)
+                
+                # 保存新的会话ID为下次调用时的"上一��ID"
+                LAST_CONVERSATION_IDS[user_index] = new_conversation_id
+                
+                return new_conversation_id
     
-    # 如果创建失败，返回原始ID
+    # 如果无法创建，返回原始ID
     return conversation_id
 
 
@@ -666,14 +669,11 @@ def send_message(message, model, think=False):
     """Flua traktado kaj plusendo de mesaĝoj"""
     (session, cookies, session_token, conversation_id, model_map, user_index) = get_user_data()
     
-    # 保存当前用户的上一个对话ID用于稍后删除
-    previous_conversation_id = PREVIOUS_CONVERSATION_IDS.get(user_index)
+    # 获取并保存当前的conversation_id（可能是旧的，用于稍后删除）
+    last_conversation_id = conversation_id
     
-    # 确保有有效的会话ID，现在总是会创建新的
-    new_conversation_id = get_or_create_conversation(session, cookies, session_token, conversation_id, model_map, model, user_index)
-    
-    # 更新当前用户的会话ID记录
-    PREVIOUS_CONVERSATION_IDS[user_index] = new_conversation_id
+    # 确保有有效的会话ID
+    conversation_id = get_or_create_conversation(session, cookies, session_token, conversation_id, model_map, model, user_index)
     
     trace_id, sentry_trace = generate_trace_id()
     
@@ -702,7 +702,7 @@ def send_message(message, model, think=False):
     
     payload = {
         "requestId": str(uuid.uuid4()),
-        "deploymentConversationId": new_conversation_id,
+        "deploymentConversationId": conversation_id,
         "message": message,
         "isDesktop": False,
         "chatConfig": {
@@ -719,7 +719,7 @@ def send_message(message, model, think=False):
         payload["useThinking"] = think
     
     try:
-        response = requests.post(
+        response = session.post(
             CHAT_URL,
             headers=headers,
             data=json.dumps(payload),
@@ -789,9 +789,10 @@ def send_message(message, model, think=False):
             completion_tokens = num_tokens_from_string(completion_buffer.getvalue())
             update_model_stats(model, prompt_tokens, completion_tokens)
             
-            # 在流式传输完成后删除上一个对话（如果存在且启用了删除功能）
-            if DELETE_CHAT and previous_conversation_id and previous_conversation_id != new_conversation_id:
-                delete_conversation(session, cookies, session_token, previous_conversation_id)
+            # 如果需要删除上一个对话且上一个对话ID不为空且与当前不同
+            global DELETE_CHAT, LAST_CONVERSATION_IDS
+            if DELETE_CHAT and last_conversation_id and last_conversation_id != conversation_id:
+                delete_conversation(session, cookies, session_token, last_conversation_id)
         
         return Response(generate(), mimetype="text/event-stream")
     except requests.exceptions.RequestException as e:
@@ -807,14 +808,11 @@ def send_message_non_stream(message, model, think=False):
     """Ne-flua traktado de mesaĝoj"""
     (session, cookies, session_token, conversation_id, model_map, user_index) = get_user_data()
     
-    # 保存当前用户的上一个对话ID用于稍后删除
-    previous_conversation_id = PREVIOUS_CONVERSATION_IDS.get(user_index)
-    
-    # 确保有有效的会话ID，现在总是会创建新的
-    new_conversation_id = get_or_create_conversation(session, cookies, session_token, conversation_id, model_map, model, user_index)
+    # 获取并保存当前的conversation_id（可能是旧的，用于稍后删除）
+    last_conversation_id = conversation_id
     
-    # 更新当前用户的会话ID记录
-    PREVIOUS_CONVERSATION_IDS[user_index] = new_conversation_id
+    # 确保有有效的会话ID
+    conversation_id = get_or_create_conversation(session, cookies, session_token, conversation_id, model_map, model, user_index)
     
     trace_id, sentry_trace = generate_trace_id()
     
@@ -842,7 +840,7 @@ def send_message_non_stream(message, model, think=False):
     
     payload = {
         "requestId": str(uuid.uuid4()),
-        "deploymentConversationId": new_conversation_id,
+        "deploymentConversationId": conversation_id,
         "message": message,
         "isDesktop": False,
         "chatConfig": {
@@ -859,7 +857,7 @@ def send_message_non_stream(message, model, think=False):
         payload["useThinking"] = think
     
     try:
-        response = requests.post(
+        response = session.post(
             CHAT_URL,
             headers=headers,
             data=json.dumps(payload),
@@ -920,9 +918,10 @@ def send_message_non_stream(message, model, think=False):
             completion_tokens = num_tokens_from_string(think_content + response_content)
             update_model_stats(model, prompt_tokens, completion_tokens)
             
-            # 删除上一个对话（如果存在且启用了删除功能）
-            if DELETE_CHAT and previous_conversation_id and previous_conversation_id != new_conversation_id:
-                delete_conversation(session, cookies, session_token, previous_conversation_id)
+            # 如果需要删除上一个对话且上一个对话ID不为空且与当前不同
+            global DELETE_CHAT, LAST_CONVERSATION_IDS
+            if DELETE_CHAT and last_conversation_id and last_conversation_id != conversation_id:
+                delete_conversation(session, cookies, session_token, last_conversation_id)
             
             return jsonify({
                 "id": f"chatcmpl-{str(uuid.uuid4())}",
@@ -957,9 +956,10 @@ def send_message_non_stream(message, model, think=False):
             completion_tokens = num_tokens_from_string(response_content)
             update_model_stats(model, prompt_tokens, completion_tokens)
             
-            # 删除上一个对话（如果存在且启用了删除功能）
-            if DELETE_CHAT and previous_conversation_id and previous_conversation_id != new_conversation_id:
-                delete_conversation(session, cookies, session_token, previous_conversation_id)
+            # 如果需要删除上一个对话且上一个对话ID不为空且与当前不同
+            global DELETE_CHAT, LAST_CONVERSATION_IDS
+            if DELETE_CHAT and last_conversation_id and last_conversation_id != conversation_id:
+                delete_conversation(session, cookies, session_token, last_conversation_id)
             
             return jsonify({
                 "id": f"chatcmpl-{str(uuid.uuid4())}",
@@ -1053,14 +1053,10 @@ def keep_alive():
     """每20分钟进行一次自我健康检查"""
     while True:
         try:
-            # 获取当前端口
-            port = int(os.environ.get("PORT", 9876))
-            # 请求本地健康检查端点
-            requests.get(f"http://127.0.0.1:{port}/health")
+            requests.get("http://127.0.0.1:7860/health")
             time.sleep(1200)  # 20分钟
         except:
-            # 忽略错误，保持运行
-            time.sleep(1200)  # 即使失败也等待20分钟
+            pass  # 忽略错误，保持运行
 
 
 @app.route("/", methods=["GET"])
@@ -1073,61 +1069,64 @@ def index():
     return redirect(url_for('dashboard'))
 
 
-# 使用tiktoken计算字符串的token数量
-def num_tokens_from_string(text):
-    """使用tiktoken计算字符串的token数量"""
+# 获取OpenAI的tokenizer来计算token数
+def num_tokens_from_string(string, model="gpt-3.5-turbo"):
+    """计算文本的token数量"""
     try:
-        # 使用cl100k_base编码器，这是gpt-4和gpt-3.5-turbo使用的编码器
-        enc = tiktoken.get_encoding("cl100k_base")
-        tokens = enc.encode(text)
-        return len(tokens)
+        encoding = tiktoken.encoding_for_model(model)
+        num_tokens = len(encoding.encode(string))
+        print(f"使用tiktoken计算token数: {num_tokens}")
+        return num_tokens
     except Exception as e:
-        # 如果出错，使用字符长度作为粗略估计（大约每4个字符1个token）
-        print(f"计算token数量出错: {e}，使用估算方法")
-        return len(text) // 4
+        # 如果tiktoken不支持模型或者出错，使用简单的估算
+        estimated_tokens = len(string) // 4  # 粗略估计每个token约4个字符
+        print(f"使用估算方法计算token数: {estimated_tokens} (原因: {str(e)})")
+        return estimated_tokens
 
 # 更新模型使用统计
 def update_model_stats(model, prompt_tokens, completion_tokens):
-    """更新模型使用统计数据"""
     global model_usage_stats, total_tokens, model_usage_records
     
-    # 获取北京时间
-    beijing_now = datetime.utcnow() + timedelta(hours=8)
-    call_time = beijing_now.strftime("%Y-%m-%d %H:%M:%S")
+    # 添加调用记录
+    # 获取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": "tiktoken" if any(x in model.lower() for x in ["gpt", "claude"]) or model in ["llama-3", "mistral", "gemma"] else "estimate"
+    }
+    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
+            "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)
     
-    # 更新总token统计
     total_tokens["prompt"] += prompt_tokens
     total_tokens["completion"] += completion_tokens
     total_tokens["total"] += (prompt_tokens + completion_tokens)
-    
-    # 添加使用记录
-    usage_record = {
-        "call_time": call_time,
-        "model": model,
-        "prompt_tokens": prompt_tokens,
-        "completion_tokens": completion_tokens,
-        "total_tokens": prompt_tokens + completion_tokens,
-        "calculation_method": "tiktoken"
-    }
-    model_usage_records.append(usage_record)
-    
-    # 保存记录到文件，确保数据持久化
-    save_model_usage_records()
-    
-    print(f"模型使用记录: {model}, 输入: {prompt_tokens}, 输出: {completion_tokens}, 时间: {call_time}")
 
 
 # 获取计算点信息
@@ -1174,7 +1173,7 @@ def get_compute_points():
                 "cookie": cookies
             }
             
-            response = requests.get(
+            response = session.get(
                 COMPUTE_POINTS_URL,
                 headers=headers
             )
@@ -1248,7 +1247,7 @@ def get_compute_points_log(session, cookies, session_token):
             "cookie": cookies
         }
         
-        response = requests.post(
+        response = session.post(
             COMPUTE_POINTS_LOG_URL,
             headers=headers,
             json={"byLlm": True}
@@ -1330,24 +1329,60 @@ def dashboard():
         space_url=SPACE_URL,  # 传递空间URL
         users_compute_points=users_compute_points,  # 传递用户计算点信息
         model_usage_records=model_usage_records,  # 传递模型使用记录
-        delete_chat=DELETE_CHAT  # 传递删除对话开关状态
+        delete_chat=DELETE_CHAT  # 传递删除对话设置
     )
 
 
-@app.route("/api/set_delete_chat", methods=["POST"])
+# 添加更新删除对话设置的路由
+@app.route("/update_delete_chat_setting", methods=["POST"])
 @require_auth
-def set_delete_chat():
-    """设置是否启用自动删除对话功能"""
-    global DELETE_CHAT
+def update_delete_chat_setting():
     try:
         data = request.get_json()
-        if "delete_chat" in data:
+        if data and "delete_chat" in data:
+            global DELETE_CHAT
             DELETE_CHAT = bool(data["delete_chat"])
-            return jsonify({"success": True, "delete_chat": DELETE_CHAT})
-        return jsonify({"success": False, "error": "Missing delete_chat parameter"}), 400
+            
+            # 将设置保存到环境变量中，以便重启后保留设置
+            os.environ["DELETE_CHAT"] = "true" if DELETE_CHAT else "false"
+            
+            print(f"更新删除对话设置为: {DELETE_CHAT}")
+            return jsonify({"success": True})
+        else:
+            return jsonify({"success": False, "error": "缺少delete_chat参数"})
     except Exception as e:
-        return jsonify({"success": False, "error": str(e)}), 500
+        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()
@@ -1356,58 +1391,10 @@ if SPACE_URL:
     print("注意：Hugging Face生成的URL会自动将空间名称中的下划线(_)替换为连字符(-)")
 
 
-# 定期保存token使用统计
-def auto_save_stats():
-    """定期自动保存token使用统计数据的线程函数"""
-    while True:
-        try:
-            # 每10分钟保存一次
-            time.sleep(600)
-            # 保存模型使用记录
-            save_model_usage_records()
-            print(f"已自动保存模型使用记录: {datetime.utcnow() + timedelta(hours=8)}")
-            
-            # 每小时尝试重新加载记录，确保数据不丢失
-            if datetime.utcnow().minute < 10:  # 每小时的前10分钟执行
-                print("尝试重新加载模型使用记录...")
-                load_model_usage_records()
-        except Exception as e:
-            print(f"自动保存/加载模型使用记录出错: {e}")
-
-
-# 加载模型调用记录
-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}")
-
-
 if __name__ == "__main__":
     # 启动保活线程
     threading.Thread(target=keep_alive, daemon=True).start()
     
-    # 启动自动保存统计数据的线程
-    threading.Thread(target=auto_save_stats, daemon=True).start()
-    
     # 加载历史模型调用记录
     load_model_usage_records()
     

templates/dashboard.html

@@ -3,7 +3,7 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Abacus Chat Service - 仪表盘</title>
+    <title>Abacus Chat Proxy - 仪表盘</title>
     <style>
         :root {
             --primary-color: #6f42c1;
@@ -505,62 +505,122 @@
             }
         }
         
-        /* 开关样式 */
-        .switch {
+        .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;
-            margin-right: 10px;
-            vertical-align: middle;
         }
         
-        .switch input {
+        .toggle-switch input {
             opacity: 0;
             width: 0;
             height: 0;
         }
         
-        .slider {
+        .toggle-slider {
             position: absolute;
             cursor: pointer;
             top: 0;
             left: 0;
             right: 0;
             bottom: 0;
-            background-color: rgba(255, 255, 255, 0.2);
+            background-color: rgba(100, 100, 150, 0.3);
             transition: .4s;
+            border-radius: 24px;
         }
         
-        .slider:before {
+        .toggle-slider:before {
             position: absolute;
             content: "";
             height: 18px;
             width: 18px;
             left: 3px;
             bottom: 3px;
-            background-color: white;
+            background-color: #e6e6ff;
             transition: .4s;
+            border-radius: 50%;
         }
         
-        input:checked + .slider {
+        input:checked + .toggle-slider {
             background-color: var(--primary-color);
         }
         
-        input:focus + .slider {
-            box-shadow: 0 0 1px var(--primary-color);
+        input:checked + .toggle-slider:before {
+            transform: translateX(26px);
         }
         
-        input:checked + .slider:before {
-            transform: translateX(26px);
+        .toggle-status {
+            font-weight: 600;
         }
         
-        .slider.round {
-            border-radius: 24px;
+        .info-text {
+            font-size: 0.85rem;
+            color: rgba(230, 230, 255, 0.7);
         }
         
-        .slider.round:before {
-            border-radius: 50%;
+        /* 通知样式 */
+        .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>
@@ -570,7 +630,7 @@
     <nav class="navbar">
         <a href="/" class="navbar-brand">
             <span class="navbar-logo">🤖</span>
-            <span class="navbar-title">Abacus Chat Service</span>
+            <span class="navbar-title">Abacus Chat Proxy</span>
         </a>
         <div class="navbar-actions">
             <a href="/logout" class="btn-logout">
@@ -584,42 +644,57 @@
         <div class="card">
             <div class="card-header">
                 <h2 class="card-title">
-                    <div class="card-icon">🖥️</div>
-                    系统信息
+                    <span class="card-icon">📊</span>
+                    系统状态
                 </h2>
             </div>
-            <div>
-                <div class="status-item">
-                    <div class="status-label">系统状态</div>
-                    <div class="status-value success">运行中</div>
-                </div>
-                <div class="status-item">
-                    <div class="status-label">运行时间</div>
-                    <div class="status-value">{{ uptime }}</div>
-                </div>
-                <div class="status-item">
-                    <div class="status-label">健康检查次数</div>
-                    <div class="status-value">{{ health_checks }}</div>
-                </div>
-                <div class="status-item">
-                    <div class="status-label">已配置用户数量</div>
-                    <div class="status-value">{{ user_count }}</div>
-                </div>
-                <div class="status-item">
-                    <div class="status-label">可用模型数量</div>
-                    <div class="status-value">{{ models|length }}</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 class="status-item">
-                    <div class="status-label">自动删除对话</div>
-                    <div class="status-value">
-                        <label class="switch">
-                            <input type="checkbox" id="deleteChat" {% if delete_chat %}checked{% endif %}>
-                            <span class="slider round"></span>
-                        </label>
-                        <span id="deleteChatStatus">{{ "已启用" if delete_chat else "已禁用" }}</span>
-                    </div>
+            </div>
+        </div>
+        
+        <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>
+                <div class="toggle-switch-container">
+                    <label class="toggle-switch">
+                        <input type="checkbox" id="delete-chat-toggle" {% if delete_chat %}checked{% endif %}>
+                        <span class="toggle-slider"></span>
+                    </label>
+                    <span class="toggle-status" id="delete-chat-status">{{ "开启" if delete_chat else "关闭" }}</span>
                 </div>
             </div>
+            <div class="status-item">
+                <span class="status-label">设置说明</span>
+                <span class="status-value info-text">开启后，系统将在每次对话完成后自动删除上一次对话，只保留最新对话</span>
+            </div>
         </div>
         
         <div class="grid">
@@ -677,7 +752,7 @@
                     <span class="status-value token-count">{{ total_tokens.completion|int }}</span>
                 </div>
                 <div class="token-note">
-                    <small>* 以上数据仅统计通过本服务使用的token数量，不包含在Abacus官网直接使用的token。数值为粗略估计，可能与实际计费有差异。</small>
+                    <small>* 以上数据仅统计通过本代理使用的token数量，不包含在Abacus官网直接使用的token。数值为粗略估计，可能与实际计费有差异。</small>
                 </div>
                 <div class="table-container">
                     <table class="data-table token-model-table">
@@ -854,7 +929,7 @@
         </div>
         
         <div class="footer">
-            <p>© {{ year }} Abacus Chat Service. 保持简单，保持可靠。</p>
+            <p>© {{ year }} Abacus Chat Proxy. 保持简单，保持可靠。</p>
         </div>
     </div>
     
@@ -880,41 +955,6 @@
         // 初始化隐藏回到顶部按钮
         document.querySelector('.float-btn').style.opacity = '0';
         
-        // 自动删除对话开关功能
-        const deleteChatSwitch = document.getElementById('deleteChat');
-        const deleteChatStatus = document.getElementById('deleteChatStatus');
-        
-        if (deleteChatSwitch) {
-            deleteChatSwitch.addEventListener('change', () => {
-                // 发送API请求更新设置
-                fetch('/api/set_delete_chat', {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json'
-                    },
-                    body: JSON.stringify({
-                        delete_chat: deleteChatSwitch.checked
-                    })
-                })
-                .then(response => response.json())
-                .then(data => {
-                    if (data.success) {
-                        deleteChatStatus.textContent = deleteChatSwitch.checked ? '已启用' : '已禁用';
-                    } else {
-                        alert('更新设置失败: ' + (data.error || '未知错误'));
-                        // 回滚UI状态
-                        deleteChatSwitch.checked = !deleteChatSwitch.checked;
-                    }
-                })
-                .catch(error => {
-                    console.error('更新设置出错:', error);
-                    alert('更新设置出错，请查看控制台');
-                    // 回滚UI状态
-                    deleteChatSwitch.checked = !deleteChatSwitch.checked;
-                });
-            });
-        }
-        
         // 模型统计折叠功能
         const toggleBtn = document.getElementById('toggleModelStats');
         const hiddenModels = document.querySelectorAll('.hidden-model');
@@ -930,6 +970,84 @@
                 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 deleteToggle = document.getElementById('delete-chat-toggle');
+            const deleteStatus = document.getElementById('delete-chat-status');
+            
+            if (deleteToggle && deleteStatus) {
+                deleteToggle.addEventListener('change', function() {
+                    const isChecked = this.checked;
+                    deleteStatus.textContent = isChecked ? '开启' : '关闭';
+                    
+                    // 发送更新请求到后端
+                    fetch('/update_delete_chat_setting', {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                        },
+                        body: JSON.stringify({ delete_chat: isChecked })
+                    })
+                    .then(response => response.json())
+                    .then(data => {
+                        if (data.success) {
+                            // 显示成功提示
+                            showNotification(isChecked ? '已开启自动删除对话功能' : '已关闭自动删除对话功能', 'success');
+                        } else {
+                            // 显示错误提示
+                            showNotification('设置更新失败: ' + data.error, 'error');
+                            // 回滚UI状态
+                            deleteToggle.checked = !isChecked;
+                            deleteStatus.textContent = !isChecked ? '开启' : '关闭';
+                        }
+                    })
+                    .catch(error => {
+                        console.error('更新设置出错:', error);
+                        showNotification('更新设置失败，请重试', 'error');
+                        // 回滚UI状态
+                        deleteToggle.checked = !isChecked;
+                        deleteStatus.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

@@ -1,462 +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>
+<!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>