Update from GitHub Actions

api/handler.go

@@ -4,6 +4,7 @@ import (
 	"augment2api/config"
 	"augment2api/pkg/logger"
 	"bufio"
+	"bytes"
 	"crypto/sha256"
 	"encoding/json"
 	"fmt"
@@ -699,13 +700,37 @@ func ChatCompletionsHandler(c *gin.Context) {
 	handleNonStreamRequest(c, augmentReq, req.Model)
 }
 
+// 异步处理token使用计数
+func asyncIncrementTokenUsage(token string, model string) {
+	go func() {
+		defer func() {
+			if r := recover(); r != nil {
+				logger.Log.WithFields(logrus.Fields{
+					"error": r,
+					"token": token,
+					"model": model,
+				}).Error("system err")
+			}
+		}()
+
+		// 增加token使用计数
+		incrementTokenUsage(token, model)
+	}()
+}
+
 // 处理流式请求
 func handleStreamRequest(c *gin.Context, augmentReq AugmentRequest, model string) {
-	defer cleanupRequestStatus(c)
-
-	c.Header("Content-Type", "text/event-stream")
-	c.Header("Cache-Control", "no-cache")
-	c.Header("Connection", "keep-alive")
+	defer func() {
+		if r := recover(); r != nil {
+			logger.Log.WithFields(logrus.Fields{
+				"error": r,
+				"model": model,
+			}).Error("处理流式请求时发生panic")
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "服务器内部错误"})
+		}
+		// 函数返回时同步清理请求状态
+		cleanupRequestStatus(c)
+	}()
 
 	// 从上下文中获取token和tenant_url
 	tokenInterface, exists := c.Get("token")
@@ -728,8 +753,8 @@ func handleStreamRequest(c *gin.Context, augmentReq AugmentRequest, model string
 		return
 	}
 
-	// 增加token使用计数
-	incrementTokenUsage(token, model)
+	// 异步处理token使用计数
+	asyncIncrementTokenUsage(token, model)
 
 	// 准备请求数据
 	jsonData, err := json.Marshal(augmentReq)
@@ -738,19 +763,35 @@ func handleStreamRequest(c *gin.Context, augmentReq AugmentRequest, model string
 		return
 	}
 
+	// 提取主机部分
+	parsedURL, err := url.Parse(tenant)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "解析租户URL失败"})
+		return
+	}
+	hostName := parsedURL.Host
+
 	// 创建请求
-	req, err := http.NewRequest("POST", tenant+"chat-stream", strings.NewReader(string(jsonData)))
+	requestURL := tenant + "chat-stream"
+	req, err := http.NewRequest("POST", requestURL, bytes.NewReader(jsonData))
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "创建请求失败"})
 		return
 	}
 
+	// 设置请求头
+	req.Header.Set("Host", hostName)
+	req.Header.Set("Content-Length", fmt.Sprintf("%d", len(jsonData)))
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("Authorization", "Bearer "+token)
-	req.Header.Set("User-Agent", "augment.intellij/0.160.0 (Mac OS X; aarch64; 15.2) WebStorm/2024.3.5")
+	req.Header.Set("User-Agent", "augment.intellij/0.184.0 (Mac OS X; aarch64; 15.2) WebStorm/2024.3.5")
 	req.Header.Set("x-api-version", "2")
-	req.Header.Set("x-request-id", uuid.New().String())
-	req.Header.Set("x-request-session-id", uuid.New().String())
+
+	// 生成请求ID和会话ID
+	requestID := uuid.New().String()
+	sessionID := uuid.New().String()
+	req.Header.Set("x-request-id", requestID)
+	req.Header.Set("x-request-session-id", sessionID)
 
 	// 使用createHTTPClient创建客户端
 	client := createHTTPClient()
@@ -783,19 +824,21 @@ func handleStreamRequest(c *gin.Context, augmentReq AugmentRequest, model string
 		}
 
 		// 创建新的请求
-		req, err = http.NewRequest("POST", tenant+"chat-stream", strings.NewReader(string(jsonData)))
+		req, err = http.NewRequest("POST", requestURL, bytes.NewReader(jsonData))
 		if err != nil {
 			c.JSON(http.StatusInternalServerError, gin.H{"error": "创建请求失败"})
 			return
 		}
 
 		// 设置相同的请求头
+		req.Header.Set("Host", hostName)
+		req.Header.Set("Content-Length", fmt.Sprintf("%d", len(jsonData)))
 		req.Header.Set("Content-Type", "application/json")
 		req.Header.Set("Authorization", "Bearer "+token)
