AI 编排层：企业模型选择的真正战场

function routeRequest(task: Task): Model {
  if (task.type === 'classification' && task.complexity < 0.3) {
    return '7b-model';  // 简单分类任务
  } else if (task.type === 'reasoning' && task.complexity < 0.7) {
    return '70b-model';  // 中等推理任务
  } else {
    return 'gpt-5.5';    // 复杂任务
  }
}

async function routeByPerformance(task: Task): Promise<Model> {
  const models = await getAvailableModels();
  
  // 选择质量得分 / 成本 比值最高的模型
  const bestModel = models
    .filter(m => m.supports(task.type))
    .sort((a, b) => {
      const scoreA = a.qualityScore / a.costPerToken;
      const scoreB = b.qualityScore / b.costPerToken;
      return scoreB - scoreA;
    })[0];
  
  return bestModel.id;
}

class RoutingAgent:
    def __init__(self):
        self.policy = PolicyNetwork()
        self.optimizer = torch.optim.Adam(self.policy.parameters())
    
    def select_model(self, task_embedding):
        # 根据任务特征选择模型
        model_probs = self.policy(task_embedding)
        model_id = torch.argmax(model_probs)
        return model_id
    
    def update(self, task, model_id, quality, cost, latency):
        # 根据结果更新策略
        reward = quality - cost_weight * cost - latency_weight * latency
        self.policy.update(task, model_id, reward)

async function activePassiveRoute(task: Task): Promise<Response> {
  try {
    return await callModel('primary-model', task);
  } catch (error) {
    console.warn('Primary model failed, switching to backup');
    return await callModel('backup-model', task);
  }
}

async function activeActiveRoute(task: Task): Promise<Response> {
  const responses = await Promise.all([
    callModel('model-a', task),
    callModel('model-b', task),
    callModel('model-c', task),
  ]);
  
  // 选择质量得分最高的
  return responses.sort((a, b) => b.quality - a.quality)[0];
}

