foliko 1.1.93 → 2.0.0

package/src/context/compaction-utils.js

@@ -0,0 +1,191 @@
+'use strict';
+
+/**
+ * Compaction utility functions
+ * 提取自 compressor.js 的纯函数工具集
+ */
+
+const { estimateTokens } = require('../llm/tokens');
+const { safeJsonStringify } = require('../llm/tokens');
+const { EntryTypes, createCustomMessage, createBranchSummaryMessage, createCompactionSummaryMessage } = require('../session/entry');
+
+const TOOL_RESULT_MAX_CHARS = 2000;
+
+function createFileOps() {
+  return { read: new Set(), written: new Set(), edited: new Set() };
+}
+
+function extractFileOpsFromMessage(message, fileOps) {
+  if (message.role !== 'assistant') return;
+  if (!message.content || !Array.isArray(message.content)) return;
+
+  for (const block of message.content) {
+    if (!block || block.type !== 'toolCall') continue;
+    const args = block.arguments;
+    if (!args) continue;
+    const filePath = typeof args.path === 'string' ? args.path : undefined;
+    if (!filePath) continue;
+    switch (block.name) {
+      case 'read': fileOps.read.add(filePath); break;
+      case 'write': fileOps.written.add(filePath); break;
+      case 'edit': fileOps.edited.add(filePath); break;
+    }
+  }
+}
+
+function computeFileLists(fileOps) {
+  const modified = new Set([...fileOps.edited, ...fileOps.written]);
+  const readOnly = [...fileOps.read].filter(f => !modified.has(f)).sort();
+  const modifiedFiles = [...modified].sort();
+  return { readFiles: readOnly, modifiedFiles };
+}
+
+function formatFileOperations(readFiles, modifiedFiles) {
+  const sections = [];
+  if (readFiles.length > 0) sections.push(`<read-files>\n${readFiles.join('\n')}\n</read-files>`);
+  if (modifiedFiles.length > 0) sections.push(`<modified-files>\n${modifiedFiles.join('\n')}\n</modified-files>`);
+  if (sections.length === 0) return '';
+  return `\n\n${sections.join('\n\n')}`;
+}
+
+function truncateForSummary(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  const truncatedChars = text.length - maxChars;
+  return `${text.slice(0, maxChars)}\n\n[... ${truncatedChars} more characters truncated]`;
+}
+
+function serializeConversation(messages) {
+  const parts = [];
+  for (const msg of messages) {
+    if (msg.role === 'user') {
+      const content = Array.isArray(msg.content)
+        ? msg.content.filter(c => c.type === 'text').map(c => c.text).join('')
+        : msg.content;
+      if (content) parts.push(`[User]: ${content}`);
+    } else if (msg.role === 'assistant') {
+      const textParts = []; const thinkingParts = []; const toolCalls = [];
+      for (const block of msg.content || []) {
+        if (block.type === 'text') textParts.push(block.text);
+        else if (block.type === 'thinking') thinkingParts.push(block.thinking);
+        else if (block.type === 'toolCall') {
+          const argsStr = Object.entries(block.arguments || {})
+            .map(([k, v]) => `${k}=${safeJsonStringify(v)}`).join(', ');
+          toolCalls.push(`${block.name}(${argsStr})`);
+        }
+      }
+      if (thinkingParts.length > 0) parts.push(`[Assistant thinking]: ${thinkingParts.join('\n')}`);
+      if (textParts.length > 0) parts.push(`[Assistant]: ${textParts.join('\n')}`);
+      if (toolCalls.length > 0) parts.push(`[Assistant tool calls]: ${toolCalls.join('; ')}`);
+    } else if (msg.role === 'toolResult') {
+      const content = Array.isArray(msg.content)
+        ? msg.content.filter(c => c.type === 'text').map(c => c.text).join('')
+        : msg.content;
+      if (content) parts.push(`[Tool result]: ${truncateForSummary(content, TOOL_RESULT_MAX_CHARS)}`);
+    }
+  }
+  return parts.join('\n\n');
+}
+
+function getMessageFromEntry(entry) {
+  switch (entry.type) {
+    case EntryTypes.MESSAGE:
+      if (entry.message.role === 'toolResult') return undefined;
+      return entry.message;
+    case EntryTypes.CUSTOM_MESSAGE:
+      return createCustomMessage(entry.customType, entry.content, entry.display, entry.details, entry.timestamp);
+    case EntryTypes.BRANCH_SUMMARY:
+      return createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp);
+    case EntryTypes.COMPACTION:
+      return createCompactionSummaryMessage(entry.summary, entry.tokensBefore, entry.timestamp);
+    default:
+      return undefined;
+  }
+}
+
+function getMessageFromEntryForCompaction(entry) {
+  if (entry.type === EntryTypes.COMPACTION) return undefined;
+  return getMessageFromEntry(entry);
+}
+
+function findValidCutPoints(entries, startIndex, endIndex) {
+  const cutPoints = [];
+  for (let i = startIndex; i < endIndex; i++) {
+    const entry = entries[i];
+    if (entry.type === EntryTypes.MESSAGE) {
+      const role = entry.message.role;
+      switch (role) {
+        case 'bashExecution': case 'custom': case 'branchSummary':
+        case 'compactionSummary': case 'user': case 'assistant':
+          cutPoints.push(i); break;
+        case 'toolResult': break;
+      }
+    }
+    if (entry.type === EntryTypes.BRANCH_SUMMARY || entry.type === EntryTypes.CUSTOM_MESSAGE) {
+      cutPoints.push(i);
+    }
+  }
+  return cutPoints;
+}
+
+function findTurnStartIndex(entries, entryIndex, startIndex) {
+  for (let i = entryIndex; i >= startIndex; i--) {
+    const entry = entries[i];
+    if (entry.type === EntryTypes.BRANCH_SUMMARY || entry.type === EntryTypes.CUSTOM_MESSAGE) return i;
+    if (entry.type === EntryTypes.MESSAGE && (entry.message.role === 'user' || entry.message.role === 'bashExecution')) return i;
+  }
+  return -1;
+}
+
+function findCutPoint(entries, startIndex, endIndex, keepRecentTokens) {
+  const cutPoints = findValidCutPoints(entries, startIndex, endIndex);
+  if (cutPoints.length === 0) {
+    return { firstKeptEntryIndex: startIndex, turnStartIndex: -1, isSplitTurn: false };
+  }
+  let accumulatedTokens = 0;
+  let cutIndex = cutPoints[0];
+
+  for (let i = endIndex - 1; i >= startIndex; i--) {
+    const entry = entries[i];
+    if (entry.type !== EntryTypes.MESSAGE) continue;
+    accumulatedTokens += estimateTokens(entry.message);
+    if (accumulatedTokens >= keepRecentTokens) {
+      for (let c = 0; c < cutPoints.length; c++) {
+        if (cutPoints[c] >= i) { cutIndex = cutPoints[c]; break; }
+      }
+      break;
+    }
+  }
+  while (cutIndex > startIndex) {
+    const prevEntry = entries[cutIndex - 1];
+    if (prevEntry.type === EntryTypes.COMPACTION) break;
+    if (prevEntry.type === EntryTypes.MESSAGE) break;
+    cutIndex--;
+  }
+
+  const cutEntry = entries[cutIndex];
+  const isUserMessage = cutEntry.type === EntryTypes.MESSAGE && cutEntry.message.role === 'user';
+  const turnStartIndex = isUserMessage ? -1 : findTurnStartIndex(entries, cutIndex, startIndex);
+
+  return { firstKeptEntryIndex: cutIndex, turnStartIndex, isSplitTurn: !isUserMessage && turnStartIndex !== -1 };
+}
+
+function extractFileOperations(messages, entries, prevCompactionIndex) {
+  const fileOps = createFileOps();
+  if (prevCompactionIndex >= 0) {
+    const prevCompaction = entries[prevCompactionIndex];
+    if (!prevCompaction.fromHook && prevCompaction.details) {
+      const { details } = prevCompaction;
+      if (Array.isArray(details.readFiles)) { for (const f of details.readFiles) fileOps.read.add(f); }
+      if (Array.isArray(details.modifiedFiles)) { for (const f of details.modifiedFiles) fileOps.edited.add(f); }
+    }
+  }
+  for (const msg of messages) extractFileOpsFromMessage(msg, fileOps);
+  return fileOps;
+}
+
+module.exports = {
+  TOOL_RESULT_MAX_CHARS, createFileOps, extractFileOpsFromMessage,
+  computeFileLists, formatFileOperations, truncateForSummary,
+  serializeConversation, getMessageFromEntry, getMessageFromEntryForCompaction,
+  findValidCutPoints, findTurnStartIndex, findCutPoint, extractFileOperations,
+};