-		req.Header.Set("User-Agent", "augment.intellij/0.160.0 (Mac OS X; aarch64; 15.2) WebStorm/2024.3.5")
+		req.Header.Set("User-Agent", "augment.intellij/0.184.0 (Mac OS X; aarch64; 15.2) WebStorm/2024.3.5")
 		req.Header.Set("x-api-version", "2")
-		req.Header.Set("x-request-id", uuid.New().String())
-		req.Header.Set("x-request-session-id", uuid.New().String())
+		req.Header.Set("x-request-id", requestID)
+		req.Header.Set("x-request-session-id", sessionID)
 
 		// 重新发送请求
 		resp, err = client.Do(req)
@@ -817,6 +860,9 @@ func handleStreamRequest(c *gin.Context, augmentReq AugmentRequest, model string
 		return
 	}
 
+	// 异步记录会话事件
+	asyncRecordSessionEvent(token, tenant, requestID, sessionID)
+
 	// 读取并转发响应
 	reader := bufio.NewReader(resp.Body)
 	responseID := fmt.Sprintf("chatcmpl-%d", time.Now().Unix())
@@ -854,19 +900,21 @@ func handleStreamRequest(c *gin.Context, augmentReq AugmentRequest, model string
 				}
 
 				// 创建新的请求
-				req, err = http.NewRequest("POST", tenant+"chat-stream", strings.NewReader(string(jsonData)))
+				req, err = http.NewRequest("POST", requestURL, bytes.NewReader(jsonData))
 				if err != nil {
 					c.JSON(http.StatusInternalServerError, gin.H{"error": "创建请求失败"})
 					return
 				}
 
 				// 设置相同的请求头
+				req.Header.Set("Host", hostName)
+				req.Header.Set("Content-Length", fmt.Sprintf("%d", len(jsonData)))
 				req.Header.Set("Content-Type", "application/json")
 				req.Header.Set("Authorization", "Bearer "+token)
-				req.Header.Set("User-Agent", "augment.intellij/0.160.0 (Mac OS X; aarch64; 15.2) WebStorm/2024.3.5")
+				req.Header.Set("User-Agent", "augment.intellij/0.184.0 (Mac OS X; aarch64; 15.2) WebStorm/2024.3.5")
 				req.Header.Set("x-api-version", "2")
-				req.Header.Set("x-request-id", uuid.New().String())
-				req.Header.Set("x-request-session-id", uuid.New().String())
+				req.Header.Set("x-request-id", requestID)
+				req.Header.Set("x-request-session-id", sessionID)
 
 				// 重新发送请求
 				resp, err = client.Do(req)
@@ -989,19 +1037,21 @@ func handleStreamRequest(c *gin.Context, augmentReq AugmentRequest, model string
 		}
 
 		// 创建新的请求
-		req, err = http.NewRequest("POST", tenant+"chat-stream", strings.NewReader(string(jsonData)))
+		req, err = http.NewRequest("POST", requestURL, bytes.NewReader(jsonData))
 		if err != nil {
 			c.JSON(http.StatusInternalServerError, gin.H{"error": "创建请求失败"})
 			return
 		}
 
 		// 设置相同的请求头
+		req.Header.Set("Host", hostName)
+		req.Header.Set("Content-Length", fmt.Sprintf("%d", len(jsonData)))
 		req.Header.Set("Content-Type", "application/json")
 		req.Header.Set("Authorization", "Bearer "+token)
-		req.Header.Set("User-Agent", "augment.intellij/0.160.0 (Mac OS X; aarch64; 15.2) WebStorm/2024.3.5")
+		req.Header.Set("User-Agent", "augment.intellij/0.184.0 (Mac OS X; aarch64; 15.2) WebStorm/2024.3.5")
 		req.Header.Set("x-api-version", "2")
-		req.Header.Set("x-request-id", uuid.New().String())
-		req.Header.Set("x-request-session-id", uuid.New().String())
+		req.Header.Set("x-request-id", requestID)
+		req.Header.Set("x-request-session-id", sessionID)
 
 		// 重新发送请求
 		resp, err = client.Do(req)
@@ -1022,6 +1072,9 @@ func handleStreamRequest(c *gin.Context, augmentReq AugmentRequest, model string
 			return
 		}
 
+		// 异步记录会话事件
+		asyncRecordSessionEvent(token, tenant, requestID, sessionID)
+
 		// 读取并转发响应
 		reader = bufio.NewReader(resp.Body)
 		responseID = fmt.Sprintf("chatcmpl-%d", time.Now().Unix())
