Update main.go

main.go

@@ -8,26 +8,23 @@ import (
 	"io"
 	"log"
 	"net/http"
-	"os"
 	"regexp"
 	"strings"
 	"sync"
 	"time"
 )
 
-// 配置变量（从环境变量读取）
+// 配置变量（硬编码，不再从环境变量读取）
 var (
-	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
+	UPSTREAM_URL      = "https://chat.z.ai/api/chat/completions"
+	MODELS_URL        = "https://chat.z.ai/api/models"
+	DEFAULT_KEY       = "sk-your-key"
+	ZAI_TOKEN         = ""
+	MODEL_NAME        = "GLM-4.5"
+	PORT              = ":7860"
+	DEBUG_MODE        = true
+	DEFAULT_STREAM    = true
+	DASHBOARD_ENABLED = true
 )
 
 // 请求统计信息
@@ -50,32 +47,40 @@ type LiveRequest struct {
 	UserAgent string    `json:"user_agent"`
 }
 
-// 上游模型响应结构 (新增)
-type UpstreamModelsResponse struct {
-	Object string          `json:"object"`
-	Data   []UpstreamModel `json:"data"`
-}
+// 全局变量
+var (
+	stats         RequestStats
+	liveRequests  = []LiveRequest{}
+	statsMutex    sync.Mutex
+	requestsMutex sync.Mutex
+	startTime     = time.Now() // 服务启动时间
+)
 
-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"`
-}
+// 思考内容处理策略
+const (
+	THINK_TAGS_MODE = "strip" // strip: 去除<details>标签；think: 转为<think>标签；raw: 保留原样
+)
+
+// 伪装前端头部（来自抓包）
+const (
+	X_FE_VERSION   = "prod-fe-1.0.76"
+	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"
+	SEC_CH_UA      = "\"Not;A=Brand\";v=\"99\", \"Edge\";v=\"139\""
+	SEC_CH_UA_MOB  = "?0"
+	SEC_CH_UA_PLAT = "\"Windows\""
+	ORIGIN_BASE    = "https://chat.z.ai"
+)
+
+// 匿名token开关
+const ANON_TOKEN_ENABLED = true
 
 // 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"`
