opencode-acp 1.14.27-pr.374.107 → 1.14.27-pr.377.112

package/README.md

@@ -381,6 +381,15 @@ Each level overrides the previous, so project settings take priority over global
         // Preserve your messages during compression.
         // Warning: large copy-pasted prompts will never be compressed away
         "protectUserMessages": false,
+        // [#368] Drop oversized reasoning (thinking) from historical compress
+        // tool calls at request time. compress calls are hard-exempt from
+        // compression, so their thinking rides along every request as an
+        // unreclaimable floor. Closed turns only; the active round is never
+        // touched. Small thinkings under the threshold are kept.
+        "reasoning": {
+            "drop": true,
+            "threshold": 2048
+        },
     },
     // Garbage collection — hardcoded 100% fallback only
     "gc": {

package/README.zh-CN.md

@@ -334,6 +334,14 @@ ACP 使用自己的配置文件，按以下顺序搜索：
         // Preserve your messages during compression.
         // Warning: large copy-pasted prompts will never be compressed away
         "protectUserMessages": false,
+        // [#368] 请求时丢弃历史 compress 工具调用中超大的 reasoning（思考）。
+        // compress 调用被硬排除在压缩之外，其思考内容会随每次请求原样重发，
+        // 形成无法回收的上下文底座。仅作用于已关闭的轮次，活跃轮永不触碰；
+        // 低于阈值的小思考保留。
+        "reasoning": {
+            "drop": true,
+            "threshold": 2048
+        },
     },
     // 垃圾回收与批量清理
     "gc": {

package/dist/index.js

@@ -909,6 +909,9 @@ var VALID_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "compress.preserveRecentMessages",
   "compress.preserveRecentTokens",
   "compress.preserveLastUserMessage",
+  "compress.reasoning",
+  "compress.reasoning.drop",
+  "compress.reasoning.threshold",
   "gc",
   "gc.algorithm",
   "gc.promotionThreshold",
@@ -1262,6 +1265,30 @@ function validateConfigTypes(config) {
           actual: typeof compress.preserveLastUserMessage
         });
       }
