flowchart TB
    subgraph Clients["客户端层"]
        AgentEngine["Agent Engine<br/>智能体引擎"]
        RAGEngine["RAG Engine<br/>检索引擎"]
        ModelAdapter["Model Adapter<br/>模型适配器"]
        Orchestrator["AI Orchestrator<br/>编排服务"]
    end

    subgraph ServerLayer["服务器层 (Server)"]
        HTTPServer["HTTP Server<br/>Gin Framework<br/>:8002<br/>RESTful API"]
        GRPCServer["gRPC Server<br/>Kratos Framework<br/>:9002<br/>高性能RPC"]
        Middleware["中间件管道<br/>Recovery/Logging<br/>Metrics/Tracing"]
    end

    subgraph ServiceLayer["服务层 (Service)"]
        ModelRouterService["Model Router Service<br/>统一服务入口<br/>协调各子服务"]
    end

    subgraph ApplicationLayer["应用层 (Application)"]
        RoutingService["Routing Service<br/>路由决策<br/>6种策略"]
        FallbackManager["Fallback Manager<br/>故障转移<br/>熔断器管理"]
        CostOptimizer["Cost Optimizer<br/>成本优化<br/>预算管理"]
        ABTestingService["A/B Testing Service V2<br/>灰度发布<br/>变体选择"]
        HealthChecker["Health Checker<br/>健康检查<br/>定期探测"]
    end

    subgraph BizLayer["业务逻辑层 (Biz/Usecase)"]
        RouterUsecase["Router Usecase<br/>路由策略实现<br/>算法选择"]
        ModelUsecase["Model Usecase<br/>模型生命周期<br/>CRUD管理"]
        SmartRoutingUsecase["Smart Routing Usecase<br/>智能路由<br/>动态优化"]
    end

    subgraph DomainLayer["领域模型层 (Domain)"]
        Model["Model<br/>模型聚合根<br/>18个字段"]
        ModelInfo["ModelInfo<br/>运行时模型信息<br/>含性能指标"]
        RouteRequest["RouteRequest<br/>路由请求<br/>策略/能力/约束"]
        RouteResult["RouteResult<br/>路由结果<br/>选中+备选"]
        ModelRegistry["Model Registry<br/>内存模型注册表<br/>快速查询"]
        ABTestConfig["A/B Test Config<br/>实验配置<br/>变体定义"]
    end

    subgraph DataLayer["数据访问层 (Data/Repository)"]
        ModelRepo["Model Repository<br/>GORM ORM<br/>PostgreSQL"]
        MetricsRepo["Metrics Repository<br/>指标CRUD<br/>缓存策略"]
        BudgetRepo["Budget Repository<br/>预算配置<br/>成本统计"]
        ABTestRepo["A/B Test Repository<br/>实验管理<br/>结果记录"]
        ClickHouseLogRepo["ClickHouse Log Repo<br/>日志存储<br/>大数据分析"]
    end

    subgraph InfrastructureLayer["基础设施层 (Infrastructure)"]
        RedisCache["Redis Client<br/>指标缓存TTL=5min<br/>轮询索引"]
        ClickHouseClient["ClickHouse Client<br/>时序日志<br/>OLAP查询"]
        ABTestCache["A/B Test Cache<br/>实验缓存<br/>快速分流"]
        CircuitBreaker["Circuit Breaker<br/>三态模型<br/>自动恢复"]
    end

    subgraph StorageLayer["存储层"]
        PostgreSQL["PostgreSQL<br/>models表<br/>model_metrics表<br/>budgets表<br/>ab_tests表"]
        Redis["Redis<br/>model:metrics:{id}<br/>routing:index:{type}<br/>circuit:{id}"]
        ClickHouse["ClickHouse<br/>routing_logs表<br/>usage_stats表<br/>时序分析"]
    end

    subgraph ExternalLLM["外部 LLM 提供商"]
        OpenAI["OpenAI API<br/>gpt-4/gpt-3.5-turbo"]
        Claude["Anthropic API<br/>claude-3-opus/sonnet"]
        Gemini["Google Gemini<br/>gemini-pro"]
        Zhipu["智谱AI<br/>glm-4"]
        Local["本地模型<br/>Llama/ChatGLM"]
    end

    Clients -->|HTTP/gRPC| ServerLayer
    HTTPServer --> Middleware
    GRPCServer --> Middleware
    Middleware --> ServiceLayer

    ModelRouterService --> ApplicationLayer

    ApplicationLayer --> BizLayer
    RoutingService -.->|使用| ModelRegistry
    FallbackManager -.->|管理| CircuitBreaker
    ABTestingService -.->|使用| ABTestCache

    BizLayer --> DomainLayer
    DomainLayer --> DataLayer
    DataLayer --> StorageLayer
    InfrastructureLayer --> StorageLayer

    ModelRegistry -.->|内存缓存| Model

    Clients -.->|根据路由结果调用| ExternalLLM
    HealthChecker -.->|定期探测| ExternalLLM

    style Clients fill:#e3f2fd
    style ServerLayer fill:#fff3e0
    style ServiceLayer fill:#e1f5fe
    style ApplicationLayer fill:#f3e5f5
    style BizLayer fill:#e8f5e9
    style DomainLayer fill:#fce4ec
    style DataLayer fill:#fff9c4
    style InfrastructureLayer fill:#f0f4c3
    style StorageLayer fill:#d7ccc8
    style ExternalLLM fill:#ffccbc