-	EnableThinking *bool     `json:"enable_thinking,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"`
 }
 
 type Message struct {
@@ -133,18 +138,17 @@ type Usage struct {
 
 // 上游SSE响应结构
 type UpstreamData struct {
-	Type string `json:"type"`
-	Data struct {
-		DeltaContent string         `json:"delta_content"`
+	Type  string         `json:"type"`
+	Error *UpstreamError `json:"error,omitempty"`
+	Data  struct {
 		Phase        string         `json:"phase"`
+		DeltaContent string         `json:"delta_content"`
 		Done         bool           `json:"done"`
-		Usage        Usage          `json:"usage,omitempty"`
 		Error        *UpstreamError `json:"error,omitempty"`
 		Inner        *struct {
 			Error *UpstreamError `json:"error,omitempty"`
-		} `json:"data,omitempty"`
+		} `json:"inner,omitempty"`
 	} `json:"data"`
-	Error *UpstreamError `json:"error,omitempty"`
 }
 
 type UpstreamError struct {
@@ -159,72 +163,41 @@ type ModelsResponse struct {
 }
 
 type Model struct {
-	ID      string `json:"id"` // 保持ID字段
+	ID      string `json:"id"`
 	Object  string `json:"object"`
-	Name    string `json:"name"` // 新增Name字段，用于显示
+	Name    string `json:"name,omitempty"`
 	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"
+// 上游模型响应结构
+type UpstreamModelsResponse struct {
+	Data []struct {
+		ID   string `json:"id"`
+		Name string `json:"name"`
+		Info struct {
+			IsActive  bool  `json:"is_active"`
+			CreatedAt int64 `json:"created_at"`
+		} `json:"info"`
+	} `json:"data"`
 }
 
 // 记录请求统计信息
 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
@@ -238,6 +211,7 @@ func recordRequestStats(startTime time.Time, path string, status int) {
 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(),
@@ -247,46 +221,15 @@ func addLiveRequest(method, path string, status int, duration time.Duration, _,
 		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头
@@ -296,10 +239,12 @@ func getClientIP(r *http.Request) string {
 			return strings.TrimSpace(ips[0])
 		}
 	}
+
 	// 检查X-Real-IP头
 	if xri := r.Header.Get("X-Real-IP"); xri != "" {
 		return xri
 	}
+
 	// 使用RemoteAddr
 	ip := r.RemoteAddr
 	// 移除端口号
@@ -309,66 +254,82 @@ func getClientIP(r *http.Request) string {
 	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
-		}
+// 调试日志
+func debugLog(format string, args ...interface{}) {
+	if DEBUG_MODE {
+		log.Printf("[DEBUG] "+format, args...)
 	}
-	return false
 }
 
-// 检查字符串是否为纯数字
-func isDigit(s string) bool {
-	for _, r := range s {
-		if r < '0' || r > '9' {
-			return false
-		}
+// 获取匿名token（每次对话使用不同token，避免共享记忆）
+func getAnonymousToken() (string, error) {
+	client := &http.Client{
+		Timeout: 10 * time.Second,
+		Transport: &http.Transport{
+			MaxIdleConns:       10,
+			IdleConnTimeout:    30 * time.Second,
+			DisableCompression: false,
+		},
 	}
-	return s != ""
-}
 
-// 格式化模型名
-func formatModelName(name string) string {
-	if name == "" {
-		return ""
+	req, err := http.NewRequest("GET", ORIGIN_BASE+"/api/v1/auths/", nil)
+	if err != nil {
+		debugLog("创建匿名token请求失败: %v", err)
+		return "", fmt.Errorf("创建请求失败: %w", err)
 	}
-	parts := strings.Split(name, "-")
-	if len(parts) == 1 {
-		return strings.ToUpper(parts[0])
+
+	// 伪装浏览器头
+	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)
+	req.Header.Set("Referer", ORIGIN_BASE+"/")
+
+	resp, err := client.Do(req)
+	if err != nil {
+		debugLog("匿名token请求失败: %v", err)
+		return "", fmt.Errorf("请求失败: %w", err)
 	}
-	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)
+	defer func() {
+		if closeErr := resp.Body.Close(); closeErr != nil {
+			debugLog("关闭响应体失败: %v", closeErr)
 		}
+	}()
+
+	if resp.StatusCode != http.StatusOK {
+		debugLog("匿名token响应状态码异常: %d", resp.StatusCode)
+		return "", fmt.Errorf("服务器响应错误，状态码: %d", resp.StatusCode)
 	}
-	return strings.Join(formatted, "-")
-}
 
-// 获取模型列表 (新增)
-func getModels() []Model {
-	modelsMutex.RLock()
-	cachedModels := modelsCache
-	modelsMutex.RUnlock()
+	var body struct {
+		Token string `json:"token"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
+		debugLog("匿名token响应解析失败: %v", err)
+		return "", fmt.Errorf("响应解析失败: %w", err)
+	}
 
-	if cachedModels != nil {
-		return cachedModels
+	if body.Token == "" {
+		debugLog("匿名token为空")
+		return "", fmt.Errorf("获取到的token为空")
 	}
 
+	debugLog("匿名token获取成功: %s...", func() string {
+		if len(body.Token) > 10 {
+			return body.Token[:10]
+		}
+		return body.Token
+	}())
+
+	return body.Token, nil
+}
+
+// 获取模型列表
+func getModels() []Model {
 	// 获取token
 	token := ZAI_TOKEN
 	if ANON_TOKEN_ENABLED {
@@ -434,15 +395,15 @@ func getModels() []Model {
 		}
 
 		modelName := m.Name
-		if modelName == "" || !isEnglishLetter([]rune(modelName)[0]) { // 确保Name不为空且首字符是字母
+		if modelName == "" || !isEnglishLetter(modelName[0]) {
 			modelName = formatModelName(m.ID)
 		}
 
 		models = append(models, Model{
 			ID:      m.ID,
 			Object:  "model",
-			Name:    modelName,        // 使用格式化后的名称或原始Name
-			Created: m.Info.CreatedAt, // 使用上游的CreatedAt
+			Name:    modelName,
+			Created: m.Info.CreatedAt,
 			OwnedBy: "z.ai",
 		})
 	}
@@ -451,956 +412,212 @@ func getModels() []Model {
 		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",
-		},
+// 格式化模型名
+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) {
+			formatted = append(formatted, strings.Title(p))
+		} else {
+			formatted = append(formatted, p)
+		}
+	}
+	return strings.Join(formatted, "-")
 }
 
-// debug日志函数
-func debugLog(format string, args ...interface{}) {
-	if DEBUG_MODE {
-		log.Printf("[DEBUG] "+format, args...)
-	}
+// 判断是否是英文字符
+func isEnglishLetter(ch byte) bool {
+	return (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z')
 }
 
-// 获取匿名token（每次对话使用不同token，避免共享记忆）
-func getAnonymousToken() (string, error) {
-	client := &http.Client{Timeout: 10 * time.Second}
-	req, err := http.NewRequest("GET", ORIGIN_BASE+"/api/v1/auths/", nil)
-	if err != nil {
-		return "", err
-	}
-	// 伪装浏览器头
-	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)
-	req.Header.Set("Referer", ORIGIN_BASE+"/")
-	resp, err := client.Do(req)
-	if err != nil {
-		return "", err
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != http.StatusOK {
-		return "", fmt.Errorf("anon token status=%d", resp.StatusCode)
-	}
-	var body struct {
-		Token string `json:"token"`
-	}
-	if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
-		return "", err
+// 判断字符串是否全为数字
+func isDigit(s string) bool {
+	for _, ch := range s {
+		if ch < '0' || ch > '9' {
+			return false
+		}
 	}
-	if body.Token == "" {
-		return "", fmt.Errorf("anon token empty")
+	return len(s) > 0
+}
+
+// 判断字符串是否包含英文字符
+func hasEnglishLetter(s string) bool {
+	for i := 0; i < len(s); i++ {
+		if isEnglishLetter(s[i]) {
+			return true
+		}
 	}
-	return body.Token, nil
+	return false
 }
 
-func main() {
-	// 初始化配置
-	initConfig()
-	// 注册路由
-	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("/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)
+// 获取默认模型列表
+func getDefaultModels() []Model {
+	return []Model{
+		{
+			ID:      "GLM-4.5",
+			Object:  "model",
+			Name:    "GLM-4.5",
+			Created: time.Now().Unix(),
+			OwnedBy: "z.ai",
+		},
+		{
+			ID:      "0727-360B-API",
+			Object:  "model",
+			Name:    "GLM-4.5",
+			Created: time.Now().Unix(),
+			OwnedBy: "z.ai",
+		},
 	}
-	log.Printf("OpenAI兼容API服务器启动在端口%s", PORT)
-	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)
+// 处理统计页面请求
+func handleStats(w http.ResponseWriter, r *http.Request) {
+	setCORSHeaders(w)
+	if r.Method == "OPTIONS" {
+		w.WriteHeader(http.StatusOK)
 		return
 	}
-	// 简单的HTML模板
-	tmpl := `<!DOCTYPE html>
+
+	statsMutex.Lock()
+	currentStats := stats
+	statsMutex.Unlock()
+
+	requestsMutex.Lock()
+	currentRequests := make([]LiveRequest, len(liveRequests))
+	copy(currentRequests, liveRequests)
+	requestsMutex.Unlock()
+
+	// 计算运行时间
+	uptime := time.Since(startTime)
+
+	// 构建HTML页面
+	html := fmt.Sprintf(`
+<!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>
+    <title>OpenAI兼容服务统计信息</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);
-        }
+        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; margin: 0; padding: 20px; background: #f5f5f5; }
+        .container { max-width: 1200px; margin: 0 auto; }
+        .header { background: white; padding: 20px; border-radius: 8px; margin-bottom: 20px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
+        .stats-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); gap: 20px; margin-bottom: 20px; }
+        .stat-card { background: white; padding: 20px; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
+        .stat-value { font-size: 2em; font-weight: bold; color: #2563eb; }
+        .stat-label { color: #6b7280; margin-top: 5px; }
+        .requests-table { background: white; border-radius: 8px; overflow: hidden; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
+        .table-header { background: #f9fafb; padding: 15px; font-weight: bold; border-bottom: 1px solid #e5e7eb; }
+        .table-row { padding: 10px 15px; border-bottom: 1px solid #f3f4f6; display: grid; grid-template-columns: 1fr 1fr 1fr 1fr 1fr; gap: 10px; }
+        .status-200 { color: #059669; }
+        .status-400, .status-401 { color: #dc2626; }
+        .status-500, .status-502 { color: #b91c1c; }
+        .refresh-btn { background: #2563eb; color: white; border: none; padding: 10px 20px; border-radius: 6px; cursor: pointer; }
+        .refresh-btn:hover { background: #1d4ed8; }
     </style>
+    <script>
+        function refreshPage() { location.reload(); }
+        setInterval(refreshPage, 30000); // 30秒自动刷新
+    </script>
 </head>
 <body>
     <div class="container">
-        <h1>API调用看板</h1>
-        <div class="stats-container">
+        <div class="header">
+            <h1>OpenAI兼容API服务器 - 统计信息</h1>
+            <p>服务运行时间: %s | 最后更新: %s</p>
+            <button class="refresh-btn" onclick="refreshPage()">刷新数据</button>
+        </div>
+        
+        <div class="stats-grid">
             <div class="stat-card">
-                <div class="stat-value" id="total-requests">0</div>
+                <div class="stat-value">%d</div>
                 <div class="stat-label">总请求数</div>
             </div>
             <div class="stat-card">
-                <div class="stat-value" id="successful-requests">0</div>
+                <div class="stat-value">%d</div>
                 <div class="stat-label">成功请求</div>
             </div>
             <div class="stat-card">
-                <div class="stat-value" id="failed-requests">0</div>
+                <div class="stat-value">%d</div>
                 <div class="stat-label">失败请求</div>
             </div>
             <div class="stat-card">
-                <div class="stat-value" id="avg-response-time">0s</div>
+                <div class="stat-value">%.2fms</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())
-}
+        <div class="requests-table">
+            <div class="table-header">最近请求记录 (最多显示50条)</div>
+            <div class="table-row" style="font-weight: bold; background: #f9fafb;">
+                <div>时间</div>
+                <div>方法</div>
+                <div>路径</div>
+                <div>状态码</div>
+                <div>响应时间</div>
+            </div>`,
+		uptime.Round(time.Second),
+		time.Now().Format("2006-01-02 15:04:05"),
+		currentStats.TotalRequests,
+		currentStats.SuccessfulRequests,
+		currentStats.FailedRequests,
+		float64(currentStats.AverageResponseTime.Nanoseconds())/1000000,
+	)
+
+	// 添加最近的请求记录
+	for i := len(currentRequests) - 1; i >= 0 && len(currentRequests)-i <= 50; i-- {
+		req := currentRequests[i]
+		statusClass := "status-200"
+		if req.Status >= 400 && req.Status < 500 {
+			statusClass = "status-400"
+		} else if req.Status >= 500 {
+			statusClass = "status-500"
+		}
 
-// 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>
+		html += fmt.Sprintf(`
+            <div class="table-row">
+                <div>%s</div>
+                <div>%s</div>
+                <div>%s</div>
+                <div class="%s">%d</div>
+                <div>%.2fms</div>
+            </div>`,
+			req.Timestamp.Format("15:04:05"),
+			req.Method,
+			req.Path,
+			statusClass,
+			req.Status,
+			float64(req.Duration)/1000000, // Duration已经是纳秒，直接转换为毫秒
+		)
+	}
+
+	html += `
         </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" {
-		w.WriteHeader(http.StatusOK)
-		return
-	}
-	w.WriteHeader(http.StatusNotFound)
-}
-
-func setCORSHeaders(w http.ResponseWriter) {
-	w.Header().Set("Access-Control-Allow-Origin", "*")
-	w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
-	w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
-	w.Header().Set("Access-Control-Allow-Credentials", "true")
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	w.WriteHeader(http.StatusOK)
+	w.Write([]byte(html))
 }
 
-// 修改 handleModels 函数，调用 getModels
+// 处理模型列表请求
 func handleModels(w http.ResponseWriter, r *http.Request) {
 	setCORSHeaders(w)
 	if r.Method == "OPTIONS" {
@@ -1410,48 +627,64 @@ func handleModels(w http.ResponseWriter, r *http.Request) {
 
 	response := ModelsResponse{
 		Object: "list",
-		Data:   getModels(), // 调用 getModels 获取列表
+		Data:   getModels(),
 	}
 
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(response)
 }
 
+// 设置CORS头
+func setCORSHeaders(w http.ResponseWriter) {
+	w.Header().Set("Access-Control-Allow-Origin", "*")
+	w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
+	w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
+	w.Header().Set("Access-Control-Allow-Credentials", "true")
+}
+
+// 处理聊天完成请求
 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)
-		// 记录请求统计
-		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验证通过")
+	//// 验证API Key（可选）
+	// authHeader := r.Header.Get("Authorization")
+	// if authHeader != "" {
+	// 	if !strings.HasPrefix(authHeader, "Bearer ") {
+	// 		debugLog("无效的Authorization头格式")
+	// 		http.Error(w, "Invalid Authorization header format", 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验证通过")
+	// } else {
+	// 	debugLog("无Authorization头，允许匿名访问")
+	// }
+
 	// 读取请求体
 	body, err := io.ReadAll(r.Body)
 	if err != nil {
@@ -1463,6 +696,7 @@ func handleChatCompletions(w http.ResponseWriter, r *http.Request) {
 		addLiveRequest(r.Method, path, http.StatusBadRequest, duration, "", userAgent)
 		return
 	}
+
 	// 解析请��
 	var req OpenAIRequest
 	if err := json.Unmarshal(body, &req); err != nil {
@@ -1475,52 +709,28 @@ func handleChatCompletions(w http.ResponseWriter, r *http.Request) {
 		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 (映射后: %s), 流式: %v, 消息数: %d", req.Model, actualUpstreamModelID, req.Stream, len(req.Messages))
+
+	debugLog("请求解析成功 - 模型: %s, 流式: %v, 消息数: %d", req.Model, 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:    actualUpstreamModelID, // 使用映射后的ID
+		Model:    "0727-360B-API", // 上游实际模型ID
 		Messages: req.Messages,
 		Params:   map[string]interface{}{},
 		Features: map[string]interface{}{
-			"enable_thinking": enableThinking,
+			"enable_thinking": true,
 		},
 		BackgroundTasks: map[string]bool{
 			"title_generation": false,
@@ -1531,7 +741,7 @@ func handleChatCompletions(w http.ResponseWriter, r *http.Request) {
 			ID      string `json:"id"`
 			Name    string `json:"name"`
 			OwnedBy string `json:"owned_by"`
-		}{ID: actualUpstreamModelID, Name: req.Model, OwnedBy: "openai"}, // ModelItem.ID也用映射后的，Name可以保留原始请求的ID或按需设置
+		}{ID: "0727-360B-API", Name: "GLM-4.5", OwnedBy: "openai"},
 		ToolServers: []string{},
 		Variables: map[string]string{
 			"{{USER_NAME}}":        "User",
@@ -1556,27 +766,31 @@ func handleChatCompletions(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	// 调用上游API，传入原始请求的模型ID用于响应
+	// 调用上游API
 	if req.Stream {
-		handleStreamResponseWithIDs(w, upstreamReq, chatID, authToken, startTime, path, clientIP, userAgent, req.Model) // 传入原始模型ID
+		handleStreamResponseWithIDs(w, upstreamReq, chatID, authToken, startTime, path, clientIP, userAgent)
 	} else {
-		handleNonStreamResponseWithIDs(w, upstreamReq, chatID, authToken, startTime, path, clientIP, userAgent, req.Model) // 传入原始模型ID
+		handleNonStreamResponseWithIDs(w, upstreamReq, chatID, authToken, startTime, path, clientIP, userAgent)
 	}
 }
 
+// 调用上游API并处理响应
 func callUpstreamWithHeaders(upstreamReq UpstreamRequest, refererChatID string, authToken string) (*http.Response, error) {
 	reqBody, err := json.Marshal(upstreamReq)
 	if err != nil {
 		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)
@@ -1588,19 +802,22 @@ 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
 }
 
-// 修改 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)
+// 处理流式响应
+func handleStreamResponseWithIDs(w http.ResponseWriter, upstreamReq UpstreamRequest, chatID string, authToken string, startTime time.Time, path string, clientIP string, userAgent string) {
+	debugLog("开始处理流式响应 (chat_id=%s)", chatID)
+
 	resp, err := callUpstreamWithHeaders(upstreamReq, chatID, authToken)
 	if err != nil {
 		debugLog("调用上游失败: %v", err)
@@ -1612,6 +829,7 @@ func handleStreamResponseWithIDs(w http.ResponseWriter, upstreamReq UpstreamRequ
 		return
 	}
 	defer resp.Body.Close()
+
 	if resp.StatusCode != http.StatusOK {
 		debugLog("上游返回错误状态: %d", resp.StatusCode)
 		// 读取错误响应体
@@ -1646,7 +864,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)
 	}
 
@@ -1654,18 +872,19 @@ 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），使用原始模型ID
+	// 发送第一个chunk（role）
 	firstChunk := OpenAIResponse{
 		ID:      fmt.Sprintf("chatcmpl-%d", time.Now().Unix()),
 		Object:  "chat.completion.chunk",
 		Created: time.Now().Unix(),
-		Model:   originalModelID, // 使用原始模型ID
+		Model:   MODEL_NAME,
 		Choices: []Choice{
 			{
 				Index: 0,
@@ -1680,17 +899,22 @@ 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)
@@ -1712,11 +936,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:   originalModelID, // 使用原始模型ID
+				Model:   MODEL_NAME,
 				Choices: []Choice{{Index: 0, Delta: Delta{}, FinishReason: "stop"}},
 			}
 			writeSSEChunk(w, endChunk)
-			fmt.Fprintf(w, "data: [DONE]\n")
+			fmt.Fprintf(w, "data: [DONE]\n\n")
 			flusher.Flush()
 			break
 		}
@@ -1736,7 +960,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:   originalModelID, // 使用原始模型ID
+					Model:   MODEL_NAME,
 					Choices: []Choice{
 						{
 							Index: 0,
@@ -1757,7 +981,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:   originalModelID, // 使用原始模型ID
+				Model:   MODEL_NAME,
 				Choices: []Choice{
 					{
 						Index:        0,
@@ -1768,13 +992,15 @@ func handleStreamResponseWithIDs(w http.ResponseWriter, upstreamReq UpstreamRequ
 			}
 			writeSSEChunk(w, endChunk)
 			flusher.Flush()
+
 			// 发送[DONE]
-			fmt.Fprintf(w, "data: [DONE]\n")
+			fmt.Fprintf(w, "data: [DONE]\n\n")
 			flusher.Flush()
 			debugLog("流式响应完成，共处理%d行", lineCount)
 			break
 		}
 	}
+
 	if err := scanner.Err(); err != nil {
 		debugLog("扫描器错误: %v", err)
 	}
@@ -1785,14 +1011,16 @@ func handleStreamResponseWithIDs(w http.ResponseWriter, upstreamReq UpstreamRequ
 	addLiveRequest("POST", path, http.StatusOK, duration, "", userAgent)
 }
 
+// 写入SSE块
 func writeSSEChunk(w http.ResponseWriter, chunk OpenAIResponse) {
 	data, _ := json.Marshal(chunk)
-	fmt.Fprintf(w, "data: %s\n", data)
+	fmt.Fprintf(w, "data: %s\n\n", data)
 }
 
-// 修改 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)
+// 处理非流式响应
+func handleNonStreamResponseWithIDs(w http.ResponseWriter, upstreamReq UpstreamRequest, chatID string, authToken string, startTime time.Time, path string, clientIP string, userAgent string) {
+	debugLog("开始处理非流式响应 (chat_id=%s)", chatID)
+
 	resp, err := callUpstreamWithHeaders(upstreamReq, chatID, authToken)
 	if err != nil {
 		debugLog("调用上游失败: %v", err)
@@ -1804,6 +1032,7 @@ func handleNonStreamResponseWithIDs(w http.ResponseWriter, upstreamReq UpstreamR
 		return
 	}
 	defer resp.Body.Close()
+
 	if resp.StatusCode != http.StatusOK {
 		debugLog("上游返回错误状态: %d", resp.StatusCode)
 		// 读取错误响应体
@@ -1823,19 +1052,23 @@ 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" {
@@ -1855,7 +1088,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)
 			}
@@ -1863,20 +1096,22 @@ 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:   originalModelID, // 使用原始模型ID
+		Model:   MODEL_NAME,
 		Choices: []Choice{
 			{
 				Index: 0,
@@ -1893,6 +1128,7 @@ func handleNonStreamResponseWithIDs(w http.ResponseWriter, upstreamReq UpstreamR
 			TotalTokens:      0,
 		},
 	}
+
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(response)
 	debugLog("非流式响应发送完成")
@@ -1902,3 +1138,37 @@ func handleNonStreamResponseWithIDs(w http.ResponseWriter, upstreamReq UpstreamR
 	recordRequestStats(startTime, path, http.StatusOK)
 	addLiveRequest("POST", path, http.StatusOK, duration, "", userAgent)
 }
+
+// 处理OPTIONS请求
+func handleOptions(w http.ResponseWriter, r *http.Request) {
+	setCORSHeaders(w)
+	if r.Method == "OPTIONS" {
+		w.WriteHeader(http.StatusOK)
+		return
+	}
+	w.WriteHeader(http.StatusNotFound)
+}
+
+func main() {
+	// 注册路由
+	http.HandleFunc("/v1/models", handleModels)
+	http.HandleFunc("/v1/chat/completions", handleChatCompletions)
+	http.HandleFunc("/api/v1/models", handleModels)
+	http.HandleFunc("/api/v1/chat/completions", handleChatCompletions)
+	http.HandleFunc("/stats", handleStats)
+	http.HandleFunc("/", handleStats) // 首页显示统计信息
+
+	log.Printf("OpenAI兼容API服务器启动在端口%s", PORT)
+	log.Printf("模型: %s", MODEL_NAME)
+	log.Printf("上游: %s", UPSTREAM_URL)
+	log.Printf("Debug模式: %v", DEBUG_MODE)
+	log.Printf("默认流式响应: %v", DEFAULT_STREAM)
+	log.Printf("匿名模式: %v", ANON_TOKEN_ENABLED)
+	log.Printf("---------------------------------------------------------------------")
+	log.Printf("🌐 服务器地址: http://localhost%s", PORT)
+	log.Printf("📊 统计页面: http://localhost%s/stats", PORT)
+	log.Printf("📋 模型列表: http://localhost%s/v1/models", PORT)
+	log.Printf("💬 聊天接口: http://localhost%s/v1/chat/completions", PORT)
+	log.Printf("---------------------------------------------------------------------")
+	log.Fatal(http.ListenAndServe(PORT, nil))
+}