Update main.go

main.go

@@ -11,70 +11,71 @@ import (
 	"os"
 	"regexp"
 	"strings"
+	"sync"
 	"time"
 )
 
 // 配置变量（从环境变量读取）
 var (
-	UPSTREAM_URL   string
-	DEFAULT_KEY    string
-	UPSTREAM_TOKEN string
-	MODEL_NAME     string
-	PORT           string
-	DEBUG_MODE     bool
-	DEFAULT_STREAM bool
+	UPSTREAM_URL              string
+	DEFAULT_KEY               string
+	ZAI_TOKEN                 string
+	MODEL_NAME                string // 未使用，因为现在动态获取
+	PORT                      string
+	DEBUG_MODE                bool
+	DEFAULT_STREAM            bool
+	DASHBOARD_ENABLED         bool
+	ENABLE_THINKING           bool
+	MODELS_URL                string // 新增：模型列表URL
+	DEFAULT_UPSTREAM_MODEL_ID string // 新增：默认上游模型ID
 )
 
-// 思考内容处理策略
-const (
-	THINK_TAGS_MODE = "strip" // strip: 去除<details>标签；think: 转为<think>标签；raw: 保留原样
-)
-
-// 伪装前端头部（来自抓包）
-const (
-	X_FE_VERSION   = "prod-fe-1.0.70"
-	BROWSER_UA     = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36 Edg/139.0.0.0"
-	SEC_CH_UA      = "\"Not;A=Brand\";v=\"99\", \"Microsoft Edge\";v=\"139\", \"Chromium\";v=\"139\""
-	SEC_CH_UA_MOB  = "?0"
-	SEC_CH_UA_PLAT = "\"Windows\""
-	ORIGIN_BASE    = "https://chat.z.ai"
-)
-
-// 匿名token开关
-const ANON_TOKEN_ENABLED = true
-
-// 从环境变量初始化配置
-func initConfig() {
-	UPSTREAM_URL = getEnv("UPSTREAM_URL", "https://chat.z.ai/api/chat/completions")
-	DEFAULT_KEY = getEnv("DEFAULT_KEY", "sk-your-key")
-	UPSTREAM_TOKEN = getEnv("UPSTREAM_TOKEN", "eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjMxNmJjYjQ4LWZmMmYtNGExNS04NTNkLWYyYTI5YjY3ZmYwZiIsImVtYWlsIjoiR3Vlc3QtMTc1NTg0ODU4ODc4OEBndWVzdC5jb20ifQ.PktllDySS3trlyuFpTeIZf-7hl8Qu1qYF3BxjgIul0BrNux2nX9hVzIjthLXKMWAf9V0qM8Vm_iyDqkjPGsaiQ")
-	MODEL_NAME = getEnv("MODEL_NAME", "GLM-4.5")
-	PORT = getEnv("PORT", "7860")
+// 请求统计信息
+type RequestStats struct {
+	TotalRequests       int64
+	SuccessfulRequests  int64
+	FailedRequests      int64
+	LastRequestTime     time.Time
+	AverageResponseTime time.Duration
+}
 
-	// 处理PORT格式，确保有冒号前缀
-	if !strings.HasPrefix(PORT, ":") {
-		PORT = ":" + PORT
-	}
+// 实时请求信息
+type LiveRequest struct {
+	ID        string    `json:"id"`
+	Timestamp time.Time `json:"timestamp"`
+	Method    string    `json:"method"`
+	Path      string    `json:"path"`
+	Status    int       `json:"status"`
+	Duration  int64     `json:"duration"`
+	UserAgent string    `json:"user_agent"`
+}
 
-	DEBUG_MODE = getEnv("DEBUG_MODE", "true") == "true"
-	DEFAULT_STREAM = getEnv("DEFAULT_STREAM", "true") == "true"
+// 上游模型响应结构 (新增)
+type UpstreamModelsResponse struct {
+	Object string          `json:"object"`
+	Data   []UpstreamModel `json:"data"`
 }
 
-// 获取环境变量，如果不存在则返回默认值
-func getEnv(key, defaultValue string) string {
-	if value := os.Getenv(key); value != "" {
-		return value
-	}
-	return defaultValue
+type UpstreamModel struct {
+	ID      string `json:"id"`
+	Name    string `json:"name"`
+	Object  string `json:"object"`
+	Created int64  `json:"created"`
+	OwnedBy string `json:"owned_by"`
+	Info    struct {
+		IsActive  bool  `json:"is_active"`
+		CreatedAt int64 `json:"created_at"`
+	} `json:"info"`
 }
 
 // OpenAI 请求结构
 type OpenAIRequest struct {
-	Model       string    `json:"model"`
-	Messages    []Message `json:"messages"`
-	Stream      bool      `json:"stream,omitempty"`
-	Temperature float64   `json:"temperature,omitempty"`
-	MaxTokens   int       `json:"max_tokens,omitempty"`
+	Model          string    `json:"model"`
+	Messages       []Message `json:"messages"`
+	Stream         bool      `json:"stream,omitempty"`
+	Temperature    float64   `json:"temperature,omitempty"`
+	MaxTokens      int       `json:"max_tokens,omitempty"`
+	EnableThinking *bool     `json:"enable_thinking,omitempty"`
 }
 
 type Message struct {
@@ -158,12 +159,320 @@ type ModelsResponse struct {
 }
 
 type Model struct {
-	ID      string `json:"id"`
+	ID      string `json:"id"` // 保持ID字段
 	Object  string `json:"object"`
+	Name    string `json:"name"` // 新增Name字段，用于显示
 	Created int64  `json:"created"`
 	OwnedBy string `json:"owned_by"`
 }
 
+// 全局变量
+var (
+	stats         RequestStats
+	liveRequests  = []LiveRequest{} // 初始化为空数组，而不是 nil
+	statsMutex    sync.Mutex
+	requestsMutex sync.Mutex
+	modelsCache   []Model      // 新增：缓存模型列表
+	modelsMutex   sync.RWMutex // 新增：保护模型缓存的读写锁
+)
+
+// 思考内容处理策略
+const (
+	THINK_TAGS_MODE = "strip" // strip: 去除<details>标签；think: 转为<think>标签；raw: 保留原样
+)
+
+// 伪装前端头部（来自抓包）
+const (
+	X_FE_VERSION   = "prod-fe-1.0.70"
+	BROWSER_UA     = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36 Edg/139.0.0.0"
+	SEC_CH_UA      = "\"Not;A=Brand\";v=\"99\", \"Microsoft Edge\";v=\"139\", \"Chromium\";v=\"139\""
+	SEC_CH_UA_MOB  = "?0"
+	SEC_CH_UA_PLAT = "\"Windows\""
+	ORIGIN_BASE    = "https://chat.z.ai"
+)
+
+// 匿名token开关
+const ANON_TOKEN_ENABLED = true
+
+// 从环境变量初始化配置
+func initConfig() {
+	UPSTREAM_URL = getEnv("UPSTREAM_URL", "https://chat.z.ai/api/chat/completions")
+	DEFAULT_KEY = getEnv("DEFAULT_KEY", "sk-your-key")
+	ZAI_TOKEN = getEnv("ZAI_TOKEN", "")
+	MODEL_NAME = getEnv("MODEL_NAME", "GLM-4.5") // 未使用，但保留
+	PORT = getEnv("PORT", "7860")
+	MODELS_URL = getEnv("MODELS_URL", "https://chat.z.ai/api/models")                // 新增
+	DEFAULT_UPSTREAM_MODEL_ID = getEnv("DEFAULT_UPSTREAM_MODEL_ID", "0727-360B-API") // 新增
+	// 处理PORT格式，确保有冒号前缀
+	if !strings.HasPrefix(PORT, ":") {
+		PORT = ":" + PORT
+	}
+	DEBUG_MODE = getEnv("DEBUG_MODE", "true") == "true"
+	DEFAULT_STREAM = getEnv("DEFAULT_STREAM", "true") == "true"
+	DASHBOARD_ENABLED = getEnv("DASHBOARD_ENABLED", "true") == "true"
+	ENABLE_THINKING = getEnv("ENABLE_THINKING", "true") == "true"
+}
+
+// 记录请求统计信息
+func recordRequestStats(startTime time.Time, path string, status int) {
+	duration := time.Since(startTime)
+	statsMutex.Lock()
+	defer statsMutex.Unlock()
+	stats.TotalRequests++
+	stats.LastRequestTime = time.Now()
+	if status >= 200 && status < 300 {
+		stats.SuccessfulRequests++
+	} else {
+		stats.FailedRequests++
+	}
+	// 更新平均响应时间
+	if stats.TotalRequests > 0 {
+		totalDuration := stats.AverageResponseTime*time.Duration(stats.TotalRequests-1) + duration
+		stats.AverageResponseTime = totalDuration / time.Duration(stats.TotalRequests)
+	} else {
+		stats.AverageResponseTime = duration
+	}
+}
+
+// 添加实时请求信息
+func addLiveRequest(method, path string, status int, duration time.Duration, _, userAgent string) {
+	requestsMutex.Lock()
+	defer requestsMutex.Unlock()
+	request := LiveRequest{
+		ID:        fmt.Sprintf("%d", time.Now().UnixNano()),
+		Timestamp: time.Now(),
+		Method:    method,
+		Path:      path,
+		Status:    status,
+		Duration:  duration.Milliseconds(),
+		UserAgent: userAgent,
+	}
+	liveRequests = append(liveRequests, request)
+	// 只保留最近的100条请求
+	if len(liveRequests) > 100 {
+		liveRequests = liveRequests[1:]
+	}
+}
+
+// 获取实时请求数据（用于SSE）
+func getLiveRequestsData() []byte {
+	requestsMutex.Lock()
+	defer requestsMutex.Unlock()
+	// 确保 liveRequests 不为 nil
+	if liveRequests == nil {
+		liveRequests = []LiveRequest{}
+	}
+	data, err := json.Marshal(liveRequests)
+	if err != nil {
+		// 如果序列化失败，返回空数组
+		emptyArray := []LiveRequest{}
+		data, _ = json.Marshal(emptyArray)
+	}
+	return data
+}
+
+// 获取统计数据（用于SSE）
+func getStatsData() []byte {
+	statsMutex.Lock()
+	defer statsMutex.Unlock()
+	data, _ := json.Marshal(stats)
+	return data
+}
+
+// 获取环境变量，如果不存在则返回默认值
+func getEnv(key, defaultValue string) string {
+	if value := os.Getenv(key); value != "" {
+		return value
+	}
+	return defaultValue
+}
+
+// 获取客户端IP地址
+func getClientIP(r *http.Request) string {
+	// 检查X-Forwarded-For头
+	if xff := r.Header.Get("X-Forwarded-For"); xff != "" {
+		ips := strings.Split(xff, ",")
+		if len(ips) > 0 {
+			return strings.TrimSpace(ips[0])
+		}
+	}
+	// 检查X-Real-IP头
+	if xri := r.Header.Get("X-Real-IP"); xri != "" {
+		return xri
+	}
+	// 使用RemoteAddr
+	ip := r.RemoteAddr
+	// 移除端口号
+	if strings.Contains(ip, ":") {
+		ip = strings.Split(ip, ":")[0]
+	}
+	return ip
+}
+
+// 检查字符是否为英文字母
+func isEnglishLetter(r rune) bool {
+	return (r >= 'A' && r <= 'Z') || (r >= 'a' && r <= 'z')
+}
+
+// 检查字符串是否包含英文字母
+func hasEnglishLetter(s string) bool {
+	for _, r := range s {
+		if isEnglishLetter(r) {
+			return true
+		}
+	}
+	return false
+}
+
+// 检查字符串是否为纯数字
+func isDigit(s string) bool {
+	for _, r := range s {
+		if r < '0' || r > '9' {
+			return false
+		}
+	}
+	return s != ""
+}
+
+// 格式化模型名
+func formatModelName(name string) string {
+	if name == "" {
+		return ""
+	}
+	parts := strings.Split(name, "-")
+	if len(parts) == 1 {
+		return strings.ToUpper(parts[0])
+	}
+	formatted := []string{strings.ToUpper(parts[0])}
+	for _, p := range parts[1:] {
+		if p == "" {
+			formatted = append(formatted, "")
+		} else if isDigit(p) {
+			formatted = append(formatted, p)
+		} else if hasEnglishLetter(p) {
+			// Use Title for better capitalization of letters
+			formatted = append(formatted, strings.Title(p))
+		} else {
+			formatted = append(formatted, p)
+		}
+	}
+	return strings.Join(formatted, "-")
+}
+
+// 获取模型列表 (新增)
+func getModels() []Model {
+	modelsMutex.RLock()
+	cachedModels := modelsCache
+	modelsMutex.RUnlock()
+
+	if cachedModels != nil {
+		return cachedModels
+	}
+
+	// 获取token
+	token := ZAI_TOKEN
+	if ANON_TOKEN_ENABLED {
+		if t, err := getAnonymousToken(); err == nil {
+			token = t
+		}
+	}
+
+	client := &http.Client{
+		Timeout: 10 * time.Second,
+		Transport: &http.Transport{
+			MaxIdleConns:       10,
+			IdleConnTimeout:    30 * time.Second,
+			DisableCompression: false,
+		},
+	}
+
+	req, err := http.NewRequest("GET", MODELS_URL, nil)
+	if err != nil {
+		debugLog("创建模型请求失败: %v", err)
+		return getDefaultModels()
+	}
+
+	// 设置请求头
+	req.Header.Set("User-Agent", BROWSER_UA)
+	req.Header.Set("Accept", "*/*")
+	req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9")
+	req.Header.Set("X-FE-Version", X_FE_VERSION)
+	req.Header.Set("sec-ch-ua", SEC_CH_UA)
+	req.Header.Set("sec-ch-ua-mobile", SEC_CH_UA_MOB)
+	req.Header.Set("sec-ch-ua-platform", SEC_CH_UA_PLAT)
+	req.Header.Set("Origin", ORIGIN_BASE)
+	if token != "" {
+		req.Header.Set("Authorization", "Bearer "+token)
+	}
+
+	resp, err := client.Do(req)
+	if err != nil {
+		debugLog("获取模型列表失败: %v", err)
+		return getDefaultModels()
+	}
+	defer func() {
+		if closeErr := resp.Body.Close(); closeErr != nil {
+			debugLog("关闭模型响应体失败: %v", closeErr)
+		}
+	}()
+
+	if resp.StatusCode != http.StatusOK {
+		debugLog("模型列表响应状态异常: %d", resp.StatusCode)
+		return getDefaultModels()
+	}
+
+	var upstreamResp UpstreamModelsResponse
+	if err := json.NewDecoder(resp.Body).Decode(&upstreamResp); err != nil {
+		debugLog("解析模型列表失败: %v", err)
+		return getDefaultModels()
+	}
+
+	var models []Model
+	for _, m := range upstreamResp.Data {
+		if !m.Info.IsActive {
+			continue
+		}
+
+		modelName := m.Name
+		if modelName == "" || !isEnglishLetter([]rune(modelName)[0]) { // 确保Name不为空且首字符是字母
+			modelName = formatModelName(m.ID)
+		}
+
+		models = append(models, Model{
+			ID:      m.ID,
+			Object:  "model",
+			Name:    modelName,        // 使用格式化后的名称或原始Name
+			Created: m.Info.CreatedAt, // 使用上游的CreatedAt
+			OwnedBy: "z.ai",
+		})
+	}
+
+	if len(models) == 0 {
+		return getDefaultModels()
+	}
+
+	// 更新缓存
+	modelsMutex.Lock()
+	modelsCache = models
+	modelsMutex.Unlock()
+
+	debugLog("获取到%d个模型", len(models))
+	return models
+}
+
+// 获取默认模型列表（获取失败时使用）
+func getDefaultModels() []Model {
+	return []Model{
+		{
+			ID:      "0727-360B-API", // 与DEFAULT_UPSTREAM_MODEL_ID一致
+			Object:  "model",
+			Name:    "GLM-4.5", // 或根据ID格式化
+			Created: time.Now().Unix(),
+			OwnedBy: "z.ai",
+		},
+	}
+}
+
 // debug日志函数
 func debugLog(format string, args ...interface{}) {
 	if DEBUG_MODE {
@@ -188,7 +497,6 @@ func getAnonymousToken() (string, error) {
 	req.Header.Set("sec-ch-ua-platform", SEC_CH_UA_PLAT)
 	req.Header.Set("Origin", ORIGIN_BASE)
 	req.Header.Set("Referer", ORIGIN_BASE+"/")
-
 	resp, err := client.Do(req)
 	if err != nil {
 		return "", err
@@ -212,21 +520,870 @@ func getAnonymousToken() (string, error) {
 func main() {
 	// 初始化配置
 	initConfig()
-
-	// http.HandleFunc("/v1/models", handleModels)
-	// http.HandleFunc("/v1/chat/completions", handleChatCompletions)
+	// 注册路由
+	http.HandleFunc("/v1/models", handleModels)
+	http.HandleFunc("/v1/chat/completions", handleChatCompletions)
+	http.HandleFunc("/docs", handleAPIDocs)
+	// http.HandleFunc("/", handleOptions)
+	http.HandleFunc("/", handleDashboard)
 	http.HandleFunc("/api/v1/models", handleModels)
 	http.HandleFunc("/api/v1/chat/completions", handleChatCompletions)
-	http.HandleFunc("/", handleOptions)
-
+	http.HandleFunc("/hf/v1/models", handleModels)
+	http.HandleFunc("/hf/v1/chat/completions", handleChatCompletions)
+	// Dashboard路由
+	if DASHBOARD_ENABLED {
+		http.HandleFunc("/dashboard", handleDashboard)
+		http.HandleFunc("/dashboard/stats", handleDashboardStats)
+		http.HandleFunc("/dashboard/requests", handleDashboardRequests)
+		log.Printf("Dashboard已启用，访问地址: http://localhost%s/dashboard", PORT)
+	}
 	log.Printf("OpenAI兼容API服务器启动在端口%s", PORT)
-	log.Printf("模型: %s", MODEL_NAME)
+	log.Printf("模型: %s", MODEL_NAME) // 这里可能需要调整显示逻辑，因为现在模型是动态的
 	log.Printf("上游: %s", UPSTREAM_URL)
 	log.Printf("Debug模式: %v", DEBUG_MODE)
 	log.Printf("默认流式响应: %v", DEFAULT_STREAM)
+	log.Printf("Dashboard启用: %v", DASHBOARD_ENABLED)
+	log.Printf("思考功能: %v", ENABLE_THINKING)
 	log.Fatal(http.ListenAndServe(PORT, nil))
 }
 
+// Dashboard页面处理器
+func handleDashboard(w http.ResponseWriter, r *http.Request) {
+	// 只允许GET请求
+	if r.Method != "GET" {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+	// 简单的HTML模板
+	tmpl := `<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>API调用看板</title>
+    <style>
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            margin: 0;
+            padding: 20px;
+            background-color: #f5f5f5;
+        }
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            background-color: white;
+            border-radius: 8px;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+            padding: 20px;
+        }
+        h1 {
+            color: #333;
+            text-align: center;
+            margin-bottom: 30px;
+        }
+        .stats-container {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 20px;
+            margin-bottom: 30px;
+        }
+        .stat-card {
+            background-color: #f8f9fa;
+            border-radius: 6px;
+            padding: 15px;
+            text-align: center;
+            box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+        }
+        .stat-value {
+            font-size: 24px;
+            font-weight: bold;
+            color: #007bff;
+        }
+        .stat-label {
+            font-size: 14px;
+            color: #6c757d;
+            margin-top: 5px;
+        }
+        .requests-container {
+            margin-top: 30px;
+        }
+        .requests-table {
+            width: 100%;
+            border-collapse: collapse;
+        }
+        .requests-table th, .requests-table td {
+            padding: 10px;
+            text-align: left;
+            border-bottom: 1px solid #ddd;
+        }
+        .requests-table th {
+            background-color: #f8f9fa;
+        }
+        .status-success {
+            color: #28a745;
+        }
+        .status-error {
+            color: #dc3545;
+        }
+        .refresh-info {
+            text-align: center;
+            margin-top: 20px;
+            color: #007bff;
+            font-size: 14px;
+        }
+        .pagination-container {
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            margin-top: 20px;
+            gap: 10px;
+        }
+        .pagination-container button {
+            padding: 5px 10px;
+            background-color: #007bff;
+            color: white;
+            border: none;
+            border-radius: 4px;
+            cursor: pointer;
+        }
+        .pagination-container button:disabled {
+            background-color: #cccccc;
+            cursor: not-allowed;
+        }
+        .pagination-container button:hover:not(:disabled) {
+            background-color: #0056b3;
+        }
+        .chart-container {
+            margin-top: 30px;
+            height: 300px;
+            background-color: #f8f9fa;
+            border-radius: 6px;
+            padding: 15px;
+            box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>API调用看板</h1>
+        <div class="stats-container">
+            <div class="stat-card">
+                <div class="stat-value" id="total-requests">0</div>
+                <div class="stat-label">总请求数</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value" id="successful-requests">0</div>
+                <div class="stat-label">成功请求</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value" id="failed-requests">0</div>
+                <div class="stat-label">失败请求</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value" id="avg-response-time">0s</div>
+                <div class="stat-label">平均响应时间</div>
+            </div>
+        </div>
+        <div class="chart-container">
+            <h2>请求统计图表</h2>
+            <canvas id="requestsChart"></canvas>
+        </div>
+        <div class="requests-container">
+            <h2>实时请求</h2>
+            <table class="requests-table">
+                <thead>
+                    <tr>
+                        <th>时间</th>
+                        <th>模型</th>
+                        <th>方法</th>
+                        <th>状态</th>
+                        <th>耗时</th>
+                        <th>User Agent</th>
+                    </tr>
+                </thead>
+                <tbody id="requests-tbody">
+                    <!-- 请求记录将通过JavaScript动态添加 -->
+                </tbody>
+            </table>
+            <div class="pagination-container">
+                <button id="prev-page" disabled>上一页</button>
+                <span id="page-info">第 1 页，共 1 页</span>
+                <button id="next-page" disabled>下一页</button>
+            </div>
+        </div>
+        <div class="refresh-info">
+            数据每5秒自动刷新一次
+        </div>
+    </div>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <script>
+        // 全局变量
+        let allRequests = [];
+        let currentPage = 1;
+        const itemsPerPage = 10;
+        let requestsChart = null;
+        // 更新统计数据
+        function updateStats() {
+            fetch('/dashboard/stats')
+                .then(response => response.json())
+                .then(data => {
+                    document.getElementById('total-requests').textContent = data.TotalRequests;
+                    document.getElementById('successful-requests').textContent = data.SuccessfulRequests;
+                    document.getElementById('failed-requests').textContent = data.FailedRequests;
+                    document.getElementById('avg-response-time').textContent = (data.AverageResponseTime / 1000000000).toFixed(2) + 's';
+                })
+                .catch(error => console.error('Error fetching stats:', error));
+        }
+        // 更新请求列表
+        function updateRequests() {
+            fetch('/dashboard/requests')
+                .then(response => response.json())
+                .then(data => {
+                    // 检查数据是否为数组
+                    if (!Array.isArray(data)) {
+                        console.error('返回的数据不是数组:', data);
+                        return;
+                    }
+                    // 保存所有请求数据
+                    allRequests = data;
+                    // 按时间倒序排列
+                    allRequests.sort((a, b) => {
+                        const timeA = new Date(a.timestamp);
+                        const timeB = new Date(b.timestamp);
+                        return timeB - timeA;
+                    });
+                    // 更新表格
+                    updateTable();
+                    // 更新图表
+                    updateChart();
+                    // 更新分页信息
+                    updatePagination();
+                })
+                .catch(error => console.error('Error fetching requests:', error));
+        }
+        // 更新表格显示
+        function updateTable() {
+            const tbody = document.getElementById('requests-tbody');
+            tbody.innerHTML = '';
+            // 计算当前页的数据范围
+            const startIndex = (currentPage - 1) * itemsPerPage;
+            const endIndex = startIndex + itemsPerPage;
+            const currentRequests = allRequests.slice(startIndex, endIndex);
+            currentRequests.forEach(request => {
+                const row = document.createElement('tr');
+                // 格式化时间 - 检查时间戳是否有效
+                let timeStr = "Invalid Date";
+                if (request.timestamp) {
+                    try {
+                        const time = new Date(request.timestamp);
+                        if (!isNaN(time.getTime())) {
+                            timeStr = time.toLocaleTimeString();
+                        }
+                    } catch (e) {
+                        console.error("时间格式化错误:", e);
+                    }
+                }
+                // 状态样式
+                const statusClass = request.status >= 200 && request.status < 300 ? 'status-success' : 'status-error';
+                // 截断 User Agent，避免过长
+                let userAgent = request.user_agent || "undefined";
+                if (userAgent.length > 30) {
+                    userAgent = userAgent.substring(0, 30) + "...";
+                }
+                row.innerHTML = "<td>" + timeStr + "</td>" + "<td>GLM-4.5</td>" + "<td>" + (request.method || "undefined") + "</td>" + "<td class=\"" + statusClass + "\">" + (request.status || "undefined") + "</td>" + "<td>" + ((request.duration / 1000).toFixed(2) || "undefined") + "s</td>" + "<td title=\"" + (request.user_agent || "") + "\">" + userAgent + "</td>";
+                tbody.appendChild(row);
+            });
+        }
+        // 更新分页信息
+        function updatePagination() {
+            const totalPages = Math.ceil(allRequests.length / itemsPerPage);
+            document.getElementById('page-info').textContent = "第 " + currentPage + " 页，共 " + totalPages + " 页";
+            document.getElementById('prev-page').disabled = currentPage <= 1;
+            document.getElementById('next-page').disabled = currentPage >= totalPages;
+        }
+        // 更新图表
+        function updateChart() {
+            const ctx = document.getElementById('requestsChart').getContext('2d');
+            // 准备图表数据 - 最近20条请求的响应时间
+            const chartData = allRequests.slice(0, 20).reverse();
+            const labels = chartData.map(req => {
+                const time = new Date(req.timestamp);
+                return time.toLocaleTimeString();
+            });
+            const responseTimes = chartData.map(req => req.duration);
+            // 如果图表已存在，先销毁
+            if (requestsChart) {
+                requestsChart.destroy();
+            }
+            // 创建新图表
+            requestsChart = new Chart(ctx, {
+                type: 'line',
+                data: {
+                    labels: labels,
+                    datasets: [{
+                        label: '响应时间 (s)',
+                        data: responseTimes.map(time => time / 1000),
+                        borderColor: '#007bff',
+                        backgroundColor: 'rgba(0, 123, 255, 0.1)',
+                        tension: 0.1,
+                        fill: true
+                    }]
+                },
+                options: {
+                    responsive: true,
+                    maintainAspectRatio: false,
+                    scales: {
+                        y: {
+                            beginAtZero: true,
+                            title: {
+                                display: true,
+                                text: '响应时间 (s)'
+                            }
+                        },
+                        x: {
+                            title: {
+                                display: true,
+                                text: '时间'
+                            }
+                        }
+                    },
+                    plugins: {
+                        title: {
+                            display: true,
+                            text: '最近20条请求的响应时间趋势 (s)'
+                        }
+                    }
+                }
+            });
+        }
+        // 分页按钮事件
+        document.getElementById('prev-page').addEventListener('click', function() {
+            if (currentPage > 1) {
+                currentPage--;
+                updateTable();
+                updatePagination();
+            }
+        });
+        document.getElementById('next-page').addEventListener('click', function() {
+            const totalPages = Math.ceil(allRequests.length / itemsPerPage);
+            if (currentPage < totalPages) {
+                currentPage++;
+                updateTable();
+                updatePagination();
+            }
+        });
+        // 初始加载
+        updateStats();
+        updateRequests();
+        // 定时刷新
+        setInterval(updateStats, 5000);
+        setInterval(updateRequests, 5000);
+    </script>
+</body>
+</html>`
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	fmt.Fprint(w, tmpl)
+}
+
+// Dashboard统计数据处理器
+func handleDashboardStats(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json")
+	w.Write(getStatsData())
+}
+
+// Dashboard请求数据处理器
+func handleDashboardRequests(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json")
+	w.Write(getLiveRequestsData())
+}
+
+// API文档页面处理器
+func handleAPIDocs(w http.ResponseWriter, r *http.Request) {
+	// 只允许GET请求
+	if r.Method != "GET" {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+	// API文档HTML模板
+	tmpl := `<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ZtoApi 文档</title>
+    <style>
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            margin: 0;
+            padding: 20px;
+            background-color: #f5f5f5;
+            line-height: 1.6;
+        }
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            background-color: white;
+            border-radius: 8px;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+            padding: 30px;
+        }
+        h1 {
+            color: #333;
+            text-align: center;
+            margin-bottom: 30px;
+            border-bottom: 2px solid #007bff;
+            padding-bottom: 10px;
+        }
+        h2 {
+            color: #007bff;
+            margin-top: 30px;
+            margin-bottom: 15px;
+        }
+        h3 {
+            color: #333;
+            margin-top: 25px;
+            margin-bottom: 10px;
+        }
+        .endpoint {
+            background-color: #f8f9fa;
+            border-radius: 6px;
+            padding: 15px;
+            margin-bottom: 20px;
+            border-left: 4px solid #007bff;
+        }
+        .method {
+            display: inline-block;
+            padding: 4px 8px;
+            border-radius: 4px;
+            color: white;
+            font-weight: bold;
+            margin-right: 10px;
+            font-size: 14px;
+        }
+        .get { background-color: #28a745; }
+        .post { background-color: #007bff; }
+        .path {
+            font-family: monospace;
+            background-color: #e9ecef;
+            padding: 2px 6px;
+            border-radius: 3px;
+            font-size: 16px;
+        }
+        .description {
+            margin: 15px 0;
+        }
+        .parameters {
+            margin: 15px 0;
+        }
+        table {
+            width: 100%;
+            border-collapse: collapse;
+            margin: 15px 0;
+        }
+        th, td {
+            padding: 10px;
+            text-align: left;
+            border-bottom: 1px solid #ddd;
+        }
+        th {
+            background-color: #f8f9fa;
+            font-weight: bold;
+        }
+        .example {
+            background-color: #f8f9fa;
+            border-radius: 6px;
+            padding: 15px;
+            margin: 15px 0;
+            font-family: monospace;
+            white-space: pre-wrap;
+            overflow-x: auto;
+        }
+        .note {
+            background-color: #fff3cd;
+            border-left: 4px solid #ffc107;
+            padding: 10px 15px;
+            margin: 15px 0;
+            border-radius: 0 4px 4px 0;
+        }
+        .response {
+            background-color: #f8f9fa;
+            border-radius: 6px;
+            padding: 15px;
+            margin: 15px 0;
+            font-family: monospace;
+            white-space: pre-wrap;
+            overflow-x: auto;
+        }
+        .tab {
+            overflow: hidden;
+            border: 1px solid #ccc;
+            background-color: #f1f1f1;
+            border-radius: 4px 4px 0 0;
+        }
+        .tab button {
+            background-color: inherit;
+            float: left;
+            border: none;
+            outline: none;
+            cursor: pointer;
+            padding: 14px 16px;
+            transition: 0.3s;
+            font-size: 16px;
+        }
+        .tab button:hover {
+            background-color: #ddd;
+        }
+        .tab button.active {
+            background-color: #ccc;
+        }
+        .tabcontent {
+            display: none;
+            padding: 6px 12px;
+            border: 1px solid #ccc;
+            border-top: none;
+            border-radius: 0 0 4px 4px;
+        }
+        .toc {
+            background-color: #f8f9fa;
+            border-radius: 6px;
+            padding: 15px;
+            margin-bottom: 20px;
+        }
+        .toc ul {
+            padding-left: 20px;
+        }
+        .toc li {
+            margin: 5px 0;
+        }
+        .toc a {
+            color: #007bff;
+            text-decoration: none;
+        }
+        .toc a:hover {
+            text-decoration: underline;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>ZtoApi 文档</h1>
+        <div class="toc">
+            <h2>目录</h2>
+            <ul>
+                <li><a href="#overview">概述</a></li>
+                <li><a href="#authentication">身份验证</a></li>
+                <li><a href="#endpoints">API端点</a>
+                    <ul>
+                        <li><a href="#models">获取模型列表</a></li>
+                        <li><a href="#chat-completions">聊天完成</a></li>
+                    </ul>
+                </li>
+                <li><a href="#examples">使用示例</a></li>
+                <li><a href="#error-handling">错误处理</a></li>
+            </ul>
+        </div>
+        <section id="overview">
+            <h2>概述</h2>
+            <p>这是一个为Z.ai GLM-4.5模型提供OpenAI兼容API接口的代理服务器。它允许你使用标准的OpenAI API格式与Z.ai的GLM-4.5模型进行交互，支持流式和非流式响应。</p>
+            <p><strong>基础URL:</strong> <code>http://localhost:7860/v1</code></p>
+            <div class="note">
+                <strong>注意:</strong> 默认端口为7860，可以通过环境变量PORT进行修改。
+            </div>
+        </section>
+        <section id="authentication">
+            <h2>身份验证</h2>
+            <p>所有API请求都需要在请求头中包含有效的API密钥进行身份验证：</p>
+            <div class="example">
+Authorization: Bearer your-api-key</div>
+            <p>默认的API密钥为 <code>sk-your-key</code>，可以通过环境变量 <code>DEFAULT_KEY</code> 进行修改。</p>
+        </section>
+        <section id="endpoints">
+            <h2>API端点</h2>
+            <div class="endpoint" id="models">
+                <h3>获取模型列表</h3>
+                <div>
+                    <span class="method get">GET</span>
+                    <span class="path">/v1/models</span>
+                </div>
+                <div class="description">
+                    <p>获取可用模型列表。</p>
+                </div>
+                <div class="parameters">
+                    <h4>请求参数</h4>
+                    <p>无</p>
+                </div>
+                <div class="response">
+{
+  "object": "list",
+  "data": [
+    {
+      "id": "GLM-4.5",
+      "object": "model",
+      "created": 1756788845,
+      "owned_by": "z.ai"
+    }
+  ]
+}</div>
+            </div>
+            <div class="endpoint" id="chat-completions">
+                <h3>聊天完成</h3>
+                <div>
+                    <span class="method post">POST</span>
+                    <span class="path">/v1/chat/completions</span>
+                </div>
+                <div class="description">
+                    <p>基于消息列表生成模型响应。支持流式和非流式两种模式。</p>
+                </div>
+                <div class="parameters">
+                    <h4>请求参数</h4>
+                    <table>
+                        <thead>
+                            <tr>
+                                <th>参数名</th>
+                                <th>类型</th>
+                                <th>必需</th>
+                                <th>说明</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr>
+                                <td>model</td>
+                                <td>string</td>
+                                <td>是</td>
+                                <td>要使用的模型ID，例如 "GLM-4.5"</td>
+                            </tr>
+                            <tr>
+                                <td>messages</td>
+                                <td>array</td>
+                                <td>是</td>
+                                <td>消息列表，包含角色和内容</td>
+                            </tr>
+                            <tr>
+                                <td>stream</td>
+                                <td>boolean</td>
+                                <td>否</td>
+                                <td>是否使用流式响应，默认为true</td>
+                            </tr>
+                            <tr>
+                                <td>temperature</td>
+                                <td>number</td>
+                                <td>否</td>
+                                <td>采样温度，控制随机性</td>
+                            </tr>
+                            <tr>
+                               <td>max_tokens</td>
+                               <td>integer</td>
+                               <td>否</td>
+                               <td>生成的最大令牌数</td>
+                           </tr>
+                           <tr>
+                               <td>enable_thinking</td>
+                               <td>boolean</td>
+                               <td>否</td>
+                               <td>是否启用思考功能，默认使用环境变量 ENABLE_THINKING 的值</td>
+                           </tr>
+                        </tbody>
+                    </table>
+                </div>
+                <div class="parameters">
+                    <h4>消息格式</h4>
+                    <table>
+                        <thead>
+                            <tr>
+                                <th>字段</th>
+                                <th>类型</th>
+                                <th>说明</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr>
+                                <td>role</td>
+                                <td>string</td>
+                                <td>消息角色，可选值：system、user、assistant</td>
+                            </tr>
+                            <tr>
+                                <td>content</td>
+                                <td>string</td>
+                                <td>消息内容</td>
+                            </tr>
+                        </tbody>
+                    </table>
+                </div>
+            </div>
+        </section>
+        <section id="examples">
+            <h2>使用示例</h2>
+            <div class="tab">
+                <button class="tablinks active" onclick="openTab(event, 'python-tab')">Python</button>
+                <button class="tablinks" onclick="openTab(event, 'curl-tab')">cURL</button>
+                <button class="tablinks" onclick="openTab(event, 'javascript-tab')">JavaScript</button>
+            </div>
+            <div id="python-tab" class="tabcontent" style="display: block;">
+                <h3>Python示例</h3>
+                <div class="example">
+import openai
+# 配置客户端
+client = openai.OpenAI(
+    api_key="your-api-key",  # 对应 DEFAULT_KEY
+    base_url="http://localhost:7860/v1"
+)
+# 非流式请求
+response = client.chat.completions.create(
+    model="GLM-4.5",
+    messages=[{"role": "user", "content": "你好，请介绍一下自己"}]
+)
+print(response.choices[0].message.content)
+# 流式请求
+response = client.chat.completions.create(
+    model="GLM-4.5",
+    messages=[{"role": "user", "content": "请写一首关于春天的诗"}],
+    stream=True
+)
+for chunk in response:
+    if chunk.choices[0].delta.content:
+        print(chunk.choices[0].delta.content, end="")</div>
+            </div>
+            <div id="curl-tab" class="tabcontent">
+                <h3>cURL示例</h3>
+                <div class="example">
+# 非流式请求
+curl -X POST http://localhost:7860/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer your-api-key" \
+  -d '{
+    "model": "GLM-4.5",
+    "messages": [{"role": "user", "content": "你好"}],
+    "stream": false
+  }'
+# 流式请求
+curl -X POST http://localhost:7860/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer your-api-key" \
+  -d '{
+    "model": "GLM-4.5",
+    "messages": [{"role": "user", "content": "你好"}],
+    "stream": true
+  }'</div>
+# 启用思考功能的请求
+curl -X POST http://localhost:7860/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer your-api-key" \
+  -d '{
+    "model": "GLM-4.5",
+    "messages": [{"role": "user", "content": "请分析一下这个问题"}],
+    "enable_thinking": true
+  }'
+            </div>
+            <div id="javascript-tab" class="tabcontent">
+                <h3>JavaScript示例</h3>
+                <div class="example">
+const fetch = require('node-fetch');
+async function chatWithGLM(message, stream = false) {
+  const response = await fetch('http://localhost:7860/v1/chat/completions', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': 'Bearer your-api-key'
+    },
+    body: JSON.stringify({
+      model: 'GLM-4.5',
+      messages: [{ role: 'user', content: message }],
+      stream: stream
+    })
+  });
+  if (stream) {
+    // 处理流式响应
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const chunk = decoder.decode(value);
+      const lines = chunk.split('\n');
+      for (const line of lines) {
+        if (line.startsWith('data: ')) {
+          const data = line.slice(6);
+          if (data === '[DONE]') {
+            console.log('\n流式响应完成');
+            return;
+          }
+          try {
+            const parsed = JSON.parse(data);
+            const content = parsed.choices[0]?.delta?.content;
+            if (content) {
+              process.stdout.write(content);
+            }
+          } catch (e) {
+            // 忽略解析错误
+          }
+        }
+      }
+    }
+  } else {
+    // 处理非流式响应
+    const data = await response.json();
+    console.log(data.choices[0].message.content);
+  }
+}
+// 使用示例
+chatWithGLM('你好，请介绍一下JavaScript', false);</div>
+            </div>
+        </section>
+        <section id="error-handling">
+            <h2>错误处理</h2>
+            <p>API使用标准HTTP状态码来表示请求的成功或失败：</p>
+            <table>
+                <thead>
+                    <tr>
+                        <th>状态码</th>
+                        <th>说明</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    <tr>
+                        <td>200 OK</td>
+                        <td>请求成功</td>
+                    </tr>
+                    <tr>
+                        <td>400 Bad Request</td>
+                        <td>请求格式错误或参数无效</td>
+                    </tr>
+                    <tr>
+                        <td>401 Unauthorized</td>
+                        <td>API密钥无效或缺失</td>
+                    </tr>
+                    <tr>
+                        <td>502 Bad Gateway</td>
+                        <td>上游服务错误</td>
+                    </tr>
+                </tbody>
+            </table>
+            <div class="note">
+                <strong>注意:</strong> 在调试模式下，服务器会输出详细的日志信息，可以通过设置环境变量 DEBUG_MODE=true 来启用。
+            </div>
+        </section>
+    </div>
+    <script>
+        function openTab(evt, tabName) {
+            var i, tabcontent, tablinks;
+            tabcontent = document.getElementsByClassName("tabcontent");
+            for (i = 0; i < tabcontent.length; i++) {
+                tabcontent[i].style.display = "none";
+            }
+            tablinks = document.getElementsByClassName("tablinks");
+            for (i = 0; i < tablinks.length; i++) {
+                tablinks[i].className = tablinks[i].className.replace(" active", "");
+            }
+            document.getElementById(tabName).style.display = "block";
+            evt.currentTarget.className += " active";
+        }
+    </script>
+</body>
+</html>`
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	fmt.Fprint(w, tmpl)
+}
+
 func handleOptions(w http.ResponseWriter, r *http.Request) {
 	setCORSHeaders(w)
 	if r.Method == "OPTIONS" {
@@ -243,6 +1400,7 @@ func setCORSHeaders(w http.ResponseWriter) {
 	w.Header().Set("Access-Control-Allow-Credentials", "true")
 }
 
+// 修改 handleModels 函数，调用 getModels
 func handleModels(w http.ResponseWriter, r *http.Request) {
 	setCORSHeaders(w)
 	if r.Method == "OPTIONS" {
@@ -252,14 +1410,7 @@ func handleModels(w http.ResponseWriter, r *http.Request) {
 
 	response := ModelsResponse{
 		Object: "list",
-		Data: []Model{
-			{
-				ID:      MODEL_NAME,
-				Object:  "model",
-				Created: time.Now().Unix(),
-				OwnedBy: "z.ai",
-			},
-		},
+		Data:   getModels(), // 调用 getModels 获取列表
 	}
 
 	w.Header().Set("Content-Type", "application/json")
@@ -267,69 +1418,109 @@ func handleModels(w http.ResponseWriter, r *http.Request) {
 }
 
 func handleChatCompletions(w http.ResponseWriter, r *http.Request) {
+	startTime := time.Now()
+	path := r.URL.Path
+	clientIP := getClientIP(r)
+	userAgent := r.UserAgent()
 	setCORSHeaders(w)
 	if r.Method == "OPTIONS" {
 		w.WriteHeader(http.StatusOK)
 		return
 	}
-
 	debugLog("收到chat completions请求")
 
-	// // 验证API Key
-	// authHeader := r.Header.Get("Authorization")
-	// if !strings.HasPrefix(authHeader, "Bearer ") {
-	// 	debugLog("缺少或无效的Authorization头")
-	// 	http.Error(w, "Missing or invalid Authorization header", http.StatusUnauthorized)
-	// 	return
-	// }
-	// // 去除key验证
-	// apiKey := strings.TrimPrefix(authHeader, "Bearer ")
-	// if apiKey != DEFAULT_KEY {
-	// 	debugLog("无效的API key: %s", apiKey)
-	// 	http.Error(w, "Invalid API key", http.StatusUnauthorized)
-	// 	return
-	// }
-
-	// debugLog("API key验证通过")
-
+	// 验证API Key
+	authHeader := r.Header.Get("Authorization")
+	if !strings.HasPrefix(authHeader, "Bearer ") {
+		debugLog("缺少或无效的Authorization头")
+		http.Error(w, "Missing or invalid Authorization header", http.StatusUnauthorized)
+		// 记录请求统计
+		duration := time.Since(startTime)
+		recordRequestStats(startTime, path, http.StatusUnauthorized)
+		addLiveRequest(r.Method, path, http.StatusUnauthorized, duration, "", userAgent)
+		return
+	}
+	//apiKey := strings.TrimPrefix(authHeader, "Bearer ")
+	//if apiKey != DEFAULT_KEY {
+	//	debugLog("无效的API key: %s", apiKey)
+	//	http.Error(w, "Invalid API key", http.StatusUnauthorized)
+	//	// 记录请求统计
+	//	duration := time.Since(startTime)
+	//	recordRequestStats(startTime, path, http.StatusUnauthorized)
+	//	addLiveRequest(r.Method, path, http.StatusUnauthorized, duration, "", userAgent)
+	//	return
+	//}
+	//
+	//debugLog("API key验证通过")
 	// 读取请求体
 	body, err := io.ReadAll(r.Body)
 	if err != nil {
 		debugLog("读取请求体失败: %v", err)
 		http.Error(w, "Failed to read request body", http.StatusBadRequest)
+		// 记录请求统计
+		duration := time.Since(startTime)
+		recordRequestStats(startTime, path, http.StatusBadRequest)
+		addLiveRequest(r.Method, path, http.StatusBadRequest, duration, "", userAgent)
 		return
 	}
-
 	// 解析请求
 	var req OpenAIRequest
 	if err := json.Unmarshal(body, &req); err != nil {
 		debugLog("JSON解析失败: %v", err)
 		http.Error(w, "Invalid JSON", http.StatusBadRequest)
+		// 记录请求统计
+		duration := time.Since(startTime)
+		recordRequestStats(startTime, path, http.StatusBadRequest)
+		addLiveRequest(r.Method, path, http.StatusBadRequest, duration, "", userAgent)
 		return
 	}
 
+	// --- 模型映射逻辑 ---
+	models := getModels()
+	modelExists := false
+	for _, m := range models {
+		if m.ID == req.Model {
+			modelExists = true
+			break
+		}
+	}
+	actualUpstreamModelID := req.Model // 默认使用请求的模型ID
+	if !modelExists {
+		debugLog("未知模型 '%s'，映射到默认上游模型 '%s'", req.Model, DEFAULT_UPSTREAM_MODEL_ID)
+		actualUpstreamModelID = DEFAULT_UPSTREAM_MODEL_ID // 映射到默认模型
+	}
+	// --- 模型映射逻辑结束 ---
+
 	// 如果客户端没有明确指定stream参数，使用默认值
 	if !bytes.Contains(body, []byte(`"stream"`)) {
 		req.Stream = DEFAULT_STREAM
 		debugLog("客户端未指定stream参数，使用默认值: %v", DEFAULT_STREAM)
 	}
-
-	debugLog("请求解析成功 - 模型: %s, 流式: %v, 消息数: %d", req.Model, req.Stream, len(req.Messages))
+	debugLog("请求解析成功 - 模型: %s (映射后: %s), 流式: %v, 消息数: %d", req.Model, actualUpstreamModelID, req.Stream, len(req.Messages))
 
 	// 生成会话相关ID
 	chatID := fmt.Sprintf("%d-%d", time.Now().UnixNano(), time.Now().Unix())
 	msgID := fmt.Sprintf("%d", time.Now().UnixNano())
 
-	// 构造上游请求
+	// 决定是否启用思考功能：优先使用请求参数，其次使用环境变量
+	enableThinking := ENABLE_THINKING // 默认使用环境变量值
+	if req.EnableThinking != nil {
+		enableThinking = *req.EnableThinking
+		debugLog("使用请求参数中的思考功能设置: %v", enableThinking)
+	} else {
+		debugLog("使用环境变量中的思考功能设置: %v", enableThinking)
+	}
+
+	// 构造上游请求 - 使用映射后的模型ID
 	upstreamReq := UpstreamRequest{
 		Stream:   true, // 总是使用流式从上游获取
 		ChatID:   chatID,
 		ID:       msgID,
-		Model:    "0727-360B-API", // 上游实际模型ID
+		Model:    actualUpstreamModelID, // 使用映射后的ID
 		Messages: req.Messages,
 		Params:   map[string]interface{}{},
 		Features: map[string]interface{}{
-			"enable_thinking": true,
+			"enable_thinking": enableThinking,
 		},
 		BackgroundTasks: map[string]bool{
 			"title_generation": false,
@@ -340,7 +1531,7 @@ func handleChatCompletions(w http.ResponseWriter, r *http.Request) {
 			ID      string `json:"id"`
 			Name    string `json:"name"`
 			OwnedBy string `json:"owned_by"`
-		}{ID: "0727-360B-API", Name: "GLM-4.5", OwnedBy: "openai"},
+		}{ID: actualUpstreamModelID, Name: req.Model, OwnedBy: "openai"}, // ModelItem.ID也用映射后���，Name可以保留原始请求的ID或按需设置
 		ToolServers: []string{},
 		Variables: map[string]string{
 			"{{USER_NAME}}":        "User",
@@ -350,7 +1541,7 @@ func handleChatCompletions(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// 选择本次对话使用的token
-	authToken := UPSTREAM_TOKEN
+	authToken := ZAI_TOKEN
 	if ANON_TOKEN_ENABLED {
 		if t, err := getAnonymousToken(); err == nil {
 			authToken = t
@@ -365,11 +1556,11 @@ func handleChatCompletions(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	// 调用上游API
+	// 调用上游API，传入原始请求的模型ID用于响应
 	if req.Stream {
-		handleStreamResponseWithIDs(w, upstreamReq, chatID, authToken)
+		handleStreamResponseWithIDs(w, upstreamReq, chatID, authToken, startTime, path, clientIP, userAgent, req.Model) // 传入原始模型ID
 	} else {
-		handleNonStreamResponseWithIDs(w, upstreamReq, chatID, authToken)
+		handleNonStreamResponseWithIDs(w, upstreamReq, chatID, authToken, startTime, path, clientIP, userAgent, req.Model) // 传入原始模型ID
 	}
 }
 
@@ -379,16 +1570,13 @@ func callUpstreamWithHeaders(upstreamReq UpstreamRequest, refererChatID string,
 		debugLog("上游请求序列化失败: %v", err)
 		return nil, err
 	}
-
 	debugLog("调用上游API: %s", UPSTREAM_URL)
 	debugLog("上游请求体: %s", string(reqBody))
-
 	req, err := http.NewRequest("POST", UPSTREAM_URL, bytes.NewBuffer(reqBody))
 	if err != nil {
 		debugLog("创建HTTP请求失败: %v", err)
 		return nil, err
 	}
-
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("Accept", "application/json, text/event-stream")
 	req.Header.Set("User-Agent", BROWSER_UA)
@@ -400,29 +1588,30 @@ func callUpstreamWithHeaders(upstreamReq UpstreamRequest, refererChatID string,
 	req.Header.Set("X-FE-Version", X_FE_VERSION)
 	req.Header.Set("Origin", ORIGIN_BASE)
 	req.Header.Set("Referer", ORIGIN_BASE+"/c/"+refererChatID)
-
 	client := &http.Client{Timeout: 60 * time.Second}
 	resp, err := client.Do(req)
 	if err != nil {
 		debugLog("上游请求失败: %v", err)
 		return nil, err
 	}
-
 	debugLog("上游响应状态: %d %s", resp.StatusCode, resp.Status)
 	return resp, nil
 }
 
-func handleStreamResponseWithIDs(w http.ResponseWriter, upstreamReq UpstreamRequest, chatID string, authToken string) {
-	debugLog("开始处理流式响应 (chat_id=%s)", chatID)
-
+// 修改 handleStreamResponseWithIDs 函数，增加原始模型ID参数
+func handleStreamResponseWithIDs(w http.ResponseWriter, upstreamReq UpstreamRequest, chatID string, authToken string, startTime time.Time, path string, clientIP, userAgent string, originalModelID string) { // 增加 originalModelID 参数
+	debugLog("开始处理流式响应 (chat_id=%s, original_model=%s)", chatID, originalModelID)
 	resp, err := callUpstreamWithHeaders(upstreamReq, chatID, authToken)
 	if err != nil {
 		debugLog("调用上游失败: %v", err)
 		http.Error(w, "Failed to call upstream", http.StatusBadGateway)
+		// 记录请求统计
+		duration := time.Since(startTime)
+		recordRequestStats(startTime, path, http.StatusBadGateway)
+		addLiveRequest("POST", path, http.StatusBadGateway, duration, "", userAgent)
 		return
 	}
 	defer resp.Body.Close()
-
 	if resp.StatusCode != http.StatusOK {
 		debugLog("上游返回错误状态: %d", resp.StatusCode)
 		// 读取错误响应体
@@ -431,6 +1620,10 @@ func handleStreamResponseWithIDs(w http.ResponseWriter, upstreamReq UpstreamRequ
 			debugLog("上游错误响应: %s", string(body))
 		}
 		http.Error(w, "Upstream error", http.StatusBadGateway)
+		// 记录请求统计
+		duration := time.Since(startTime)
+		recordRequestStats(startTime, path, http.StatusBadGateway)
+		addLiveRequest("POST", path, http.StatusBadGateway, duration, "", userAgent)
 		return
 	}
 
@@ -453,7 +1646,7 @@ func handleStreamResponseWithIDs(w http.ResponseWriter, upstreamReq UpstreamRequ
 		}
 		// 处理每行前缀 "> "（包括起始位置）
 		s = strings.TrimPrefix(s, "> ")
-		s = strings.ReplaceAll(s, "\n> ", "\n")
+		s = strings.ReplaceAll(s, "\n> ", "\n") // <--- 修正换行符
 		return strings.TrimSpace(s)
 	}
 
@@ -461,19 +1654,18 @@ func handleStreamResponseWithIDs(w http.ResponseWriter, upstreamReq UpstreamRequ
 	w.Header().Set("Content-Type", "text/event-stream")
 	w.Header().Set("Cache-Control", "no-cache")
 	w.Header().Set("Connection", "keep-alive")
-
 	flusher, ok := w.(http.Flusher)
 	if !ok {
 		http.Error(w, "Streaming unsupported", http.StatusInternalServerError)
 		return
 	}
 
-	// 发送第一个chunk（role）
+	// 发送第一个chunk（role），使用原始模型ID
 	firstChunk := OpenAIResponse{
 		ID:      fmt.Sprintf("chatcmpl-%d", time.Now().Unix()),
 		Object:  "chat.completion.chunk",
 		Created: time.Now().Unix(),
-		Model:   MODEL_NAME,
+		Model:   originalModelID, // 使用原始模型ID
 		Choices: []Choice{
 			{
 				Index: 0,
@@ -488,22 +1680,17 @@ func handleStreamResponseWithIDs(w http.ResponseWriter, upstreamReq UpstreamRequ
 	debugLog("开始读取上游SSE流")
 	scanner := bufio.NewScanner(resp.Body)
 	lineCount := 0
-
 	for scanner.Scan() {
 		line := scanner.Text()
 		lineCount++
-
 		if !strings.HasPrefix(line, "data: ") {
 			continue
 		}
-
 		dataStr := strings.TrimPrefix(line, "data: ")
 		if dataStr == "" {
 			continue
 		}
-
 		debugLog("收到SSE数据 (第%d行): %s", lineCount, dataStr)
-
 		var upstreamData UpstreamData
 		if err := json.Unmarshal([]byte(dataStr), &upstreamData); err != nil {
 			debugLog("SSE数据解析失败: %v", err)
@@ -525,11 +1712,11 @@ func handleStreamResponseWithIDs(w http.ResponseWriter, upstreamReq UpstreamRequ
 				ID:      fmt.Sprintf("chatcmpl-%d", time.Now().Unix()),
 				Object:  "chat.completion.chunk",
 				Created: time.Now().Unix(),
-				Model:   MODEL_NAME,
+				Model:   originalModelID, // 使用原始模型ID
 				Choices: []Choice{{Index: 0, Delta: Delta{}, FinishReason: "stop"}},
 			}
 			writeSSEChunk(w, endChunk)
-			fmt.Fprintf(w, "data: [DONE]\n\n")
+			fmt.Fprintf(w, "data: [DONE]\n")
 			flusher.Flush()
 			break
 		}
@@ -549,7 +1736,7 @@ func handleStreamResponseWithIDs(w http.ResponseWriter, upstreamReq UpstreamRequ
 					ID:      fmt.Sprintf("chatcmpl-%d", time.Now().Unix()),
 					Object:  "chat.completion.chunk",
 					Created: time.Now().Unix(),
-					Model:   MODEL_NAME,
+					Model:   originalModelID, // 使用原始模型ID
 					Choices: []Choice{
 						{
 							Index: 0,
@@ -570,7 +1757,7 @@ func handleStreamResponseWithIDs(w http.ResponseWriter, upstreamReq UpstreamRequ
 				ID:      fmt.Sprintf("chatcmpl-%d", time.Now().Unix()),
 				Object:  "chat.completion.chunk",
 				Created: time.Now().Unix(),
-				Model:   MODEL_NAME,
+				Model:   originalModelID, // 使用原始模型ID
 				Choices: []Choice{
 					{
 						Index:        0,
@@ -581,36 +1768,42 @@ func handleStreamResponseWithIDs(w http.ResponseWriter, upstreamReq UpstreamRequ
 			}
 			writeSSEChunk(w, endChunk)
 			flusher.Flush()
-
 			// 发送[DONE]
-			fmt.Fprintf(w, "data: [DONE]\n\n")
+			fmt.Fprintf(w, "data: [DONE]\n")
 			flusher.Flush()
 			debugLog("流式响应完成，共处理%d行", lineCount)
 			break
 		}
 	}
-
 	if err := scanner.Err(); err != nil {
 		debugLog("扫描器错误: %v", err)
 	}
+
+	// 记录成功请求统计
+	duration := time.Since(startTime)
+	recordRequestStats(startTime, path, http.StatusOK)
+	addLiveRequest("POST", path, http.StatusOK, duration, "", userAgent)
 }
 
 func writeSSEChunk(w http.ResponseWriter, chunk OpenAIResponse) {
 	data, _ := json.Marshal(chunk)
-	fmt.Fprintf(w, "data: %s\n\n", data)
+	fmt.Fprintf(w, "data: %s\n", data)
 }
 
-func handleNonStreamResponseWithIDs(w http.ResponseWriter, upstreamReq UpstreamRequest, chatID string, authToken string) {
-	debugLog("开始处理非流式响应 (chat_id=%s)", chatID)
-
+// 修改 handleNonStreamResponseWithIDs 函数，增加原始模型ID参数
+func handleNonStreamResponseWithIDs(w http.ResponseWriter, upstreamReq UpstreamRequest, chatID string, authToken string, startTime time.Time, path string, clientIP, userAgent string, originalModelID string) { // 增加 originalModelID 参数
+	debugLog("开始处理非流式响应 (chat_id=%s, original_model=%s)", chatID, originalModelID)
 	resp, err := callUpstreamWithHeaders(upstreamReq, chatID, authToken)
 	if err != nil {
 		debugLog("调用上游失败: %v", err)
 		http.Error(w, "Failed to call upstream", http.StatusBadGateway)
+		// 记录请求统计
+		duration := time.Since(startTime)
+		recordRequestStats(startTime, path, http.StatusBadGateway)
+		addLiveRequest("POST", path, http.StatusBadGateway, duration, "", userAgent)
 		return
 	}
 	defer resp.Body.Close()
-
 	if resp.StatusCode != http.StatusOK {
 		debugLog("上游返回错误状态: %d", resp.StatusCode)
 		// 读取错误响应体
@@ -619,6 +1812,10 @@ func handleNonStreamResponseWithIDs(w http.ResponseWriter, upstreamReq UpstreamR
 			debugLog("上游错误响应: %s", string(body))
 		}
 		http.Error(w, "Upstream error", http.StatusBadGateway)
+		// 记录请求统计
+		duration := time.Since(startTime)
+		recordRequestStats(startTime, path, http.StatusBadGateway)
+		addLiveRequest("POST", path, http.StatusBadGateway, duration, "", userAgent)
 		return
 	}
 
@@ -626,23 +1823,19 @@ func handleNonStreamResponseWithIDs(w http.ResponseWriter, upstreamReq UpstreamR
 	var fullContent strings.Builder
 	scanner := bufio.NewScanner(resp.Body)
 	debugLog("开始收集完整响应内容")
-
 	for scanner.Scan() {
 		line := scanner.Text()
 		if !strings.HasPrefix(line, "data: ") {
 			continue
 		}
-
 		dataStr := strings.TrimPrefix(line, "data: ")
 		if dataStr == "" {
 			continue
 		}
-
 		var upstreamData UpstreamData
 		if err := json.Unmarshal([]byte(dataStr), &upstreamData); err != nil {
 			continue
 		}
-
 		if upstreamData.Data.DeltaContent != "" {
 			out := upstreamData.Data.DeltaContent
 			if upstreamData.Data.Phase == "thinking" {
@@ -662,7 +1855,7 @@ func handleNonStreamResponseWithIDs(w http.ResponseWriter, upstreamReq UpstreamR
 						s = strings.ReplaceAll(s, "</details>", "")
 					}
 					s = strings.TrimPrefix(s, "> ")
-					s = strings.ReplaceAll(s, "\n> ", "\n")
+					s = strings.ReplaceAll(s, "\n> ", "\n") // <--- 修正换行符
 					return strings.TrimSpace(s)
 				}(out)
 			}
@@ -670,22 +1863,20 @@ func handleNonStreamResponseWithIDs(w http.ResponseWriter, upstreamReq UpstreamR
 				fullContent.WriteString(out)
 			}
 		}
-
 		if upstreamData.Data.Done || upstreamData.Data.Phase == "done" {
 			debugLog("检测到完成信号，停止收集")
 			break
 		}
 	}
-
 	finalContent := fullContent.String()
 	debugLog("内容收集完成，最终长度: %d", len(finalContent))
 
-	// 构造完整响应
+	// 构造完整响应，使用原始模型ID
 	response := OpenAIResponse{
 		ID:      fmt.Sprintf("chatcmpl-%d", time.Now().Unix()),
 		Object:  "chat.completion",
 		Created: time.Now().Unix(),
-		Model:   MODEL_NAME,
+		Model:   originalModelID, // 使用原始模型ID
 		Choices: []Choice{
 			{
 				Index: 0,
@@ -702,8 +1893,12 @@ func handleNonStreamResponseWithIDs(w http.ResponseWriter, upstreamReq UpstreamR
 			TotalTokens:      0,
 		},
 	}
-
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(response)
 	debugLog("非流式响应发送完成")
+
+	// 记录成功请求统计
+	duration := time.Since(startTime)
+	recordRequestStats(startTime, path, http.StatusOK)
+	addLiveRequest("POST", path, http.StatusOK, duration, "", userAgent)
 }