force update files

.env

@@ -0,0 +1,19 @@
+# Server Configuration
+PORT=8080
+DEBUG=false
+
+# Database Configuration
+DB_PATH=data.db
+
+# Authentication
+# Global authentication token for accessing the API
+AUTH_TOKEN=your_secret_token_here
+
+# Admin Management Password
+# Password for accessing account management endpoints
+ADMIN_PASSWORD=your_secret_token_here
+
+# SOCKS Proxy Pool for API Requests Retry
+# Comma-separated list of SOCKS5 proxies with format: socks5://host:port:username:password
+SOCKS_PROXY_POOL=
+

go.mod

@@ -0,0 +1,78 @@
+module zencoder-2api
+
+go 1.21
+
+require (
+	github.com/anthropics/anthropic-sdk-go v0.2.0-alpha.13
+	github.com/gin-gonic/gin v1.9.1
+	github.com/glebarez/sqlite v1.10.0
+	github.com/google/generative-ai-go v0.19.0
+	github.com/google/uuid v1.6.0
+	github.com/joho/godotenv v1.5.1
+	github.com/openai/openai-go v0.1.0-alpha.44
+	google.golang.org/api v0.214.0
+	gorm.io/gorm v1.25.7
+)
+
+require (
+	cloud.google.com/go v0.115.0 // indirect
+	cloud.google.com/go/ai v0.8.0 // indirect
+	cloud.google.com/go/auth v0.13.0 // indirect
+	cloud.google.com/go/auth/oauth2adapt v0.2.6 // indirect
+	cloud.google.com/go/compute/metadata v0.6.0 // indirect
+	cloud.google.com/go/longrunning v0.5.7 // indirect
+	github.com/bytedance/sonic v1.9.1 // indirect
+	github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // indirect
+	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/felixge/httpsnoop v1.0.4 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.2 // indirect
+	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/glebarez/go-sqlite v1.21.2 // indirect
+	github.com/go-logr/logr v1.4.2 // indirect
+	github.com/go-logr/stdr v1.2.2 // indirect
+	github.com/go-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-playground/validator/v10 v10.14.0 // indirect
+	github.com/goccy/go-json v0.10.2 // indirect
+	github.com/google/s2a-go v0.1.8 // indirect
+	github.com/googleapis/enterprise-certificate-proxy v0.3.4 // indirect
+	github.com/googleapis/gax-go/v2 v2.14.0 // indirect
+	github.com/jinzhu/inflection v1.0.0 // indirect
+	github.com/jinzhu/now v1.1.5 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.4 // indirect
+	github.com/leodido/go-urn v1.2.4 // indirect
+	github.com/mattn/go-isatty v0.0.19 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/pelletier/go-toml/v2 v2.0.8 // indirect
+	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+	github.com/tidwall/gjson v1.14.4 // indirect
+	github.com/tidwall/match v1.1.1 // indirect
+	github.com/tidwall/pretty v1.2.1 // indirect
+	github.com/tidwall/sjson v1.2.5 // indirect
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	github.com/ugorji/go/codec v1.2.11 // indirect
+	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.54.0 // indirect
+	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.54.0 // indirect
+	go.opentelemetry.io/otel v1.29.0 // indirect
+	go.opentelemetry.io/otel/metric v1.29.0 // indirect
+	go.opentelemetry.io/otel/trace v1.29.0 // indirect
+	golang.org/x/arch v0.3.0 // indirect
+	golang.org/x/crypto v0.31.0 // indirect
+	golang.org/x/net v0.33.0 // indirect
+	golang.org/x/oauth2 v0.24.0 // indirect
+	golang.org/x/sync v0.10.0 // indirect
+	golang.org/x/sys v0.28.0 // indirect
+	golang.org/x/text v0.21.0 // indirect
+	golang.org/x/time v0.8.0 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20241104194629-dd2ea8efbc28 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20241209162323-e6fa225c2576 // indirect
+	google.golang.org/grpc v1.67.1 // indirect
+	google.golang.org/protobuf v1.35.2 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+	modernc.org/libc v1.22.5 // indirect
+	modernc.org/mathutil v1.5.0 // indirect
+	modernc.org/memory v1.5.0 // indirect
+	modernc.org/sqlite v1.23.1 // indirect
+)

internal/database/db.go

@@ -0,0 +1,31 @@
+package database
+
+import (
+	"zencoder-2api/internal/model"
+
+	"github.com/glebarez/sqlite"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+var DB *gorm.DB
+
+func Init(dbPath string) error {
+	var err error
+	DB, err = gorm.Open(sqlite.Open(dbPath), &gorm.Config{
+		Logger: logger.Default.LogMode(logger.Silent), // 完全关闭日志输出
+	})
+	if err != nil {
+		return err
+	}
+
+	return DB.AutoMigrate(
+		&model.Account{},
+		&model.TokenRecord{},
+		&model.GenerationTask{},
+	)
+}
+
+func GetDB() *gorm.DB {
+	return DB
+}

internal/handler/account.go

@@ -0,0 +1,774 @@
+package handler
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"zencoder-2api/internal/database"
+	"zencoder-2api/internal/model"
+	"zencoder-2api/internal/service"
+)
+
+type AccountHandler struct{}
+
+func NewAccountHandler() *AccountHandler {
+	return &AccountHandler{}
+}
+
+func (h *AccountHandler) List(c *gin.Context) {
+	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
+	size, _ := strconv.Atoi(c.DefaultQuery("size", "10"))
+	
+	// 兼容旧的 category 参数，优先使用 status
+	status := c.DefaultQuery("status", "")
+	if status == "" {
+		category := c.DefaultQuery("category", "normal")
+		if category == "abnormal" {
+			status = "cooling"
+		} else {
+			status = category
+		}
+	}
+
+	if page < 1 {
+		page = 1
+	}
+	if size < 1 {
+		size = 10
+	}
+
+	var accounts []model.Account
+	var total int64
+
+	query := database.GetDB().Model(&model.Account{})
+	if status != "all" {
+		query = query.Where("status = ?", status)
+	}
+
+	if err := query.Count(&total).Error; err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	offset := (page - 1) * size
+	if err := query.Offset(offset).Limit(size).Order("id desc").Find(&accounts).Error; err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	
+	// 调试日志：输出冷却账号的信息
+	if status == "cooling" {
+		for _, acc := range accounts {
+			if !acc.CoolingUntil.IsZero() {
+				log.Printf("[DEBUG] 冷却账号 %s (ID:%d) - CoolingUntil: %s (UTC), 现在: %s (UTC)",
+					acc.Email, acc.ID,
+					acc.CoolingUntil.Format("2006-01-02 15:04:05"),
+					time.Now().UTC().Format("2006-01-02 15:04:05"))
+			}
+		}
+	}
+
+	// Calculate Stats
+	var stats struct {
+		TotalAccounts  int64   `json:"total_accounts"`
+		NormalAccounts int64   `json:"normal_accounts"` // 原 active_accounts
+		BannedAccounts int64   `json:"banned_accounts"`
+		ErrorAccounts  int64   `json:"error_accounts"`
+		CoolingAccounts int64  `json:"cooling_accounts"`
+		DisabledAccounts int64 `json:"disabled_accounts"`
+		TodayUsage     float64 `json:"today_usage"`
+		TotalUsage     float64 `json:"total_usage"`
+	}
+
+	db := database.GetDB()
+
+	db.Model(&model.Account{}).Count(&stats.TotalAccounts)
+	db.Model(&model.Account{}).Where("status = ?", "normal").Count(&stats.NormalAccounts)
+	db.Model(&model.Account{}).Where("status = ?", "banned").Count(&stats.BannedAccounts)
+	db.Model(&model.Account{}).Where("status = ?", "error").Count(&stats.ErrorAccounts)
+	db.Model(&model.Account{}).Where("status = ?", "cooling").Count(&stats.CoolingAccounts)
+	db.Model(&model.Account{}).Where("status = ?", "disabled").Count(&stats.DisabledAccounts)
+
+	db.Model(&model.Account{}).Select("COALESCE(SUM(daily_used), 0)").Scan(&stats.TodayUsage)
+	db.Model(&model.Account{}).Select("COALESCE(SUM(total_used), 0)").Scan(&stats.TotalUsage)
+
+	// 兼容前端旧字段
+	statsMap := map[string]interface{}{
+		"total_accounts":    stats.TotalAccounts,
+		"active_accounts":   stats.NormalAccounts,
+		"banned_accounts":   stats.BannedAccounts,
+		"error_accounts":    stats.ErrorAccounts,
+		"cooling_accounts":  stats.CoolingAccounts,
+		"disabled_accounts": stats.DisabledAccounts,
+		"today_usage":       stats.TodayUsage,
+		"total_usage":       stats.TotalUsage,
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"items": accounts,
+		"total": total,
+		"page":  page,
+		"size":  size,
+		"stats": statsMap,
+	})
+}
+
+type BatchCategoryRequest struct {
+	IDs      []uint `json:"ids"`
+	Category string `json:"category"` // 前端可能还传 category
+	Status   string `json:"status"`
+}
+
+func (h *AccountHandler) BatchUpdateCategory(c *gin.Context) {
+	var req BatchCategoryRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if len(req.IDs) == 0 {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "no ids provided"})
+		return
+	}
+
+	status := req.Status
+	if status == "" {
+		status = req.Category
+	}
+
+	updates := map[string]interface{}{
+		"status": status,
+		// 兼容旧字段
+		"category": status,
+	}
+
+	switch status {
+	case "normal":
+		updates["is_active"] = true
+		updates["is_cooling"] = false
+	case "cooling":
+		updates["is_active"] = true // cooling 也是 active 的一种? 不，cooling 不参与轮询
+		updates["is_cooling"] = true
+	case "disabled":
+		updates["is_active"] = false
+		updates["is_cooling"] = false
+	default: // banned, error
+		updates["is_active"] = false
+		updates["is_cooling"] = false
+	}
+
+	if err := database.GetDB().Model(&model.Account{}).Where("id IN ?", req.IDs).Updates(updates).Error; err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	// 触发 refresh? 为了性能这里不触发，等待自动刷新
+	c.JSON(http.StatusOK, gin.H{"message": "updated", "count": len(req.IDs)})
+}
+
+type MoveAllRequest struct {
+	FromStatus string `json:"from_status"`
+	ToStatus   string `json:"to_status"`
+}
+
+// BatchMoveAll 一键移动某个分类的所有账号到另一个分类
+func (h *AccountHandler) BatchMoveAll(c *gin.Context) {
+	var req MoveAllRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if req.FromStatus == "" || req.ToStatus == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "from_status and to_status are required"})
+		return
+	}
+
+	if req.FromStatus == req.ToStatus {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "from_status and to_status cannot be the same"})
+		return
+	}
+
+	updates := map[string]interface{}{
+		"status": req.ToStatus,
+		// 兼容旧字段
+		"category": req.ToStatus,
+	}
+
+	// 根据目标状态设置相应的标志
+	switch req.ToStatus {
+	case "normal":
+		updates["is_active"] = true
+		updates["is_cooling"] = false
+		updates["error_count"] = 0
+		updates["ban_reason"] = ""
+	case "cooling":
+		updates["is_active"] = false
+		updates["is_cooling"] = true
+		updates["ban_reason"] = ""
+	case "disabled":
+		updates["is_active"] = false
+		updates["is_cooling"] = false
+		updates["ban_reason"] = ""
+	case "banned":
+		updates["is_active"] = false
+		updates["is_cooling"] = false
+	case "error":
+		updates["is_active"] = false
+		updates["is_cooling"] = false
+	default:
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid to_status"})
+		return
+	}
+
+	// 执行批量更新
+	result := database.GetDB().Model(&model.Account{}).Where("status = ?", req.FromStatus).Updates(updates)
+	if result.Error != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": result.Error.Error()})
+		return
+	}
+
+	log.Printf("[批量移动] 从 %s 移动到 %s，影响 %d 个账号", req.FromStatus, req.ToStatus, result.RowsAffected)
+
+	c.JSON(http.StatusOK, gin.H{
+		"message":     "moved successfully",
+		"moved_count": result.RowsAffected,
+		"from_status": req.FromStatus,
+		"to_status":   req.ToStatus,
+	})
+}
+
+type BatchRefreshTokenRequest struct {
+	IDs []uint `json:"ids"`      // 选中的账号IDs，如果为空则刷新所有账号
+	All bool   `json:"all"`      // 是否刷新所有账号
+}
+
+type BatchDeleteRequest struct {
+	IDs       []uint `json:"ids"`       // 选中的账号IDs
+	DeleteAll bool   `json:"delete_all"` // 是否删除分类中的所有账号
+	Status    string `json:"status"`    // 要删除的分类状态
+}
+
+// BatchRefreshToken 批量刷新账号token
+func (h *AccountHandler) BatchRefreshToken(c *gin.Context) {
+	var req BatchRefreshTokenRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	// 设置流式响应头
+	c.Header("Content-Type", "text/event-stream")
+	c.Header("Cache-Control", "no-cache")
+	c.Header("Connection", "keep-alive")
+	c.Header("X-Accel-Buffering", "no")
+
+	flusher, ok := c.Writer.(http.Flusher)
+	if !ok {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "流式传输不支持"})
+		return
+	}
+
+	var accounts []model.Account
+	var err error
+
+	// 根据请求类型获取要刷新的账号
+	if req.All {
+		// 刷新所有状态为normal且有refresh_token的账号
+		err = database.GetDB().Where("status = ? AND (client_id != '' AND client_secret != '')", "normal").Find(&accounts).Error
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "获取账号列表失败: " + err.Error()})
+			return
+		}
+		log.Printf("[批量刷新Token] 准备刷新所有正常账号，共 %d 个", len(accounts))
+	} else if len(req.IDs) > 0 {
+		// 刷新选中的账号
+		err = database.GetDB().Where("id IN ? AND (client_id != '' AND client_secret != '')", req.IDs).Find(&accounts).Error
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "获取选中账号失败: " + err.Error()})
+			return
+		}
+		log.Printf("[批量刷新Token] 准备刷新选中账号，共 %d 个", len(accounts))
+	} else {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "请选择要刷新的账号或选择刷新所有账号"})
+		return
+	}
+
+	if len(accounts) == 0 {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "没有找到可刷新的账号"})
+		return
+	}
+
+	// 发送开始消息
+	fmt.Fprintf(c.Writer, "data: {\"type\":\"start\",\"total\":%d}\n\n", len(accounts))
+	flusher.Flush()
+
+	successCount := 0
+	failCount := 0
+
+	// 逐个刷新token
+	for i, account := range accounts {
+		log.Printf("[批量刷新Token] 开始刷新第 %d/%d 个账号: %s (ID:%d)", i+1, len(accounts), account.ClientID, account.ID)
+		
+		// 使用OAuth client credentials刷新token
+		if err := service.RefreshAccountToken(&account); err != nil {
+			failCount++
+			errMsg := fmt.Sprintf("刷新失败: %v", err)
+			
+			// 检查是否是账号锁定错误
+			if lockoutErr, ok := err.(*service.AccountLockoutError); ok {
+				errMsg = fmt.Sprintf("账号被锁定已自动标记为封禁: %s", lockoutErr.Body)
+				log.Printf("[批量刷新Token] 第 %d/%d 个账号被锁定: %s - %s", i+1, len(accounts), account.ClientID, lockoutErr.Body)
+			} else {
+				log.Printf("[批量刷新Token] 第 %d/%d 个账号刷新失败: %s - %v", i+1, len(accounts), account.ClientID, err)
+			}
+			
+			fmt.Fprintf(c.Writer, "data: {\"type\":\"error\",\"index\":%d,\"account_id\":\"%s\",\"message\":\"%s\"}\n\n", i+1, account.ClientID, errMsg)
+			flusher.Flush()
+		} else {
+			successCount++
+			log.Printf("[批量刷新Token] 第 %d/%d 个账号刷新成功: %s (ID:%d)", i+1, len(accounts), account.ClientID, account.ID)
+			fmt.Fprintf(c.Writer, "data: {\"type\":\"success\",\"index\":%d,\"account_id\":\"%s\",\"email\":\"%s\"}\n\n", i+1, account.ClientID, account.Email)
+			flusher.Flush()
+		}
+
+		// 添加延迟避免请求过快
+		if i < len(accounts)-1 {
+			time.Sleep(200 * time.Millisecond)
+		}
+	}
+
+	// 发送完成消息
+	log.Printf("[批量刷新Token] 完成: 成功 %d 个, 失败 %d 个", successCount, failCount)
+	fmt.Fprintf(c.Writer, "data: {\"type\":\"complete\",\"success\":%d,\"fail\":%d}\n\n", successCount, failCount)
+	flusher.Flush()
+}
+
+func (h *AccountHandler) Create(c *gin.Context) {
+	var req model.AccountRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	// 生成模式 - 固定生成1个账号
+	if req.GenerateMode {
+		// 检查是否提供了 refresh_token 或 access_token
+		if req.RefreshToken == "" && req.Token == "" {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "生成模式需要提供 access_token 或 RefreshToken"})
+			return
+		}
+
+		// 优先使用 access_token，如果同时提供了两个字段
+		var masterToken string
+		
+		if req.Token != "" {
+			// 直接使用提供的 access_token
+			masterToken = req.Token
+			log.Printf("[生成凭证] 使用提供的 access_token")
+		} else {
+			// 使用 refresh_token 获取 access_token
+			tokenResp, err := service.RefreshAccessToken(req.RefreshToken, req.Proxy)
+			if err != nil {
+				c.JSON(http.StatusBadRequest, gin.H{"error": "RefreshToken 无效: " + err.Error()})
+				return
+			}
+			masterToken = tokenResp.AccessToken
+			log.Printf("[生成凭证] 通过 RefreshToken 获取了 access_token")
+		}
+
+		log.Printf("[生成凭证] 开始生成账号凭证")
+		
+		// 生成凭证
+		cred, err := service.GenerateCredential(masterToken)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("生成失败: %v", err)})
+			return
+		}
+
+		log.Printf("[生成凭证] 凭证生成成功: ClientID=%s", cred.ClientID)
+
+		// 创建账号
+		account := model.Account{
+			ClientID:     cred.ClientID,
+			ClientSecret: cred.Secret,
+			Proxy:        req.Proxy,
+			IsActive:     true,
+			Status:       "normal",
+		}
+
+		// 使用生成的client_id和client_secret获取token
+		// 使用OAuth client credentials方式刷新token，使用 https://fe.zencoder.ai/oauth/token
+		if _, err := service.RefreshToken(&account); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("认证失败: %v", err)})
+			return
+		}
+
+		// 解析 Token 获取详细信息
+		if payload, err := service.ParseJWT(account.AccessToken); err == nil {
+			account.Email = payload.Email
+			account.SubscriptionStartDate = service.GetSubscriptionDate(payload)
+			
+			if payload.Expiration > 0 {
+				account.TokenExpiry = time.Unix(payload.Expiration, 0)
+			}
+
+			plan := payload.CustomClaims.Plan
+			if plan != "" {
+				plan = strings.ToUpper(plan[:1]) + plan[1:]
+			}
+			if plan != "" {
+				account.PlanType = model.PlanType(plan)
+			}
+		}
+		if account.PlanType == "" {
+			account.PlanType = model.PlanFree
+		}
+
+		// 检查是否已存在
+		var existing model.Account
+		var count int64
+		database.GetDB().Model(&model.Account{}).Where("client_id = ?", account.ClientID).Count(&count)
+		if count > 0 {
+			// 获取现有账号
+			database.GetDB().Where("client_id = ?", account.ClientID).First(&existing)
+			// 更新现有账号
+			existing.AccessToken = account.AccessToken
+			existing.TokenExpiry = account.TokenExpiry
+			existing.PlanType = account.PlanType
+			existing.Email = account.Email
+			existing.SubscriptionStartDate = account.SubscriptionStartDate
+			existing.IsActive = true
+			existing.Status = "normal" // 重新激活
+			existing.ClientSecret = account.ClientSecret
+			if account.Proxy != "" {
+				existing.Proxy = account.Proxy
+			}
+
+			if err := database.GetDB().Save(&existing).Error; err != nil {
+				c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("更新失败: %v", err)})
+				return
+			}
+			
+			log.Printf("[添加账号] 账号更新成功: ClientID=%s, Email=%s, Plan=%s", existing.ClientID, existing.Email, existing.PlanType)
+			c.JSON(http.StatusOK, existing)
+		} else {
+			// 创建新账号
+			if err := database.GetDB().Create(&account).Error; err != nil {
+				c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("创建失败: %v", err)})
+				return
+			}
+			
+			log.Printf("[添加账号] 新账号创建成功: ClientID=%s, Email=%s, Plan=%s", account.ClientID, account.Email, account.PlanType)
+			c.JSON(http.StatusCreated, account)
+		}
+		return
+	}
+
+	// 原有的单个账号添加逻辑 - 现在使用 refresh_token
+	account := model.Account{
+		Proxy:    req.Proxy,
+		IsActive: true,
+		Status:   "normal",
+	}
+
+	// 优先使用 access_token，如果同时提供了两个字段则不使用 refresh_token
+	if req.Token != "" && req.RefreshToken != "" {
+		log.Printf("[凭证模式] 同时提供了 access_token 和 RefreshToken，优先使用 access_token")
+	}
+	
+	if req.Token != "" {
+		// JWT Parsing Logic
+		payload, err := service.ParseJWT(req.Token)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "无效的Token: " + err.Error()})
+			return
+		}
+
+		account.AccessToken = req.Token
+		// 优先使用ClientID字段，如果没有则使用Subject
+		if payload.ClientID != "" {
+			account.ClientID = payload.ClientID
+		} else {
+			account.ClientID = payload.Subject
+		}
+
+		account.Email = payload.Email
+		account.SubscriptionStartDate = service.GetSubscriptionDate(payload)
+
+		if payload.Expiration > 0 {
+			account.TokenExpiry = time.Unix(payload.Expiration, 0)
+		} else {
+			account.TokenExpiry = time.Now().Add(24 * time.Hour) // 默认24小时
+		}
+
+		// Map PlanType
+		plan := payload.CustomClaims.Plan
+		
+		// Simple normalization
+		if plan != "" {
+			plan = strings.ToUpper(plan[:1]) + plan[1:]
+		}
+		account.PlanType = model.PlanType(plan)
+		if account.PlanType == "" {
+			account.PlanType = model.PlanFree
+		}
+
+		// Placeholder for secret since it's required by DB but not in JWT
+		account.ClientSecret = "jwt-login"
+	} else if req.RefreshToken != "" {
+		// 只提供了 refresh_token，使用它来获取 access_token
+		tokenResp, err := service.RefreshAccessToken(req.RefreshToken, req.Proxy)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "RefreshToken 无效: " + err.Error()})
+			return
+		}
+
+		account.AccessToken = tokenResp.AccessToken
+		account.RefreshToken = tokenResp.RefreshToken
+		account.TokenExpiry = time.Now().Add(time.Duration(tokenResp.ExpiresIn) * time.Second)
+
+		// 解析 Token 获取详细信息
+		if payload, err := service.ParseJWT(tokenResp.AccessToken); err == nil {
+			// 设置 Email
+			if payload.Email != "" {
+				account.Email = payload.Email
+			} else if tokenResp.Email != "" {
+				account.Email = tokenResp.Email
+			}
+			
+			// 设置 ClientID - 优先使用 Email 作为唯一标识符
+			if payload.Email != "" {
+				account.ClientID = payload.Email
+			} else if payload.Subject != "" {
+				account.ClientID = payload.Subject
+			} else if payload.ClientID != "" {
+				account.ClientID = payload.ClientID
+			}
+			
+			account.SubscriptionStartDate = service.GetSubscriptionDate(payload)
+
+			// Map PlanType
+			plan := payload.CustomClaims.Plan
+			if plan != "" {
+				plan = strings.ToUpper(plan[:1]) + plan[1:]
+			}
+			account.PlanType = model.PlanType(plan)
+			if account.PlanType == "" {
+				account.PlanType = model.PlanFree
+			}
+			
+			log.Printf("[凭证模式-RefreshToken] 解析JWT成功: ClientID=%s, Email=%s, Plan=%s",
+				account.ClientID, account.Email, account.PlanType)
+		} else {
+			log.Printf("[凭证模式-RefreshToken] 解析JWT失败: %v", err)
+			// 如果JWT解析失败，使用 tokenResp 中的信息
+			if tokenResp.UserID != "" {
+				account.ClientID = tokenResp.UserID
+				account.Email = tokenResp.UserID
+			}
+		}
+
+		// 生成一个占位 ClientSecret
+		account.ClientSecret = "refresh-token-login"
+		
+		// 确保 ClientID 不为空
+		if account.ClientID == "" {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "无法获取用户信息，请检查RefreshToken是否有效"})
+			return
+		}
+		
+	} else {
+		// Old Logic
+		if req.PlanType == "" {
+			req.PlanType = model.PlanFree
+		}
+		account.ClientID = req.ClientID
+		account.ClientSecret = req.ClientSecret
+		account.Email = req.Email
+		account.PlanType = req.PlanType
+
+		// 验证Token是否能正确获取
+		if _, err := service.RefreshToken(&account); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "认证失败: " + err.Error()})
+			return
+		}
+
+		// 解析Token获取详细信息
+		if payload, err := service.ParseJWT(account.AccessToken); err == nil {
+			if account.Email == "" {
+				account.Email = payload.Email
+			}
+			account.SubscriptionStartDate = service.GetSubscriptionDate(payload)
+			
+			if payload.Expiration > 0 {
+				account.TokenExpiry = time.Unix(payload.Expiration, 0)
+			}
+
+			plan := payload.CustomClaims.Plan
+			if plan != "" {
+				plan = strings.ToUpper(plan[:1]) + plan[1:]
+			}
+			if plan != "" {
+				account.PlanType = model.PlanType(plan)
+			}
+		}
+		if account.PlanType == "" {
+			account.PlanType = model.PlanFree
+		}
+	}
+
+	// Check if account exists - 使用 Count 避免 record not found 警告
+	var existing model.Account
+	var count int64
+	database.GetDB().Model(&model.Account{}).Where("client_id = ?", account.ClientID).Count(&count)
+	if count > 0 {
+		// 获取现有账号
+		database.GetDB().Where("client_id = ?", account.ClientID).First(&existing)
+		// Update existing
+		existing.AccessToken = account.AccessToken
+		existing.RefreshToken = account.RefreshToken // 更新 refresh_token
+		existing.TokenExpiry = account.TokenExpiry
+		existing.PlanType = account.PlanType
+		existing.Email = account.Email
+		existing.SubscriptionStartDate = account.SubscriptionStartDate
+		existing.IsActive = true
+		existing.Status = "normal"
+		if account.Proxy != "" {
+			existing.Proxy = account.Proxy
+		}
+		// If secret was provided manually, update it. If placeholder, keep existing.
+		if account.ClientSecret != "jwt-login" && account.ClientSecret != "refresh-token-login" {
+			existing.ClientSecret = account.ClientSecret
+		}
+
+		if err := database.GetDB().Save(&existing).Error; err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, existing)
+		return
+	}
+
+	if err := database.GetDB().Create(&account).Error; err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusCreated, account)
+}
+
+func (h *AccountHandler) Update(c *gin.Context) {
+	id := c.Param("id")
+	var account model.Account
+	if err := database.GetDB().First(&account, id).Error; err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "account not found"})
+		return
+	}
+
+	var req model.AccountRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	account.Email = req.Email
+	account.PlanType = req.PlanType
+	account.Proxy = req.Proxy
+
+	if err := database.GetDB().Save(&account).Error; err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, account)
+}
+
+// BatchDelete 批量删除账号
+func (h *AccountHandler) BatchDelete(c *gin.Context) {
+	var req BatchDeleteRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	var deletedCount int64
+
+	if req.DeleteAll {
+		// 删除指定分类的所有账号
+		if req.Status == "" {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "delete_all模式需要指定status"})
+			return
+		}
+
+		// 执行删除操作
+		result := database.GetDB().Where("status = ?", req.Status).Delete(&model.Account{})
+		if result.Error != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": result.Error.Error()})
+			return
+		}
+
+		deletedCount = result.RowsAffected
+		log.Printf("[批量删除] 删除分类 %s 的所有账号，共删除 %d 个", req.Status, deletedCount)
+
+	} else {
+		// 删除选中的账号
+		if len(req.IDs) == 0 {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "未选择要删除的账号"})
+			return
+		}
+
+		// 执行删除操作
+		result := database.GetDB().Where("id IN ?", req.IDs).Delete(&model.Account{})
+		if result.Error != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": result.Error.Error()})
+			return
+		}
+
+		deletedCount = result.RowsAffected
+		log.Printf("[批量删除] 删除选中的 %d 个账号，实际删除 %d 个", len(req.IDs), deletedCount)
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"message":       "批量删除成功",
+		"deleted_count": deletedCount,
+	})
+}
+
+func (h *AccountHandler) Delete(c *gin.Context) {
+	id := c.Param("id")
+	if err := database.GetDB().Delete(&model.Account{}, id).Error; err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"message": "deleted"})
+}
+
+func (h *AccountHandler) Toggle(c *gin.Context) {
+	id := c.Param("id")
+	var account model.Account
+	if err := database.GetDB().First(&account, id).Error; err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "account not found"})
+		return
+	}
+
+	// 切换 Disabled / Normal
+	if account.Status == "disabled" || !account.IsActive {
+		account.Status = "normal"
+		account.IsActive = true
+		account.IsCooling = false
+		account.ErrorCount = 0
+	} else {
+		account.Status = "disabled"
+		account.IsActive = false
+	}
+	
+	database.GetDB().Save(&account)
+
+	c.JSON(http.StatusOK, account)
+}

internal/handler/anthropic.go

@@ -0,0 +1,57 @@
+package handler
+
+import (
+	"context"
+	"crypto/rand"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+
+	"zencoder-2api/internal/service"
+
+	"github.com/gin-gonic/gin"
+)
+
+type AnthropicHandler struct {
+	svc *service.AnthropicService
+}
+
+func NewAnthropicHandler() *AnthropicHandler {
+	return &AnthropicHandler{svc: service.NewAnthropicService()}
+}
+
+// generateTraceID 生成一个随机的 trace ID
+func generateAnthropicTraceID() string {
+	b := make([]byte, 16)
+	rand.Read(b)
+	return hex.EncodeToString(b)
+}
+
+// Messages 处理 POST /v1/messages
+func (h *AnthropicHandler) Messages(c *gin.Context) {
+	body, err := io.ReadAll(c.Request.Body)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	// 传递原始请求头给service层，用于错误日志记录
+	ctx := context.WithValue(c.Request.Context(), "originalHeaders", c.Request.Header)
+	
+	if err := h.svc.MessagesProxy(ctx, c.Writer, body); err != nil {
+		h.handleError(c, err)
+	}
+}
+
+// handleError 统一处理错误，特别是没有可用账号的错误
+func (h *AnthropicHandler) handleError(c *gin.Context, err error) {
+	if errors.Is(err, service.ErrNoAvailableAccount) || errors.Is(err, service.ErrNoPermission) {
+		traceID := generateAnthropicTraceID()
+		errMsg := fmt.Sprintf("没有可用token（traceid: %s）", traceID)
+		c.JSON(http.StatusServiceUnavailable, gin.H{"error": errMsg})
+		return
+	}
+	c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+}

internal/handler/chat.go

@@ -0,0 +1,48 @@
+package handler
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"zencoder-2api/internal/model"
+	"zencoder-2api/internal/service"
+)
+
+type ChatHandler struct {
+	svc *service.APIService
+}
+
+func NewChatHandler() *ChatHandler {
+	return &ChatHandler{svc: service.NewAPIService()}
+}
+
+func (h *ChatHandler) ChatCompletions(c *gin.Context) {
+	var req model.ChatCompletionRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if req.Stream {
+		h.handleStream(c, &req)
+		return
+	}
+
+	resp, err := h.svc.Chat(&req)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, resp)
+}
+
+func (h *ChatHandler) handleStream(c *gin.Context, req *model.ChatCompletionRequest) {
+	c.Writer.Header().Set("Content-Type", "text/event-stream")
+	c.Writer.Header().Set("Cache-Control", "no-cache")
+	c.Writer.Header().Set("Connection", "keep-alive")
+
+	if err := h.svc.ChatStream(req, c.Writer); err != nil {
+		c.SSEvent("error", err.Error())
+	}
+}

internal/handler/external.go

@@ -0,0 +1,209 @@
+package handler
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"zencoder-2api/internal/database"
+	"zencoder-2api/internal/model"
+	"zencoder-2api/internal/service"
+)
+
+type ExternalHandler struct{}
+
+func NewExternalHandler() *ExternalHandler {
+	return &ExternalHandler{}
+}
+
+// ExternalTokenRequest 外部API提交token请求结构
+type ExternalTokenRequest struct {
+	AccessToken  string `json:"access_token"`  // OAuth获取的access_token
+	RefreshToken string `json:"refresh_token"` // OAuth获取的refresh_token
+	Proxy        string `json:"proxy"`         // 可选的代理设置
+}
+
+// ExternalTokenResponse 外部API响应结构
+type ExternalTokenResponse struct {
+	Success bool           `json:"success"`
+	Message string         `json:"message"`
+	Account *model.Account `json:"account,omitempty"`
+	Error   string         `json:"error,omitempty"`
+}
+
+// SubmitTokens 外部API接口：接收OAuth token信息并生成账号记录
+func (h *ExternalHandler) SubmitTokens(c *gin.Context) {
+	var req ExternalTokenRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, ExternalTokenResponse{
+			Success: false,
+			Error:   "请求格式错误: " + err.Error(),
+		})
+		return
+	}
+
+	// 验证必要字段
+	if req.AccessToken == "" && req.RefreshToken == "" {
+		c.JSON(http.StatusBadRequest, ExternalTokenResponse{
+			Success: false,
+			Error:   "必须提供 access_token 或 refresh_token",
+		})
+		return
+	}
+
+	log.Printf("[外部API] 收到token提交请求，access_token长度: %d, refresh_token长度: %d", 
+		len(req.AccessToken), len(req.RefreshToken))
+
+	// 优先使用 access_token，如果同时提供了两个字段
+	var masterToken string
+	
+	if req.AccessToken != "" {
+		// 直接使用提供的 access_token
+		masterToken = req.AccessToken
+		log.Printf("[外部API] 使用提供的 access_token")
+	} else {
+		// 使用 refresh_token 获取 access_token
+		tokenResp, err := service.RefreshAccessToken(req.RefreshToken, req.Proxy)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, ExternalTokenResponse{
+				Success: false,
+				Error:   "RefreshToken 无效: " + err.Error(),
+			})
+			return
+		}
+		masterToken = tokenResp.AccessToken
+		log.Printf("[外部API] 通过 RefreshToken 获取了 access_token")
+	}
+
+	log.Printf("[外部API] 开始生成账号凭证")
+	
+	// 生成凭证
+	cred, err := service.GenerateCredential(masterToken)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, ExternalTokenResponse{
+			Success: false,
+			Error:   fmt.Sprintf("生成失败: %v", err),
+		})
+		return
+	}
+
+	log.Printf("[外部API] 凭证生成成功: ClientID=%s", cred.ClientID)
+
+	// 创建账号
+	account := model.Account{
+		ClientID:     cred.ClientID,
+		ClientSecret: cred.Secret,
+		Proxy:        req.Proxy,
+		IsActive:     true,
+		Status:       "normal",
+	}
+
+	// 使用生成的client_id和client_secret获取token，带重试机制
+	// 使用OAuth client credentials方式刷新token，使用 https://fe.zencoder.ai/oauth/token
+	maxRetries := 3
+	retryDelay := 2 * time.Second
+	var lastErr error
+	
+	for attempt := 1; attempt <= maxRetries; attempt++ {
+		log.Printf("[外部API] 尝试获取token，第 %d/%d 次", attempt, maxRetries)
+		
+		if _, err := service.RefreshToken(&account); err != nil {
+			lastErr = err
+			log.Printf("[外部API] 第 %d 次获取token失败: %v", attempt, err)
+			
+			if attempt < maxRetries {
+				log.Printf("[外部API] 等待 %v 后重试", retryDelay)
+				time.Sleep(retryDelay)
+				continue
+			}
+		} else {
+			log.Printf("[外部API] 第 %d 次获取token成功", attempt)
+			lastErr = nil
+			break
+		}
+	}
+	
+	if lastErr != nil {
+		c.JSON(http.StatusBadRequest, ExternalTokenResponse{
+			Success: false,
+			Error:   fmt.Sprintf("认证失败（重试 %d 次后）: %v", maxRetries, lastErr),
+		})
+		return
+	}
+
+	// 解析 Token 获取详细信息
+	if payload, err := service.ParseJWT(account.AccessToken); err == nil {
+		account.Email = payload.Email
+		account.SubscriptionStartDate = service.GetSubscriptionDate(payload)
+		
+		if payload.Expiration > 0 {
+			account.TokenExpiry = time.Unix(payload.Expiration, 0)
+		}
+
+		plan := payload.CustomClaims.Plan
+		if plan != "" {
+			plan = strings.ToUpper(plan[:1]) + plan[1:]
+		}
+		if plan != "" {
+			account.PlanType = model.PlanType(plan)
+		}
+	}
+	if account.PlanType == "" {
+		account.PlanType = model.PlanFree
+	}
+
+	// 检查是否已存在
+	var existing model.Account
+	var count int64
+	database.GetDB().Model(&model.Account{}).Where("client_id = ?", account.ClientID).Count(&count)
+	if count > 0 {
+		// 获取现有账号
+		database.GetDB().Where("client_id = ?", account.ClientID).First(&existing)
+		// 更新现有账号
+		existing.AccessToken = account.AccessToken
+		existing.TokenExpiry = account.TokenExpiry
+		existing.PlanType = account.PlanType
+		existing.Email = account.Email
+		existing.SubscriptionStartDate = account.SubscriptionStartDate
+		existing.IsActive = true
+		existing.Status = "normal" // 重新激活
+		existing.ClientSecret = account.ClientSecret
+		if account.Proxy != "" {
+			existing.Proxy = account.Proxy
+		}
+
+		if err := database.GetDB().Save(&existing).Error; err != nil {
+			c.JSON(http.StatusInternalServerError, ExternalTokenResponse{
+				Success: false,
+				Error:   fmt.Sprintf("更新失败: %v", err),
+			})
+			return
+		}
+		
+		log.Printf("[外部API] 账号更新成功: ClientID=%s, Email=%s, Plan=%s", existing.ClientID, existing.Email, existing.PlanType)
+		c.JSON(http.StatusOK, ExternalTokenResponse{
+			Success: true,
+			Message: "账号更新成功",
+			Account: &existing,
+		})
+	} else {
+		// 创建新账号
+		if err := database.GetDB().Create(&account).Error; err != nil {
+			c.JSON(http.StatusInternalServerError, ExternalTokenResponse{
+				Success: false,
+				Error:   fmt.Sprintf("创建失败: %v", err),
+			})
+			return
+		}
+		
+		log.Printf("[外部API] 新账号创建成功: ClientID=%s, Email=%s, Plan=%s", account.ClientID, account.Email, account.PlanType)
+		c.JSON(http.StatusCreated, ExternalTokenResponse{
+			Success: true,
+			Message: "账号创建成功",
+			Account: &account,
+		})
+	}
+}

internal/handler/gemini.go

@@ -0,0 +1,77 @@
+package handler
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	"zencoder-2api/internal/service"
+)
+
+type GeminiHandler struct {
+	svc *service.GeminiService
+}
+
+func NewGeminiHandler() *GeminiHandler {
+	return &GeminiHandler{svc: service.NewGeminiService()}
+}
+
+// generateTraceID 生成一个随机的 trace ID
+func generateGeminiTraceID() string {
+	b := make([]byte, 16)
+	rand.Read(b)
+	return hex.EncodeToString(b)
+}
+
+// HandleRequest 处理 POST /v1beta/models/*path
+// 路径格式: /model:action 例如 /gemini-3-flash-preview:streamGenerateContent
+func (h *GeminiHandler) HandleRequest(c *gin.Context) {
+	path := c.Param("path")
+	// 去掉开头的斜杠
+	path = strings.TrimPrefix(path, "/")
+
+	// 解析 model:action
+	parts := strings.SplitN(path, ":", 2)
+	if len(parts) != 2 {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid path format"})
+		return
+	}
+
+	modelName := parts[0]
+	action := parts[1]
+
+	body, err := io.ReadAll(c.Request.Body)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	switch action {
+	case "generateContent":
+		if err := h.svc.GenerateContentProxy(c.Request.Context(), c.Writer, modelName, body); err != nil {
+			h.handleError(c, err)
+		}
+	case "streamGenerateContent":
+		if err := h.svc.StreamGenerateContentProxy(c.Request.Context(), c.Writer, modelName, body); err != nil {
+			h.handleError(c, err)
+		}
+	default:
+		c.JSON(http.StatusBadRequest, gin.H{"error": "unsupported action: " + action})
+	}
+}
+
+// handleError 统一处理错误，特别是没有可用账号的错误
+func (h *GeminiHandler) handleError(c *gin.Context, err error) {
+	if errors.Is(err, service.ErrNoAvailableAccount) || errors.Is(err, service.ErrNoPermission) {
+		traceID := generateGeminiTraceID()
+		errMsg := fmt.Sprintf("没有可用token（traceid: %s）", traceID)
+		c.JSON(http.StatusServiceUnavailable, gin.H{"error": errMsg})
+		return
+	}
+	c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+}

internal/handler/grok.go

@@ -0,0 +1,53 @@
+package handler
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+
+	"zencoder-2api/internal/service"
+
+	"github.com/gin-gonic/gin"
+)
+
+type GrokHandler struct {
+	svc *service.GrokService
+}
+
+func NewGrokHandler() *GrokHandler {
+	return &GrokHandler{svc: service.NewGrokService()}
+}
+
+// generateTraceID 生成一个随机的 trace ID
+func generateGrokTraceID() string {
+	b := make([]byte, 16)
+	rand.Read(b)
+	return hex.EncodeToString(b)
+}
+
+// ChatCompletions 处理 POST /v1/chat/completions (xAI)
+func (h *GrokHandler) ChatCompletions(c *gin.Context) {
+	body, err := io.ReadAll(c.Request.Body)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if err := h.svc.ChatCompletionsProxy(c.Request.Context(), c.Writer, body); err != nil {
+		h.handleError(c, err)
+	}
+}
+
+// handleError 统一处理错误，特别是没有可用账号的错误
+func (h *GrokHandler) handleError(c *gin.Context, err error) {
+	if errors.Is(err, service.ErrNoAvailableAccount) || errors.Is(err, service.ErrNoPermission) {
+		traceID := generateGrokTraceID()
+		errMsg := fmt.Sprintf("没有可用token（traceid: %s）", traceID)
+		c.JSON(http.StatusServiceUnavailable, gin.H{"error": errMsg})
+		return
+	}
+	c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+}

internal/handler/oauth.go

@@ -0,0 +1,331 @@
+package handler
+
+import (
+	"bytes"
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"sync"
+	"time"
+
+	"github.com/gin-gonic/gin"
+)
+
+// PKCESession 存储PKCE会话信息
+type PKCESession struct {
+	CodeVerifier string
+	CreatedAt    time.Time
+}
+
+// PKCESessionStore 内存中存储PKCE会话
+type PKCESessionStore struct {
+	sync.RWMutex
+	sessions map[string]*PKCESession
+}
+
+// 全局PKCE会话存储
+var pkceStore = &PKCESessionStore{
+	sessions: make(map[string]*PKCESession),
+}
+
+// OAuthHandler OAuth相关处理器
+type OAuthHandler struct {
+}
+
+// NewOAuthHandler 创建OAuth处理器
+func NewOAuthHandler() *OAuthHandler {
+	// 启动清理过期会话的定时器
+	go cleanupExpiredSessions()
+	
+	return &OAuthHandler{}
+}
+
+// StartOAuthForRT 开始OAuth流程获取RT
+func (h *OAuthHandler) StartOAuthForRT(c *gin.Context) {
+	// 生成PKCE参数
+	codeVerifier, err := generateCodeVerifier(32)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"error": "生成PKCE参数失败",
+		})
+		return
+	}
+	
+	// 生成code_challenge
+	codeChallenge := generateCodeChallenge(codeVerifier)
+	
+	// 生成会话ID
+	sessionID, err := generateSessionID()
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"error": "生成会话ID失败",
+		})
+		return
+	}
+	
+	// 存储会话
+	pkceStore.Lock()
+	pkceStore.sessions[sessionID] = &PKCESession{
+		CodeVerifier: codeVerifier,
+		CreatedAt:    time.Now(),
+	}
+	pkceStore.Unlock()
+	
+	// 获取回调URL
+	scheme := "http"
+	if c.Request.TLS != nil {
+		scheme = "https"
+	}
+	host := c.Request.Host
+	
+	callbackURL := fmt.Sprintf("%s://%s/api/oauth/callback-rt?session=%s", 
+		scheme, host, sessionID)
+	
+	// 构建state参数
+	state := map[string]string{
+		"redirectUri":   callbackURL,
+		"codeChallenge": codeChallenge,
+		"sessionId":     sessionID,
+	}
+	stateJSON, _ := json.Marshal(state)
+	
+	// 构建授权URL
+	params := url.Values{
+		"state":                       {string(stateJSON)},
+		"response_type":               {"code"},
+		"client_id":                   {"5948a5c5-4b30-4465-a3f2-2136ea53ea0a"},
+		"scope":                       {"openid profile email"},
+		"redirect_uri":                {"https://auth.zencoder.ai/extension/auth-success"},
+		"code_challenge":              {codeChallenge},
+		"code_challenge_method":       {"S256"},
+	}
+	
+	authURL := fmt.Sprintf("https://fe.zencoder.ai/oauth/authorize?%s", params.Encode())
+	
+	// 重定向到授权页面
+	c.Redirect(http.StatusFound, authURL)
+}
+
+// CallbackOAuthForRT 处理OAuth回调
+func (h *OAuthHandler) CallbackOAuthForRT(c *gin.Context) {
+	code := c.Query("code")
+	sessionID := c.Query("session")
+	
+	// 验证参数
+	if code == "" || sessionID == "" {
+		h.renderCallbackPage(c, false, "", "", "缺少必要参数")
+		return
+	}
+	
+	// 获取会话
+	pkceStore.RLock()
+	session, exists := pkceStore.sessions[sessionID]
+	pkceStore.RUnlock()
+	
+	if !exists {
+		h.renderCallbackPage(c, false, "", "", "会话已过期，请重新获取")
+		return
+	}
+	
+	// 交换token
+	tokenResp, err := h.exchangeCodeForToken(code, session.CodeVerifier)
+	if err != nil {
+		h.renderCallbackPage(c, false, "", "", fmt.Sprintf("获取Token失败: %v", err))
+		return
+	}
+	
+	// 清理会话
+	pkceStore.Lock()
+	delete(pkceStore.sessions, sessionID)
+	pkceStore.Unlock()
+	
+	// 渲染成功页面，传递access token和refresh token
+	h.renderCallbackPage(c, true, tokenResp.AccessToken, tokenResp.RefreshToken, "")
+}
+
+// exchangeCodeForToken 用授权码换取token
+func (h *OAuthHandler) exchangeCodeForToken(code, codeVerifier string) (*OAuthTokenResponse, error) {
+	tokenURL := "https://auth.zencoder.ai/api/frontegg/oauth/token"
+	
+	payload := map[string]string{
+		"code":          code,
+		"redirect_uri":  "https://auth.zencoder.ai/extension/auth-success",
+		"code_verifier": codeVerifier,
+		"grant_type":    "authorization_code",
+	}
+	
+	body, _ := json.Marshal(payload)
+	
+	req, err := http.NewRequest("POST", tokenURL, bytes.NewReader(body))
+	if err != nil {
+		return nil, err
+	}
+	
+	// 设置请求头
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("x-frontegg-sdk", "@frontegg/nextjs@9.2.10")
+	req.Header.Set("x-frontegg-framework", "next@15.3.8")
+	req.Header.Set("Origin", "https://auth.zencoder.ai")
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36")
+	
+	client := &http.Client{Timeout: 30 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("token exchange failed with status %d", resp.StatusCode)
+	}
+	
+	var tokenResp OAuthTokenResponse
+	if err := json.NewDecoder(resp.Body).Decode(&tokenResp); err != nil {
+		return nil, err
+	}
+	
+	return &tokenResp, nil
+}
+
+// renderCallbackPage 渲染回调页面
+func (h *OAuthHandler) renderCallbackPage(c *gin.Context, success bool, accessToken, refreshToken, errorMsg string) {
+	html := `
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>OAuth认证</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+</head>
+<body class="bg-gray-50 dark:bg-gray-900 min-h-screen flex items-center justify-center">
+    <div class="max-w-md w-full mx-4">
+        <div class="bg-white dark:bg-gray-800 rounded-lg shadow-lg p-8">
+`
+	
+	if success {
+		html += fmt.Sprintf(`
+	           <div class="text-center">
+	               <div class="mx-auto flex items-center justify-center h-12 w-12 rounded-full bg-green-100">
+	                   <svg class="h-6 w-6 text-green-600" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+	                       <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"></path>
+	                   </svg>
+	               </div>
+	               <h2 class="mt-4 text-xl font-semibold text-gray-900 dark:text-white">认证成功！</h2>
+	               <p class="mt-2 text-sm text-gray-600 dark:text-gray-400">正在返回并填充Token...</p>
+	           </div>
+	           <script>
+	               // 发送消息给父窗口
+	               if (window.opener) {
+	                   window.opener.postMessage({
+	                       type: 'oauth-rt-complete',
+	                       success: true,
+	                       accessToken: '%s',
+	                       refreshToken: '%s'
+	                   }, window.location.origin);
+	                   
+	                   // 2秒后关闭窗口
+	                   setTimeout(() => {
+	                       window.close();
+	                   }, 2000);
+	               }
+	           </script>
+`, accessToken, refreshToken)
+	} else {
+		html += fmt.Sprintf(`
+            <div class="text-center">
+                <div class="mx-auto flex items-center justify-center h-12 w-12 rounded-full bg-red-100">
+                    <svg class="h-6 w-6 text-red-600" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"></path>
+                    </svg>
+                </div>
+                <h2 class="mt-4 text-xl font-semibold text-gray-900 dark:text-white">认证失败</h2>
+                <p class="mt-2 text-sm text-gray-600 dark:text-gray-400">%s</p>
+                <button onclick="window.close()" class="mt-4 px-4 py-2 bg-gray-600 text-white rounded-lg hover:bg-gray-700 transition-colors">
+                    关闭窗口
+                </button>
+            </div>
+            <script>
+                // 发送错误消息给父窗口
+                if (window.opener) {
+                    window.opener.postMessage({
+                        type: 'oauth-rt-complete',
+                        success: false,
+                        error: '%s'
+                    }, window.location.origin);
+                }
+            </script>
+`, errorMsg, errorMsg)
+	}
+	
+	html += `
+        </div>
+    </div>
+</body>
+</html>
+`
+	
+	c.Header("Content-Type", "text/html; charset=utf-8")
+	c.String(http.StatusOK, html)
+}
+
+// OAuthTokenResponse OAuth token响应
+type OAuthTokenResponse struct {
+	AccessToken  string `json:"access_token"`
+	RefreshToken string `json:"refresh_token"`
+	TokenType    string `json:"token_type"`
+	ExpiresIn    int    `json:"expires_in"`
+}
+
+// generateCodeVerifier 生成PKCE code_verifier
+func generateCodeVerifier(length int) (string, error) {
+	const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~"
+	result := make([]byte, length)
+	randomBytes := make([]byte, length)
+	
+	if _, err := rand.Read(randomBytes); err != nil {
+		return "", err
+	}
+	
+	for i := 0; i < length; i++ {
+		result[i] = chars[int(randomBytes[i])%len(chars)]
+	}
+	
+	return string(result), nil
+}
+
+// generateCodeChallenge 生成PKCE code_challenge
+func generateCodeChallenge(codeVerifier string) string {
+	hash := sha256.Sum256([]byte(codeVerifier))
+	return base64.RawURLEncoding.EncodeToString(hash[:])
+}
+
+// generateSessionID 生成会话ID
+func generateSessionID() (string, error) {
+	b := make([]byte, 16)
+	if _, err := rand.Read(b); err != nil {
+		return "", err
+	}
+	return base64.URLEncoding.EncodeToString(b), nil
+}
+
+// cleanupExpiredSessions 清理过期的PKCE会话
+func cleanupExpiredSessions() {
+	ticker := time.NewTicker(5 * time.Minute)
+	defer ticker.Stop()
+	
+	for range ticker.C {
+		pkceStore.Lock()
+		now := time.Now()
+		for id, session := range pkceStore.sessions {
+			if now.Sub(session.CreatedAt) > 10*time.Minute {
+				delete(pkceStore.sessions, id)
+			}
+		}
+		pkceStore.Unlock()
+	}
+}

internal/handler/openai.go

@@ -0,0 +1,96 @@
+package handler
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"zencoder-2api/internal/model"
+	"zencoder-2api/internal/service"
+)
+
+type OpenAIHandler struct {
+	svc     *service.OpenAIService
+	grokSvc *service.GrokService
+}
+
+func NewOpenAIHandler() *OpenAIHandler {
+	return &OpenAIHandler{
+		svc:     service.NewOpenAIService(),
+		grokSvc: service.NewGrokService(),
+	}
+}
+
+// generateTraceID 生成一个随机的 trace ID
+func generateTraceID() string {
+	b := make([]byte, 16)
+	rand.Read(b)
+	return hex.EncodeToString(b)
+}
+
+// ChatCompletions 处理 POST /v1/chat/completions
+func (h *OpenAIHandler) ChatCompletions(c *gin.Context) {
+	body, err := io.ReadAll(c.Request.Body)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	// 解析模型名以确定使用哪个服务
+	var req struct {
+		Model string `json:"model"`
+	}
+	if err := json.Unmarshal(body, &req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	// 根据模型的 ProviderID 分流
+	zenModel, exists := model.GetZenModel(req.Model)
+	if !exists {
+		// 模型不存在，返回错误
+		h.handleError(c, service.ErrNoAvailableAccount)
+		return
+	}
+	if zenModel.ProviderID == "xai" {
+		// Grok 模型使用 xAI 服务
+		if err := h.grokSvc.ChatCompletionsProxy(c.Request.Context(), c.Writer, body); err != nil {
+			h.handleError(c, err)
+		}
+		return
+	}
+
+	// 其他模型使用 OpenAI 服务
+	if err := h.svc.ChatCompletionsProxy(c.Request.Context(), c.Writer, body); err != nil {
+		h.handleError(c, err)
+	}
+}
+
+// Responses 处理 POST /v1/responses
+func (h *OpenAIHandler) Responses(c *gin.Context) {
+	body, err := io.ReadAll(c.Request.Body)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if err := h.svc.ResponsesProxy(c.Request.Context(), c.Writer, body); err != nil {
+		h.handleError(c, err)
+	}
+}
+
+// handleError 统一处理错误，特别是没有可用账号的错误
+func (h *OpenAIHandler) handleError(c *gin.Context, err error) {
+	if errors.Is(err, service.ErrNoAvailableAccount) || errors.Is(err, service.ErrNoPermission) {
+		traceID := generateTraceID()
+		errMsg := fmt.Sprintf("没有可用token（traceid: %s）", traceID)
+		c.JSON(http.StatusServiceUnavailable, gin.H{"error": errMsg})
+		return
+	}
+	c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+}

internal/handler/token.go

@@ -0,0 +1,270 @@
+package handler
+
+import (
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"zencoder-2api/internal/database"
+	"zencoder-2api/internal/model"
+	"zencoder-2api/internal/service"
+)
+
+type TokenHandler struct{}
+
+func NewTokenHandler() *TokenHandler {
+	return &TokenHandler{}
+}
+
+// ListTokenRecords 获取所有token记录
+func (h *TokenHandler) ListTokenRecords(c *gin.Context) {
+	records, err := service.GetAllTokenRecords()
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	// 获取每个token的生成任务统计
+	var enrichedRecords []map[string]interface{}
+	for _, record := range records {
+		// 统计该token的任务信息
+		var taskStats struct {
+			TotalTasks    int64 `json:"total_tasks"`
+			TotalSuccess  int64 `json:"total_success"`
+			TotalFail     int64 `json:"total_fail"`
+			RunningTasks  int64 `json:"running_tasks"`
+		}
+		
+		db := database.GetDB()
+		db.Model(&model.GenerationTask{}).Where("token_record_id = ?", record.ID).Count(&taskStats.TotalTasks)
+		db.Model(&model.GenerationTask{}).Where("token_record_id = ?", record.ID).
+			Select("COALESCE(SUM(success_count), 0)").Scan(&taskStats.TotalSuccess)
+		db.Model(&model.GenerationTask{}).Where("token_record_id = ?", record.ID).
+			Select("COALESCE(SUM(fail_count), 0)").Scan(&taskStats.TotalFail)
+		db.Model(&model.GenerationTask{}).Where("token_record_id = ? AND status = ?", record.ID, "running").
+			Count(&taskStats.RunningTasks)
+
+		// 解析JWT获取用户信息
+		var email string
+		var planType string
+		var subscriptionStartDate time.Time
+		if record.Token != "" {
+			if payload, err := service.ParseJWT(record.Token); err == nil {
+				email = payload.Email
+				planType = payload.CustomClaims.Plan
+				if planType != "" {
+					planType = strings.ToUpper(planType[:1]) + planType[1:]
+				}
+				// 获取订阅开始时间
+				subscriptionStartDate = service.GetSubscriptionDate(payload)
+			}
+		}
+
+		enrichedRecord := map[string]interface{}{
+			"id":                      record.ID,
+			"description":             record.Description,
+			"generated_count":         record.GeneratedCount,
+			"last_generated_at":       record.LastGeneratedAt,
+			"auto_generate":           record.AutoGenerate,
+			"threshold":               record.Threshold,
+			"generate_batch":          record.GenerateBatch,
+			"is_active":               record.IsActive,
+			"created_at":              record.CreatedAt,
+			"updated_at":              record.UpdatedAt,
+			"token_expiry":            record.TokenExpiry,
+			"status":                  record.Status,
+			"ban_reason":              record.BanReason,
+			"email":                   email,
+			"plan_type":               planType,
+			"subscription_start_date": subscriptionStartDate,
+			"has_refresh_token":       record.RefreshToken != "",
+			"total_tasks":             taskStats.TotalTasks,
+			"total_success":           taskStats.TotalSuccess,
+			"total_fail":              taskStats.TotalFail,
+			"running_tasks":           taskStats.RunningTasks,
+		}
+		enrichedRecords = append(enrichedRecords, enrichedRecord)
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"items": enrichedRecords,
+		"total": len(enrichedRecords),
+	})
+}
+
+// UpdateTokenRecord 更新token记录配置
+func (h *TokenHandler) UpdateTokenRecord(c *gin.Context) {
+	id := c.Param("id")
+	tokenID, err := strconv.ParseUint(id, 10, 32)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid id"})
+		return
+	}
+
+	var req struct {
+		AutoGenerate  *bool `json:"auto_generate"`
+		Threshold     *int  `json:"threshold"`
+		GenerateBatch *int  `json:"generate_batch"`
+		IsActive      *bool `json:"is_active"`
+		Description   string `json:"description"`
+	}
+
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	updates := make(map[string]interface{})
+	if req.AutoGenerate != nil {
+		updates["auto_generate"] = *req.AutoGenerate
+	}
+	if req.Threshold != nil {
+		updates["threshold"] = *req.Threshold
+	}
+	if req.GenerateBatch != nil {
+		updates["generate_batch"] = *req.GenerateBatch
+	}
+	if req.IsActive != nil {
+		updates["is_active"] = *req.IsActive
+	}
+	if req.Description != "" {
+		updates["description"] = req.Description
+	}
+
+	if err := service.UpdateTokenRecord(uint(tokenID), updates); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"message": "updated"})
+}
+
+// GetGenerationTasks 获取生成任务历史
+func (h *TokenHandler) GetGenerationTasks(c *gin.Context) {
+	tokenRecordID := c.Query("token_record_id")
+	var tokenID uint
+	if tokenRecordID != "" {
+		id, err := strconv.ParseUint(tokenRecordID, 10, 32)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "invalid token_record_id"})
+			return
+		}
+		tokenID = uint(id)
+	}
+
+	tasks, err := service.GetGenerationTasks(tokenID)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"items": tasks,
+		"total": len(tasks),
+	})
+}
+
+// TriggerGeneration 手动触发生成
+func (h *TokenHandler) TriggerGeneration(c *gin.Context) {
+	id := c.Param("id")
+	tokenID, err := strconv.ParseUint(id, 10, 32)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid id"})
+		return
+	}
+
+	if err := service.ManualTriggerGeneration(uint(tokenID)); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"message": "生成任务已触发"})
+}
+
+// GetPoolStatus 获取号池状态
+func (h *TokenHandler) GetPoolStatus(c *gin.Context) {
+	db := database.GetDB()
+	
+	var stats struct {
+		TotalAccounts   int64 `json:"total_accounts"`
+		NormalAccounts  int64 `json:"normal_accounts"`
+		CoolingAccounts int64 `json:"cooling_accounts"`
+		BannedAccounts  int64 `json:"banned_accounts"`
+		ErrorAccounts   int64 `json:"error_accounts"`
+		DisabledAccounts int64 `json:"disabled_accounts"`
+		ActiveTokens    int64 `json:"active_tokens"`
+		RunningTasks    int64 `json:"running_tasks"`
+	}
+
+	// 统计账号状态
+	db.Model(&model.Account{}).Count(&stats.TotalAccounts)
+	db.Model(&model.Account{}).Where("status = ?", "normal").Count(&stats.NormalAccounts)
+	db.Model(&model.Account{}).Where("status = ?", "cooling").Count(&stats.CoolingAccounts)
+	db.Model(&model.Account{}).Where("status = ?", "banned").Count(&stats.BannedAccounts)
+	db.Model(&model.Account{}).Where("status = ?", "error").Count(&stats.ErrorAccounts)
+	db.Model(&model.Account{}).Where("status = ?", "disabled").Count(&stats.DisabledAccounts)
+	
+	// 统计激活的token
+	db.Model(&model.TokenRecord{}).Where("is_active = ?", true).Count(&stats.ActiveTokens)
+	
+	// 统计运行中的任务
+	db.Model(&model.GenerationTask{}).Where("status = ?", "running").Count(&stats.RunningTasks)
+
+	c.JSON(http.StatusOK, stats)
+}
+
+// DeleteTokenRecord 删除token记录
+func (h *TokenHandler) DeleteTokenRecord(c *gin.Context) {
+	id := c.Param("id")
+	tokenID, err := strconv.ParseUint(id, 10, 32)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid id"})
+		return
+	}
+
+	// 开启事务，确保删除操作的原子性
+	db := database.GetDB()
+	tx := db.Begin()
+	
+	// 先删除所有关联的生成任务历史记录
+	if err := tx.Where("token_record_id = ?", tokenID).Delete(&model.GenerationTask{}).Error; err != nil {
+		tx.Rollback()
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "删除关联任务失败: " + err.Error()})
+		return
+	}
+	
+	// 删除token记录本身
+	if err := tx.Delete(&model.TokenRecord{}, tokenID).Error; err != nil {
+		tx.Rollback()
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "删除token记录失败: " + err.Error()})
+		return
+	}
+	
+	// 提交事务
+	if err := tx.Commit().Error; err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "提交事务失败: " + err.Error()})
+		return
+	}
+	
+	c.JSON(http.StatusOK, gin.H{"message": "token及其所有历史记录已删除"})
+}
+
+// RefreshTokenRecord 刷新token记录
+func (h *TokenHandler) RefreshTokenRecord(c *gin.Context) {
+	id := c.Param("id")
+	tokenID, err := strconv.ParseUint(id, 10, 32)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid id"})
+		return
+	}
+
+	// 调用service层的刷新函数
+	if err := service.RefreshTokenAndAccounts(uint(tokenID)); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"message": "Token刷新成功，相关账号刷新已启动"})
+}

internal/middleware/auth.go

@@ -0,0 +1,126 @@
+package middleware
+
+import (
+	"net/http"
+	"os"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	"zencoder-2api/internal/service"
+)
+
+// LoggerMiddleware 为每个请求创建 logger 并在结束时 flush
+func LoggerMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		logger := service.NewRequestLogger()
+		ctx := service.WithLogger(c.Request.Context(), logger)
+		c.Request = c.Request.WithContext(ctx)
+		
+		c.Next()
+		
+		// 请求结束时 flush 日志
+		logger.Flush()
+	}
+}
+
+func AuthMiddleware() gin.HandlerFunc {
+	// 从环境变量获取全局 Token
+	token := os.Getenv("AUTH_TOKEN")
+
+	return func(c *gin.Context) {
+		// 如果没有配置全局 Token，则跳过鉴权
+		if token == "" {
+			c.Next()
+			return
+		}
+
+		// 1. 检查 OpenAI 格式: Authorization: Bearer <token>
+		authHeader := c.GetHeader("Authorization")
+		if authHeader != "" {
+			parts := strings.SplitN(authHeader, " ", 2)
+			if len(parts) == 2 && parts[0] == "Bearer" && parts[1] == token {
+				c.Next()
+				return
+			}
+		}
+
+		// 2. 检查 Anthropic 格式: x-api-key: <token>
+		if c.GetHeader("x-api-key") == token {
+			c.Next()
+			return
+		}
+
+		// 3. 检查 Gemini 格式: x-goog-api-key: <token> 或 query param key=<token>
+		if c.GetHeader("x-goog-api-key") == token {
+			c.Next()
+			return
+		}
+		if c.Query("key") == token {
+			c.Next()
+			return
+		}
+
+		// 鉴权失败
+		c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
+			"error": gin.H{
+				"message": "Invalid authentication token",
+				"type":    "authentication_error",
+			},
+		})
+	}
+}
+
+// AdminAuthMiddleware 后台管理密码验证中间件
+func AdminAuthMiddleware() gin.HandlerFunc {
+	// 从环境变量获取后台管理密码
+	adminPassword := os.Getenv("ADMIN_PASSWORD")
+
+	return func(c *gin.Context) {
+		// 如果没有配置管理密码，则跳过鉴权
+		if adminPassword == "" {
+			c.Next()
+			return
+		}
+
+		// 检查请求头中的管理密码
+		// 支持多种格式：
+		// 1. Authorization: Bearer <password>
+		// 2. X-Admin-Password: <password>
+		// 3. Admin-Password: <password>
+		
+		var providedPassword string
+		
+		// 检查 Authorization: Bearer <password>
+		authHeader := c.GetHeader("Authorization")
+		if authHeader != "" {
+			parts := strings.SplitN(authHeader, " ", 2)
+			if len(parts) == 2 && parts[0] == "Bearer" {
+				providedPassword = parts[1]
+			}
+		}
+		
+		// 检查 X-Admin-Password
+		if providedPassword == "" {
+			providedPassword = c.GetHeader("X-Admin-Password")
+		}
+		
+		// 检查 Admin-Password
+		if providedPassword == "" {
+			providedPassword = c.GetHeader("Admin-Password")
+		}
+
+		// 验证密码
+		if providedPassword == adminPassword {
+			c.Next()
+			return
+		}
+
+		// 鉴权失败
+		c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
+			"error": gin.H{
+				"message": "Invalid admin password",
+				"type":    "authentication_error",
+			},
+		})
+	}
+}

internal/model/account.go

@@ -0,0 +1,65 @@
+package model
+
+import (
+	"time"
+)
+
+type PlanType string
+
+const (
+	PlanFree     PlanType = "Free"
+	PlanStarter  PlanType = "Starter"
+	PlanCore     PlanType = "Core"
+	PlanAdvanced PlanType = "Advanced"
+	PlanMax      PlanType = "Max"
+)
+
+// 每日积分限制
+var PlanLimits = map[PlanType]int{
+	PlanFree:     30,
+	PlanStarter:  280,
+	PlanCore:     750,
+	PlanAdvanced: 1900,
+	PlanMax:      4200,
+}
+
+type Account struct {
+	ID            uint      `json:"id" gorm:"primaryKey"`
+	ClientID      string    `json:"client_id" gorm:"uniqueIndex;not null"`
+	ClientSecret  string    `json:"-" gorm:"not null"`  // 隐藏不传出
+	Email         string    `json:"email" gorm:"index"`
+	Category      string    `json:"category" gorm:"default:'normal';index"` // Deprecated: Use Status instead
+	Status        string    `json:"status" gorm:"default:'normal';index"`   // normal, cooling, banned, error, disabled
+	PlanType      PlanType  `json:"plan_type" gorm:"default:'Free'"`
+	Proxy         string    `json:"proxy"`
+	AccessToken   string    `json:"-" gorm:"type:text"`
+	RefreshToken  string    `json:"-" gorm:"type:text"` // 用于刷新 AccessToken
+	TokenExpiry   time.Time `json:"token_expiry"`       // 传出token过期时间
+	CreditRefreshTime time.Time `json:"credit_refresh_time"` // 积分刷新时间（来自Zen-Pricing-Period-End）
+	IsActive      bool      `json:"is_active" gorm:"default:true"`
+	IsCooling     bool      `json:"is_cooling" gorm:"default:false"`
+	CoolingUntil  time.Time `json:"cooling_until"` // 冷却结束时间
+	BanReason     string    `json:"ban_reason"`    // 封禁/冷却原因
+	RateLimitHits int       `json:"rate_limit_hits" gorm:"default:0"` // 429 错误次数
+	DailyUsed     float64   `json:"daily_used" gorm:"default:0"`
+	TotalUsed     float64   `json:"total_used" gorm:"default:0"`
+	LastResetDate         string    `json:"last_reset_date"`
+	SubscriptionStartDate time.Time `json:"subscription_start_date"`
+	LastUsed              time.Time `json:"last_used"`
+	ErrorCount            int       `json:"error_count" gorm:"default:0"`
+	CreatedAt             time.Time `json:"created_at"`
+	UpdatedAt             time.Time `json:"updated_at"`
+}
+
+type AccountRequest struct {
+	ClientID     string   `json:"client_id"`
+	ClientSecret string   `json:"client_secret"`
+	RefreshToken string   `json:"refresh_token"` // Refresh token for authentication
+	Token        string   `json:"token"` // Deprecated: Use RefreshToken instead
+	Email        string   `json:"email"`
+	PlanType     PlanType `json:"plan_type"`
+	Proxy        string   `json:"proxy"`
+	// Batch generation fields
+	GenerateMode bool `json:"generate_mode"` // true for batch generation mode
+	GenerateCount int `json:"generate_count"` // number of credentials to generate
+}

internal/model/debug.go

@@ -0,0 +1,29 @@
+package model
+
+import (
+	"log"
+)
+
+// DebugLogModelMapping 输出模型映射查找日志
+func DebugLogModelMapping(requestModel string, zenModel ZenModel, found bool) {
+	if found {
+		log.Printf("[DEBUG] [ModelMapping] ✓ 找到模型映射: request=%s → id=%s, model=%s, provider=%s, multiplier=%.1f",
+			requestModel, zenModel.ID, zenModel.Model, zenModel.ProviderID, zenModel.Multiplier)
+		if zenModel.Parameters != nil {
+			if zenModel.Parameters.Thinking != nil {
+				log.Printf("[DEBUG] [ModelMapping]   └─ thinking: type=%s, budgetTokens=%d",
+					zenModel.Parameters.Thinking.Type, zenModel.Parameters.Thinking.BudgetTokens)
+			}
+			if zenModel.Parameters.ExtraHeaders != nil {
+				for k, v := range zenModel.Parameters.ExtraHeaders {
+					log.Printf("[DEBUG] [ModelMapping]   └─ extraHeader: %s=%s", k, v)
+				}
+			}
+			if zenModel.Parameters.ForceStreaming != nil && *zenModel.Parameters.ForceStreaming {
+				log.Printf("[DEBUG] [ModelMapping]   └─ forceStreaming: true")
+			}
+		}
+	} else {
+		log.Printf("[DEBUG] [ModelMapping] ✗ 未找到模型映射: request=%s, 使用默认配置", requestModel)
+	}
+}

internal/model/openai.go

@@ -0,0 +1,53 @@
+package model
+
+// OpenAI compatible request/response structures
+
+type ChatCompletionRequest struct {
+	Model       string        `json:"model"`
+	Messages    []ChatMessage `json:"messages"`
+	MaxTokens   int           `json:"max_tokens,omitempty"`
+	Temperature float64       `json:"temperature,omitempty"`
+	TopP        float64       `json:"top_p,omitempty"`
+	Stream      bool          `json:"stream,omitempty"`
+	Stop        []string      `json:"stop,omitempty"`
+}
+
+type ChatMessage struct {
+	Role    string `json:"role"`
+	Content string `json:"content"`
+}
+
+type ChatCompletionResponse struct {
+	ID      string   `json:"id"`
+	Object  string   `json:"object"`
+	Created int64    `json:"created"`
+	Model   string   `json:"model"`
+	Choices []Choice `json:"choices"`
+	Usage   Usage    `json:"usage"`
+}
+
+type Choice struct {
+	Index        int         `json:"index"`
+	Message      ChatMessage `json:"message"`
+	FinishReason string      `json:"finish_reason"`
+}
+
+type Usage struct {
+	PromptTokens     int `json:"prompt_tokens"`
+	CompletionTokens int `json:"completion_tokens"`
+	TotalTokens      int `json:"total_tokens"`
+}
+
+type StreamChoice struct {
+	Index        int         `json:"index"`
+	Delta        ChatMessage `json:"delta"`
+	FinishReason *string     `json:"finish_reason"`
+}
+
+type ChatCompletionChunk struct {
+	ID      string         `json:"id"`
+	Object  string         `json:"object"`
+	Created int64          `json:"created"`
+	Model   string         `json:"model"`
+	Choices []StreamChoice `json:"choices"`
+}

internal/model/token_record.go

@@ -0,0 +1,48 @@
+package model
+
+import (
+	"time"
+)
+
+// TokenRecord 记录生成账号时使用的token
+type TokenRecord struct {
+	ID                    uint      `json:"id" gorm:"primaryKey"`
+	Token                 string    `json:"token" gorm:"type:text"` // 当前的access token（通过refresh_token生成）
+	RefreshToken          string    `json:"refresh_token" gorm:"type:text"` // 用于刷新token的refresh_token，可以为空
+	TokenExpiry           time.Time `json:"token_expiry"`            // access token过期时间
+	Description           string    `json:"description"`                      // token描述
+	Email                 string    `json:"email"`                            // 账号邮箱（从JWT解析）
+	PlanType              string    `json:"plan_type"`                        // 订阅等级（从JWT解析）
+	SubscriptionStartDate time.Time `json:"subscription_start_date"`          // 订阅开始时间（从JWT解析）
+	GeneratedCount        int       `json:"generated_count" gorm:"default:0"` // 已生成账号总数
+	LastGeneratedAt       time.Time `json:"last_generated_at"`               // 最后生成时间
+	AutoGenerate          bool      `json:"auto_generate" gorm:"default:true"` // 是否自动生成
+	Threshold             int       `json:"threshold" gorm:"default:10"`      // 触发自动生成的阈值
+	GenerateBatch         int       `json:"generate_batch" gorm:"default:30"` // 每批生成数量
+	IsActive              bool      `json:"is_active" gorm:"default:true"`    // 是否激活
+	Status                string    `json:"status" gorm:"default:'active'"`   // token状态: active, banned, expired, disabled
+	BanReason             string    `json:"ban_reason"`                        // 封禁原因
+	HasRefreshToken       bool      `json:"has_refresh_token" gorm:"default:false"` // 是否有refresh_token
+	TotalSuccess          int       `json:"total_success" gorm:"default:0"`    // 总成功数
+	TotalFail             int       `json:"total_fail" gorm:"default:0"`       // 总失败数
+	TotalTasks            int       `json:"total_tasks" gorm:"default:0"`      // 总任务数
+	RunningTasks          int       `json:"running_tasks" gorm:"-"`            // 运行中的任务数（不存储在数据库）
+	CreatedAt             time.Time `json:"created_at"`
+	UpdatedAt             time.Time `json:"updated_at"`
+}
+
+// GenerationTask 生成任务记录
+type GenerationTask struct {
+	ID            uint      `json:"id" gorm:"primaryKey"`
+	TokenRecordID uint      `json:"token_record_id" gorm:"index;not null"`
+	Token         string    `json:"-" gorm:"type:text"`                   // 实际使用的token
+	BatchSize     int       `json:"batch_size"`                           // 批次大小
+	SuccessCount  int       `json:"success_count" gorm:"default:0"`      // 成功数量
+	FailCount     int       `json:"fail_count" gorm:"default:0"`         // 失败数量
+	Status        string    `json:"status" gorm:"default:'pending'"`     // pending, running, completed, failed
+	StartedAt     time.Time `json:"started_at"`
+	CompletedAt   time.Time `json:"completed_at"`
+	ErrorMessage  string    `json:"error_message"`
+	CreatedAt     time.Time `json:"created_at"`
+	UpdatedAt     time.Time `json:"updated_at"`
+}

internal/model/zenmodel.go

@@ -0,0 +1,223 @@
+package model
+
+// ThinkingConfig thinking模式配置
+type ThinkingConfig struct {
+	Type         string `json:"type"`
+	BudgetTokens int    `json:"budgetTokens"`
+	Signature    string `json:"signature,omitempty"`
+}
+
+// ReasoningConfig OpenAI reasoning配置
+type ReasoningConfig struct {
+	Effort  string `json:"effort"`
+	Summary string `json:"summary,omitempty"`
+}
+
+// TextConfig OpenAI text配置
+type TextConfig struct {
+	Verbosity string `json:"verbosity"`
+}
+
+// ModelParameters 模型参数配置
+type ModelParameters struct {
+	Temperature    *float64          `json:"temperature,omitempty"`
+	Thinking       *ThinkingConfig   `json:"thinking,omitempty"`
+	Reasoning      *ReasoningConfig  `json:"reasoning,omitempty"`
+	Text           *TextConfig       `json:"text,omitempty"`
+	ExtraHeaders   map[string]string `json:"extraHeaders,omitempty"`
+	ForceStreaming *bool             `json:"forceStreaming,omitempty"`
+}
+
+type ZenModel struct {
+	ID          string           `json:"id"`
+	DisplayName string           `json:"displayName"`
+	Model       string           `json:"model"`
+	Multiplier  float64          `json:"multiplier"`
+	ProviderID  string           `json:"providerId"`
+	Parameters  *ModelParameters `json:"parameters,omitempty"`
+	IsHidden    bool             `json:"isHidden"`
+	PremiumOnly bool             `json:"premiumOnly"` // 仅Advanced/Max可用
+}
+
+// 辅助变量
+var (
+	temp0       = 0.0
+	temp1       = 1.0
+	forceStream = true
+
+	// Thinking模式参数
+	thinkingParams = &ModelParameters{
+		Temperature: &temp1,
+		Thinking:    &ThinkingConfig{Type: "enabled", BudgetTokens: 4096},
+		ExtraHeaders: map[string]string{
+			"anthropic-beta": "interleaved-thinking-2025-05-14",
+		},
+	}
+
+	// OpenAI reasoning参数
+	openaiParams = &ModelParameters{
+		Temperature: &temp1,
+		Reasoning:   &ReasoningConfig{Effort: "medium", Summary: "auto"},
+		Text:        &TextConfig{Verbosity: "medium"},
+	}
+)
+
+// 模型映射表
+var ZenModels = map[string]ZenModel{
+	// Anthropic Models - Thinking模式（通过ID访问）
+	"claude-haiku-4-5-20251001-thinking": {
+		ID: "haiku-4-5-think", DisplayName: "Haiku 4.5 Parallel Thinking",
+		Model: "claude-haiku-4-5-20251001", Multiplier: 1, ProviderID: "anthropic",
+		Parameters: thinkingParams,
+	},
+	"claude-sonnet-4-20250514-thinking": {
+		ID: "sonnet-4-think", DisplayName: "Sonnet 4 Parallel Thinking",
+		Model: "claude-sonnet-4-20250514", Multiplier: 3, ProviderID: "anthropic",
+		Parameters: thinkingParams,
+		IsHidden:   true,
+	},
+	"claude-sonnet-4-5-20250929-thinking": {
+		ID: "sonnet-4-5-think", DisplayName: "Sonnet 4.5 Parallel Thinking",
+		Model: "claude-sonnet-4-5-20250929", Multiplier: 3, ProviderID: "anthropic",
+		Parameters: thinkingParams,
+	},
+	"claude-opus-4-1-20250805-thinking": {
+		ID: "opus-4-think", DisplayName: "Opus 4.1 Parallel Thinking",
+		Model: "claude-opus-4-1-20250805", Multiplier: 15, ProviderID: "anthropic",
+		PremiumOnly: true,
+		Parameters: &ModelParameters{
+			Temperature:    &temp1,
+			Thinking:       &ThinkingConfig{Type: "enabled", BudgetTokens: 4096},
+			ExtraHeaders:   map[string]string{"anthropic-beta": "interleaved-thinking-2025-05-14"},
+			ForceStreaming: &forceStream,
+		},
+		IsHidden: true,
+	},
+	"claude-opus-4-5-20251101-thinking": {
+		ID: "opus-4-5-think", DisplayName: "Opus 4.5 Parallel Thinking",
+		Model: "claude-opus-4-5-20251101", Multiplier: 5, ProviderID: "anthropic",
+		PremiumOnly: true,
+		Parameters: &ModelParameters{
+			Temperature:    &temp1,
+			Thinking:       &ThinkingConfig{Type: "enabled", BudgetTokens: 4096},
+			ExtraHeaders:   map[string]string{"anthropic-beta": "interleaved-thinking-2025-05-14"},
+			ForceStreaming: &forceStream,
+		},
+	},
+	// Anthropic Models - 标准模式（不带 Thinking）
+	"claude-sonnet-4-20250514": {
+		ID: "sonnet-4", DisplayName: "Sonnet 4",
+		Model: "claude-sonnet-4-20250514", Multiplier: 2, ProviderID: "anthropic",
+	},
+	"claude-sonnet-4-5-20250929": {
+		ID: "sonnet-4-5", DisplayName: "Sonnet 4.5",
+		Model: "claude-sonnet-4-5-20250929", Multiplier: 2, ProviderID: "anthropic",
+	},
+	"claude-opus-4-1-20250805": {
+		ID: "opus-4", DisplayName: "Opus 4.1",
+		Model: "claude-opus-4-1-20250805", Multiplier: 10, ProviderID: "anthropic",
+		PremiumOnly: true,
+		Parameters:  &ModelParameters{ForceStreaming: &forceStream},
+	},
+	"claude-opus-4-5-20251101": { //非原生实现
+		ID: "opus-4-5-think", DisplayName: "Opus 4.5 Parallel Thinking",
+		Model: "claude-opus-4-5-20251101", Multiplier: 5, ProviderID: "anthropic",
+		PremiumOnly: true,
+		Parameters: &ModelParameters{
+			Temperature:    &temp1,
+			Thinking:       &ThinkingConfig{Type: "enabled", BudgetTokens: 4096},
+			ExtraHeaders:   map[string]string{"anthropic-beta": "interleaved-thinking-2025-05-14"},
+			ForceStreaming: &forceStream,
+		},
+	},
+	"claude-haiku-4-5-20251001": { //非原生实现
+		ID: "haiku-4-5-think", DisplayName: "Haiku 4.5 Parallel Thinking",
+		Model: "claude-haiku-4-5-20251001", Multiplier: 1, ProviderID: "anthropic",
+		Parameters: thinkingParams,
+	},
+	// Gemini Models
+	"gemini-3-pro-preview": {
+		ID: "gemini-3-pro-preview", DisplayName: "Gemini Pro 3.0",
+		Model: "gemini-3-pro-preview", Multiplier: 2, ProviderID: "gemini",
+		Parameters: &ModelParameters{Temperature: &temp1},
+	},
+	"gemini-3-flash-preview": {
+		ID: "gemini-3-flash-preview", DisplayName: "Gemini Flash 3.0",
+		Model: "gemini-3-flash-preview", Multiplier: 1, ProviderID: "gemini",
+		Parameters: &ModelParameters{Temperature: &temp1},
+		IsHidden:   true,
+	},
+
+	// OpenAI Models
+	"gpt-5.1-codex-mini": {
+		ID: "gpt-5-1-codex-mini", DisplayName: "GPT-5.1 Codex mini",
+		Model: "gpt-5.1-codex-mini", Multiplier: 0.5, ProviderID: "openai",
+		Parameters: openaiParams,
+	},
+	"gpt-5.1-codex": {
+		ID: "gpt-5-1-codex-medium", DisplayName: "GPT-5.1 Codex",
+		Model: "gpt-5.1-codex", Multiplier: 1, ProviderID: "openai",
+		Parameters: openaiParams,
+		IsHidden:   true,
+	},
+	"gpt-5.1-codex-max": {
+		ID: "gpt-5-1-codex-max", DisplayName: "GPT-5.1 Codex Max",
+		Model: "gpt-5.1-codex-max", Multiplier: 1.5, ProviderID: "openai",
+		Parameters: openaiParams,
+	},
+	"gpt-5.2-codex": {
+		ID: "gpt-5-2-codex", DisplayName: "GPT-5.2 Codex",
+		Model: "gpt-5.2-codex", Multiplier: 2, ProviderID: "openai",
+		Parameters: openaiParams,
+	},
+	"gpt-5-2025-08-07": {
+		ID: "gpt-5-medium", DisplayName: "GPT-5",
+		Model: "gpt-5-2025-08-07", Multiplier: 1, ProviderID: "openai",
+		Parameters: openaiParams,
+		IsHidden:   true,
+	},
+	"gpt-5-codex": {
+		ID: "gpt-5-codex-medium", DisplayName: "GPT-5-Codex",
+		Model: "gpt-5-codex", Multiplier: 1, ProviderID: "openai",
+		Parameters: openaiParams,
+		IsHidden:   true,
+	},
+
+	// xAI Models
+	"grok-code-fast-1": {
+		ID: "grok-code-fast", DisplayName: "Grok Code Fast 1",
+		Model: "grok-code-fast-1", Multiplier: 0.25, ProviderID: "xai",
+		Parameters: &ModelParameters{Temperature: &temp0},
+	},
+
+	// Utility Models
+	"gpt-5-nano-2025-08-07": {
+		ID: "generate-name-v2", DisplayName: "Cheap model for generating names",
+		Model: "gpt-5-nano-2025-08-07", Multiplier: 0, ProviderID: "openai",
+		Parameters: &ModelParameters{
+			Reasoning: &ReasoningConfig{Effort: "minimal"},
+		},
+	},
+}
+
+// GetZenModel 获取模型配置，如果不存在则返回空模型和false
+func GetZenModel(modelID string) (ZenModel, bool) {
+	if m, ok := ZenModels[modelID]; ok {
+		return m, true
+	}
+	// 模型不存在，返回空模型和false
+	return ZenModel{}, false
+}
+
+// CanUseModel 检查订阅类型是否可以使用指定模型
+func CanUseModel(planType PlanType, modelID string) bool {
+	zenModel, _ := GetZenModel(modelID)
+
+	// Advanced和Max可以使用所有模型
+	if planType == PlanAdvanced || planType == PlanMax {
+		return true
+	}
+
+	// 其他订阅类型不能使用PremiumOnly模型
+	return !zenModel.PremiumOnly
+}

internal/service/anthropic.go

@@ -0,0 +1,1602 @@
+package service
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"math/rand"
+	"net/http"
+	"strings"
+	"time"
+
+	"zencoder-2api/internal/model"
+	"zencoder-2api/internal/service/provider"
+)
+
+// sanitizeRequestBody 清理请求体中的敏感信息，保留结构但替换内容
+func sanitizeRequestBody(body []byte) string {
+	var reqMap map[string]interface{}
+	if err := json.Unmarshal(body, &reqMap); err != nil {
+		return string(body) // 如果解析失败，返回原始内容
+	}
+
+	// 处理messages数组
+	if messages, ok := reqMap["messages"].([]interface{}); ok {
+		for i, msg := range messages {
+			if msgMap, ok := msg.(map[string]interface{}); ok {
+				// 处理content字段
+				if content, exists := msgMap["content"]; exists {
+					// content可能是字符串或数组
+					switch c := content.(type) {
+					case string:
+						// 如果是字符串，直接替换
+						msgMap["content"] = "Content omitted"
+					case []interface{}:
+						// 如果是数组（结构化内容），保留结构但替换文本
+						for j, block := range c {
+							if blockMap, ok := block.(map[string]interface{}); ok {
+								// 保留type字段
+								if blockType, hasType := blockMap["type"]; hasType {
+									// 根据type处理不同的内容块
+									switch blockType {
+									case "text":
+										// 替换text内容
+										blockMap["text"] = "Content omitted"
+									case "thinking", "redacted_thinking":
+										// thinking块：替换thinking内容
+										if _, hasThinking := blockMap["thinking"]; hasThinking {
+											blockMap["thinking"] = "Content omitted"
+										}
+										// 保留signature字段不变
+									case "image":
+										// 图片块：清理source内容
+										if source, hasSource := blockMap["source"]; hasSource {
+											if sourceMap, ok := source.(map[string]interface{}); ok {
+												// 保留类型但清理数据
+												if _, hasData := sourceMap["data"]; hasData {
+													sourceMap["data"] = "Image data omitted"
+												}
+											}
+										}
+									case "tool_use":
+										// 工具使用块：清理input内容
+										if _, hasInput := blockMap["input"]; hasInput {
+											blockMap["input"] = map[string]interface{}{
+												"note": "Tool input omitted",
+											}
+										}
+									case "tool_result":
+										// 工具结果块：清理content内容
+										if _, hasContent := blockMap["content"]; hasContent {
+											blockMap["content"] = "Tool result omitted"
+										}
+									}
+								}
+								c[j] = blockMap
+							}
+						}
+						msgMap["content"] = c
+					}
+				}
+				messages[i] = msgMap
+			}
+		}
+		reqMap["messages"] = messages
+	}
+
+	// 处理tools字段 - 改为空数组
+	if _, hasTools := reqMap["tools"]; hasTools {
+		reqMap["tools"] = []interface{}{}
+	}
+
+	// 处理system字段 - 替换为固定文本
+	if _, hasSystem := reqMap["system"]; hasSystem {
+		reqMap["system"] = "System prompt omitted"
+	}
+
+	// 序列化为JSON字符串
+	sanitized, _ := json.MarshalIndent(reqMap, "", "  ")
+	return string(sanitized)
+}
+
+// logRequestDetails 记录请求详细信息
+func logRequestDetails(prefix string, headers http.Header, body []byte) {
+	log.Printf("%s 请求详情:", prefix)
+
+	// 记录请求头
+	log.Printf("%s 请求头:", prefix)
+	for k, v := range headers {
+		// 过滤敏感请求头
+		if strings.Contains(strings.ToLower(k), "auth") ||
+			strings.Contains(strings.ToLower(k), "key") ||
+			strings.Contains(strings.ToLower(k), "token") {
+			log.Printf("  %s: [REDACTED]", k)
+		} else {
+			log.Printf("  %s: %s", k, strings.Join(v, ", "))
+		}
+	}
+
+	// 记录请求体（已清理敏感信息）
+	log.Printf("%s 请求体 (已清理):", prefix)
+	log.Printf("%s", sanitizeRequestBody(body))
+}
+
+const AnthropicBaseURL = "https://api.zencoder.ai/anthropic"
+
+type AnthropicService struct{}
+
+func NewAnthropicService() *AnthropicService {
+	return &AnthropicService{}
+}
+
+// Messages 处理/v1/messages请求，直接透传到Anthropic API
+func (s *AnthropicService) Messages(ctx context.Context, body []byte, isStream bool) (*http.Response, error) {
+	var req struct {
+		Model     string                 `json:"model"`
+		MaxTokens float64                `json:"max_tokens,omitempty"`
+		Thinking  map[string]interface{} `json:"thinking,omitempty"`
+	}
+	if err := json.Unmarshal(body, &req); err != nil {
+		return nil, fmt.Errorf("invalid request body: %w", err)
+	}
+
+	// 记录请求的模型和thinking状态
+	thinkingStatus := "disabled"
+	if req.Thinking != nil {
+		if enabled, ok := req.Thinking["enabled"].(bool); ok && enabled {
+			thinkingStatus = "enabled"
+		} else if thinkingType, ok := req.Thinking["type"].(string); ok && thinkingType == "enabled" {
+			thinkingStatus = "enabled"
+		}
+		// 如果有thinking配置且有budget_tokens，也记录
+		if budget, ok := req.Thinking["budget_tokens"].(float64); ok && budget > 0 {
+			thinkingStatus = fmt.Sprintf("enabled(budget=%g)", budget)
+		}
+	}
+	// 只在非限速测试时输出请求信息
+	if IsDebugMode() && !strings.Contains(req.Model, "test") {
+		log.Printf("[Anthropic] 请求 - Model: %s, Thinking: %s", req.Model, thinkingStatus)
+	}
+
+	// 检查是否需要映射到对应的thinking模型
+	originalModel := req.Model
+	if req.Thinking != nil {
+		// 检查是否开启了thinking
+		thinkingEnabled := false
+		if enabled, ok := req.Thinking["enabled"].(bool); ok && enabled {
+			thinkingEnabled = true
+		} else if thinkingType, ok := req.Thinking["type"].(string); ok && thinkingType == "enabled" {
+			thinkingEnabled = true
+		}
+
+		if thinkingEnabled {
+			// 检查是否存在对应的thinking模型
+			thinkingModelID := req.Model + "-thinking"
+			if _, exists := model.GetZenModel(thinkingModelID); exists {
+				req.Model = thinkingModelID
+				DebugLog(ctx, "[Anthropic] 映射到thinking模型: %s -> %s", originalModel, req.Model)
+			}
+		}
+	}
+
+	// 检查模型是否存在于模型字典中
+	_, exists := model.GetZenModel(req.Model)
+	if !exists {
+		DebugLog(ctx, "[Anthropic] 模型不存在: %s", req.Model)
+		return nil, ErrNoAvailableAccount
+	}
+
+	DebugLogRequest(ctx, "Anthropic", "/v1/messages", req.Model)
+
+	// 处理max_tokens和thinking.budget_tokens的关系
+	// 如果用户传入了thinking配置，检查并调整max_tokens
+	if req.Thinking != nil {
+		budgetTokens := 0.0
+		if budget, ok := req.Thinking["budget_tokens"].(float64); ok {
+			budgetTokens = budget
+		}
+
+		// 如果max_tokens小于等于budget_tokens，调整max_tokens
+		if budgetTokens > 0 && req.MaxTokens > 0 && req.MaxTokens <= budgetTokens {
+			// 按用户要求：max_tokens = max_tokens + budget_tokens
+			newMaxTokens := req.MaxTokens + budgetTokens
+
+			// 修改原始请求体中的max_tokens
+			var reqMap map[string]interface{}
+			if err := json.Unmarshal(body, &reqMap); err == nil {
+				reqMap["max_tokens"] = newMaxTokens
+				if modifiedBody, err := json.Marshal(reqMap); err == nil {
+					body = modifiedBody
+					DebugLog(ctx, "[Anthropic] 调整max_tokens: %.0f -> %.0f (原值+budget_tokens)", req.MaxTokens, newMaxTokens)
+				}
+			}
+		}
+	}
+
+	var lastErr error
+	for i := 0; i < MaxRetries; i++ {
+		account, err := GetNextAccountForModel(req.Model)
+		if err != nil {
+			DebugLogRequestEnd(ctx, "Anthropic", false, err)
+			return nil, err
+		}
+		DebugLogAccountSelected(ctx, "Anthropic", account.ID, account.Email)
+
+		resp, err := s.doRequest(ctx, account, req.Model, body)
+		if err != nil {
+			// 请求失败，释放账号
+			ReleaseAccount(account)
+			// MarkAccountError(account)
+			lastErr = err
+			DebugLogRetry(ctx, "Anthropic", i+1, account.ID, err)
+			continue
+		}
+
+		// 只在调试模式下且非限速测试时输出详细响应信息
+		if IsDebugMode() && !strings.Contains(req.Model, "test") {
+			DebugLogResponseReceived(ctx, "Anthropic", resp.StatusCode)
+
+			// 只输出积分信息，不输出所有响应头
+			if resp.Header.Get("Zen-Pricing-Period-Limit") != "" ||
+				resp.Header.Get("Zen-Pricing-Period-Cost") != "" ||
+				resp.Header.Get("Zen-Request-Cost") != "" {
+				DebugLog(ctx, "[Anthropic] 积分信息 - 周期限额: %s, 周期消耗: %s, 本次消耗: %s",
+					resp.Header.Get("Zen-Pricing-Period-Limit"),
+					resp.Header.Get("Zen-Pricing-Period-Cost"),
+					resp.Header.Get("Zen-Request-Cost"))
+			}
+		}
+
+		if resp.StatusCode >= 400 {
+			// 读取错误响应内容
+			errBody, _ := io.ReadAll(resp.Body)
+			resp.Body.Close()
+
+			// 检查是否是官方API直接抛出的错误（413、400、429）
+			// 这些错误不是token池问题，应直接返回给客户端
+			if resp.StatusCode == 413 || resp.StatusCode == 400 || resp.StatusCode == 429 {
+				// 对于400错误，根据错误类型决定日志级别
+				if resp.StatusCode == 400 {
+					// 解析thinking状态用于日志
+					thinkingStatus := "disabled"
+					if req.Thinking != nil {
+						if enabled, ok := req.Thinking["enabled"].(bool); ok && enabled {
+							thinkingStatus = "enabled"
+						} else if thinkingType, ok := req.Thinking["type"].(string); ok && thinkingType == "enabled" {
+							thinkingStatus = "enabled"
+						}
+						// 如果有thinking配置且有budget_tokens，也记录
+						if budget, ok := req.Thinking["budget_tokens"].(float64); ok && budget > 0 {
+							thinkingStatus = fmt.Sprintf("enabled(budget=%g)", budget)
+						}
+					}
+
+					// 尝试解析错误类型
+					var errResp struct {
+						Error struct {
+							Type    string `json:"type"`
+							Message string `json:"message"`
+						} `json:"error"`
+					}
+
+					isKnownError := false
+					isPromptTooLongError := false
+					if err := json.Unmarshal(errBody, &errResp); err == nil && errResp.Error.Type != "" {
+						// 检查是否是已知的错误类型
+						knownErrors := []string{
+							"prompt is too long",
+							"max_tokens",
+							"invalid_request_error",
+							"authentication_error",
+							"permission_error",
+							"rate_limit_error",
+						}
+
+						errorMessage := strings.ToLower(errResp.Error.Message)
+						for _, known := range knownErrors {
+							if strings.Contains(errorMessage, known) || errResp.Error.Type == known {
+								isKnownError = true
+								if known == "prompt is too long" || strings.Contains(errorMessage, "prompt is too long") {
+									isPromptTooLongError = true
+								}
+								break
+							}
+						}
+
+						if isKnownError {
+							// 已知错误，只输出简单日志，包含请求模型ID和thinking状态
+							log.Printf("[Anthropic] 400错误: %s - %s (Model: %s, Thinking: %s)", errResp.Error.Type, errResp.Error.Message, req.Model, thinkingStatus)
+
+							// 对于非"prompt is too long"错误，在DEBUG模式下输出详细信息
+							if !isPromptTooLongError && IsDebugMode() {
+								if originalHeaders, ok := ctx.Value("originalHeaders").(http.Header); ok {
+									logRequestDetails("[Anthropic] 原始客户端", originalHeaders, body)
+								}
+							}
+						} else {
+							// 未知错误，输出详细日志用于调试，包含请求模型ID和thinking状态
+							log.Printf("[Anthropic] 400未知错误: %s (Model: %s, Thinking: %s)", string(errBody), req.Model, thinkingStatus)
+							if IsDebugMode() {
+								// DEBUG模式下输出原始请求信息
+								if originalHeaders, ok := ctx.Value("originalHeaders").(http.Header); ok {
+									logRequestDetails("[Anthropic] 原始客户端", originalHeaders, body)
+								}
+							}
+						}
+					} else {
+						// 解析失败，输出完整错误用于调试，包含请求模型ID和thinking状态
+						log.Printf("[Anthropic] 400错误（无法解析）: %s (Model: %s, Thinking: %s)", string(errBody), req.Model, thinkingStatus)
+						if IsDebugMode() {
+							// DEBUG模式下输出原始请求信息
+							if originalHeaders, ok := ctx.Value("originalHeaders").(http.Header); ok {
+								logRequestDetails("[Anthropic] 原始客户端", originalHeaders, body)
+							}
+						}
+					}
+				} else if resp.StatusCode == 429 {
+					// 简化429错误日志输出
+					s.classifyAndLog429Error(string(errBody), account.ID, account.Email)
+
+					// 检查是否是Claude官方的429错误
+					isClaudeOfficialError := s.isClaudeOfficial429Error(string(errBody))
+
+					// 尝试使用代理池重试
+					proxyResp, proxyErr := s.retryWithProxy(ctx, account, req.Model, body)
+					if proxyErr == nil && proxyResp != nil {
+						// 代理重试成功
+						ReleaseAccount(account)
+						return proxyResp, nil
+					}
+
+					if proxyErr != nil {
+						log.Printf("[Anthropic] 代理重试失败 账号ID:%d %s", account.ID, account.Email)
+					}
+
+					// 只有Claude官方的429错误才返回原始响应，其他429错误返回通用错误
+					if isClaudeOfficialError {
+						// Claude官方429错误，返回原始响应
+						ReleaseAccount(account)
+						return &http.Response{
+							StatusCode: resp.StatusCode,
+							Header:     resp.Header,
+							Body:       io.NopCloser(bytes.NewReader(errBody)),
+						}, nil
+					} else {
+						// 非Claude官方429错误，不返回原始响应，继续重试其他账号
+						ReleaseAccount(account)
+						lastErr = fmt.Errorf("non-official 429 error")
+						if IsDebugMode() {
+							DebugLogRetry(ctx, "Anthropic", i+1, account.ID, lastErr)
+						}
+						continue
+					}
+				}
+				// 对于其他官方API错误（400、413）：
+				// 1. 释放账号
+				// 2. 不计算账号错误次数
+				// 3. 直接返回原始响应
+				ReleaseAccount(account)
+				return &http.Response{
+					StatusCode: resp.StatusCode,
+					Header:     resp.Header,
+					Body:       io.NopCloser(bytes.NewReader(errBody)),
+				}, nil
+			}
+
+			// 503和529错误：上游API错误，不是token问题
+			if resp.StatusCode == 503 || resp.StatusCode == 529 {
+				// 只记录简单的错误日志
+				log.Printf("错误响应 [%d]: %s", resp.StatusCode, string(errBody))
+				// 释放账号，不计算错误次数，返回通用错误
+				ReleaseAccount(account)
+				return nil, ErrNoAvailableAccount
+			}
+
+			// 500错误处理
+			if resp.StatusCode == 500 {
+				// 检查是否是限速问题
+				if strings.Contains(string(errBody), "Rate limit tracking problem") {
+					log.Printf("[Anthropic] 限速跟踪问题，尝试使用代理重试")
+
+					// 尝试使用代理池重试
+					proxyResp, proxyErr := s.retryWithProxy(ctx, account, req.Model, body)
+					if proxyErr == nil && proxyResp != nil {
+						// 代理重试成功
+						ReleaseAccount(account)
+						return proxyResp, nil
+					}
+
+					log.Printf("[Anthropic] 代理重试失败: %v", proxyErr)
+
+					// 代理重试失败，继续原有逻���：冻结账号5-10秒随机时间
+					freezeTime := 5 + rand.Intn(6) // 5-10秒随机
+
+					// 非调试模式下只输出简单信息
+					if !IsDebugMode() {
+						log.Printf("[Anthropic] 限速错误，冻结账号 ID:%d %s %d秒，重试 #%d", account.ID, account.Email, freezeTime, i+1)
+					} else {
+						log.Printf("[Anthropic] 检测到限速错误，冻结账号 ID:%d %s %d秒", account.ID, account.Email, freezeTime)
+					}
+
+					// 冻结账号并释放（不计算错误次数，这是临时限速问题）
+					FreezeAccount(account, time.Duration(freezeTime)*time.Second) // 这个函数内部会释放账号
+
+					// 设置错误并继续重试其他账号
+					lastErr = fmt.Errorf("rate limit tracking problem")
+
+					// 只在调试模式下输出详细重试日志
+					if IsDebugMode() {
+						DebugLogRetry(ctx, "Anthropic", i+1, account.ID, lastErr)
+					}
+					continue
+				}
+
+				// 其他500错误，释放账号并直接返回
+				ReleaseAccount(account)
+				return &http.Response{
+					StatusCode: resp.StatusCode,
+					Header:     resp.Header,
+					Body:       io.NopCloser(bytes.NewReader(errBody)),
+				}, nil
+			}
+
+			// 其他错误，释放账号并继续重试
+			ReleaseAccount(account)
+			// MarkAccountError(account)
+			lastErr = fmt.Errorf("API error: %d", resp.StatusCode)
+
+			// 只在调试模式下输出详细错误信息
+			if IsDebugMode() {
+				DebugLogErrorResponse(ctx, "Anthropic", resp.StatusCode, string(errBody))
+				DebugLogRetry(ctx, "Anthropic", i+1, account.ID, lastErr)
+			} else {
+				// 非调试模式下只输出简单的重试信息
+				log.Printf("[Anthropic] API错误 %d，重试 #%d", resp.StatusCode, i+1)
+			}
+			continue
+		}
+
+		// 请求成功，释放账号
+		ReleaseAccount(account)
+
+		ResetAccountError(account)
+		zenModel, exists := model.GetZenModel(req.Model)
+		if !exists {
+			// 模型不存在，使用默认倍率
+			UpdateAccountCreditsFromResponse(account, resp, 1.0)
+		} else {
+			// 使用统一的积分更新函数，自动处理响应头中的积分信息
+			UpdateAccountCreditsFromResponse(account, resp, zenModel.Multiplier)
+		}
+
+		DebugLogRequestEnd(ctx, "Anthropic", true, nil)
+		return resp, nil
+	}
+
+	// 只在调试模式下输出详细的请求结束日志
+	if IsDebugMode() {
+		DebugLogRequestEnd(ctx, "Anthropic", false, lastErr)
+	} else {
+		// 非调试模式下只输出简单的失败信息
+		log.Printf("[Anthropic] 所有重试失败: %v", lastErr)
+	}
+
+	// 检查是否是网络连接错误，如果是则返回统一的错误信息，避免暴露内部网络详情
+	if lastErr != nil {
+		errStr := lastErr.Error()
+		// 检查常见的网络连接错误
+		if strings.Contains(errStr, "dial tcp") ||
+			strings.Contains(errStr, "connection refused") ||
+			strings.Contains(errStr, "no such host") ||
+			strings.Contains(errStr, "cannot assign requested address") ||
+			strings.Contains(errStr, "timeout") ||
+			strings.Contains(errStr, "network is unreachable") {
+			return nil, ErrNoAvailableAccount
+		}
+	}
+
+	return nil, fmt.Errorf("all retries failed: %w", lastErr)
+}
+
+func (s *AnthropicService) doRequest(ctx context.Context, account *model.Account, modelID string, body []byte) (*http.Response, error) {
+	zenModel, exists := model.GetZenModel(modelID)
+	if !exists {
+		// 模型不存在，返回错误
+		return nil, ErrNoAvailableAccount
+	}
+
+	// 注意：已移除模型替换逻辑，直接使用原始请求体
+	modifiedBody := body
+
+	// 对于需要 thinking 的模型，强制添加 thinking 配置
+	var err error
+	modifiedBody, err = s.ensureThinkingConfig(modifiedBody, modelID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to ensure thinking config: %w", err)
+	}
+
+	// 根据模型要求调整参数（温度、top_p等）
+	modifiedBody, err = s.adjustParametersForModel(modifiedBody, modelID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to adjust parameters: %w", err)
+	}
+
+	// 注意：已移除模型重定向逻辑，直接使用用户请求的模型名
+	DebugLogActualModel(ctx, "Anthropic", modelID, modelID)
+
+	reqURL := AnthropicBaseURL + "/v1/messages"
+	DebugLogRequestSent(ctx, "Anthropic", reqURL)
+
+	resp, err := s.makeRequest(ctx, modifiedBody, account, zenModel)
+	if err != nil {
+		return nil, err
+	}
+
+	// 检查是否是400错误，需要特殊处理
+	if resp.StatusCode == 400 {
+		bodyBytes, readErr := io.ReadAll(resp.Body)
+		resp.Body.Close()
+
+		if readErr == nil {
+			errorBody := string(bodyBytes)
+
+			// 检查是否是thinking格式错误，但不再进行模型切换
+			if s.isThinkingFormatError(errorBody) {
+				log.Printf("[Anthropic] thinking格式错误: %s", errorBody)
+			}
+
+			// 检查是否是thinking signature过期错误
+			if s.isThinkingSignatureError(errorBody) {
+				// 解析当前请求的模型和thinking状态
+				var reqInfo struct {
+					Model string `json:"model"`
+					Thinking map[string]interface{} `json:"thinking,omitempty"`
+				}
+				json.Unmarshal(modifiedBody, &reqInfo)
+				
+				thinkingStatus := "disabled"
+				if reqInfo.Thinking != nil {
+					if enabled, ok := reqInfo.Thinking["enabled"].(bool); ok && enabled {
+						thinkingStatus = "enabled"
+					} else if thinkingType, ok := reqInfo.Thinking["type"].(string); ok && thinkingType == "enabled" {
+						thinkingStatus = "enabled"
+					}
+					if budget, ok := reqInfo.Thinking["budget_tokens"].(float64); ok && budget > 0 {
+						thinkingStatus = fmt.Sprintf("enabled(budget=%g)", budget)
+					}
+				}
+
+				if IsDebugMode() {
+					log.Printf("[Anthropic] thinking signature过期，尝试转换assistant消息为user消息重试")
+				} else {
+					log.Printf("[Anthropic] thinking signature过期，尝试转换assistant消息为user消息重试 model:%s thinking:%s", reqInfo.Model, thinkingStatus)
+				}
+
+				// 转换请求体：将assistant消息转换为user消息
+				fixedBody, fixErr := s.convertAssistantMessagesToUser(modifiedBody)
+				if fixErr == nil {
+					return s.makeRequest(ctx, fixedBody, account, zenModel)
+				} else {
+					log.Printf("[Anthropic] 转换assistant消息失败: %v", fixErr)
+				}
+			}
+
+			// 检查是否是参数冲突错误（temperature 和 top_p 不能同时指定）
+			if s.isParameterConflictError(errorBody) {
+				DebugLogRequestSent(ctx, "Anthropic", "Retrying with only temperature parameter")
+
+				// 移除 top_p 参数，只保留 temperature
+				fixedBody, fixErr := s.removeTopP(modifiedBody)
+				if fixErr == nil {
+					return s.makeRequest(ctx, fixedBody, account, zenModel)
+				}
+			}
+
+			// 检查是否是温度参数错误
+			if s.isTemperatureError(errorBody) {
+				DebugLogRequestSent(ctx, "Anthropic", "Retrying with temperature=1.0")
+
+				// 强制设置温度为1.0并重试
+				fixedBody, fixErr := s.forceTemperature(modifiedBody, 1.0)
+				if fixErr == nil {
+					return s.makeRequest(ctx, fixedBody, account, zenModel)
+				}
+			}
+
+		}
+
+		// 如果不是thinking相关的可修复错误，返回原始响应
+		return &http.Response{
+			StatusCode: resp.StatusCode,
+			Header:     resp.Header,
+			Body:       io.NopCloser(bytes.NewReader(bodyBytes)),
+		}, nil
+	}
+
+	return resp, nil
+}
+
+func (s *AnthropicService) makeRequest(ctx context.Context, body []byte, account *model.Account, zenModel model.ZenModel) (*http.Response, error) {
+	httpReq, err := http.NewRequest("POST", AnthropicBaseURL+"/v1/messages", bytes.NewReader(body))
+	if err != nil {
+		return nil, err
+	}
+
+	// 设置Zencoder自定义请求头
+	SetZencoderHeaders(httpReq, account, zenModel)
+
+	// Anthropic特有请求头
+	httpReq.Header.Set("anthropic-version", "2023-06-01")
+
+	// 添加模型配置的额外请求头
+	if zenModel.Parameters != nil && zenModel.Parameters.ExtraHeaders != nil {
+		for k, v := range zenModel.Parameters.ExtraHeaders {
+			httpReq.Header.Set(k, v)
+		}
+	}
+
+	// 只在非限速测试且调试模式下记录请求头
+	if IsDebugMode() {
+		// 检查请求体中的模型以判断是否为限速测试
+		var reqCheck struct {
+			Model string `json:"model"`
+		}
+		if json.Unmarshal(body, &reqCheck) == nil && !strings.Contains(reqCheck.Model, "test") {
+			DebugLogRequestHeaders(ctx, "Anthropic", httpReq.Header)
+		}
+	}
+
+	httpClient := provider.NewHTTPClient(account.Proxy, 0)
+	resp, err := httpClient.Do(httpReq)
+	if err != nil {
+		return nil, err
+	}
+
+	// 不输出响应头调试信息以减少日志量
+
+	// 如果是400错误，记录详细的请求信息
+	if resp.StatusCode == 400 {
+		// 读取错误响应内容
+		errBody, _ := io.ReadAll(resp.Body)
+		resp.Body.Close()
+
+		// 检查是否是"prompt is too long"错误
+		isPromptTooLongError := false
+		// 检查是否是thinking格式错误（将在doRequest中处理并重试）
+		isThinkingFormatError := false
+		// 检查是否是thinking signature过期错误（将在doRequest中处理并重试）
+		isThinkingSignatureError := false
+		var errResp struct {
+			Error struct {
+				Type    string `json:"type"`
+				Message string `json:"message"`
+			} `json:"error"`
+		}
+
+		if err := json.Unmarshal(errBody, &errResp); err == nil {
+			errorMessage := strings.ToLower(errResp.Error.Message)
+			if strings.Contains(errorMessage, "prompt is too long") {
+				isPromptTooLongError = true
+				// 对于prompt过长错误，只输出简单的错误信息
+				log.Printf("[Anthropic] 400错误: %s - %s", errResp.Error.Type, errResp.Error.Message)
+			}
+			// 检查是否是thinking格式错误
+			if strings.Contains(errResp.Error.Message, "When `thinking` is enabled") ||
+				strings.Contains(errResp.Error.Message, "Expected `thinking` or `redacted_thinking`") {
+				isThinkingFormatError = true
+				// 输出详细的thinking格式错误信息
+				log.Printf("[Anthropic] thinking格式错误详情: %s", errResp.Error.Message)
+				log.Printf("[Anthropic] 发送给zencoder的请求体:")
+				log.Printf("%s", sanitizeRequestBody(body))
+			}
+			// 检查是否是thinking signature过期错误
+			if strings.Contains(errResp.Error.Message, "Invalid `signature` in `thinking` block") {
+				isThinkingSignatureError = true
+				// 对于thinking signature过期错误，只输出简单信息，详细处理留给doRequest
+			}
+		}
+
+		// 只在非调试模式且非已知可重试错误时才输出详细debug信息
+		// thinking相关错误会在doRequest中处理，如果重试成功就不需要输出debug日志
+		shouldOutputDetails := !isPromptTooLongError && !isThinkingFormatError && !isThinkingSignatureError
+		if shouldOutputDetails {
+			log.Printf("[Anthropic] API返回400错误: %s", string(errBody))
+			// 只在调试模式下输出详细的请求信息
+			if IsDebugMode() {
+				logRequestDetails("[Anthropic] 实际API", httpReq.Header, body)
+			}
+		} else if isThinkingSignatureError && IsDebugMode() {
+			// thinking signature错误只在调试模式下输出简单信息
+			log.Printf("[Anthropic] API返回400错误: %s", string(errBody))
+			logRequestDetails("[Anthropic] 实际API", httpReq.Header, body)
+		}
+
+		// 重新构建响应，因为body已经被读取
+		resp.Body = io.NopCloser(bytes.NewReader(errBody))
+	}
+
+	return resp, nil
+}
+
+// isThinkingFormatError 检查是否是thinking格式相关的错误
+func (s *AnthropicService) isThinkingFormatError(errorBody string) bool {
+	return strings.Contains(errorBody, "When `thinking` is enabled, a final `assistant` message must start with a thinking block") ||
+		strings.Contains(errorBody, "Expected `thinking` or `redacted_thinking`") ||
+		strings.Contains(errorBody, "To avoid this requirement, disable `thinking`")
+}
+
+// isThinkingSignatureError 检查是否是thinking signature过期错误
+func (s *AnthropicService) isThinkingSignatureError(errorBody string) bool {
+	return strings.Contains(errorBody, "Invalid `signature` in `thinking` block") ||
+		strings.Contains(errorBody, "invalid_request_error") && strings.Contains(errorBody, "signature")
+}
+
+// isTemperatureError 检查是否是温度参数相关的错误
+func (s *AnthropicService) isTemperatureError(errorBody string) bool {
+	return strings.Contains(errorBody, "requires temperature=1.0") ||
+		strings.Contains(errorBody, "Parallel Thinking' requires temperature")
+}
+
+// isParameterConflictError 检查是否是参数冲突错误
+func (s *AnthropicService) isParameterConflictError(errorBody string) bool {
+	return strings.Contains(errorBody, "`temperature` and `top_p` cannot both be specified")
+}
+
+// isClaudeOfficial429Error 检查是否是Claude官方的429限流错误
+func (s *AnthropicService) isClaudeOfficial429Error(errorBody string) bool {
+	// 尝试解析错误响应
+	var errResp struct {
+		Type  string `json:"type"`
+		Error struct {
+			Type    string `json:"type"`
+			Message string `json:"message"`
+		} `json:"error"`
+		RequestID string `json:"request_id"`
+	}
+
+	// 如果能解析成功且符合Claude官方格式
+	if err := json.Unmarshal([]byte(errorBody), &errResp); err == nil {
+		// Claude官方错误特征：
+		// 1. type = "error"
+		// 2. error.type = "rate_limit_error"
+		// 3. 错误消息包含anthropic.com或claude.com域名
+		if errResp.Type == "error" &&
+			errResp.Error.Type == "rate_limit_error" &&
+			(strings.Contains(errResp.Error.Message, "anthropic.com") ||
+				strings.Contains(errResp.Error.Message, "claude.com") ||
+				strings.Contains(errResp.Error.Message, "docs.claude.com")) {
+			return true
+		}
+	}
+
+	// 检查是否是非Claude官方的错误格式（如Google API格式）
+	var nonClaudeErr struct {
+		Error struct {
+			Code    int    `json:"code"`
+			Message string `json:"message"`
+			Status  string `json:"status"`
+		} `json:"error"`
+	}
+
+	if err := json.Unmarshal([]byte(errorBody), &nonClaudeErr); err == nil {
+		// 非Claude官方错误特征：有code和status字段
+		if nonClaudeErr.Error.Code == 429 &&
+			nonClaudeErr.Error.Status == "RESOURCE_EXHAUSTED" {
+			return false
+		}
+	}
+
+	// 默认情况下，如果无法确定，保守处理：不返回原始响应
+	return false
+}
+
+// classifyAndLog429Error 分类并记录429错误的简化日志
+func (s *AnthropicService) classifyAndLog429Error(errorBody string, accountID uint, email string) {
+	// 尝试解析Claude官方错误
+	var claudeErr struct {
+		Type  string `json:"type"`
+		Error struct {
+			Type    string `json:"type"`
+			Message string `json:"message"`
+		} `json:"error"`
+	}
+
+	if err := json.Unmarshal([]byte(errorBody), &claudeErr); err == nil {
+		if claudeErr.Type == "error" && claudeErr.Error.Type == "rate_limit_error" {
+			// Claude官方限流错误
+			log.Printf("[Anthropic] Claude rate_limit_error 账号ID:%d %s", accountID, email)
+			return
+		}
+	}
+
+	// 尝试解析GCP错误
+	var gcpErr struct {
+		Error struct {
+			Code    int    `json:"code"`
+			Message string `json:"message"`
+			Status  string `json:"status"`
+		} `json:"error"`
+	}
+
+	if err := json.Unmarshal([]byte(errorBody), &gcpErr); err == nil {
+		if gcpErr.Error.Code == 429 && gcpErr.Error.Status == "RESOURCE_EXHAUSTED" {
+			// GCP限流错误
+			log.Printf("[Anthropic] GCP RESOURCE_EXHAUSTED 账号ID:%d %s", accountID, email)
+			return
+		}
+	}
+
+	// 其他未识别的429错误
+	log.Printf("[Anthropic] 429限流错误 账号ID:%d %s", accountID, email)
+}
+
+// MessagesProxy 直接代理请求和响应
+func (s *AnthropicService) MessagesProxy(ctx context.Context, w http.ResponseWriter, body []byte) error {
+	var req struct {
+		Model  string `json:"model"`
+		Stream bool   `json:"stream"`
+	}
+	// 忽略错误，Messages方法会再次解析
+	_ = json.Unmarshal(body, &req)
+
+	resp, err := s.Messages(ctx, body, false)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	// 判断是否需要过滤thinking内容
+	// 规则：如果用户调用的是非thinking版本，但平台强制开启了thinking，则需要过滤
+	needsFiltering := false
+
+	// 获取模型配置
+	zenModel, exists := model.GetZenModel(req.Model)
+
+	// 如果模型配置中有thinking参数（平台强制thinking）
+	if exists && zenModel.Parameters != nil && zenModel.Parameters.Thinking != nil {
+		// 检查用户是否明确请求了thinking版本
+		// 如果模型ID不包含 "thinking" 后缀，说明用户要的是非thinking版本
+		if !strings.HasSuffix(req.Model, "-thinking") {
+			needsFiltering = true
+		}
+	}
+
+	if needsFiltering {
+		if req.Stream {
+			return s.streamFilteredResponse(w, resp)
+		}
+		return s.handleNonStreamFilteredResponse(w, resp)
+	}
+
+	return StreamResponse(w, resp)
+}
+
+func (s *AnthropicService) handleNonStreamFilteredResponse(w http.ResponseWriter, resp *http.Response) error {
+	// 读取全部响应体
+	bodyBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
+	// 复制响应头
+	for k, v := range resp.Header {
+		// 过滤掉 Content-Length 和 Content-Encoding
+		if k != "Content-Length" && k != "Content-Encoding" {
+			for _, vv := range v {
+				w.Header().Add(k, vv)
+			}
+		}
+	}
+	w.WriteHeader(resp.StatusCode)
+
+	// 尝试解析响应
+	var raw map[string]interface{}
+	if err := json.Unmarshal(bodyBytes, &raw); err != nil {
+		w.Write(bodyBytes)
+		return nil
+	}
+
+	// 过滤 content 中的 thinking block
+	if content, ok := raw["content"].([]interface{}); ok {
+		var newContent []interface{}
+		for _, block := range content {
+			if b, ok := block.(map[string]interface{}); ok {
+				if typeStr, ok := b["type"].(string); ok && (typeStr == "thinking" || typeStr == "thought") {
+					continue
+				}
+			}
+			newContent = append(newContent, block)
+		}
+		raw["content"] = newContent
+	}
+
+	return json.NewEncoder(w).Encode(raw)
+}
+
+// adjustTemperatureForModel 根据模型要求调整温度参数
+func (s *AnthropicService) adjustTemperatureForModel(body []byte, modelID string) ([]byte, error) {
+	// 获取模型配置
+	zenModel, exists := model.GetZenModel(modelID)
+
+	// 检查模型配置中是否有特定的温度要求
+	if exists && zenModel.Parameters != nil && zenModel.Parameters.Temperature != nil {
+		return s.forceTemperature(body, *zenModel.Parameters.Temperature)
+	}
+
+	return body, nil
+}
+
+// forceTemperature 强制设置温度参数
+func (s *AnthropicService) forceTemperature(body []byte, temperature float64) ([]byte, error) {
+	// 解析请求体
+	var reqMap map[string]interface{}
+	if err := json.Unmarshal(body, &reqMap); err != nil {
+		return body, nil // 如果解析失败，返回原始body
+	}
+
+	// 强制设置 temperature
+	reqMap["temperature"] = temperature
+
+	// 如果同时存在 top_p，移除它（某些模型不允许同时指定）
+	delete(reqMap, "top_p")
+
+	// 重新序列化
+	return json.Marshal(reqMap)
+}
+
+// removeTopP 移除 top_p 参数，避免与 temperature 冲突
+func (s *AnthropicService) removeTopP(body []byte) ([]byte, error) {
+	// 解析请求体
+	var reqMap map[string]interface{}
+	if err := json.Unmarshal(body, &reqMap); err != nil {
+		return body, nil // 如果解析失败，返回原始body
+	}
+
+	// 移除 top_p 参数
+	delete(reqMap, "top_p")
+
+	// 重新序列化
+	return json.Marshal(reqMap)
+}
+
+// hasMatchingToolResult 检查消息中是否包含指定tool_use_id的tool_result
+func hasMatchingToolResult(msg map[string]interface{}, toolUseID interface{}) bool {
+	if msg == nil || toolUseID == nil {
+		return false
+	}
+
+	toolUseIDStr, ok := toolUseID.(string)
+	if !ok {
+		return false
+	}
+
+	content, ok := msg["content"].([]interface{})
+	if !ok {
+		return false
+	}
+
+	for _, block := range content {
+		if b, ok := block.(map[string]interface{}); ok {
+			if b["type"] == "tool_result" {
+				if id, ok := b["tool_use_id"].(string); ok && id == toolUseIDStr {
+					return true
+				}
+			}
+		}
+	}
+
+	return false
+}
+
+// ensureThinkingConfig 确保需要 thinking 的模型有正确的配置
+func (s *AnthropicService) ensureThinkingConfig(body []byte, modelID string) ([]byte, error) {
+	// 获取模型配置
+	zenModel, exists := model.GetZenModel(modelID)
+
+	// 检查模型配置中是否包含thinking参数
+	needsThinking := false
+	var modelBudgetTokens int
+	if exists && zenModel.Parameters != nil && zenModel.Parameters.Thinking != nil {
+		needsThinking = true
+		modelBudgetTokens = zenModel.Parameters.Thinking.BudgetTokens
+		if modelBudgetTokens == 0 {
+			modelBudgetTokens = 4096 // 默认值
+		}
+	}
+
+	if !needsThinking {
+		return body, nil
+	}
+
+	// 解析请求体
+	var reqMap map[string]interface{}
+	if err := json.Unmarshal(body, &reqMap); err != nil {
+		return body, nil
+	}
+
+	// 检查用户是否明确不想要thinking模式
+	userDisablesThinking := false
+	if existingThinking, ok := reqMap["thinking"].(map[string]interface{}); ok {
+		if thinkingType, ok := existingThinking["type"].(string); ok && thinkingType == "disabled" {
+			userDisablesThinking = true
+		}
+		if enabled, ok := existingThinking["enabled"].(bool); ok && !enabled {
+			userDisablesThinking = true
+		}
+	} else {
+		// 如果没有thinking配置，检查是否是非thinking版本的模型调用
+		// 例如 claude-haiku-4-5-20251001 而不是 claude-haiku-4-5-20251001-thinking
+		if !strings.HasSuffix(modelID, "-thinking") {
+			userDisablesThinking = true
+		}
+	}
+
+	// 如果用户不想要thinking但模型强制thinking，转换assistant消息为user消息
+	if userDisablesThinking {
+		if IsDebugMode() {
+			log.Printf("[Anthropic] 用户不想要thinking模式，但模型强制thinking，转换assistant消息为user消息")
+		}
+		if messages, ok := reqMap["messages"].([]interface{}); ok {
+			for i, msg := range messages {
+				if msgMap, ok := msg.(map[string]interface{}); ok {
+					if role, ok := msgMap["role"].(string); ok && role == "assistant" {
+						// 转换thinking内容为text并改变角色为user
+						if err := s.convertAssistantToUserMessage(msgMap); err != nil {
+							log.Printf("[Anthropic] 转换assistant消息为user消息失败: %v", err)
+						}
+					}
+					messages[i] = msgMap
+				}
+			}
+			reqMap["messages"] = messages
+		}
+	}
+
+	// 注意：即使有tool_choice，某些模型仍然需要thinking配置
+	// 因此不再因为tool_choice的存在而跳过thinking配置
+
+	// 检查请求体中是否已有thinking配置
+	if existingThinking, ok := reqMap["thinking"].(map[string]interface{}); ok {
+		// 如果已有thinking配置，确保budget_tokens与模型配置一致
+		if _, hasBudget := existingThinking["budget_tokens"]; hasBudget {
+			// 强制使用模型配置中的budget_tokens值
+			existingThinking["budget_tokens"] = modelBudgetTokens
+			if IsDebugMode() {
+				log.Printf("[Anthropic] 调整thinking.budget_tokens为模型配置值: %d", modelBudgetTokens)
+			}
+		} else {
+			// 如果没有budget_tokens，添加
+			existingThinking["budget_tokens"] = modelBudgetTokens
+		}
+		// 确保type字段正确
+		if _, hasType := existingThinking["type"]; !hasType {
+			existingThinking["type"] = "enabled"
+		} else {
+			// 强制启用thinking（因为模型要求）
+			existingThinking["type"] = "enabled"
+		}
+		reqMap["thinking"] = existingThinking
+	} else {
+		// 添加 thinking 配置 - 使用模型配置中的值
+		reqMap["thinking"] = map[string]interface{}{
+			"type":          "enabled",
+			"budget_tokens": modelBudgetTokens,
+		}
+		if IsDebugMode() {
+			log.Printf("[Anthropic] 添加thinking配置，budget_tokens: %d", modelBudgetTokens)
+		}
+		if IsDebugMode() {
+			log.Printf("[Anthropic] 原始请求体 (处理前):")
+			log.Printf("%s", sanitizeRequestBody(body))
+		}
+	}
+
+	// 当启用 thinking 时，必须设置 temperature = 1.0
+	reqMap["temperature"] = 1.0
+	// 移除 top_p 以避免冲突
+	delete(reqMap, "top_p")
+
+	// 注意：不再尝试为assistant消息添加thinking块，因为signature信息无法正确生成
+	// 如果模型要求thinking模式但用户消息不符合格式，让API返回错误由上层处理
+
+	// 重新序列化
+	modifiedBody, err := json.Marshal(reqMap)
+	if err != nil {
+		return body, err
+	}
+
+	// 输出处理后的请求体日志
+	if IsDebugMode() {
+		log.Printf("[Anthropic] 处理后的请求体 (发送给实际API):")
+		log.Printf("%s", sanitizeRequestBody(modifiedBody))
+	}
+
+	return modifiedBody, nil
+}
+
+// 已移除fixAssistantMessageForThinking函数，因为signature信息无法正确生成
+
+// convertThinkingToText 将thinking内容转换为普通文本格式（当用户不想要thinking模式时）
+func (s *AnthropicService) convertThinkingToText(msgMap map[string]interface{}) error {
+	content, ok := msgMap["content"]
+	if !ok {
+		return nil
+	}
+
+	switch c := content.(type) {
+	case []interface{}:
+		var newContent []interface{}
+		for _, block := range c {
+			if blockMap, ok := block.(map[string]interface{}); ok {
+				blockType, _ := blockMap["type"].(string)
+				if blockType == "thinking" || blockType == "redacted_thinking" {
+					// 将thinking块转换为text块
+					if thinkingText, ok := blockMap["thinking"].(string); ok {
+						newContent = append(newContent, map[string]interface{}{
+							"type": "text",
+							"text": "[thinking] " + thinkingText,
+						})
+					}
+				} else {
+					// 保留其他类型的块
+					newContent = append(newContent, block)
+				}
+			}
+		}
+		msgMap["content"] = newContent
+		if IsDebugMode() {
+			log.Printf("[Anthropic] 将thinking块转换为普通文本格式")
+		}
+	}
+
+	return nil
+}
+
+// convertAssistantToUserMessage 将assistant消息转换为user消息，避免thinking格式要求
+// 使用range循环逐个处理块，保留缓存信息，不合并消息
+func (s *AnthropicService) convertAssistantToUserMessage(msgMap map[string]interface{}) error {
+	content, ok := msgMap["content"]
+	if !ok {
+		return nil
+	}
+
+	// 将角色从assistant改为user
+	msgMap["role"] = "user"
+
+	switch c := content.(type) {
+	case string:
+		// 如果是字符串content，保持不变，只改角色
+		if IsDebugMode() {
+			log.Printf("[Anthropic] 将assistant字符串消息转换为user消息")
+		}
+	case []interface{}:
+		// 使用range循环逐个处理每个块，保留结构和缓存信息
+		for i, block := range c {
+			if blockMap, ok := block.(map[string]interface{}); ok {
+				blockType, _ := blockMap["type"].(string)
+
+				// 保留原有的缓存控制信息
+				var cacheControl interface{}
+				if cache, hasCacheControl := blockMap["cache_control"]; hasCacheControl {
+					cacheControl = cache
+				}
+
+				switch blockType {
+				case "thinking", "redacted_thinking":
+					// 将thinking块转换为text块，保留缓存信息
+					if thinkingText, ok := blockMap["thinking"].(string); ok {
+						newBlock := map[string]interface{}{
+							"type": "text",
+							"text": "[thinking] " + thinkingText,
+						}
+						if cacheControl != nil {
+							newBlock["cache_control"] = cacheControl
+						}
+						c[i] = newBlock
+					}
+				case "tool_use":
+					// 将tool_use块转换为text描述，保留缓存信息
+					toolName, _ := blockMap["name"].(string)
+					toolId, _ := blockMap["id"].(string)
+					newBlock := map[string]interface{}{
+						"type": "text",
+						"text": fmt.Sprintf("[tool_use] %s (ID: %s)", toolName, toolId),
+					}
+					if cacheControl != nil {
+						newBlock["cache_control"] = cacheControl
+					}
+					c[i] = newBlock
+				case "tool_result":
+					// 将tool_result块转换为text描述，保留缓存信息
+					toolUseId, _ := blockMap["tool_use_id"].(string)
+					isError, _ := blockMap["is_error"].(bool)
+					var resultText string
+					if isError {
+						resultText = fmt.Sprintf("[tool_error] (ID: %s)", toolUseId)
+					} else {
+						resultText = fmt.Sprintf("[tool_result] (ID: %s)", toolUseId)
+					}
+					newBlock := map[string]interface{}{
+						"type": "text",
+						"text": resultText,
+					}
+					if cacheControl != nil {
+						newBlock["cache_control"] = cacheControl
+					}
+					c[i] = newBlock
+				default:
+					// text块和其他类型的块保持不变，包括缓存信息
+					// 不需要修改，保持原样
+				}
+			}
+			// 非map类型的块也保持不变
+		}
+
+		msgMap["content"] = c
+		if IsDebugMode() {
+			log.Printf("[Anthropic] 将assistant消息转换为user消息，逐个处理内容块并保留缓存信息")
+		}
+	}
+
+	return nil
+}
+
+// convertAssistantMessagesToUser 将请求体中的所有assistant消息转换为user消息
+func (s *AnthropicService) convertAssistantMessagesToUser(body []byte) ([]byte, error) {
+	// 解析请求体
+	var reqMap map[string]interface{}
+	if err := json.Unmarshal(body, &reqMap); err != nil {
+		return body, err
+	}
+
+	// 处理messages数组，同时处理工具调用关系
+	if messages, ok := reqMap["messages"].([]interface{}); ok {
+		for i, msg := range messages {
+			if msgMap, ok := msg.(map[string]interface{}); ok {
+				// 无论是assistant还是user消息，都要检查并转换工具相关块
+				if role, ok := msgMap["role"].(string); ok {
+					if role == "assistant" {
+						// 转换assistant消息为user消息
+						if err := s.convertAssistantToUserMessage(msgMap); err != nil {
+							log.Printf("[Anthropic] 转换第%d个assistant消息失败: %v", i, err)
+							continue
+						}
+					} else if role == "user" {
+						// 对于user消息，也要确保tool_result被正确处理
+						if err := s.convertToolBlocksToText(msgMap); err != nil {
+							log.Printf("[Anthropic] 转换第%d个user消息中的工具块失败: %v", i, err)
+							continue
+						}
+					}
+					messages[i] = msgMap
+				}
+			}
+		}
+		reqMap["messages"] = messages
+	}
+
+	// 重新序列化
+	modifiedBody, err := json.Marshal(reqMap)
+	if err != nil {
+		return body, err
+	}
+
+	if IsDebugMode() {
+		log.Printf("[Anthropic] 已转换所有工具调用消息，处理后的请求体:")
+		log.Printf("%s", sanitizeRequestBody(modifiedBody))
+	}
+
+	return modifiedBody, nil
+}
+
+// convertToolBlocksToText 将消息中的所有工具相关块转换为文本
+func (s *AnthropicService) convertToolBlocksToText(msgMap map[string]interface{}) error {
+	content, ok := msgMap["content"]
+	if !ok {
+		return nil
+	}
+
+	switch c := content.(type) {
+	case []interface{}:
+		// 使用range循环逐个处理每个块，将工具相关块转换为文本
+		for i, block := range c {
+			if blockMap, ok := block.(map[string]interface{}); ok {
+				blockType, _ := blockMap["type"].(string)
+
+				// 保留原有的缓存控制信息
+				var cacheControl interface{}
+				if cache, hasCacheControl := blockMap["cache_control"]; hasCacheControl {
+					cacheControl = cache
+				}
+
+				switch blockType {
+				case "tool_use":
+					// 将tool_use块转换为text块
+					toolName, _ := blockMap["name"].(string)
+					toolId, _ := blockMap["id"].(string)
+					newBlock := map[string]interface{}{
+						"type": "text",
+						"text": fmt.Sprintf("[tool_use] %s (ID: %s)", toolName, toolId),
+					}
+					if cacheControl != nil {
+						newBlock["cache_control"] = cacheControl
+					}
+					c[i] = newBlock
+				case "tool_result":
+					// 将tool_result块转换为text块
+					toolUseId, _ := blockMap["tool_use_id"].(string)
+					isError, _ := blockMap["is_error"].(bool)
+					var resultText string
+					if isError {
+						resultText = fmt.Sprintf("[tool_error] (ID: %s)", toolUseId)
+					} else {
+						resultText = fmt.Sprintf("[tool_result] (ID: %s)", toolUseId)
+					}
+					newBlock := map[string]interface{}{
+						"type": "text",
+						"text": resultText,
+					}
+					if cacheControl != nil {
+						newBlock["cache_control"] = cacheControl
+					}
+					c[i] = newBlock
+				default:
+					// text块和其他类型的块保持不变
+					// 不需要修改，保持原样
+				}
+			}
+		}
+
+		msgMap["content"] = c
+		if IsDebugMode() {
+			log.Printf("[Anthropic] 已将消息中的工具块转换为文本格式")
+		}
+	}
+
+	return nil
+}
+
+// adjustParametersForModel 根据模型要求调整参数，避免冲突
+func (s *AnthropicService) adjustParametersForModel(body []byte, modelID string) ([]byte, error) {
+	// 对于 claude-opus-4-5-20251101 等模型，不能同时有 temperature 和 top_p
+	modelsNoTopP := []string{
+		"claude-opus-4-5-20251101",
+		"claude-opus-4-1-20250805",
+	}
+
+	for _, model := range modelsNoTopP {
+		if modelID == model {
+			body, _ = s.removeTopP(body)
+			break
+		}
+	}
+
+	// 继续处理温度参数
+	return s.adjustTemperatureForModel(body, modelID)
+}
+
+func (s *AnthropicService) streamFilteredResponse(w http.ResponseWriter, resp *http.Response) error {
+	// 复制响应头
+	for k, v := range resp.Header {
+		if k != "Content-Encoding" && k != "Content-Length" {
+			for _, vv := range v {
+				w.Header().Add(k, vv)
+			}
+		}
+	}
+	w.WriteHeader(resp.StatusCode)
+
+	flusher, ok := w.(http.Flusher)
+	if !ok {
+		_, err := io.Copy(w, resp.Body)
+		return err
+	}
+
+	reader := bufio.NewReader(resp.Body)
+	isThinking := false // 标记当前是否处于 thinking block 中
+
+	for {
+		line, err := reader.ReadString('\n')
+		if err != nil {
+			if err == io.EOF {
+				return nil
+			}
+			return err
+		}
+
+		trimmedLine := strings.TrimSpace(line)
+		if trimmedLine == "" {
+			fmt.Fprintf(w, "\n")
+			flusher.Flush()
+			continue
+		}
+
+		if strings.HasPrefix(trimmedLine, "event:") {
+			// 读取下一行 data
+			dataLine, err := reader.ReadString('\n')
+			if err != nil {
+				return err
+			}
+
+			// 解析 event 类型
+			event := strings.TrimSpace(strings.TrimPrefix(trimmedLine, "event:"))
+			data := strings.TrimSpace(strings.TrimPrefix(dataLine, "data:"))
+
+			var shouldFilter bool
+
+			if event == "content_block_start" {
+				var payload struct {
+					ContentBlock struct {
+						Type string `json:"type"`
+					} `json:"content_block"`
+				}
+				if json.Unmarshal([]byte(data), &payload) == nil {
+					if payload.ContentBlock.Type == "thinking" || payload.ContentBlock.Type == "thought" {
+						isThinking = true
+						shouldFilter = true
+					}
+
+				}
+			} else if event == "content_block_delta" {
+				if isThinking {
+					shouldFilter = true
+				}
+			} else if event == "content_block_stop" {
+				if isThinking {
+					shouldFilter = true
+					isThinking = false
+				}
+			}
+
+			if !shouldFilter {
+				fmt.Fprint(w, line)     // event: ...
+				fmt.Fprint(w, dataLine) // data: ...
+				flusher.Flush()
+			}
+		} else {
+			// 其他格式（如 ping），直接透传
+			fmt.Fprint(w, line)
+			flusher.Flush()
+		}
+	}
+}
+
+// retryWithProxy 使用代理池重试请求
+func (s *AnthropicService) retryWithProxy(ctx context.Context, account *model.Account, modelID string, body []byte) (*http.Response, error) {
+	// 获取模型配置
+	zenModel, exists := model.GetZenModel(modelID)
+	if !exists {
+		return nil, fmt.Errorf("模型配置不存在: %s", modelID)
+	}
+
+	// 预处理请求体 - 确保包含所需的thinking配置和参数调整
+	processedBody, err := s.preprocessRequestBody(body, modelID, zenModel)
+	if err != nil {
+		log.Printf("[Anthropic] 代理重试请求体预处理失败: %v", err)
+		// 如果预处理失败，使用原始body
+		processedBody = body
+	}
+
+	proxyPool := provider.GetProxyPool()
+	if !proxyPool.HasProxies() {
+		return nil, fmt.Errorf("没有可用的代理")
+	}
+
+	maxRetries := 3
+	for i := 0; i < maxRetries; i++ {
+		// 获取随机代理
+		proxyURL := proxyPool.GetRandomProxy()
+		if proxyURL == "" {
+			continue
+		}
+
+		log.Printf("[Anthropic] 尝试代理 %s (重试 %d/%d)", proxyURL, i+1, maxRetries)
+
+		// 创建使用代理的HTTP客户端
+		proxyClient, err := provider.NewHTTPClientWithProxy(proxyURL, 0)
+		if err != nil {
+			log.Printf("[Anthropic] 创建代理客户端失败: %v", err)
+			continue
+		}
+
+		// 创建新请求
+		httpReq, err := http.NewRequest("POST", AnthropicBaseURL+"/v1/messages", bytes.NewReader(processedBody))
+		if err != nil {
+			log.Printf("[Anthropic] 创建请求失败: %v", err)
+			continue
+		}
+
+		// 设置请求头
+		SetZencoderHeaders(httpReq, account, zenModel)
+		httpReq.Header.Set("anthropic-version", "2023-06-01")
+
+		// 添加模型配置的额外请求头
+		if zenModel.Parameters != nil && zenModel.Parameters.ExtraHeaders != nil {
+			for k, v := range zenModel.Parameters.ExtraHeaders {
+				httpReq.Header.Set(k, v)
+			}
+		}
+
+		// 只在非限速测试且调试模式下记录代理请求详情
+		var reqCheck struct {
+			Model string `json:"model"`
+		}
+		if IsDebugMode() && json.Unmarshal(body, &reqCheck) == nil && !strings.Contains(reqCheck.Model, "test") {
+			log.Printf("[Anthropic] 代理请求详情 - URL: %s", httpReq.URL.String())
+			logRequestDetails("[Anthropic] 代理请求", httpReq.Header, processedBody)
+		}
+
+		// 执行请求
+		resp, err := proxyClient.Do(httpReq)
+		if err != nil {
+			log.Printf("[Anthropic] 代理请求失败: %v", err)
+			continue
+		}
+
+		// 检查响应状态
+		if resp.StatusCode == 429 {
+			// 仍然是429，尝试下一个代理
+			resp.Body.Close()
+			log.Printf("[Anthropic] 代理 %s 仍返回429，尝试下一个", proxyURL)
+			continue
+		}
+
+		if resp.StatusCode >= 400 {
+			// 其他错误，记录并尝试下一个代理
+			errBody, _ := io.ReadAll(resp.Body)
+			resp.Body.Close()
+
+			// 解析thinking状态
+			thinkingStatus := "disabled"
+			var reqCheck struct {
+				Thinking map[string]interface{} `json:"thinking,omitempty"`
+			}
+			json.Unmarshal(body, &reqCheck)
+			if reqCheck.Thinking != nil {
+				if enabled, ok := reqCheck.Thinking["enabled"].(bool); ok && enabled {
+					thinkingStatus = "enabled"
+				} else if thinkingType, ok := reqCheck.Thinking["type"].(string); ok && thinkingType == "enabled" {
+					thinkingStatus = "enabled"
+				}
+				// 如果有thinking配置且有budget_tokens，也记录
+				if budget, ok := reqCheck.Thinking["budget_tokens"].(float64); ok && budget > 0 {
+					thinkingStatus = fmt.Sprintf("enabled(budget=%g)", budget)
+				}
+			}
+
+			log.Printf("[Anthropic] 代理 %s 返回错误 %d: %s (Model: %s, Thinking: %s)", proxyURL, resp.StatusCode, string(errBody), modelID, thinkingStatus)
+			continue
+		}
+
+		// 成功
+		log.Printf("[Anthropic] 代理 %s 请求成功", proxyURL)
+		return resp, nil
+	}
+
+	return nil, fmt.Errorf("所有代理重试均失败")
+}
+
+// preprocessRequestBody 预处理请求体，应用所有必要的配置和调整
+func (s *AnthropicService) preprocessRequestBody(body []byte, modelID string, zenModel model.ZenModel) ([]byte, error) {
+	// 注意：已移除模型替换逻辑，直接使用原始请求体
+	modifiedBody := body
+
+	// 2. 确保thinking配置
+	var err error
+	modifiedBody, err = s.ensureThinkingConfig(modifiedBody, modelID)
+	if err != nil {
+		return modifiedBody, fmt.Errorf("确保thinking配置失败: %w", err)
+	}
+
+	// 3. 根据模型调整参数
+	modifiedBody, err = s.adjustParametersForModel(modifiedBody, modelID)
+	if err != nil {
+		return modifiedBody, fmt.Errorf("调整模型参数失败: %w", err)
+	}
+
+	return modifiedBody, nil
+}

internal/service/api.go

@@ -0,0 +1,143 @@
+package service
+
+import (
+	"fmt"
+	"net/http"
+
+	"zencoder-2api/internal/model"
+	"zencoder-2api/internal/service/provider"
+)
+
+type APIService struct {
+	manager *provider.Manager
+}
+
+func NewAPIService() *APIService {
+	return &APIService{
+		manager: provider.GetManager(),
+	}
+}
+
+func (s *APIService) Chat(req *model.ChatCompletionRequest) (*model.ChatCompletionResponse, error) {
+	// 检查模型是否存在于模型字典中
+	_, exists := model.GetZenModel(req.Model)
+	if !exists {
+		return nil, ErrNoAvailableAccount
+	}
+
+	var lastErr error
+
+	for i := 0; i < MaxRetries; i++ {
+		account, err := GetNextAccountForModel(req.Model)
+		if err != nil {
+			return nil, err
+		}
+
+		resp, err := s.doChat(account, req)
+		if err != nil {
+			MarkAccountError(account)
+			lastErr = err
+			continue
+		}
+
+		ResetAccountError(account)
+		zenModel, exists := model.GetZenModel(req.Model)
+		if !exists {
+			// 模型不存在，使用默认倍率
+			UseCredit(account, 1.0)
+		} else {
+			// API服务没有HTTP响应，只能使用模型倍率
+			UseCredit(account, zenModel.Multiplier)
+		}
+		
+		return resp, nil
+	}
+
+	return nil, fmt.Errorf("all retries failed: %w", lastErr)
+}
+
+func (s *APIService) doChat(account *model.Account, req *model.ChatCompletionRequest) (*model.ChatCompletionResponse, error) {
+	zenModel, exists := model.GetZenModel(req.Model)
+	if !exists {
+		return nil, ErrNoAvailableAccount
+	}
+
+	cfg := s.buildConfig(account, zenModel)
+	p, err := s.manager.GetProvider(account.ID, zenModel, cfg)
+	if err != nil {
+		return nil, err
+	}
+
+	// 注意：已移除模型重定向逻辑，直接使用用户请求的模型名
+
+	return p.Chat(req)
+}
+
+func (s *APIService) buildConfig(account *model.Account, zenModel model.ZenModel) provider.Config {
+	cfg := provider.Config{
+		APIKey: account.AccessToken,
+		Proxy:  account.Proxy,
+	}
+
+	// 设置额外请求头
+	if zenModel.Parameters != nil && zenModel.Parameters.ExtraHeaders != nil {
+		cfg.ExtraHeaders = zenModel.Parameters.ExtraHeaders
+	}
+
+	return cfg
+}
+
+func (s *APIService) ChatStream(req *model.ChatCompletionRequest, writer http.ResponseWriter) error {
+	// 检查模型是否存在于模型字典中
+	_, exists := model.GetZenModel(req.Model)
+	if !exists {
+		return ErrNoAvailableAccount
+	}
+
+	var lastErr error
+
+	for i := 0; i < MaxRetries; i++ {
+		account, err := GetNextAccountForModel(req.Model)
+		if err != nil {
+			return err
+		}
+
+		err = s.doChatStream(account, req, writer)
+		if err != nil {
+			MarkAccountError(account)
+			lastErr = err
+			continue
+		}
+
+		ResetAccountError(account)
+		zenModel, exists := model.GetZenModel(req.Model)
+		if !exists {
+			// 模型不存在，使用默认倍率
+			UseCredit(account, 1.0)
+		} else {
+			// 流式响应，使用模型倍率
+			UseCredit(account, zenModel.Multiplier)
+		}
+		
+		return nil
+	}
+
+	return fmt.Errorf("all retries failed: %w", lastErr)
+}
+
+func (s *APIService) doChatStream(account *model.Account, req *model.ChatCompletionRequest, writer http.ResponseWriter) error {
+	zenModel, exists := model.GetZenModel(req.Model)
+	if !exists {
+		return ErrNoAvailableAccount
+	}
+
+	cfg := s.buildConfig(account, zenModel)
+	p, err := s.manager.GetProvider(account.ID, zenModel, cfg)
+	if err != nil {
+		return err
+	}
+
+	// 注意：已移除模型重定向逻辑，直接使用用户请求的模型名
+
+	return p.ChatStream(req, writer)
+}

internal/service/autogen.go

@@ -0,0 +1,453 @@
+package service
+
+import (
+	"errors"
+	"fmt"
+	"log"
+	"strings"
+	"sync"
+	"time"
+	"zencoder-2api/internal/database"
+	"zencoder-2api/internal/model"
+	
+	"gorm.io/gorm"
+)
+
+type AutoGenerationService struct {
+	mu              sync.Mutex
+	lastTriggered   map[uint]time.Time // tokenID -> last triggered time
+	isGenerating    map[uint]bool      // tokenID -> is generating
+	debounceTime    time.Duration      // 防抖时间
+	generationDelay time.Duration      // 生成任务间隔时间
+}
+
+var autoGenService *AutoGenerationService
+
+func InitAutoGenerationService() {
+	autoGenService = &AutoGenerationService{
+		lastTriggered:   make(map[uint]time.Time),
+		isGenerating:    make(map[uint]bool),
+		debounceTime:    5 * time.Minute,  // 5分钟防抖
+		generationDelay: 1 * time.Hour,    // 生成任务间隔1小时
+	}
+	
+	// 启动监控协程
+	go autoGenService.startMonitoring()
+}
+
+// SaveGenerationToken 保存生成模式使用的token
+func SaveGenerationToken(token string, description string) error {
+	db := database.GetDB()
+	
+	// 检查是否已存在
+	var existing model.TokenRecord
+	if err := db.Where("token = ?", token).First(&existing).Error; err == nil {
+		// 更新最后生成时间
+		existing.LastGeneratedAt = time.Now()
+		existing.GeneratedCount += 1
+		return db.Save(&existing).Error
+	}
+	
+	// 创建新记录
+	record := model.TokenRecord{
+		Token:           token,
+		Description:     description,
+		GeneratedCount:  1,
+		LastGeneratedAt: time.Now(),
+		AutoGenerate:    true,
+		Threshold:       10,
+		GenerateBatch:   30,
+		IsActive:        true,
+	}
+	
+	return db.Create(&record).Error
+}
+
+// SaveGenerationTokenWithRefresh 保存生成模式使用的 refresh_token
+func SaveGenerationTokenWithRefresh(refreshToken string, accessToken string, description string, expiresIn int) error {
+	db := database.GetDB()
+
+	// 计算过期时间
+	expiresAt := time.Now().Add(time.Duration(expiresIn) * time.Second)
+
+	// 解析JWT获取用户信息，特别是邮箱
+	var email, planType string
+	var subscriptionDate time.Time
+	
+	if accessToken != "" {
+		if payload, err := ParseJWT(accessToken); err == nil {
+			email = payload.Email
+			planType = payload.CustomClaims.Plan
+			if planType != "" {
+				planType = strings.ToUpper(planType[:1]) + planType[1:]
+			}
+			subscriptionDate = GetSubscriptionDate(payload)
+			log.Printf("[SaveGenerationToken] 解析JWT成功: Email=%s, Plan=%s, SubStart=%s",
+				email, planType, subscriptionDate.Format("2006-01-02"))
+		} else {
+			log.Printf("[SaveGenerationToken] 解析JWT失败: %v", err)
+		}
+	}
+
+	// 如果有邮箱，按邮箱查找；否则按refresh_token查找
+	var existing model.TokenRecord
+	var err error
+	
+	if email != "" {
+		// 优先按邮箱查找，实现相同邮箱的记录合并
+		err = db.Where("email = ?", email).First(&existing).Error
+	} else {
+		// 没有邮箱时，按refresh_token查找
+		err = db.Where("refresh_token = ?", refreshToken).First(&existing).Error
+	}
+
+	if err == nil {
+		// 更新现有记录
+		updates := map[string]interface{}{
+			"token":                   accessToken,
+			"refresh_token":          refreshToken,
+			"token_expiry":           expiresAt,
+			"description":            description,
+			"updated_at":             time.Now(),
+			"plan_type":              planType,
+			"subscription_start_date": subscriptionDate,
+		}
+		
+		// 如果之前没有refresh_token，标记为有
+		if existing.RefreshToken == "" {
+			updates["has_refresh_token"] = true
+		}
+		
+		return db.Model(&existing).Updates(updates).Error
+	}
+
+	// 创建新记录
+	record := model.TokenRecord{
+		Token:                 accessToken,
+		RefreshToken:         refreshToken,
+		TokenExpiry:          expiresAt,
+		Description:          description,
+		Email:                email,
+		PlanType:             planType,
+		SubscriptionStartDate: subscriptionDate,
+		HasRefreshToken:      true,
+		CreatedAt:            time.Now(),
+		UpdatedAt:            time.Now(),
+		AutoGenerate:         true,
+		Threshold:            10,
+		GenerateBatch:        30,
+		IsActive:             true,
+		GeneratedCount:       0,
+		TotalSuccess:         0,
+		TotalFail:            0,
+	}
+
+	if err := db.Create(&record).Error; err != nil {
+		return fmt.Errorf("failed to save generation token: %w", err)
+	}
+
+	return nil
+}
+
+// GetActiveTokenRecords 获取所有活跃的token记录
+func GetActiveTokenRecords() ([]model.TokenRecord, error) {
+	var records []model.TokenRecord
+	err := database.GetDB().Where("is_active = ?", true).Find(&records).Error
+	return records, err
+}
+
+// GetAllTokenRecords 获取所有token记录
+func GetAllTokenRecords() ([]model.TokenRecord, error) {
+	var records []model.TokenRecord
+	err := database.GetDB().Order("created_at DESC").Find(&records).Error
+	return records, err
+}
+
+// GetGenerationTasks 获取生成任务历史
+func GetGenerationTasks(tokenRecordID uint) ([]model.GenerationTask, error) {
+	var tasks []model.GenerationTask
+	query := database.GetDB().Order("created_at DESC")
+	if tokenRecordID > 0 {
+		query = query.Where("token_record_id = ?", tokenRecordID)
+	}
+	err := query.Find(&tasks).Error
+	return tasks, err
+}
+
+// UpdateTokenRecord 更新token记录设置
+func UpdateTokenRecord(id uint, updates map[string]interface{}) error {
+	return database.GetDB().Model(&model.TokenRecord{}).Where("id = ?", id).Updates(updates).Error
+}
+
+// 监控账号池并触发自动生成
+func (s *AutoGenerationService) startMonitoring() {
+	ticker := time.NewTicker(1 * time.Minute) // 每分钟检查一次
+	defer ticker.Stop()
+	
+	for range ticker.C {
+		s.checkAndTriggerGeneration()
+	}
+}
+
+// 检查并触发生成
+func (s *AutoGenerationService) checkAndTriggerGeneration() {
+	// 获取所有活跃的token记录
+	records, err := GetActiveTokenRecords()
+	if err != nil {
+		log.Printf("[AutoGen] 获取token记录失败: %v", err)
+		return
+	}
+	
+	// 计算当前可用账号数量
+	var activeAccountCount int64
+	database.GetDB().Model(&model.Account{}).
+		Where("status = ?", "normal").
+		Where("token_expiry > ?", time.Now()).
+		Count(&activeAccountCount)
+	
+	log.Printf("[AutoGen] 当前活跃账号数量: %d", activeAccountCount)
+	
+	// 检查每个token记录的阈值
+	for _, record := range records {
+		if !record.AutoGenerate || !record.IsActive {
+			continue
+		}
+		
+		// 检查是否达到阈值
+		if int(activeAccountCount) <= record.Threshold {
+			s.triggerGeneration(record)
+		}
+	}
+}
+
+// 触发生成任务（带防抖）
+func (s *AutoGenerationService) triggerGeneration(record model.TokenRecord) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	
+	// 检查是否正在生成
+	if s.isGenerating[record.ID] {
+		log.Printf("[AutoGen] Token %d 正在生成中，跳过", record.ID)
+		return
+	}
+	
+	// 检查防抖时间
+	if lastTime, ok := s.lastTriggered[record.ID]; ok {
+		if time.Since(lastTime) < s.debounceTime {
+			log.Printf("[AutoGen] Token %d 防抖中，距上次触发 %v", record.ID, time.Since(lastTime))
+			return
+		}
+	}
+	
+	// 检查生成间隔
+	if !record.LastGeneratedAt.IsZero() && time.Since(record.LastGeneratedAt) < s.generationDelay {
+		log.Printf("[AutoGen] Token %d 未达到生成间隔时间，距上次生成 %v", record.ID, time.Since(record.LastGeneratedAt))
+		return
+	}
+	
+	// 标记开始生成
+	s.isGenerating[record.ID] = true
+	s.lastTriggered[record.ID] = time.Now()
+	
+	// 异步执行生成任务
+	go s.executeGeneration(record)
+}
+
+// 执行生成任务
+func (s *AutoGenerationService) executeGeneration(record model.TokenRecord) {
+	defer func() {
+		s.mu.Lock()
+		s.isGenerating[record.ID] = false
+		s.mu.Unlock()
+	}()
+	
+	log.Printf("[AutoGen] 开始自动生成任务 - Token %d, 批次大小: %d", record.ID, record.GenerateBatch)
+	
+	// 检查token记录状态
+	if record.Status != "active" {
+		log.Printf("[AutoGen] Token记录 %d 状态异常 (%s)，跳过生成任务", record.ID, record.Status)
+		return
+	}
+	
+	// 检查token是否需要刷新
+	if record.RefreshToken != "" && time.Now().After(record.TokenExpiry.Add(-time.Hour)) {
+		log.Printf("[AutoGen] Token记录 %d 的token即将过期，尝试刷新", record.ID)
+		if err := UpdateTokenRecordToken(&record); err != nil {
+			log.Printf("[AutoGen] Token记录 %d 刷新失败，停止生成任务: %v", record.ID, err)
+			return
+		}
+	}
+	
+	// 创建生成任务记录
+	task := model.GenerationTask{
+		TokenRecordID: record.ID,
+		Token:         record.Token,
+		BatchSize:     record.GenerateBatch,
+		Status:        "running",
+		StartedAt:     time.Now(),
+	}
+	
+	if err := database.GetDB().Create(&task).Error; err != nil {
+		log.Printf("[AutoGen] 创建任务记录失败: %v", err)
+		return
+	}
+	
+	// 批量生成凭证
+	credentials, errs := BatchGenerateCredentials(record.Token, record.GenerateBatch)
+	
+	// 检查生成过程中是否有token失效的错误
+	for _, err := range errs {
+		if strings.Contains(err.Error(), "locked out") || strings.Contains(err.Error(), "User is locked out") {
+			log.Printf("[AutoGen] 检测到原始token被锁定，禁用token记录 %d: %v", record.ID, err)
+			// 将token记录标记为封禁状态
+			if markErr := markTokenRecordAsBanned(&record, "原始token被锁定: "+err.Error()); markErr != nil {
+				log.Printf("[AutoGen] 标记token记录封禁状态失败: %v", markErr)
+			}
+			// 根据邮箱禁用相关的token记录
+			if record.Email != "" {
+				if disableErr := disableTokenRecordsByEmail(record.Email, "关联账号被锁定"); disableErr != nil {
+					log.Printf("[AutoGen] 禁用相关token记录失败: %v", disableErr)
+				}
+			}
+			// 提前结束任务
+			task.Status = "failed"
+			task.ErrorMessage = "原始token被锁定"
+			task.CompletedAt = time.Now()
+			database.GetDB().Save(&task)
+			return
+		}
+	}
+	
+	successCount := 0
+	failCount := len(errs)
+	
+	// 处理生成的凭证
+	for _, cred := range credentials {
+		account := model.Account{
+			ClientID:     cred.ClientID,
+			ClientSecret: cred.Secret,
+			IsActive:     true,
+			Status:       "normal",
+		}
+		
+		// 获取Token并解析信息
+		if _, err := RefreshToken(&account); err != nil {
+			failCount++
+			// 检查是否是账号锁定错误
+			if lockoutErr, ok := err.(*AccountLockoutError); ok {
+				log.Printf("[AutoGen] 账号 %s 被锁定: %s", cred.ClientID, lockoutErr.Body)
+			} else {
+				log.Printf("[AutoGen] 账号 %s 认证失败: %v", cred.ClientID, err)
+			}
+			continue
+		}
+		
+		// 解析JWT获取详细信息
+		if payload, err := ParseJWT(account.AccessToken); err == nil {
+			account.Email = payload.Email
+			account.SubscriptionStartDate = GetSubscriptionDate(payload)
+			
+			if payload.Expiration > 0 {
+				account.TokenExpiry = time.Unix(payload.Expiration, 0)
+			}
+			
+			// 设置计划类型
+			plan := "Free"
+			if payload.CustomClaims.Plan != "" {
+				plan = payload.CustomClaims.Plan
+			}
+			account.PlanType = model.PlanType(plan)
+		}
+		
+		// 保存账号
+		var existing model.Account
+		err := database.GetDB().Where("client_id = ?", account.ClientID).First(&existing).Error
+		
+		if err == nil {
+			// 更新已存在的账号
+			existing.AccessToken = account.AccessToken
+			existing.TokenExpiry = account.TokenExpiry
+			existing.PlanType = account.PlanType
+			existing.Email = account.Email
+			existing.SubscriptionStartDate = account.SubscriptionStartDate
+			existing.IsActive = true
+			existing.Status = "normal"
+			existing.ClientSecret = account.ClientSecret
+			
+			if err := database.GetDB().Save(&existing).Error; err != nil {
+				failCount++
+				log.Printf("[AutoGen] 更新账号 %s 失败: %v", account.ClientID, err)
+			} else {
+				successCount++
+			}
+		} else if errors.Is(err, gorm.ErrRecordNotFound) {
+			// 记录不存在是正常的，创建新账号（不输出错误日志）
+			if err := database.GetDB().Create(&account).Error; err != nil {
+				failCount++
+				log.Printf("[AutoGen] 创建账号 %s 失败: %v", account.ClientID, err)
+			} else {
+				successCount++
+			}
+		} else {
+			// 其他数据库错误（非record not found的真实错误）
+			failCount++
+			log.Printf("[AutoGen] 查询账号 %s 时发生数据库错误: %v", account.ClientID, err)
+		}
+	}
+	
+	// 更新任务状态
+	task.SuccessCount = successCount
+	task.FailCount = failCount
+	task.Status = "completed"
+	if successCount == 0 && failCount > 0 {
+		task.Status = "failed"
+		task.ErrorMessage = fmt.Sprintf("所有账号生成失败")
+	}
+	task.CompletedAt = time.Now()
+	
+	if err := database.GetDB().Save(&task).Error; err != nil {
+		log.Printf("[AutoGen] 更新任务记录失败: %v", err)
+	}
+	
+	// 更新token记录，累计所有统计数据
+	updates := map[string]interface{}{
+		"last_generated_at": time.Now(),
+		"generated_count":   gorm.Expr("generated_count + ?", successCount),
+		"total_success":     gorm.Expr("total_success + ?", successCount),
+		"total_fail":        gorm.Expr("total_fail + ?", failCount),
+		"total_tasks":       gorm.Expr("total_tasks + 1"),
+	}
+	
+	if err := database.GetDB().Model(&model.TokenRecord{}).
+		Where("id = ?", record.ID).
+		Updates(updates).Error; err != nil {
+		log.Printf("[AutoGen] 更新token记录失败: %v", err)
+	}
+	
+	// 刷新账号池
+	RefreshAccountPool()
+	
+	log.Printf("[AutoGen] 自动生成完成 - 成功: %d, 失败: %d", successCount, failCount)
+}
+
+// ManualTriggerGeneration 手动触发生成
+func ManualTriggerGeneration(tokenRecordID uint) error {
+	var record model.TokenRecord
+	if err := database.GetDB().First(&record, tokenRecordID).Error; err != nil {
+		return fmt.Errorf("token记录不存在: %v", err)
+	}
+	
+	if !record.IsActive {
+		return fmt.Errorf("token记录未激活")
+	}
+	
+	go autoGenService.executeGeneration(record)
+	return nil
+}
+
+// RefreshAccountPool 刷新账号池
+func RefreshAccountPool() {
+	if pool != nil {
+		pool.refresh()
+	}
+}

internal/service/credential.go

@@ -0,0 +1,122 @@
+package service
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"math/rand"
+	"net/http"
+	"time"
+)
+
+const (
+	CredentialGenerateURL = "https://fe.zencoder.ai/frontegg/identity/resources/users/api-tokens/v1"
+)
+
+type CredentialGenerateRequest struct {
+	Description      string `json:"description"`
+	ExpiresInMinutes int    `json:"expiresInMinutes"`
+}
+
+type CredentialGenerateResponse struct {
+	ClientID     string `json:"clientId"`
+	Description  string `json:"description"`
+	CreatedAt    string `json:"createdAt"`
+	Secret       string `json:"secret"`
+	Expires      string `json:"expires"`
+	RefreshToken string `json:"refreshToken,omitempty"` // 添加 RefreshToken 字段
+}
+
+// GenerateRandomDescription 生成随机5字符描述
+func GenerateRandomDescription() string {
+	const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
+	b := make([]byte, 5)
+	for i := range b {
+		b[i] = charset[rng.Intn(len(charset))]
+	}
+	return string(b)
+}
+
+// GenerateCredential 使用 token 生成一个新凭证
+func GenerateCredential(token string) (*CredentialGenerateResponse, error) {
+	reqBody := CredentialGenerateRequest{
+		Description:      GenerateRandomDescription(),
+		ExpiresInMinutes: 525600, // 1 year
+	}
+
+	bodyBytes, err := json.Marshal(reqBody)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal request: %w", err)
+	}
+
+	req, err := http.NewRequest("POST", CredentialGenerateURL, bytes.NewReader(bodyBytes))
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	// 设置请求头
+	req.Header.Set("Accept-Encoding", "gzip, deflate, br")
+	req.Header.Set("Connection", "keep-alive")
+	req.Header.Set("accept", "*/*")
+	req.Header.Set("accept-language", "zh-CN,zh;q=0.9,en;q=0.8,zh-TW;q=0.7,ja;q=0.6")
+	req.Header.Set("authorization", "Bearer "+token)
+	req.Header.Set("cache-control", "no-cache")
+	req.Header.Set("content-type", "application/json")
+	req.Header.Set("frontegg-source", "admin-portal")
+	req.Header.Set("origin", "https://auth.zencoder.ai")
+	req.Header.Set("pragma", "no-cache")
+	req.Header.Set("priority", "u=1, i")
+	req.Header.Set("referer", "https://auth.zencoder.ai/")
+	req.Header.Set("sec-ch-ua", `"Google Chrome";v="143", "Chromium";v="143", "Not A(Brand";v="24"`)
+	req.Header.Set("sec-ch-ua-mobile", "?0")
+	req.Header.Set("sec-ch-ua-platform", `"Windows"`)
+	req.Header.Set("sec-fetch-dest", "empty")
+	req.Header.Set("sec-fetch-mode", "cors")
+	req.Header.Set("sec-fetch-site", "same-site")
+	req.Header.Set("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36")
+	req.Header.Set("x-frontegg-framework", "next@15.3.8")
+	req.Header.Set("x-frontegg-sdk", "@frontegg/nextjs@9.2.10")
+
+	client := &http.Client{Timeout: 30 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to send request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("API returned status %d: %s", resp.StatusCode, string(body))
+	}
+
+	var result CredentialGenerateResponse
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	return &result, nil
+}
+
+// BatchGenerateCredentials 批量生成凭证
+func BatchGenerateCredentials(token string, count int) ([]*CredentialGenerateResponse, []error) {
+	var results []*CredentialGenerateResponse
+	var errors []error
+
+	for i := 0; i < count; i++ {
+		cred, err := GenerateCredential(token)
+		if err != nil {
+			errors = append(errors, fmt.Errorf("credential %d: %w", i+1, err))
+			continue
+		}
+		results = append(results, cred)
+		
+		// 添加短暂延迟避免请求过快
+		if i < count-1 {
+			time.Sleep(500 * time.Millisecond)
+		}
+	}
+
+	return results, errors
+}

internal/service/debug.go

@@ -0,0 +1,185 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"os"
+	"sync"
+)
+
+var (
+	debugMode     bool
+	debugModeOnce sync.Once
+)
+
+// IsDebugMode 检查是否启用调试模式
+func IsDebugMode() bool {
+	debugModeOnce.Do(func() {
+		debugMode = os.Getenv("DEBUG") == "true" || os.Getenv("DEBUG") == "1"
+	})
+	return debugMode
+}
+
+// RequestLogger 用于收集请求级日志
+type RequestLogger struct {
+	logs     []string
+	mu       sync.Mutex
+	hasError bool
+}
+
+// NewRequestLogger 创建新的请求日志记录器
+func NewRequestLogger() *RequestLogger {
+	return &RequestLogger{
+		logs: make([]string, 0, 20),
+	}
+}
+
+// Log 记录一条日志
+func (l *RequestLogger) Log(format string, args ...interface{}) {
+	msg := fmt.Sprintf(format, args...)
+	
+	// 如果全局 DEBUG 开启，直接打印
+	if IsDebugMode() {
+		log.Print("[DEBUG] " + msg)
+		return 
+	}
+
+	// 否则缓冲
+	l.mu.Lock()
+	l.logs = append(l.logs, "[DEBUG] " + msg)
+	l.mu.Unlock()
+}
+
+// MarkError 标记发生错误
+func (l *RequestLogger) MarkError() {
+	l.mu.Lock()
+	l.hasError = true
+	l.mu.Unlock()
+}
+
+// Flush 输出缓冲的日志（如果有错误）
+func (l *RequestLogger) Flush() {
+	// 只有在非 Debug 模式且发生错误时才需要 Flush (Debug 模式下已经实时打印了)
+	if !IsDebugMode() && l.hasError {
+		l.mu.Lock()
+		defer l.mu.Unlock()
+		for _, msg := range l.logs {
+			log.Print(msg)
+		}
+	}
+}
+
+type contextKey string
+
+const loggerContextKey contextKey = "request_logger"
+
+// WithLogger 将 logger 注入 context
+func WithLogger(ctx context.Context, logger *RequestLogger) context.Context {
+	return context.WithValue(ctx, loggerContextKey, logger)
+}
+
+// GetLogger 从 context 获取 logger
+func GetLogger(ctx context.Context) *RequestLogger {
+	val := ctx.Value(loggerContextKey)
+	if val != nil {
+		if logger, ok := val.(*RequestLogger); ok {
+			return logger
+		}
+	}
+	return nil
+}
+
+// 辅助函数：获取 logger 并记录
+func logToContext(ctx context.Context, format string, args ...interface{}) {
+	logger := GetLogger(ctx)
+	if logger != nil {
+		logger.Log(format, args...)
+	} else if IsDebugMode() {
+		log.Printf("[DEBUG] "+format, args...)
+	}
+}
+
+// DebugLog 调试日志输出
+func DebugLog(ctx context.Context, format string, args ...interface{}) {
+	logToContext(ctx, format, args...)
+}
+
+// DebugLogRequest 请求开始日志
+func DebugLogRequest(ctx context.Context, provider, endpoint, model string) {
+	logToContext(ctx, "[%s] >>> 请求开始: endpoint=%s, model=%s", provider, endpoint, model)
+}
+
+// DebugLogRetry 重试日志
+func DebugLogRetry(ctx context.Context, provider string, attempt int, accountID uint, err error) {
+    if logger := GetLogger(ctx); logger != nil {
+        logger.MarkError()
+    }
+	logToContext(ctx, "[%s] ↻ 重试 #%d: accountID=%d, error=%v", provider, attempt, accountID, err)
+}
+
+// DebugLogAccountSelected 账号选择日志
+func DebugLogAccountSelected(ctx context.Context, provider string, accountID uint, email string) {
+	logToContext(ctx, "[%s] ✓ 选择账号: id=%d, email=%s", provider, accountID, email)
+}
+
+// DebugLogRequestSent 请求发送日志
+func DebugLogRequestSent(ctx context.Context, provider, url string) {
+	logToContext(ctx, "[%s] → 发送请求: %s", provider, url)
+}
+
+// DebugLogResponseReceived 响应接收日志
+func DebugLogResponseReceived(ctx context.Context, provider string, statusCode int) {
+	logToContext(ctx, "[%s] ← 收到响应: status=%d", provider, statusCode)
+}
+
+// DebugLogRequestEnd 请求结束日志
+func DebugLogRequestEnd(ctx context.Context, provider string, success bool, err error) {
+    if !success || err != nil {
+        if logger := GetLogger(ctx); logger != nil {
+            logger.MarkError()
+        }
+		logToContext(ctx, "[%s] <<< 请求完成: success=false, error=%v", provider, err)
+    } else {
+        logToContext(ctx, "[%s] <<< 请求完成: success=true", provider)
+    }
+}
+
+// DebugLogRequestHeaders 请求头日志
+func DebugLogRequestHeaders(ctx context.Context, provider string, headers map[string][]string) {
+	logToContext(ctx, "[%s] 请求头:", provider)
+	for k, v := range headers {
+		// 隐藏敏感信息
+		if k == "Authorization" || k == "x-api-key" {
+			logToContext(ctx, "[%s]   %s: ***", provider, k)
+		} else {
+			logToContext(ctx, "[%s]   %s: %v", provider, k, v)
+		}
+	}
+}
+
+// DebugLogResponseHeaders 响应头日志
+func DebugLogResponseHeaders(ctx context.Context, provider string, headers map[string][]string) {
+	logToContext(ctx, "[%s] 响应头:", provider)
+	for k, v := range headers {
+		// 隐藏敏感信息
+		if k == "X-Api-Key" || k == "Authorization" {
+			logToContext(ctx, "[%s]   %s: ***", provider, k)
+		} else {
+			logToContext(ctx, "[%s]   %s: %v", provider, k, v)
+		}
+	}
+}
+
+// DebugLogActualModel 实际调用模型日志
+func DebugLogActualModel(ctx context.Context, provider, requestModel, actualModel string) {
+	logToContext(ctx, "[%s] 模型映射: %s → %s", provider, requestModel, actualModel)
+}
+
+// DebugLogErrorResponse 错误响应内容日志
+func DebugLogErrorResponse(ctx context.Context, provider string, statusCode int, body string) {
+    if logger := GetLogger(ctx); logger != nil {
+        logger.MarkError()
+    }
+	logToContext(ctx, "[%s] ✗ 错误响应 [%d]: %s", provider, statusCode, body)
+}

internal/service/errors.go

@@ -0,0 +1,10 @@
+package service
+
+import "errors"
+
+var (
+	ErrNoAvailableAccount = errors.New("没有可用token")
+	ErrNoPermission       = errors.New("没有账号有权限使用此模型")
+	ErrTokenExpired       = errors.New("token已过期")
+	ErrRequestFailed      = errors.New("请求失败")
+)

internal/service/gemini.go

@@ -0,0 +1,360 @@
+package service
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+
+	"zencoder-2api/internal/model"
+	"zencoder-2api/internal/service/provider"
+)
+
+const GeminiBaseURL = "https://api.zencoder.ai/gemini"
+
+type GeminiService struct{}
+
+func NewGeminiService() *GeminiService {
+	return &GeminiService{}
+}
+
+// GenerateContent 处理generateContent请求
+func (s *GeminiService) GenerateContent(ctx context.Context, modelName string, body []byte) (*http.Response, error) {
+	// 检查模型是否存在于模型字典中
+	_, exists := model.GetZenModel(modelName)
+	if !exists {
+		DebugLog(ctx, "[Gemini] 模型不存在: %s", modelName)
+		return nil, ErrNoAvailableAccount
+	}
+
+	DebugLogRequest(ctx, "Gemini", "generateContent", modelName)
+
+	var lastErr error
+	for i := 0; i < MaxRetries; i++ {
+		account, err := GetNextAccountForModel(modelName)
+		if err != nil {
+			DebugLogRequestEnd(ctx, "Gemini", false, err)
+			return nil, err
+		}
+		DebugLogAccountSelected(ctx, "Gemini", account.ID, account.Email)
+
+		resp, err := s.doRequest(ctx, account, modelName, body, false)
+		if err != nil {
+			MarkAccountError(account)
+			lastErr = err
+			DebugLogRetry(ctx, "Gemini", i+1, account.ID, err)
+			continue
+		}
+
+		DebugLogResponseReceived(ctx, "Gemini", resp.StatusCode)
+		DebugLogResponseHeaders(ctx, "Gemini", resp.Header)
+		
+		// 总是输出重要的响应头信息
+		if resp.Header.Get("Zen-Pricing-Period-Limit") != "" ||
+		   resp.Header.Get("Zen-Pricing-Period-Cost") != "" ||
+		   resp.Header.Get("Zen-Request-Cost") != "" {
+			log.Printf("[Gemini] 积分信息 - 周期限额: %s, 周期消耗: %s, 本次消耗: %s",
+				resp.Header.Get("Zen-Pricing-Period-Limit"),
+				resp.Header.Get("Zen-Pricing-Period-Cost"),
+				resp.Header.Get("Zen-Request-Cost"))
+		}
+
+		if resp.StatusCode >= 400 {
+			// 读取错误响应内容用于日志
+			errBody, _ := io.ReadAll(resp.Body)
+			resp.Body.Close()
+			DebugLogErrorResponse(ctx, "Gemini", resp.StatusCode, string(errBody))
+
+			// 400和500错误直接返回，不进行账号错误计数
+			if resp.StatusCode == 400 || resp.StatusCode == 500 {
+				DebugLogRequestEnd(ctx, "Gemini", false, fmt.Errorf("API error: %d", resp.StatusCode))
+				return nil, fmt.Errorf("API error: %d - %s", resp.StatusCode, string(errBody))
+			}
+
+			// 429 错误特殊处理
+			if resp.StatusCode == 429 {
+				log.Printf("[Gemini] 429限流错误，尝试使用代理重试")
+
+				// 尝试使用代理池重试
+				proxyResp, proxyErr := s.retryWithProxy(ctx, account, modelName, body, false)
+				if proxyErr == nil && proxyResp != nil {
+					// 代理重试成功
+					return proxyResp, nil
+				}
+
+				log.Printf("[Gemini] 代理重试失败: %v", proxyErr)
+				MarkAccountRateLimitedWithResponse(account, resp)
+			} else {
+				MarkAccountError(account)
+			}
+			
+			lastErr = fmt.Errorf("API error: %d", resp.StatusCode)
+			DebugLogRetry(ctx, "Gemini", i+1, account.ID, lastErr)
+			continue
+		}
+
+		ResetAccountError(account)
+		zenModel, exists := model.GetZenModel(modelName)
+		if !exists {
+			// 模型不存在，使用默认倍率
+			UpdateAccountCreditsFromResponse(account, resp, 1.0)
+		} else {
+			// 使用统一的积分更新函数，自动处理响应头中的积分信息
+			UpdateAccountCreditsFromResponse(account, resp, zenModel.Multiplier)
+		}
+		
+		DebugLogRequestEnd(ctx, "Gemini", true, nil)
+		return resp, nil
+	}
+
+	DebugLogRequestEnd(ctx, "Gemini", false, lastErr)
+	return nil, fmt.Errorf("all retries failed: %w", lastErr)
+}
+
+// StreamGenerateContent 处理streamGenerateContent请求
+func (s *GeminiService) StreamGenerateContent(ctx context.Context, modelName string, body []byte) (*http.Response, error) {
+	// 检查模型是否存在于模型字典中
+	_, exists := model.GetZenModel(modelName)
+	if !exists {
+		DebugLog(ctx, "[Gemini] 模型不存在: %s", modelName)
+		return nil, ErrNoAvailableAccount
+	}
+
+	DebugLogRequest(ctx, "Gemini", "streamGenerateContent", modelName)
+
+	var lastErr error
+	for i := 0; i < MaxRetries; i++ {
+		account, err := GetNextAccountForModel(modelName)
+		if err != nil {
+			DebugLogRequestEnd(ctx, "Gemini", false, err)
+			return nil, err
+		}
+		DebugLogAccountSelected(ctx, "Gemini", account.ID, account.Email)
+
+		resp, err := s.doRequest(ctx, account, modelName, body, true)
+		if err != nil {
+			MarkAccountError(account)
+			lastErr = err
+			DebugLogRetry(ctx, "Gemini", i+1, account.ID, err)
+			continue
+		}
+
+		DebugLogResponseReceived(ctx, "Gemini", resp.StatusCode)
+		DebugLogResponseHeaders(ctx, "Gemini", resp.Header)
+		
+		// 总是输出重要的响应头信息
+		if resp.Header.Get("Zen-Pricing-Period-Limit") != "" ||
+		   resp.Header.Get("Zen-Pricing-Period-Cost") != "" ||
+		   resp.Header.Get("Zen-Request-Cost") != "" {
+			log.Printf("[Gemini] 积分信息 - 周期限额: %s, 周期消耗: %s, 本次消耗: %s",
+				resp.Header.Get("Zen-Pricing-Period-Limit"),
+				resp.Header.Get("Zen-Pricing-Period-Cost"),
+				resp.Header.Get("Zen-Request-Cost"))
+		}
+
+		if resp.StatusCode >= 400 {
+			// 读取错误响应内容用于日志
+			errBody, _ := io.ReadAll(resp.Body)
+			resp.Body.Close()
+			DebugLogErrorResponse(ctx, "Gemini", resp.StatusCode, string(errBody))
+
+			// 400和500错误直接返回，不进行账号错误计数
+			if resp.StatusCode == 400 || resp.StatusCode == 500 {
+				DebugLogRequestEnd(ctx, "Gemini", false, fmt.Errorf("API error: %d", resp.StatusCode))
+				return nil, fmt.Errorf("API error: %d - %s", resp.StatusCode, string(errBody))
+			}
+
+			// 429 错误特殊处理
+			if resp.StatusCode == 429 {
+				log.Printf("[Gemini] 429限流错误，尝试使用代理重试")
+
+				// 尝试使用代理池重试
+				proxyResp, proxyErr := s.retryWithProxy(ctx, account, modelName, body, true)
+				if proxyErr == nil && proxyResp != nil {
+					// 代理重试成功
+					return proxyResp, nil
+				}
+
+				log.Printf("[Gemini] 代理重试失败: %v", proxyErr)
+				MarkAccountRateLimitedWithResponse(account, resp)
+			} else {
+				MarkAccountError(account)
+			}
+			
+			lastErr = fmt.Errorf("API error: %d", resp.StatusCode)
+			DebugLogRetry(ctx, "Gemini", i+1, account.ID, lastErr)
+			continue
+		}
+
+		ResetAccountError(account)
+		zenModel, exists := model.GetZenModel(modelName)
+		if !exists {
+			// 模型不存在，使用默认倍率
+			UseCredit(account, 1.0)
+		} else {
+			// 流式响应，暂时使用模型倍率（因为没有完整响应头）
+			UseCredit(account, zenModel.Multiplier)
+		}
+		
+		DebugLogRequestEnd(ctx, "Gemini", true, nil)
+		return resp, nil
+	}
+
+	DebugLogRequestEnd(ctx, "Gemini", false, lastErr)
+	return nil, fmt.Errorf("all retries failed: %w", lastErr)
+}
+
+func (s *GeminiService) doRequest(ctx context.Context, account *model.Account, modelName string, body []byte, stream bool) (*http.Response, error) {
+	zenModel, exists := model.GetZenModel(modelName)
+	if !exists {
+		return nil, ErrNoAvailableAccount
+	}
+	httpClient := provider.NewHTTPClient(account.Proxy, 0)
+
+	action := "generateContent"
+	queryParam := ""
+	if stream {
+		action = "streamGenerateContent"
+		queryParam = "?alt=sse"
+	}
+	reqURL := fmt.Sprintf("%s/v1beta/models/%s:%s%s", GeminiBaseURL, modelName, action, queryParam)
+	DebugLogRequestSent(ctx, "Gemini", reqURL)
+	httpReq, err := http.NewRequest("POST", reqURL, bytes.NewReader(body))
+	if err != nil {
+		return nil, err
+	}
+
+	// 设置Zencoder自定义请求头
+	SetZencoderHeaders(httpReq, account, zenModel)
+
+	// 流式请求禁用压缩，确保可以逐行读取
+	if stream {
+		httpReq.Header.Set("Accept-Encoding", "identity")
+	}
+
+	// 添加模型配置的额外请求头
+	if zenModel.Parameters != nil && zenModel.Parameters.ExtraHeaders != nil {
+		for k, v := range zenModel.Parameters.ExtraHeaders {
+			httpReq.Header.Set(k, v)
+		}
+	}
+
+	// 记录请求头用于调试
+	DebugLogRequestHeaders(ctx, "Gemini", httpReq.Header)
+
+	return httpClient.Do(httpReq)
+}
+
+// GenerateContentProxy 代理generateContent请求
+func (s *GeminiService) GenerateContentProxy(ctx context.Context, w http.ResponseWriter, modelName string, body []byte) error {
+	resp, err := s.GenerateContent(ctx, modelName, body)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	return StreamResponse(w, resp)
+}
+
+// retryWithProxy 使用代理池重试Gemini请求
+func (s *GeminiService) retryWithProxy(ctx context.Context, account *model.Account, modelName string, body []byte, stream bool) (*http.Response, error) {
+	// 获取模型配置
+	zenModel, exists := model.GetZenModel(modelName)
+	if !exists {
+		return nil, fmt.Errorf("模型配置不存在: %s", modelName)
+	}
+
+	proxyPool := provider.GetProxyPool()
+	if !proxyPool.HasProxies() {
+		return nil, fmt.Errorf("没有可用的代理")
+	}
+
+	maxRetries := 3
+	for i := 0; i < maxRetries; i++ {
+		// 获取随机代理
+		proxyURL := proxyPool.GetRandomProxy()
+		if proxyURL == "" {
+			continue
+		}
+
+		log.Printf("[Gemini] 尝试代理 %s (重试 %d/%d)", proxyURL, i+1, maxRetries)
+
+		// 创建使用代理的HTTP客户端
+		proxyClient, err := provider.NewHTTPClientWithProxy(proxyURL, 0)
+		if err != nil {
+			log.Printf("[Gemini] 创建代理客户端失败: %v", err)
+			continue
+		}
+
+		// 创建新请求
+		action := "generateContent"
+		queryParam := ""
+		if stream {
+			action = "streamGenerateContent"
+			queryParam = "?alt=sse"
+		}
+		reqURL := fmt.Sprintf("%s/v1beta/models/%s:%s%s", GeminiBaseURL, modelName, action, queryParam)
+		httpReq, err := http.NewRequest("POST", reqURL, bytes.NewReader(body))
+		if err != nil {
+			log.Printf("[Gemini] 创建请求失败: %v", err)
+			continue
+		}
+
+		// 设置请求头
+		SetZencoderHeaders(httpReq, account, zenModel)
+
+		// 流式请求禁用压缩，确保��以逐行读取
+		if stream {
+			httpReq.Header.Set("Accept-Encoding", "identity")
+		}
+
+		// 添加模型配置的额外请求头
+		if zenModel.Parameters != nil && zenModel.Parameters.ExtraHeaders != nil {
+			for k, v := range zenModel.Parameters.ExtraHeaders {
+				httpReq.Header.Set(k, v)
+			}
+		}
+
+		// 执行请求
+		resp, err := proxyClient.Do(httpReq)
+		if err != nil {
+			log.Printf("[Gemini] 代理请求失败: %v", err)
+			continue
+		}
+
+		// 检查响应状态
+		if resp.StatusCode == 429 {
+			// 仍然是429，尝试下一个代理
+			resp.Body.Close()
+			log.Printf("[Gemini] 代理 %s 仍返回429，尝试下一个", proxyURL)
+			continue
+		}
+
+		if resp.StatusCode >= 400 {
+			// 其他错误，记录并尝试下一个代理
+			errBody, _ := io.ReadAll(resp.Body)
+			resp.Body.Close()
+			log.Printf("[Gemini] 代理 %s 返回错误 %d: %s", proxyURL, resp.StatusCode, string(errBody))
+			continue
+		}
+
+		// 成功
+		log.Printf("[Gemini] 代理 %s 请求成功", proxyURL)
+		return resp, nil
+	}
+
+	return nil, fmt.Errorf("所有代理重试均失败")
+}
+
+// StreamGenerateContentProxy 代理streamGenerateContent请求
+func (s *GeminiService) StreamGenerateContentProxy(ctx context.Context, w http.ResponseWriter, modelName string, body []byte) error {
+	resp, err := s.StreamGenerateContent(ctx, modelName, body)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	return StreamResponse(w, resp)
+}

internal/service/grok.go

@@ -0,0 +1,273 @@
+package service
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"strings"
+
+	"zencoder-2api/internal/model"
+	"zencoder-2api/internal/service/provider"
+)
+
+const GrokBaseURL = "https://api.zencoder.ai/xai"
+
+type GrokService struct{}
+
+func NewGrokService() *GrokService {
+	return &GrokService{}
+}
+
+// ChatCompletions 处理/v1/chat/completions请求
+func (s *GrokService) ChatCompletions(ctx context.Context, body []byte) (*http.Response, error) {
+	var req struct {
+		Model string `json:"model"`
+	}
+	if err := json.Unmarshal(body, &req); err != nil {
+		return nil, fmt.Errorf("invalid request body: %w", err)
+	}
+
+	// 检查模型是否存在于模型字典中
+	_, exists := model.GetZenModel(req.Model)
+	if !exists {
+		DebugLog(ctx, "[Grok] 模型不存在: %s", req.Model)
+		return nil, ErrNoAvailableAccount
+	}
+
+	DebugLogRequest(ctx, "Grok", "/v1/chat/completions", req.Model)
+
+	var lastErr error
+	for i := 0; i < MaxRetries; i++ {
+		account, err := GetNextAccountForModel(req.Model)
+		if err != nil {
+			DebugLogRequestEnd(ctx, "Grok", false, err)
+			return nil, err
+		}
+		DebugLogAccountSelected(ctx, "Grok", account.ID, account.Email)
+
+		resp, err := s.doRequest(ctx, account, req.Model, body)
+		if err != nil {
+			MarkAccountError(account)
+			lastErr = err
+			DebugLogRetry(ctx, "Grok", i+1, account.ID, err)
+			continue
+		}
+
+		DebugLogResponseReceived(ctx, "Grok", resp.StatusCode)
+		DebugLogResponseHeaders(ctx, "Grok", resp.Header)
+		
+		// 总是输出重要的响应头信息
+		if resp.Header.Get("Zen-Pricing-Period-Limit") != "" ||
+		   resp.Header.Get("Zen-Pricing-Period-Cost") != "" ||
+		   resp.Header.Get("Zen-Request-Cost") != "" {
+			log.Printf("[Grok] 积分信息 - 周期限额: %s, 周期消耗: %s, 本次消耗: %s",
+				resp.Header.Get("Zen-Pricing-Period-Limit"),
+				resp.Header.Get("Zen-Pricing-Period-Cost"),
+				resp.Header.Get("Zen-Request-Cost"))
+		}
+
+		if resp.StatusCode >= 400 {
+			// 读取错误响应内容
+			errBody, _ := io.ReadAll(resp.Body)
+			resp.Body.Close()
+			
+			// 429 错误特殊处理 - 直接返回，不重试
+			if resp.StatusCode == 429 {
+				log.Printf("[Grok] 429限流错误，尝试使用代理重试")
+
+				// 尝试使用代理池重试
+				proxyResp, proxyErr := s.retryWithProxy(ctx, account, req.Model, body)
+				if proxyErr == nil && proxyResp != nil {
+					// 代理重试成功
+					return proxyResp, nil
+				}
+
+				log.Printf("[Grok] 代理重试失败: %v", proxyErr)
+				// 在DEBUG模式下记录详细信息
+				DebugLogErrorResponse(ctx, "Grok", resp.StatusCode, string(errBody))
+				// 将账号放入短期冷却（5秒）
+				MarkAccountRateLimitedShort(account)
+				// 标记错误并结束请求
+				DebugLogRequestEnd(ctx, "Grok", false, ErrNoAvailableAccount)
+				// 返回通用错误
+				return nil, ErrNoAvailableAccount
+			}
+			
+			DebugLogErrorResponse(ctx, "Grok", resp.StatusCode, string(errBody))
+
+			// 400和500错误直接返回，不进行账号错误计数
+			if resp.StatusCode == 400 || resp.StatusCode == 500 {
+				DebugLogRequestEnd(ctx, "Grok", false, fmt.Errorf("API error: %d", resp.StatusCode))
+				return nil, fmt.Errorf("API error: %d - %s", resp.StatusCode, string(errBody))
+			}
+
+			MarkAccountError(account)
+			lastErr = fmt.Errorf("API error: %d", resp.StatusCode)
+			DebugLogRetry(ctx, "Grok", i+1, account.ID, lastErr)
+			continue
+		}
+
+		ResetAccountError(account)
+		zenModel, exists := model.GetZenModel(req.Model)
+		if !exists {
+			// 模型不存在，使用默认倍率
+			UpdateAccountCreditsFromResponse(account, resp, 1.0)
+		} else {
+			// 使用统一的积分更新函数，自动处理响应头中的积分信息
+			UpdateAccountCreditsFromResponse(account, resp, zenModel.Multiplier)
+		}
+		
+		DebugLogRequestEnd(ctx, "Grok", true, nil)
+		return resp, nil
+	}
+
+	DebugLogRequestEnd(ctx, "Grok", false, lastErr)
+	return nil, fmt.Errorf("all retries failed: %w", lastErr)
+}
+
+func (s *GrokService) doRequest(ctx context.Context, account *model.Account, modelID string, body []byte) (*http.Response, error) {
+	zenModel, exists := model.GetZenModel(modelID)
+	if !exists {
+		return nil, ErrNoAvailableAccount
+	}
+	httpClient := provider.NewHTTPClient(account.Proxy, 0)
+
+	// 处理请求体，Grok Code 模型要求 temperature=0
+	modifiedBody := body
+	if strings.Contains(modelID, "grok-code") {
+		modifiedBody, _ = s.setTemperatureZero(body)
+	}
+
+	reqURL := GrokBaseURL + "/v1/chat/completions"
+	DebugLogRequestSent(ctx, "Grok", reqURL)
+
+	httpReq, err := http.NewRequest("POST", reqURL, bytes.NewReader(modifiedBody))
+	if err != nil {
+		return nil, err
+	}
+
+	// 设置Zencoder自定义请求头
+	SetZencoderHeaders(httpReq, account, zenModel)
+
+	// 添加模型配置的额外请求头
+	if zenModel.Parameters != nil && zenModel.Parameters.ExtraHeaders != nil {
+		for k, v := range zenModel.Parameters.ExtraHeaders {
+			httpReq.Header.Set(k, v)
+		}
+	}
+
+	// 记录请求头用于调试
+	DebugLogRequestHeaders(ctx, "Grok", httpReq.Header)
+
+	return httpClient.Do(httpReq)
+}
+
+// setTemperatureZero 设置 temperature=0
+func (s *GrokService) setTemperatureZero(body []byte) ([]byte, error) {
+	var reqMap map[string]interface{}
+	if err := json.Unmarshal(body, &reqMap); err != nil {
+		return body, err
+	}
+	reqMap["temperature"] = 0
+	return json.Marshal(reqMap)
+}
+
+// ChatCompletionsProxy 代理chat completions请求
+func (s *GrokService) ChatCompletionsProxy(ctx context.Context, w http.ResponseWriter, body []byte) error {
+	resp, err := s.ChatCompletions(ctx, body)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	return StreamResponse(w, resp)
+}
+
+// retryWithProxy 使用代理池重试Grok请求
+func (s *GrokService) retryWithProxy(ctx context.Context, account *model.Account, modelID string, body []byte) (*http.Response, error) {
+	// 获取模型配置
+	zenModel, exists := model.GetZenModel(modelID)
+	if !exists {
+		return nil, fmt.Errorf("模型配置不存在: %s", modelID)
+	}
+
+	proxyPool := provider.GetProxyPool()
+	if !proxyPool.HasProxies() {
+		return nil, fmt.Errorf("没有可用的代理")
+	}
+
+	maxRetries := 3
+	for i := 0; i < maxRetries; i++ {
+		// 获取随机代理
+		proxyURL := proxyPool.GetRandomProxy()
+		if proxyURL == "" {
+			continue
+		}
+
+		log.Printf("[Grok] 尝试代理 %s (重试 %d/%d)", proxyURL, i+1, maxRetries)
+
+		// 创建使用代理的HTTP客户端
+		proxyClient, err := provider.NewHTTPClientWithProxy(proxyURL, 0)
+		if err != nil {
+			log.Printf("[Grok] 创建代理客户端失败: %v", err)
+			continue
+		}
+
+		// 处理请求体，Grok Code 模型要求 temperature=0
+		modifiedBody := body
+		if strings.Contains(modelID, "grok-code") {
+			modifiedBody, _ = s.setTemperatureZero(body)
+		}
+
+		// 创建新请求
+		reqURL := GrokBaseURL + "/v1/chat/completions"
+		httpReq, err := http.NewRequest("POST", reqURL, bytes.NewReader(modifiedBody))
+		if err != nil {
+			log.Printf("[Grok] 创建请求失败: %v", err)
+			continue
+		}
+
+		// 设置请求头
+		SetZencoderHeaders(httpReq, account, zenModel)
+
+		// 添加模型配置的额外请求头
+		if zenModel.Parameters != nil && zenModel.Parameters.ExtraHeaders != nil {
+			for k, v := range zenModel.Parameters.ExtraHeaders {
+				httpReq.Header.Set(k, v)
+			}
+		}
+
+		// 执行请求
+		resp, err := proxyClient.Do(httpReq)
+		if err != nil {
+			log.Printf("[Grok] 代理请求失败: %v", err)
+			continue
+		}
+
+		// 检查响应状态
+		if resp.StatusCode == 429 {
+			// 仍然是429，尝试下一个代理
+			resp.Body.Close()
+			log.Printf("[Grok] 代理 %s 仍返回429，尝试下一个", proxyURL)
+			continue
+		}
+
+		if resp.StatusCode >= 400 {
+			// 其他错误，记录并尝试下一个代理
+			errBody, _ := io.ReadAll(resp.Body)
+			resp.Body.Close()
+			log.Printf("[Grok] 代理 %s 返回错误 %d: %s", proxyURL, resp.StatusCode, string(errBody))
+			continue
+		}
+
+		// 成功
+		log.Printf("[Grok] 代理 %s 请求成功", proxyURL)
+		return resp, nil
+	}
+
+	return nil, fmt.Errorf("所有代理重试均失败")
+}

internal/service/headers.go

@@ -0,0 +1,84 @@
+package service
+
+import (
+	"math/rand"
+	"net/http"
+	"time"
+
+	"zencoder-2api/internal/model"
+
+	"github.com/google/uuid"
+)
+
+var (
+	// 可变的 User-Agent 列表
+	userAgents = []string{
+		"zen-cli/0.9.0-SNAPSHOT_4c6ffdd-windows-x64",
+		"zen-cli/0.9.0-SNAPSHOT_5d7ggee-windows-x64",
+		"zen-cli/0.9.0-SNAPSHOT_6e8hhff-windows-x64",
+		"zen-cli/0.8.9-SNAPSHOT_3b5eedd-windows-x64",
+	}
+
+	// 可变的 Node 版本
+	nodeVersions = []string{
+		"v24.3.0",
+		"v24.2.0",
+		"v24.1.0",
+		"v23.5.0",
+		"v22.11.0",
+	}
+
+	// 可变的 zencoder 版本
+	zencoderVersions = []string{
+		"3.24.0",
+		"3.23.9",
+		"3.23.8",
+		"3.24.1",
+	}
+
+	// 可变的 package 版本
+	packageVersions = []string{
+		"6.9.1",
+		"6.9.0",
+		"6.8.9",
+		"6.8.8",
+	}
+
+	rng = rand.New(rand.NewSource(time.Now().UnixNano()))
+)
+
+// 随机选择一个元素
+func randomChoice(items []string) string {
+	return items[rng.Intn(len(items))]
+}
+
+// SetZencoderHeaders 设置Zencoder自定义请求头
+func SetZencoderHeaders(req *http.Request, account *model.Account, zenModel model.ZenModel) {
+	// 基础请求头 - 使用随机 User-Agent
+	req.Header.Set("User-Agent", "zen-cli/0.9.0-SNAPSHOT_4c6ffdd-windows-x64")
+	req.Header.Set("Accept", "application/json")
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Connection", "keep-alive")
+
+	// 认证头
+	req.Header.Set("Authorization", "Bearer "+account.AccessToken)
+
+	// x-stainless 系列
+	req.Header.Set("x-stainless-arch", "x64")
+	req.Header.Set("x-stainless-lang", "js")
+	req.Header.Set("x-stainless-os", "Windows")
+	req.Header.Set("x-stainless-package-version", "0.70.1")
+	req.Header.Set("x-stainless-retry-count", "0")
+	req.Header.Set("x-stainless-runtime", "node")
+	req.Header.Set("x-stainless-runtime-version", "v24.3.0")
+
+	// zen/zencoder 系列 - 使用随机版本和唯一 ID
+	req.Header.Set("zen-model-id", zenModel.ID)
+	req.Header.Set("zencoder-arch", "x64")
+	req.Header.Set("zencoder-auto-model", "false")
+	req.Header.Set("zencoder-client-type", "vscode")
+	req.Header.Set("zencoder-operation-id", uuid.New().String())
+	req.Header.Set("zencoder-operation-type", "agent_call")
+	req.Header.Set("zencoder-os", "windows")
+	req.Header.Set("zencoder-version", "3.24.0")
+}

internal/service/jwt.go

@@ -0,0 +1,74 @@
+package service
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"strings"
+	"time"
+)
+
+type CustomClaims struct {
+	Plan     string `json:"plan"`
+	Autobots struct {
+		SubscriptionStartDate string `json:"subscription_start_date"`
+	} `json:"autobots"`
+}
+
+type JWTPayload struct {
+	Subject      string       `json:"sub"`
+	ClientID     string       `json:"client_id"`
+	Email        string       `json:"email"`
+	CustomClaims CustomClaims `json:"customClaims"`
+	IssuedAt     int64        `json:"iat"`
+	Expiration   int64        `json:"exp"`
+}
+
+func ParseJWT(tokenString string) (*JWTPayload, error) {
+	parts := strings.Split(tokenString, ".")
+	if len(parts) != 3 {
+		return nil, errors.New("invalid token format")
+	}
+
+	payloadPart := parts[1]
+	
+	// Add padding if missing
+	if l := len(payloadPart) % 4; l > 0 {
+		payloadPart += strings.Repeat("=", 4-l)
+	}
+
+	decoded, err := base64.URLEncoding.DecodeString(payloadPart)
+	if err != nil {
+		// Try standard encoding if URL encoding fails
+		decoded, err = base64.StdEncoding.DecodeString(payloadPart)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	var payload JWTPayload
+	if err := json.Unmarshal(decoded, &payload); err != nil {
+		return nil, err
+	}
+
+	return &payload, nil
+}
+
+func GetSubscriptionDate(payload *JWTPayload) time.Time {
+	// Try to parse SubscriptionStartDate from CustomClaims
+	if v := payload.CustomClaims.Autobots.SubscriptionStartDate; v != "" {
+		if t, err := time.Parse(time.RFC3339, v); err == nil {
+			return t
+		}
+		if t, err := time.Parse("2006-01-02", v); err == nil {
+			return t
+		}
+	}
+	
+	// Fallback to IssuedAt
+	if payload.IssuedAt > 0 {
+		return time.Unix(payload.IssuedAt, 0)
+	}
+
+	return time.Now()
+}

internal/service/openai.go

@@ -0,0 +1,868 @@
+package service
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"strings"
+	"time"
+
+	"zencoder-2api/internal/model"
+	"zencoder-2api/internal/service/provider"
+)
+
+const OpenAIBaseURL = "https://api.zencoder.ai/openai"
+
+type OpenAIService struct{}
+
+func NewOpenAIService() *OpenAIService {
+	return &OpenAIService{}
+}
+
+// ChatCompletions 处理/v1/chat/completions请求
+func (s *OpenAIService) ChatCompletions(ctx context.Context, body []byte) (*http.Response, error) {
+	var req struct {
+		Model string `json:"model"`
+	}
+	if err := json.Unmarshal(body, &req); err != nil {
+		return nil, fmt.Errorf("invalid request body: %w", err)
+	}
+
+	// 检查模型是否存在于模型字典中
+	_, exists := model.GetZenModel(req.Model)
+	if !exists {
+		DebugLog(ctx, "[OpenAI] 模型不存在: %s", req.Model)
+		return nil, ErrNoAvailableAccount
+	}
+
+	DebugLogRequest(ctx, "OpenAI", "/v1/chat/completions", req.Model)
+
+	var lastErr error
+	for i := 0; i < MaxRetries; i++ {
+		account, err := GetNextAccountForModel(req.Model)
+		if err != nil {
+			DebugLogRequestEnd(ctx, "OpenAI", false, err)
+			return nil, err
+		}
+		DebugLogAccountSelected(ctx, "OpenAI", account.ID, account.Email)
+
+		// Zencoder API使用/v1/responses端点
+		// 需要转换请求体：messages -> input
+		convertedBody, err := s.convertChatToResponsesBody(body)
+		if err != nil {
+			DebugLogRequestEnd(ctx, "OpenAI", false, err)
+			return nil, fmt.Errorf("failed to convert request body: %w", err)
+		}
+
+		resp, err := s.doRequest(ctx, account, req.Model, "/v1/responses", convertedBody)
+		if err != nil {
+			MarkAccountError(account)
+			lastErr = err
+			DebugLogRetry(ctx, "OpenAI", i+1, account.ID, err)
+			continue
+		}
+
+		DebugLogResponseReceived(ctx, "OpenAI", resp.StatusCode)
+		DebugLogResponseHeaders(ctx, "OpenAI", resp.Header)
+		
+		// 总是输出重要的响应头信息
+		if resp.Header.Get("Zen-Pricing-Period-Limit") != "" ||
+		   resp.Header.Get("Zen-Pricing-Period-Cost") != "" ||
+		   resp.Header.Get("Zen-Request-Cost") != "" {
+			log.Printf("[OpenAI] 积分信息 - 周期限额: %s, 周期消耗: %s, 本次消耗: %s",
+				resp.Header.Get("Zen-Pricing-Period-Limit"),
+				resp.Header.Get("Zen-Pricing-Period-Cost"),
+				resp.Header.Get("Zen-Request-Cost"))
+		}
+
+		if resp.StatusCode >= 400 {
+			// 读取错误响应内容
+			errBody, _ := io.ReadAll(resp.Body)
+			resp.Body.Close()
+			DebugLogErrorResponse(ctx, "OpenAI", resp.StatusCode, string(errBody))
+
+			// 400和500错误直接返回，不进行账号错误计数
+			if resp.StatusCode == 400 || resp.StatusCode == 500 {
+				DebugLogRequestEnd(ctx, "OpenAI", false, fmt.Errorf("API error: %d", resp.StatusCode))
+				return nil, fmt.Errorf("API error: %d - %s", resp.StatusCode, string(errBody))
+			}
+
+			// 429 错误特殊处理
+			if resp.StatusCode == 429 {
+				log.Printf("[OpenAI] 429限流错误，尝试使用代理重试")
+
+				// 尝试使用代理池重试
+				proxyResp, proxyErr := s.retryWithProxy(ctx, account, req.Model, "/v1/responses", convertedBody)
+				if proxyErr == nil && proxyResp != nil {
+					// 代理重试成功
+					return proxyResp, nil
+				}
+
+				log.Printf("[OpenAI] 代理重试失败: %v", proxyErr)
+				MarkAccountRateLimitedWithResponse(account, resp)
+			} else {
+				MarkAccountError(account)
+			}
+			
+			lastErr = fmt.Errorf("API error: %d", resp.StatusCode)
+			DebugLogRetry(ctx, "OpenAI", i+1, account.ID, lastErr)
+			continue
+		}
+
+		ResetAccountError(account)
+		zenModel, exists := model.GetZenModel(req.Model)
+		if !exists {
+			// 模型不存在，使用默认倍率
+			UpdateAccountCreditsFromResponse(account, resp, 1.0)
+		} else {
+			// 使用统一的积分更新函数，自动处理响应头中的积分信息
+			UpdateAccountCreditsFromResponse(account, resp, zenModel.Multiplier)
+		}
+		
+		DebugLogRequestEnd(ctx, "OpenAI", true, nil)
+		return resp, nil
+	}
+
+	DebugLogRequestEnd(ctx, "OpenAI", false, lastErr)
+	return nil, fmt.Errorf("all retries failed: %w", lastErr)
+}
+
+// Responses 处理/v1/responses请求
+func (s *OpenAIService) Responses(ctx context.Context, body []byte) (*http.Response, error) {
+	var req struct {
+		Model string `json:"model"`
+	}
+	if err := json.Unmarshal(body, &req); err != nil {
+		return nil, fmt.Errorf("invalid request body: %w", err)
+	}
+
+	// 检查模型是否存在于模型字典中
+	_, exists := model.GetZenModel(req.Model)
+	if !exists {
+		DebugLog(ctx, "[OpenAI] 模型不存在: %s", req.Model)
+		return nil, ErrNoAvailableAccount
+	}
+
+	DebugLogRequest(ctx, "OpenAI", "/v1/responses", req.Model)
+
+	var lastErr error
+	for i := 0; i < MaxRetries; i++ {
+		account, err := GetNextAccountForModel(req.Model)
+		if err != nil {
+			DebugLogRequestEnd(ctx, "OpenAI", false, err)
+			return nil, err
+		}
+		DebugLogAccountSelected(ctx, "OpenAI", account.ID, account.Email)
+
+		resp, err := s.doRequest(ctx, account, req.Model, "/v1/responses", body)
+		if err != nil {
+			MarkAccountError(account)
+			lastErr = err
+			DebugLogRetry(ctx, "OpenAI", i+1, account.ID, err)
+			continue
+		}
+
+		DebugLogResponseReceived(ctx, "OpenAI", resp.StatusCode)
+		DebugLogResponseHeaders(ctx, "OpenAI", resp.Header)
+		
+		// 总是输出重要的响应头信息
+		if resp.Header.Get("Zen-Pricing-Period-Limit") != "" ||
+		   resp.Header.Get("Zen-Pricing-Period-Cost") != "" ||
+		   resp.Header.Get("Zen-Request-Cost") != "" {
+			log.Printf("[OpenAI] 积分信息 - 周期限额: %s, 周期消耗: %s, 本次消耗: %s",
+				resp.Header.Get("Zen-Pricing-Period-Limit"),
+				resp.Header.Get("Zen-Pricing-Period-Cost"),
+				resp.Header.Get("Zen-Request-Cost"))
+		}
+
+		if resp.StatusCode >= 400 {
+			// 读取错误响应内容
+			errBody, _ := io.ReadAll(resp.Body)
+			resp.Body.Close()
+			
+			// 429 错误特殊处理 - 直接返回，不重试
+			if resp.StatusCode == 429 {
+				log.Printf("[OpenAI] 429限流错误，尝试使用代理重试")
+
+				// 尝试使用代理池重试
+				proxyResp, proxyErr := s.retryWithProxy(ctx, account, req.Model, "/v1/responses", body)
+				if proxyErr == nil && proxyResp != nil {
+					// 代理重试成功
+					return proxyResp, nil
+				}
+
+				log.Printf("[OpenAI] 代理重试失败: %v", proxyErr)
+				// 将账号放入短期冷却（5秒）
+				MarkAccountRateLimitedShort(account)
+				// 不输出错误日志，直接返回
+				return nil, ErrNoAvailableAccount
+			}
+			
+			DebugLogErrorResponse(ctx, "OpenAI", resp.StatusCode, string(errBody))
+
+			// 400和500错误直接返回，不进行账号错误计数
+			if resp.StatusCode == 400 || resp.StatusCode == 500 {
+				DebugLogRequestEnd(ctx, "OpenAI", false, fmt.Errorf("API error: %d", resp.StatusCode))
+				return nil, fmt.Errorf("API error: %d - %s", resp.StatusCode, string(errBody))
+			}
+
+			MarkAccountError(account)
+			lastErr = fmt.Errorf("API error: %d", resp.StatusCode)
+			DebugLogRetry(ctx, "OpenAI", i+1, account.ID, lastErr)
+			continue
+		}
+
+		ResetAccountError(account)
+		zenModel, exists := model.GetZenModel(req.Model)
+		if !exists {
+			// 模型不存在，使用默认倍率
+			UpdateAccountCreditsFromResponse(account, resp, 1.0)
+		} else {
+			// 使用统一的积分更新函数，自动处理响应头中的积分信息
+			UpdateAccountCreditsFromResponse(account, resp, zenModel.Multiplier)
+		}
+		
+		DebugLogRequestEnd(ctx, "OpenAI", true, nil)
+		return resp, nil
+	}
+
+	DebugLogRequestEnd(ctx, "OpenAI", false, lastErr)
+	return nil, fmt.Errorf("all retries failed: %w", lastErr)
+}
+
+// convertChatToResponsesBody 将 Chat Completion 的请求体转换为 Responses API 的请求体
+func (s *OpenAIService) convertChatToResponsesBody(body []byte) ([]byte, error) {
+	var raw map[string]interface{}
+	if err := json.Unmarshal(body, &raw); err != nil {
+		return nil, err
+	}
+
+	// 移除 /v1/responses API 不支持的参数
+	delete(raw, "stream_options")  // 不支持 stream_options.include_usage 等
+	delete(raw, "function_call")   // 旧版函数调用参数
+	delete(raw, "functions")       // 旧版函数定义参数
+	
+	// 转换 token 限制参数
+	// max_completion_tokens (新) / max_tokens (旧) -> max_output_tokens (Responses API)
+	if val, ok := raw["max_completion_tokens"]; ok {
+		raw["max_output_tokens"] = val
+		delete(raw, "max_completion_tokens")
+	} else if val, ok := raw["max_tokens"]; ok {
+		raw["max_output_tokens"] = val
+		delete(raw, "max_tokens")
+	}
+
+	modelStr, _ := raw["model"].(string)
+
+	// 检查是否有 messages 字段
+	if messages, ok := raw["messages"].([]interface{}); ok {
+		if modelStr == "gpt-5-nano-2025-08-07" {
+			// gpt-5-nano 特殊处理：转换为复杂的 input 结构
+			newInput := make([]map[string]interface{}, 0)
+			for _, m := range messages {
+				if msgMap, ok := m.(map[string]interface{}); ok {
+					role, _ := msgMap["role"].(string)
+					content := msgMap["content"]
+
+					newItem := map[string]interface{}{
+						"type": "message",
+						"role": role,
+					}
+
+					newContent := make([]map[string]interface{}, 0)
+					if contentStr, ok := content.(string); ok {
+						newContent = append(newContent, map[string]interface{}{
+							"type": "input_text",
+							"text": contentStr,
+						})
+					}
+					// 这里的 content 如果是数组，暂时忽略或假设是纯文本场景
+					// 如果需要支持多模态，需要进一步解析 content 数组
+
+					newItem["content"] = newContent
+					newInput = append(newInput, newItem)
+				}
+			}
+			raw["input"] = newInput
+		} else {
+			// 标准转换：直接移动到 input
+			raw["input"] = messages
+		}
+		delete(raw, "messages")
+	}
+
+	// gpt-5-nano-2025-08-07 特殊处理参数
+	if modelStr == "gpt-5-nano-2025-08-07" {
+		// 添加该模型所需的特定参数
+		raw["prompt_cache_key"] = "generate-name"
+		raw["store"] = false
+		raw["include"] = []string{"reasoning.encrypted_content"}
+		raw["service_tier"] = "auto"
+	}
+
+	return json.Marshal(raw)
+}
+
+func (s *OpenAIService) doRequest(ctx context.Context, account *model.Account, modelID, path string, body []byte) (*http.Response, error) {
+	zenModel, exists := model.GetZenModel(modelID)
+	if !exists {
+		return nil, ErrNoAvailableAccount
+	}
+	httpClient := provider.NewHTTPClient(account.Proxy, 0)
+
+	// 将模型参数合并到请求体中
+	modifiedBody := body
+	if zenModel.Parameters != nil {
+		var raw map[string]interface{}
+		if json.Unmarshal(modifiedBody, &raw) == nil {
+			// 添加 reasoning 配置
+			if zenModel.Parameters.Reasoning != nil && raw["reasoning"] == nil {
+				reasoningMap := map[string]interface{}{
+					"effort": zenModel.Parameters.Reasoning.Effort,
+				}
+				if zenModel.Parameters.Reasoning.Summary != "" {
+					reasoningMap["summary"] = zenModel.Parameters.Reasoning.Summary
+				}
+				raw["reasoning"] = reasoningMap
+			}
+			
+			// 添加 text 配置
+			if zenModel.Parameters.Text != nil && raw["text"] == nil {
+				raw["text"] = map[string]interface{}{
+					"verbosity": zenModel.Parameters.Text.Verbosity,
+				}
+			}
+			
+			// 添加 temperature 配置
+			if zenModel.Parameters.Temperature != nil && raw["temperature"] == nil {
+				raw["temperature"] = *zenModel.Parameters.Temperature
+			}
+			
+			modifiedBody, _ = json.Marshal(raw)
+		}
+	}
+
+	// gpt-5-nano-2025-08-07 特殊处理参数
+	if modelID == "gpt-5-nano-2025-08-07" {
+		var raw map[string]interface{}
+		if json.Unmarshal(modifiedBody, &raw) == nil {
+			// 添加 text 参数
+			if _, ok := raw["text"]; !ok {
+				raw["text"] = map[string]string{"verbosity": "medium"}
+			}
+			// 添加 temperature 参数 (如果缺失)
+			if _, ok := raw["temperature"]; !ok {
+				raw["temperature"] = 1
+			}
+			// 强制开启 stream，因为该模型似乎不支持非流式
+			raw["stream"] = true
+
+			// 修正 reasoning 参数，添加 summary
+			if reasoning, ok := raw["reasoning"].(map[string]interface{}); ok {
+				reasoning["summary"] = "auto"
+				raw["reasoning"] = reasoning
+			} else {
+				raw["reasoning"] = map[string]interface{}{
+					"effort":  "minimal",
+					"summary": "auto",
+				}
+			}
+			modifiedBody, _ = json.Marshal(raw)
+		}
+	}
+
+	// 注意：已移除模型重定向逻辑，直接使用用户请求的模型名
+	DebugLogActualModel(ctx, "OpenAI", modelID, modelID)
+
+	reqURL := OpenAIBaseURL + path
+	DebugLogRequestSent(ctx, "OpenAI", reqURL)
+
+	httpReq, err := http.NewRequest("POST", reqURL, bytes.NewReader(modifiedBody))
+	if err != nil {
+		return nil, err
+	}
+
+	// 设置Zencoder自定义请求头
+	SetZencoderHeaders(httpReq, account, zenModel)
+
+	// 添加模型配置的额外请求头
+	if zenModel.Parameters != nil && zenModel.Parameters.ExtraHeaders != nil {
+		for k, v := range zenModel.Parameters.ExtraHeaders {
+			httpReq.Header.Set(k, v)
+		}
+	}
+
+	// 记录请求头用于调试
+	DebugLogRequestHeaders(ctx, "OpenAI", httpReq.Header)
+	
+	// 强制记录请求体用于调试
+	log.Printf("[DEBUG] [OpenAI] 请求体:")
+	log.Printf("[DEBUG] [OpenAI] %s", string(modifiedBody))
+
+	return httpClient.Do(httpReq)
+}
+
+// ChatCompletionsProxy 代理chat completions请求
+func (s *OpenAIService) ChatCompletionsProxy(ctx context.Context, w http.ResponseWriter, body []byte) error {
+	// 解析 model 和 stream 参数
+	var req struct {
+		Model  string `json:"model"`
+		Stream bool   `json:"stream"`
+	}
+	// 忽略错误，因为ChatCompletions会再次解析并处理错误
+	_ = json.Unmarshal(body, &req)
+
+	resp, err := s.ChatCompletions(ctx, body)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if req.Stream {
+		return s.streamConvertedResponse(w, resp, req.Model)
+	}
+
+	return s.handleNonStreamResponse(w, resp, req.Model)
+}
+
+func (s *OpenAIService) handleNonStreamResponse(w http.ResponseWriter, resp *http.Response, modelID string) error {
+	// 读取全部响应体
+	bodyBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
+	// 复制响应头
+	for k, v := range resp.Header {
+		// 过滤掉 Content-Length (会重新计算) 和 Content-Encoding (Go会自动解压)
+		if k != "Content-Length" && k != "Content-Encoding" {
+			for _, vv := range v {
+				w.Header().Add(k, vv)
+			}
+		}
+	}
+	w.WriteHeader(resp.StatusCode)
+
+	// 尝试解析响应
+	var raw map[string]interface{}
+	if err := json.Unmarshal(bodyBytes, &raw); err != nil {
+		// 如果不是 JSON，检查是否是 SSE 流 (可能是因为我们强制开启了 stream)
+		bodyStr := string(bodyBytes)
+		trimmedBody := strings.TrimSpace(bodyStr)
+		contentType := resp.Header.Get("Content-Type")
+		isSSE := strings.Contains(contentType, "text/event-stream") ||
+			strings.HasPrefix(trimmedBody, "data:") ||
+			strings.HasPrefix(trimmedBody, "event:") ||
+			strings.HasPrefix(trimmedBody, ":") ||
+			modelID == "gpt-5-nano-2025-08-07" // 强制该模型走 SSE 解析
+
+		if isSSE {
+			var fullContent string
+			scanner := bufio.NewScanner(bytes.NewReader(bodyBytes))
+			for scanner.Scan() {
+				line := strings.TrimSpace(scanner.Text())
+				if !strings.HasPrefix(line, "data: ") {
+					continue
+				}
+				data := strings.TrimPrefix(line, "data: ")
+				if data == "[DONE]" {
+					break
+				}
+				var chunk map[string]interface{}
+				if json.Unmarshal([]byte(data), &chunk) == nil {
+					// 尝试提取 content
+					if val, ok := chunk["text"].(string); ok {
+						fullContent += val
+					} else if val, ok := chunk["content"].(string); ok {
+						fullContent += val
+					} else if val, ok := chunk["response"].(string); ok {
+						fullContent += val
+					}
+					// 标准 chunk
+					if choices, ok := chunk["choices"].([]interface{}); ok && len(choices) > 0 {
+						if choice, ok := choices[0].(map[string]interface{}); ok {
+							if delta, ok := choice["delta"].(map[string]interface{}); ok {
+								if content, ok := delta["content"].(string); ok {
+									fullContent += content
+								}
+							}
+						}
+					}
+				}
+			}
+
+			// 如果提取到了内容，或者是强制模型（即使没提取到也返回空内容以避免透传错误格式）
+			if fullContent != "" || modelID == "gpt-5-nano-2025-08-07" {
+				timestamp := time.Now().Unix()
+				respObj := model.ChatCompletionResponse{
+					ID:      fmt.Sprintf("chatcmpl-%d", timestamp),
+					Object:  "chat.completion",
+					Created: timestamp,
+					Model:   modelID,
+					Choices: []model.Choice{
+						{
+							Index: 0,
+							Message: model.ChatMessage{
+								Role:    "assistant",
+								Content: fullContent,
+							},
+							FinishReason: "stop",
+						},
+					},
+				}
+				return json.NewEncoder(w).Encode(respObj)
+			}
+		}
+
+		// 既不是 JSON 也不是 SSE，直接透传
+		w.Write(bodyBytes)
+		return nil
+	}
+
+	// 检查是否已经是 OpenAI 格式 (包含 choices)
+	if _, ok := raw["choices"]; ok {
+		w.Write(bodyBytes)
+		return nil
+	}
+
+	// 尝试从常见字段提取内容进行转换
+	var content string
+	if val, ok := raw["text"].(string); ok {
+		content = val
+	} else if val, ok := raw["content"].(string); ok {
+		content = val
+	} else if val, ok := raw["response"].(string); ok {
+		content = val
+	}
+
+	if content != "" {
+		timestamp := time.Now().Unix()
+		respObj := model.ChatCompletionResponse{
+			ID:      fmt.Sprintf("chatcmpl-%d", timestamp),
+			Object:  "chat.completion",
+			Created: timestamp,
+			Model:   modelID,
+			Choices: []model.Choice{
+				{
+					Index: 0,
+					Message: model.ChatMessage{
+						Role:    "assistant",
+						Content: content,
+					},
+					FinishReason: "stop",
+				},
+			},
+		}
+		return json.NewEncoder(w).Encode(respObj)
+	}
+
+	// 无法识别格式，直接透传
+	w.Write(bodyBytes)
+	return nil
+}
+
+func (s *OpenAIService) streamConvertedResponse(w http.ResponseWriter, resp *http.Response, modelID string) error {
+	// 复制响应头
+	for k, v := range resp.Header {
+		// 过滤掉 Content-Encoding 和 Content-Length
+		if k != "Content-Encoding" && k != "Content-Length" {
+			for _, vv := range v {
+				w.Header().Add(k, vv)
+			}
+		}
+	}
+	w.WriteHeader(resp.StatusCode)
+
+	flusher, ok := w.(http.Flusher)
+	if !ok {
+		// 如果不支持Flusher，回退到普通复制
+		_, err := io.Copy(w, resp.Body)
+		return err
+	}
+
+	reader := bufio.NewReader(resp.Body)
+	timestamp := time.Now().Unix()
+	id := fmt.Sprintf("chatcmpl-%d", timestamp)
+
+	for {
+		line, err := reader.ReadString('\n')
+		if err != nil {
+			if err == io.EOF {
+				return nil
+			}
+			return err
+		}
+
+		// 处理空行
+		trimmedLine := strings.TrimSpace(line)
+		if trimmedLine == "" {
+			fmt.Fprintf(w, "\n")
+			flusher.Flush()
+			continue
+		}
+
+		// 解析 data: 前缀
+		if !strings.HasPrefix(trimmedLine, "data: ") {
+			// 尝试解析为 JSON 对象 (处理被强制转为非流式的响应)
+			var rawObj map[string]interface{}
+			if json.Unmarshal([]byte(trimmedLine), &rawObj) == nil {
+				// 尝试从 JSON 中提取内容
+				var content string
+				if val, ok := rawObj["text"].(string); ok {
+					content = val
+				} else if val, ok := rawObj["content"].(string); ok {
+					content = val
+				} else if val, ok := rawObj["response"].(string); ok {
+					content = val
+				}
+
+				if content != "" {
+					// 构造并发送 SSE chunk
+					chunk := model.ChatCompletionChunk{
+						ID:      id,
+						Object:  "chat.completion.chunk",
+						Created: timestamp,
+						Model:   modelID,
+						Choices: []model.StreamChoice{
+							{
+								Index: 0,
+								Delta: model.ChatMessage{
+									Content: content,
+								},
+								FinishReason: nil,
+							},
+						},
+					}
+					newBytes, _ := json.Marshal(chunk)
+					fmt.Fprintf(w, "data: %s\n\n", string(newBytes))
+
+					// 发送结束标记
+					fmt.Fprintf(w, "data: [DONE]\n\n")
+					flusher.Flush()
+					return nil
+				}
+			}
+
+			// 非 data 行直接通过
+			fmt.Fprint(w, line)
+			flusher.Flush()
+			continue
+		}
+
+		data := strings.TrimPrefix(trimmedLine, "data: ")
+		if data == "[DONE]" {
+			fmt.Fprintf(w, "data: [DONE]\n\n")
+			flusher.Flush()
+			return nil
+		}
+
+		// 尝试解析 JSON
+		var raw map[string]interface{}
+		if err := json.Unmarshal([]byte(data), &raw); err != nil {
+			// 解析失败，直接透传
+			fmt.Fprint(w, line)
+			flusher.Flush()
+			continue
+		}
+
+		// 检查是否已经是 OpenAI 格式
+		if _, hasChoices := raw["choices"]; hasChoices {
+			fmt.Fprint(w, line)
+			flusher.Flush()
+			continue
+		}
+
+		// 尝试转换非标准格式
+		// 假设可能有 text, content, response 等字段
+		var content string
+		if val, ok := raw["text"].(string); ok {
+			content = val
+		} else if val, ok := raw["content"].(string); ok {
+			content = val
+		} else if val, ok := raw["response"].(string); ok {
+			content = val
+		}
+
+		if content != "" {
+			// 构造标准 OpenAI Chunk
+			chunk := model.ChatCompletionChunk{
+				ID:      id,
+				Object:  "chat.completion.chunk",
+				Created: timestamp,
+				Model:   modelID,
+				Choices: []model.StreamChoice{
+					{
+						Index: 0,
+						Delta: model.ChatMessage{
+							Content: content,
+						},
+						FinishReason: nil,
+					},
+				},
+			}
+
+			newBytes, _ := json.Marshal(chunk)
+			fmt.Fprintf(w, "data: %s\n\n", string(newBytes))
+			flusher.Flush()
+		} else {
+			// 无法识别内容，直接透传
+			fmt.Fprint(w, line)
+			flusher.Flush()
+		}
+	}
+}
+
+// ResponsesProxy 代理responses请求
+func (s *OpenAIService) ResponsesProxy(ctx context.Context, w http.ResponseWriter, body []byte) error {
+	resp, err := s.Responses(ctx, body)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	return StreamResponse(w, resp)
+}
+
+// retryWithProxy 使用代理池重试OpenAI请求
+func (s *OpenAIService) retryWithProxy(ctx context.Context, account *model.Account, modelID, path string, body []byte) (*http.Response, error) {
+	// 获取模型配置
+	zenModel, exists := model.GetZenModel(modelID)
+	if !exists {
+		return nil, fmt.Errorf("模型配置不存在: %s", modelID)
+	}
+
+	proxyPool := provider.GetProxyPool()
+	if !proxyPool.HasProxies() {
+		return nil, fmt.Errorf("没有可用的代理")
+	}
+
+	maxRetries := 3
+	for i := 0; i < maxRetries; i++ {
+		// 获取随机代理
+		proxyURL := proxyPool.GetRandomProxy()
+		if proxyURL == "" {
+			continue
+		}
+
+		log.Printf("[OpenAI] 尝试代理 %s (重试 %d/%d)", proxyURL, i+1, maxRetries)
+
+		// 创建使用代理的HTTP客户端
+		proxyClient, err := provider.NewHTTPClientWithProxy(proxyURL, 0)
+		if err != nil {
+			log.Printf("[OpenAI] 创建代理客户端失败: %v", err)
+			continue
+		}
+
+		// 将模型参数合并到请求体中
+		modifiedBody := body
+		if zenModel.Parameters != nil {
+			var raw map[string]interface{}
+			if json.Unmarshal(modifiedBody, &raw) == nil {
+				// 添加 reasoning 配置
+				if zenModel.Parameters.Reasoning != nil && raw["reasoning"] == nil {
+					reasoningMap := map[string]interface{}{
+						"effort": zenModel.Parameters.Reasoning.Effort,
+					}
+					if zenModel.Parameters.Reasoning.Summary != "" {
+						reasoningMap["summary"] = zenModel.Parameters.Reasoning.Summary
+					}
+					raw["reasoning"] = reasoningMap
+				}
+				
+				// 添加 text 配置
+				if zenModel.Parameters.Text != nil && raw["text"] == nil {
+					raw["text"] = map[string]interface{}{
+						"verbosity": zenModel.Parameters.Text.Verbosity,
+					}
+				}
+				
+				// 添加 temperature 配置
+				if zenModel.Parameters.Temperature != nil && raw["temperature"] == nil {
+					raw["temperature"] = *zenModel.Parameters.Temperature
+				}
+				
+				modifiedBody, _ = json.Marshal(raw)
+			}
+		}
+
+		// 特殊模型的额外处理
+		if modelID == "gpt-5-nano-2025-08-07" {
+			var raw map[string]interface{}
+			if json.Unmarshal(modifiedBody, &raw) == nil {
+				if _, ok := raw["text"]; !ok {
+					raw["text"] = map[string]string{"verbosity": "medium"}
+				}
+				if _, ok := raw["temperature"]; !ok {
+					raw["temperature"] = 1
+				}
+				raw["stream"] = true
+				if reasoning, ok := raw["reasoning"].(map[string]interface{}); ok {
+					reasoning["summary"] = "auto"
+					raw["reasoning"] = reasoning
+				} else {
+					raw["reasoning"] = map[string]interface{}{
+						"effort":  "minimal",
+						"summary": "auto",
+					}
+				}
+				modifiedBody, _ = json.Marshal(raw)
+			}
+		}
+
+		// 创建新请求
+		reqURL := OpenAIBaseURL + path
+		httpReq, err := http.NewRequest("POST", reqURL, bytes.NewReader(modifiedBody))
+		if err != nil {
+			log.Printf("[OpenAI] 创建请求失败: %v", err)
+			continue
+		}
+
+		// 设置请求头
+		SetZencoderHeaders(httpReq, account, zenModel)
+
+		// 添加模型配置的额外请求头
+		if zenModel.Parameters != nil && zenModel.Parameters.ExtraHeaders != nil {
+			for k, v := range zenModel.Parameters.ExtraHeaders {
+				httpReq.Header.Set(k, v)
+			}
+		}
+
+		// 强制记录代理请求体用于调试
+		log.Printf("[DEBUG] [OpenAI] 代理请求体:")
+		log.Printf("[DEBUG] [OpenAI] %s", string(modifiedBody))
+
+		// 执行请求
+		resp, err := proxyClient.Do(httpReq)
+		if err != nil {
+			log.Printf("[OpenAI] 代理请求失败: %v", err)
+			continue
+		}
+
+		// 检查响应状态
+		if resp.StatusCode == 429 {
+			// 仍然是429，尝试下一个代理
+			resp.Body.Close()
+			log.Printf("[OpenAI] 代理 %s 仍返回429，尝试下一个", proxyURL)
+			continue
+		}
+
+		if resp.StatusCode >= 400 {
+			// 其他错误，记录并尝试下一个代理
+			errBody, _ := io.ReadAll(resp.Body)
+			resp.Body.Close()
+			log.Printf("[OpenAI] 代理 %s 返回错误 %d: %s", proxyURL, resp.StatusCode, string(errBody))
+			continue
+		}
+
+		// 成功
+		log.Printf("[OpenAI] 代理 %s 请求成功", proxyURL)
+		return resp, nil
+	}
+
+	return nil, fmt.Errorf("所有代理重试均失败")
+}

internal/service/pool.go

@@ -0,0 +1,766 @@
+package service
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"sync"
+	"time"
+
+	"zencoder-2api/internal/database"
+	"zencoder-2api/internal/model"
+)
+
+type AccountPool struct {
+	mu       sync.RWMutex
+	accounts []*model.Account
+	index    uint64
+	maxErrs  int
+	stopChan chan struct{}
+}
+
+var pool *AccountPool
+
+func init() {
+	pool = &AccountPool{
+		maxErrs:  3,
+		accounts: make([]*model.Account, 0),
+		stopChan: make(chan struct{}),
+	}
+}
+
+// InitAccountPool 初始化账号池并启动刷新协程
+func InitAccountPool() {
+	// 数据迁移：将旧字段状态迁移到 Status
+	pool.migrateData()
+	
+	// 初始加载
+	pool.refresh()
+	// 启动后台刷新
+	go pool.refreshLoop()
+}
+
+func (p *AccountPool) migrateData() {
+	db := database.GetDB()
+	// 默认设为 normal
+	db.Model(&model.Account{}).Where("status = '' OR status IS NULL").Update("status", "normal")
+	
+	// 迁移冷却状态
+	db.Model(&model.Account{}).Where("is_cooling = ?", true).Update("status", "cooling")
+	
+	// 迁移错误封禁状态
+	db.Model(&model.Account{}).Where("is_active = ? AND error_count >= ?", false, p.maxErrs).Update("status", "error")
+	
+	// 迁移手动禁用状态 (!Active && !Cooling && Error < Max)
+	db.Model(&model.Account{}).Where("is_active = ? AND is_cooling = ? AND error_count < ?", false, false, p.maxErrs).Update("status", "disabled")
+	
+	// 迁移 category 到 status (如果 category 是 banned/error/cooling/abnormal)
+	db.Model(&model.Account{}).Where("category = ?", "banned").Update("status", "banned")
+	db.Model(&model.Account{}).Where("category = ?", "error").Update("status", "error")
+	db.Model(&model.Account{}).Where("category = ?", "cooling").Update("status", "cooling")
+	db.Model(&model.Account{}).Where("category = ?", "abnormal").Update("status", "cooling")
+}
+
+func (p *AccountPool) refreshLoop() {
+	ticker := time.NewTicker(30 * time.Second)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ticker.C:
+			p.refresh()
+			p.cleanupTimeoutAccounts() // 清理超时账号
+		case <-p.stopChan:
+			return
+		}
+	}
+}
+
+// cleanupTimeoutAccounts 定期清理超时的账号状态
+func (p *AccountPool) cleanupTimeoutAccounts() {
+	now := time.Now()
+	statusMu.Lock()
+	defer statusMu.Unlock()
+	
+	cleanedCount := 0
+	for _, status := range accountStatuses {
+		// 清理超过60秒还在使用中的账号
+		if status.InUse && !status.InUseSince.IsZero() && now.Sub(status.InUseSince) > 60*time.Second {
+			status.InUse = false
+			status.InUseSince = time.Time{}
+			cleanedCount++
+		}
+	}
+	
+	if cleanedCount > 0 {
+		log.Printf("[INFO] 定期清理：释放了 %d 个超时账号", cleanedCount)
+	}
+}
+
+func (p *AccountPool) refresh() {
+	// 先恢复冷却账号
+	recoverCoolingAccounts()
+
+	// 刷新即将过期的token（1小时内过期）
+	p.refreshExpiredTokens()
+
+	var dbAccounts []model.Account
+	// 只查询状态为 normal 的账号
+	result := database.GetDB().Where("status = ?", "normal").
+		Where("token_expiry > ?", time.Now()).
+		Find(&dbAccounts)
+
+	if result.Error != nil {
+		log.Printf("[Error] Failed to refresh account pool: %v", result.Error)
+		return
+	}
+
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	// 重新构建缓存，但保留现有对象的指针以维持状态（如果ID匹配）
+	// 或者简单全量替换，依赖 30s 的一致性窗口
+	// 为了简化并防止并发问题，这里使用全量替换，将 DB 数据作为 Source of Truth
+	newAccounts := make([]*model.Account, len(dbAccounts))
+	for i := range dbAccounts {
+		newAccounts[i] = &dbAccounts[i]
+	}
+	
+	// 如果账号数量有显著变化，记录日志
+	oldCount := len(p.accounts)
+	newCount := len(newAccounts)
+	if oldCount != newCount {
+		log.Printf("[AccountPool] 账号池刷新：%d -> %d 个可用账号", oldCount, newCount)
+	}
+	
+	p.accounts = newAccounts
+}
+
+// refreshExpiredTokens 刷新即将过期的账号token
+func (p *AccountPool) refreshExpiredTokens() {
+	now := time.Now()
+	threshold := now.Add(time.Hour) // 1小时内即将过期的token
+
+	var expiredAccounts []model.Account
+	// 只排除banned状态的账号，其他状态的账号仍可以刷新token
+	result := database.GetDB().Where("status != ?", "banned").
+		Where("client_id != '' AND client_secret != ''").
+		Where("token_expiry < ?", threshold).
+		Find(&expiredAccounts)
+
+	if result.Error != nil {
+		log.Printf("[AccountPool] 查询即将过期的账号失败: %v", result.Error)
+		return
+	}
+
+	// 额外验证：再次过滤掉banned状态的账号
+	var validAccounts []model.Account
+	for _, acc := range expiredAccounts {
+		if acc.Status != "banned" {
+			validAccounts = append(validAccounts, acc)
+		}
+	}
+	expiredAccounts = validAccounts
+
+	if len(expiredAccounts) == 0 {
+		return
+	}
+
+	log.Printf("[AccountPool] 发现 %d 个非封禁账号的token需要刷新", len(expiredAccounts))
+
+	// 限制并发刷新数量，避免对API造成压力
+	semaphore := make(chan struct{}, 10) // 最多10个并发
+	var refreshCount int32
+	var successCount int32
+
+	// 并发刷新token
+	for i := range expiredAccounts {
+		account := &expiredAccounts[i]
+		
+		go func(acc *model.Account) {
+			semaphore <- struct{}{} // 获取信号量
+			defer func() { <-semaphore }() // 释放信号量
+			
+			refreshCount++
+			
+			// 根据账号类型选择不同的刷新方式
+			if acc.ClientSecret == "refresh-token-login" {
+				// refresh-token-login 账号使用 refresh_token 刷新
+				if err := p.refreshRefreshTokenAccount(acc); err != nil {
+					log.Printf("[AccountPool] refresh-token账号 %s (ID:%d) token刷新失败: %v",
+						acc.ClientID, acc.ID, err)
+				} else {
+					successCount++
+					log.Printf("[AccountPool] refresh-token账号 %s (ID:%d) token刷新成功，新过期时间: %s",
+						acc.ClientID, acc.ID, acc.TokenExpiry.Format("2006-01-02 15:04:05"))
+				}
+			} else {
+				// 普通账号使用 OAuth client credentials 刷新
+				if err := p.refreshSingleAccountToken(acc); err != nil {
+					log.Printf("[AccountPool] 账号 %s (ID:%d) token刷新失败: %v",
+						acc.ClientID, acc.ID, err)
+				} else {
+					successCount++
+					log.Printf("[AccountPool] 账号 %s (ID:%d) token刷新成功，新过期时间: %s",
+						acc.ClientID, acc.ID, acc.TokenExpiry.Format("2006-01-02 15:04:05"))
+				}
+			}
+		}(account)
+	}
+
+	// 等待所有刷新完成（最多等待30秒）
+	timeout := time.After(30 * time.Second)
+	ticker := time.NewTicker(100 * time.Millisecond)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-timeout:
+			log.Printf("[AccountPool] Token刷新超时，已完成 %d/%d", refreshCount, len(expiredAccounts))
+			return
+		case <-ticker.C:
+			if int(refreshCount) >= len(expiredAccounts) {
+				log.Printf("[AccountPool] Token刷新完成：成功 %d/%d", successCount, len(expiredAccounts))
+				return
+			}
+		}
+	}
+}
+
+// refreshSingleAccountToken 刷新单个账号的token
+func (p *AccountPool) refreshSingleAccountToken(account *model.Account) error {
+	return refreshAccountToken(account)
+}
+
+func GetNextAccount() (*model.Account, error) {
+	return GetNextAccountForModel("")
+}
+
+// AccountStatus 账号运行时状态
+type AccountStatus struct {
+	LastUsed       time.Time
+	InUse          bool
+	FrozenUntil    time.Time
+	InUseSince     time.Time // 记录开始使用的时间
+}
+
+// 账号运行时状态管理
+var (
+	accountStatuses = make(map[uint]*AccountStatus)
+	statusMu        sync.RWMutex
+)
+
+// GetNextAccountForModel 获取可用于指定模型的账号
+// 使用内存状态管理，避免高并发下的竞态条件
+func GetNextAccountForModel(modelID string) (*model.Account, error) {
+	pool.mu.RLock()
+	accounts := pool.accounts // 获取账号列表引用
+	pool.mu.RUnlock()
+
+	if len(accounts) == 0 {
+		return nil, ErrNoAvailableAccount
+	}
+
+	// 获取候选账号
+	var candidates []*model.Account
+	now := time.Now()
+	statusMu.RLock()
+	for _, acc := range accounts {
+		// 检查模型权限
+		if modelID != "" && !model.CanUseModel(acc.PlanType, modelID) {
+			continue
+		}
+		
+		// 获取或初始化状态
+		status, exists := accountStatuses[acc.ID]
+		if !exists {
+			// 初始化状态
+			accountStatuses[acc.ID] = &AccountStatus{
+				LastUsed:    acc.LastUsed,
+				InUse:       false,
+				FrozenUntil: acc.CoolingUntil,
+				InUseSince:  time.Time{},
+			}
+			status = accountStatuses[acc.ID]
+		}
+		
+		// 自动释放超时账号（超过30秒未释放的账号）
+		if status.InUse && !status.InUseSince.IsZero() && now.Sub(status.InUseSince) > 30*time.Second {
+			status.InUse = false
+			status.InUseSince = time.Time{}
+			log.Printf("[WARN] 账号 %s (ID:%d) 使用超时，已自动释放", acc.Email, acc.ID)
+		}
+		
+		// 检查是否可用（未被使用且未被冻结）
+		if !status.InUse && now.After(status.FrozenUntil) {
+			candidates = append(candidates, acc)
+		}
+	}
+	statusMu.RUnlock()
+
+	if len(candidates) == 0 {
+		// 提供详细的调试信息
+		totalAccounts := len(accounts)
+		inUseCount := 0
+		frozenCount := 0
+		noPermissionCount := 0
+		
+		statusMu.RLock()
+		for _, acc := range accounts {
+			if modelID != "" && !model.CanUseModel(acc.PlanType, modelID) {
+				noPermissionCount++
+				continue
+			}
+			
+			if status, exists := accountStatuses[acc.ID]; exists {
+				if status.InUse {
+					inUseCount++
+				} else if !now.After(status.FrozenUntil) {
+					frozenCount++
+				}
+			}
+		}
+		statusMu.RUnlock()
+		
+		log.Printf("[ERROR] 无可用账号 - 总账号数: %d, 权限不足: %d, 使用中: %d, 冻结中: %d, 模型: %s",
+			totalAccounts, noPermissionCount, inUseCount, frozenCount, modelID)
+			
+		return nil, ErrNoPermission
+	}
+
+	// 选择最长时间未使用的账号
+	var selected *model.Account
+	oldestTime := time.Now()
+	
+	statusMu.RLock()
+	for _, acc := range candidates {
+		status := accountStatuses[acc.ID]
+		if status == nil {
+			continue
+		}
+		
+		// 如果账号从未使用过，优先选择
+		if status.LastUsed.IsZero() {
+			selected = acc
+			break
+		}
+		// 选择最长时间未使用的账号
+		if status.LastUsed.Before(oldestTime) {
+			oldestTime = status.LastUsed
+			selected = acc
+		}
+	}
+	statusMu.RUnlock()
+	
+	// 如果没有找到合适的账号，使用轮询
+	if selected == nil {
+		selected = candidates[time.Now().UnixNano()%int64(len(candidates))]
+	}
+	
+	// 立即在内存中标记账号为使用中
+	statusMu.Lock()
+	currentTime := time.Now()
+	if status, exists := accountStatuses[selected.ID]; exists {
+		status.InUse = true
+		status.LastUsed = currentTime
+		status.InUseSince = currentTime
+	} else {
+		accountStatuses[selected.ID] = &AccountStatus{
+			LastUsed:    currentTime,
+			InUse:       true,
+			FrozenUntil: time.Time{},
+			InUseSince:  currentTime,
+		}
+	}
+	statusMu.Unlock()
+	
+	// 异步更新数据库
+	go func(acc *model.Account, usedTime time.Time) {
+		database.GetDB().Model(acc).Update("last_used", usedTime)
+	}(selected, time.Now())
+	
+	return selected, nil
+}
+
+// ReleaseAccount 释放账号（标记为未使用）
+func ReleaseAccount(account *model.Account) {
+	if account == nil {
+		return
+	}
+	
+	statusMu.Lock()
+	defer statusMu.Unlock()
+	
+	if status, exists := accountStatuses[account.ID]; exists {
+		status.InUse = false
+		status.InUseSince = time.Time{} // 重置使用开始时间
+	}
+}
+
+// recoverCoolingAccounts 恢复冷却期已过的账号
+func recoverCoolingAccounts() {
+	var coolingAccounts []model.Account
+	// 查询 status = cooling 且时间已到的账号（使用 UTC 时间）
+	nowUTC := time.Now().UTC()
+	database.GetDB().Where("status = ?", "cooling").
+		Where("cooling_until < ?", nowUTC).
+		Find(&coolingAccounts)
+
+	for _, acc := range coolingAccounts {
+		acc.IsCooling = false
+		acc.IsActive = true
+		acc.Category = "normal" // 保持兼容
+		acc.Status = "normal"   // 恢复状态
+		acc.BanReason = ""      // 清除封禁原因
+		database.GetDB().Save(&acc)
+		log.Printf("[INFO] 账号 %s (ID:%d) 冷却期结束，已恢复 (冷却结束时间: %s UTC)",
+			acc.Email, acc.ID, acc.CoolingUntil.Format("2006-01-02 15:04:05"))
+	}
+}
+
+func MarkAccountError(account *model.Account) {
+	account.ErrorCount++
+	if account.ErrorCount >= pool.maxErrs {
+		account.IsActive = false
+		account.Status = "error" // 更新状态
+		account.Category = "error"
+		account.BanReason = "Error count exceeded limit"
+	}
+	database.GetDB().Save(account)
+}
+
+// MarkAccountRateLimited 标记账号遇到 429 限流错误
+func MarkAccountRateLimited(account *model.Account) {
+	account.RateLimitHits++
+	account.IsCooling = true
+	account.IsActive = false
+
+	// 设置冷却时间：1小时（使用UTC时间）
+	account.CoolingUntil = time.Now().UTC().Add(1 * time.Hour)
+
+	// 更新状态
+	oldStatus := account.Status
+	account.Status = "cooling"
+	account.Category = "cooling"
+	account.BanReason = "Rate limited (429)"
+
+	database.GetDB().Save(account)
+
+	log.Printf("[WARN] 账号 %s (ID:%d) 遇到 429 限流 (第 %d 次)，已移至冷却分组，冷却至 %s UTC",
+		account.Email, account.ID, account.RateLimitHits, account.CoolingUntil.Format("2006-01-02 15:04:05"))
+
+	if oldStatus != "cooling" {
+		log.Printf("[INFO] 账号 %s 状态变更: %s -> cooling", account.Email, oldStatus)
+	}
+}
+
+// MarkAccountRateLimitedWithResponse 根据响应头信息处理429限流错误
+func MarkAccountRateLimitedWithResponse(account *model.Account, resp *http.Response) {
+	if resp == nil || resp.Header == nil {
+		// 如果没有响应头，使用默认处理
+		MarkAccountRateLimited(account)
+		return
+	}
+	
+	// 获取响应头中的积分信息
+	periodLimit := resp.Header.Get("Zen-Pricing-Period-Limit")
+	periodCost := resp.Header.Get("Zen-Pricing-Period-Cost")
+	periodEnd := resp.Header.Get("Zen-Pricing-Period-End")
+	
+	// 检查是否为积分耗尽导致的429
+	isQuotaExhausted := false
+	if periodLimit != "" && periodCost != "" {
+		limit := parseFloat(periodLimit)
+		used := parseFloat(periodCost)
+		
+		// 如果使用积分 >= 最大积分，说明积分已满
+		if limit > 0 && used >= limit {
+			isQuotaExhausted = true
+		}
+	}
+	
+	account.RateLimitHits++
+	account.IsCooling = true
+	account.IsActive = false
+	
+	oldStatus := account.Status
+	account.Status = "cooling"
+	account.Category = "cooling"
+	
+	if isQuotaExhausted {
+		// 积分耗尽导致的429，根据periodEnd设置冷却时间
+		if periodEnd != "" {
+			if endTime, err := time.Parse(time.RFC3339, periodEnd); err == nil {
+				account.CoolingUntil = endTime
+				account.BanReason = "Quota exhausted (429)"
+				// 同时更新积分刷新时间
+				account.CreditRefreshTime = endTime
+				
+				log.Printf("[WARN] 账号 %s (ID:%d) 积分耗尽导致429限���，冷却至积分刷新时间: %s UTC",
+					account.Email, account.ID, endTime.Format("2006-01-02 15:04:05"))
+			} else {
+				// 解析失败，使用默认冷却时间
+				account.CoolingUntil = time.Now().UTC().Add(1 * time.Hour)
+				account.BanReason = "Quota exhausted (429) - fallback cooling"
+				
+				log.Printf("[WARN] 账号 %s (ID:%d) 积分耗尽但无法解析刷新时间，使用默认冷却: %s UTC",
+					account.Email, account.ID, account.CoolingUntil.Format("2006-01-02 15:04:05"))
+			}
+		} else {
+			// 没有periodEnd，使用默认冷却时间
+			account.CoolingUntil = time.Now().UTC().Add(1 * time.Hour)
+			account.BanReason = "Quota exhausted (429) - no end time"
+			
+			log.Printf("[WARN] 账号 %s (ID:%d) 积分耗尽但无刷新时间信息，使用默认冷却: %s UTC",
+				account.Email, account.ID, account.CoolingUntil.Format("2006-01-02 15:04:05"))
+		}
+	} else {
+		// 常规429限流错误，使用默认冷却时间
+		account.CoolingUntil = time.Now().UTC().Add(1 * time.Hour)
+		account.BanReason = "Rate limited (429)"
+		
+		log.Printf("[WARN] 账号 %s (ID:%d) 遇到常规429限流 (第 %d 次)，冷却至: %s UTC",
+			account.Email, account.ID, account.RateLimitHits, account.CoolingUntil.Format("2006-01-02 15:04:05"))
+	}
+	
+	database.GetDB().Save(account)
+	
+	if oldStatus != "cooling" {
+		log.Printf("[INFO] 账号 %s 状态变更: %s -> cooling", account.Email, oldStatus)
+	}
+}
+
+// MarkAccountRateLimitedShort 标记账号遇到 429 限流错误（短期冷却）
+func MarkAccountRateLimitedShort(account *model.Account) {
+	account.RateLimitHits++
+	account.IsCooling = true
+	account.IsActive = false
+
+	// 设置短期冷却时间：5秒（使用UTC时间）
+	account.CoolingUntil = time.Now().UTC().Add(5 * time.Second)
+
+	// 更新状态
+	account.Status = "cooling"
+	account.Category = "cooling"
+	account.BanReason = "Rate limited (429) - short cooling"
+
+	database.GetDB().Save(account)
+	
+	log.Printf("[INFO] 账号 %s (ID:%d) 短期冷却，冷却至 %s UTC",
+		account.Email, account.ID, account.CoolingUntil.Format("2006-01-02 15:04:05"))
+}
+
+// FreezeAccount 冻结账号指定时间（用于500错误限速）
+func FreezeAccount(account *model.Account, duration time.Duration) {
+	if account == nil {
+		return
+	}
+	
+	freezeUntil := time.Now().Add(duration)
+	
+	// 立即在内存中更新冻结状态
+	statusMu.Lock()
+	if status, exists := accountStatuses[account.ID]; exists {
+		status.FrozenUntil = freezeUntil
+		status.InUse = false // 释放账号
+		status.InUseSince = time.Time{} // 重置使用开始时间
+	} else {
+		accountStatuses[account.ID] = &AccountStatus{
+			LastUsed:    time.Now(),
+			InUse:       false,
+			FrozenUntil: freezeUntil,
+			InUseSince:  time.Time{},
+		}
+	}
+	statusMu.Unlock()
+	
+	// 异步更新数据库
+	go func() {
+		// 设置冷却时间（使用UTC时间）
+		account.CoolingUntil = freezeUntil.UTC()
+		account.IsCooling = true
+		account.IsActive = false
+		
+		// 更新状态
+		account.Status = "cooling"
+		account.Category = "cooling"
+		account.BanReason = "Rate limit tracking problem (500)"
+		
+		database.GetDB().Save(account)
+	}()
+}
+
+func ResetAccountError(account *model.Account) {
+	account.ErrorCount = 0
+	database.GetDB().Save(account)
+}
+
+// 扣减积分并检查是否需要冷却
+func UseCredit(account *model.Account, multiplier float64) {
+	account.DailyUsed += multiplier
+	account.TotalUsed += multiplier
+	account.LastUsed = time.Now()  // 更新最后使用时间
+
+	limit := float64(model.PlanLimits[account.PlanType])
+	if account.DailyUsed >= limit {
+		account.IsCooling = true
+		account.Status = "cooling" // 更新状态
+		account.Category = "cooling"
+		account.BanReason = "Daily quota exceeded"
+	}
+
+	database.GetDB().Save(account)
+}
+
+// UpdateAccountCreditsFromResponse 根据响应头中的积分信息更新账号
+// 如果响应头中有积分信息，使用实际值；否则使用模型倍率
+func UpdateAccountCreditsFromResponse(account *model.Account, resp *http.Response, modelMultiplier float64) {
+	// 无论如何都要更新最后使用时间
+	account.LastUsed = time.Now()
+	
+	if resp == nil || resp.Header == nil {
+		// 如果没有响应头，使用模型倍率
+		UseCredit(account, modelMultiplier)
+		return
+	}
+	
+	// 获取响应头中的积分信息
+	periodLimit := resp.Header.Get("Zen-Pricing-Period-Limit")
+	periodCost := resp.Header.Get("Zen-Pricing-Period-Cost")
+	requestCost := resp.Header.Get("Zen-Request-Cost")
+	periodEnd := resp.Header.Get("Zen-Pricing-Period-End")
+	
+	// 解析本次请求消耗的积分
+	var creditUsed float64
+	hasAPICredits := false
+	
+	if requestCost != "" {
+		if val := parseFloat(requestCost); val > 0 {
+			creditUsed = val
+			hasAPICredits = true
+		}
+	}
+	
+	// 如果有 periodCost，更新账号的总使用量（当日总计）
+	if periodCost != "" {
+		if val := parseFloat(periodCost); val >= 0 {
+			// 直接使用API返回的当日使用量
+			account.DailyUsed = val
+			hasAPICredits = true
+		}
+	}
+	
+	// 如果有 periodLimit，可以用于验证账号计划类型
+	if periodLimit != "" {
+		if limit := parseFloat(periodLimit); limit > 0 {
+			// 可选：验证或更新账号的计划类型
+			// 这里只记录日志，不改变计划类型
+			expectedLimit := float64(model.PlanLimits[account.PlanType])
+			if limit != expectedLimit && IsDebugMode() {
+				log.Printf("[INFO] 账号 %s (ID:%d) API限额(%v)与本地限额(%v)不一致",
+					account.Email, account.ID, limit, expectedLimit)
+			}
+		}
+	}
+	
+	// 解析冷却到期时间（UTC时间）和积分刷新时间
+	var coolingEndTime time.Time
+	if periodEnd != "" {
+		if t, err := time.Parse(time.RFC3339, periodEnd); err == nil {
+			coolingEndTime = t
+			// 同时更新积分刷新时间
+			account.CreditRefreshTime = t
+		} else {
+			// 如果解析失败，记录日志
+			log.Printf("[WARN] 无法解析 Zen-Pricing-Period-End: %s, error: %v", periodEnd, err)
+		}
+	}
+	
+	if hasAPICredits {
+		// 使用API返回的积分值
+		if requestCost != "" && creditUsed > 0 {
+			account.TotalUsed += creditUsed
+		}
+		
+		// 检查是否需要冷却
+		limit := float64(model.PlanLimits[account.PlanType])
+		if account.DailyUsed >= limit {
+			account.IsCooling = true
+			account.Status = "cooling"
+			account.Category = "cooling"
+			account.BanReason = "Daily quota exceeded"
+			
+			// 如果有响应头中的冷却到期时间，使用它；否则使用默认时间
+			if !coolingEndTime.IsZero() {
+				account.CoolingUntil = coolingEndTime
+				log.Printf("[INFO] 账号 %s (ID:%d) 积分耗尽，进入冷却，到期时间: %s (UTC)",
+					account.Email, account.ID, coolingEndTime.Format("2006-01-02 15:04:05"))
+			} else {
+				// 默认冷却到第二天的 UTC 0点
+				now := time.Now().UTC()
+				tomorrow := now.Add(24 * time.Hour)
+				account.CoolingUntil = time.Date(tomorrow.Year(), tomorrow.Month(), tomorrow.Day(), 0, 0, 0, 0, time.UTC)
+				log.Printf("[INFO] 账号 %s (ID:%d) 积分耗尽，进入冷却至: %s (UTC)",
+					account.Email, account.ID, account.CoolingUntil.Format("2006-01-02 15:04:05"))
+			}
+		}
+		
+		database.GetDB().Save(account)
+		
+		// 输出调试日志（仅在调试模式下）
+		if IsDebugMode() && (requestCost != "" || periodCost != "") {
+			log.Printf("[DEBUG] 使用API积分: 账号=%s, RequestCost=%s, PeriodCost=%s, PeriodLimit=%s, PeriodEnd=%s",
+				account.Email, requestCost, periodCost, periodLimit, periodEnd)
+		}
+	} else {
+		// 没有API积分信息，使用模型倍率（UseCredit 会自动更新 LastUsed）
+		UseCredit(account, modelMultiplier)
+	}
+}
+
+// parseFloat 安全地解析字符串为浮点数
+func parseFloat(s string) float64 {
+	if s == "" {
+		return 0
+	}
+	var val float64
+	_, _ = fmt.Sscanf(s, "%f", &val)
+	return val
+}
+
+// refreshRefreshTokenAccount 使用 refresh_token 刷新账号 token (用于 refresh-token-login 类型的账号)
+func (p *AccountPool) refreshRefreshTokenAccount(account *model.Account) error {
+	if account.RefreshToken == "" {
+		return fmt.Errorf("账号 %s 缺少 refresh_token", account.ClientID)
+	}
+
+	// 调用 zencoder auth API 刷新 token
+	tokenResp, err := RefreshAccessToken(account.RefreshToken, account.Proxy)
+	if err != nil {
+		return fmt.Errorf("调用 zencoder auth API 失败: %w", err)
+	}
+
+	// 计算过期时间
+	expiry := time.Now().Add(time.Duration(tokenResp.ExpiresIn) * time.Second)
+
+	// 更新数据库
+	updates := map[string]interface{}{
+		"access_token":  tokenResp.AccessToken,
+		"refresh_token": tokenResp.RefreshToken,
+		"token_expiry":  expiry,
+		"updated_at":    time.Now(),
+	}
+
+	if err := database.GetDB().Model(&model.Account{}).
+		Where("id = ?", account.ID).
+		Updates(updates).Error; err != nil {
+		return fmt.Errorf("更新数据库失败: %w", err)
+	}
+
+	// 更新内存中的值
+	account.AccessToken = tokenResp.AccessToken
+	account.RefreshToken = tokenResp.RefreshToken
+	account.TokenExpiry = expiry
+
+	return nil
+}

internal/service/provider/anthropic.go

@@ -0,0 +1,164 @@
+package provider
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"github.com/anthropics/anthropic-sdk-go"
+	"github.com/anthropics/anthropic-sdk-go/option"
+	"github.com/anthropics/anthropic-sdk-go/packages/ssestream"
+	"zencoder-2api/internal/model"
+)
+
+const DefaultAnthropicBaseURL = "https://api.anthropic.com"
+
+type AnthropicProvider struct {
+	client *anthropic.Client
+	config Config
+}
+
+func NewAnthropicProvider(cfg Config) *AnthropicProvider {
+	if cfg.BaseURL == "" {
+		cfg.BaseURL = DefaultAnthropicBaseURL
+	}
+
+	opts := []option.RequestOption{
+		option.WithAPIKey(cfg.APIKey),
+		option.WithBaseURL(cfg.BaseURL),
+	}
+
+	for k, v := range cfg.ExtraHeaders {
+		opts = append(opts, option.WithHeader(k, v))
+	}
+
+	if cfg.Proxy != "" {
+		httpClient := NewHTTPClient(cfg.Proxy, 0)
+		opts = append(opts, option.WithHTTPClient(httpClient))
+	}
+
+	return &AnthropicProvider{
+		client: anthropic.NewClient(opts...),
+		config: cfg,
+	}
+}
+
+func (p *AnthropicProvider) Name() string {
+	return "anthropic"
+}
+
+func (p *AnthropicProvider) ValidateToken() error {
+	_, err := p.client.Messages.New(context.Background(), anthropic.MessageNewParams{
+		Model:     anthropic.F(anthropic.ModelClaude3_5SonnetLatest),
+		MaxTokens: anthropic.F(int64(1)),
+		Messages:  anthropic.F([]anthropic.MessageParam{{Role: anthropic.F(anthropic.MessageParamRoleUser), Content: anthropic.F([]anthropic.ContentBlockParamUnion{anthropic.NewTextBlock("hi")})}}),
+	})
+	return err
+}
+
+func (p *AnthropicProvider) Chat(req *model.ChatCompletionRequest) (*model.ChatCompletionResponse, error) {
+	messages := p.convertMessages(req.Messages)
+
+	maxTokens := int64(4096)
+	if req.MaxTokens > 0 {
+		maxTokens = int64(req.MaxTokens)
+	}
+
+	resp, err := p.client.Messages.New(context.Background(), anthropic.MessageNewParams{
+		Model:     anthropic.F(req.Model),
+		MaxTokens: anthropic.F(maxTokens),
+		Messages:  anthropic.F(messages),
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return p.convertResponse(resp), nil
+}
+
+func (p *AnthropicProvider) convertMessages(msgs []model.ChatMessage) []anthropic.MessageParam {
+	var messages []anthropic.MessageParam
+	for _, msg := range msgs {
+		if msg.Role == "system" {
+			continue
+		}
+		role := anthropic.MessageParamRoleUser
+		if msg.Role == "assistant" {
+			role = anthropic.MessageParamRoleAssistant
+		}
+		messages = append(messages, anthropic.MessageParam{
+			Role:    anthropic.F(role),
+			Content: anthropic.F([]anthropic.ContentBlockParamUnion{anthropic.NewTextBlock(msg.Content)}),
+		})
+	}
+	return messages
+}
+
+func (p *AnthropicProvider) convertResponse(resp *anthropic.Message) *model.ChatCompletionResponse {
+	content := ""
+	for _, block := range resp.Content {
+		if block.Type == anthropic.ContentBlockTypeText {
+			content += block.Text
+		}
+	}
+
+	return &model.ChatCompletionResponse{
+		ID:      resp.ID,
+		Object:  "chat.completion",
+		Model:   string(resp.Model),
+		Choices: []model.Choice{{
+			Index:        0,
+			Message:      model.ChatMessage{Role: "assistant", Content: content},
+			FinishReason: string(resp.StopReason),
+		}},
+		Usage: model.Usage{
+			PromptTokens:     int(resp.Usage.InputTokens),
+			CompletionTokens: int(resp.Usage.OutputTokens),
+			TotalTokens:      int(resp.Usage.InputTokens + resp.Usage.OutputTokens),
+		},
+	}
+}
+
+func (p *AnthropicProvider) ChatStream(req *model.ChatCompletionRequest, writer http.ResponseWriter) error {
+	messages := p.convertMessages(req.Messages)
+
+	maxTokens := int64(4096)
+	if req.MaxTokens > 0 {
+		maxTokens = int64(req.MaxTokens)
+	}
+
+	stream := p.client.Messages.NewStreaming(context.Background(), anthropic.MessageNewParams{
+		Model:     anthropic.F(req.Model),
+		MaxTokens: anthropic.F(maxTokens),
+		Messages:  anthropic.F(messages),
+	})
+
+	return p.handleStream(stream, writer)
+}
+
+func (p *AnthropicProvider) handleStream(stream *ssestream.Stream[anthropic.MessageStreamEvent], writer http.ResponseWriter) error {
+	flusher, ok := writer.(http.Flusher)
+	if !ok {
+		return fmt.Errorf("streaming not supported")
+	}
+
+	writer.Header().Set("Content-Type", "text/event-stream")
+	writer.Header().Set("Cache-Control", "no-cache")
+	writer.Header().Set("Connection", "keep-alive")
+
+	for stream.Next() {
+		event := stream.Current()
+		data, _ := json.Marshal(event)
+		fmt.Fprintf(writer, "data: %s\n\n", data)
+		flusher.Flush()
+	}
+
+	if err := stream.Err(); err != nil {
+		return err
+	}
+
+	fmt.Fprintf(writer, "data: [DONE]\n\n")
+	flusher.Flush()
+	return nil
+}

internal/service/provider/client.go

@@ -0,0 +1,69 @@
+package provider
+
+import (
+	"log"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+)
+
+// NewHTTPClient 创建HTTP客户端
+// 支持HTTP和SOCKS5代理
+func NewHTTPClient(proxy string, timeout time.Duration) *http.Client {
+	// 如果代理是SOCKS5格式，使用新的代理客户端创建函数
+	if strings.HasPrefix(proxy, "socks5://") {
+		client, err := NewHTTPClientWithProxy(proxy, timeout)
+		if err != nil {
+			log.Printf("创建SOCKS5代理客户端失败: %v, 使用默认客户端", err)
+			client, _ := NewHTTPClientWithProxy("", timeout)
+			return client
+		}
+		return client
+	}
+	
+	// 原有的HTTP代理逻辑
+	transport := &http.Transport{}
+
+	if proxy != "" {
+		if proxyURL, err := url.Parse(proxy); err == nil {
+			transport.Proxy = http.ProxyURL(proxyURL)
+		}
+	}
+
+	if timeout == 0 {
+		timeout = 600 * time.Second // 10分钟超时，支持长时间流式响应
+	}
+
+	return &http.Client{
+		Transport: transport,
+		Timeout:   timeout,
+	}
+}
+
+// NewHTTPClientWithPoolProxy 使用代理池创建HTTP客户端
+func NewHTTPClientWithPoolProxy(useProxy bool, timeout time.Duration) *http.Client {
+	if !useProxy {
+		// 不使用代理
+		client, _ := NewHTTPClientWithProxy("", timeout)
+		return client
+	}
+	
+	pool := GetProxyPool()
+	if !pool.HasProxies() {
+		// 没有可用代理，使用默认客户端
+		client, _ := NewHTTPClientWithProxy("", timeout)
+		return client
+	}
+	
+	// 获取下一个代理
+	proxyURL := pool.GetNextProxy()
+	client, err := NewHTTPClientWithProxy(proxyURL, timeout)
+	if err != nil {
+		log.Printf("使用代理 %s 创建客户端失败: %v, 使用默认客户端", proxyURL, err)
+		client, _ := NewHTTPClientWithProxy("", timeout)
+		return client
+	}
+	
+	return client
+}

internal/service/provider/errors.go

@@ -0,0 +1,10 @@
+package provider
+
+import "errors"
+
+var (
+	ErrStreamNotSupported = errors.New("streaming not supported")
+	ErrInvalidToken       = errors.New("invalid token")
+	ErrRequestFailed      = errors.New("request failed")
+	ErrUnknownProvider    = errors.New("unknown provider")
+)

internal/service/provider/factory.go

@@ -0,0 +1,27 @@
+package provider
+
+import "fmt"
+
+type ProviderType string
+
+const (
+	ProviderOpenAI    ProviderType = "openai"
+	ProviderAnthropic ProviderType = "anthropic"
+	ProviderGemini    ProviderType = "gemini"
+	ProviderGrok      ProviderType = "grok"
+)
+
+func NewProvider(providerType ProviderType, cfg Config) (Provider, error) {
+	switch providerType {
+	case ProviderOpenAI:
+		return NewOpenAIProvider(cfg), nil
+	case ProviderAnthropic:
+		return NewAnthropicProvider(cfg), nil
+	case ProviderGemini:
+		return NewGeminiProvider(cfg)
+	case ProviderGrok:
+		return NewGrokProvider(cfg), nil
+	default:
+		return nil, fmt.Errorf("%w: %s", ErrUnknownProvider, providerType)
+	}
+}

internal/service/provider/gemini.go

@@ -0,0 +1,124 @@
+package provider
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"github.com/google/generative-ai-go/genai"
+	"google.golang.org/api/option"
+	"zencoder-2api/internal/model"
+)
+
+type GeminiProvider struct {
+	client *genai.Client
+	config Config
+}
+
+func NewGeminiProvider(cfg Config) (*GeminiProvider, error) {
+	ctx := context.Background()
+
+	opts := []option.ClientOption{
+		option.WithAPIKey(cfg.APIKey),
+	}
+
+	if cfg.BaseURL != "" {
+		opts = append(opts, option.WithEndpoint(cfg.BaseURL))
+	}
+
+	client, err := genai.NewClient(ctx, opts...)
+	if err != nil {
+		return nil, err
+	}
+
+	return &GeminiProvider{
+		client: client,
+		config: cfg,
+	}, nil
+}
+
+func (p *GeminiProvider) Name() string {
+	return "gemini"
+}
+
+func (p *GeminiProvider) ValidateToken() error {
+	model := p.client.GenerativeModel("gemini-1.5-flash")
+	_, err := model.GenerateContent(context.Background(), genai.Text("hi"))
+	return err
+}
+
+func (p *GeminiProvider) Chat(req *model.ChatCompletionRequest) (*model.ChatCompletionResponse, error) {
+	geminiModel := p.client.GenerativeModel(req.Model)
+
+	var parts []genai.Part
+	for _, msg := range req.Messages {
+		parts = append(parts, genai.Text(msg.Content))
+	}
+
+	resp, err := geminiModel.GenerateContent(context.Background(), parts...)
+	if err != nil {
+		return nil, err
+	}
+
+	return p.convertResponse(resp, req.Model), nil
+}
+
+func (p *GeminiProvider) convertResponse(resp *genai.GenerateContentResponse, modelName string) *model.ChatCompletionResponse {
+	content := ""
+	if len(resp.Candidates) > 0 && resp.Candidates[0].Content != nil {
+		for _, part := range resp.Candidates[0].Content.Parts {
+			if text, ok := part.(genai.Text); ok {
+				content += string(text)
+			}
+		}
+	}
+
+	return &model.ChatCompletionResponse{
+		ID:      "gemini-" + modelName,
+		Object:  "chat.completion",
+		Model:   modelName,
+		Choices: []model.Choice{{
+			Index:        0,
+			Message:      model.ChatMessage{Role: "assistant", Content: content},
+			FinishReason: "stop",
+		}},
+	}
+}
+
+func (p *GeminiProvider) ChatStream(req *model.ChatCompletionRequest, writer http.ResponseWriter) error {
+	geminiModel := p.client.GenerativeModel(req.Model)
+
+	var parts []genai.Part
+	for _, msg := range req.Messages {
+		parts = append(parts, genai.Text(msg.Content))
+	}
+
+	iter := geminiModel.GenerateContentStream(context.Background(), parts...)
+	return p.handleStream(iter, writer)
+}
+
+func (p *GeminiProvider) handleStream(iter *genai.GenerateContentResponseIterator, writer http.ResponseWriter) error {
+	flusher, ok := writer.(http.Flusher)
+	if !ok {
+		return fmt.Errorf("streaming not supported")
+	}
+
+	writer.Header().Set("Content-Type", "text/event-stream")
+	writer.Header().Set("Cache-Control", "no-cache")
+	writer.Header().Set("Connection", "keep-alive")
+
+	for {
+		resp, err := iter.Next()
+		if err != nil {
+			break
+		}
+		data, _ := json.Marshal(resp)
+		fmt.Fprintf(writer, "data: %s\n\n", data)
+		flusher.Flush()
+	}
+
+	fmt.Fprintf(writer, "data: [DONE]\n\n")
+	flusher.Flush()
+	return nil
+}

internal/service/provider/grok.go

@@ -0,0 +1,149 @@
+package provider
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"github.com/openai/openai-go"
+	"github.com/openai/openai-go/option"
+	"github.com/openai/openai-go/packages/ssestream"
+	"zencoder-2api/internal/model"
+)
+
+const DefaultGrokBaseURL = "https://api.x.ai/v1"
+
+type GrokProvider struct {
+	client *openai.Client
+	config Config
+}
+
+func NewGrokProvider(cfg Config) *GrokProvider {
+	if cfg.BaseURL == "" {
+		cfg.BaseURL = DefaultGrokBaseURL
+	}
+
+	opts := []option.RequestOption{
+		option.WithAPIKey(cfg.APIKey),
+		option.WithBaseURL(cfg.BaseURL),
+	}
+
+	for k, v := range cfg.ExtraHeaders {
+		opts = append(opts, option.WithHeader(k, v))
+	}
+
+	if cfg.Proxy != "" {
+		httpClient := NewHTTPClient(cfg.Proxy, 0)
+		opts = append(opts, option.WithHTTPClient(httpClient))
+	}
+
+	return &GrokProvider{
+		client: openai.NewClient(opts...),
+		config: cfg,
+	}
+}
+
+func (p *GrokProvider) Name() string {
+	return "grok"
+}
+
+func (p *GrokProvider) ValidateToken() error {
+	_, err := p.client.Models.List(context.Background())
+	return err
+}
+
+func (p *GrokProvider) Chat(req *model.ChatCompletionRequest) (*model.ChatCompletionResponse, error) {
+	messages := make([]openai.ChatCompletionMessageParamUnion, len(req.Messages))
+	for i, msg := range req.Messages {
+		switch msg.Role {
+		case "system":
+			messages[i] = openai.SystemMessage(msg.Content)
+		case "user":
+			messages[i] = openai.UserMessage(msg.Content)
+		case "assistant":
+			messages[i] = openai.AssistantMessage(msg.Content)
+		}
+	}
+
+	resp, err := p.client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
+		Model:    openai.F(req.Model),
+		Messages: openai.F(messages),
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return p.convertResponse(resp), nil
+}
+
+func (p *GrokProvider) convertResponse(resp *openai.ChatCompletion) *model.ChatCompletionResponse {
+	choices := make([]model.Choice, len(resp.Choices))
+	for i, c := range resp.Choices {
+		choices[i] = model.Choice{
+			Index:        int(c.Index),
+			Message:      model.ChatMessage{Role: string(c.Message.Role), Content: c.Message.Content},
+			FinishReason: string(c.FinishReason),
+		}
+	}
+
+	return &model.ChatCompletionResponse{
+		ID:      resp.ID,
+		Object:  string(resp.Object),
+		Created: resp.Created,
+		Model:   resp.Model,
+		Choices: choices,
+		Usage: model.Usage{
+			PromptTokens:     int(resp.Usage.PromptTokens),
+			CompletionTokens: int(resp.Usage.CompletionTokens),
+			TotalTokens:      int(resp.Usage.TotalTokens),
+		},
+	}
+}
+
+func (p *GrokProvider) ChatStream(req *model.ChatCompletionRequest, writer http.ResponseWriter) error {
+	messages := make([]openai.ChatCompletionMessageParamUnion, len(req.Messages))
+	for i, msg := range req.Messages {
+		switch msg.Role {
+		case "system":
+			messages[i] = openai.SystemMessage(msg.Content)
+		case "user":
+			messages[i] = openai.UserMessage(msg.Content)
+		case "assistant":
+			messages[i] = openai.AssistantMessage(msg.Content)
+		}
+	}
+
+	stream := p.client.Chat.Completions.NewStreaming(context.Background(), openai.ChatCompletionNewParams{
+		Model:    openai.F(req.Model),
+		Messages: openai.F(messages),
+	})
+
+	return p.handleStream(stream, writer)
+}
+
+func (p *GrokProvider) handleStream(stream *ssestream.Stream[openai.ChatCompletionChunk], writer http.ResponseWriter) error {
+	flusher, ok := writer.(http.Flusher)
+	if !ok {
+		return fmt.Errorf("streaming not supported")
+	}
+
+	writer.Header().Set("Content-Type", "text/event-stream")
+	writer.Header().Set("Cache-Control", "no-cache")
+	writer.Header().Set("Connection", "keep-alive")
+
+	for stream.Next() {
+		chunk := stream.Current()
+		data, _ := json.Marshal(chunk)
+		fmt.Fprintf(writer, "data: %s\n\n", data)
+		flusher.Flush()
+	}
+
+	if err := stream.Err(); err != nil {
+		return err
+	}
+
+	fmt.Fprintf(writer, "data: [DONE]\n\n")
+	flusher.Flush()
+	return nil
+}

internal/service/provider/manager.go

@@ -0,0 +1,73 @@
+package provider
+
+import (
+	"fmt"
+	"sync"
+
+	"zencoder-2api/internal/model"
+)
+
+// Manager Provider管理器，缓存已创建的provider实例
+type Manager struct {
+	mu        sync.RWMutex
+	providers map[string]Provider
+}
+
+var defaultManager = &Manager{
+	providers: make(map[string]Provider),
+}
+
+// GetManager 获取默认管理器
+func GetManager() *Manager {
+	return defaultManager
+}
+
+// GetProvider 根据账号和模型获取或创建Provider
+func (m *Manager) GetProvider(accountID uint, zenModel model.ZenModel, cfg Config) (Provider, error) {
+	key := m.buildKey(accountID, zenModel.ProviderID)
+
+	m.mu.RLock()
+	if p, ok := m.providers[key]; ok {
+		m.mu.RUnlock()
+		return p, nil
+	}
+	m.mu.RUnlock()
+
+	return m.createProvider(key, zenModel.ProviderID, cfg)
+}
+
+func (m *Manager) buildKey(accountID uint, providerID string) string {
+	return fmt.Sprintf("%d:%s", accountID, providerID)
+}
+
+func (m *Manager) createProvider(key, providerID string, cfg Config) (Provider, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	// 双重检查
+	if p, ok := m.providers[key]; ok {
+		return p, nil
+	}
+
+	var providerType ProviderType
+	switch providerID {
+	case "openai":
+		providerType = ProviderOpenAI
+	case "anthropic":
+		providerType = ProviderAnthropic
+	case "gemini":
+		providerType = ProviderGemini
+	case "xai":
+		providerType = ProviderGrok
+	default:
+		providerType = ProviderAnthropic
+	}
+
+	p, err := NewProvider(providerType, cfg)
+	if err != nil {
+		return nil, err
+	}
+
+	m.providers[key] = p
+	return p, nil
+}

internal/service/provider/openai.go

@@ -0,0 +1,149 @@
+package provider
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"github.com/openai/openai-go"
+	"github.com/openai/openai-go/option"
+	"github.com/openai/openai-go/packages/ssestream"
+	"zencoder-2api/internal/model"
+)
+
+const DefaultOpenAIBaseURL = "https://api.openai.com/v1"
+
+type OpenAIProvider struct {
+	client *openai.Client
+	config Config
+}
+
+func NewOpenAIProvider(cfg Config) *OpenAIProvider {
+	if cfg.BaseURL == "" {
+		cfg.BaseURL = DefaultOpenAIBaseURL
+	}
+
+	opts := []option.RequestOption{
+		option.WithAPIKey(cfg.APIKey),
+		option.WithBaseURL(cfg.BaseURL),
+	}
+
+	for k, v := range cfg.ExtraHeaders {
+		opts = append(opts, option.WithHeader(k, v))
+	}
+
+	if cfg.Proxy != "" {
+		httpClient := NewHTTPClient(cfg.Proxy, 0)
+		opts = append(opts, option.WithHTTPClient(httpClient))
+	}
+
+	return &OpenAIProvider{
+		client: openai.NewClient(opts...),
+		config: cfg,
+	}
+}
+
+func (p *OpenAIProvider) Name() string {
+	return "openai"
+}
+
+func (p *OpenAIProvider) ValidateToken() error {
+	_, err := p.client.Models.List(context.Background())
+	return err
+}
+
+func (p *OpenAIProvider) Chat(req *model.ChatCompletionRequest) (*model.ChatCompletionResponse, error) {
+	messages := make([]openai.ChatCompletionMessageParamUnion, len(req.Messages))
+	for i, msg := range req.Messages {
+		switch msg.Role {
+		case "system":
+			messages[i] = openai.SystemMessage(msg.Content)
+		case "user":
+			messages[i] = openai.UserMessage(msg.Content)
+		case "assistant":
+			messages[i] = openai.AssistantMessage(msg.Content)
+		}
+	}
+
+	resp, err := p.client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
+		Model:    openai.F(req.Model),
+		Messages: openai.F(messages),
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return p.convertResponse(resp), nil
+}
+
+func (p *OpenAIProvider) convertResponse(resp *openai.ChatCompletion) *model.ChatCompletionResponse {
+	choices := make([]model.Choice, len(resp.Choices))
+	for i, c := range resp.Choices {
+		choices[i] = model.Choice{
+			Index:        int(c.Index),
+			Message:      model.ChatMessage{Role: string(c.Message.Role), Content: c.Message.Content},
+			FinishReason: string(c.FinishReason),
+		}
+	}
+
+	return &model.ChatCompletionResponse{
+		ID:      resp.ID,
+		Object:  string(resp.Object),
+		Created: resp.Created,
+		Model:   resp.Model,
+		Choices: choices,
+		Usage: model.Usage{
+			PromptTokens:     int(resp.Usage.PromptTokens),
+			CompletionTokens: int(resp.Usage.CompletionTokens),
+			TotalTokens:      int(resp.Usage.TotalTokens),
+		},
+	}
+}
+
+func (p *OpenAIProvider) ChatStream(req *model.ChatCompletionRequest, writer http.ResponseWriter) error {
+	messages := make([]openai.ChatCompletionMessageParamUnion, len(req.Messages))
+	for i, msg := range req.Messages {
+		switch msg.Role {
+		case "system":
+			messages[i] = openai.SystemMessage(msg.Content)
+		case "user":
+			messages[i] = openai.UserMessage(msg.Content)
+		case "assistant":
+			messages[i] = openai.AssistantMessage(msg.Content)
+		}
+	}
+
+	stream := p.client.Chat.Completions.NewStreaming(context.Background(), openai.ChatCompletionNewParams{
+		Model:    openai.F(req.Model),
+		Messages: openai.F(messages),
+	})
+
+	return p.handleStream(stream, writer)
+}
+
+func (p *OpenAIProvider) handleStream(stream *ssestream.Stream[openai.ChatCompletionChunk], writer http.ResponseWriter) error {
+	flusher, ok := writer.(http.Flusher)
+	if !ok {
+		return fmt.Errorf("streaming not supported")
+	}
+
+	writer.Header().Set("Content-Type", "text/event-stream")
+	writer.Header().Set("Cache-Control", "no-cache")
+	writer.Header().Set("Connection", "keep-alive")
+
+	for stream.Next() {
+		chunk := stream.Current()
+		data, _ := json.Marshal(chunk)
+		fmt.Fprintf(writer, "data: %s\n\n", data)
+		flusher.Flush()
+	}
+
+	if err := stream.Err(); err != nil {
+		return err
+	}
+
+	fmt.Fprintf(writer, "data: [DONE]\n\n")
+	flusher.Flush()
+	return nil
+}

internal/service/provider/provider.go

@@ -0,0 +1,77 @@
+package provider
+
+import (
+	"io"
+	"net/http"
+
+	"zencoder-2api/internal/model"
+)
+
+// Config Provider配置
+type Config struct {
+	BaseURL      string            // 自定义请求地址
+	APIKey       string            // API密钥
+	ExtraHeaders map[string]string // 额外请求头
+	Proxy        string            // 代理地址
+}
+
+// Provider AI平台提供者接口
+type Provider interface {
+	// Name 返回提供者名称
+	Name() string
+
+	// Chat 非流式聊天
+	Chat(req *model.ChatCompletionRequest) (*model.ChatCompletionResponse, error)
+
+	// ChatStream 流式聊天
+	ChatStream(req *model.ChatCompletionRequest, writer http.ResponseWriter) error
+
+	// ValidateToken 验证token是否有效
+	ValidateToken() error
+}
+
+// BaseProvider 基础Provider实现
+type BaseProvider struct {
+	Config Config
+	Client *http.Client
+}
+
+// SetHeaders 设置通用请求头
+func (b *BaseProvider) SetHeaders(req *http.Request) {
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", "application/json")
+
+	// 设置额外请求头
+	for k, v := range b.Config.ExtraHeaders {
+		req.Header.Set(k, v)
+	}
+}
+
+// StreamResponse 通用流式响应处理
+func (b *BaseProvider) StreamResponse(body io.Reader, writer http.ResponseWriter) error {
+	flusher, ok := writer.(http.Flusher)
+	if !ok {
+		return ErrStreamNotSupported
+	}
+
+	writer.Header().Set("Content-Type", "text/event-stream")
+	writer.Header().Set("Cache-Control", "no-cache")
+	writer.Header().Set("Connection", "keep-alive")
+
+	buf := make([]byte, 4096)
+	for {
+		n, err := body.Read(buf)
+		if n > 0 {
+			writer.Write(buf[:n])
+			flusher.Flush()
+		}
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

internal/service/provider/proxy.go

@@ -0,0 +1,251 @@
+package provider
+
+import (
+	"context"
+	"fmt"
+	"math/rand"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"strings"
+	"sync"
+	"time"
+
+	"golang.org/x/net/proxy"
+)
+
+// ProxyPool 代理池管理器
+type ProxyPool struct {
+	proxies []string
+	mu      sync.RWMutex
+	index   int
+}
+
+var (
+	globalProxyPool *ProxyPool
+	once           sync.Once
+)
+
+// GetProxyPool 获取全局代理池实例
+func GetProxyPool() *ProxyPool {
+	once.Do(func() {
+		globalProxyPool = NewProxyPool()
+	})
+	return globalProxyPool
+}
+
+// NewProxyPool 创建新的代理池
+func NewProxyPool() *ProxyPool {
+	pool := &ProxyPool{
+		proxies: make([]string, 0),
+	}
+	pool.loadProxiesFromEnv()
+	return pool
+}
+
+// loadProxiesFromEnv 从环境变量加载代理列表
+func (p *ProxyPool) loadProxiesFromEnv() {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	
+	proxyEnv := os.Getenv("SOCKS_PROXY_POOL")
+	if proxyEnv == "" {
+		return
+	}
+	
+	// 解析逗号分隔的代理列表
+	proxiesStr := strings.Split(proxyEnv, ",")
+	for _, proxyStr := range proxiesStr {
+		proxyStr = strings.TrimSpace(proxyStr)
+		if proxyStr != "" {
+			p.proxies = append(p.proxies, proxyStr)
+		}
+	}
+}
+
+// GetNextProxy 获取下一个代理(轮询方式)
+func (p *ProxyPool) GetNextProxy() string {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	
+	if len(p.proxies) == 0 {
+		return ""
+	}
+	
+	proxy := p.proxies[p.index]
+	p.index = (p.index + 1) % len(p.proxies)
+	return proxy
+}
+
+// GetRandomProxy 获取随机代理
+func (p *ProxyPool) GetRandomProxy() string {
+	p.mu.RLock()
+	defer p.mu.RUnlock()
+	
+	if len(p.proxies) == 0 {
+		return ""
+	}
+	
+	index := rand.Intn(len(p.proxies))
+	return p.proxies[index]
+}
+
+// HasProxies 检查是否有可用代理
+func (p *ProxyPool) HasProxies() bool {
+	p.mu.RLock()
+	defer p.mu.RUnlock()
+	return len(p.proxies) > 0
+}
+
+// Count 返回代理数量
+func (p *ProxyPool) Count() int {
+	p.mu.RLock()
+	defer p.mu.RUnlock()
+	return len(p.proxies)
+}
+
+// GetAllProxies 获取所有代理列表(用于测试)
+func (p *ProxyPool) GetAllProxies() []string {
+	p.mu.RLock()
+	defer p.mu.RUnlock()
+	result := make([]string, len(p.proxies))
+	copy(result, p.proxies)
+	return result
+}
+
+// createSOCKS5Transport 创建SOCKS5代理传输层
+func createSOCKS5Transport(proxyURL string, timeout time.Duration) (*http.Transport, error) {
+	// 处理自定义格式：socks5://host:port:username:password
+	// 转换为标准格式：socks5://username:password@host:port
+	if strings.Contains(proxyURL, "socks5://") && strings.Count(proxyURL, ":") == 4 {
+		// 解析自定义格式
+		parts := strings.Split(proxyURL, ":")
+		if len(parts) == 5 {
+			// parts[0] = "socks5", parts[1] = "//host", parts[2] = "port", parts[3] = "username", parts[4] = "password"
+			host := strings.TrimPrefix(parts[1], "//")
+			port := parts[2]
+			username := parts[3]
+			password := parts[4]
+			
+			// 重构为标准URL格式
+			proxyURL = fmt.Sprintf("socks5://%s:%s@%s:%s", username, password, host, port)
+		}
+	}
+	
+	u, err := url.Parse(proxyURL)
+	if err != nil {
+		return nil, fmt.Errorf("解析代理URL失败: %v", err)
+	}
+	
+	if u.Scheme != "socks5" {
+		return nil, fmt.Errorf("仅支持SOCKS5代理")
+	}
+	
+	// 解析用户名和密码
+	var auth *proxy.Auth
+	if u.User != nil {
+		password, _ := u.User.Password()
+		auth = &proxy.Auth{
+			User:     u.User.Username(),
+			Password: password,
+		}
+	}
+	
+	// 创建SOCKS5拨号器
+	dialer, err := proxy.SOCKS5("tcp", u.Host, auth, proxy.Direct)
+	if err != nil {
+		return nil, fmt.Errorf("创建SOCKS5拨号器失败: %v", err)
+	}
+	
+	transport := &http.Transport{
+		DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
+			return dialer.Dial(network, addr)
+		},
+		MaxIdleConns:        100,
+		IdleConnTimeout:     90 * time.Second,
+		TLSHandshakeTimeout: 10 * time.Second,
+	}
+	
+	return transport, nil
+}
+
+// parseCustomProxyURL 解析自定义代理URL格式
+func parseCustomProxyURL(proxyURL string) string {
+	// 处理自定义格式：socks5://host:port:username:password
+	// 转换为标准格式：socks5://username:password@host:port
+	if strings.Contains(proxyURL, "socks5://") && strings.Count(proxyURL, ":") == 4 {
+		// 解析自定义格式
+		parts := strings.Split(proxyURL, ":")
+		if len(parts) == 5 {
+			// parts[0] = "socks5", parts[1] = "//host", parts[2] = "port", parts[3] = "username", parts[4] = "password"
+			host := strings.TrimPrefix(parts[1], "//")
+			port := parts[2]
+			username := parts[3]
+			password := parts[4]
+			
+			// 重构为标准URL格式
+			return fmt.Sprintf("socks5://%s:%s@%s:%s", username, password, host, port)
+		}
+	}
+	return proxyURL
+}
+
+// NewHTTPClientWithProxy 创建带指定代理的HTTP客户端
+func NewHTTPClientWithProxy(proxyURL string, timeout time.Duration) (*http.Client, error) {
+	if timeout == 0 {
+		timeout = 600 * time.Second // 10分钟超时，支持长时间流式响应
+	}
+	
+	if proxyURL == "" {
+		// 没有代理，使用默认客户端
+		return &http.Client{
+			Transport: &http.Transport{
+				DialContext: (&net.Dialer{
+					Timeout:   30 * time.Second,
+					KeepAlive: 30 * time.Second,
+				}).DialContext,
+				MaxIdleConns:        100,
+				IdleConnTimeout:     90 * time.Second,
+				TLSHandshakeTimeout: 10 * time.Second,
+			},
+			Timeout: timeout,
+		}, nil
+	}
+	
+	// 转换自定义格式到标准格式
+	standardURL := parseCustomProxyURL(proxyURL)
+	
+	// 解析代理URL
+	u, err := url.Parse(standardURL)
+	if err != nil {
+		return nil, fmt.Errorf("解析代理URL失败: %v", err)
+	}
+	
+	var transport *http.Transport
+	
+	if u.Scheme == "socks5" {
+		// SOCKS5代理 - 使用转换后的标准URL
+		transport, err = createSOCKS5Transport(standardURL, timeout)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		// HTTP代理
+		transport = &http.Transport{
+			Proxy: http.ProxyURL(u),
+			DialContext: (&net.Dialer{
+				Timeout:   30 * time.Second,
+				KeepAlive: 30 * time.Second,
+			}).DialContext,
+			MaxIdleConns:        100,
+			IdleConnTimeout:     90 * time.Second,
+			TLSHandshakeTimeout: 10 * time.Second,
+		}
+	}
+	
+	return &http.Client{
+		Transport: transport,
+		Timeout:   timeout,
+	}, nil
+}

internal/service/proxy_client.go

@@ -0,0 +1,143 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"zencoder-2api/internal/service/provider"
+)
+
+// ProxyRequestOptions 代理请求选项
+type ProxyRequestOptions struct {
+	UseProxy         bool          // 是否使用代理
+	MaxRetries       int           // 最大重试次数
+	RetryDelay       time.Duration // 重试延迟
+	OnError          func(error) bool // 错误判断函数，返回true表示需要重试
+}
+
+// DefaultProxyRequestOptions 默认代理请求选项
+func DefaultProxyRequestOptions() ProxyRequestOptions {
+	return ProxyRequestOptions{
+		UseProxy:   true,
+		MaxRetries: 3,
+		RetryDelay: time.Second,
+		OnError:    isNetworkError,
+	}
+}
+
+// isNetworkError 判断是否为网络错误（可重试的错误）
+func isNetworkError(err error) bool {
+	if err == nil {
+		return false
+	}
+	
+	errStr := err.Error()
+	
+	// 网络连接错误
+	if strings.Contains(errStr, "connection refused") ||
+		strings.Contains(errStr, "connection reset") ||
+		strings.Contains(errStr, "connection timed out") ||
+		strings.Contains(errStr, "timeout") ||
+		strings.Contains(errStr, "network is unreachable") ||
+		strings.Contains(errStr, "no such host") ||
+		strings.Contains(errStr, "dial tcp") ||
+		strings.Contains(errStr, "i/o timeout") ||
+		strings.Contains(errStr, "EOF") {
+		return true
+	}
+	
+	// SOCKS代理相关错误
+	if strings.Contains(errStr, "socks connect") ||
+		strings.Contains(errStr, "proxy") {
+		return true
+	}
+	
+	return false
+}
+
+// DoRequestWithProxyRetry 执行带代理重试的HTTP请求
+func DoRequestWithProxyRetry(ctx context.Context, req *http.Request, originalProxy string, options ProxyRequestOptions) (*http.Response, error) {
+	// 首先尝试使用原始代理（如果有的话）
+	client := provider.NewHTTPClient(originalProxy, 0)
+	
+	resp, err := client.Do(req)
+	if err == nil {
+		// 请求成功，返回结果
+		return resp, nil
+	}
+	
+	// 检查错误是否可重试
+	if !options.OnError(err) {
+		return nil, err
+	}
+	
+	// 如果不使用代理池，直接返回错误
+	if !options.UseProxy {
+		return nil, err
+	}
+	
+	proxyPool := provider.GetProxyPool()
+	if !proxyPool.HasProxies() {
+		return nil, fmt.Errorf("原始请求失败且无可用代理: %v", err)
+	}
+	
+	var lastErr error = err
+	
+	// 使用代理池进行重试
+	for i := 0; i < options.MaxRetries; i++ {
+		// 获取下一个代理
+		proxyURL := proxyPool.GetNextProxy()
+		if proxyURL == "" {
+			break
+		}
+		
+		// 创建使用代理的HTTP客户端
+		proxyClient, clientErr := provider.NewHTTPClientWithProxy(proxyURL, 0)
+		if clientErr != nil {
+			lastErr = clientErr
+			time.Sleep(options.RetryDelay)
+			continue
+		}
+		
+		// 克隆请求（因为request body可能已经被消费）
+		newReq := req.Clone(ctx)
+		
+		resp, err := proxyClient.Do(newReq)
+		if err == nil {
+			// 请求成功
+			return resp, nil
+		}
+		
+		// 检查错误是否继续重试
+		if !options.OnError(err) {
+			return nil, err
+		}
+		
+		lastErr = err
+		time.Sleep(options.RetryDelay)
+	}
+	
+	return nil, fmt.Errorf("所有代理重试均失败，最后错误: %v", lastErr)
+}
+
+// CreateHTTPClientWithFallback 创建支持代理fallback的HTTP客户端
+func CreateHTTPClientWithFallback(originalProxy string, useProxyPool bool) *http.Client {
+	// 如果不使用代理池，使用原始逻辑
+	if !useProxyPool {
+		return provider.NewHTTPClient(originalProxy, 0)
+	}
+	
+	// 如果有原始代理，先尝试原始代理
+	if originalProxy != "" {
+		client, err := provider.NewHTTPClientWithProxy(originalProxy, 0)
+		if err == nil {
+			return client
+		}
+	}
+	
+	// 使用代理池
+	return provider.NewHTTPClientWithPoolProxy(true, 0)
+}

internal/service/refresh.go

@@ -0,0 +1,764 @@
+package service
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"strings"
+	"time"
+
+	"zencoder-2api/internal/model"
+	"zencoder-2api/internal/database"
+	"zencoder-2api/internal/service/provider"
+)
+
+// RefreshTokenRequest 请求刷新token的结构
+type RefreshTokenRequest struct {
+	GrantType    string `json:"grant_type"`
+	RefreshToken string `json:"refresh_token"`
+}
+
+// RefreshTokenResponse 刷新token的响应结构
+type RefreshTokenResponse struct {
+	TokenType      string                 `json:"token_type"`
+	AccessToken    string                 `json:"access_token"`
+	IDToken        string                 `json:"id_token"`
+	RefreshToken   string                 `json:"refresh_token"`
+	ExpiresIn      int                    `json:"expires_in"`
+	Federated      map[string]interface{} `json:"federated"`
+	
+	// 这些字段可能不在响应中，但我们可以从JWT解析
+	UserID         string `json:"-"`
+	Email          string `json:"-"`
+}
+
+// AccountLockoutError 表示账号被锁定的错误
+type AccountLockoutError struct {
+	StatusCode int
+	Body       string
+	AccountID  string
+}
+
+func (e *AccountLockoutError) Error() string {
+	return fmt.Sprintf("account %s is locked out: status %d, body: %s", e.AccountID, e.StatusCode, e.Body)
+}
+
+// isAccountLockoutError 检查是否是账号锁定错误
+func isAccountLockoutError(statusCode int, body string) bool {
+	if statusCode == 400 {
+		// 检查响应体中是否包含锁定信息
+		return strings.Contains(body, "User is locked out") ||
+		       strings.Contains(body, "user is locked out") ||
+		       strings.Contains(body, "locked out")
+	}
+	return false
+}
+
+// markAccountAsBanned 将账号标记为被封禁状态
+func markAccountAsBanned(account *model.Account, reason string) error {
+	updates := map[string]interface{}{
+		"status":     "banned",
+		"is_active":  false,
+		"is_cooling": false,
+		"ban_reason": reason,
+		"updated_at": time.Now(),
+	}
+	
+	if err := database.GetDB().Model(&model.Account{}).
+		Where("id = ?", account.ID).
+		Updates(updates).Error; err != nil {
+		return fmt.Errorf("failed to update account status: %w", err)
+	}
+	
+	log.Printf("[账号管理] 账号 %s (ID:%d) 已标记为封禁状态: %s", account.ClientID, account.ID, reason)
+	return nil
+}
+
+// isRefreshTokenInvalidError 检查是否是refresh token无效错误
+func isRefreshTokenInvalidError(statusCode int, body string) bool {
+	if statusCode == 401 {
+		return strings.Contains(body, "Refresh token is not valid") ||
+		       strings.Contains(body, "refresh token is not valid") ||
+		       strings.Contains(body, "invalid refresh token") ||
+		       strings.Contains(body, "refresh_token is invalid")
+	}
+	return false
+}
+
+// markTokenRecordAsBanned 将token记录标记为封禁状态
+func markTokenRecordAsBanned(record *model.TokenRecord, reason string) error {
+	updates := map[string]interface{}{
+		"status":      "banned",
+		"is_active":   false,
+		"ban_reason":  reason,
+		"updated_at":  time.Now(),
+	}
+	
+	if err := database.GetDB().Model(&model.TokenRecord{}).
+		Where("id = ?", record.ID).
+		Updates(updates).Error; err != nil {
+		return fmt.Errorf("failed to update token record status: %w", err)
+	}
+	
+	log.Printf("[Token管理] Token记录 #%d 已标记为封禁状态: %s", record.ID, reason)
+	return nil
+}
+
+// markTokenRecordAsExpired 将token记录标记为过期状态
+func markTokenRecordAsExpired(record *model.TokenRecord, reason string) error {
+	updates := map[string]interface{}{
+		"status":      "expired",
+		"is_active":   false,
+		"ban_reason":  reason,
+		"updated_at":  time.Now(),
+	}
+	
+	if err := database.GetDB().Model(&model.TokenRecord{}).
+		Where("id = ?", record.ID).
+		Updates(updates).Error; err != nil {
+		return fmt.Errorf("failed to update token record status: %w", err)
+	}
+	
+	log.Printf("[Token管理] Token记录 #%d 已标记为过期状态: %s", record.ID, reason)
+	return nil
+}
+
+// disableTokenRecordsByEmail 根据邮箱禁用相关的token记录
+func disableTokenRecordsByEmail(email string, reason string) error {
+	updates := map[string]interface{}{
+		"status":      "banned",
+		"is_active":   false,
+		"ban_reason":  reason,
+		"updated_at":  time.Now(),
+	}
+	
+	result := database.GetDB().Model(&model.TokenRecord{}).
+		Where("email = ? AND status = ?", email, "active").
+		Updates(updates)
+	
+	if result.Error != nil {
+		return fmt.Errorf("failed to disable token records: %w", result.Error)
+	}
+	
+	if result.RowsAffected > 0 {
+		log.Printf("[Token管理] 已禁用邮箱 %s 相关的 %d 条token记录: %s", email, result.RowsAffected, reason)
+	}
+	
+	return nil
+}
+
+// RefreshAccessToken 使用 refresh_token 获取新的 access_token
+func RefreshAccessToken(refreshToken string, proxy string) (*RefreshTokenResponse, error) {
+	url := "https://auth.zencoder.ai/api/frontegg/oauth/token"
+	
+	// 打印调试日志
+	if IsDebugMode() {
+		log.Printf("[DEBUG] [RefreshToken] >>> 开始刷新Token")
+		log.Printf("[DEBUG] [RefreshToken] 请求URL: %s", url)
+		if len(refreshToken) > 20 {
+			log.Printf("[DEBUG] [RefreshToken] RefreshToken: %s...", refreshToken[:20])
+		} else {
+			log.Printf("[DEBUG] [RefreshToken] RefreshToken: %s", refreshToken)
+		}
+	}
+	
+	reqBody := RefreshTokenRequest{
+		GrantType:    "refresh_token",
+		RefreshToken: refreshToken,
+	}
+	
+	jsonData, err := json.Marshal(reqBody)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal request: %w", err)
+	}
+	
+	if IsDebugMode() {
+		log.Printf("[DEBUG] [RefreshToken] 请求Body: %s", string(jsonData))
+	}
+	
+	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+	
+	// 设置请求头
+	req.Header.Set("Accept", "*/*")
+	req.Header.Set("Accept-Encoding", "gzip, deflate, br")
+	req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8,zh-TW;q=0.7,ja;q=0.6")
+	req.Header.Set("Cache-Control", "no-cache")
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Origin", "https://auth.zencoder.ai")
+	req.Header.Set("Pragma", "no-cache")
+	req.Header.Set("Priority", "u=1, i")
+	req.Header.Set("Sec-Ch-Ua", `"Google Chrome";v="143", "Chromium";v="143", "Not A(Brand";v="24"`)
+	req.Header.Set("Sec-Ch-Ua-Mobile", "?0")
+	req.Header.Set("Sec-Ch-Ua-Platform", `"Windows"`)
+	req.Header.Set("Sec-Fetch-Dest", "empty")
+	req.Header.Set("Sec-Fetch-Mode", "cors")
+	req.Header.Set("Sec-Fetch-Site", "same-origin")
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36")
+	req.Header.Set("X-Frontegg-Framework", "react@18.2.0")
+	req.Header.Set("X-Frontegg-Sdk", "@frontegg/react@7.12.14")
+	
+	// 使用客户端执行请求
+	client := provider.NewHTTPClient(proxy, 30*time.Second)
+	
+	if IsDebugMode() {
+		log.Printf("[DEBUG] [RefreshToken] → 发送请求...")
+	}
+	
+	resp, err := client.Do(req)
+	if err != nil {
+		if IsDebugMode() {
+			log.Printf("[DEBUG] [RefreshToken] ✗ 请求失败: %v", err)
+		}
+		return nil, fmt.Errorf("failed to send request: %w", err)
+	}
+	defer resp.Body.Close()
+	
+	if IsDebugMode() {
+		log.Printf("[DEBUG] [RefreshToken] ← 收到响应: status=%d", resp.StatusCode)
+		// 输出响应头
+		log.Printf("[DEBUG] [RefreshToken] 响应头:")
+		for k, v := range resp.Header {
+			log.Printf("[DEBUG] [RefreshToken]   %s: %v", k, v)
+		}
+	}
+	
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read response: %w", err)
+	}
+	
+	if IsDebugMode() {
+		log.Printf("[DEBUG] [RefreshToken] 响应Body: %s", string(body))
+	}
+	
+	if resp.StatusCode != http.StatusOK {
+		if IsDebugMode() {
+			log.Printf("[DEBUG] [RefreshToken] ✗ API错误: %d - %s", resp.StatusCode, string(body))
+		}
+		
+		// 检查是否是账号锁定错误
+		if isAccountLockoutError(resp.StatusCode, string(body)) {
+			return nil, &AccountLockoutError{
+				StatusCode: resp.StatusCode,
+				Body:       string(body),
+			}
+		}
+		
+		// 检查是否是refresh token无效错误
+		if isRefreshTokenInvalidError(resp.StatusCode, string(body)) {
+			return nil, fmt.Errorf("refresh token expired or invalid: status %d, body: %s", resp.StatusCode, string(body))
+		}
+		
+		return nil, fmt.Errorf("failed to refresh token: status %d, body: %s", resp.StatusCode, string(body))
+	}
+	
+	var tokenResp RefreshTokenResponse
+	if err := json.Unmarshal(body, &tokenResp); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal response: %w", err)
+	}
+	
+	// 如果响应中没有UserID，尝试从access_token中解析
+	if tokenResp.UserID == "" && tokenResp.AccessToken != "" {
+		if payload, err := ParseJWT(tokenResp.AccessToken); err == nil {
+			// 优先使用 Email，没有则使用 Subject
+			if payload.Email != "" {
+				tokenResp.UserID = payload.Email
+				tokenResp.Email = payload.Email
+			} else if payload.Subject != "" {
+				tokenResp.UserID = payload.Subject
+			}
+			
+			if IsDebugMode() {
+				log.Printf("[DEBUG] [RefreshToken] 从JWT解析UserID: %s", tokenResp.UserID)
+				log.Printf("[DEBUG] [RefreshToken] JWT Payload - Email: %s, Subject: %s",
+					payload.Email, payload.Subject)
+			}
+		} else {
+			if IsDebugMode() {
+				log.Printf("[DEBUG] [RefreshToken] 解析JWT失败: %v", err)
+			}
+		}
+	}
+	
+	if IsDebugMode() {
+		accessTokenPreview := tokenResp.AccessToken
+		if len(accessTokenPreview) > 20 {
+			accessTokenPreview = accessTokenPreview[:20]
+		}
+		log.Printf("[DEBUG] [RefreshToken] <<< 刷新成功: UserID=%s, AccessToken=%s..., ExpiresIn=%d",
+			tokenResp.UserID,
+			accessTokenPreview,
+			tokenResp.ExpiresIn)
+	}
+	
+	return &tokenResp, nil
+}
+
+// min 辅助函数
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+// UpdateAccountToken 更新账号的 token
+func UpdateAccountToken(account *model.Account) error {
+	if account.RefreshToken == "" {
+		return fmt.Errorf("account %s has no refresh token", account.ClientID)
+	}
+	
+	// 调用刷新接口
+	tokenResp, err := RefreshAccessToken(account.RefreshToken, account.Proxy)
+	if err != nil {
+		// 检查是否是账号锁定错误
+		if lockoutErr, ok := err.(*AccountLockoutError); ok {
+			// 将账号标记为封禁状态
+			if markErr := markAccountAsBanned(account, "用户被锁定: "+lockoutErr.Body); markErr != nil {
+				log.Printf("[账号管理] 标记账号封禁状态失败: %v", markErr)
+			}
+		}
+		return fmt.Errorf("failed to refresh token for account %s: %w", account.ClientID, err)
+	}
+	
+	// 计算过期时间
+	expiry := time.Now().Add(time.Duration(tokenResp.ExpiresIn) * time.Second)
+	
+	// 更新数据库
+	updates := map[string]interface{}{
+		"access_token":  tokenResp.AccessToken,
+		"refresh_token": tokenResp.RefreshToken, // 更新新的 refresh_token
+		"token_expiry":  expiry,
+		"updated_at":    time.Now(),
+	}
+	
+	if err := database.DB.Model(&model.Account{}).
+		Where("id = ?", account.ID).
+		Updates(updates).Error; err != nil {
+		return fmt.Errorf("failed to update account token: %w", err)
+	}
+	
+	// 更新内存中的值
+	account.AccessToken = tokenResp.AccessToken
+	account.RefreshToken = tokenResp.RefreshToken
+	account.TokenExpiry = expiry
+	
+	debugLogf("✅ Refreshed token for account %s, expires at %s", account.ClientID, expiry.Format(time.RFC3339))
+	
+	return nil
+}
+
+// UpdateTokenRecordToken 更新 TokenRecord 的 token
+func UpdateTokenRecordToken(record *model.TokenRecord) error {
+	if record.RefreshToken == "" {
+		return fmt.Errorf("token record %d has no refresh token", record.ID)
+	}
+	
+	// 调用刷新接口
+	tokenResp, err := RefreshAccessToken(record.RefreshToken, "")
+	if err != nil {
+		// 检查是否是账号锁定错误
+		if lockoutErr, ok := err.(*AccountLockoutError); ok {
+			// 将token记录标记为封禁状态
+			if markErr := markTokenRecordAsBanned(record, "账号被锁定: "+lockoutErr.Body); markErr != nil {
+				log.Printf("[Token管理] 标记token记录封禁状态失败: %v", markErr)
+			}
+			// 根据邮箱禁用相关的token记录
+			if record.Email != "" {
+				if disableErr := disableTokenRecordsByEmail(record.Email, "关联账号被锁定"); disableErr != nil {
+					log.Printf("[Token管理] 禁用相关token记录失败: %v", disableErr)
+				}
+			}
+			return fmt.Errorf("token record %d account locked out: %w", record.ID, err)
+		}
+		
+		// 检查是否是refresh token过期错误
+		if strings.Contains(err.Error(), "refresh token expired or invalid") {
+			// 将token记录标记为过期状态
+			if markErr := markTokenRecordAsExpired(record, "Refresh token过期或无效"); markErr != nil {
+				log.Printf("[Token管理] 标记token记录过期状态失败: %v", markErr)
+			}
+			return fmt.Errorf("token record %d refresh token expired: %w", record.ID, err)
+		}
+		
+		return fmt.Errorf("failed to refresh token for record %d: %w", record.ID, err)
+	}
+	
+	// 计算过期时间
+	expiry := time.Now().Add(time.Duration(tokenResp.ExpiresIn) * time.Second)
+	
+	// 更新数据库
+	updates := map[string]interface{}{
+		"token":         tokenResp.AccessToken,
+		"refresh_token": tokenResp.RefreshToken, // 更新新的 refresh_token
+		"token_expiry":  expiry,
+		"status":        "active", // 刷新成功时重新激活
+		"updated_at":    time.Now(),
+	}
+	
+	if err := database.DB.Model(&model.TokenRecord{}).
+		Where("id = ?", record.ID).
+		Updates(updates).Error; err != nil {
+		return fmt.Errorf("failed to update token record: %w", err)
+	}
+	
+	// 更新内存中的值
+	record.Token = tokenResp.AccessToken
+	record.RefreshToken = tokenResp.RefreshToken
+	record.TokenExpiry = expiry
+	record.Status = "active"
+	
+	debugLogf("✅ Refreshed token for record %d, expires at %s", record.ID, expiry.Format(time.RFC3339))
+	
+	return nil
+}
+
+// CheckAndRefreshToken 检查并刷新即将过期的 token
+func CheckAndRefreshToken(account *model.Account) error {
+	// 如果没有 RefreshToken，跳过
+	if account.RefreshToken == "" {
+		return nil
+	}
+	
+	// 如果 token 在一小时内过期，则刷新
+	if time.Until(account.TokenExpiry) < time.Hour {
+		debugLogf("⚠️ Token for account %s expires in %v, refreshing...",
+			account.ClientID, time.Until(account.TokenExpiry))
+		return UpdateAccountToken(account)
+	}
+	
+	return nil
+}
+
+// CheckAndRefreshTokenRecord 检查并刷新即将过期的 TokenRecord
+func CheckAndRefreshTokenRecord(record *model.TokenRecord) error {
+	// 如果没有 RefreshToken，跳过
+	if record.RefreshToken == "" {
+		return nil
+	}
+	
+	// 如果 token 在一小时内过期，则刷新
+	if time.Until(record.TokenExpiry) < time.Hour {
+		debugLogf("⚠️ Token for record %d expires in %v, refreshing...",
+			record.ID, time.Until(record.TokenExpiry))
+		return UpdateTokenRecordToken(record)
+	}
+	
+	return nil
+}
+
+// StartTokenRefreshScheduler 启动定时刷新 token 的调度器
+func StartTokenRefreshScheduler() {
+	go func() {
+		// 立即执行一次
+		refreshExpiredTokens()
+		
+		// 然后每分钟检查一次
+		ticker := time.NewTicker(1 * time.Minute)
+		defer ticker.Stop()
+		
+		for range ticker.C {
+			refreshExpiredTokens()
+		}
+	}()
+	
+	log.Printf("🔄 Token refresh scheduler started - checking every minute")
+}
+
+// refreshExpiredTokens 刷新即将过期的 tokens
+func refreshExpiredTokens() {
+	now := time.Now()
+	threshold := now.Add(time.Hour) // 1小时内即将过期的token
+	
+	// 查询所有即将过期的账号（排除banned状态）
+	var accounts []model.Account
+	if err := database.DB.Where("token_expiry < ?", threshold).
+		Where("status != ?", "banned").
+		Find(&accounts).Error; err == nil {
+		
+		for _, account := range accounts {
+			// 根据账号类型选择不同的刷新方式
+			if account.ClientSecret == "refresh-token-login" {
+				// refresh-token-login 账号使用 refresh_token 刷新
+				if account.RefreshToken != "" {
+					if err := UpdateAccountToken(&account); err != nil {
+						log.Printf("[Token刷新] ❌ refresh-token账号 %s 刷新失败: %v", account.ClientID, err)
+					}
+				}
+			} else {
+				// 普通账号使用 OAuth client credentials 刷新
+				if account.ClientID != "" && account.ClientSecret != "" {
+					if err := refreshAccountToken(&account); err != nil {
+						log.Printf("[Token刷新] ❌ 账号 %s OAuth刷新失败: %v", account.ClientID, err)
+					}
+				}
+			}
+		}
+	}
+	
+	// 刷新 TokenRecord 的 tokens - 只排除banned状态的记录
+	var records []model.TokenRecord
+	if err := database.DB.Where("refresh_token != '' AND token_expiry < ?", threshold).
+		Where("status != ?", "banned").
+		Find(&records).Error; err == nil {
+		
+		for _, record := range records {
+			if err := UpdateTokenRecordToken(&record); err != nil {
+				log.Printf("[Token刷新] ❌ 生成token #%d 刷新失败: %v", record.ID, err)
+			}
+		}
+	}
+}
+
+// debugLogf 简单的调试日志函数
+func debugLogf(format string, args ...interface{}) {
+	if IsDebugMode() {
+		log.Printf("[DEBUG] "+format, args...)
+	}
+}
+
+// RefreshTokenAndAccounts 刷新token记录并异步刷新相同邮箱的账号
+func RefreshTokenAndAccounts(tokenRecordID uint) error {
+	// 获取token记录
+	var record model.TokenRecord
+	if err := database.GetDB().First(&record, tokenRecordID).Error; err != nil {
+		return fmt.Errorf("获取token记录失败: %w", err)
+	}
+
+	if record.RefreshToken == "" {
+		return fmt.Errorf("token记录没有refresh_token")
+	}
+
+	// 1. 刷新token记录的token
+	log.Printf("[Token刷新] 开始刷新token记录 #%d", tokenRecordID)
+	
+	// 调用刷新接口
+	tokenResp, err := RefreshAccessToken(record.RefreshToken, "")
+	if err != nil {
+		// 检查是否是账号锁定错误
+		if lockoutErr, ok := err.(*AccountLockoutError); ok {
+			// 将token记录标记为封禁状态
+			if markErr := markTokenRecordAsBanned(&record, "账号被锁定: "+lockoutErr.Body); markErr != nil {
+				log.Printf("[Token管理] 标记token记录封禁状态失败: %v", markErr)
+			}
+			// 根据邮箱禁用相关的token记录
+			if record.Email != "" {
+				if disableErr := disableTokenRecordsByEmail(record.Email, "关联账号被锁定"); disableErr != nil {
+					log.Printf("[Token管理] 禁用相关token记录失败: %v", disableErr)
+				}
+			}
+		}
+		
+		// 检查是否是refresh token过期错误
+		if strings.Contains(err.Error(), "refresh token expired or invalid") {
+			// 将token记录标记为过期状态
+			if markErr := markTokenRecordAsExpired(&record, "Refresh token过期或无效"); markErr != nil {
+				log.Printf("[Token管理] 标记token记录过期状态失败: %v", markErr)
+			}
+		}
+		
+		return fmt.Errorf("刷新token失败: %w", err)
+	}
+	
+	// 计算过期时间
+	expiry := time.Now().Add(time.Duration(tokenResp.ExpiresIn) * time.Second)
+	
+	// 更新数据库
+	updates := map[string]interface{}{
+		"token":         tokenResp.AccessToken,
+		"refresh_token": tokenResp.RefreshToken,
+		"token_expiry":  expiry,
+		"status":        "active", // 刷新成功时重置为活跃状态
+		"ban_reason":    "",       // 清除封禁原因
+		"updated_at":    time.Now(),
+	}
+	
+	if err := database.GetDB().Model(&model.TokenRecord{}).
+		Where("id = ?", tokenRecordID).
+		Updates(updates).Error; err != nil {
+		return fmt.Errorf("更新token记录失败: %w", err)
+	}
+	
+	// 2. 解析新token获取邮箱
+	email := ""
+	if payload, err := ParseJWT(tokenResp.AccessToken); err == nil {
+		email = payload.Email
+		log.Printf("[Token刷新] 解析到邮箱: %s", email)
+	} else {
+		log.Printf("[Token刷新] 无法解析JWT获取邮箱: %v", err)
+		return nil // 不影响token记录的刷新
+	}
+	
+	if email == "" {
+		log.Printf("[Token刷新] 邮箱为空，跳过账号刷新")
+		return nil
+	}
+	
+	// 3. 异步刷新相同邮箱的账号
+	go refreshAccountsByEmail(email)
+	
+	return nil
+}
+
+// refreshAccountsByEmail 刷新指定邮箱的所有账号
+func refreshAccountsByEmail(email string) {
+	log.Printf("[账号刷新] 开始刷新邮箱 %s 的所有账号", email)
+	
+	// 查询所有相同邮箱的账号
+	var accounts []model.Account
+	if err := database.GetDB().Where("email = ?", email).Find(&accounts).Error; err != nil {
+		log.Printf("[账号刷新] 查询邮箱 %s 的账号失败: %v", email, err)
+		return
+	}
+	
+	if len(accounts) == 0 {
+		log.Printf("[账号刷新] 没有找到邮箱 %s 的账号", email)
+		return
+	}
+	
+	log.Printf("[账号刷新] 找到 %d 个账号需要刷新", len(accounts))
+	
+	// 逐个刷新账号
+	successCount := 0
+	failCount := 0
+	
+	for _, account := range accounts {
+		// 如果账号没有client_id和client_secret，跳过
+		if account.ClientID == "" || account.ClientSecret == "" {
+			log.Printf("[账号刷新] 账号 ID:%d 缺少client_id或client_secret，跳过", account.ID)
+			continue
+		}
+		
+		log.Printf("[账号刷新] 正在刷新账号 ID:%d (ClientID: %s)", account.ID, account.ClientID)
+		
+		// 使用OAuth方式刷新token
+		if err := refreshAccountToken(&account); err != nil {
+			log.Printf("[账号刷新] 账号 ID:%d 刷新失败: %v", account.ID, err)
+			failCount++
+		} else {
+			log.Printf("[账号刷新] 账号 ID:%d 刷新成功", account.ID)
+			successCount++
+		}
+		
+		// 添加短暂延迟，避免请求过快
+		time.Sleep(100 * time.Millisecond)
+	}
+	
+	log.Printf("[账号刷新] 邮箱 %s 的账号刷新完成 - 成功: %d, 失败: %d",
+		email, successCount, failCount)
+}
+
+// RefreshAccountToken 使用client credentials刷新账号token（导出函数）
+func RefreshAccountToken(account *model.Account) error {
+	return refreshAccountToken(account)
+}
+
+// refreshAccountToken 使用client credentials刷新账号token
+func refreshAccountToken(account *model.Account) error {
+	// 构建OAuth token请求
+	url := "https://fe.zencoder.ai/oauth/token"
+	
+	reqBody := map[string]string{
+		"grant_type":    "client_credentials",
+		"client_id":     account.ClientID,
+		"client_secret": account.ClientSecret,
+	}
+	
+	jsonData, err := json.Marshal(reqBody)
+	if err != nil {
+		return fmt.Errorf("序列化请求失败: %w", err)
+	}
+	
+	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
+	if err != nil {
+		return fmt.Errorf("创建请求失败: %w", err)
+	}
+	
+	// 设置请求头
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", "application/json")
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36")
+	
+	// 使用代理（如果有）
+	client := provider.NewHTTPClient(account.Proxy, 30*time.Second)
+	
+	resp, err := client.Do(req)
+	if err != nil {
+		return fmt.Errorf("发送请求失败: %w", err)
+	}
+	defer resp.Body.Close()
+	
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("读取响应失败: %w", err)
+	}
+	
+	if resp.StatusCode != http.StatusOK {
+		// 检查是否是账号锁定错误
+		if isAccountLockoutError(resp.StatusCode, string(body)) {
+			// 将账号标记为封禁状态
+			if markErr := markAccountAsBanned(account, "OAuth认证失败-用户被锁定: "+string(body)); markErr != nil {
+				log.Printf("[账号管理] 标记账号封禁状态失败: %v", markErr)
+			}
+			return &AccountLockoutError{
+				StatusCode: resp.StatusCode,
+				Body:       string(body),
+				AccountID:  account.ClientID,
+			}
+		}
+		return fmt.Errorf("API返回错误: %d - %s", resp.StatusCode, string(body))
+	}
+	
+	// 解析响应
+	var tokenResp struct {
+		AccessToken  string `json:"access_token"`
+		TokenType    string `json:"token_type"`
+		ExpiresIn    int    `json:"expires_in"`
+		RefreshToken string `json:"refresh_token"`
+	}
+	
+	if err := json.Unmarshal(body, &tokenResp); err != nil {
+		return fmt.Errorf("解析响应失败: %w", err)
+	}
+	
+	// 计算过期时间
+	expiry := time.Now().Add(time.Duration(tokenResp.ExpiresIn) * time.Second)
+	
+	// 解析token获取更多信息
+	planType := account.PlanType // 保留原有计划类型
+	dailyUsed := account.DailyUsed // 保留原有使用量
+	totalUsed := account.TotalUsed // 保留原有总使用量
+	
+	if payload, err := ParseJWT(tokenResp.AccessToken); err == nil {
+		// 更新计划类型（如果有）
+		if payload.CustomClaims.Plan != "" {
+			planType = model.PlanType(payload.CustomClaims.Plan)
+		}
+		// 验证邮箱
+		if account.Email != "" && payload.Email != account.Email {
+			log.Printf("[账号刷新] 警告: 账号 ID:%d 邮箱不匹配 (期望: %s, 实际: %s)",
+				account.ID, account.Email, payload.Email)
+		}
+	}
+	
+	// 更新数据库
+	updates := map[string]interface{}{
+		"access_token":  tokenResp.AccessToken,
+		"refresh_token": tokenResp.RefreshToken,
+		"token_expiry":  expiry,
+		"plan_type":     planType,
+		"daily_used":    dailyUsed,  // 保持原有使用量
+		"total_used":    totalUsed,  // 保持原有总使用量
+		"updated_at":    time.Now(),
+	}
+	
+	return database.GetDB().Model(&model.Account{}).
+		Where("id = ?", account.ID).
+		Updates(updates).Error
+}

internal/service/request.go

@@ -0,0 +1,3 @@
+package service
+
+// 注意：ReplaceModelInBody 函数已被删除，不再进行模型重定向/替换

internal/service/scheduler.go

@@ -0,0 +1,39 @@
+package service
+
+import (
+	"log"
+	"time"
+
+	"zencoder-2api/internal/database"
+	"zencoder-2api/internal/model"
+)
+
+func StartCreditResetScheduler() {
+	go func() {
+		for {
+			now := time.Now()
+			next := time.Date(now.Year(), now.Month(), now.Day(), 9, 9, 0, 0, now.Location())
+			if now.After(next) {
+				next = next.Add(24 * time.Hour)
+			}
+
+			time.Sleep(time.Until(next))
+			ResetAllCredits()
+		}
+	}()
+	log.Println("Credit reset scheduler started (daily at 09:09)")
+}
+
+func ResetAllCredits() {
+	today := time.Now().Format("2006-01-02")
+
+	database.GetDB().Model(&model.Account{}).
+		Where("last_reset_date != ? OR last_reset_date IS NULL", today).
+		Updates(map[string]interface{}{
+			"daily_used":      0,
+			"is_cooling":      false,
+			"last_reset_date": today,
+		})
+
+	log.Printf("Credits reset completed at %s", time.Now().Format("2006-01-02 15:04:05"))
+}

internal/service/stream.go

@@ -0,0 +1,57 @@
+package service
+
+import (
+	"bufio"
+	"io"
+	"net/http"
+)
+
+// StreamResponse 流式传输响应到客户端
+func StreamResponse(w http.ResponseWriter, resp *http.Response) error {
+	// 复制响应头
+	for k, v := range resp.Header {
+		for _, vv := range v {
+			w.Header().Add(k, vv)
+		}
+	}
+	w.WriteHeader(resp.StatusCode)
+
+	// 获取Flusher接口
+	flusher, ok := w.(http.Flusher)
+	if !ok {
+		// 如果不支持Flusher，直接复制
+		_, err := io.Copy(w, resp.Body)
+		return err
+	}
+
+	// 使用bufio读取并逐行刷新
+	reader := bufio.NewReader(resp.Body)
+	for {
+		line, err := reader.ReadBytes('\n')
+		if len(line) > 0 {
+			_, writeErr := w.Write(line)
+			if writeErr != nil {
+				return writeErr
+			}
+			flusher.Flush()
+		}
+		if err != nil {
+			if err == io.EOF {
+				return nil
+			}
+			return err
+		}
+	}
+}
+
+// CopyResponse 普通响应复制
+func CopyResponse(w http.ResponseWriter, resp *http.Response) error {
+	for k, v := range resp.Header {
+		for _, vv := range v {
+			w.Header().Add(k, vv)
+		}
+	}
+	w.WriteHeader(resp.StatusCode)
+	_, err := io.Copy(w, resp.Body)
+	return err
+}

internal/service/token.go

@@ -0,0 +1,128 @@
+package service
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"zencoder-2api/internal/database"
+	"zencoder-2api/internal/model"
+)
+
+type TokenResponse struct {
+	AccessToken string `json:"access_token"`
+	TokenType   string `json:"token_type"`
+	ExpiresIn   int    `json:"expires_in"`
+}
+
+const (
+	ZencoderTokenURL = "https://fe.zencoder.ai/oauth/token"
+)
+
+func GetToken(account *model.Account) (string, error) {
+	if account.AccessToken != "" && time.Now().Before(account.TokenExpiry) {
+		return account.AccessToken, nil
+	}
+	return RefreshToken(account)
+}
+
+func RefreshToken(account *model.Account) (string, error) {
+	// 每次创建新的 HTTP 客户端，禁用连接复用
+	transport := &http.Transport{
+		DisableKeepAlives:   true,  // 禁用 Keep-Alive
+		DisableCompression:  false,
+		MaxIdleConns:        0,     // 不保持空闲连接
+		MaxIdleConnsPerHost: 0,
+		IdleConnTimeout:     0,
+	}
+
+	if account.Proxy != "" {
+		proxyURL, err := url.Parse(account.Proxy)
+		if err == nil {
+			transport.Proxy = http.ProxyURL(proxyURL)
+		}
+	}
+
+	client := &http.Client{
+		Transport: transport,
+		Timeout:   30 * time.Second,
+	}
+
+	data := url.Values{}
+	data.Set("grant_type", "client_credentials")
+	data.Set("client_id", account.ClientID)
+	data.Set("client_secret", account.ClientSecret)
+
+	req, err := http.NewRequest("POST", ZencoderTokenURL, strings.NewReader(data.Encode()))
+	if err != nil {
+		return "", err
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.Header.Set("Connection", "close") // 明确要求关闭连接
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		// 检查是否是账号锁定错误
+		if isAccountLockoutError(resp.StatusCode, string(body)) {
+			// 将账号标记为封禁状态
+			if markErr := markAccountAsBanned(account, "OAuth认证失败-用户被锁定: "+string(body)); markErr != nil {
+				log.Printf("[账号管理] 标记账号封禁状态失败: %v", markErr)
+			}
+			return "", &AccountLockoutError{
+				StatusCode: resp.StatusCode,
+				Body:       string(body),
+				AccountID:  account.ClientID,
+			}
+		}
+		return "", fmt.Errorf("token request failed: %s", string(body))
+	}
+
+	var tokenResp TokenResponse
+	if err := json.Unmarshal(body, &tokenResp); err != nil {
+		return "", err
+	}
+
+	account.AccessToken = tokenResp.AccessToken
+	account.TokenExpiry = time.Now().Add(time.Duration(tokenResp.ExpiresIn-60) * time.Second)
+
+	// 只有已存在的账号才保存到数据库
+	if account.ID > 0 {
+		database.GetDB().Save(account)
+	}
+
+	// 显式关闭传输层，确保连接被清理
+	transport.CloseIdleConnections()
+
+	return account.AccessToken, nil
+}
+
+func createHTTPClient(proxy string) *http.Client {
+	transport := &http.Transport{}
+
+	if proxy != "" {
+		proxyURL, err := url.Parse(proxy)
+		if err == nil {
+			transport.Proxy = http.ProxyURL(proxyURL)
+		}
+	}
+
+	return &http.Client{
+		Transport: transport,
+		Timeout:   30 * time.Second,
+	}
+}

internal/service/zencoder.go

@@ -0,0 +1,217 @@
+package service
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+
+	"github.com/google/uuid"
+	"zencoder-2api/internal/model"
+)
+
+const (
+	ZencoderChatURL = "https://api.zencoder.ai/v1/chat/completions"
+	MaxRetries      = 3
+	ZencoderVersion = "3.24.0"
+)
+
+type ZencoderService struct{}
+
+func NewZencoderService() *ZencoderService {
+	return &ZencoderService{}
+}
+
+func setZencoderHeaders(req *http.Request, token, modelID string) {
+	req.Header.Set("Accept", "application/json")
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+token)
+	req.Header.Set("User-Agent", "zen-cli/0.9.0-windows-x64")
+	req.Header.Set("zen-model-id", modelID)
+	req.Header.Set("zencoder-arch", "x64")
+	req.Header.Set("zencoder-os", "windows")
+	req.Header.Set("zencoder-version", ZencoderVersion)
+	req.Header.Set("zencoder-client-type", "vscode")
+	req.Header.Set("zencoder-operation-id", uuid.New().String())
+	req.Header.Set("zencoder-operation-type", "agent_call")
+}
+
+func (s *ZencoderService) Chat(req *model.ChatCompletionRequest) (*model.ChatCompletionResponse, error) {
+	// 检查模型是否存在于模型字典中
+	zenModel, exists := model.GetZenModel(req.Model)
+	if !exists {
+		return nil, ErrNoAvailableAccount
+	}
+
+	var lastErr error
+	for i := 0; i < MaxRetries; i++ {
+		account, err := GetNextAccountForModel(req.Model)
+		if err != nil {
+			return nil, err
+		}
+
+		resp, err := s.doRequest(account, req)
+		if err != nil {
+			MarkAccountError(account)
+			lastErr = err
+			continue
+		}
+
+		ResetAccountError(account)
+		
+		// ZenCoder服务没有HTTP响应，只能使用模型倍率
+		UseCredit(account, zenModel.Multiplier)
+		
+		return resp, nil
+	}
+
+	return nil, fmt.Errorf("all retries failed: %w", lastErr)
+}
+
+func (s *ZencoderService) doRequest(account *model.Account, req *model.ChatCompletionRequest) (*model.ChatCompletionResponse, error) {
+	token, err := GetToken(account)
+	if err != nil {
+		return nil, err
+	}
+
+	// 获取模型映射
+	zenModel, exists := model.GetZenModel(req.Model)
+	if !exists {
+		return nil, ErrNoAvailableAccount
+	}
+
+	body, err := json.Marshal(req)
+	if err != nil {
+		return nil, err
+	}
+
+	client := createHTTPClient(account.Proxy)
+	httpReq, err := http.NewRequest("POST", ZencoderChatURL, bytes.NewReader(body))
+	if err != nil {
+		return nil, err
+	}
+
+	setZencoderHeaders(httpReq, token, zenModel.ID)
+
+	resp, err := client.Do(httpReq)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	respBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("request failed with status %d: %s", resp.StatusCode, string(respBody))
+	}
+
+	var chatResp model.ChatCompletionResponse
+	if err := json.Unmarshal(respBody, &chatResp); err != nil {
+		return nil, err
+	}
+
+	return &chatResp, nil
+}
+
+func (s *ZencoderService) ChatStream(req *model.ChatCompletionRequest, writer http.ResponseWriter) error {
+	// 检查模型是否存在于模型字典中
+	zenModel, exists := model.GetZenModel(req.Model)
+	if !exists {
+		return ErrNoAvailableAccount
+	}
+
+	var lastErr error
+	for i := 0; i < MaxRetries; i++ {
+		account, err := GetNextAccountForModel(req.Model)
+		if err != nil {
+			return err
+		}
+
+		err = s.doStreamRequest(account, req, writer)
+		if err != nil {
+			MarkAccountError(account)
+			lastErr = err
+			continue
+		}
+
+		ResetAccountError(account)
+		
+		// 流式响应，使用模型倍率
+		UseCredit(account, zenModel.Multiplier)
+		
+		return nil
+	}
+
+	return fmt.Errorf("all retries failed: %w", lastErr)
+}
+
+func (s *ZencoderService) doStreamRequest(account *model.Account, req *model.ChatCompletionRequest, writer http.ResponseWriter) error {
+	token, err := GetToken(account)
+	if err != nil {
+		return err
+	}
+
+	// 获取模型映射
+	zenModel, exists := model.GetZenModel(req.Model)
+	if !exists {
+		return ErrNoAvailableAccount
+	}
+
+	req.Stream = true
+	body, err := json.Marshal(req)
+	if err != nil {
+		return err
+	}
+
+	client := createHTTPClient(account.Proxy)
+	client.Timeout = 5 * time.Minute
+
+	httpReq, err := http.NewRequest("POST", ZencoderChatURL, bytes.NewReader(body))
+	if err != nil {
+		return err
+	}
+
+	setZencoderHeaders(httpReq, token, zenModel.ID)
+
+	resp, err := client.Do(httpReq)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		respBody, _ := io.ReadAll(resp.Body)
+		return fmt.Errorf("status %d: %s", resp.StatusCode, string(respBody))
+	}
+
+	return s.streamResponse(resp.Body, writer)
+}
+
+func (s *ZencoderService) streamResponse(body io.Reader, writer http.ResponseWriter) error {
+	flusher, ok := writer.(http.Flusher)
+	if !ok {
+		return fmt.Errorf("streaming not supported")
+	}
+
+	writer.Header().Set("Content-Type", "text/event-stream")
+	writer.Header().Set("Cache-Control", "no-cache")
+	writer.Header().Set("Connection", "keep-alive")
+
+	scanner := bufio.NewScanner(body)
+	for scanner.Scan() {
+		line := scanner.Text()
+		if line == "" {
+			continue
+		}
+		fmt.Fprintf(writer, "%s\n\n", line)
+		flusher.Flush()
+	}
+
+	return scanner.Err()
+}

main.go

@@ -0,0 +1,112 @@
+package main
+
+import (
+	"log"
+	"os"
+
+	"github.com/gin-gonic/gin"
+	"github.com/joho/godotenv"
+	"zencoder-2api/internal/database"
+	"zencoder-2api/internal/handler"
+	"zencoder-2api/internal/middleware"
+	"zencoder-2api/internal/service"
+)
+
+func main() {
+	// 加载 .env 文件
+	if err := godotenv.Load(); err != nil {
+		log.Println("No .env file found or error loading it, using system environment variables or defaults")
+	}
+
+	port := os.Getenv("PORT")
+	if port == "" {
+		port = "8080"
+	}
+
+	dbPath := os.Getenv("DB_PATH")
+	if dbPath == "" {
+		dbPath = "data.db"
+	}
+
+	if err := database.Init(dbPath); err != nil {
+		log.Fatal("Failed to init database:", err)
+	}
+
+	// 启动积分重置定时任务
+	service.StartCreditResetScheduler()
+
+	// 启动Token刷新定时任务
+	service.StartTokenRefreshScheduler()
+
+	// 初始化账号池
+	service.InitAccountPool()
+	
+	// 初始化自动生成服务
+	service.InitAutoGenerationService()
+
+	r := gin.Default()
+	setupRoutes(r)
+
+	log.Printf("Server starting on :%s", port)
+	if err := r.Run(":" + port); err != nil {
+		log.Fatal(err)
+	}
+}
+
+func setupRoutes(r *gin.Engine) {
+	r.Static("/static", "./web/static")
+	r.LoadHTMLGlob("web/templates/*")
+
+	r.GET("/", func(c *gin.Context) {
+		c.HTML(200, "index.html", nil)
+	})
+
+	// Anthropic API - /v1/messages
+	anthropicHandler := handler.NewAnthropicHandler()
+	r.POST("/v1/messages", middleware.LoggerMiddleware(), middleware.AuthMiddleware(), anthropicHandler.Messages)
+
+	// OpenAI API - /v1/chat/completions, /v1/responses
+	openaiHandler := handler.NewOpenAIHandler()
+	r.POST("/v1/chat/completions", middleware.LoggerMiddleware(), middleware.AuthMiddleware(), openaiHandler.ChatCompletions)
+	r.POST("/v1/responses", middleware.LoggerMiddleware(), middleware.AuthMiddleware(), openaiHandler.Responses)
+
+	// Gemini API - /v1beta/models/*path
+	geminiHandler := handler.NewGeminiHandler()
+	r.POST("/v1beta/models/*path", middleware.LoggerMiddleware(), middleware.AuthMiddleware(), geminiHandler.HandleRequest)
+
+	// OAuth处理器 - 不需要管理密码验证（公开访问）
+	oauthHandler := handler.NewOAuthHandler()
+	r.GET("/api/oauth/start-rt", oauthHandler.StartOAuthForRT)
+	r.GET("/api/oauth/callback-rt", oauthHandler.CallbackOAuthForRT)
+
+	// External API - 用于注册机提交OAuth token（公开访问）
+	externalHandler := handler.NewExternalHandler()
+	r.POST("/api/external/submit-tokens", externalHandler.SubmitTokens)
+
+	// Account management API - 需要后台管理密码验证
+	accountHandler := handler.NewAccountHandler()
+	tokenHandler := handler.NewTokenHandler()
+	api := r.Group("/api")
+	api.Use(middleware.AdminAuthMiddleware()) // 应用后台管理密码验证中间件
+	{
+		// 账号管理
+		api.GET("/accounts", accountHandler.List)
+		api.POST("/accounts", accountHandler.Create)
+		api.PUT("/accounts/:id", accountHandler.Update)
+		api.DELETE("/accounts/:id", accountHandler.Delete)
+		api.POST("/accounts/:id/toggle", accountHandler.Toggle)
+		api.POST("/accounts/batch/category", accountHandler.BatchUpdateCategory)
+		api.POST("/accounts/batch/move-all", accountHandler.BatchMoveAll)
+		api.POST("/accounts/batch/refresh-token", accountHandler.BatchRefreshToken)
+		api.POST("/accounts/batch/delete", accountHandler.BatchDelete)
+		
+		// Token记录管理
+		api.GET("/tokens", tokenHandler.ListTokenRecords)
+		api.PUT("/tokens/:id", tokenHandler.UpdateTokenRecord)
+		api.DELETE("/tokens/:id", tokenHandler.DeleteTokenRecord)
+		api.POST("/tokens/:id/trigger", tokenHandler.TriggerGeneration)
+		api.POST("/tokens/:id/refresh", tokenHandler.RefreshTokenRecord)
+		api.GET("/tokens/tasks", tokenHandler.GetGenerationTasks)
+		api.GET("/tokens/pool-status", tokenHandler.GetPoolStatus)
+	}
+}