// 代码位置: cmd/model-router/internal/server/http_server.go:19-43
httpRequestsTotal = prometheus.NewCounterVec(
    prometheus.CounterOpts{
        Name: "model_router_http_requests_total",
        Help: "Total number of HTTP requests",
    },
    []string{"method", "path", "status"},
)

httpRequestDuration = prometheus.NewHistogramVec(
    prometheus.HistogramOpts{
        Name:    "model_router_http_request_duration_seconds",
        Help:    "HTTP request duration in seconds",
        Buckets: prometheus.DefBuckets,
    },
    []string{"method", "path"},
)

routingDecisions = prometheus.NewCounterVec(
    prometheus.CounterOpts{
        Name: "model_router_routing_decisions_total",
        Help: "Total number of routing decisions",
    },
    []string{"strategy", "model_id", "success"},
)

// 代码位置: cmd/model-router/internal/service/model_router_service.go:10-29
type ModelRouterService struct {
    routingService  *application.RoutingService      // 路由决策
    costOptimizer   *application.CostOptimizer       // 成本优化
    fallbackManager *application.FallbackManager     // 故障转移
    abTestService   *application.ABTestingServiceV2  // A/B测试
}

// 代码位置: cmd/model-router/internal/service/model_router_service.go:33-63
func (s *ModelRouterService) Route(ctx context.Context, req *application.RoutingRequest) (*application.RoutingResponse, error) {
    // 1. 执行路由决策
    response, err := s.routingService.Route(ctx, req)
    if err != nil {
        return nil, err
    }

    // 2. 成本优化（可选）
    if s.costOptimizer != nil {
        selectedModel, _ := s.routingService.GetModelInfo(response.ModelID)
        optimizedModel, err := s.costOptimizer.OptimizeRoute(ctx, req, selectedModel)
        if err == nil && optimizedModel != nil && optimizedModel.ModelID != selectedModel.ModelID {
            // 使用优化后的模型
            response = &application.RoutingResponse{
                ModelID:          optimizedModel.ModelID,
                ModelName:        optimizedModel.ModelName,
                Provider:         optimizedModel.Provider,
                EstimatedCost:    optimizedModel.EstimateCost(estimatedInputTokens, req.MaxTokens),
                EstimatedLatency: optimizedModel.AvgLatency,
                Reason:           "Cost optimized: " + response.Reason,
            }
        }
    }

    return response, nil
}

// 代码位置: cmd/model-router/internal/application/routing_service.go:194-245
func (s *RoutingService) getCandidates(req *RoutingRequest) ([]*domain.ModelInfo, error) {
    allModels := s.registry.ListAll()

    for _, model := range allModels {
        // 1. 健康状态检查
        if !model.IsHealthy() {
            continue
        }

        // 2. 提供商过滤
        if req.Provider != nil && model.Provider != *req.Provider {
            continue
        }

        // 3. 能力检查
        if req.Capability != nil && !model.HasCapability(*req.Capability) {
            continue
        }

        // 4. 流式能力检查
        if req.Streaming && !model.HasCapability(domain.CapabilityStreaming) {
            continue
        }

        // 5. 上下文长度检查
        if req.MinContextLength > 0 && model.ContextLength < req.MinContextLength {
            continue
        }

        // 6. 成本限制检查
        if req.MaxCost != nil {
            estimatedCost := model.EstimateCost(estimatedInputTokens, req.MaxTokens)
            if estimatedCost > *req.MaxCost {
                continue
            }
        }

        // 7. 延迟限制检查
        if req.MaxLatency != nil && model.AvgLatency > *req.MaxLatency {
            continue
        }

        candidates = append(candidates, model)
    }

    return candidates, nil
}

