🛤️ LLM Routing（大语言模型路由）详解

目标：让OpenClaw根据任务类型自动选择模型，优化成本。

# openclaw.config.yaml
llm:
  router:
    strategy: "hybrid"  # 混合策略：规则+成本+性能
    
    # 定义可用的模型池
    models:
      - name: "gpt-3.5-turbo"
        costPer1kTokens: 0.001
        maxTokens: 16385
        capabilities: ["chat", "classification", "summarization"]
        
      - name: "gpt-4o-mini"
        costPer1kTokens: 0.01
        maxTokens: 128000
        capabilities: ["chat", "code", "analysis"]
        
      - name: "gpt-4o"
        costPer1kTokens: 0.03
        maxTokens: 128000
        capabilities: ["chat", "code", "reasoning", "creative"]
        
      - name: "o1"
        costPer1kTokens: 0.15
        maxTokens: 128000
        capabilities: ["reasoning", "math", "complex_code"]
    
    # 路由规则
    rules:
      - if: "task.type == 'classification'"
        then: "gpt-3.5-turbo"
        
      - if: "task.type == 'simple_chat'"
        then: "gpt-4o-mini"
        
      - if: "task.complexity > 8"
        then: "o1"
        
      - if: "user.budget == 'low'"
        then: "cheapest_available"
        
      - default: "gpt-4o"  # 兜底
    
    # 成本保护
    costProtection:
      maxCostPerDay: 100  # 每天最多花$100
      alertAt: 80         # 花到$80时报警

问题：某个模型API限流或响应慢，需要自动切换到备用模型。

// OpenClaw中的动态路由实现
import { LLMRouter } from '@openclaw/core';

const router = new LLMRouter({
  models: [
    { name: 'gpt-4o', priority: 1, endpoint: 'https://api.openai.com/v1' },
    { name: 'claude-3.5-sonnet', priority: 2, endpoint: 'https://api.anthropic.com' },
    { name: 'gpt-4o-mini', priority: 3, endpoint: 'https://api.openai.com/v1' }  // 备用
  ],
  
  // 健康检查
  healthCheck: {
    interval: 30000,  // 每30秒检查一次
    timeout: 5000,     // 5秒超时
    onUnhealthy: (model) => {
      console.warn(`⚠️ ${model.name} 不健康，降低优先级`);
      router.lowerPriority(model.name);
    },
    onRecovered: (model) => {
      console.log(`✅ ${model.name} 恢复，恢复优先级`);
      router.restorePriority(model.name);
    }
  }
});

// 执行任务
async function processTask(task) {
  try {
    // Router自动选择最健康的模型
    const model = await router.selectModel(task);
    console.log(`📡 路由到: ${model.name}`);
    
    const response = await model.complete({
      messages: task.messages,
      temperature: task.temperature || 0.7
    });
    
    return response;
  } catch (error) {
    // 自动重试其他模型
    console.error(`❌ ${model.name} 失败，尝试下一个`);
    return router.retryWithNext(task);
  }
}

目标：测试哪种路由策略成本更低、质量更好。

// 在OpenClaw中配置A/B测试
const abTest = {
  name: 'routing-strategy-test',
  variants: [
    { name: 'rule-based', weight: 50 },   // 50%流量
    { name: 'cost-based', weight: 50 }    // 50%流量
  ],
  
  metrics: {
    track: ['cost', 'latency', 'user_satisfaction'],
    onComplete: (results) => {
      console.log('A/B测试结果：');
      console.log(`规则路由：平均成本 $${results['rule-based'].avgCost}`);
      console.log(`成本路由：平均成本 $${results['cost-based'].avgCost}`);
      
      // 自动切换到更好的策略
      if (results['cost-based'].avgCost < results['rule-based'].avgCost) {
        console.log('✅ 切换到成本路由策略');
        router.setStrategy('cost-based');
      }
    }
  }
};

await router.startABTest(abTest);