@@ -1117,7 +1170,16 @@ func estimateTokenCount(text string) int {
 
 // 处理非流式请求
 func handleNonStreamRequest(c *gin.Context, augmentReq AugmentRequest, model string) {
-	defer cleanupRequestStatus(c)
+	defer func() {
+		if r := recover(); r != nil {
+			logger.Log.WithFields(logrus.Fields{
+				"error": r,
+				"model": model,
+			}).Error("处理非流式请求时发生panic")
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "服务器内部错误"})
+		}
+		cleanupRequestStatus(c) // 确保在函数返回时同步清理请求状态
+	}()
 
 	// 从上下文中获取token和tenant_url
 	tokenInterface, exists := c.Get("token")
@@ -1140,8 +1202,8 @@ func handleNonStreamRequest(c *gin.Context, augmentReq AugmentRequest, model str
 		return
 	}
 
-	// 增加token使用计数
-	incrementTokenUsage(token, model)
+	// 异步处理token使用计数
+	asyncIncrementTokenUsage(token, model)
 
 	// 准备请求数据
 	jsonData, err := json.Marshal(augmentReq)
@@ -1150,19 +1212,35 @@ func handleNonStreamRequest(c *gin.Context, augmentReq AugmentRequest, model str
 		return
 	}
 
-	// 打印请求参数
-	//log.Printf("发送到远程接口的请求参数: %s", string(jsonData))
+	// 提取主机部分
+	parsedURL, err := url.Parse(tenant)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "解析租户URL失败"})
+		return
+	}
+	hostName := parsedURL.Host
 
-	// 创建请求 - 使用获取到的tenant_url
-	req, err := http.NewRequest("POST", tenant+"chat-stream", strings.NewReader(string(jsonData)))
+	// 创建请求
+	requestURL := tenant + "chat-stream"
+	req, err := http.NewRequest("POST", requestURL, bytes.NewReader(jsonData))
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "创建请求失败"})
 		return
 	}
 
+	// 设置请求头
+	req.Header.Set("Host", hostName)
+	req.Header.Set("Content-Length", fmt.Sprintf("%d", len(jsonData)))
 	req.Header.Set("Content-Type", "application/json")
-	// 使用获取到的token
 	req.Header.Set("Authorization", "Bearer "+token)
+	req.Header.Set("User-Agent", "augment.intellij/0.184.0 (Mac OS X; aarch64; 15.2) WebStorm/2024.3.5")
+	req.Header.Set("x-api-version", "2")
+
+	// 生成请求ID和会话ID
+	requestID := uuid.New().String()
+	sessionID := uuid.New().String()
+	req.Header.Set("x-request-id", requestID)
+	req.Header.Set("x-request-session-id", sessionID)
 
 	client := createHTTPClient()
 	resp, err := client.Do(req)
@@ -1183,6 +1261,9 @@ func handleNonStreamRequest(c *gin.Context, augmentReq AugmentRequest, model str
 		return
 	}
 
+	// 异步记录会话事件
+	asyncRecordSessionEvent(token, tenant, requestID, sessionID)
+
 	// 读取完整响应
 	reader := bufio.NewReader(resp.Body)
 	var fullText string