package/src/context/compressor.js

@@ -0,0 +1,413 @@
+'use strict';
+
+/**
+ * ContextCompressor - 上下文压缩器
+ * Ported from pi's compaction/compaction.ts with enhanced functionality
+ */
+
+const { logger } = require('../common/logger');
+const { estimateTokens, estimateContextTokens, buildSessionContext, TokenCounter } = require('../llm/tokens');
+const { validateMessagesPairing } = require('../utils/message-validator');
+const { EntryTypes } = require('../session/entry');
+const {
+  createFileOps, extractFileOpsFromMessage, computeFileLists, formatFileOperations,
+  serializeConversation, getMessageFromEntry, getMessageFromEntryForCompaction,
+  findCutPoint, findTurnStartIndex, extractFileOperations,
+} = require('./compaction-utils');
+const {
+  SUMMARIZATION_SYSTEM_PROMPT, SUMMARIZATION_PROMPT, UPDATE_SUMMARIZATION_PROMPT,
+  TURN_PREFIX_SUMMARIZATION_PROMPT, BRANCH_SUMMARY_PREAMBLE, BRANCH_SUMMARY_PROMPT,
+  DEFAULT_COMPACTION_SETTINGS, MODEL_CONTEXT_LIMITS, COMPRESSION_TIMEOUT_MS,
+} = require('./compaction-prompts');
+
+// ─── Helper classes ───────────────────────────────────────────────────
+
+class CompactionDetails {
+  constructor(readFiles = [], modifiedFiles = []) {
+    this.readFiles = readFiles;
+    this.modifiedFiles = modifiedFiles;
+  }
+}
+
+class Result {
+  constructor(ok, value, error) {
+    this.ok = ok; this.value = value; this.error = error;
+  }
+  static success(value) { return new Result(true, value, null); }
+  static failure(error) { return new Result(false, null, error); }
+}
+
+class CompactionError extends Error {
+  constructor(code, message, cause) {
+    super(message, cause === undefined ? undefined : { cause });
+    this.name = 'CompactionError'; this.code = code;
+  }
+}
+
+class BranchSummaryError extends Error {
+  constructor(code, message, cause) {
+    super(message, cause === undefined ? undefined : { cause });
+    this.name = 'BranchSummaryError'; this.code = code;
+  }
+}
+
+// ─── Compaction preparation ──────────────────────────────────────────
+
+class CompactionResult {
+  constructor(summary, firstKeptEntryId, tokensBefore, details) {
+    this.summary = summary;
+    this.firstKeptEntryId = firstKeptEntryId;
+    this.tokensBefore = tokensBefore;
+    this.details = details;
+  }
+}
+
+function prepareCompaction(pathEntries, settings) {
+  if (pathEntries.length === 0 || pathEntries[pathEntries.length - 1].type === EntryTypes.COMPACTION) {
+    return Result.success(undefined);
+  }
+
+  let prevCompactionIndex = -1;
+  for (let i = pathEntries.length - 1; i >= 0; i--) {
+    if (pathEntries[i].type === EntryTypes.COMPACTION) { prevCompactionIndex = i; break; }
+  }
+
+  let previousSummary;
+  let boundaryStart = 0;
+  if (prevCompactionIndex >= 0) {
+    const prevCompaction = pathEntries[prevCompactionIndex];
+    previousSummary = prevCompaction.summary;
+    const firstKeptEntryIndex = pathEntries.findIndex(entry => entry.id === prevCompaction.firstKeptEntryId);
+    boundaryStart = firstKeptEntryIndex >= 0 ? firstKeptEntryIndex : prevCompactionIndex + 1;
+  }
+  const boundaryEnd = pathEntries.length;
+  const tokensBefore = estimateContextTokens(buildSessionContext(pathEntries).messages).tokens;
+
+  const cutPoint = findCutPoint(pathEntries, boundaryStart, boundaryEnd, settings.keepRecentTokens);
+  const firstKeptEntry = pathEntries[cutPoint.firstKeptEntryIndex];
+  if (!firstKeptEntry?.id) {
+    return Result.failure(new CompactionError('invalid_session', 'First kept entry has no UUID'));
+  }
+  const firstKeptEntryId = firstKeptEntry.id;
+
+  const historyEnd = cutPoint.isSplitTurn ? cutPoint.turnStartIndex : cutPoint.firstKeptEntryIndex;
+  const messagesToSummarize = [];
+  for (let i = boundaryStart; i < historyEnd; i++) {
+    const msg = getMessageFromEntryForCompaction(pathEntries[i]);
+    if (msg) messagesToSummarize.push(msg);
+  }
+  const turnPrefixMessages = [];
+  if (cutPoint.isSplitTurn) {
+    for (let i = cutPoint.turnStartIndex; i < cutPoint.firstKeptEntryIndex; i++) {
+      const msg = getMessageFromEntryForCompaction(pathEntries[i]);
+      if (msg) turnPrefixMessages.push(msg);
+    }
+  }
+  const fileOps = extractFileOperations(messagesToSummarize, pathEntries, prevCompactionIndex);
+  if (cutPoint.isSplitTurn) {
+    for (const msg of turnPrefixMessages) extractFileOpsFromMessage(msg, fileOps);
+  }
+
+  return Result.success({
+    firstKeptEntryId, messagesToSummarize, turnPrefixMessages,
+    isSplitTurn: cutPoint.isSplitTurn, tokensBefore, previousSummary, fileOps, settings,
+  });
+}
+
+class BranchPreparation {
+  constructor(messages, fileOps, totalTokens) {
+    this.messages = messages; this.fileOps = fileOps; this.totalTokens = totalTokens;
+  }
+}
+
+function prepareBranchEntries(entries, tokenBudget = 0) {
+  const messages = [];
+  const fileOps = createFileOps();
+  let totalTokens = 0;
+
+  for (const entry of entries) {
+    if (entry.type === EntryTypes.BRANCH_SUMMARY && !entry.fromHook && entry.details) {
+      const { details } = entry;
+      if (Array.isArray(details.readFiles)) { for (const f of details.readFiles) fileOps.read.add(f); }
+      if (Array.isArray(details.modifiedFiles)) { for (const f of details.modifiedFiles) fileOps.edited.add(f); }
+    }
+  }
+
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i];
+    const message = getMessageFromEntry(entry);
+    if (!message) continue;
+    extractFileOpsFromMessage(message, fileOps);
+
+    const tokens = estimateTokens(message);
+    if (tokenBudget > 0 && totalTokens + tokens > tokenBudget) {
+      if (entry.type === EntryTypes.COMPACTION || entry.type === EntryTypes.BRANCH_SUMMARY) {
+        if (totalTokens < tokenBudget * 0.9) { messages.unshift(message); totalTokens += tokens; }
+      }
+      break;
+    }
+    messages.unshift(message);
+    totalTokens += tokens;
+  }
+  return new BranchPreparation(messages, fileOps, totalTokens);
+}
+
+function collectEntriesForBranchSummary(session, oldLeafId, targetId) {
+  if (!oldLeafId) return { entries: [], commonAncestorId: null };
+
+  const oldPath = new Set(session.getBranch(oldLeafId).map(e => e.id));
+  const targetPath = session.getBranch(targetId);
+  let commonAncestorId = null;
+  for (let i = targetPath.length - 1; i >= 0; i--) {
+    if (oldPath.has(targetPath[i].id)) { commonAncestorId = targetPath[i].id; break; }
+  }
+
+  const entries = [];
+  let current = oldLeafId;
+  while (current && current !== commonAncestorId) {
+    const entry = session.getEntry(current);
+    if (!entry) break;
+    entries.push(entry);
+    current = entry.parentId;
+  }
+  entries.reverse();
+  return { entries, commonAncestorId };
+}
+
+// ─── ContextCompressor ───────────────────────────────────────────────
+
+class ContextCompressor {
+  constructor(config = {}) {
+    this.config = config;
+    this.agent = config.agent;
+    this.framework = config.framework;
+
+    this.model = config.model || 'deepseek-chat';
+    this._maxContextTokens = config.maxContextTokens || this._getDefaultContextLimit();
+    this._keepRecentMessages = config.keepRecentMessages || 20;
+    this._compressionMessageThreshold = config.compressionMessageThreshold || 200;
+    this._enableSmartCompress = config.enableSmartCompress !== false;
+    this._compactionSettings = config.compactionSettings || DEFAULT_COMPACTION_SETTINGS;
+
+    this._compressionCount = 0;
+    this._compressionInProgress = false;
+    this._compressionPromise = null;
+    this._compressionTimeoutId = null;
+    this._maxToolResultSize = config.maxToolResultSize || 4000;
+    this._tokenCounter = new TokenCounter();
+  }
+
+  _getDefaultContextLimit() {
+    const modelKey = Object.keys(MODEL_CONTEXT_LIMITS).find(k =>
+      this.model.toLowerCase().includes(k.toLowerCase())
+    );
+    return modelKey ? MODEL_CONTEXT_LIMITS[modelKey] : 40000;
+  }
+
+  validateMessagesPairing(messages) {
+    return validateMessagesPairing(messages);
+  }
+
+  async compress(sessionId, messages, messageStore) {
+    if (this._compressionInProgress && this._compressionPromise) {
+      logger.debug('Compression already in progress, waiting...');
+      return this._compressionPromise;
+    }
+
+    if (messages.length <= this._keepRecentMessages) return;
+
+    this._compressionInProgress = true;
+    this._compressionPromise = this._executeWithTimeout(sessionId, messages, messageStore).finally(() => {
+      this._compressionInProgress = false;
+      this._compressionPromise = null;
+      if (this._compressionTimeoutId) { clearTimeout(this._compressionTimeoutId); this._compressionTimeoutId = null; }
+    });
+    return this._compressionPromise;
+  }
+
+  async _executeWithTimeout(sessionId, messages, messageStore) {
+    try {
+      return await Promise.race([
+        this._doCompress(sessionId, messages, messageStore),
+        new Promise((_, reject) => {
+          this._compressionTimeoutId = setTimeout(() => {
+            this._compressionTimeoutId = null;
+            reject(new Error(`Compression timeout (${COMPRESSION_TIMEOUT_MS}ms)`));
+          }, COMPRESSION_TIMEOUT_MS);
+        }),
+      ]);
+    } catch (err) {
+      logger.warn('Compression failed:', err.message);
+      this._simpleCompress(sessionId, messages, messageStore);
+    }
+  }
+
+  cancelCompression() {
+    if (this._compressionTimeoutId) { clearTimeout(this._compressionTimeoutId); this._compressionTimeoutId = null; }
+    this._compressionInProgress = false;
+    this._compressionPromise = null;
+  }
+
+  async _doCompress(sessionId, messages, messageStore) {
+    const systemMessages = messages.filter(m => m.role === 'system');
+    const otherMessages = messages.filter(m => m.role !== 'system');
+    const recentMessages = otherMessages.slice(-this._keepRecentMessages);
+    const messagesToSummarize = otherMessages.slice(0, -this._keepRecentMessages);
+    const compressedCount = messagesToSummarize.length;
+
+    let summaryContent = '';
+    if (this._enableSmartCompress && this.agent?._chatHandler?._aiClient) {
+      try {
+        const summaryText = await this._summarizeMessages(messagesToSummarize);
+        summaryContent = `[Early conversation summary]: ${summaryText || '(no content)'}`;
+      } catch (err) {
+        logger.warn('AI summary failed, using simple compression:', err.message);
+        summaryContent = `[Context compressed: ${compressedCount} early messages omitted. Kept recent ${this._keepRecentMessages} messages.]`;
+      }
+    } else {
+      summaryContent = `[Context compressed: ${compressedCount} early messages omitted. Kept recent ${this._keepRecentMessages} messages.]`;
+    }
+
+    const summary = { role: 'assistant', content: summaryContent };
+    const combined = [...systemMessages, summary, ...recentMessages];
+    this._cleanupOrphanedToolResults(combined);
+
+    messages.length = 0;
+    messages.push(...combined);
+
+    this._compressionCount++;
+    const tokenCount = this._tokenCounter.countMessages(messages);
+    if (messageStore.compressionState) {
+      messageStore.compressionState.count++;
+      messageStore.compressionState.lastCompressedAt = Date.now();
+      messageStore.compressionState.lastTokenCount = tokenCount;
+    }
+    if (typeof messageStore.recordCompression === 'function') messageStore.recordCompression(tokenCount);
+
+    logger.info(`Context compressed (${this._compressionCount} times). Messages: ${messages.length}`);
+  }
+
+  _simpleCompress(sessionId, messages, messageStore) {
+    const systemMessages = messages.filter(m => m.role === 'system');
+    const otherMessages = messages.filter(m => m.role !== 'system');
+    const recentMessages = otherMessages.slice(-this._keepRecentMessages);
+    const compressedCount = otherMessages.length - this._keepRecentMessages;
+
+    const summary = { role: 'assistant', content: `[Context compressed: ${compressedCount} early messages omitted. Kept recent ${this._keepRecentMessages} messages.]` };
+    const combined = [...systemMessages, summary, ...recentMessages];
+    this._cleanupOrphanedToolResults(combined);
+
+    messages.length = 0;
+    messages.push(...combined);
+
+    this._compressionCount++;
+    if (messageStore.compressionState) {
+      messageStore.compressionState.count++;
+      messageStore.compressionState.lastCompressedAt = Date.now();
+      messageStore.compressionState.lastTokenCount = this._tokenCounter.countMessages(combined);
+    }
+    logger.info(`Context simple compressed. Messages: ${messages.length}`);
+  }
+
+  _cleanupOrphanedToolResults(messages) {
+    const validToolCallIds = new Set();
+    for (const msg of messages) {
+      if (msg.role !== 'assistant') continue;
+      if (Array.isArray(msg.content)) {
+        for (const item of msg.content) {
+          if ((item.type === 'tool-call' || item.type === 'tool-use') && item.toolCallId) validToolCallIds.add(item.toolCallId);
+        }
+      }
+      if (Array.isArray(msg.tool_calls)) {
+        for (const tc of msg.tool_calls) { if (tc.id) validToolCallIds.add(tc.id); }
+      }
+    }
+
+    let removedItems = 0;
+    let removedMsgs = 0;
+    for (const msg of messages) {
+      if (msg.role !== 'tool' || !Array.isArray(msg.content)) continue;
+      const originalLength = msg.content.length;
+      msg.content = msg.content.filter((item) => {
+        if (item && (item.type === 'tool-result' || item.type === 'tool_result') && item.toolCallId && !validToolCallIds.has(item.toolCallId)) {
+          removedItems++; return false;
+        }
+        return true;
+      });
+      if (msg.content.length === 0 && originalLength > 0) msg._orphaned = true;
+    }
+
+    for (let i = messages.length - 1; i >= 0; i--) {
+      if (messages[i]._orphaned) { messages.splice(i, 1); removedMsgs++; }
+    }
+
+    if (removedItems > 0 || removedMsgs > 0) {
+      logger.debug(`[ContextCompressor] cleanup: removed ${removedItems} orphaned tool-result items, ${removedMsgs} orphaned tool messages`);
+    }
+  }
+
+  async _summarizeMessages(messages) {
+    if (!this.framework) throw new Error('Framework not available');
+
+    const msg_str = messages.map(m => {
+      let text = '';
+      if (typeof m.content === 'string') text = m.content;
+      else if (Array.isArray(m.content)) text = m.content.filter(c => c.type === 'text').map(c => c.text).join(' ');
+      if (m.role === 'tool') return '';
+      return `${m.role}: ${text}`;
+    }).filter(line => line.length > 0).join('\n');
+
+    const task = `Summarize the following conversation, keeping only meaningful information. Describe in 1000 characters or less:\n\n${msg_str}`;
+
+    try {
+      const subagent = this.framework.createSubAgent({
+        name: 'context-compressor',
+        role: 'Information extraction expert',
+        systemPrompt: 'You are a conversation summarization assistant. Extract and preserve only meaningful information. Keep output concise.',
+        maxRetries: 0,
+        disableTools: true,
+      });
+
+      const result = await subagent.chat(task);
+      if (result.success) return result.message;
+      throw new Error(result.error || 'Summary generation failed');
+    } catch (err) {
+      logger.warn('Summarize failed:', err.message);
+      throw err;
+    }
+  }
+
+  getStats() {
+    return { compressionCount: this._compressionCount, inProgress: this._compressionInProgress };
+  }
+}
+
+module.exports = {
+  ContextCompressor,
+  CompactionDetails,
+  CompactionResult,
+  CompactionError,
+  BranchSummaryError,
+  Result,
+  DEFAULT_COMPACTION_SETTINGS,
+  createFileOps,
+  extractFileOpsFromMessage,
+  computeFileLists,
+  formatFileOperations,
+  serializeConversation,
+  findCutPoint,
+  findTurnStartIndex,
+  SUMMARIZATION_SYSTEM_PROMPT,
+  SUMMARIZATION_PROMPT,
+  UPDATE_SUMMARIZATION_PROMPT,
+  TURN_PREFIX_SUMMARIZATION_PROMPT,
+  BRANCH_SUMMARY_PREAMBLE,
+  BRANCH_SUMMARY_PROMPT,
+  extractFileOperations,
+  prepareCompaction,
+  prepareBranchEntries,
+  collectEntriesForBranchSummary,
+  getMessageFromEntry,
+  getMessageFromEntryForCompaction,
+  EntryTypes,
+};

