feat: 实现智能Token选择策略系统

- 新增三种Token选择策略：顺序使用、最优使用、均衡使用
- 支持环境变量TOKEN_SELECTION_STRATEGY动态配置策略
- 实现SequentialSelectionStrategy顺序策略（默认）
- 实现OptimalSelectionStrategy最优策略
- 实现BalancedSelectionStrategy均衡策略
- 添加策略状态监控和动态切换功能
- 更新CLAUDE.md文档，添加Token选择策略配置说明

技术改进：
- 重构TokenManager，集成选择策略模式
- 优化token选择逻辑，提升并发性能
- 增强日志记录，便于调试和监控
- 保持向后兼容性，默认使用顺序策略

Author: caidaoli

CLAUDE.md

@@ -62,6 +62,12 @@ docker-compose up -d         # 启动服务
 # 复制配置文件
 cp .env.example .env
 
+# === Token选择策略配置 ===
+# 控制多个token时的使用顺序，支持三种策略：
+TOKEN_SELECTION_STRATEGY=sequential     # 顺序使用（默认）：按配置顺序依次使用token，用完再用下一个
+# TOKEN_SELECTION_STRATEGY=optimal     # 最优使用：选择可用次数最多的token
+# TOKEN_SELECTION_STRATEGY=balanced    # 均衡使用：轮询所有可用token
+
 # === Token管理配置（推荐使用JSON格式） ===
 # 新的JSON格式配置方式，支持多认证方式和多token。
 #

auth/token_manager.go

@@ -4,16 +4,20 @@ import (
 	"fmt"
 	"kiro2api/logger"
 	"kiro2api/types"
+	"os"
+	"strings"
 	"sync"
 	"time"
 )
 
 // TokenManager 简化的token管理器
 type TokenManager struct {
-	cache       *SimpleTokenCache
-	configs     []AuthConfig
-	mutex       sync.RWMutex
-	lastRefresh time.Time
+	cache            *SimpleTokenCache
+	configs          []AuthConfig
+	mutex            sync.RWMutex
+	lastRefresh      time.Time
+	selectionStrategy TokenSelectionStrategy // 新增：token选择策略
+	configOrder      []string                // 新增：配置顺序
 }
 
 // SimpleTokenCache 简化的token缓存
