aws-runtime-bridge 1.9.32 → 1.9.40

package/package/acode/dist/compaction.js

@@ -0,0 +1,664 @@
+/**
+ * 上下文压缩模块 — 参考 OpenCode compaction.ts 的设计
+ *
+ * 核心策略：
+ * 1. Prune（裁剪）：从旧到新遍历工具输出，超过保护线后用占位符替换内容
+ * 2. Summarize（摘要）：将早期对话结构化摘要，保留目标/指令/发现/已完成/相关文件
+ *
+ * 触发时机：在每次 AI 请求前检测 token 是否溢出，溢出则执行压缩
+ *
+ * 与 OpenCode 的对应关系：
+ * - isOverflow  ↔  SessionCompaction.isOverflow
+ * - prune       ↔  SessionCompaction.prune
+ * - summarize   ↔  SessionCompaction.process (LLM 摘要的简化版)
+ */
+// ============ 常量（与 OpenCode compaction.ts 对齐） ============
+/** 压缩缓冲区：保留这么多 token 的空闲空间，避免压缩过程中溢出 */
+export const COMPACTION_BUFFER = 20_000;
+/** 基于实际累积 token 的触发比例：当累积量达到上下文窗口的此比例时触发压缩 */
+export const COMPACTION_TRIGGER_RATIO = 0.55;
+/** Prune 保护线默认值：保留最近 PRUNE_PROTECT token 的工具输出完整。
+ *  注意：实际使用时会按 contextLimit 比例调整（见 pruneToolOutputs），
+ *  避免在小上下文窗口（如 60k）下保护线过高导致 prune 永不触发。
+ */
+export const PRUNE_PROTECT = 40_000;
+/** Prune 最小收益默认值：累计可释放 token 不足此数时跳过修剪。
+ *  注意：实际使用时会按 contextLimit 比例调整。
+ */
+export const PRUNE_MINIMUM = 20_000;
+/** Prune 保护线占 contextLimit 的比例（取较小者：固定值或比例值） */
+const PRUNE_PROTECT_RATIO = 0.5;
+/** Prune 最小收益占 contextLimit 的比例 */
+const PRUNE_MINIMUM_RATIO = 0.1;
+/** Prune 白名单：这些工具的输出永远不会被裁剪 */
+const PRUNE_PROTECTED_TOOLS = new Set(["skill", "todo_write", "todo_read"]);
+/** 默认上下文窗口上限（查找不到模型时使用） */
+const DEFAULT_CONTEXT_LIMIT = 128_000;
+/** 默认最大输出 token */
+const DEFAULT_MAX_OUTPUT = 8_192;
+/** 压缩后保留的最近消息条数。
+ *  注意：此值针对 compactable 消息（user/assistant/tool，不含 system）。
+ *  设为 8 而非 12，避免在常见场景（4 条 system + 12 条非 system = 16 条总消息）下
+ *  removableCount = max(0, 12 - 12) = 0 导致 summarize 完全不生效。
+ */
+const COMPACTION_RECENT_MESSAGE_COUNT = 8;
+/** 摘要最大字符数 */
+const COMPACTION_MAX_SUMMARY_CHARS = 6000;
+/** 单条消息预览最大字符数 */
+const COMPACTION_MAX_PREVIEW_CHARS = 500;
+/** 摘要前缀标识 */
+const COMPACTION_SUMMARY_PREFIX = "ACode context compaction summary:";
+/**
+ * LLM 摘要 prompt 模板（OpenCode 风格结构化摘要）。
+ *
+ * 用于 summarizeConversationWithLLM：追加到 user 消息末尾，指导 LLM 按结构化
+ * 段落（Goal/Instructions/Discoveries/Accomplished/Files）输出摘要，便于后续
+ * 轮次快速恢复上下文。LLM 摘要失败时降级到 rule-based summarizeConversation。
+ */
+export const COMPACTION_LLM_PROMPT_TEMPLATE = [
+    "Please summarize the conversation above using the following structured format.",
+    "Keep each section concise but preserve all actionable details.",
+    "",
+    "## Goal",
+    "The user's primary objective in this conversation.",
+    "",
+    "## Instructions",
+    "Standing instructions, constraints, or preferences the user has stated.",
+    "",
+    "## Discoveries",
+    "Key findings, decisions, tool results, file paths, and errors encountered.",
+    "",
+    "## Accomplished",
+    "Tasks that have been completed (do not redo these).",
+    "",
+    "## Files",
+    "Files read, modified, or created with brief context.",
+    "",
+    "Output only the summary, no preamble.",
+].join("\n");
+/** token 估算系数：约 3 字符/token（混合中英文） */
+const ESTIMATED_CHARS_PER_TOKEN = 3;
+/**
+ * 计算压缩触发阈值：取 min(contextLimit × 55%, hardLimit - reserved)。
+ *
+ * - ratioBased = contextLimit × COMPACTION_TRIGGER_RATIO（基于窗口比例的软阈值）
+ * - hardLimit = inputLimit ?? contextLimit（provider 显式 inputLimit 优先）
+ * - reserved = min(COMPACTION_BUFFER, maxOutput)（buffer 不超过输出上限）
+ *
+ * 取两者较小者，既避免小窗口下过早触发，又避免接近硬上限时来不及压缩。
+ */
+export function calculateCompactionThreshold(contextLimit, maxOutput, inputLimit) {
+    const ratioBased = Math.floor(contextLimit * COMPACTION_TRIGGER_RATIO);
+    const hardLimit = inputLimit ?? contextLimit;
+    const reserved = Math.min(COMPACTION_BUFFER, maxOutput);
+    const hardLimitBased = hardLimit - reserved;
+    return Math.min(ratioBased, hardLimitBased);
+}
+// ============ 模型上下文窗口查找 ============
+/**
+ * 知名模型的上下文窗口大小查找表。
+ * 数据来源：各模型官方文档。
+ */
+const MODEL_CONTEXT_LIMITS = {
+    // Anthropic Claude
+    "claude-4": { contextLimit: 200_000, maxOutput: 8_192 },
+    "claude-sonnet-4": { contextLimit: 200_000, maxOutput: 8_192 },
+    "claude-3-5-sonnet": { contextLimit: 200_000, maxOutput: 8_192 },
+    "claude-3-opus": { contextLimit: 200_000, maxOutput: 8_192 },
+    "claude-3-haiku": { contextLimit: 200_000, maxOutput: 8_192 },
+    "claude-2": { contextLimit: 100_000, maxOutput: 4_096 },
+    // OpenAI GPT
+    "gpt-4o": { contextLimit: 128_000, maxOutput: 16_384 },
+    "gpt-4-turbo": { contextLimit: 128_000, maxOutput: 4_096 },
+    "gpt-4": { contextLimit: 8_192, maxOutput: 4_096 },
+    "gpt-3.5-turbo": { contextLimit: 16_384, maxOutput: 4_096 },
+    "o1": { contextLimit: 200_000, maxOutput: 100_000 },
+    "o3-mini": { contextLimit: 200_000, maxOutput: 100_000 },
+    // Google Gemini
+    "gemini-2.0-flash": { contextLimit: 1_048_576, maxOutput: 8_192 },
+    "gemini-2.5-pro": { contextLimit: 1_048_576, maxOutput: 8_192 },
+    "gemini-1.5-pro": { contextLimit: 2_097_152, maxOutput: 8_192 },
+    "gemini-1.5-flash": { contextLimit: 1_048_576, maxOutput: 8_192 },
+    // DeepSeek
+    "deepseek": { contextLimit: 64_000, maxOutput: 8_192 },
+    "deepseek-chat": { contextLimit: 64_000, maxOutput: 8_192 },
+    "deepseek-reasoner": { contextLimit: 64_000, maxOutput: 8_192 },
+    // Qwen
+    "qwen-max": { contextLimit: 32_000, maxOutput: 8_192 },
+    "qwen-plus": { contextLimit: 128_000, maxOutput: 8_192 },
+    "qwen-turbo": { contextLimit: 1_000_000, maxOutput: 8_192 },
+    // GLM
+    "glm-4": { contextLimit: 128_000, maxOutput: 4_096 },
+    // Yi
+    "yi-": { contextLimit: 200_000, maxOutput: 4_096 },
+    // Meta Llama
+    "llama-3": { contextLimit: 8_192, maxOutput: 4_096 },
+    "llama-2": { contextLimit: 4_096, maxOutput: 4_096 },
+    // Mistral
+    "mistral": { contextLimit: 32_000, maxOutput: 4_096 },
+    "mixtral": { contextLimit: 32_000, maxOutput: 4_096 },
+    "codestral": { contextLimit: 256_000, maxOutput: 8_192 },
+    // Grok
+    "grok": { contextLimit: 131_072, maxOutput: 4_096 },
+    // Amazon Nova
+    "nova-": { contextLimit: 200_000, maxOutput: 8_192 },
+};
+/**
+ * 根据模型名查找上下文窗口大小。
+ * 主流程：优先使用传入的 configOverrides → 精确匹配 → 前缀匹配（按长度降序）→ 默认值。
+ *
+ * @param modelName 模型名
+ * @param configOverrides 可选的配置覆盖值（来自 acode.json 的 contextLimit/maxOutput）
+ */
+export function lookupModelLimits(modelName, configOverrides) {
+    // 配置覆盖优先（来自 acode.json 等模板配置）
+    if (configOverrides?.contextLimit && configOverrides.contextLimit > 0) {
+        return {
+            contextLimit: configOverrides.contextLimit,
+            maxOutput: configOverrides.maxOutput ?? DEFAULT_MAX_OUTPUT,
+        };
+    }
+    if (!modelName)
+        return { contextLimit: DEFAULT_CONTEXT_LIMIT, maxOutput: DEFAULT_MAX_OUTPUT };
+    const key = modelName.toLowerCase().trim();
+    if (MODEL_CONTEXT_LIMITS[key])
+        return MODEL_CONTEXT_LIMITS[key];
+    const matches = Object.keys(MODEL_CONTEXT_LIMITS)
+        .filter((prefix) => key.startsWith(prefix))
+        .sort((a, b) => b.length - a.length);
+    if (matches.length > 0)
+        return MODEL_CONTEXT_LIMITS[matches[0]];
+    return { contextLimit: DEFAULT_CONTEXT_LIMIT, maxOutput: DEFAULT_MAX_OUTPUT };
+}
+// ============ Token 估算 ============
+/**
+ * 粗略估算文本的 token 数。
+ * 不使用真实 tokenizer（太慢），基于字符数乘经验系数。
+ * 对纯 ASCII 约 4 字符/token，对中文约 1.5-2 字符/token，混合取 3 字符/token。
+ */
+export function estimateTokens(text) {
+    if (!text)
+        return 0;
+    return Math.ceil(text.length / ESTIMATED_CHARS_PER_TOKEN);
+}
+/**
+ * 估算单条消息的字节大小。
+ */
+function estimateMessageBytes(message) {
+    let size = 16;
+    if (typeof message.content === "string") {
+        size += message.content.length * 2;
+    }
+    else if (Array.isArray(message.content)) {
+        for (const part of message.content) {
+            if (typeof part === "object" && part !== null) {
+                size += JSON.stringify(part).length;
+            }
+        }
+    }
+    if (message.tool_calls) {
+        size += JSON.stringify(message.tool_calls).length;
+    }
+    if (message.tool_call_id) {
+        size += message.tool_call_id.length;
+    }
+    return size;
+}
+/**
+ * 估算整个对话的 token 数。
+ */
+export function estimateConversationTokens(messages) {
+    let totalChars = 0;
+    for (const msg of messages) {
+        if (typeof msg.content === "string") {
+            totalChars += msg.content.length;
+        }
+        else if (Array.isArray(msg.content)) {
+            for (const part of msg.content) {
+                if (typeof part === "object" && part !== null) {
+                    totalChars += JSON.stringify(part).length;
+                }
+            }
+        }
+        if (msg.tool_calls) {
+            totalChars += JSON.stringify(msg.tool_calls).length;
+        }
+        if (msg.tool_call_id) {
+            totalChars += msg.tool_call_id.length;
+        }
+    }
+    return Math.ceil(totalChars / ESTIMATED_CHARS_PER_TOKEN);
+}
+/**
+ * 计算对话的 KB 大小。
+ */
+export function conversationSizeKB(messages) {
+    let totalBytes = 0;
+    for (const msg of messages) {
+        totalBytes += estimateMessageBytes(msg);
+    }
+    return Math.round((totalBytes / 1024) * 10) / 10;
+}
+/**
+ * 判断对话是否上下文溢出（基于文本估算）。
+ * 使用显式传入的 contextLimit 和比例触发，不依赖模型名查找表。
+ *
+ * @param messages 对话消息数组
+ * @param contextLimit 上下文窗口上限
+ * @param maxOutput 模型最大输出 token（未使用，保留参数兼容）
+ */
+export function isOverflow(messages, contextLimit, _maxOutput) {
+    if (contextLimit <= 0)
+        return false;
+    const totalUsed = estimateConversationTokens(messages);
+    const ratioThreshold = Math.floor(contextLimit * COMPACTION_TRIGGER_RATIO);
+    return totalUsed >= ratioThreshold;
+}
+/**
+ * 基于 provider 实际返回的累积 token 使用量判断是否应触发压缩。
+ *
+ * provider 每次请求都会返回实际 token 计数（input + output），
+ * 这个计数比基于文本的估算（estimateConversationTokens）要准确得多。
+ *
+ * 触发条件：累积 tokens >= contextLimit * COMPACTION_TRIGGER_RATIO
+ * 使用显式传入的 contextLimit，不依赖模型名查找表。
+ *
+ * @param accumulatedInput  provider 实际累积的 input tokens
+ * @param accumulatedOutput provider 实际累积的 output tokens
+ * @param contextLimit 上下文窗口上限（来自模板配置，未配置时使用默认值）
+ */
+export function isOverflowByActualUsage(accumulatedInput, accumulatedOutput, contextLimit) {
+    if (contextLimit <= 0)
+        return false;
+    const totalUsed = accumulatedInput + accumulatedOutput;
+    const ratioThreshold = Math.floor(contextLimit * COMPACTION_TRIGGER_RATIO);
+    return totalUsed >= ratioThreshold;
+}
+// ============ Prune 策略 ============
+/**
+ * 判断消息是否为工具消息（可裁剪）。
+ */
+function isToolMessage(message) {
+    return message.role === "tool";
+}
+/**
+ * 从工具消息中提取工具名（用于白名单检查）。
+ * 通过 tool_call_id 在对话历史中查找对应的 assistant 消息的 tool_calls，
+ * 匹配后返回 function name。
+ */
+function getToolNameFromMessage(message, allMessages, messageIndex) {
+    if (message.role !== "tool" || !message.tool_call_id) {
+        return undefined;
+    }
+    for (let i = messageIndex - 1; i >= 0; i--) {
+        const m = allMessages[i];
+        if (!m)
+            continue;
+        if (m.role === "assistant" && Array.isArray(m.tool_calls)) {
+            for (const tc of m.tool_calls) {
+                if (typeof tc === "object" &&
+                    tc !== null &&
+                    "id" in tc &&
+                    tc.id === message.tool_call_id) {
+                    const fn = tc.function;
+                    return fn ? String(fn.name ?? "") : undefined;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Prune：从消息列表中裁剪旧工具消息的输出内容。
+ *
+ * 算法（参考 OpenCode compaction.ts:58-99）：
+ * 1. 从最新消息往旧遍历
+ * 2. 跳过前 2 轮对话（保护最近上下文）
+ * 3. 累计工具消息的 token
+ * 4. 超过保护线后，将工具输出替换为占位符
+ * 5. 只有收益超过最小阈值才真正执行
+ *
+ * 保护线和最小阈值会按 contextLimit 比例调整：
+ *   - protectLine = min(PRUNE_PROTECT, contextLimit * PRUNE_PROTECT_RATIO)
+ *   - minimumGain = min(PRUNE_MINIMUM, contextLimit * PRUNE_MINIMUM_RATIO)
+ * 这样在小上下文窗口（如 60k）下也能正常触发 prune，
+ * 而不是固定 40k/20k 导致 60k 上下文永远无法 prune。
+ *
+ * @param messages 对话消息数组（会被原地修改）
+ * @param contextLimit 上下文窗口大小，用于按比例调整阈值（默认使用 DEFAULT_CONTEXT_LIMIT）
+ * @returns 裁剪结果
+ */
+export function pruneToolOutputs(messages, contextLimit = DEFAULT_CONTEXT_LIMIT) {
+    if (messages.length === 0) {
+        return { prunedCount: 0, freedTokens: 0 };
+    }
+    // 按比例调整保护线和最小收益阈值
+    const protectLine = Math.min(PRUNE_PROTECT, Math.floor(contextLimit * PRUNE_PROTECT_RATIO));
+    const minimumGain = Math.min(PRUNE_MINIMUM, Math.floor(contextLimit * PRUNE_MINIMUM_RATIO));
+    let total = 0;
+    let freedTokens = 0;
+    const toPrune = [];
+    let turns = 0;
+    // 从最新往旧遍历
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.role === "user")
+            turns++;
+        if (turns < 2)
+            continue;
+        if (!isToolMessage(msg))
+            continue;
+        const toolName = getToolNameFromMessage(msg, messages, i);
+        if (toolName && PRUNE_PROTECTED_TOOLS.has(toolName))
+            continue;
+        const contentStr = typeof msg.content === "string" ? msg.content : "";
+        const estimate = estimateTokens(contentStr);
+        total += estimate;
+        if (total > protectLine) {
+            freedTokens += estimate;
+            toPrune.push(msg);
+        }
+    }
+    if (freedTokens < minimumGain) {
+        return { prunedCount: 0, freedTokens: 0 };
+    }
+    // 执行裁剪：将工具输出替换为占位符
+    for (const msg of toPrune) {
+        msg.content = "[Old tool result content cleared]";
+    }
+    return { prunedCount: toPrune.length, freedTokens };
+}
+// ============ Summarize 策略 ============
+/**
+ * 判断消息是否为压缩摘要消息。
+ */
+function isCompactionSummaryMessage(message) {
+    return (message.role === "system" &&
+        typeof message.content === "string" &&
+        message.content.startsWith(COMPACTION_SUMMARY_PREFIX));
+}
+/**
+ * 生成单条消息的摘要预览。
+ */
+function summarizeMessage(message, index) {
+    const contentStr = typeof message.content === "string"
+        ? message.content
+        : Array.isArray(message.content)
+            ? message.content.map((p) => (typeof p === "object" && p !== null ? JSON.stringify(p) : String(p))).join(" ")
+            : "";
+    const preview = contentStr.length > COMPACTION_MAX_PREVIEW_CHARS
+        ? `${contentStr.slice(0, COMPACTION_MAX_PREVIEW_CHARS)}…`
+        : contentStr;
+    const parts = [`${index + 1}. ${message.role}`];
+    if (message.tool_calls && Array.isArray(message.tool_calls) && message.tool_calls.length > 0) {
+        const toolCallSummary = message.tool_calls
+            .map((tc) => {
+            if (typeof tc === "object" && tc !== null) {
+                const fn = tc.function;
+                return fn ? String(fn.name ?? "") : "";
+            }
+            return "";
+        })
+            .filter(Boolean)
+            .join(", ");
+        if (toolCallSummary)
+            parts.push(`tool_calls=${toolCallSummary}`);
+    }
+    if (message.tool_call_id)
+        parts.push(`tool_call_id=${message.tool_call_id}`);
+    if (preview)
+        parts.push(`content=${preview}`);
+    return parts.join(" | ");
+}
+/**
+ * Summarize：将早期对话消息替换为结构化摘要。
+ *
+ * 算法（参考 OpenCode compaction.ts:101-229 的 process 函数）：
+ * 1. 分离 base system 消息和可压缩消息
+ * 2. 保留最近 COMPACTION_RECENT_MESSAGE_COUNT 条消息
+ * 3. 将早期消息生成结构化摘要
+ * 4. 用摘要消息替换早期消息
+ *
+ * @param messages 对话消息数组（会被原地修改）
+ * @returns 摘要化的消息数
+ */
+export async function summarizeConversation(messages, options) {
+    const baseSystemMessages = messages.filter((m) => m.role === "system" && !isCompactionSummaryMessage(m));
+    const compactableMessages = messages.filter((m) => m.role !== "system" || isCompactionSummaryMessage(m));
+    const removableCount = Math.max(0, compactableMessages.length - COMPACTION_RECENT_MESSAGE_COUNT);
+    if (removableCount === 0)
+        return 0;
+    // ★ 切片 + 后清理（取代之前的边界推进）：
+    //    边界推进在找不到"干净边界"时会一路推进到末尾，返回 0，导致 summarize 完全不生效。
+    //    新策略：先按 removableCount 切片，再清理 kept 部分中的 orphan tool 消息和
+    //    orphan assistant(tool_calls)，保证消息序列对 OpenAI 兼容 API 有效。
+    const removedMessages = compactableMessages.slice(0, removableCount);
+    let keptMessages = compactableMessages.slice(removableCount);
+    // 收集 kept 部分所有 assistant(tool_calls) 的 tool_call_id
+    const keptToolCallIds = new Set();
+    for (const m of keptMessages) {
+        if (m.role === "assistant" && m.tool_calls?.length) {
+            for (const tc of m.tool_calls) {
+                if (typeof tc === "object" &&
+                    tc !== null &&
+                    typeof tc.id === "string") {
+                    keptToolCallIds.add(tc.id);
+                }
+            }
+        }
+    }
+    // 第一轮过滤：移除 orphan tool 消息（其父 assistant 已被摘要化）
+    keptMessages = keptMessages.filter((m) => {
+        if (m.role === "tool" && m.tool_call_id) {
+            return keptToolCallIds.has(m.tool_call_id);
+        }
+        return true;
+    });
+    // 第二轮过滤：移除 orphan assistant(tool_calls)（其部分 tool 结果已在第一轮被移除）
+    // 反复迭代直到稳定（一次过滤可能产生新的 orphan）
+    let changed = true;
+    while (changed) {
+        changed = false;
+        // 重新收集 kept 中的 tool_call_id
+        const currentToolCallIds = new Set();
+        for (const m of keptMessages) {
+            if (m.role === "assistant" && m.tool_calls?.length) {
+                for (const tc of m.tool_calls) {
+                    if (typeof tc === "object" &&
+                        tc !== null &&
+                        typeof tc.id === "string") {
+                        currentToolCallIds.add(tc.id);
+                    }
+                }
+            }
+        }
+        // 重新收集 kept 中的 tool_result id
+        const currentToolResultIds = new Set();
+        for (const m of keptMessages) {
+            if (m.role === "tool" && m.tool_call_id) {
+                currentToolResultIds.add(m.tool_call_id);
+            }
+        }
+        const nextKept = keptMessages.filter((m) => {
+            if (m.role === "tool" && m.tool_call_id) {
+                return currentToolCallIds.has(m.tool_call_id);
+            }
+            if (m.role === "assistant" && m.tool_calls?.length) {
+                const expectedIds = new Set();
+                for (const tc of m.tool_calls) {
+                    if (typeof tc === "object" &&
+                        tc !== null &&
+                        typeof tc.id === "string") {
+                        expectedIds.add(tc.id);
+                    }
+                }
+                if (expectedIds.size === 0)
+                    return true;
+                let allFound = true;
+                for (const id of expectedIds) {
+                    if (!currentToolResultIds.has(id)) {
+                        allFound = false;
+                        break;
+                    }
+                }
+                return allFound;
+            }
+            return true;
+        });
+        if (nextKept.length !== keptMessages.length) {
+            changed = true;
+            keptMessages = nextKept;
+        }
+    }
+    // 如果清理后 kept 为空，放弃本次摘要（避免清空整个对话）
+    if (keptMessages.length === 0) {
+        return 0;
+    }
+    // ★ 尝试 LLM 摘要（若注入了 llmSummarizer），失败则降级到规则摘要。
+    //    LLM 摘要失败时静默降级，不抛异常，保证压缩流程继续。
+    let llmSummary = null;
+    if (options?.llmSummarizer) {
+        try {
+            const conversationText = removedMessages
+                .map((message, index) => summarizeMessage(message, index))
+                .join("\n");
+            llmSummary = await options.llmSummarizer({
+                conversationText,
+                messageCount: removableCount,
+                contextLimit: options.contextLimit ?? DEFAULT_CONTEXT_LIMIT,
+            });
+        }
+        catch {
+            // 降级到规则摘要
+            llmSummary = null;
+        }
+    }
+    // 原地修改 messages 数组
+    messages.length = 0;
+    messages.push(...baseSystemMessages);
+    if (llmSummary !== null) {
+        // LLM 摘要路径：标记 "summarized by LLM" 以便 performCompaction 识别
+        messages.push({
+            role: "system",
+            content: [
+                COMPACTION_SUMMARY_PREFIX,
+                `${removableCount} earlier conversation messages were summarized by LLM to free context space.`,
+                "Preserve the user's goal, decisions, tool results, file paths, errors, and unresolved tasks from this summary.",
+                "Recent messages below remain authoritative.",
+                "",
+                llmSummary,
+            ].join("\n"),
+        });
+    }
+    else {
+        // 规则摘要路径（降级或未注入 llmSummarizer）
+        const summaryLines = removedMessages.map((message, index) => summarizeMessage(message, index));
+        const summary = summaryLines.join("\n").slice(0, COMPACTION_MAX_SUMMARY_CHARS);
+        messages.push({
+            role: "system",
+            content: [
+                COMPACTION_SUMMARY_PREFIX,
+                `${removableCount} earlier conversation messages were summarized to free context space.`,
+                "Preserve the user's goal, decisions, tool results, file paths, errors, and unresolved tasks from this summary.",
+                "Recent messages below remain authoritative.",
+                "",
+                summary,
+            ].join("\n"),
+        });
+    }
+    messages.push(...keptMessages);
+    return removableCount;
+}
+// ============ 完整压缩流程 ============
+/**
+ * 执行完整压缩流程：Prune → 若仍溢出则 Summarize。
+ *
+ * 参考 OpenCode 的两阶段策略：
+ * 1. 先尝试 prune（低成本，只清除旧工具输出）
+ * 2. 若 prune 后仍溢出，执行 summarize（高成本，摘要化早期对话）
+ *
+ * @param messages 对话消息数组（会被原地修改）
+ * @param contextLimit 上下文窗口上限（来自模板配置，未配置时使用默认值）
+ * @param maxOutput 模型最大输出 token
+ * @param options 可选：llmSummarizer（LLM 摘要器，失败降级到规则摘要）、onPhase（阶段事件回调）
+ * @returns 压缩结果
+ */
+export async function performCompaction(messages, contextLimit, maxOutput = DEFAULT_MAX_OUTPUT, options) {
+    const sizeBeforeKB = conversationSizeKB(messages);
+    const messageCountBefore = messages.length;
+    const tokensBefore = estimateConversationTokens(messages);
+    let strategy = "none";
+    let prunedToolMessages = 0;
+    let summarizedMessages = 0;
+    let freedTokens = 0;
+    let usedLLM = false;
+    // 阶段 1: Prune（传入 contextLimit 以按比例调整保护线和最小收益阈值）
+    if (options?.onPhase) {
+        options.onPhase({ phase: "prune_start", messageCount: messages.length });
+    }
+    const pruneResult = pruneToolOutputs(messages, contextLimit);
+    if (pruneResult.prunedCount > 0) {
+        strategy = "prune";
+        prunedToolMessages = pruneResult.prunedCount;
+        freedTokens += pruneResult.freedTokens;
+    }
+    if (options?.onPhase) {
+        options.onPhase({
+            phase: "prune_end",
+            prunedCount: pruneResult.prunedCount,
+            freedTokens: pruneResult.freedTokens,
+        });
+    }
+    // 阶段 2: 若仍溢出，执行 Summarize
+    if (isOverflow(messages, contextLimit, maxOutput)) {
+        if (options?.onPhase) {
+            options.onPhase({ phase: "summarize_start", messageCount: messages.length });
+        }
+        const summarized = await summarizeConversation(messages, {
+            llmSummarizer: options?.llmSummarizer,
+            contextLimit,
+        });
+        if (summarized > 0) {
+            strategy = strategy === "prune" ? "prune+summarize" : "summarize";
+            summarizedMessages = summarized;
+            const tokensAfter = estimateConversationTokens(messages);
+            freedTokens = Math.max(freedTokens, tokensBefore - tokensAfter);
+            // 检测是否使用了 LLM 摘要（通过摘要消息内容识别）
+            const summaryMsg = messages.find((m) => m.role === "system" &&
+                typeof m.content === "string" &&
+                m.content.includes("summarized by LLM"));
+            usedLLM = Boolean(summaryMsg);
+        }
+        if (options?.onPhase) {
+            options.onPhase({
+                phase: "summarize_end",
+                summarizedCount: summarizedMessages,
+                usedLLM,
+            });
+        }
+    }
+    const sizeAfterKB = conversationSizeKB(messages);
+    const messageCountAfter = messages.length;
+    if (strategy === "none") {
+        return {
+            strategy: "none",
+            freedTokens: 0,
+            sizeBeforeKB,
+            sizeAfterKB: sizeBeforeKB,
+            messageCountBefore,
+            messageCountAfter,
+            prunedToolMessages: 0,
+            summarizedMessages: 0,
+        };
+    }
+    return {
+        strategy,
+        freedTokens,
+        sizeBeforeKB,
+        sizeAfterKB,
+        messageCountBefore,
+        messageCountAfter,
+        prunedToolMessages,
+        summarizedMessages,
+    };
+}

package/package/acode/dist/config.d.ts

@@ -1,4 +1,9 @@
-import type { ACodeConfigFile, ACodeSkillMetadata } from './types.js';
+import type { ACodeConfigFile, ACodeSkillGroup, ACodeSkillMetadata } from './types.js';
 export declare function loadAcodeConfig(configPath: string | undefined): Promise<ACodeConfigFile>;
 export declare function loadAcodeSkills(skillsDir: string | undefined): Promise<ACodeSkillMetadata[]>;
+/**
+ * 加载单个 skills 目录：返回目录路径、是否存在、以及该目录下的 skills 列表。
+ * 目录不存在时返回 exists=false + 空 skills，供前端展示空节点。
+ */
+export declare function loadAcodeSkillGroup(skillsDir: string): Promise<ACodeSkillGroup>;
 //# sourceMappingURL=config.d.ts.map

package/package/acode/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAWtE,wBAAsB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,eAAe,CAAC,CAU9F;AA8CD,wBAAsB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAgBlG"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAWvF,wBAAsB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,eAAe,CAAC,CAU9F;AA4DD,wBAAsB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAKlG;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAgBrF"}