+      if (compress.reasoning !== void 0) {
+        if (typeof compress.reasoning !== "object" || compress.reasoning === null || Array.isArray(compress.reasoning)) {
+          errors.push({
+            key: "compress.reasoning",
+            expected: "object { drop?: boolean; threshold?: integer (>= 0) }",
+            actual: JSON.stringify(compress.reasoning)
+          });
+        } else {
+          if (compress.reasoning.drop !== void 0 && typeof compress.reasoning.drop !== "boolean") {
+            errors.push({
+              key: "compress.reasoning.drop",
+              expected: "boolean",
+              actual: typeof compress.reasoning.drop
+            });
+          }
+          if (compress.reasoning.threshold !== void 0 && (typeof compress.reasoning.threshold !== "number" || !Number.isInteger(compress.reasoning.threshold) || compress.reasoning.threshold < 0)) {
+            errors.push({
+              key: "compress.reasoning.threshold",
+              expected: "integer (>= 0)",
+              actual: JSON.stringify(compress.reasoning.threshold)
+            });
+          }
+        }
+      }
       if (typeof compress.iterationNudgeThreshold === "number" && compress.iterationNudgeThreshold < 1) {
         errors.push({
           key: "compress.iterationNudgeThreshold",
@@ -1347,7 +1374,8 @@ function validateConfigTypes(config) {
         maxVisibleSegments: "positiveNumber",
         keepEmbedMaxChars: "nonNegativeNumber",
         preserveRecentMessages: "nonNegativeNumber",
-        preserveRecentTokens: "nonNegativeNumber"
+        preserveRecentTokens: "nonNegativeNumber",
+        reasoning: "reasoningConfig"
       };
       const validateOverrideField = (key, type, value) => {
         if (value === void 0) {
@@ -1387,6 +1415,31 @@ function validateConfigTypes(config) {
               errors.push({ key, expected: "string[]", actual: JSON.stringify(value) });
             }
             break;
+          case "reasoningConfig":
+            if (typeof value !== "object" || value === null || Array.isArray(value)) {
+              errors.push({
+                key,
+                expected: "object { drop?: boolean; threshold?: integer (>= 0) }",
+                actual: JSON.stringify(value)
+              });
+              break;
+            }
+            const reasoning = value;
+            if (reasoning.drop !== void 0 && typeof reasoning.drop !== "boolean") {
+              errors.push({
+                key: `${key}.drop`,
+                expected: "boolean",
+                actual: typeof reasoning.drop
+              });
+            }
+            if (reasoning.threshold !== void 0 && (typeof reasoning.threshold !== "number" || !Number.isInteger(reasoning.threshold) || reasoning.threshold < 0)) {
+              errors.push({
+                key: `${key}.threshold`,
+                expected: "integer (>= 0)",
+                actual: JSON.stringify(reasoning.threshold)
+              });
+            }
+            break;
         }
       };
       const validateOverrideObject = (prefix, overrides) => {
@@ -1565,6 +1618,10 @@ function validateConfigTypes(config) {
 }
 
 // lib/config.ts
+var DEFAULT_COMPRESS_REASONING = {
+  drop: true,
+  threshold: 2048
+};
 var DEFAULT_PROTECTED_TOOLS = [
   "task",
   "skill",
@@ -1659,7 +1716,8 @@ var defaultConfig = {
     lastSegmentSoftBlock: true,
     preserveRecentMessages: 5,
     preserveRecentTokens: 5e3,
-    preserveLastUserMessage: true
+    preserveLastUserMessage: true,
+    reasoning: { ...DEFAULT_COMPRESS_REASONING }
   },
   gc: {
     algorithm: "truncate",
@@ -1829,7 +1887,11 @@ function mergeCompress(base, override) {
     lastSegmentSoftBlock: override.lastSegmentSoftBlock ?? base.lastSegmentSoftBlock,
     preserveRecentMessages: override.preserveRecentMessages ?? base.preserveRecentMessages,
     preserveRecentTokens: override.preserveRecentTokens ?? base.preserveRecentTokens,
-    preserveLastUserMessage: override.preserveLastUserMessage ?? base.preserveLastUserMessage
+    preserveLastUserMessage: override.preserveLastUserMessage ?? base.preserveLastUserMessage,
+    reasoning: {
+      drop: override.reasoning?.drop ?? base.reasoning?.drop ?? DEFAULT_COMPRESS_REASONING.drop,
+      threshold: override.reasoning?.threshold ?? base.reasoning?.threshold ?? DEFAULT_COMPRESS_REASONING.threshold
+    }
   };
 }
 function mergeCommands(base, override) {
@@ -6647,10 +6709,11 @@ function resolveCompressOverrides(config, providerId, modelId) {
   }
   const { models: _models, ...providerFields } = providerEntry;
   const modelEntry = modelId !== void 0 ? providerEntry.models?.[modelId] : void 0;
-  if (modelEntry) {
-    return { ...providerFields, ...modelEntry };
+  const merged = modelEntry ? { ...providerFields, ...modelEntry } : providerFields;
+  if (providerFields.reasoning !== void 0 || modelEntry?.reasoning !== void 0) {
+    merged.reasoning = { ...providerFields.reasoning, ...modelEntry?.reasoning };
   }
-  return providerFields;
+  return merged;
 }
 function resolveMinNudgeContextPercent(config, providerId, modelId) {
   const overrides = resolveCompressOverrides(config, providerId, modelId);
@@ -6667,19 +6730,26 @@ function resolveMinNudgeFloorTokens(config, modelContextLimit, providerId, model
   const clamped = Math.min(100, Math.max(0, percent));
   return Math.round(clamped / 100 * modelContextLimit);
 }
-var OVERRIDE_BLANKET_APPLY_EXCLUDE = /* @__PURE__ */ new Set(["maxContextLimit"]);
+var OVERRIDE_BLANKET_APPLY_EXCLUDE = /* @__PURE__ */ new Set([
+  "maxContextLimit",
+  "reasoning"
+]);
 function applyCompressOverrides(config, providerId, modelId) {
   const overrides = resolveCompressOverrides(config, providerId, modelId);
   const applied = Object.keys(overrides).filter(
     (key) => !OVERRIDE_BLANKET_APPLY_EXCLUDE.has(key)
   );
-  if (applied.length === 0 || !config.compress) {
+  const reasoningOverride = overrides.reasoning;
+  if (applied.length === 0 && reasoningOverride === void 0 || !config.compress) {
     return config;
   }
   const effectiveCompress = { ...config.compress };
   for (const key of applied) {
     effectiveCompress[key] = overrides[key];
   }
+  if (reasoningOverride !== void 0) {
+    effectiveCompress.reasoning = { ...config.compress.reasoning, ...reasoningOverride };
+  }
   return { ...config, compress: effectiveCompress };
 }
 function addAnchor(anchorMessageIds, anchorMessageId, anchorMessageIndex, messages, interval) {
@@ -6819,7 +6889,6 @@ function estimateContextComposition(messages, state, protectedTools = [], protec
   let summaryTokens = 0;
   let messageTokens = 0;
   let protectedTokens = 0;
-  let reasoningTokens = 0;
   const perMessage = [];
   const perTool = [];
   const perCode = [];
@@ -6873,10 +6942,6 @@ function estimateContextComposition(messages, state, protectedTools = [], protec
         summaryTokens += summaryPartTokens;
         toolTypeMap.set(toolName, (toolTypeMap.get(toolName) || 0) + toolPartTokens);
         if (!msgToolName) msgToolName = toolName;
-      } else if (part.type === "reasoning" && typeof part.text === "string") {
-        const tokens = Math.round(part.text.length / 4);
-        msgTotal += tokens;
-        reasoningTokens += tokens;
       }
     }
     if (isProtected && !isSummary) {
@@ -6904,8 +6969,7 @@ function estimateContextComposition(messages, state, protectedTools = [], protec
     textTokens: Math.max(0, messageTokens - codeTokens),
     systemTokens,
     protectedTokens,
-    reasoningTokens,
-    total: systemTokens + toolTokens + summaryTokens + messageTokens + reasoningTokens,
+    total: systemTokens + toolTokens + summaryTokens + messageTokens,
     largestRanges: perMessage.slice(0, 15),
     largestToolRanges: perTool.slice(0, 15),
     largestCodeRanges: perCode.slice(0, 5),
@@ -8100,7 +8164,7 @@ This is an efficiency nudge to compress early and keep context lean \u2014 not a
 ${COMPRESS_PHILOSOPHY}` : "";
       const sysPart = composition.systemTokens > 0 ? `${fmt(composition.systemTokens)} system (${pct2(composition.systemTokens)}%) | ` : "";
       let breakdown = `${efficiencyNote}
-Breakdown: ${sysPart}${fmt(composition.toolTokens)} tool (${pct2(composition.toolTokens)}%) | ${fmt(composition.summaryTokens)} summaries (${pct2(composition.summaryTokens)}%) | ${fmt(composition.codeTokens)} code (${pct2(composition.codeTokens)}%) | ${fmt(plainTextTokens)} text (${pct2(plainTextTokens)}%) | ${fmt(composition.reasoningTokens)} reasoning (${pct2(composition.reasoningTokens)}%)${growthStr}`;
+Breakdown: ${sysPart}${fmt(composition.toolTokens)} tool (${pct2(composition.toolTokens)}%) | ${fmt(composition.summaryTokens)} summaries (${pct2(composition.summaryTokens)}%) | ${fmt(composition.codeTokens)} code (${pct2(composition.codeTokens)}%) | ${fmt(plainTextTokens)} text (${pct2(plainTextTokens)}%)${growthStr}`;
       const compressibleTokens = composition.total - composition.systemTokens - composition.protectedTokens - composition.summaryTokens;
       if (composition.protectedTokens > 0) {
         breakdown += `
@@ -8268,6 +8332,46 @@ function stripStaleMetadata(messages) {
     });
   });
 }
+function dropCompressReasoning(messages, threshold) {
+  const lastUserMessage = getLastUserMessage(messages);
+  if (!lastUserMessage || lastUserMessage.info.role !== "user") {
+    return 0;
+  }
+  const lastUserIndex = messages.lastIndexOf(lastUserMessage);
+  if (lastUserIndex <= 0) {
+    return 0;
+  }
+  let removed = 0;
+  for (let i = 0; i < lastUserIndex; i++) {
+    const message = messages[i];
+    if (!message || message.info.role !== "assistant") {
+      continue;
+    }
+    const parts = Array.isArray(message.parts) ? message.parts : [];
+    let hasCompressTool = false;
+    let reasoningLength = 0;
+    for (const part of parts) {
+      if (part.type === "tool" && part.tool === "compress") {
+        hasCompressTool = true;
+      } else if (part.type === "reasoning") {
+        reasoningLength += part.text.length;
+      }
+    }
+    if (!hasCompressTool) {
+      continue;
+    }
+    if (reasoningLength <= threshold) {
+      continue;
+    }
+    const filtered = parts.filter((part) => part.type !== "reasoning");
+    if (filtered.length === parts.length) {
+      continue;
+    }
+    message.parts = filtered;
+    removed += parts.length - filtered.length;
+  }
+  return removed;
+}
 
 // lib/messages/priority.ts
 function buildPriorityMap(_config, _state, _messages) {
@@ -8948,7 +9052,6 @@ function collectVisibleMessages(rawMessages, ctx) {
     const ref = byRawId.get(msgId);
     if (!ref) return;
     let tokens = 0;
-    let reasoning = 0;
     let toolName = "";
     for (const part of msg.parts || []) {
       if (part.type === "text" && typeof part.text === "string") {
@@ -8959,12 +9062,10 @@ function collectVisibleMessages(rawMessages, ctx) {
         if (!toolName) {
           toolName = part?.tool || "unknown";
         }
-      } else if (part.type === "reasoning" && typeof part.text === "string") {
-        reasoning += Math.round(part.text.length / 4);
       }
     }
-    if (tokens > 0 || reasoning > 0) {
-      result.push({ ref, tokens, tool: toolName || "text", index: idx, reasoning });
+    if (tokens > 0) {
+      result.push({ ref, tokens, tool: toolName || "text", index: idx });
     }
   });
   return {
@@ -8986,16 +9087,14 @@ function renderOverview(visibleMessages, summaryTokens, systemTokens, blocks, fe
   } else {
     const totalTool = visibleMessages.filter((m) => m.tool !== "text" && m.tool !== "step-finish").reduce((s, m) => s + m.tokens, 0);
     const totalText = visibleMessages.filter((m) => m.tool === "text").reduce((s, m) => s + m.tokens, 0);
-    const totalReasoning = visibleMessages.reduce((s, m) => s + m.reasoning, 0);
-    const total = systemTokens + totalTool + totalText + summaryTokens + totalReasoning;
+    const total = systemTokens + totalTool + totalText + summaryTokens;
     const sysPct = pct(systemTokens, total);
     const toolPct = pct(totalTool, total);
     const textPct = pct(totalText, total);
     const summaryPct = pct(summaryTokens, total);
-    const reasoningPct = pct(totalReasoning, total);
     lines.push("CONTEXT BREAKDOWN");
     lines.push(
-      `  ${formatTokens(systemTokens)} system (${sysPct}%) | ${formatTokens(totalTool)} tool (${toolPct}%) | ${formatTokens(totalText)} text (${textPct}%) | ${formatTokens(summaryTokens)} summaries (${summaryPct}%) | ${formatTokens(totalReasoning)} reasoning (${reasoningPct}%)`
+      `  ${formatTokens(systemTokens)} system (${sysPct}%) | ${formatTokens(totalTool)} tool (${toolPct}%) | ${formatTokens(totalText)} text (${textPct}%) | ${formatTokens(summaryTokens)} summaries (${summaryPct}%)`
     );
     const topTypes = Array.from(toolTypeMap.entries()).map(([tool6, tokens]) => ({ tool: tool6, tokens })).sort((a, b) => b.tokens - a.tokens).slice(0, 3);
     if (topTypes.length > 0) {
@@ -9106,23 +9205,22 @@ function renderUncompressedDrilldown(visibleMessages, toolFilter, sort, limit) {
   if (toolFilter) {
     filtered = filtered.filter((m) => m.tool === toolFilter);
   }
-  const sizeOf = (m) => m.tokens + m.reasoning;
   if (sort === "time") {
     filtered.sort((a, b) => a.index - b.index);
   } else if (sort === "tool") {
-    filtered.sort((a, b) => a.tool.localeCompare(b.tool) || sizeOf(b) - sizeOf(a));
+    filtered.sort((a, b) => a.tool.localeCompare(b.tool) || b.tokens - a.tokens);
   } else {
-    filtered.sort((a, b) => sizeOf(b) - sizeOf(a));
+    filtered.sort((a, b) => b.tokens - a.tokens);
   }
-  const totalTokens = filtered.reduce((s, m) => s + sizeOf(m), 0);
-  const allTokens = visibleMessages.reduce((s, m) => s + sizeOf(m), 0);
+  const totalTokens = filtered.reduce((s, m) => s + m.tokens, 0);
+  const allTokens = visibleMessages.reduce((s, m) => s + m.tokens, 0);
   const header = toolFilter ? `UNCOMPRESSED \u2014 ${toolFilter}: ${formatTokens(totalTokens)} | ${filtered.length} msgs | ${pct(totalTokens, allTokens)}% of visible` : `UNCOMPRESSED \u2014 ${formatTokens(totalTokens)} | ${filtered.length} msgs`;
   lines.push(header);
   lines.push(`Sorted by ${sort}`);
   lines.push("");
   const shown = filtered.slice(0, limit);
   for (const m of shown) {
-    lines.push(`  ${m.ref} (${formatTokens(sizeOf(m))}) ${m.tool}`);
+    lines.push(`  ${m.ref} (${formatTokens(m.tokens)}) ${m.tool}`);
   }
   if (filtered.length > shown.length) {
     lines.push("");
@@ -9390,7 +9488,7 @@ import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
 import { join as join3 } from "path";
 import { existsSync as existsSync3 } from "fs";
 import { homedir as homedir3 } from "os";
-var LOG_VERSION = true ? "1.14.27-pr.374.107" : "dev";
+var LOG_VERSION = true ? "1.14.27-pr.377.112" : "dev";
 var LEVEL_RANK = {
   debug: 10,
   info: 20,
@@ -9686,14 +9784,13 @@ CONTEXT BREAKDOWN
 
 When context usage passes a threshold, the system appends a breakdown showing where your context tokens are spent:
 
-Breakdown: 4.2K system (21%) | 8.0K tool (40%) | 2.0K summaries (10%) | 2.6K code (13%) | 2.2K text (11%) | 1.0K reasoning (5%)
+Breakdown: 5.2K system (21%) | 12.3K tool (40%) | 3.1K summaries (10%) | 8.5K code (28%) | 6.5K text (22%)
 
 - "system" = system prompt tokens (AGENTS.md, tool definitions \u2014 not compressible)
 - "tool" = tool call outputs (largest category \u2014 compress first when consumed)
 - "summaries" = existing compression block summaries (already compressed; do not re-compress standalone)
 - "code" = messages containing code blocks
 - "text" = plain text messages
-- "reasoning" = model thinking blocks (counted to match real API usage; freed when their message is compressed)
 
 Below the breakdown, the system lists compressible ranges grouped by conversation turn. All listed ranges should be compressed to summary format \u2014 the only exceptions are protected content, content the current step is actively using, or critical content you cannot reconstruct. Compress the largest ranges first when the current step no longer needs them.
 
@@ -11383,6 +11480,24 @@ function createChatMessageTransformHandler(client, registry4, logger, config, pr
       return;
     }
     stripHallucinations(output.messages);
+    const dropReasoningModel = lastUserMessage?.info?.model;
+    const reasoningConfig = applyCompressOverrides(
+      config,
+      dropReasoningModel?.providerID ?? state.modelProviderID,
+      dropReasoningModel?.modelID ?? state.modelID
+    ).compress.reasoning;
+    if (reasoningConfig?.drop !== false) {
+      const droppedReasoning = dropCompressReasoning(
+        output.messages,
+        reasoningConfig?.threshold ?? DEFAULT_COMPRESS_REASONING.threshold
+      );
+      if (droppedReasoning > 0) {
+        logger.debug("compress.reasoning: dropped oversized reasoning parts", {
+          dropped: droppedReasoning,
+          threshold: reasoningConfig?.threshold ?? DEFAULT_COMPRESS_REASONING.threshold
+        });
+      }
+    }
     ensureBuiltinFiltersRegistered();
     applyMessageFilters(output.messages, config.messageFilters, logger, {
       sessionId: state.sessionId ?? "",
@@ -11864,7 +11979,7 @@ var server = (async (ctx) => {
   }
   const logger = new Logger(config.debug, config.debug ? "debug" : config.logLevel);
   logger.info("ACP plugin initialized", {
-    version: true ? "1.14.27-pr.374.107" : "dev",
+    version: true ? "1.14.27-pr.377.112" : "dev",
     workspace: ctx.directory,
     logLevel: logger.level,
     debug: config.debug,