async function gracefulDegradation(task: Task): Promise<Response> {
  const models = ['gpt-5.5', 'claude-opus-4.8', 'gemini-2.5-pro', '7b-fallback'];
  
  for (const model of models) {
    try {
      const response = await callModel(model, task);
      if (response.quality >= task.minQuality) {
        return response;
      }
    } catch (error) {
      console.warn(\`Model \${model} failed, trying next\`);
    }
  }
  
  throw new Error('All models failed');
}

// ❌ 错误：直接耦合 OpenAI API
import OpenAI from 'openai';
const client = new OpenAI();

async function analyzeSentiment(text: string) {
  const response = await client.chat.completions.create({
    model: 'gpt-5.5',
    messages: [{ role: 'user', content: \`Analyze sentiment: \${text}\` }],
  });
  return response.choices[0].message.content;
}

// ✅ 正确：通过抽象层
interface AIProvider {
  chat(messages: Message[]): Promise<string>;
  supports(taskType: TaskType): boolean;
  getCost(): CostInfo;
}

class OpenAIProvider implements AIProvider {
  async chat(messages: Message[]): Promise<string> {
    // OpenAI 特定实现
  }
  supports(taskType: TaskType): boolean {
    return ['reasoning', 'coding', 'analysis'].includes(taskType);
  }
  getCost(): CostInfo {
    return { perToken: 0.000015 };
  }
}

class AnthropicProvider implements AIProvider {
  // Anthropic 特定实现
}

// 业务逻辑通过抽象层调用
async function analyzeSentiment(text: string, provider: AIProvider) {
  return await provider.chat([
    { role: 'user', content: \`Analyze sentiment: \${text}\` }
  ]);
}

class PromptTemplate {
  private templates: Record<string, string> = {
    'openai': 'Analyze the sentiment of the following text. Respond with JSON: {"sentiment": "positive|negative|neutral", "confidence": 0-1}\\n\\nText: {text}',
    'anthropic': 'You are a sentiment analysis expert. Analyze the text and respond in JSON format with "sentiment" and "confidence" fields.\\n\\nText: {text}',
    'local': 'Sentiment: {text}\\nOutput: ',
  };

  render(model: string, text: string): string {
    const template = this.templates[model] || this.templates['openai'];
    return template.replace('{text}', text);
  }
}

interface NormalizedResponse {
  content: string;
  model: string;
  latency: number;
  cost: number;
  quality?: number;
}

function normalizeResponse(provider: string, raw: any): NormalizedResponse {
  switch (provider) {
    case 'openai':
      return {
        content: raw.choices[0].message.content,
        model: raw.model,
        latency: raw.usage.latency_ms,
        cost: raw.usage.total_tokens * 0.000015,
      };
    case 'anthropic':
      return {
        content: raw.content[0].text,
        model: raw.model,
        latency: raw.usage.latency_ms,
        cost: raw.usage.input_tokens * 0.000003 + raw.usage.output_tokens * 0.000015,
      };
    default:
      throw new Error(\`Unknown provider: \${provider}\`);
  }
}

const routingRules = {
  'order_status': { model: '7b', cost: 0.000001 },
  'return_policy': { model: '7b', cost: 0.000001 },
  'product_recommendation': { model: '70b', cost: 0.000005 },
  'complaint_handling': { model: '70b', cost: 0.000005 },
  'dispute_resolution': { model: 'gpt-5.5', cost: 0.000015 },
  'legal_inquiry': { model: 'gpt-5.5', cost: 0.000015 },
};

async function routeByPricing(task: Task): Promise<Model> {
  const models = await getAvailableModels();
  const currentPrices = await getCurrentPricing(models);
  
  // 选择性价比最高的模型
  const bestValue = models
    .filter(m => m.supports(task.type))
    .sort((a, b) => {
      const valueA = a.qualityScore / currentPrices[a.id];
      const valueB = b.qualityScore / currentPrices[b.id];
      return valueB - valueA;
    })[0];
  
  return bestValue.id;
}

class BatchOptimizer {
  private queue: Task[] = [];
  private batchSize = 10;
  private flushInterval = 1000; // 1 秒

  async submit(task: Task): Promise<Response> {
    this.queue.push(task);
    
    if (this.queue.length >= this.batchSize) {
      await this.flush();
    }
    
    return task.promise;
  }

  private async flush() {
    const batch = this.queue.splice(0, this.batchSize);
    
    // 批量调用可能有折扣
    const responses = await callModelBatch('7b-model', batch);
    
    batch.forEach((task, i) => {
      task.resolve(responses[i]);
    });
  }
}

class CostMonitor {
  private dailyBudget = 1000; // $1000/天
  private hourlyBudget = 50;  // $50/小时
  private currentDailyCost = 0;
  private currentHourlyCost = 0;

  track(cost: number) {
    this.currentDailyCost += cost;
    this.currentHourlyCost += cost;
    
    if (this.currentDailyCost > this.dailyBudget * 0.8) {
      this.alert('Daily cost approaching 80%');
    }
    
    if (this.currentHourlyCost > this.hourlyBudget) {
      this.alert('Hourly budget exceeded, switching to cheaper models');
      this.enableCostSavingMode();
    }
  }

  private enableCostSavingMode() {
    // 强制路由到最便宜的模型
    setRoutingPreference('cheapest');
  }
}

// 最小可行编排层
interface AIProvider {
  chat(messages: Message[]): Promise<string>;
  supports(taskType: string): boolean;
}

class SimpleRouter {
  private providers: Map<string, AIProvider> = new Map();

  register(name: string, provider: AIProvider) {
    this.providers.set(name, provider);
  }

  async route(taskType: string, messages: Message[]): Promise<string> {
    for (const [name, provider] of this.providers) {
      if (provider.supports(taskType)) {
        return await provider.chat(messages);
      }
    }
    throw new Error('No provider supports this task type');
  }
}

class RouterWithFailover {
  async route(taskType: string, messages: Message[]): Promise<string> {
    const providers = this.getProvidersForTask(taskType);
    
    for (const provider of providers) {
      try {
        if (await this.isHealthy(provider)) {
          return await provider.chat(messages);
        }
      } catch (error) {
        console.warn(\`Provider \${provider.name} failed, trying next\`);
      }
    }
    
    throw new Error('All providers failed');
  }

  private async isHealthy(provider: AIProvider): Promise<boolean> {
    try {
      await provider.chat([{ role: 'user', content: 'ping' }]);
      return true;
    } catch {
      return false;
    }
  }
}

// 更新后的路由策略示例
const routingStrategy = {
  // 简单任务：使用自托管 GLM-5.2（零 API 成本）
  simple: {
    model: 'glm-5-2-self-hosted',
    thinking: 'standard',
    cost: '$0 (self-hosted)',
    fallback: 'gemini-3.5-flash'
  },
  // 中等任务：使用 GLM-5.2 API（成本约为 Opus 的 1/5）
  medium: {
    model: 'glm-5-2-api',
    thinking: 'high',
    cost: '~$0.50/MTok',
    fallback: 'claude-opus-4.8'
  },
  // 复杂任务：使用闭源旗舰模型
  complex: {
    model: 'claude-opus-4.8',
    thinking: 'high',
    cost: '$5/$25 MTok',
    fallback: 'gpt-5.5'
  },
  // 超长上下文：使用 GLM-5.2（100 万 Token）
  longContext: {
    model: 'glm-5-2-api',
    maxTokens: 1_000_000,
    cost: '~$0.50/MTok',
    fallback: 'gemini-3.5-pro'
  }
};