// 代码位置: cmd/model-router/internal/application/fallback_manager.go:21-48
type CircuitBreaker struct {
    config           *CircuitBreakerConfig
    state            CircuitState  // Closed/Open/Half-Open
    failureCount     int           // 失败计数
    successCount     int           // 成功计数
    lastFailureTime  time.Time     // 最后失败时间
    halfOpenRequests int           // 半开状态请求数
}

// 默认配置
FailureThreshold: 5          // 失败5次打开熔断器
SuccessThreshold: 2          // 成功2次关闭熔断器
Timeout:          30s        // 超时30秒后进入半开状态
HalfOpenRequests: 3          // 半开状态允许3个试探请求

// 代码位置: cmd/model-router/internal/application/fallback_manager.go:166-201
// GPT-4 降级链
openai-gpt-4 → openai-gpt-3.5-turbo-16k → openai-gpt-3.5-turbo

// Claude Opus 降级链
claude-3-opus → claude-3-sonnet → openai-gpt-3.5-turbo

// GPT-3.5 降级链
openai-gpt-3.5-turbo → zhipu-glm-4

// 代码位置: cmd/model-router/internal/application/fallback_manager.go:250-274
func (m *FallbackManager) ExecuteWithFallback(
    ctx context.Context,
    modelID string,
    executor func(string) error,
) error {
    // 1. 检查熔断器
    if !m.allowRequest(modelID) {
        return m.tryFallback(ctx, modelID, executor)  // 直接降级
    }

    // 2. 尝试执行
    err := executor(modelID)
    if err == nil {
        m.recordSuccess(modelID)
        return nil
    }

    // 3. 失败，记录并降级
    m.recordFailure(modelID)
    return m.tryFallback(ctx, modelID, executor)
}

// 代码位置: cmd/model-router/internal/application/cost_optimizer.go:12-17
type BudgetConfig struct {
    DailyBudget    float64  // 每日预算 (USD)
    WeeklyBudget   float64  // 每周预算 (USD)
    MonthlyBudget  float64  // 每月预算 (USD)
    AlertThreshold float64  // 告警阈值 (0-1, 默认0.8)
}

// 代码位置: cmd/model-router/internal/application/cost_optimizer.go:119-143
func (o *CostOptimizer) shouldDowngrade() bool {
    dailyCost := o.getDailyCost()
    usageRate := dailyCost / o.budgetConfig.DailyBudget
    return usageRate > 0.8  // 使用率 > 80% 降级
}

func (o *CostOptimizer) canUpgrade() bool {
    dailyCost := o.getDailyCost()
    usageRate := dailyCost / o.budgetConfig.DailyBudget
    return usageRate < 0.5  // 使用率 < 50% 可升级
}

// 代码位置: cmd/model-router/internal/application/cost_optimizer.go:58-83
func (o *CostOptimizer) OptimizeRoute(ctx context.Context, req *RoutingRequest, currentModel *domain.ModelInfo) (*domain.ModelInfo, error) {
    // 1. 检查预算
    if err := o.checkBudget(ctx); err != nil {
        return nil, err  // 预算超限
    }

    // 2. 检查是否需要降级
    if o.shouldDowngrade() {
        cheaper, _ := o.findCheaperAlternative(currentModel, req)
        if cheaper != nil {
            return cheaper, nil  // 返回更便宜的模型
        }
    }

    // 3. 检查是否可以升级
    if o.canUpgrade() {
        better, _ := o.findBetterAlternative(currentModel, req)
        if better != nil {
            return better, nil  // 返回更好的模型
        }
    }

    return currentModel, nil
}

// 代码位置: cmd/model-router/internal/application/cost_optimizer.go:278-328
func (o *CostOptimizer) GetRecommendations() []*OptimizationRecommendation {
    var recommendations []*OptimizationRecommendation

    // 1. 检查高成本模型（单个模型 > 30%总成本）
    for modelID, cost := range o.usageStats.CostByModel {
        if cost > o.usageStats.TotalCost*0.3 {
            recommendations = append(recommendations, &OptimizationRecommendation{
                Type:        "high_cost_model",
                Description: fmt.Sprintf("Model %s accounts for %.1f%% of total cost", modelName, percent),
                Impact:      "Consider using cheaper alternatives for non-critical tasks",
                Savings:     cost * 0.5,  // 预计节省50%
            })
        }
    }

    // 2. 检查GPT-4过度使用
    if gpt4Cost > 0 {
        recommendations = append(recommendations, &OptimizationRecommendation{
            Type:        "expensive_model",
            Description: "GPT-4 is being used extensively",
            Impact:      "Consider using GPT-3.5-turbo for simpler tasks (10x cheaper)",
            Savings:     gpt4Cost * 0.9,  // 预计节省90%
        })
    }

    // 3. 检查预算告警
    if usageRate > 0.8 {
        recommendations = append(recommendations, &OptimizationRecommendation{
            Type:        "budget_warning",
            Description: fmt.Sprintf("Daily budget usage: %.1f%%", usageRate*100),
            Impact:      "Budget limit may be exceeded soon",
        })
    }

    return recommendations
}