package/src/context/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+module.exports = {
+  ContextStorage: require('./storage'),
+  RequestContext: require('./request').RequestContext,
+  SessionContext: require('./session').SessionContext,
+  AgentContext: require('./agent').AgentContext,
+  ContextCompressor: require('./compressor').ContextCompressor,
+};

package/src/{core/context-manager.js → context/manager.js}

@@ -7,7 +7,7 @@
  * 3. 处理上下文清理和资源释放
  */
 
-const { RequestContext } = require('./request-context');
+const { RequestContext } = require('../context/request');
 
 class ContextManager {
   /**

package/src/context/request.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const { uuid } = require('../common/id');
+
+class RequestContext {
+  constructor(options = {}) {
+    this.requestId = options.requestId || `req_${uuid()}`;
+    this.traceId = options.traceId || `trace_${uuid()}`;
+    this.parentSpanId = options.parentSpanId || null;
+    this.timeout = options.timeout || 120000;
+    this.startTime = options.startTime || Date.now();
+    this.isStream = options.isStream || false;
+    this.userId = options.userId || null;
+    this.cancelled = false;
+    this.abortController = null;
+    this.metadata = options.metadata || {};
+  }
+
+  getAbortController() {
+    if (!this.abortController) {
+      this.abortController = new AbortController();
+    }
+    return this.abortController;
+  }
+
+  isTimeout() { return Date.now() - this.startTime > this.timeout; }
+
+  cancel() {
+    this.cancelled = true;
+    if (this.abortController) this.abortController.abort();
+  }
+
+  getElapsed() { return Date.now() - this.startTime; }
+
+  toJSON() {
+    return {
+      requestId: this.requestId,
+      traceId: this.traceId,
+      parentSpanId: this.parentSpanId,
+      timeout: this.timeout,
+      startTime: this.startTime,
+      elapsed: this.getElapsed(),
+      isStream: this.isStream,
+      userId: this.userId,
+      cancelled: this.cancelled,
+    };
+  }
+}
+
+module.exports = { RequestContext };