OpenClaw 不是「一个模型走天下」——不同任务需要不同模型：代码生成用 DeepSeek、长文档分析用 Claude、快速问答用 GPT-4o mini。模型路由系统根据任务类型、成本预算、延迟要求自动选择最优模型。这篇讲清楚路由策略、故障转移和成本控制的实现原理。

一、为什么需要模型路由

单一模型的痛点：

• 成本失控：所有请求都走 GPT-4，账单爆炸
• 延迟不可控：简单问答也走慢模型，用户体验差
• 能力错配：代码任务用通用模型，效果差
• 单点故障：模型挂了整个服务不可用

路由系统的目标：让合适的请求找合适的模型。

二、路由策略：不只是「最贵的优先」

OpenClaw 的路由策略配置：

# ~/.openclaw/config.yaml
model_routing:
  default: volcengine-coding/ark-code-latest
  
  rules:
    # 代码任务
    - match:
        tool: [edit, apply_patch, exec]
        prompt_contains: ["代码", "bug", "函数", "api"]
      model: volcengine-coding/ark-code-latest
      max_tokens: 8000
    
    # 长文档分析
    - match:
        prompt_length_gt: 10000
      model: anthropic/claude-3-5-sonnet
      max_tokens: 4000
    
    # 快速问答
    - match:
        prompt_length_lt: 500
        no_tools: true
      model: openai/gpt-4o-mini
      max_tokens: 1000
    
    # 中文优化
    - match:
        language: zh
      model: volcengine-coding/deepseek-v3
  
  fallback:
    - volcengine-coding/ark-code-latest
    - anthropic/claude-3-5-sonnet
    - openai/gpt-4o

三、故障转移：从「重试」到「降级」

模型挂了不能只是「报错」，要有降级策略：

async function callWithFallback(prompt, options) {
    const models = getFallbackChain(options.preferredModel);
    
    for (const model of models) {
        try {
            const result = await callModel(model, prompt, options);
            
            // 记录成功，用于后续路由优化
            recordSuccess(model, prompt, result);
            
            return result;
        } catch (error) {
            // 429/5xx → 下一个模型
            if (error.status === 429 || error.status >= 500) {
                console.warn(`Model ${model} failed: ${error.message}, trying next...`);
                continue;
            }
            
            // 4xx → 不重试，是请求问题
            throw error;
        }
    }
    
    throw new Error("All models failed");
}

关键设计：

• 429 限流：自动切到下一个模型
• 5xx 服务错误：自动切到下一个模型
• 4xx 客户端错误：不重试，是 prompt 问题
• 超时：30 秒无响应切下一个

四、成本控制：不只是「选便宜的」

class CostController {
    constructor(dailyBudget) {
        this.dailyBudget = dailyBudget;  // 每日预算（分）
        this.todaySpent = 0;
        this.modelCosts = {
            'gpt-4o': { input: 0.005, output: 0.015 },      // 每千 token
            'claude-3-5-sonnet': { input: 0.003, output: 0.015 },
            'gpt-4o-mini': { input: 0.00015, output: 0.0006 },
            'deepseek-v3': { input: 0.0001, output: 0.0002 },
        };
    }
    
    // 预估成本
    estimateCost(model, inputTokens, outputTokens) {
        const cost = this.modelCosts[model];
        return (inputTokens / 1000 * cost.input) + 
               (outputTokens / 1000 * cost.output);
    }
    
    // 检查预算
    canAfford(model, estimatedCost) {
        return (this.todaySpent + estimatedCost) <= this.dailyBudget;
    }
    
    // 选择最便宜的可用模型
    selectCheapest(models, estimatedCost) {
        const affordable = models.filter(m => 
            this.canAfford(m, estimatedCost)
        );
        
        if (affordable.length === 0) {
            // 预算耗尽，降级到最便宜
            return 'gpt-4o-mini';
        }
        
        // 按成本排序，选最便宜的
        return affordable.sort((a, b) => 
            this.estimateCost(a, 1000, 500) - 
            this.estimateCost(b, 1000, 500)
        )[0];
    }
}

五、延迟优化：不是所有请求都要 GPT-4

// 延迟预估（基于历史数据）
const latencyStats = {
    'gpt-4o': { avg: 3000, p95: 8000 },
    'claude-3-5-sonnet': { avg: 2500, p95: 6000 },
    'gpt-4o-mini': { avg: 800, p95: 2000 },
    'deepseek-v3': { avg: 1200, p95: 3000 },
};

// 根据 SLA 选模型
function selectByLatency(requirement) {
    if (requirement === 'realtime') {
        // 实时对话：选最快的
        return 'gpt-4o-mini';
    } else if (requirement === 'interactive') {
        // 交互式：平衡速度和质量
        return 'claude-3-5-sonnet';
    } else {
        // 批处理：质量优先
        return 'gpt-4o';
    }
}

六、实战：一个完整的路由决策

async function routeRequest(request) {
    // 1. 提取特征
    const features = {
        toolCount: request.tools?.length || 0,
        promptLength: request.prompt.length,
        hasCode: /```|function|class|import/.test(request.prompt),
        language: detectLanguage(request.prompt),
        userTier: request.user.tier,  // free / pro / enterprise
    };
    
    // 2. 规则匹配
    let selectedModel = matchRules(features);
    
    // 3. 预算检查
    const cost = costController.estimateCost(
        selectedModel, 
        features.promptLength / 4,  // 估算 token
        1000  // 预估输出
    );
    
    if (!costController.canAfford(selectedModel, cost)) {
        // 降级
        selectedModel = costController.selectCheapest(
            getFallbackChain(selectedModel), 
            cost
        );
    }
    
    // 4. 延迟优化
    if (features.userTier === 'free' && selectedModel !== 'gpt-4o-mini') {
        // 免费用户强制走快模型
        selectedModel = 'gpt-4o-mini';
    }
    
    // 5. 执行（带故障转移）
    return callWithFallback(request.prompt, {
        preferredModel: selectedModel,
        maxTokens: getMaxTokens(selectedModel),
    });
}

七、监控与调优

# 看各模型的调用量
openclaw metrics model_usage

# 看各模型的平均延迟
openclaw metrics model_latency

# 看各模型的错误率
openclaw metrics model_errors

# 看今日成本
openclaw metrics cost_today

调优方向：

• 某模型 429 太多 → 降低它的优先级或加备用
• 某模型成本占比过高 → 检查是否有可替代的更便宜模型
• 平均延迟上升 → 检查是否有模型降级或网络问题

结语

模型路由不是「选最贵的」或「选最快的」，而是在成本、延迟、质量之间找最优解。规则引擎匹配任务类型，故障转移保证可用性，成本控制防止账单爆炸，延迟优化提升体验。理解了这套机制，做 A/B 测试、多区域部署、自定义 SLA 都只是配置扩展。下一篇讲怎么用 OpenClaw 的插件系统实现自定义路由策略。