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

package/dist/index.js

@@ -909,10 +909,6 @@ var VALID_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "compress.preserveRecentMessages",
   "compress.preserveRecentTokens",
   "compress.preserveLastUserMessage",
-  "compress.stripProtectedReasoning",
-  "compress.stripProtectedReasoningThreshold",
-  "compress.stripProtectedReasoningProviders",
-  "compress.stripProtectedReasoningMinMessages",
   "gc",
   "gc.algorithm",
   "gc.promotionThreshold",
@@ -1266,36 +1262,6 @@ function validateConfigTypes(config) {
           actual: typeof compress.preserveLastUserMessage
         });
       }
-      if (compress.stripProtectedReasoning !== void 0 && typeof compress.stripProtectedReasoning !== "boolean") {
-        errors.push({
-          key: "compress.stripProtectedReasoning",
-          expected: "boolean",
-          actual: typeof compress.stripProtectedReasoning
-        });
-      }
-      if (compress.stripProtectedReasoningThreshold !== void 0 && (typeof compress.stripProtectedReasoningThreshold !== "number" || !Number.isFinite(compress.stripProtectedReasoningThreshold) || compress.stripProtectedReasoningThreshold < 0)) {
-        errors.push({
-          key: "compress.stripProtectedReasoningThreshold",
-          expected: "number (>= 0)",
-          actual: JSON.stringify(compress.stripProtectedReasoningThreshold)
-        });
-      }
-      if (compress.stripProtectedReasoningProviders !== void 0 && (!Array.isArray(compress.stripProtectedReasoningProviders) || !compress.stripProtectedReasoningProviders.every(
-        (entry) => typeof entry === "string" && entry.trim() !== ""
-      ))) {
-        errors.push({
-          key: "compress.stripProtectedReasoningProviders",
-          expected: 'string[] (non-empty strings; "*" = all providers)',
-          actual: JSON.stringify(compress.stripProtectedReasoningProviders)
-        });
-      }
-      if (compress.stripProtectedReasoningMinMessages !== void 0 && (typeof compress.stripProtectedReasoningMinMessages !== "number" || !Number.isInteger(compress.stripProtectedReasoningMinMessages) || compress.stripProtectedReasoningMinMessages < 0)) {
-        errors.push({
-          key: "compress.stripProtectedReasoningMinMessages",
-          expected: "integer (>= 0)",
-          actual: JSON.stringify(compress.stripProtectedReasoningMinMessages)
-        });
-      }
       if (typeof compress.iterationNudgeThreshold === "number" && compress.iterationNudgeThreshold < 1) {
         errors.push({
           key: "compress.iterationNudgeThreshold",
@@ -1693,11 +1659,7 @@ var defaultConfig = {
     lastSegmentSoftBlock: true,
     preserveRecentMessages: 5,
     preserveRecentTokens: 5e3,
-    preserveLastUserMessage: true,
-    stripProtectedReasoning: true,
-    stripProtectedReasoningThreshold: 0,
-    stripProtectedReasoningProviders: ["anthropic", "gemini"],
-    stripProtectedReasoningMinMessages: 100
+    preserveLastUserMessage: true
   },
   gc: {
     algorithm: "truncate",
@@ -1867,11 +1829,7 @@ function mergeCompress(base, override) {
     lastSegmentSoftBlock: override.lastSegmentSoftBlock ?? base.lastSegmentSoftBlock,
     preserveRecentMessages: override.preserveRecentMessages ?? base.preserveRecentMessages,
     preserveRecentTokens: override.preserveRecentTokens ?? base.preserveRecentTokens,
-    preserveLastUserMessage: override.preserveLastUserMessage ?? base.preserveLastUserMessage,
-    stripProtectedReasoning: override.stripProtectedReasoning ?? base.stripProtectedReasoning,
-    stripProtectedReasoningThreshold: override.stripProtectedReasoningThreshold ?? base.stripProtectedReasoningThreshold,
-    stripProtectedReasoningProviders: Array.isArray(override.stripProtectedReasoningProviders) ? [...override.stripProtectedReasoningProviders] : base.stripProtectedReasoningProviders,
-    stripProtectedReasoningMinMessages: override.stripProtectedReasoningMinMessages ?? base.stripProtectedReasoningMinMessages
+    preserveLastUserMessage: override.preserveLastUserMessage ?? base.preserveLastUserMessage
   };
 }
 function mergeCommands(base, override) {
@@ -6861,6 +6819,7 @@ function estimateContextComposition(messages, state, protectedTools = [], protec
   let summaryTokens = 0;
   let messageTokens = 0;
   let protectedTokens = 0;
+  let reasoningTokens = 0;
   const perMessage = [];
   const perTool = [];
   const perCode = [];
@@ -6914,6 +6873,10 @@ 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) {
@@ -6941,7 +6904,8 @@ function estimateContextComposition(messages, state, protectedTools = [], protec
     textTokens: Math.max(0, messageTokens - codeTokens),
     systemTokens,
     protectedTokens,
-    total: systemTokens + toolTokens + summaryTokens + messageTokens,
+    reasoningTokens,
+    total: systemTokens + toolTokens + summaryTokens + messageTokens + reasoningTokens,
     largestRanges: perMessage.slice(0, 15),
     largestToolRanges: perTool.slice(0, 15),
     largestCodeRanges: perCode.slice(0, 5),
@@ -8136,7 +8100,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)}%)${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)}%) | ${fmt(composition.reasoningTokens)} reasoning (${pct2(composition.reasoningTokens)}%)${growthStr}`;
       const compressibleTokens = composition.total - composition.systemTokens - composition.protectedTokens - composition.summaryTokens;
       if (composition.protectedTokens > 0) {
         breakdown += `
@@ -8304,76 +8268,6 @@ function stripStaleMetadata(messages) {
     });
   });
 }