@@ -42,9 +46,31 @@ func NewSimpleTokenCache(ttl time.Duration) *SimpleTokenCache {
 
 // NewTokenManager 创建新的token管理器
 func NewTokenManager(configs []AuthConfig) *TokenManager {
+	// 确定选择策略类型
+	strategyType := getTokenSelectionStrategy()
+
+	// 生成配置顺序
+	configOrder := generateConfigOrder(configs)
+
+	// 创建选择策略
+	strategy, err := CreateTokenSelectionStrategy(strategyType, configOrder)
+	if err != nil {
+		logger.Warn("创建token选择策略失败，使用默认策略",
+			logger.Err(err),
+			logger.String("requested_strategy", string(strategyType)))
+		strategy = NewOptimalSelectionStrategy()
+	}
+
+	logger.Info("TokenManager初始化",
+		logger.String("selection_strategy", strategy.Name()),
+		logger.Int("config_count", len(configs)),
+		logger.Int("config_order_count", len(configOrder)))
+
 	return &TokenManager{
-		cache:   NewSimpleTokenCache(5 * time.Minute),
-		configs: configs,
+		cache:            NewSimpleTokenCache(5 * time.Minute),
+		configs:          configs,
+		selectionStrategy: strategy,
+		configOrder:      configOrder,
 	}
 }
 
@@ -78,31 +104,48 @@ func (tm *TokenManager) getBestToken() (types.TokenInfo, error) {
 	return bestToken.Token, nil
 }
 
-// selectBestToken 选择最优token（简化策略）
+// selectBestToken 使用选择策略选择最优token
 func (tm *TokenManager) selectBestToken() *CachedToken {
 	tm.cache.mutex.RLock()
-	defer tm.cache.mutex.RUnlock()
+	tokens := tm.cache.tokens // 获取token映射的引用
+	tm.cache.mutex.RUnlock()
 
-	var bestToken *CachedToken
-
-	for _, cached := range tm.cache.tokens {
+	// 过滤出可用的token
+	availableTokens := make(map[string]*CachedToken)
+	for key, cached := range tokens {
 		// 检查token是否过期
 		if time.Since(cached.CachedAt) > tm.cache.ttl {
 			continue
 		}
 
 		// 检查token是否可用
-		if !cached.IsUsable() {
-			continue
+		if cached.IsUsable() {
+			availableTokens[key] = cached
 		}
+	}
 
-		// 选择可用次数最多的token
-		if bestToken == nil || cached.Available > bestToken.Available {
-			bestToken = cached
-		}
+	if len(availableTokens) == 0 {
+		logger.Debug("没有可用的token")
+		return nil
 	}
 
-	return bestToken
+	// 使用策略选择token
+	selectedKey := tm.selectionStrategy.SelectToken(availableTokens)
+	if selectedKey == "" {
+		logger.Warn("选择策略未能选择任何token",
+			logger.String("strategy", tm.selectionStrategy.Name()),
+			logger.Int("available_count", len(availableTokens)))
+		return nil
+	}
+
+	selectedToken := availableTokens[selectedKey]
+
+	logger.Debug("token选择完成",
+		logger.String("strategy", tm.selectionStrategy.Name()),
+		logger.String("selected_key", selectedKey),
+		logger.Int("available_count", selectedToken.Available))
+
+	return selectedToken
 }
 
 // refreshCache 刷新token缓存
@@ -212,3 +255,75 @@ func calculateAvailableCount(usage *types.UsageLimits) int {
 func CalculateAvailableCount(usage *types.UsageLimits) int {
 	return calculateAvailableCount(usage)
 }
+
+// getTokenSelectionStrategy 从环境变量获取token选择策略
+func getTokenSelectionStrategy() TokenSelectionStrategyType {
+	strategyEnv := strings.ToLower(strings.TrimSpace(os.Getenv("TOKEN_SELECTION_STRATEGY")))
+
+	switch strategyEnv {
+	case "sequential", "sequence", "顺序":
+		return StrategySequential
+	case "optimal", "best", "最优":
+		return StrategyOptimal
+	case "balanced", "均衡":
+		return StrategyBalanced
+	default:
+		// 默认使用顺序策略（满足用户需求）
+		return StrategySequential
+	}
+}
+
+// generateConfigOrder 生成token配置的顺序
+func generateConfigOrder(configs []AuthConfig) []string {
+	var order []string
+
+	for i := range configs {
+		// 使用索引生成cache key，与refreshCache中的逻辑保持一致
+		cacheKey := fmt.Sprintf("token_%d", i)
+		order = append(order, cacheKey)
+	}
+
+	logger.Debug("生成配置顺序",
+		logger.Int("config_count", len(configs)),
+		logger.Any("order", order))
+
+	return order
+}
+
+// SetSelectionStrategy 动态设置选择策略（用于测试和动态配置）
+func (tm *TokenManager) SetSelectionStrategy(strategyType TokenSelectionStrategyType) error {
+	tm.mutex.Lock()
+	defer tm.mutex.Unlock()
+
+	strategy, err := CreateTokenSelectionStrategy(strategyType, tm.configOrder)
+	if err != nil {
+		return fmt.Errorf("创建选择策略失败: %w", err)
+	}
+
+	oldStrategy := tm.selectionStrategy.Name()
+	tm.selectionStrategy = strategy
+
+	logger.Info("token选择策略已更新",
+		logger.String("old_strategy", oldStrategy),
+		logger.String("new_strategy", strategy.Name()))
+
+	return nil
+}
+
+// GetSelectionStrategyStatus 获取选择策略状态（用于监控和调试）
+func (tm *TokenManager) GetSelectionStrategyStatus() map[string]interface{} {
+	tm.mutex.RLock()
+	defer tm.mutex.RUnlock()
+
+	status := map[string]interface{}{
+		"strategy_name": tm.selectionStrategy.Name(),
+		"config_order":  tm.configOrder,
+	}
+
+	// 如果是顺序策略，获取详细状态
+	if seqStrategy, ok := tm.selectionStrategy.(*SequentialSelectionStrategy); ok {
+		status["sequential_status"] = seqStrategy.GetCurrentStatus()
+	}
+
+	return status
+}