sequenceDiagram
    autonumber
    participant Client as 客户端<br/>(Agent Engine)
    participant HTTPServer as HTTP Server<br/>(Gin)
    participant Middleware as 中间件管道<br/>Recovery/Logging/Metrics
    participant Service as Model Router<br/>Service
    participant RoutingService as Routing Service<br/>路由决策
    participant CostOptimizer as Cost Optimizer<br/>成本优化
    participant FallbackMgr as Fallback Manager<br/>熔断器
    participant Registry as Model Registry<br/>内存缓存
    participant ModelInfo as ModelInfo<br/>模型信息
    participant LLM as LLM Provider<br/>OpenAI/Claude

    Note over Client,LLM: 阶段1: 路由请求处理

    Client->>HTTPServer: POST /api/v1/route<br/>{"prompt":"...", "max_tokens":1000,<br/>"strategy":"cheapest"}
    HTTPServer->>Middleware: 处理请求

    Middleware->>Middleware: 1. Recovery (捕获panic)
    Middleware->>Middleware: 2. Logging (记录请求)
    Middleware->>Middleware: 3. Metrics (Prometheus)

    Middleware->>Service: Route(ctx, req)

    Service->>RoutingService: Route(ctx, req)

    Note over RoutingService: 检查是否启用A/B测试

    RoutingService->>Registry: ListAll() 获取所有模型
    Registry-->>RoutingService: [model1...modelN]

    RoutingService->>RoutingService: getCandidates(req)<br/>过滤候选模型

    Note over RoutingService: 7层过滤:<br/>1.健康状态 2.提供商<br/>3.能力 4.流式 5.上下文<br/>6.成本约束 7.延迟约束

    RoutingService->>Registry: Get(modelID) 获取每个候选模型
    loop 每个候选模型
        Registry-->>RoutingService: ModelInfo{<br/>availability, latency,<br/>cost, capabilities}
    end

    alt 策略: cheapest
        RoutingService->>RoutingService: selectCheapest()<br/>计算成本并排序<br/>O(n log n)
    else 策略: fastest
        RoutingService->>RoutingService: selectFastest()<br/>按延迟排序<br/>O(n log n)
    else 策略: round_robin
        RoutingService->>RoutingService: selectRoundRobin()<br/>轮询选择 O(1)
    end

    RoutingService->>ModelInfo: EstimateCost(inputTokens, outputTokens)
    ModelInfo-->>RoutingService: estimatedCost

    RoutingService-->>Service: RoutingResponse{<br/>modelID, estimatedCost,<br/>estimatedLatency, reason}

    Note over Service: 成本优化阶段（可选）

    Service->>CostOptimizer: OptimizeRoute(ctx, req, selectedModel)

    CostOptimizer->>CostOptimizer: checkBudget()<br/>检查每日/周/月预算

    alt 预算使用率 > 80%
        CostOptimizer->>CostOptimizer: shouldDowngrade() = true
        CostOptimizer->>Registry: findCheaperAlternative()
        Registry-->>CostOptimizer: cheaperModel
        CostOptimizer-->>Service: optimizedModel (更便宜)
    else 预算使用率 < 50%
        CostOptimizer->>CostOptimizer: canUpgrade() = true
        CostOptimizer->>Registry: findBetterAlternative()
        Registry-->>CostOptimizer: betterModel
        CostOptimizer-->>Service: optimizedModel (更好)
    else 预算正常
        CostOptimizer-->>Service: 保持原模型
    end

    Service-->>HTTPServer: RoutingResponse
    HTTPServer->>Middleware: 记录指标
    Middleware->>Middleware: Prometheus: routingDecisions++
    HTTPServer-->>Client: 200 OK<br/>{"model_id":"gpt-3.5-turbo",<br/>"estimated_cost":0.002,<br/>"reason":"Cheapest model"}

    Note over Client,LLM: 阶段2: 客户端调用LLM

    Client->>LLM: 根据路由结果调用<br/>使用model的endpoint和apiKey
    LLM-->>Client: LLM响应<br/>success/failure + tokens + latency

    Note over Client,LLM: 阶段3: 记录使用情况

    Client->>HTTPServer: POST /api/v1/usage<br/>{"model_id":"...", "input_tokens":800,<br/>"output_tokens":200, "success":true,<br/>"latency":1250}
    HTTPServer->>Service: RecordUsage(...)

    Service->>Registry: UpdateMetrics(modelID, latency, success)
    Registry->>Registry: 更新ModelInfo的<br/>avgLatency, availability, errorRate

    Service->>CostOptimizer: RecordUsage(modelID, tokens, cost)
    CostOptimizer->>CostOptimizer: usageStats.TotalCost += cost<br/>usageStats.CostByModel[id] += cost

    Service->>FallbackMgr: recordSuccess/recordFailure(modelID)

    alt 请求成功
        FallbackMgr->>FallbackMgr: CircuitBreaker.RecordSuccess()<br/>failureCount = 0<br/>successCount++

        alt state==Half-Open && successCount>=2
            FallbackMgr->>FallbackMgr: state = Closed<br/>熔断器关闭，恢复正常
        end
    else 请求失败
        FallbackMgr->>FallbackMgr: CircuitBreaker.RecordFailure()<br/>failureCount++<br/>successCount = 0

        alt failureCount >= 5
            FallbackMgr->>FallbackMgr: state = Open<br/>熔断器打开，拒绝请求
        end
    end

    Service-->>HTTPServer: success
    HTTPServer-->>Client: 200 OK

    Note over Client,LLM: 阶段4: 后台健康检查（异步，每60秒）

    Note over Registry: 定时器触发健康检查

    loop 每个已注册模型
        Registry->>LLM: 探测请求 (timeout 10s)<br/>简单completion测试

        alt 响应正常
            LLM-->>Registry: 200 OK, latency=250ms
            Registry->>Registry: 更新availability=1.0<br/>更新avgLatency
        else 超时或错误
            LLM-->>Registry: Timeout / 500 Error
            Registry->>Registry: consecutiveFails++

            alt consecutiveFails >= 3
                Registry->>Registry: 标记为不健康<br/>availability=0.0
                Registry->>FallbackMgr: 通知熔断器打开
            end
        end
    end

