speculation

推测执行通过预测和预执行可能的工具调用来优化响应速度。

设计理念

问题

AI 思考需要时间：

AI 思考 (2s) → 工具调用 (0.5s) → AI 继续思考 (2s)
总时间: 4.5s

解决方案

在 AI 思考时预执行：

AI 思考 (2s)
  ↓ (同时)
预测并执行工具 (0.5s)
  ↓
AI 调用工具 → 直接使用缓存结果 (0ms)
  ↓
AI 继续 (2s)
总时间: 4s (节省 0.5s)

核心实现

预测工具调用

function predictNextTools(
  messages: Message[]
): ToolPrediction[] {
  // 分析对话历史
  const lastUserMessage = messages
    .filter(m => m.role === 'user')
    .pop();
  
  const predictions = [];
  
  // 规则基础预测
  if (lastUserMessage.content.includes('读取')) {
    predictions.push({
      tool: 'readFile',
      input: extractFilePath(lastUserMessage.content),
      confidence: 0.8,
    });
  }
  
  if (lastUserMessage.content.includes('搜索')) {
    predictions.push({
      tool: 'grepSearch',
      input: extractSearchQuery(lastUserMessage.content),
      confidence: 0.7,
    });
  }
  
  return predictions;
}

预执行

async function speculativeExecute(
  predictions: ToolPrediction[]
): Promise<void> {
  for (const pred of predictions) {
    if (pred.confidence < 0.6) {
      continue; // 置信度太低，跳过
    }
    
    // 后台执行
    executeTool(pred.tool, pred.input)
      .then(result => {
        // 缓存结果
        const key = `${pred.tool}:${JSON.stringify(pred.input)}`;
        speculativeCache.set(key, result);
      })
      .catch(() => {
        // 预测错误，忽略
      });
  }
}

使用预执行结果

async function executeTool(
  call: ToolCall
): Promise<ToolResult> {
  const key = `${call.name}:${JSON.stringify(call.input)}`;
  
  // 检查预执行缓存
  if (speculativeCache.has(key)) {
    const cached = speculativeCache.get(key);
    speculativeCache.delete(key); // 使用后删除
    return cached;
  }
  
  // 正常执行
  return await tool.execute(call.input, context);
}

预测策略

基于模式

const PREDICTION_PATTERNS = [
  {
    pattern: /读取.*文件/,
    tool: 'readFile',
    extractInput: (text) => ({
      path: extractFilePath(text),
    }),
  },
  {
    pattern: /搜索.*代码/,
    tool: 'grepSearch',
    extractInput: (text) => ({
      query: extractSearchQuery(text),
    }),
  },
];

基于历史

function predictFromHistory(
  messages: Message[]
): ToolPrediction[] {
  // 分析历史模式
  const patterns = analyzeHistoricalPatterns(messages);
  
  // 预测下一步
  return patterns.map(p => ({
    tool: p.tool,
    input: p.input,
    confidence: p.frequency,
  }));
}

性能影响

命中率

const speculativeStats = {
  predictions: 0,
  hits: 0,
  misses: 0,
};

function recordSpeculativeHit(): void {
  speculativeStats.hits++;
}

function getHitRate(): number {
  return speculativeStats.hits / speculativeStats.predictions;
}

时间节省

典型场景的时间节省：

场景	无推测	有推测	节省
读取文件	2.5s	2.0s	20%
搜索代码	3.0s	2.3s	23%
多文件操作	5.0s	3.5s	30%

配置

启用推测执行

{
  "speculation": {
    "enabled": true,
    "minConfidence": 0.6,
    "maxPredictions": 3
  }
}

下一步

• 查看 流式工具执行

• 了解 缓存策略

• 探索 Coordinator 模式