auto compact

Auto Compact 是最后一层压缩策略，当其他方法都不够时自动触发。

设计理念

最后的防线

当前四层压缩都不足以控制 token 数量时：

1. Tool Result Budget - 已应用

2. Snip - 已应用

3. Microcompact - 已应用

4. Context Collapse - 已应用

5. Auto Compact - 最后的手段

激进压缩

Auto Compact 会更激进地压缩内容：

• 移除所有非关键信息

• 只保留最小必要上下文

• 可能丢失部分历史信息

核心实现

触发条件

async function* query(messages, tools, options) {
  const tokenCount = estimateTokens(messages);
  
  if (tokenCount > 180000) {
    // 触发激进压缩
    messages = await autoCompact(messages, { aggressive: true });
  } else if (tokenCount > 170000) {
    // 触发标准压缩
    messages = await autoCompact(messages, { aggressive: false });
  }
  
  // 继续执行
  // ...
}

压缩算法

async function autoCompact(
  messages: Message[],
  options: { aggressive: boolean }
): Promise<Message[]> {
  // 1. 应用所有前置压缩
  messages = microcompact(messages);
  messages = contextCollapse(messages);
  
  // 2. 计算当前 token 数
  let tokenCount = estimateTokens(messages);
  
  // 3. 如果还是太多，继续压缩
  if (tokenCount > 150000) {
    if (options.aggressive) {
      messages = aggressiveCompact(messages);
    } else {
      messages = standardCompact(messages);
    }
  }
  
  return messages;
}

标准压缩

function standardCompact(messages: Message[]): Message[] {
  return messages.map(msg => {
    if (msg.role === 'user') {
      // 保留用户消息
      return msg;
    }
    
    // 压缩助手消息
    return {
      ...msg,
      content: compressContent(msg.content, { level: 'standard' }),
    };
  });
}

function compressContent(
  content: ContentBlock[],
  options: { level: 'standard' | 'aggressive' }
): ContentBlock[] {
  return content.map(block => {
    if (block.type === 'text') {
      // 移除冗余文本
      return {
        ...block,
        text: removeRedundancy(block.text),
      };
    }
    
    if (block.type === 'tool_result') {
      // 进一步截断工具结果
      return {
        ...block,
        content: truncate(block.content, 10000),
      };
    }
    
    return block;
  });
}

激进压缩

function aggressiveCompact(messages: Message[]): Message[] {
  const KEEP_RECENT = 5; // 只保留最近 5 条
  
  const recent = messages.slice(-KEEP_RECENT);
  const old = messages.slice(0, -KEEP_RECENT);
  
  // 将旧消息压缩为单条摘要
  const summary = {
    role: 'user',
    content: `[Conversation history: ${generateBriefSummary(old)}]`,
  };
  
  return [summary, ...recent];
}

function generateBriefSummary(messages: Message[]): string {
  // 只提取最关键的信息
  const tools = extractAllToolCalls(messages);
  const errors = extractErrors(messages);
  
  return `Used tools: ${tools.join(', ')}. ${errors.length > 0 ? `Encountered ${errors.length} errors.` : ''}`;
}

压缩效果

示例

压缩前 (180K tokens):

[50 条完整消息，包含详细的思考过程、工具调用、结果等]

标准压缩后 (120K tokens):

[Earlier conversation summary: ...]
[最近 10 条消息，移除了冗余文本]

激进压缩后 (80K tokens):

[Brief history: Used readFile, grepSearch, strReplace. No errors.]
[最近 5 条消息]

质量保证

关键信息保留

即使在激进压缩下，也要保留：

function preserveCriticalInfo(messages: Message[]): string[] {
  const critical = [];
  
  // 保留错误信息
  messages.forEach(msg => {
    const errors = extractErrors(msg);
    critical.push(...errors);
  });
  
  // 保留用户明确的要求
  messages.forEach(msg => {
    if (msg.role === 'user' && isExplicitRequest(msg)) {
      critical.push(msg.content);
    }
  });
  
  // 保留最终结论
  const lastAssistant = messages
    .filter(m => m.role === 'assistant')
    .pop();
  
  if (lastAssistant) {
    critical.push(extractConclusion(lastAssistant));
  }
  
  return critical;
}

压缩验证

function validateCompression(
  original: Message[],
  compressed: Message[]
): boolean {
  // 确保关键信息没有丢失
  const originalCritical = extractCriticalInfo(original);
  const compressedCritical = extractCriticalInfo(compressed);
  
  return originalCritical.every(info =>
    compressedCritical.some(c => c.includes(info))
  );
}

用户通知

压缩提示

// 压缩后通知用户
if (compressionApplied) {
  console.log(
    chalk.yellow('⚠ Context compressed to fit token budget')
  );
}

压缩统计

function logCompressionStats(before: Message[], after: Message[]) {
  const beforeTokens = estimateTokens(before);
  const afterTokens = estimateTokens(after);
  const saved = beforeTokens - afterTokens;
  const percentage = (saved / beforeTokens * 100).toFixed(1);
  
  console.log(`Compressed: ${beforeTokens} → ${afterTokens} tokens (${percentage}% saved)`);
}

配置选项

压缩级别

// .kiro/config.json
{
  "autoCompact": {
    "enabled": true,
    "triggerThreshold": 180000,
    "aggressiveThreshold": 190000,
    "keepRecent": 10,
    "preserveErrors": true,
    "preserveUserRequests": true
  }
}

下一步

• 查看 性能优化 的整体策略

• 了解 System Prompt 的缓存优化

• 探索 流式工具执行