sequenceDiagram
    autonumber
    participant Timer as 定时器<br/>(60s间隔)
    participant HealthChecker as Health Checker
    participant ModelRegistry as Model Registry
    participant AdapterClient as Adapter Client
    participant ModelAdapter as Model Adapter
    participant LLM1 as OpenAI GPT-4
    participant LLM2 as Claude Opus
    participant FallbackMgr as Fallback Manager
    participant CircuitBreaker as Circuit Breaker

    Note over Timer,CircuitBreaker: 定期健康检查流程

    Timer->>HealthChecker: 触发健康检查
    HealthChecker->>ModelRegistry: ListModels()
    ModelRegistry-->>HealthChecker: [GPT-4, Claude, Gemini, ...]

    HealthChecker->>AdapterClient: BatchHealthCheck(models)

    par 并行探测
        AdapterClient->>ModelAdapter: CheckHealth(GPT-4)
        ModelAdapter->>LLM1: 测试请求 (timeout 10s)
        alt 响应正常
            LLM1-->>ModelAdapter: 200 OK (latency 250ms)
            ModelAdapter-->>AdapterClient: {status: healthy, latency: 250ms}
        else 超时或错误
            LLM1-->>ModelAdapter: Timeout / 500 Error
            ModelAdapter-->>AdapterClient: {status: unhealthy, error: "timeout"}
        end
    and
        AdapterClient->>ModelAdapter: CheckHealth(Claude)
        ModelAdapter->>LLM2: 测试请求 (timeout 10s)
        LLM2-->>ModelAdapter: 500 Internal Error
        ModelAdapter-->>AdapterClient: {status: unhealthy, error: "500"}
    end

    AdapterClient-->>HealthChecker: 批量探测结果

    HealthChecker->>HealthChecker: 分析健康状态

    loop 处理每个模型结果
        alt 探测失败
            HealthChecker->>HealthChecker: consecutiveFails++
            alt consecutiveFails >= 3
                HealthChecker->>FallbackMgr: MarkUnavailable(modelID)
                FallbackMgr->>CircuitBreaker: RecordFailure()
                CircuitBreaker->>CircuitBreaker: failureCount++
                alt failureCount >= 5
                    CircuitBreaker->>CircuitBreaker: state = Open<br/>记录lastFailureTime
                    Note over CircuitBreaker: 熔断器打开<br/>拒绝所有请求30秒
                end
                FallbackMgr->>ModelRegistry: UpdateAvailability(modelID, false)
            end
        else 探测成功
            HealthChecker->>HealthChecker: consecutiveFails = 0
            alt 之前标记为不可用
                HealthChecker->>FallbackMgr: MarkAvailable(modelID)
                FallbackMgr->>CircuitBreaker: RecordSuccess()
                CircuitBreaker->>CircuitBreaker: successCount++
                alt state == Half-Open && successCount >= 2
                    CircuitBreaker->>CircuitBreaker: state = Closed<br/>重置计数器
                    Note over CircuitBreaker: 熔断器关闭<br/>恢复正常
                end
                FallbackMgr->>ModelRegistry: UpdateAvailability(modelID, true)
            end
        end
    end

    HealthChecker->>HealthChecker: 记录健康摘要日志

    Note over Timer,CircuitBreaker: 熔断器自动恢复（30秒后）

    CircuitBreaker->>CircuitBreaker: 检查时间间隔
    alt time.Since(lastFailureTime) > 30s
        CircuitBreaker->>CircuitBreaker: state = Half-Open<br/>允许试探请求
        Note over CircuitBreaker: 半开状态<br/>允许3个试探请求
    end

