企业多模型路由架构实战：从单模型依赖到智能调度

interface ModelConfig {
  id: string;
  provider: string;
  endpoint: string;
  apiKey: string;
  capabilities: string[];  // ['code', 'chat', 'analysis', 'creative']
  costPerToken: number;
  maxTokens: number;
  latency: number;  // p50 latency in ms
  availability: number;  // 0-1
}

interface RoutingRequest {
  type: 'code' | 'chat' | 'analysis' | 'creative';
  prompt: string;
  maxTokens: number;
  qualityThreshold?: number;  // 0-1, minimum quality score
  budgetLimit?: number;  // max cost per request
}

class ModelRouter {
  private models: ModelConfig[];
  
  constructor(models: ModelConfig[]) {
    this.models = models;
  }

  async route(req: RoutingRequest): Promise<string> {
    // 1. 过滤：只保留支持该能力的模型
    const capable = this.models.filter(m => 
      m.capabilities.includes(req.type)
    );

    // 2. 评分：对每个候选模型打分
    const scored = capable.map(m => ({
      model: m,
      score: this.calculateScore(m, req)
    }));

    // 3. 排序：按分数降序
    scored.sort((a, b) => b.score - a.score);

    // 4. 选择：返回最高分的模型
    return scored[0].model.id;
  }

  private calculateScore(model: ModelConfig, req: RoutingRequest): number {
    // 综合评分 = 质量 * 0.4 + 成本 * 0.3 + 可用性 * 0.2 + 速度 * 0.1
    const qualityScore = this.getQualityScore(model, req.type);
    const costScore = 1 - (model.costPerToken / 0.0001); // 归一化
    const availabilityScore = model.availability;
    const speedScore = 1 - (model.latency / 5000); // 归一化

    return qualityScore * 0.4 + costScore * 0.3 + 
           availabilityScore * 0.2 + speedScore * 0.1;
  }

  private getQualityScore(model: ModelConfig, type: string): number {
    // 基于 benchmark 数据的质量评分
    const scores: Record<string, Record<string, number>> = {
      'deepseek-v4': { code: 0.95, chat: 0.85, analysis: 0.90, creative: 0.75 },
      'minimax-m2.5': { code: 0.85, chat: 0.90, analysis: 0.85, creative: 0.88 },
      'glm-5.2': { code: 0.80, chat: 0.88, analysis: 0.92, creative: 0.82 },
    };
    return scores[model.id]?.[type] ?? 0.5;
  }
}

class FallbackManager {
  private cache: Map<string, { result: string; timestamp: number }>;
  private healthStatus: Map<string, boolean>;

  async executeWithFallback(
    req: RoutingRequest,
    router: ModelRouter
  ): Promise<string> {
    // Level 1: 尝试主模型
    const primaryModel = await router.route(req);
    try {
      return await this.callModel(primaryModel, req);
    } catch (e) {
      console.warn(`Primary model ${primaryModel} failed, fallback...`);
    }

    // Level 1b: 同能力备用模型
    const backups = router.getBackups(req.type);
    for (const backup of backups) {
      try {
        return await this.callModel(backup, req);
      } catch (e) {
        continue;
      }
    }

    // Level 2: 通用模型
    try {
      return await this.callModel('general-fallback', req);
    } catch (e) {
      console.error('All models failed');
    }

    // Level 3: 缓存降级
    const cached = this.getFromCache(req.prompt);
    if (cached && Date.now() - cached.timestamp < 3600000) {
      return cached.result + '\n[注: 此为缓存结果，非实时生成]';
    }

    throw new Error('All fallback options exhausted');
  }

  private getFromCache(key: string) {
    return this.cache.get(this.hashKey(key));
  }

  private hashKey(key: string): string {
    // 简化：实际应使用语义相似度匹配
    return key.slice(0, 100);
  }

  private async callModel(modelId: string, req: RoutingRequest): Promise<string> {
    // 实际调用逻辑
    throw new Error('Not implemented');
  }
}