@@ -1269,6 +1350,14 @@ func handleNonStreamRequest(c *gin.Context, augmentReq AugmentRequest, model str
 
 // 清理请求状态
 func cleanupRequestStatus(c *gin.Context) {
+	defer func() {
+		if r := recover(); r != nil {
+			logger.Log.WithFields(logrus.Fields{
+				"error": r,
+			}).Error("清理请求状态时发生panic")
+		}
+	}()
+
 	// 获取锁和 token
 	lockInterface, exists := c.Get("token_lock")
 	if !exists {
@@ -1300,7 +1389,9 @@ func cleanupRequestStatus(c *gin.Context) {
 	defer lock.Unlock()
 
 	if err != nil {
-		log.Printf("清理请求状态失败: %v", err)
+		logger.Log.WithFields(logrus.Fields{
+			"error": err.Error(),
+		}).Error("清理请求状态失败")
 		return
 	}
 }
@@ -1326,6 +1417,93 @@ func createHTTPClient() *http.Client {
 	return client
 }
 
+// 异步记录用户会话事件
+func asyncRecordSessionEvent(token, tenantURL, requestID, sessionID string) {
+	go func() {
+		defer func() {
+			if r := recover(); r != nil {
+				logger.Log.WithFields(logrus.Fields{
+					"error":      r,
+					"token":      token,
+					"tenant_url": tenantURL,
+				}).Error("记录会话事件时发生panic")
+			}
+		}()
+
+		// 提取主机部分
+		parsedURL, err := url.Parse(tenantURL)
+		if err != nil {
+			logger.Log.WithFields(logrus.Fields{
+				"error":      err.Error(),
+				"tenant_url": tenantURL,
+			}).Error("解析租户URL失败")
+			return
+		}
+		hostName := parsedURL.Host
+
+		// 构建事件数据
+		currentTime := time.Now()
+		eventData := map[string]interface{}{
+			"events": []map[string]interface{}{
+				{
+					"event_name":      "used-chat",
+					"event_time_sec":  currentTime.Unix(),
+					"event_time_nsec": currentTime.UnixNano() % 1000000000,
+				},
+			},
+		}
+
+		// 序列化请求数据
+		jsonData, err := json.Marshal(eventData)
+		if err != nil {
+			logger.Log.WithFields(logrus.Fields{
+				"error": err.Error(),
+			}).Error("序列化事件数据失败")
+			return
+		}
+
+		// 构建请求URL
+		requestURL := tenantURL + "record-onboarding-session-event"
+
+		// 创建请求
+		req, err := http.NewRequest("POST", requestURL, bytes.NewReader(jsonData))
+		if err != nil {
+			logger.Log.WithFields(logrus.Fields{
+				"error": err.Error(),
+			}).Error("创建记录事件请求失败")
+			return
+		}
+
+		// 设置请求头
+		req.Header.Set("Host", hostName)
+		req.Header.Set("Content-Length", fmt.Sprintf("%d", len(jsonData)))
+		req.Header.Set("Content-Type", "application/json")
+		req.Header.Set("Authorization", "Bearer "+token)
+		req.Header.Set("User-Agent", "augment.intellij/0.184.0 (Mac OS X; aarch64; 15.2) WebStorm/2024.3.5")
+		req.Header.Set("x-api-version", "2")
+		req.Header.Set("x-request-id", requestID)
+		req.Header.Set("x-request-session-id", sessionID)
+		req.Header.Set("Accept-Charset", "UTF-8")
+
+		// 发送请求
+		client := createHTTPClient()
+		resp, err := client.Do(req)
+		if err != nil {
+			logger.Log.WithFields(logrus.Fields{
+				"error": err.Error(),
+			}).Error("发送记录事件请求失败")
+			return
+		}
+		defer resp.Body.Close()
+
+		// 记录响应状态
+		logger.Log.WithFields(logrus.Fields{
+			"status_code": resp.StatusCode,
+			"tenant_url":  tenantURL,
+		}).Info("记录会话事件完成")
+	}()
+}
+
 // 在处理聊天请求时增加token使用计数
 func incrementTokenUsage(token string, model string) {
 	// 先将模型名称转换为小写
@@ -1339,6 +1517,11 @@ func incrementTokenUsage(token string, model string) {
 		countKey = "token_usage_agent:" + token
 	} else {
 		countKey = "token_usage:" + token // 默认键
+		// 非特定结尾的模型，增加chat计数
+		err := config.RedisIncr("token_usage_chat:" + token)
+		if err != nil {
+			logger.Log.Error("增加token chat使用计数失败: %v", err)
+		}
 	}
 
 	// 使用Redis的INCR命令增加计数

api/token_handler.go

@@ -85,41 +85,76 @@ func GetRedisTokenHandler(c *gin.Context) {
 		return
 	}
 
-	// 构建token列表
-	var tokenList []TokenInfo
+	// 使用并发方式批量获取token信息
+	var wg sync.WaitGroup
+	tokenList := make([]TokenInfo, 0, len(keys))
+	tokenListChan := make(chan TokenInfo, len(keys))
+	concurrencyLimit := 10 // 限制并发数
+	sem := make(chan struct{}, concurrencyLimit)
+
 	for _, key := range keys {
 		// 从key中提取token (格式: "token:{token}")
 		token := key[6:] // 去掉前缀 "token:"
 
-		// 获取对应的tenant_url
-		tenantURL, err := config.RedisHGet(key, "tenant_url")
-		if err != nil {
-			continue // 跳过无效的token
-		}
+		wg.Add(1)
+		sem <- struct{}{} // 获取信号量
 
-		// 获取token状态
-		status, err := config.RedisHGet(key, "status")
-		if err == nil && status == "disabled" {
-			continue // 跳过被标记为不可用的token
-		}
+		go func(tokenKey string, tokenValue string) {
+			defer wg.Done()
+			defer func() { <-sem }() // 释放信号量
 
-		// 获取备注信息
-		remark, _ := config.RedisHGet(key, "remark")
-
-		// 获取token的冷却状态
-		coolStatus, _ := GetTokenCoolStatus(token)
-
-		// 在获取token信息时，同时获取对话次数、备注和冷却状态
-		tokenList = append(tokenList, TokenInfo{
-			Token:           token,
-			TenantURL:       tenantURL,
-			UsageCount:      getTokenUsageCount(token),
-			ChatUsageCount:  getTokenChatUsageCount(token),
-			AgentUsageCount: getTokenAgentUsageCount(token),
-			Remark:          remark,
-			InCool:          coolStatus.InCool,
-			CoolEnd:         coolStatus.CoolEnd,
-		})
+			// 使用HGETALL一次性获取所有字段，减少网络往返
+			fields, err := config.RedisHGetAll(tokenKey)
+			if err != nil {
+				return // 跳过无效的token
+			}
+
+			// 检查必要字段
+			tenantURL, ok := fields["tenant_url"]
+			if !ok {
+				return
+			}
+
+			// 检查token状态
+			status, ok := fields["status"]
+			if ok && status == "disabled" {
+				return // 跳过被标记为不可用的token
+			}
+
+			// 获取备注信息
+			remark := fields["remark"]
+
+			// 获取token的冷却状态 (异步获取)
+			coolStatus, _ := GetTokenCoolStatus(tokenValue)
+
+			// 获取使用次数 (可以考虑将这些计数缓存在Redis中)
+			chatCount := getTokenChatUsageCount(tokenValue)
+			agentCount := getTokenAgentUsageCount(tokenValue)
+			totalCount := chatCount + agentCount
+
+			// 构建token信息并发送到channel
+			tokenListChan <- TokenInfo{
+				Token:           tokenValue,
+				TenantURL:       tenantURL,
+				UsageCount:      totalCount,
+				ChatUsageCount:  chatCount,
+				AgentUsageCount: agentCount,
+				Remark:          remark,
+				InCool:          coolStatus.InCool,
+				CoolEnd:         coolStatus.CoolEnd,
+			}
+		}(key, token)
+	}
+
+	// 启动一个goroutine来收集结果
+	go func() {
+		wg.Wait()
+		close(tokenListChan)
+	}()
+
+	// 从channel中收集结果
+	for info := range tokenListChan {
+		tokenList = append(tokenList, info)
 	}
 
 	// 计算总页数和分页数据

config/redis.go

@@ -105,3 +105,9 @@ func RedisHExists(key, field string) (bool, error) {
 	ctx := context.Background()
 	return RDB.HExists(ctx, key, field).Result()
 }
+
+// RedisHGetAll 获取哈希表中的所有字段和值
+func RedisHGetAll(key string) (map[string]string, error) {
+	ctx := context.Background()
+	return RDB.HGetAll(ctx, key).Result()
+}

docker-compose.yml

@@ -6,9 +6,9 @@ services:
     restart: always
     volumes:
       - redis_data:/data
-    command: redis-server --requirepass $${REDIS_PASSWORD:-yourpassword}
+    command: redis-server --requirepass ${REDIS_PASSWORD:-yourpassword}
     healthcheck:
-      test: ["CMD", "redis-cli", "-a", "$${REDIS_PASSWORD:-yourpassword}", "ping"]
+      test: ["CMD", "redis-cli", "-a", "${REDIS_PASSWORD:-yourpassword}", "ping"]
       interval: 5s
       timeout: 3s
       retries: 5
@@ -35,4 +35,4 @@ volumes:
 
 networks:
   default:
-    driver: bridge 
+    driver: bridge 

templates/admin.html

@@ -248,9 +248,34 @@
 
         /* 添加token列表容器样式，使其可滚动 */
         .token-list-container {
-            flex: 1;
+            max-height: calc(100vh - 250px);
             overflow-y: auto;
-            margin-bottom: 15px;
+            overflow-x: hidden;
+            padding-right: 10px;
+            position: relative;
+        }
+
+        /* 添加列表加载效果 */
+        .token-list-loading {
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            padding: 20px;
+            color: var(--text-secondary);
+        }
+        
+        .token-list-loading .spinner {
+            width: 20px;
+            height: 20px;
+            border: 2px solid var(--border-color);
+            border-top-color: var(--primary-color);
+            border-radius: 50%;
+            animation: spin 1s linear infinite;
+            margin-right: 10px;
+        }
+        
+        @keyframes spin {
+            to { transform: rotate(360deg); }
         }
 
         /* 面板标题样式优化 */
@@ -1019,19 +1044,71 @@
                 fetchCurrentToken();
             });
             
+            // 添加节流功能，避免短时间内多次请求
+            function throttle(func, delay) {
+                let lastCall = 0;
+                return function(...args) {
+                    const now = new Date().getTime();
+                    if (now - lastCall < delay) {
+                        return;
+                    }
+                    lastCall = now;
+                    return func.apply(this, args);
+                };
+            }
+            
+            // 添加简单的缓存机制
+            const tokenCache = {
+                data: {},
+                timestamp: 0,
+                ttl: 10000, // 缓存有效期10秒
+                
+                get: function(key) {
+                    const now = new Date().getTime();
+                    if (this.data[key] && (now - this.timestamp < this.ttl)) {
+                        return this.data[key];
+                    }
+                    return null;
+                },
+                
+                set: function(key, data) {
+                    this.data[key] = data;
+                    this.timestamp = new Date().getTime();
+                }
+            };
+            
             // 修改获取当前Token列表函数，使用后端分页
-            function fetchCurrentToken() {
+            const fetchCurrentToken = throttle(function() {
                 // 显示加载动画
                 const refreshBtn = document.getElementById('refresh-token');
                 const tokenListElement = document.getElementById('token-list');
                 refreshBtn.classList.add('loading');
                 
+                // 构造缓存键
+                const cacheKey = `tokens_${currentPage}_${pageSize}`;
+                
+                // 检查缓存
+                const cachedData = tokenCache.get(cacheKey);
+                if (cachedData && !forceFresh) {
+                    // 使用缓存数据
+                    allTokens = cachedData.tokens || [];
+                    renderTokenList(cachedData.total || 0, cachedData.total_pages || 1);
+                    refreshBtn.classList.remove('loading');
+                    return;
+                }
+                
+                // 重置强制刷新标志
+                forceFresh = false;
+                
                 // 设置超时处理
                 const timeoutId = setTimeout(() => {
                     refreshBtn.classList.remove('loading');
                     tokenListElement.innerHTML = '<div class="error" style="display:block;">请求超时,请重试</div>';
                 }, 10000); // 10秒超时
                 
+                // 添加性能标记
+                const startTime = performance.now();
+                
                 fetch(`/api/tokens?page=${currentPage}&page_size=${pageSize}`)
                 .then(response => {
                     if (!response.ok) {
@@ -1042,7 +1119,14 @@
                 .then(data => {
                     clearTimeout(timeoutId); // 清除超时定时器
                     
+                    // 记录加载时间
+                    const loadTime = performance.now() - startTime;
+                    console.log(`Token列表加载耗时: ${loadTime.toFixed(2)}ms`);
+                    
                     if (data.status === 'success') {
+                        // 缓存结果
+                        tokenCache.set(cacheKey, data);
+                        
                         // 使用后端返回的token列表
                         allTokens = data.tokens || [];
                         
@@ -1066,8 +1150,17 @@
                 .finally(() => {
                     refreshBtn.classList.remove('loading');
                 });
-            }
+            }, 300); // 300ms节流
             
+            // 添加强制刷新标记
+            let forceFresh = false;
+            
+            // 刷新Token按钮事件
+            document.getElementById('refresh-token').addEventListener('click', function() {
+                forceFresh = true; // 强制刷新，忽略缓存
+                fetchCurrentToken();
+            });
+
             // 修改渲染token列表函数，使用后端返回的分页信息
             function renderTokenList(totalItems, totalPages) {
                 const tokenListElement = document.getElementById('token-list');
@@ -1092,17 +1185,91 @@
                 prevPageBtn.disabled = currentPage === 1;
                 nextPageBtn.disabled = currentPage === totalPages;
                 
-                // 创建token列表容器
-                tokenListElement.innerHTML = '<div class="token-list"></div>';
-                const listContainer = tokenListElement.querySelector('.token-list');
+                // 检查token数量，如果过多则使用分批渲染
+                const useBatchRendering = allTokens.length > 50;
+                
+                // 优化：使用文档片段减少DOM重绘次数
+                const fragment = document.createDocumentFragment();
+                const tokenList = document.createElement('div');
+                tokenList.className = 'token-list';
+                fragment.appendChild(tokenList);
+                
+                // 清空现有内容并显示加载中
+                tokenListElement.innerHTML = '';
+                
+                if (useBatchRendering) {
+                    // 先显示加载状态
+                    const loadingEl = document.createElement('div');
+                    loadingEl.className = 'token-list-loading';
+                    loadingEl.innerHTML = '<div class="spinner"></div> <span>正在加载Token列表...</span>';
+                    tokenListElement.appendChild(loadingEl);
+                    
+                    // 使用requestAnimationFrame和分批处理来渲染大列表
+                    setTimeout(() => {
+                        renderTokensBatch(tokenList, 0, 20);
+                    }, 10);
+                    
+                    function renderTokensBatch(container, startIdx, batchSize) {
+                        // 移除加载状态
+                        const loadingEl = tokenListElement.querySelector('.token-list-loading');
+                        if (loadingEl) {
+                            loadingEl.remove();
+                        }
+                        
+                        // 添加当前批次的token
+                        const endIdx = Math.min(startIdx + batchSize, allTokens.length);
+                        
+                        for (let i = startIdx; i < endIdx; i++) {
+                            const tokenItem = createTokenItem(allTokens[i], i);
+                            container.appendChild(tokenItem);
+                        }
+                        
+                        // 如果还有更多token待渲染，安排下一批
+                        if (endIdx < allTokens.length) {
+                            // 添加临时"加载更多"指示器
+                            if (startIdx === 0) { // 只在第一批后添加DOM
+                                tokenListElement.appendChild(fragment);
+                            }
+                            
+                            setTimeout(() => {
+                                requestAnimationFrame(() => {
+                                    renderTokensBatch(container, endIdx, batchSize);
+                                });
+                            }, 0);
+                        } else {
+                            // 全部渲染完成，如果是第一批，添加到DOM
+                            if (startIdx === 0) {
+                                tokenListElement.appendChild(fragment);
+                            }
+                            
+                            // 应用Token可见性
+                            if (!tokenVisible) {
+                                applyTokenVisibility();
+                            }
+                        }
+                    }
+                } else {
+                    // 直接渲染所有token
+                    allTokens.forEach((tokenInfo, index) => {
+                        const tokenItem = createTokenItem(tokenInfo, index);
+                        tokenList.appendChild(tokenItem);
+                    });
+                    
+                    // 一次性替换DOM内容
+                    tokenListElement.appendChild(fragment);
+                    
+                    // 应用Token可见性
+                    if (!tokenVisible) {
+                        applyTokenVisibility();
+                    }
+                }
                 
-                // 添加每个token项
-                allTokens.forEach((tokenInfo, index) => {
+                // 辅助函数：创建token项元素
+                function createTokenItem(tokenInfo, index) {
                     // 计算在当前页中的索引
                     const displayIndex = index + 1 + (currentPage - 1) * pageSize;
                     
                     // 获取使用次数并设置样式类
-                    const usageCount = tokenInfo.usage_count || 0;
                     const chatUsageCount = tokenInfo.chat_usage_count || 0;
                     const agentUsageCount = tokenInfo.agent_usage_count || 0;
                     let usageClass = '';
@@ -1116,11 +1283,11 @@
                         usageClass = 'high';
                     }
                     
-                    // 显示完整token，不再截断
                     const tokenItem = document.createElement('div');
                     tokenItem.className = 'token-item';
+                    tokenItem.dataset.index = index;
                     tokenItem.innerHTML = `
-                        <div class="token-header">
+                        <div class="token-header" data-index="${index}">
                             <div class="token-number">${displayIndex}</div>
                             <div class="token-summary">
                                 ${tokenInfo.token}
@@ -1149,91 +1316,110 @@
                         </div>
                     `;
                     
-                    listContainer.appendChild(tokenItem);
-                    
-                    // 添加事件处理
-                    const header = tokenItem.querySelector('.token-header');
-                    const details = tokenItem.querySelector('.token-details');
-                    const toggle = tokenItem.querySelector('.token-toggle');
-                    const remarkSpan = tokenItem.querySelector('.token-remark');
-                    
-                    // 为备注添加点击事件
-                    remarkSpan.addEventListener('click', function(e) {
-                        e.stopPropagation(); // 阻止事件冒泡到header
-                        
-                        const token = this.dataset.token;
-                        const currentRemark = this.dataset.remark;
-                        
-                        // 创建弹出层
-                        const modal = document.createElement('div');
-                        modal.className = 'remark-input-modal';
+                    return tokenItem;
+                }
+                
+                // 使用事件委托处理所有点击事件
+                if (!document.querySelector('.token-list').hasEventListener) {
+                    document.querySelector('.token-list').addEventListener('click', function(e) {
+                        // 处理折叠/展开
+                        const headerElement = e.target.closest('.token-header');
+                        if (headerElement) {
+                            const tokenItem = headerElement.closest('.token-item');
+                            const details = tokenItem.querySelector('.token-details');
+                            const toggle = tokenItem.querySelector('.token-toggle');
+                            
+                            details.classList.toggle('open');
+                            toggle.classList.toggle('open');
+                        }
                         
-                        modal.innerHTML = `
-                            <div class="remark-input-container">
-                                <h3>编辑备注</h3>
-                                <input type="text" maxlength="30" placeholder="请输入备注（30字以内）" value="${currentRemark}">
-                                <div class="char-count"><span>${currentRemark.length}</span>/30</div>
-                                <div class="remark-input-actions">
-                                    <button class="secondary" onclick="this.closest('.remark-input-modal').remove()">取消</button>
-                                    <button class="save-remark" data-token="${token}">保存</button>
+                        // 处理备注点击
+                        const remarkElement = e.target.closest('.token-remark');
+                        if (remarkElement) {
+                            e.stopPropagation(); // 阻止事件冒泡到header
+                            
+                            const token = remarkElement.dataset.token;
+                            const currentRemark = remarkElement.dataset.remark;
+                            
+                            // 创建弹出层
+                            const modal = document.createElement('div');
+                            modal.className = 'remark-input-modal';
+                            
+                            modal.innerHTML = `
+                                <div class="remark-input-container">
+                                    <h3>编辑备注</h3>
+                                    <input type="text" maxlength="30" placeholder="请输入备注（30字以内）" value="${currentRemark}">
+                                    <div class="char-count"><span>${currentRemark.length}</span>/30</div>
+                                    <div class="remark-input-actions">
+                                        <button class="secondary" onclick="this.closest('.remark-input-modal').remove()">取消</button>
+                                        <button class="save-remark" data-token="${token}">保存</button>
+                                    </div>
                                 </div>
-                            </div>
-                        `;
-                        
-                        document.body.appendChild(modal);
-                        
-                        // 获取输入框并聚焦
-                        const input = modal.querySelector('input');
-                        input.focus();
-                        
-                        // 更新字符计数
-                        input.addEventListener('input', () => {
-                            const count = input.value.length;
-                            modal.querySelector('.char-count span').textContent = count;
-                        });
-                        
-                        // 点击背景关闭弹窗
-                        modal.addEventListener('click', (e) => {
-                            if (e.target === modal) {
-                                modal.remove();
-                            }
-                        });
-                        
-                        // 处理保存按钮点击
-                        modal.querySelector('.save-remark').addEventListener('click', async function() {
-                            const token = this.dataset.token;
-                            const newRemark = input.value.trim();
+                            `;
                             
-                            try {
-                                const response = await fetch(`/api/token/${token}/remark`, {
-                                    method: 'PUT',
-                                    headers: {
-                                        'Content-Type': 'application/json'
-                                    },
-                                    body: JSON.stringify({ remark: newRemark })
-                                });
-                                
-                                const data = await response.json();
-                                if (data.status === 'success') {
-                                    // 关闭弹窗
+                            document.body.appendChild(modal);
+                            
+                            // 获取输入框并聚焦
+                            const input = modal.querySelector('input');
+                            input.focus();
+                            
+                            // 更新字符计数
+                            input.addEventListener('input', () => {
+                                const count = input.value.length;
+                                modal.querySelector('.char-count span').textContent = count;
+                            });
+                            
+                            // 点击背景关闭弹窗
+                            modal.addEventListener('click', (e) => {
+                                if (e.target === modal) {
                                     modal.remove();
-                                    // 刷新列表
-                                    fetchCurrentToken();
-                                } else {
-                                    alert('更新备注失败: ' + (data.error || '未知错误'));
                                 }
-                            } catch (error) {
-                                alert('请求失败: ' + error.message);
-                            }
-                        });
+                            });
+                            
+                            // 处理保存按钮点击
+                            modal.querySelector('.save-remark').addEventListener('click', async function() {
+                                const token = this.dataset.token;
+                                const newRemark = input.value.trim();
+                                
+                                try {
+                                    const response = await fetch(`/api/token/${token}/remark`, {
+                                        method: 'PUT',
+                                        headers: {
+                                            'Content-Type': 'application/json'
+                                        },
+                                        body: JSON.stringify({ remark: newRemark })
+                                    });
+                                    
+                                    const data = await response.json();
+                                    
+                                    if (data.status === 'success') {
+                                        // 更新所有具有相同token的备注元素
+                                        document.querySelectorAll(`.token-remark[data-token="${token}"]`).forEach(el => {
+                                            el.textContent = newRemark || '添加备��';
+                                            el.dataset.remark = newRemark;
+                                            
+                                            if (newRemark) {
+                                                el.classList.remove('empty');
+                                            } else {
+                                                el.classList.add('empty');
+                                            }
+                                        });
+                                        
+                                        // 关闭弹窗
+                                        modal.remove();
+                                    } else {
+                                        alert('更新备注失败: ' + (data.error || '未知错误'));
+                                    }
+                                } catch (error) {
+                                    alert('请求失败: ' + error.message);
+                                }
+                            });
+                        }
                     });
                     
-                    // 为header添加点击事件（展开/折叠详情）
-                    header.addEventListener('click', function() {
-                        details.classList.toggle('open');
-                        toggle.classList.toggle('open');
-                    });
-                });
+                    // 标记已添加过事件监听器
+                    document.querySelector('.token-list').hasEventListener = true;
+                }
             }
             
             // 为token列表添加事件委托,只处理删除按钮
@@ -1264,11 +1450,6 @@
                 }
             });
 
-            // 刷新Token按钮事件
-            document.getElementById('refresh-token').addEventListener('click', function() {
-                fetchCurrentToken();
-            });
-
             // 添加登出处理逻辑
             document.getElementById('logout-btn').addEventListener('click', function() {
                 if(confirm('确定要登出吗？')) {