// 代码位置: routing_service.go:247-264
func selectCheapest(candidates []*ModelInfo, req *RoutingRequest) (*ModelInfo, string) {
    estimatedInputTokens := len(req.Prompt) / 4

    sort.Slice(candidates, func(i, j int) bool {
        costI := candidates[i].EstimateCost(estimatedInputTokens, req.MaxTokens)
        costJ := candidates[j].EstimateCost(estimatedInputTokens, req.MaxTokens)
        return costI < costJ
    })

    return candidates[0], fmt.Sprintf("Cheapest model (cost: $%.6f)", cost)
}

// 代码位置: routing_service.go:268-280
func selectFastest(candidates []*ModelInfo) (*ModelInfo, string) {
    sort.Slice(candidates, func(i, j int) bool {
        return candidates[i].AvgLatency < candidates[j].AvgLatency
    })

    return candidates[0], fmt.Sprintf("Fastest model (latency: %v)", selected.AvgLatency)
}

// 代码位置: routing_service.go:283-295
func selectMostAvailable(candidates []*ModelInfo) (*ModelInfo, string) {
    sort.Slice(candidates, func(i, j int) bool {
        return candidates[i].Availability > candidates[j].Availability
    })

    return candidates[0], fmt.Sprintf("Most available model (%.2f%%)", selected.Availability*100)
}

availability = successCount / totalRequests
// 示例：980次成功 / 1000次请求 = 0.98 (98%)

// 代码位置: routing_service.go:298-322
func selectBestQuality(candidates []*ModelInfo) (*ModelInfo, string) {
    // 综合评分: 可用性40% + 低错误率30% + 上下文长度30%
    for _, model := range candidates {
        score := model.Availability*0.4 +
                 (1-model.ErrorRate)*0.3 +
                 float64(model.ContextLength)/200000.0*0.3
    }

    // 选择评分最高的模型
    return bestModel, fmt.Sprintf("Best quality (score: %.2f)", bestScore)
}

// 代码位置: routing_service.go:324-342
func selectRoundRobin(candidates []*ModelInfo, req *RoutingRequest) (*ModelInfo, string) {
    key := "all"
    if req.Provider != nil {
        key = string(*req.Provider)
    }

    idx := s.roundRobinIdx[key] % len(candidates)
    selected := candidates[idx]
    s.roundRobinIdx[key] = (idx + 1) % len(candidates)

    return selected, "Round-robin selection"
}

// 代码位置: routing_service.go:345-355
func selectRandom(candidates []*ModelInfo) (*ModelInfo, string) {
    rand.Seed(time.Now().UnixNano())
    idx := rand.Intn(len(candidates))
    return candidates[idx], "Random selection"
}

P(系统可用) = 1 - P(所有模型同时不可用)
            = 1 - (1 - 0.995)^3  // 假设3个模型
            = 1 - 0.000000125
            = 99.9999875%

