Upload 19 files

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/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()
+}