microcompact

Microcompact 是第三层压缩策略，专门压缩工具调用历史。

设计理念

问题

AI 的思考过程（thinking）占用大量 token：

Assistant: Let me analyze the code structure first...
[长篇分析文本]
Now I'll read the main file...
[更多思考过程]
Based on this, I should...
[继续思考]

Tool calls: [readCode, readFile, grepSearch]

解决方案

保留工具调用，移除思考过程：

Assistant: [thinking removed]

Tool calls: [readCode, readFile, grepSearch]

核心实现

压缩算法

function microcompact(messages: Message[]): Message[] {
  return messages.map(msg => {
    if (msg.role !== 'assistant') {
      return msg;
    }
    
    // 检查是否包含工具调用
    const hasTools = msg.content.some(
      block => block.type === 'tool_use'
    );
    
    if (!hasTools) {
      return msg; // 保留纯文本响应
    }
    
    // 只保留工具调用，移除文本
    return {
      ...msg,
      content: msg.content.filter(
        block => block.type === 'tool_use'
      ),
    };
  });
}

选择性保留

某些思考过程需要保留：

function selectiveCompact(messages: Message[]): Message[] {
  return messages.map(msg => {
    if (msg.role !== 'assistant') {
      return msg;
    }
    
    const textBlocks = msg.content.filter(b => b.type === 'text');
    const toolBlocks = msg.content.filter(b => b.type === 'tool_use');
    
    if (toolBlocks.length === 0) {
      return msg; // 没有工具调用，保留全部
    }
    
    // 保留重要的思考过程
    const importantText = textBlocks.filter(block =>
      isImportant(block.text)
    );
    
    return {
      ...msg,
      content: [...importantText, ...toolBlocks],
    };
  });
}

function isImportant(text: string): boolean {
  // 保留错误信息
  if (text.includes('Error') || text.includes('Failed')) {
    return true;
  }
  
  // 保留决策说明
  if (text.includes('I will') || text.includes('I need to')) {
    return true;
  }
  
  // 移除冗长的分析
  if (text.length > 500) {
    return false;
  }
  
  return true;
}

触发时机

自动触发

async function* query(messages, tools, options) {
  // 检查 token 数量
  const tokenCount = estimateTokens(messages);
  
  if (tokenCount > 120000) {
    // 触发 Microcompact
    messages = microcompact(messages);
  }
  
  // 继续执行
  // ...
}

手动触发

// 用户命令: /compact
await compactConversation('microcompact');

压缩效果

示例

压缩前 (约 5000 tokens):

Assistant: Let me start by analyzing the codebase structure. I'll need to 
understand the main entry point and how the application is organized. First, 
I'll read the package.json to see the project configuration and dependencies.

After reviewing the package.json, I can see this is a TypeScript project using 
React and Ink for the terminal UI. The main entry point is src/main.tsx. Let 
me read that file to understand the application flow.

Now I'll search for all the tool implementations to understand what capabilities 
are available...

Tool calls:
- readFile(path: "package.json")
- readFile(path: "src/main.tsx")
- grepSearch(query: "class.*Tool")

压缩后 (约 500 tokens):

Assistant: [thinking removed]

Tool calls:
- readFile(path: "package.json")
- readFile(path: "src/main.tsx")
- grepSearch(query: "class.*Tool")

节省: 90% tokens

保留策略

保留最近的消息

const KEEP_RECENT = 5; // 保留最近 5 轮对话

function microcompactWithRecency(messages: Message[]): Message[] {
  const recent = messages.slice(-KEEP_RECENT * 2); // 用户+助手 = 2 条
  const old = messages.slice(0, -KEEP_RECENT * 2);
  
  // 只压缩旧消息
  const compactedOld = microcompact(old);
  
  return [...compactedOld, ...recent];
}

保留关键信息

function preserveKeyInfo(messages: Message[]): Message[] {
  return messages.map(msg => {
    if (msg.role !== 'assistant') {
      return msg;
    }
    
    // 提取关键信息
    const keyInfo = extractKeyInfo(msg.content);
    
    // 保留工具调用 + 关键信息
    return {
      ...msg,
      content: [
        ...keyInfo,
        ...msg.content.filter(b => b.type === 'tool_use'),
      ],
    };
  });
}

function extractKeyInfo(content: ContentBlock[]): ContentBlock[] {
  return content.filter(block => {
    if (block.type !== 'text') return false;
    
    const text = block.text;
    
    // 保留错误和警告
    if (/error|warning|failed/i.test(text)) return true;
    
    // 保留决策
    if (/I will|I need to|Next, I'll/i.test(text)) return true;
    
    // 保留总结
    if (/In summary|To summarize/i.test(text)) return true;
    
    return false;
  });
}

与其他压缩层的配合

组合使用

async function compressMessages(messages: Message[]): Promise<Message[]> {
  // 1. Tool Result Budget (已在工具执行时应用)
  
  // 2. Microcompact - 移除思考过程
  messages = microcompact(messages);
  
  // 3. Context Collapse - 折叠旧对话
  if (estimateTokens(messages) > 100000) {
    messages = contextCollapse(messages);
  }
  
  // 4. Auto Compact - 最终压缩
  if (estimateTokens(messages) > 150000) {
    messages = await autoCompact(messages);
  }
  
  return messages;
}

下一步

• 了解 Context Collapse 的折叠机制

• 探索 Auto Compact 的自动触发

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