classDiagram
    class Model {
        +string ID
        +string Name
        +string DisplayName
        +ModelProvider Provider
        +ModelType Type
        +ModelStatus Status
        +string Endpoint
        +string APIKey
        +int MaxTokens
        +int ContextWindow
        +float64 InputPricePerK
        +float64 OutputPricePerK
        +int Priority
        +int Weight
        +int Timeout
        +int RetryCount
        +int RateLimit
        +[]string Capabilities
        +map Metadata
        +time CreatedAt
        +time UpdatedAt
        +Update(displayName, endpoint)
        +UpdatePricing(input, output)
        +SetPriority(priority) error
        +SetWeight(weight) error
        +Activate()
        +Deactivate()
        +IsAvailable() bool
        +CalculateCost(in, out) float64
        +HasCapability(cap) bool
        +Validate() error
    }

    class ModelProvider {
        <<enumeration>>
        OPENAI
        ANTHROPIC
        GOOGLE
        COHERE
        HUGGINGFACE
        LOCAL
    }

    class ModelType {
        <<enumeration>>
        CHAT
        EMBEDDING
        COMPLETION
        IMAGE
    }

    class ModelStatus {
        <<enumeration>>
        ACTIVE
        INACTIVE
        MAINTENANCE
        DEPRECATED
    }

    class RouteRequest {
        +string ID
        +ModelType ModelType
        +RoutingStrategy Strategy
        +[]string RequiredCapabilities
        +ModelProvider PreferredProvider
        +map Context
    }

    class RouteResult {
        +string RequestID
        +Model* SelectedModel
        +[]Model* AlternativeModels
        +RoutingStrategy Strategy
        +string Reason
        +time Timestamp
    }

    class RoutingStrategy {
        <<enumeration>>
        PRIORITY
        ROUND_ROBIN
        WEIGHTED
        LEAST_LATENCY
        LEAST_COST
        RANDOM
    }

    class ModelMetrics {
        +string ModelID
        +int TotalRequests
        +int SuccessCount
        +int FailureCount
        +float64 SuccessRate
        +float64 AvgLatencyMs
        +float64 P95LatencyMs
        +float64 P99LatencyMs
        +int TotalTokens
        +float64 TotalCost
        +time LastRequestAt
        +time UpdatedAt
        +IsHealthy() bool
        +CalculateSuccessRate()
    }

    Model --> ModelProvider
    Model --> ModelType
    Model --> ModelStatus
    RouteRequest --> ModelType
    RouteRequest --> RoutingStrategy
    RouteRequest --> ModelProvider
    RouteResult --> Model
    RouteResult --> RoutingStrategy
    ModelMetrics --> Model : tracks

type RouteRequest struct {
    RequestID            string   `json:"request_id" binding:"required"`         // 请求ID
    ModelType            string   `json:"model_type" binding:"required"`         // 模型类型
    Strategy             string   `json:"strategy"`                              // 路由策略
    RequiredCapabilities []string `json:"required_capabilities"`                 // 必需能力
    PreferredProvider    string   `json:"preferred_provider"`                    // 偏好提供商
    Context              map[string]interface{} `json:"context"`                // 上下文
}

type RouteResponse struct {
    RequestID         string       `json:"request_id"`          // 请求ID
    SelectedModel     *ModelInfo   `json:"selected_model"`      // 选中的模型
    AlternativeModels []*ModelInfo `json:"alternative_models"`  // 备选模型
    Strategy          string       `json:"strategy"`            // 使用的策略
    Reason            string       `json:"reason"`              // 选择原因
    Timestamp         string       `json:"timestamp"`           // 路由时间戳
}

type ModelInfo struct {
    ID            string   `json:"id"`              // 模型ID
    Name          string   `json:"name"`            // 模型名称
    DisplayName   string   `json:"display_name"`    // 显示名称
    Provider      string   `json:"provider"`        // 提供商
    Type          string   `json:"type"`            // 模型类型
    Endpoint      string   `json:"endpoint"`        // API端点
    APIKey        string   `json:"api_key"`         // API密钥（masked）
    MaxTokens     int      `json:"max_tokens"`      // 最大Token数
    ContextWindow int      `json:"context_window"`  // 上下文窗口
    Timeout       int      `json:"timeout"`         // 超时时间
    RetryCount    int      `json:"retry_count"`     // 重试次数
    Capabilities  []string `json:"capabilities"`    // 能力列表
}

