opencode-acp 1.14.27-pr.376.109 → 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) {
@@ -2323,12 +2385,12 @@ function serializePruneMessagesState(messagesState) {
     markedForCleanup: Array.from(messagesState.markedForCleanup)
   };
 }
-async function getForkParentId(client, sessionID) {
+async function isSubAgentSession(client, sessionID) {
   try {
     const result = await client.session.get({ path: { id: sessionID } });
-    return result.data?.parentID ?? null;
+    return !!result.data?.parentID;
   } catch (error) {
-    return null;
+    return false;
   }
 }
 function findLastCompactionTimestamp(messages) {
@@ -4365,205 +4427,6 @@ function rebuildCompressionState(state, messages, config, logger) {
   return rebuilt;
 }
 
-// lib/state/fork-transfer.ts
-function extractIdentity(message) {
-  const id = message?.info?.id;
-  if (typeof id !== "string" || id.length === 0) {
-    return null;
-  }
-  if (isSyntheticMessage(message)) {
-    return null;
-  }
-  const role = message.info.role;
-  const created = message.info.time?.created;
-  if (typeof created !== "number") {
-    return null;
-  }
-  return { id, role, created };
-}
-function buildSharedPrefixMapping(parentMessages, forkMessages) {
-  const parentIds = parentMessages.map(extractIdentity).filter((x) => x !== null);
-  const forkIds = forkMessages.map(extractIdentity).filter((x) => x !== null);
-  const mapping = /* @__PURE__ */ new Map();
-  const limit = Math.min(parentIds.length, forkIds.length);
-  for (let i = 0; i < limit; i++) {
-    const p = parentIds[i];
-    const f = forkIds[i];
-    if (p.created === f.created && p.role === f.role) {
-      mapping.set(p.id, f.id);
-    } else {
-      break;
-    }
-  }
-  return mapping;
-}
-function remapBoundaryRef(ref, mapping, forkByRawId, parentByRef) {
-  const parsed = parseBoundaryId(ref);
-  if (!parsed) {
-    return ref;
-  }
-  if (parsed.kind === "compressed-block") {
-    return parsed.ref;
-  }
-  const parentRawId = parentByRef.get(parsed.ref);
-  if (!parentRawId) {
-    return ref;
-  }
-  const forkRawId = mapping.get(parentRawId);
-  if (!forkRawId) {
-    return ref;
-  }
-  const forkRef = forkByRawId.get(forkRawId);
-  return forkRef ?? ref;
-}
-function translateBlock(block, mapping, forkByRawId, parentByRef) {
-  const anchorForkId = mapping.get(block.anchorMessageId);
-  if (!anchorForkId) {
-    return null;
-  }
-  const compressForkId = mapping.get(block.compressMessageId);
-  if (!compressForkId) {
-    return null;
-  }
-  const translateList = (ids) => ids.map((id) => mapping.get(id)).filter((id) => id !== void 0);
-  const preserveList = (ids) => [...new Set(ids)];
-  return {
-    ...block,
-    anchorMessageId: anchorForkId,
-    compressMessageId: compressForkId,
-    directMessageIds: translateList(block.directMessageIds),
-    effectiveMessageIds: translateList(block.effectiveMessageIds),
-    directToolIds: preserveList(block.directToolIds),
-    effectiveToolIds: preserveList(block.effectiveToolIds),
-    startId: remapBoundaryRef(block.startId, mapping, forkByRawId, parentByRef),
-    endId: remapBoundaryRef(block.endId, mapping, forkByRawId, parentByRef)
-  };
-}
-function translateByMessageId(parentByMessageId, mapping, translatedBlockIds) {
-  const result = /* @__PURE__ */ new Map();
-  for (const [parentMsgId, entry] of Object.entries(parentByMessageId)) {
-    if (!entry || typeof entry !== "object") {
-      continue;
-    }
-    const forkMsgId = mapping.get(parentMsgId);
-    if (!forkMsgId) {
-      continue;
-    }
-    const allBlockIds = (entry.allBlockIds ?? []).filter((id) => translatedBlockIds.has(id));
-    const activeBlockIds = (entry.activeBlockIds ?? []).filter(
-      (id) => translatedBlockIds.has(id)
-    );
-    result.set(forkMsgId, {
-      tokenCount: typeof entry.tokenCount === "number" ? entry.tokenCount : 0,
-      allBlockIds,
-      activeBlockIds
-    });
-  }
-  return result;
-}
-async function recoverFromParentState(client, state, forkMessages, parentId, logger) {
-  const parentState = await loadSessionState(parentId, logger);
-  if (!parentState) {
-    logger.info("fork-transfer: no parent state found, falling back to replay", {
-      parentId
-    });
-    return 0;
-  }
-  const parentMessagesState = parentState.prune?.messages;
-  const parentBlocks = parentMessagesState?.blocksById;
-  if (!parentBlocks) {
-    logger.info("fork-transfer: parent state has no blocks, falling back to replay", {
-      parentId
-    });
-    return 0;
-  }
-  const parentBlockEntries = Object.entries(parentBlocks).filter(
-    ([id, block]) => Number.isInteger(Number.parseInt(id, 10)) && Number.parseInt(id, 10) >= 1 && !!block
-  );
-  if (parentBlockEntries.length === 0) {
-    logger.info("fork-transfer: parent state has no blocks, falling back to replay", {
-      parentId
-    });
-    return 0;
-  }
-  let parentMessages;
-  try {
-    const response = await client.session.messages({ path: { id: parentId } });
-    parentMessages = filterMessages(response?.data || response);
-  } catch (error) {
-    logger.warn("fork-transfer: failed to fetch parent messages, falling back to replay", {
-      parentId,
-      error: error?.message || String(error)
-    });
-    return 0;
-  }
-  const mapping = buildSharedPrefixMapping(parentMessages, forkMessages);
-  if (mapping.size === 0) {
-    logger.info("fork-transfer: no shared prefix detected, falling back to replay", {
-      parentId
-    });
-    return 0;
-  }
-  assignMessageRefs(state, forkMessages);
-  const forkByRawId = state.messageIds.byRawId;
-  const parentByRef = new Map(Object.entries(parentState.messageIds?.byRef ?? {}));
-  const translatedBlocks = /* @__PURE__ */ new Map();
-  let skipped = 0;
-  for (const [blockIdStr, block] of parentBlockEntries) {
-    const blockId = Number.parseInt(blockIdStr, 10);
-    const translated = translateBlock(block, mapping, forkByRawId, parentByRef);
-    if (translated) {
-      translatedBlocks.set(blockId, translated);
-    } else {
-      skipped++;
-    }
-  }
-  if (translatedBlocks.size === 0) {
-    logger.info("fork-transfer: no blocks translatable, falling back to replay", {
-      parentId,
-      parentBlockCount: parentBlockEntries.length,
-      mappingSize: mapping.size
-    });
-    return 0;
-  }
-  const activeCount = Array.from(translatedBlocks.values()).filter((b) => b.active).length;
-  if (activeCount === 0) {
-    logger.info("fork-transfer: no active blocks translatable, falling back to replay", {
-      parentId,
-      recoveredBlocks: translatedBlocks.size,
-      skippedBlocks: skipped,
-      mappingSize: mapping.size
-    });
-    return 0;
-  }
-  const translatedByMessageId = translateByMessageId(
-    parentMessagesState.byMessageId ?? {},
-    mapping,
-    new Set(translatedBlocks.keys())
-  );
-  state.prune.messages = loadPruneMessagesState({
-    byMessageId: Object.fromEntries(translatedByMessageId),
-    blocksById: Object.fromEntries(
-      Array.from(translatedBlocks.entries()).map(
-        ([id, block]) => [String(id), block]
-      )
-    ),
-    activeBlockIds: [],
-    activeByAnchorMessageId: {},
-    nextBlockId: 1,
-    nextRunId: 1,
-    markedForCleanup: []
-  });
-  logger.info("fork-transfer: recovered compression state from parent", {
-    parentId,
-    recoveredBlocks: translatedBlocks.size,
-    activeBlocks: activeCount,
-    skippedBlocks: skipped,
-    mappingSize: mapping.size
-  });
-  return activeCount;
-}
-
 // lib/state/state.ts
 async function updatePerTurnState(state, logger, messages) {
   const lastCompactionTimestamp = findLastCompactionTimestamp(messages);
@@ -4752,22 +4615,16 @@ async function ensureSessionInitialized(client, state, sessionId, logger, messag
   }
   resetSessionState(state);
   state.sessionId = sessionId;
-  const parentId = await getForkParentId(client, sessionId);
-  state.isSubAgent = parentId !== null;
+  const isSubAgent = await isSubAgentSession(client, sessionId);
+  state.isSubAgent = isSubAgent;
   state.lastCompaction = findLastCompactionTimestamp(messages);
   state.currentTurn = countTurns(state, messages);
   state.nudges.turnNudgeAnchors = collectTurnNudgeAnchors(messages);
   const persisted = await loadSessionState(sessionId, logger);
   if (persisted === null) {
     if (config) {
-      let recovered = 0;
-      if (parentId) {
-        recovered = await recoverFromParentState(client, state, messages, parentId, logger);
-      }
-      if (recovered === 0) {
-        recovered = rebuildCompressionState(state, messages, config, logger);
-      }
-      if (recovered > 0) {
+      const rebuilt = rebuildCompressionState(state, messages, config, logger);
+      if (rebuilt > 0) {
         await saveSessionState(state, logger);
       }
     }
@@ -6852,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);
@@ -6872,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) {
@@ -8467,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) {
@@ -9583,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.376.109" : "dev";
+var LOG_VERSION = true ? "1.14.27-pr.377.112" : "dev";
 var LEVEL_RANK = {
   debug: 10,
   info: 20,
@@ -11575,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 ?? "",
@@ -12056,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.376.109" : "dev",
+    version: true ? "1.14.27-pr.377.112" : "dev",
     workspace: ctx.directory,
     logLevel: logger.level,
     debug: config.debug,