-function stripProtectedReasoning(messages, protectedTools, threshold, options) {
-  if (protectedTools.length === 0) {
-    return 0;
-  }
-  const allowedProviders = options?.allowedProviders;
-  if (allowedProviders !== void 0) {
-    if (allowedProviders.length === 0) {
-      return 0;
-    }
-    if (!allowedProviders.some((entry) => entry.trim() === "*")) {
-      const providerID = options?.providerID;
-      if (providerID === void 0 || !allowedProviders.some(
-        (entry) => providerID.toLowerCase().includes(entry.trim().toLowerCase())
-      )) {
-        return 0;
-      }
-    }
-  }
-  const minMessages = options?.minMessages;
-  if (minMessages !== void 0 && minMessages > 0 && messages.length < minMessages) {
-    return 0;
-  }
-  const lastUserMessage = getLastUserMessage(messages);
-  if (!lastUserMessage || lastUserMessage.info.role !== "user") {
-    return 0;
-  }
-  let lastUserIndex = -1;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i] === lastUserMessage) {
-      lastUserIndex = i;
-      break;
-    }
-  }
-  if (lastUserIndex <= 0) {
-    return 0;
-  }
-  const protectedSet = new Set(protectedTools);
-  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 hasProtectedTool = false;
-    let reasoningLength = 0;
-    for (const part of parts) {
-      if (part.type === "tool") {
-        if (protectedSet.has(part.tool)) {
-          hasProtectedTool = true;
-        }
-      } else if (part.type === "reasoning") {
-        reasoningLength += part.text.length;
-      }
-    }
-    if (!hasProtectedTool) {
-      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) {
@@ -9054,6 +8948,7 @@ 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") {
@@ -9064,10 +8959,12 @@ 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) {
-      result.push({ ref, tokens, tool: toolName || "text", index: idx });
+    if (tokens > 0 || reasoning > 0) {
+      result.push({ ref, tokens, tool: toolName || "text", index: idx, reasoning });
     }
   });
   return {
@@ -9089,14 +8986,16 @@ 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 total = systemTokens + totalTool + totalText + summaryTokens;
+    const totalReasoning = visibleMessages.reduce((s, m) => s + m.reasoning, 0);
+    const total = systemTokens + totalTool + totalText + summaryTokens + totalReasoning;
     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(systemTokens)} system (${sysPct}%) | ${formatTokens(totalTool)} tool (${toolPct}%) | ${formatTokens(totalText)} text (${textPct}%) | ${formatTokens(summaryTokens)} summaries (${summaryPct}%) | ${formatTokens(totalReasoning)} reasoning (${reasoningPct}%)`
     );
     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) {
@@ -9207,22 +9106,23 @@ 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) || b.tokens - a.tokens);
+    filtered.sort((a, b) => a.tool.localeCompare(b.tool) || sizeOf(b) - sizeOf(a));
   } else {
-    filtered.sort((a, b) => b.tokens - a.tokens);
+    filtered.sort((a, b) => sizeOf(b) - sizeOf(a));
   }
-  const totalTokens = filtered.reduce((s, m) => s + m.tokens, 0);
-  const allTokens = visibleMessages.reduce((s, m) => s + m.tokens, 0);
+  const totalTokens = filtered.reduce((s, m) => s + sizeOf(m), 0);
+  const allTokens = visibleMessages.reduce((s, m) => s + sizeOf(m), 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(m.tokens)}) ${m.tool}`);
+    lines.push(`  ${m.ref} (${formatTokens(sizeOf(m))}) ${m.tool}`);
   }
   if (filtered.length > shown.length) {
     lines.push("");
@@ -9490,7 +9390,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.370.110" : "dev";
+var LOG_VERSION = true ? "1.14.27-pr.374.107" : "dev";
 var LEVEL_RANK = {
   debug: 10,
   info: 20,
@@ -9786,13 +9686,14 @@ CONTEXT BREAKDOWN
 
 When context usage passes a threshold, the system appends a breakdown showing where your context tokens are spent:
 
-Breakdown: 5.2K system (21%) | 12.3K tool (40%) | 3.1K summaries (10%) | 8.5K code (28%) | 6.5K text (22%)
+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%)
 
 - "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.
 
@@ -11432,7 +11333,6 @@ function createChatMessageTransformHandler(client, registry4, logger, config, pr
       return;
     }
     const lastUserMessage = getLastUserMessage(messages);
-    const requestModel = lastUserMessage?.info?.model;
     let state;
     if (!lastUserMessage) {
       state = createSessionState();
@@ -11443,6 +11343,7 @@ function createChatMessageTransformHandler(client, registry4, logger, config, pr
         messages,
         config
       );
+      const requestModel = lastUserMessage.info.model;
       const requestModelLimit = registry4.resolveModelLimit(
         requestModel?.providerID,
         requestModel?.modelID
@@ -11507,30 +11408,6 @@ function createChatMessageTransformHandler(client, registry4, logger, config, pr
     prune(state, logger, config, output.messages);
     truncateLargeToolOutputs(state, config, logger, output.messages);
     hideConsumedCompressCalls(state, output.messages);
-    if (config.compress.stripProtectedReasoning !== false) {
-      const removedReasoning = stripProtectedReasoning(
-        output.messages,
-        config.compress.protectedTools,
-        config.compress.stripProtectedReasoningThreshold ?? 0,
-        {
-          // Prefer this request's provider from the user-message
-          // model metadata; fall back to the cached identity pair
-          // (undefined on the first request of a fresh session →
-          // fail-closed).
-          providerID: requestModel?.providerID ?? state.modelProviderID,
-          allowedProviders: config.compress.stripProtectedReasoningProviders ?? [
-            "anthropic",
-            "gemini"
-          ],
-          minMessages: config.compress.stripProtectedReasoningMinMessages ?? 100
-        }
-      );
-      if (removedReasoning > 0) {
-        logger.debug("stripProtectedReasoning: removed reasoning parts from historical protected messages", {
-          removed: removedReasoning
-        });
-      }
-    }
     assignMessageRefs(state, output.messages);
     const compressionPriorities = buildPriorityMap(config, state, output.messages);
     prompts.reload();
@@ -11987,7 +11864,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.370.110" : "dev",
+    version: true ? "1.14.27-pr.374.107" : "dev",
     workspace: ctx.directory,
     logLevel: logger.level,
     debug: config.debug,