// 路由请求入口
func (uc *RouterUsecase) Route(
    ctx context.Context,
    req *domain.RouteRequest,
) (*domain.RouteResult, error) {
    // 1. 获取可用模型列表
    models, err := uc.modelRepo.ListAvailable(ctx, req.ModelType)
    if err != nil {
        return nil, err
    }

    if len(models) == 0 {
        return nil, domain.ErrNoAvailableModel
    }

    // 2. 过滤：根据能力要求
    models = uc.filterByCapabilities(models, req.RequiredCapabilities)
    if len(models) == 0 {
        return nil, domain.ErrCapabilityNotSupported
    }

    // 3. 过滤：根据偏好提供商
    if req.PreferredProvider != "" {
        preferredModels := uc.filterByProvider(models, req.PreferredProvider)
        if len(preferredModels) > 0 {
            models = preferredModels
        }
    }

    // 4. 根据策略选择模型
    var selectedModel *domain.Model
    var reason string

    switch req.Strategy {
    case domain.StrategyPriority:
        selectedModel, reason = uc.selectByPriority(models)
    case domain.StrategyRoundRobin:
        selectedModel, reason = uc.selectByRoundRobin(models, string(req.ModelType))
    case domain.StrategyWeighted:
        selectedModel, reason = uc.selectByWeight(models)
    case domain.StrategyLeastLatency:
        selectedModel, reason = uc.selectByLeastLatency(ctx, models)
    case domain.StrategyLeastCost:
        selectedModel, reason = uc.selectByLeastCost(models)
    case domain.StrategyRandom:
        selectedModel, reason = uc.selectRandom(models)
    default:
        selectedModel, reason = uc.selectByPriority(models)
    }

    // 5. 构建结果
    result := domain.NewRouteResult(req.ID, selectedModel, req.Strategy, reason)

    // 6. 添加备选模型
    for _, m := range models {
        if m.ID != selectedModel.ID {
            result.AlternativeModels = append(result.AlternativeModels, m)
        }
    }

    // （省略日志记录）

    return result, nil
}

// 按优先级选择
func (uc *RouterUsecase) selectByPriority(models []*domain.Model) (*domain.Model, string) {
    // 按优先级降序排序
    sort.Slice(models, func(i, j int) bool {
        return models[i].Priority > models[j].Priority
    })

    return models[0], fmt.Sprintf("highest priority: %d", models[0].Priority)
}

// 轮询选择
func (uc *RouterUsecase) selectByRoundRobin(models []*domain.Model, key string) (*domain.Model, string) {
    uc.mu.Lock()
    defer uc.mu.Unlock()

    index := uc.roundRobinIndex[key]
    selected := models[index%len(models)]
    uc.roundRobinIndex[key] = (index + 1) % len(models)

    return selected, "round robin"
}

// 加权选择
func (uc *RouterUsecase) selectByWeight(models []*domain.Model) (*domain.Model, string) {
    // 计算总权重
    totalWeight := 0
    for _, model := range models {
        totalWeight += model.Weight
    }

    // 加权随机选择
    random := rand.Intn(totalWeight)
    cumulative := 0
    for _, model := range models {
        cumulative += model.Weight
        if random < cumulative {
            return model, fmt.Sprintf("weighted: %d/%d", model.Weight, totalWeight)
        }
    }

    return models[0], "fallback"
}

// 按最低延迟选择
func (uc *RouterUsecase) selectByLeastLatency(ctx context.Context, models []*domain.Model) (*domain.Model, string) {
    // 获取所有模型的指标
    metricsMap := make(map[string]*domain.ModelMetrics)
    for _, model := range models {
        metrics, err := uc.metricsRepo.GetByModelID(ctx, model.ID)
        if err == nil {
            metricsMap[model.ID] = metrics
        }
    }

    // 选择延迟最低的
    var selected *domain.Model
    minLatency := float64(999999)

    for _, model := range models {
        if metrics, exists := metricsMap[model.ID]; exists {
            if metrics.AvgLatencyMs < minLatency {
                minLatency = metrics.AvgLatencyMs
                selected = model
            }
        }
    }

    if selected == nil {
        return models[0], "no metrics, fallback to first"
    }

    return selected, fmt.Sprintf("lowest latency: %.2fms", minLatency)
}

// 按最低成本选择
func (uc *RouterUsecase) selectByLeastCost(models []*domain.Model) (*domain.Model, string) {
    // 按平均价格排序（输入+输出平均）
    sort.Slice(models, func(i, j int) bool {
        avgI := (models[i].InputPricePerK + models[i].OutputPricePerK) / 2.0
        avgJ := (models[j].InputPricePerK + models[j].OutputPricePerK) / 2.0
        return avgI < avgJ
    })

    selected := models[0]
    avgPrice := (selected.InputPricePerK + selected.OutputPricePerK) / 2.0

    return selected, fmt.Sprintf("lowest cost: $%.4f/1K", avgPrice)
}