@royalcat/opencode-dcp-rc 4.0.0 → 4.0.2

package/dist/index.js

@@ -913,6 +913,8 @@ var VALID_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "compress.protectedTools",
   "compress.protectTags",
   "compress.protectUserMessages",
+  "compress.scrubModelOutput",
+  "compress.scrubMessageIds",
   "strategies",
   "strategies.deduplication",
   "strategies.deduplication.enabled",
@@ -1146,6 +1148,20 @@ function validateConfigTypes(config) {
           actual: typeof compress.protectUserMessages
         });
       }
+      if (compress.scrubModelOutput !== void 0 && typeof compress.scrubModelOutput !== "boolean") {
+        errors.push({
+          key: "compress.scrubModelOutput",
+          expected: "boolean",
+          actual: typeof compress.scrubModelOutput
+        });
+      }
+      if (compress.scrubMessageIds !== void 0 && typeof compress.scrubMessageIds !== "boolean") {
+        errors.push({
+          key: "compress.scrubMessageIds",
+          expected: "boolean",
+          actual: typeof compress.scrubMessageIds
+        });
+      }
       if (typeof compress.iterationNudgeThreshold === "number" && compress.iterationNudgeThreshold < 1) {
         errors.push({
           key: "compress.iterationNudgeThreshold",
@@ -1331,7 +1347,9 @@ var defaultConfig = {
     nudgeForce: "soft",
     protectedTools: [...COMPRESS_DEFAULT_PROTECTED_TOOLS],
     protectTags: false,
-    protectUserMessages: false
+    protectUserMessages: false,
+    scrubModelOutput: true,
+    scrubMessageIds: true
   },
   strategies: {
     deduplication: {
@@ -1456,7 +1474,9 @@ function mergeCompress(base, override) {
     nudgeForce: override.nudgeForce ?? base.nudgeForce,
     protectedTools: [.../* @__PURE__ */ new Set([...base.protectedTools, ...override.protectedTools ?? []])],
     protectTags: override.protectTags ?? base.protectTags,
-    protectUserMessages: override.protectUserMessages ?? base.protectUserMessages
+    protectUserMessages: override.protectUserMessages ?? base.protectUserMessages,
+    scrubModelOutput: override.scrubModelOutput ?? base.scrubModelOutput,
+    scrubMessageIds: override.scrubMessageIds ?? base.scrubMessageIds
   };
 }
 function mergeCommands(base, override) {
@@ -1791,7 +1811,7 @@ You operate in a context-constrained environment. Manage context continuously to
 
 The ONLY tool you have for context management is \`compress\`. It replaces older conversation content with compact technical summaries.
 
-${markers} and \`<dcp-system-reminder>\` tags are environment-injected metadata. Do not output them.
+${markers} and \`<dcp-system-reminder>\` tags are environment-injected metadata. Do not output, quote, or mention them in your replies or reasoning.
 
 THE PHILOSOPHY OF COMPRESS
 \`compress\` transforms conversation content into dense, high-fidelity summaries. This is not cleanup - it is crystallization. Your summary becomes the authoritative record of what transpired.
@@ -1863,6 +1883,8 @@ Avoid the newest active working messages unless it is clearly closed.
 SUMMARY REQUIREMENTS
 Your summary MUST cover all essential details from the selected messages so work can continue.
 If the compressed range includes user messages, preserve user intent exactly. Prefer direct quotes for short user messages to avoid semantic drift.
+
+Never repeat or quote this reminder in your reply.
 </dcp-system-reminder>
 `;
 
@@ -1875,6 +1897,8 @@ If direction has shifted, compress earlier ranges that are now less relevant.
 
 The goal is to filter noise and distill key information so context accumulation stays under control.
 Keep active context uncompressed.
+
+Never repeat or quote this reminder in your reply.
 </dcp-system-reminder>
 `;
 
@@ -1883,6 +1907,8 @@ var ITERATION_NUDGE = `<dcp-system-reminder>
 You've been iterating for a while after the last user message.
 
 If there is a closed portion that is unlikely to be referenced immediately (for example, finished research before implementation), use the compress tool on it now.
+
+Never repeat or quote this reminder in your reply.
 </dcp-system-reminder>
 `;
 
@@ -1895,6 +1921,8 @@ Only use the compress tool after seeing \`<compress triggered manually>\` in the
 Issue exactly ONE compress tool per manual trigger. Do NOT launch multiple compress tools in parallel. Each trigger grants a single compression; after it completes, wait for the next trigger.
 
 After completing a manually triggered context-management action, STOP IMMEDIATELY. Do NOT continue with any task execution. End your response right after the tool use completes and wait for the next user input.
+
+Never repeat this notice in your reply.
 </dcp-system-reminder>
 `;
 var SUBAGENT_SYSTEM_EXTENSION = `<dcp-system-reminder>
@@ -1903,6 +1931,8 @@ You are operating in a subagent environment.
 The initial subagent instruction is imperative and must be followed exactly.
 It is the only user message intentionally not assigned a message ID, and therefore is not eligible for compression.
 All subsequent messages in the session will have IDs.
+
+Never repeat this notice in your reply.
 </dcp-system-reminder>
 `;
 function buildProtectedToolsExtension(protectedTools) {
@@ -2250,6 +2280,102 @@ import { existsSync as existsSync4 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join4 } from "path";
 
+// lib/compress/usage.ts
+function emptyCompressionUsage() {
+  return {
+    calls: 0,
+    providerCalls: 0,
+    estimatedCalls: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    reasoningTokens: 0
+  };
+}
+function toCount(value, fallback = 0) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return fallback;
+  }
+  return Math.round(value);
+}
+function normalizeProviderUsage(raw) {
+  if (!raw || typeof raw !== "object") {
+    return void 0;
+  }
+  const value = raw;
+  const input = value.inputTokens && typeof value.inputTokens === "object" ? value.inputTokens : {};
+  const output2 = value.outputTokens && typeof value.outputTokens === "object" ? value.outputTokens : {};
+  const cacheRead = toCount(input.cacheRead);
+  const cacheWrite = toCount(input.cacheWrite);
+  const uncached = toCount(input.noCache);
+  const inputFromParts = uncached + cacheRead + cacheWrite;
+  const inputTotal = Math.max(toCount(input.total, inputFromParts), inputFromParts);
+  const reasoning = toCount(output2.reasoning);
+  const outputTotal = Math.max(toCount(output2.total, toCount(output2.text) + reasoning), reasoning);
+  if (inputTotal === 0 && outputTotal === 0 && cacheRead === 0 && cacheWrite === 0 && reasoning === 0) {
+    return void 0;
+  }
+  return {
+    inputTokens: inputTotal,
+    outputTokens: outputTotal,
+    cacheReadTokens: cacheRead,
+    cacheWriteTokens: cacheWrite,
+    reasoningTokens: reasoning,
+    source: "provider"
+  };
+}
+function estimatedCompressionUsage(inputTokens, outputTokens) {
+  return {
+    inputTokens: toCount(inputTokens),
+    outputTokens: toCount(outputTokens),
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    reasoningTokens: 0,
+    source: "estimated"
+  };
+}
+function addCompressionUsage(totals, usage) {
+  return {
+    calls: totals.calls + 1,
+    providerCalls: totals.providerCalls + (usage.source === "provider" ? 1 : 0),
+    estimatedCalls: totals.estimatedCalls + (usage.source === "estimated" ? 1 : 0),
+    inputTokens: totals.inputTokens + usage.inputTokens,
+    outputTokens: totals.outputTokens + usage.outputTokens,
+    cacheReadTokens: totals.cacheReadTokens + usage.cacheReadTokens,
+    cacheWriteTokens: totals.cacheWriteTokens + usage.cacheWriteTokens,
+    reasoningTokens: totals.reasoningTokens + usage.reasoningTokens
+  };
+}
+function addCompressionUsageTotals(totals, other) {
+  return {
+    calls: totals.calls + other.calls,
+    providerCalls: totals.providerCalls + other.providerCalls,
+    estimatedCalls: totals.estimatedCalls + other.estimatedCalls,
+    inputTokens: totals.inputTokens + other.inputTokens,
+    outputTokens: totals.outputTokens + other.outputTokens,
+    cacheReadTokens: totals.cacheReadTokens + other.cacheReadTokens,
+    cacheWriteTokens: totals.cacheWriteTokens + other.cacheWriteTokens,
+    reasoningTokens: totals.reasoningTokens + other.reasoningTokens
+  };
+}
+function normalizeCompressionUsageTotals(value) {
+  if (!value || typeof value !== "object") {
+    return emptyCompressionUsage();
+  }
+  const raw = value;
+  return {
+    calls: toCount(raw.calls),
+    providerCalls: toCount(raw.providerCalls),
+    estimatedCalls: toCount(raw.estimatedCalls),
+    inputTokens: toCount(raw.inputTokens),
+    outputTokens: toCount(raw.outputTokens),
+    cacheReadTokens: toCount(raw.cacheReadTokens),
+    cacheWriteTokens: toCount(raw.cacheWriteTokens),
+    reasoningTokens: toCount(raw.reasoningTokens)
+  };
+}
+
 // lib/messages/shape.ts
 function isMessageWithInfo(message) {
   if (!message || typeof message !== "object") {
@@ -2824,7 +2950,8 @@ function emptyPersistedState(manualMode) {
     },
     stats: {
       pruneTokenCounter: 0,
-      totalPruneTokens: 0
+      totalPruneTokens: 0,
+      compressionUsage: emptyCompressionUsage()
     },
     lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
   };
@@ -2845,7 +2972,8 @@ async function loadAllSessionStats(logger) {
     totalTokens: 0,
     totalTools: 0,
     totalMessages: 0,
-    sessionCount: 0
+    sessionCount: 0,
+    compressionUsage: emptyCompressionUsage()
   };
   try {
     if (!existsSync4(STORAGE_DIR)) {
@@ -2858,10 +2986,16 @@ async function loadAllSessionStats(logger) {
         const filePath = join4(STORAGE_DIR, file);
         const content = await fs.readFile(filePath, "utf-8");
         const state = JSON.parse(content);
-        if (state?.stats?.totalPruneTokens && state?.prune) {
-          result.totalTokens += state.stats.totalPruneTokens;
+        const usage = normalizeCompressionUsageTotals(state?.stats?.compressionUsage);
+        const hasUsage = usage.calls > 0;
+        if (state?.prune && (state?.stats?.totalPruneTokens || hasUsage)) {
+          result.totalTokens += state.stats?.totalPruneTokens || 0;
           result.totalTools += state.prune.tools ? Object.keys(state.prune.tools).length : 0;
           result.totalMessages += state.prune.messages?.byMessageId ? Object.keys(state.prune.messages.byMessageId).length : 0;
+          result.compressionUsage = addCompressionUsageTotals(
+            result.compressionUsage,
+            usage
+          );
           result.sessionCount++;
         }
       } catch {
@@ -3302,7 +3436,8 @@ function createSessionState(idFormat = "xml") {
     },
     stats: {
       pruneTokenCounter: 0,
-      totalPruneTokens: 0
+      totalPruneTokens: 0,
+      compressionUsage: emptyCompressionUsage()
     },
     compressionTiming: {
       startsByCallId: /* @__PURE__ */ new Map(),
@@ -3339,7 +3474,8 @@ function resetSessionState(state) {
   };
   state.stats = {
     pruneTokenCounter: 0,
-    totalPruneTokens: 0
+    totalPruneTokens: 0,
+    compressionUsage: emptyCompressionUsage()
   };
   state.toolParameters.clear();
   state.subAgentResultCache.clear();
@@ -3385,7 +3521,8 @@ async function ensureSessionInitialized(client, state, sessionId, logger, messag
   );
   state.stats = {
     pruneTokenCounter: persisted.stats?.pruneTokenCounter || 0,
-    totalPruneTokens: persisted.stats?.totalPruneTokens || 0
+    totalPruneTokens: persisted.stats?.totalPruneTokens || 0,
+    compressionUsage: normalizeCompressionUsageTotals(persisted.stats?.compressionUsage)
   };
   const applied = applyPendingCompressionDurations(state);
   if (applied > 0) {
@@ -4562,6 +4699,22 @@ ${output2}`);
 
 // lib/compress/summary.ts
 var RC_SUMMARY_MARKER = "[[DCP-RC-SUMMARY]]";
+var RC_SUMMARY_MARKER_PREFIX = "[[DCP-RC-SUMMARY";
+function sanitizeCallId(callId) {
+  return callId.replace(/[^A-Za-z0-9_-]/g, "-");
+}
+function buildSummaryMarker(callId) {
+  if (!callId) {
+    return RC_SUMMARY_MARKER;
+  }
+  return `${RC_SUMMARY_MARKER_PREFIX}:${sanitizeCallId(callId)}]]`;
+}
+function hasSummaryMarker(text) {
+  return text.includes(RC_SUMMARY_MARKER_PREFIX);
+}
+function extractSummaryCallId(text) {
+  return text.match(/\[\[DCP-RC-SUMMARY:([A-Za-z0-9_-]+)\]\]/)?.[1];
+}
 function stringify(value) {
   if (typeof value === "string") {
     return value;
@@ -4641,7 +4794,7 @@ var SUMMARY_RULES = `RULES
 - Preserve every high-signal detail: user intent (quote short user messages exactly), decisions, constraints, file paths, function and symbol names, commands run, key findings, errors, verification results, and any subagent task IDs with their scope and completion state.
 - Drop noise: failed attempts that led nowhere, repeated tool output, exploration that produced no durable result.
 - Be dense and precise. Prefer terse technical wording over narrative.`;
-function buildSummaryPrompt(selectors, idFormat = "xml") {
+function buildSummaryPrompt(selectors, idFormat = "xml", callId) {
   const selectorList = selectors.map((segment) => segment.selector);
   const example = selectorList[0] ?? (idFormat === "compact" ? "" : "m0004");
   const body = selectors.map((segment) => {
@@ -4652,7 +4805,7 @@ ${prior.body.trim()}`
     ).join("\n\n");
     return [messageBody, priorBody].filter((part) => part.length > 0).join("\n\n");
   }).join("\n\n");
-  return `${RC_SUMMARY_MARKER}
+  return `${buildSummaryMarker(callId)}
 
 You generate compressed-context entries for a coding session. Summarize ONLY the conversation segments listed below. Do not summarize anything else and do not ask questions.
 
@@ -4759,6 +4912,11 @@ function parseSummarySections(text, expected, idFormat = "xml") {
 }
 
 // lib/compress/rc.ts
+var summaryCallCounter = 0;
+function nextSummaryCallId() {
+  summaryCallCounter += 1;
+  return `c${summaryCallCounter.toString(36)}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
 function validateArgs(args) {
   if (!args || typeof args !== "object") {
     throw new Error("compress requires an object argument with an `ids` array");
@@ -4905,7 +5063,12 @@ function createRcCompressTool(ctx) {
           messages: plan.messages,
           priorSummaries: plan.priorSummaries
         }));
-        const text = await generateSummaries(ctx, sessionID, segments);
+        const { text, usage } = await generateSummaries(ctx, sessionID, segments);
+        ctx.state.stats.compressionUsage = addCompressionUsageTotals(
+          ctx.state.stats.compressionUsage,
+          usage
+        );
+        await saveSessionState(ctx.state, ctx.logger);
         const accepted = await resolveAcceptedSections(
           ctx,
           plans.map((plan) => plan.selector.selector),
@@ -4944,8 +5107,19 @@ function createRcCompressTool(ctx) {
   });
 }
 async function generateSummaries(ctx, sessionID, segments) {
-  const prompt = buildSummaryPrompt(segments, ctx.state.idFormat);
-  let text = await ctx.generate({ sessionID, prompt });
+  let usage = emptyCompressionUsage();
+  const summarize = async (promptSegments) => {
+    const callId = nextSummaryCallId();
+    const prompt = buildSummaryPrompt(promptSegments, ctx.state.idFormat, callId);
+    const result = await ctx.generate({ sessionID, prompt, callId });
+    const text2 = result.text ?? "";
+    usage = addCompressionUsage(
+      usage,
+      result.usage ?? estimatedCompressionUsage(countTokens2(prompt), countTokens2(text2))
+    );
+    return text2;
+  };
+  let text = await summarize(segments);
   for (let retry = 0; retry < 2; retry++) {
     const parsed = parseSummarySections(
       text,
@@ -4962,14 +5136,13 @@ async function generateSummaries(ctx, sessionID, segments) {
     if (retrySegments.length === 0) {
       break;
     }
-    const retryPrompt = buildSummaryPrompt(retrySegments, ctx.state.idFormat);
     try {
-      text += "\n\n" + await ctx.generate({ sessionID, prompt: retryPrompt });
+      text += "\n\n" + await summarize(retrySegments);
     } catch {
       break;
     }
   }
-  return text;
+  return { text, usage };
 }
 async function resolveAcceptedSections(ctx, selectors, text) {
   const parsed = parseSummarySections(text, selectors, ctx.state.idFormat);
@@ -5081,6 +5254,1140 @@ async function resetManualMode(ctx, sessionID) {
   await saveSessionState(ctx.state, ctx.logger);
 }
 
+// lib/v2/scrub.ts
+function outputScrubEnabled(config) {
+  return config.modelOutput || config.messageIds;
+}
+var DCP_PAIRED_TAG_REGEX = /<dcp[^>]*>[\s\S]*?<\/dcp[^>]*>/gi;
+var DCP_UNPAIRED_TAG_REGEX = /<\/?dcp[^>]*>/gi;
+var ID_LINE_REGEX = /^[ \t]*@(?:[1-9]\d*|b[1-9]\d*|blocked)@(?:[ \t]+\[(?:low|medium|high)\])?[ \t]*$/;
+function isIdLine(line) {
+  const value = line.endsWith("\r") ? line.slice(0, -1) : line;
+  return ID_LINE_REGEX.test(value);
+}
+function isIdLinePrefix(text) {
+  let index = 0;
+  while (index < text.length && (text[index] === " " || text[index] === "	")) {
+    index += 1;
+  }
+  if (index === text.length) {
+    return true;
+  }
+  if (text[index] !== "@") {
+    return false;
+  }
+  index += 1;
+  if (index === text.length) {
+    return true;
+  }
+  if (text.startsWith("blocked", index)) {
+    index += 7;
+  } else if (text[index] === "b") {
+    if (index + 1 === text.length) {
+      return true;
+    }
+    if (!/\d/.test(text[index + 1])) {
+      return false;
+    }
+    index += 2;
+    while (index < text.length && /\d/.test(text[index])) {
+      index += 1;
+    }
+  } else if (/[1-9]/.test(text[index])) {
+    index += 1;
+    while (index < text.length && /\d/.test(text[index])) {
+      index += 1;
+    }
+  } else {
+    return false;
+  }
+  if (index === text.length) {
+    return true;
+  }
+  if (text[index] !== "@") {
+    return false;
+  }
+  return isIdPriorityPrefix(text.slice(index + 1));
+}
+function isIdPriorityPrefix(text) {
+  if (text.length === 0 || /^[ \t]+$/.test(text)) {
+    return true;
+  }
+  return /^[ \t]*\[(?:l(?:o(?:w)?)?|m(?:e(?:d(?:i(?:u(?:m)?)?)?)?)?|h(?:i(?:g(?:h)?)?)?)?\]?[ \t]*$/.test(
+    text
+  );
+}
+function stripDcpArtifacts(text, config) {
+  let out = text;
+  if (config.modelOutput) {
+    out = out.replace(DCP_PAIRED_TAG_REGEX, "").replace(DCP_UNPAIRED_TAG_REGEX, "");
+  }
+  if (config.messageIds && out.includes("\n")) {
+    out = out.split("\n").filter((line) => !isIdLine(line)).join("\n");
+  } else if (config.messageIds && isIdLine(out)) {
+    out = "";
+  }
+  return out;
+}
+var TAG_OPEN = "<dcp";
+var TAG_CLOSE = "</dcp";
+var MAX_TAG_LENGTH = 512;
+var MAX_BLOCK_LENGTH = 8192;
+function heldTagSuffix(text) {
+  const max = Math.min(4, text.length);
+  for (let length = max; length >= 1; length -= 1) {
+    const suffix = text.slice(text.length - length).toLowerCase();
+    if (TAG_OPEN.startsWith(suffix) || TAG_CLOSE.startsWith(suffix)) {
+      return text.slice(text.length - length);
+    }
+  }
+  return "";
+}
+var DcpTagStripper = class {
+  mode = "text";
+  carry = "";
+  push(chunk) {
+    this.carry += chunk;
+    let out = "";
+    for (; ; ) {
+      if (this.mode === "text") {
+        const lower = this.carry.toLowerCase();
+        const open = lower.indexOf(TAG_OPEN);
+        const close2 = lower.indexOf(TAG_CLOSE);
+        let index = -1;
+        let next = "open";
+        if (open === -1 && close2 === -1) {
+          index = -1;
+        } else if (open === -1) {
+          index = close2;
+          next = "close";
+        } else if (close2 === -1) {
+          index = open;
+        } else if (open <= close2) {
+          index = open;
+        } else {
+          index = close2;
+          next = "close";
+        }
+        if (index === -1) {
+          const held = heldTagSuffix(this.carry);
+          out += held ? this.carry.slice(0, -held.length) : this.carry;
+          this.carry = held;
+          break;
+        }
+        out += this.carry.slice(0, index);
+        this.carry = this.carry.slice(index);
+        this.mode = next;
+        continue;
+      }
+      if (this.mode === "open" || this.mode === "close") {
+        const end = this.carry.indexOf(">");
+        if (end === -1) {
+          if (this.carry.length > MAX_TAG_LENGTH) {
+            out += this.carry;
+            this.carry = "";
+            this.mode = "text";
+          }
+          break;
+        }
+        const wasOpen = this.mode === "open";
+        this.carry = this.carry.slice(end + 1);
+        this.mode = wasOpen ? "block" : "text";
+        continue;
+      }
+      const close = this.carry.toLowerCase().indexOf(TAG_CLOSE);
+      if (close !== -1) {
+        const end = this.carry.indexOf(">", close);
+        if (end !== -1) {
+          this.carry = this.carry.slice(end + 1);
+          this.mode = "text";
+          continue;
+        }
+      }
+      if (this.carry.length > MAX_BLOCK_LENGTH) {
+        out += this.carry;
+        this.carry = "";
+        this.mode = "text";
+      }
+      break;
+    }
+    return out;
+  }
+  flush() {
+    const out = this.mode === "block" ? this.carry : "";
+    this.carry = "";
+    this.mode = "text";
+    return out;
+  }
+  reset() {
+    this.carry = "";
+    this.mode = "text";
+  }
+};
+var IdLineStripper = class {
+  carry = "";
+  push(chunk) {
+    this.carry += chunk;
+    let out = "";
+    for (; ; ) {
+      const newline = this.carry.indexOf("\n");
+      if (newline === -1) {
+        if (isIdLinePrefix(this.carry)) {
+          break;
+        }
+        out += this.carry;
+        this.carry = "";
+        break;
+      }
+      const line = this.carry.slice(0, newline);
+      this.carry = this.carry.slice(newline + 1);
+      if (!isIdLine(line)) {
+        out += line + "\n";
+      }
+    }
+    return out;
+  }
+  flush() {
+    const held = this.carry;
+    this.carry = "";
+    return isIdLine(held) ? "" : held;
+  }
+  reset() {
+    this.carry = "";
+  }
+};
+var DcpStreamScrubber = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  tags = new DcpTagStripper();
+  ids = new IdLineStripper();
+  push(chunk) {
+    let out = chunk;
+    if (this.config.modelOutput) {
+      out = this.tags.push(out);
+    }
+    if (this.config.messageIds) {
+      out = this.ids.push(out);
+    }
+    return out;
+  }
+  flush() {
+    let out = this.config.modelOutput ? this.tags.flush() : "";
+    if (out && this.config.messageIds) {
+      out = this.ids.push(out);
+    }
+    if (this.config.messageIds) {
+      out += this.ids.flush();
+    }
+    return out;
+  }
+  reset() {
+    this.tags.reset();
+    this.ids.reset();
+  }
+};
+function assignText(target, key, value) {
+  if (target[key] === value) {
+    return false;
+  }
+  target[key] = value;
+  return true;
+}
+var TEXT_PART_TYPES = /* @__PURE__ */ new Set(["text", "output_text", "reasoning_text", "summary_text"]);
+var ProviderPayloadScrubber = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  streams = /* @__PURE__ */ new Map();
+  /** Scrub one streamed provider event. Returns true when it was modified. */
+  scrub(payload) {
+    try {
+      if (!payload || typeof payload !== "object") {
+        return false;
+      }
+      const record = payload;
+      const type = typeof record.type === "string" ? record.type : "";
+      if (Array.isArray(record.choices)) {
+        return this.scrubChat(record, false);
+      }
+      if (Array.isArray(record.candidates)) {
+        return this.scrubGoogle(record, false);
+      }
+      if (type.startsWith("response.")) {
+        return this.scrubResponses(record);
+      }
+      if (type.startsWith("content_block") || type === "message" || type === "message_delta") {
+        return this.scrubAnthropic(record);
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  /** Scrub a complete (non-streamed) JSON payload. */
+  scrubComplete(payload) {
+    try {
+      if (Array.isArray(payload)) {
+        let changed = false;
+        for (const item of payload) {
+          changed = this.scrubComplete(item) || changed;
+        }
+        return changed;
+      }
+      if (!payload || typeof payload !== "object") {
+        return false;
+      }
+      const record = payload;
+      if (Array.isArray(record.choices)) {
+        return this.scrubChat(record, true);
+      }
+      if (Array.isArray(record.candidates)) {
+        return this.scrubGoogle(record, true);
+      }
+      if (record.type === "message" && Array.isArray(record.content)) {
+        return this.scrubAnthropic(record);
+      }
+      if (Array.isArray(record.output)) {
+        return this.scrubItems(record.output);
+      }
+      if (typeof record.output_text === "string") {
+        return assignText(record, "output_text", this.complete(record.output_text));
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  complete(text) {
+    return stripDcpArtifacts(text, this.config);
+  }
+  stream(key) {
+    let scrubber = this.streams.get(key);
+    if (!scrubber) {
+      scrubber = new DcpStreamScrubber(this.config);
+      this.streams.set(key, scrubber);
+    }
+    return scrubber;
+  }
+  textFor(value, key, complete) {
+    if (complete || !key) {
+      return this.complete(value);
+    }
+    return this.stream(key).push(value);
+  }
+  scrubField(target, key, streamKey, complete = false) {
+    if (!target || typeof target !== "object" || typeof target[key] !== "string") {
+      return false;
+    }
+    return assignText(target, key, this.textFor(target[key], streamKey, complete));
+  }
+  scrubParts(parts, key, complete = false) {
+    if (!Array.isArray(parts)) {
+      return false;
+    }
+    let changed = false;
+    parts.forEach((part, index) => {
+      if (!part || typeof part !== "object" || typeof part.text !== "string") {
+        return;
+      }
+      if (part.type && !TEXT_PART_TYPES.has(part.type)) {
+        return;
+      }
+      changed = assignText(
+        part,
+        "text",
+        this.textFor(part.text, key ? `${key}:${index}` : void 0, complete)
+      ) || changed;
+    });
+    return changed;
+  }
+  scrubChat(record, complete) {
+    let changed = false;
+    const choices = Array.isArray(record.choices) ? record.choices : [];
+    choices.forEach((choice, index) => {
+      const delta = choice?.delta;
+      if (delta && typeof delta === "object") {
+        changed = this.scrubField(delta, "content", `chat:content:${index}`) || changed;
+        changed = this.scrubField(delta, "reasoning_content", `chat:reasoning:${index}`) || changed;
+        changed = this.scrubField(delta, "reasoning", `chat:reasoning:${index}`) || changed;
+        changed = this.scrubParts(delta.content, `chat:parts:${index}`) || changed;
+        if (choice?.finish_reason) {
+          this.streams.delete(`chat:content:${index}`);
+          this.streams.delete(`chat:reasoning:${index}`);
+          this.streams.delete(`chat:parts:${index}`);
+        }
+      }
+      const message = choice?.message;
+      if (message && typeof message === "object") {
+        changed = this.scrubField(message, "content", void 0, true) || changed;
+        changed = this.scrubField(message, "reasoning_content", void 0, true) || changed;
+        changed = this.scrubField(message, "reasoning", void 0, true) || changed;
+        changed = this.scrubParts(message.content, void 0, true) || changed;
+      }
+    });
+    return changed;
+  }
+  scrubResponses(record) {
+    const type = record.type;
+    const itemId = record.item_id ?? "";
+    const outputIndex = record.output_index ?? "";
+    const contentIndex = record.content_index ?? "";
+    const key = (family) => `resp:${family}:${itemId}:${outputIndex}:${contentIndex}`;
+    switch (type) {
+      case "response.output_text.delta":
+        return this.scrubField(record, "delta", key("text"));
+      case "response.reasoning_text.delta":
+        return this.scrubField(record, "delta", key("reasoning"));
+      case "response.reasoning_summary_text.delta":
+        return this.scrubField(record, "delta", key("summary"));
+      case "response.output_text.done":
+      case "response.reasoning_text.done":
+      case "response.reasoning_summary_text.done":
+        return this.scrubField(record, "text", void 0, true);
+      case "response.content_part.added":
+      case "response.content_part.done":
+      case "response.reasoning_summary_part.added":
+      case "response.reasoning_summary_part.done":
+        return this.scrubParts(record.part ? [record.part] : void 0, void 0, true);
+      case "response.output_item.added":
+      case "response.output_item.done":
+        return this.scrubItems(record.item ? [record.item] : void 0);
+      case "response.completed": {
+        const changed = this.scrubResponseObject(record.response);
+        this.streams.clear();
+        return changed;
+      }
+      default:
+        return false;
+    }
+  }
+  scrubResponseObject(response) {
+    if (!response || typeof response !== "object") {
+      return false;
+    }
+    let changed = this.scrubItems(response.output);
+    if (typeof response.output_text === "string") {
+      changed = assignText(response, "output_text", this.complete(response.output_text)) || changed;
+    }
+    return changed;
+  }
+  scrubItems(items) {
+    if (!Array.isArray(items)) {
+      return false;
+    }
+    let changed = false;
+    items.forEach((entry) => {
+      if (!entry || typeof entry !== "object") {
+        return;
+      }
+      changed = this.scrubParts(entry.content, void 0, true) || changed;
+      changed = this.scrubParts(entry.summary, void 0, true) || changed;
+    });
+    return changed;
+  }
+  scrubAnthropic(record) {
+    const type = record.type;
+    if (type === "content_block_start") {
+      const block = record.content_block;
+      if (!block || typeof block !== "object") {
+        return false;
+      }
+      if (block.type === "text") {
+        return this.scrubField(block, "text", `anthropic:text:${record.index}`);
+      }
+      if (block.type === "thinking") {
+        return this.scrubField(block, "thinking", `anthropic:thinking:${record.index}`);
+      }
+      return false;
+    }
+    if (type === "content_block_delta") {
+      const delta = record.delta;
+      if (!delta || typeof delta !== "object") {
+        return false;
+      }
+      if (delta.type === "text_delta") {
+        return this.scrubField(delta, "text", `anthropic:text:${record.index}`);
+      }
+      if (delta.type === "thinking_delta") {
+        return this.scrubField(delta, "thinking", `anthropic:thinking:${record.index}`);
+      }
+      return false;
+    }
+    if (type === "content_block_stop") {
+      this.streams.delete(`anthropic:text:${record.index}`);
+      this.streams.delete(`anthropic:thinking:${record.index}`);
+      return false;
+    }
+    if (type === "message" && Array.isArray(record.content)) {
+      let changed = false;
+      record.content.forEach((block) => {
+        if (block?.type === "text") {
+          changed = this.scrubField(block, "text", void 0, true) || changed;
+        } else if (block?.type === "thinking") {
+          changed = this.scrubField(block, "thinking", void 0, true) || changed;
+        }
+      });
+      return changed;
+    }
+    return false;
+  }
+  scrubGoogle(record, complete) {
+    const candidates = Array.isArray(record.candidates) ? record.candidates : [];
+    let changed = false;
+    candidates.forEach((candidate, candidateIndex) => {
+      const parts = candidate?.content?.parts;
+      if (Array.isArray(parts)) {
+        parts.forEach((part, partIndex) => {
+          if (!part || typeof part !== "object" || typeof part.text !== "string") {
+            return;
+          }
+          changed = assignText(
+            part,
+            "text",
+            this.textFor(
+              part.text,
+              complete ? void 0 : `google:${candidateIndex}:${partIndex}`,
+              complete
+            )
+          ) || changed;
+        });
+      }
+      if (candidate?.finishReason) {
+        this.streams.clear();
+      }
+    });
+    return changed;
+  }
+};
+function findBoundary(buffer) {
+  const lf = buffer.indexOf("\n\n");
+  const crlf = buffer.indexOf("\r\n\r\n");
+  if (lf === -1 && crlf === -1) {
+    return null;
+  }
+  if (crlf !== -1 && (lf === -1 || crlf <= lf)) {
+    return { start: crlf, end: crlf + 4, separator: "\r\n\r\n" };
+  }
+  return { start: lf, end: lf + 2, separator: "\n\n" };
+}
+function scrubJsonBody(body, config, scrubber) {
+  const trimmed = body.trim();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+    return body;
+  }
+  try {
+    const payload = JSON.parse(trimmed);
+    const worker = scrubber ?? new ProviderPayloadScrubber(config);
+    if (worker.scrubComplete(payload)) {
+      return JSON.stringify(payload);
+    }
+  } catch {
+  }
+  return body;
+}
+function createSseScrubTransform(config) {
+  const TransformStreamImpl = globalThis.TransformStream;
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  const scrubber = new ProviderPayloadScrubber(config);
+  let buffer = "";
+  const processBlock = (block) => {
+    try {
+      const lines = block.split("\n");
+      const dataLines = [];
+      lines.forEach((raw, index) => {
+        const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+        const match = /^data:( ?)(.*)$/.exec(line);
+        if (match) {
+          dataLines.push({ index, space: match[1] ?? "", value: match[2] ?? "" });
+        }
+      });
+      if (dataLines.length === 0) {
+        return block;
+      }
+      const data = dataLines.map((entry) => entry.value).join("\n");
+      const payloadText = data.trim();
+      if (!payloadText || payloadText === "[DONE]") {
+        return block;
+      }
+      let payload;
+      try {
+        payload = JSON.parse(data);
+      } catch {
+        return block;
+      }
+      if (!scrubber.scrub(payload)) {
+        return block;
+      }
+      const first = dataLines[0];
+      const drop = new Set(dataLines.slice(1).map((entry) => entry.index));
+      const rebuilt = [];
+      lines.forEach((raw, index) => {
+        if (drop.has(index)) {
+          return;
+        }
+        if (index === first.index) {
+          rebuilt.push(`data:${first.space}${JSON.stringify(payload)}`);
+          return;
+        }
+        rebuilt.push(raw);
+      });
+      return rebuilt.join("\n");
+    } catch {
+      return block;
+    }
+  };
+  return new TransformStreamImpl({
+    transform(chunk, controller) {
+      let enqueued = false;
+      try {
+        buffer += decoder.decode(chunk, { stream: true });
+        let boundary = findBoundary(buffer);
+        while (boundary) {
+          const block = buffer.slice(0, boundary.start);
+          buffer = buffer.slice(boundary.end);
+          controller.enqueue(encoder.encode(processBlock(block) + boundary.separator));
+          enqueued = true;
+          boundary = findBoundary(buffer);
+        }
+      } catch {
+        if (!enqueued) {
+          try {
+            controller.enqueue(chunk);
+          } catch {
+          }
+        }
+      }
+    },
+    flush(controller) {
+      try {
+        buffer += decoder.decode();
+        if (buffer) {
+          controller.enqueue(encoder.encode(processBlock(buffer)));
+        }
+        buffer = "";
+      } catch {
+      }
+    }
+  });
+}
+function createJsonScrubTransform(config) {
+  const TransformStreamImpl = globalThis.TransformStream;
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  const scrubber = new ProviderPayloadScrubber(config);
+  let buffer = "";
+  return new TransformStreamImpl({
+    transform(chunk, _controller) {
+      try {
+        buffer += decoder.decode(chunk, { stream: true });
+      } catch {
+      }
+    },
+    flush(controller) {
+      try {
+        buffer += decoder.decode();
+        controller.enqueue(encoder.encode(scrubJsonBody(buffer, config, scrubber)));
+        buffer = "";
+      } catch {
+        try {
+          controller.enqueue(encoder.encode(buffer));
+          buffer = "";
+        } catch {
+        }
+      }
+    }
+  });
+}
+function wrapScrubResponse(response, config) {
+  try {
+    if (!response || typeof response !== "object" || !response.body) {
+      return response;
+    }
+    const headers = new Headers(response.headers);
+    const contentType = headers.get("content-type") ?? "";
+    let body;
+    if (/text\/event-stream/i.test(contentType)) {
+      body = response.body.pipeThrough(createSseScrubTransform(config));
+    } else if (/json/i.test(contentType)) {
+      body = response.body.pipeThrough(createJsonScrubTransform(config));
+    } else {
+      return response;
+    }
+    headers.delete("content-length");
+    return new Response(body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  } catch {
+    return response;
+  }
+}
+async function installResponseScrubHook(ctx, config, logger) {
+  if (!outputScrubEnabled(config)) {
+    return;
+  }
+  const session2 = ctx?.session;
+  if (!session2 || typeof session2.hook !== "function") {
+    return;
+  }
+  try {
+    await session2.hook("http.response", async (event) => {
+      try {
+        const response = event?.response;
+        if (!response || typeof response !== "object") {
+          return;
+        }
+        const wrapped = wrapScrubResponse(response, config);
+        if (wrapped !== response) {
+          event.response = wrapped;
+        }
+      } catch (error) {
+        logger.debug("DCP output scrub failed", { error: error?.message });
+      }
+    });
+    logger.debug("DCP output scrub hook installed");
+  } catch (error) {
+    logger.warn("DCP output scrub hook registration failed", { error: error?.message });
+  }
+}
+function isTextDelta(part) {
+  if (part?.type === "text-delta") {
+    return { family: "text-delta", field: deltaField(part) };
+  }
+  if (part?.type === "reasoning-delta" || part?.type === "reasoning") {
+    return { family: "reasoning-delta", field: deltaField(part) };
+  }
+  return void 0;
+}
+function deltaField(part) {
+  if (typeof part.text === "string") {
+    return "text";
+  }
+  if (typeof part.delta === "string") {
+    return "delta";
+  }
+  return "textDelta";
+}
+var AisdkPartScrubber = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  streams = /* @__PURE__ */ new Map();
+  process(part) {
+    try {
+      if (!part || typeof part !== "object") {
+        return [part];
+      }
+      const delta = isTextDelta(part);
+      if (delta) {
+        const key = `${delta.family}:${part.id ?? ""}`;
+        return [{ ...part, [delta.field]: this.stream(key).push(part[delta.field]) }];
+      }
+      if (part.type === "text-start" || part.type === "reasoning-start") {
+        const family = part.type === "text-start" ? "text-delta" : "reasoning-delta";
+        this.streams.delete(`${family}:${part.id ?? ""}`);
+        return [part];
+      }
+      if (part.type === "text-end" || part.type === "reasoning-end") {
+        const family = part.type === "text-end" ? "text-delta" : "reasoning-delta";
+        const out = [];
+        const leftover = this.take(`${family}:${part.id ?? ""}`);
+        if (leftover) {
+          out.push({ type: family, id: part.id, text: leftover });
+        }
+        const field = deltaField(part);
+        if (typeof part[field] === "string") {
+          out.push({ ...part, [field]: stripDcpArtifacts(part[field], this.config) });
+        } else {
+          out.push(part);
+        }
+        return out;
+      }
+      if (part.type === "finish") {
+        return [...this.flushStreams(), part];
+      }
+      return [part];
+    } catch {
+      return [part];
+    }
+  }
+  stream(key) {
+    let scrubber = this.streams.get(key);
+    if (!scrubber) {
+      scrubber = new DcpStreamScrubber(this.config);
+      this.streams.set(key, scrubber);
+    }
+    return scrubber;
+  }
+  take(key) {
+    const scrubber = this.streams.get(key);
+    if (!scrubber) {
+      return "";
+    }
+    this.streams.delete(key);
+    return scrubber.flush();
+  }
+  flushStreams() {
+    const out = [];
+    for (const [key, scrubber] of this.streams) {
+      const leftover = scrubber.flush();
+      if (!leftover) {
+        continue;
+      }
+      const separator = key.indexOf(":");
+      out.push({
+        type: separator === -1 ? "text-delta" : key.slice(0, separator),
+        id: separator === -1 ? "" : key.slice(separator + 1),
+        text: leftover
+      });
+    }
+    this.streams.clear();
+    return out;
+  }
+};
+function stripAisdkResultContent(result, config) {
+  if (!result || !Array.isArray(result.content)) {
+    return;
+  }
+  for (const part of result.content) {
+    if (!part || typeof part !== "object") {
+      continue;
+    }
+    if ((part.type === "text" || part.type === "reasoning") && typeof part.text === "string") {
+      part.text = stripDcpArtifacts(part.text, config);
+    }
+  }
+}
+
+// lib/v2/usage.ts
+function createCompressionUsageTracker() {
+  const pending = /* @__PURE__ */ new Map();
+  const entry = (callId) => {
+    let current = pending.get(callId);
+    if (!current) {
+      current = {};
+      pending.set(callId, current);
+    }
+    return current;
+  };
+  return {
+    recordProvider(callId, usage) {
+      entry(callId).provider = usage;
+    },
+    recordEstimatedInput(callId, inputTokens) {
+      if (Number.isFinite(inputTokens) && inputTokens > 0) {
+        entry(callId).estimatedInput = Math.round(inputTokens);
+      }
+    },
+    resolve(callId, outputText) {
+      const current = pending.get(callId);
+      if (!current) {
+        return void 0;
+      }
+      if (current.provider) {
+        return current.provider;
+      }
+      if (current.estimatedInput === void 0) {
+        return void 0;
+      }
+      return estimatedCompressionUsage(current.estimatedInput, countTokens2(outputText));
+    },
+    discard(callId) {
+      pending.delete(callId);
+    }
+  };
+}
+function findSummaryCallId(options) {
+  const texts = [];
+  collectTexts(options?.prompt, texts);
+  for (const text of texts) {
+    const callId = extractSummaryCallId(text);
+    if (callId) {
+      return callId;
+    }
+  }
+  return void 0;
+}
+function collectTexts(value, out, depth = 0) {
+  if (depth > 8 || out.length > 200) {
+    return;
+  }
+  if (typeof value === "string") {
+    out.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectTexts(item, out, depth + 1);
+    }
+    return;
+  }
+  if (value && typeof value === "object") {
+    const record = value;
+    if (typeof record.text === "string") {
+      out.push(record.text);
+    }
+    if (typeof record.content === "string") {
+      out.push(record.content);
+    } else if (Array.isArray(record.content)) {
+      collectTexts(record.content, out, depth + 1);
+    }
+  }
+}
+function wrapLanguageModel(model, tracker, logger, scrub) {
+  return new Proxy(model, {
+    get(target, property, receiver) {
+      if (property === "doStream") {
+        return (options) => trackedStream(target, options, tracker, logger, scrub);
+      }
+      if (property === "doGenerate") {
+        return (options) => trackedGenerate(target, options, tracker, logger, scrub);
+      }
+      return Reflect.get(target, property, receiver);
+    }
+  });
+}
+async function trackedStream(target, options, tracker, logger, scrub) {
+  const result = await target.doStream(options);
+  const callId = findSummaryCallId(options);
+  const scrubEnabled = !!scrub && outputScrubEnabled(scrub);
+  logger.debug("Compression usage stream call", { callId: callId ?? null });
+  const TransformStreamImpl = globalThis.TransformStream;
+  if (!callId && !scrubEnabled || typeof result?.stream?.pipeThrough !== "function") {
+    return result;
+  }
+  if (typeof TransformStreamImpl !== "function") {
+    return result;
+  }
+  const partScrubber = scrubEnabled ? new AisdkPartScrubber(scrub) : void 0;
+  let recorded = false;
+  const transform = new TransformStreamImpl({
+    transform(part, controller) {
+      try {
+        if (callId && !recorded && part?.type === "finish" && part.usage) {
+          const usage = normalizeProviderUsage(part.usage);
+          if (usage) {
+            recorded = true;
+            tracker.recordProvider(callId, usage);
+          }
+        }
+      } catch {
+      }
+      const parts = partScrubber ? partScrubber.process(part) : [part];
+      for (const next of parts) {
+        controller.enqueue(next);
+      }
+    }
+  });
+  return { ...result, stream: result.stream.pipeThrough(transform) };
+}
+async function trackedGenerate(target, options, tracker, logger, scrub) {
+  const result = await target.doGenerate(options);
+  const callId = findSummaryCallId(options);
+  logger.debug("Compression usage generate call", { callId: callId ?? null });
+  if (scrub && outputScrubEnabled(scrub)) {
+    try {
+      stripAisdkResultContent(result, scrub);
+    } catch {
+    }
+  }
+  if (!callId) {
+    return result;
+  }
+  const usage = normalizeProviderUsage(result?.usage);
+  if (usage) {
+    tracker.recordProvider(callId, usage);
+  }
+  return result;
+}
+async function installCompressionUsageHook(ctx, tracker, logger, scrub) {
+  const aisdk = ctx?.aisdk;
+  if (!aisdk || typeof aisdk.hook !== "function") {
+    logger.debug("aisdk hook unavailable; compression usage will be estimated");
+    return;
+  }
+  try {
+    await aisdk.hook("language", (event) => {
+      try {
+        const isModel = (candidate) => !!candidate && typeof candidate.doStream === "function";
+        logger.debug("Compression usage hook event", {
+          modelID: event?.model?.modelID ?? event?.model?.id ?? null,
+          hasLanguage: isModel(event?.language),
+          hasFactory: typeof event?.sdk?.languageModel === "function"
+        });
+        let model = isModel(event?.language) ? event.language : void 0;
+        if (!model && typeof event?.sdk?.languageModel === "function") {
+          model = event.sdk.languageModel(
+            event?.model?.modelID ?? event?.model?.id
+          );
+        }
+        if (!isModel(model)) {
+          return;
+        }
+        event.language = wrapLanguageModel(model, tracker, logger, scrub);
+      } catch (error) {
+        logger.debug("Compression usage hook could not wrap language model", {
+          error: error?.message
+        });
+      }
+    });
+    logger.debug("Compression usage hook installed");
+  } catch (error) {
+    logger.warn("Compression usage hook registration failed", {
+      error: error?.message
+    });
+  }
+}
+function emptyUsageAccumulator() {
+  return {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    reasoning: 0,
+    exclusiveInput: false
+  };
+}
+function usageField(key) {
+  switch (key) {
+    case "input_tokens":
+    case "prompt_tokens":
+    case "promptTokenCount":
+      return "input";
+    case "output_tokens":
+    case "completion_tokens":
+    case "candidatesTokenCount":
+      return "output";
+    case "cache_read_input_tokens":
+    case "cache_creation_input_tokens":
+    case "cached_tokens":
+    case "cachedContentTokenCount":
+      return key === "cache_creation_input_tokens" ? "cacheWrite" : "cacheRead";
+    case "reasoning_tokens":
+    case "thoughtsTokenCount":
+      return "reasoning";
+    default:
+      return void 0;
+  }
+}
+function scanUsage(value, acc, depth) {
+  if (depth > 8 || !value || typeof value !== "object") {
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      scanUsage(item, acc, depth + 1);
+    }
+    return;
+  }
+  for (const [key, raw] of Object.entries(value)) {
+    const field = usageField(key);
+    if (field && typeof raw === "number" && Number.isFinite(raw)) {
+      acc[field] = Math.max(acc[field], raw);
+      if (key === "cache_read_input_tokens" || key === "cache_creation_input_tokens") {
+        acc.exclusiveInput = true;
+      }
+      continue;
+    }
+    if (raw && typeof raw === "object") {
+      scanUsage(raw, acc, depth + 1);
+    }
+  }
+}
+function usageFromAccumulator(acc) {
+  const input = acc.exclusiveInput ? acc.input + acc.cacheRead + acc.cacheWrite : acc.input;
+  const usage = {
+    inputTokens: Math.max(0, Math.round(input)),
+    outputTokens: Math.max(0, Math.round(acc.output)),
+    cacheReadTokens: Math.max(0, Math.round(acc.cacheRead)),
+    cacheWriteTokens: Math.max(0, Math.round(acc.cacheWrite)),
+    reasoningTokens: Math.max(0, Math.round(acc.reasoning)),
+    source: "provider"
+  };
+  const total = usage.inputTokens + usage.outputTokens + usage.cacheReadTokens + usage.cacheWriteTokens + usage.reasoningTokens;
+  return total > 0 ? usage : void 0;
+}
+function parseProviderUsageFromBody(body) {
+  const acc = emptyUsageAccumulator();
+  const trimmed = body.trim();
+  let parsedJson = false;
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      scanUsage(JSON.parse(trimmed), acc, 0);
+      parsedJson = true;
+    } catch {
+    }
+  }
+  if (!parsedJson) {
+    for (const line of body.split(/\r?\n/)) {
+      const match = /^\s*data:\s*(.*)$/.exec(line);
+      if (!match) {
+        continue;
+      }
+      const payload = match[1].trim();
+      if (!payload || payload === "[DONE]") {
+        continue;
+      }
+      try {
+        scanUsage(JSON.parse(payload), acc, 0);
+      } catch {
+      }
+    }
+  }
+  return usageFromAccumulator(acc);
+}
+async function installHttpUsageHook(ctx, tracker, logger) {
+  const session2 = ctx?.session;
+  if (!session2 || typeof session2.hook !== "function") {
+    return;
+  }
+  try {
+    await session2.hook("http.response", async (event) => {
+      if (event?.kind !== "generate") {
+        return;
+      }
+      try {
+        const request = event.request;
+        const response = event.response;
+        if (!request || typeof request.clone !== "function") {
+          return;
+        }
+        const callId = extractSummaryCallId(await request.clone().text());
+        if (!callId) {
+          return;
+        }
+        if (!response || typeof response.clone !== "function") {
+          return;
+        }
+        const usage = parseProviderUsageFromBody(await response.clone().text());
+        if (usage) {
+          tracker.recordProvider(callId, usage);
+          logger.debug("Compression usage captured from http response", {
+            callId,
+            inputTokens: usage.inputTokens,
+            outputTokens: usage.outputTokens
+          });
+        }
+      } catch (error) {
+        logger.debug("Compression usage http capture failed", {
+          error: error?.message
+        });
+      }
+    });
+    logger.debug("Compression usage http hook installed");
+  } catch (error) {
+    logger.warn("Compression usage http hook registration failed", {
+      error: error?.message
+    });
+  }
+}
+
 // lib/prompts/index.ts
 function renderSystemPrompt(prompts, protectedToolsExtension, manual, subagent) {
   const extensions = [];
@@ -5285,8 +6592,8 @@ async function handleContextCommand(ctx) {
 // lib/messages/utils.ts
 import { createHash } from "crypto";
 var SUMMARY_ID_HASH_LENGTH = 16;
-var DCP_PAIRED_TAG_REGEX = /<dcp[^>]*>[\s\S]*?<\/dcp[^>]*>/gi;
-var DCP_UNPAIRED_TAG_REGEX = /<\/?dcp[^>]*>/gi;
+var DCP_PAIRED_TAG_REGEX2 = /<dcp[^>]*>[\s\S]*?<\/dcp[^>]*>/gi;
+var DCP_UNPAIRED_TAG_REGEX2 = /<\/?dcp[^>]*>/gi;
 var INJECTED_MESSAGE_ID_SUFFIX_REGEX = /(?<=\n)<dcp-message-id[^>]*>m\d+<\/dcp-message-id>\s*$/;
 var HALLUCINATED_PARAMETER_SUFFIX_REGEX = /(?<=\n)m\d+<\/parameter>\s*$/;
 var COMPACT_TAG_REGEX = /@(?:[1-9]\d*|b[1-9]\d*|blocked)@(?:[ \t]+\[(?:low|medium|high)\])?/gi;
@@ -5410,7 +6717,7 @@ function buildToolIdList(state, messages) {
 var stripHallucinationsFromString = (text, format2 = "xml") => {
   if (format2 === "compact") text = text.replace(COMPACT_TAG_REGEX, "");
   const withoutKnownSuffixes = text.replace(INJECTED_MESSAGE_ID_SUFFIX_REGEX, "").replace(HALLUCINATED_PARAMETER_SUFFIX_REGEX, "");
-  return withoutKnownSuffixes.replace(DCP_PAIRED_TAG_REGEX, "").replace(DCP_UNPAIRED_TAG_REGEX, "");
+  return withoutKnownSuffixes.replace(DCP_PAIRED_TAG_REGEX2, "").replace(DCP_UNPAIRED_TAG_REGEX2, "");
 };
 var stripHallucinations = (messages, format2 = "xml") => {
   for (const message of messages) {
@@ -6592,7 +7899,7 @@ async function handleRecompressCommand(ctx) {
 }
 
 // lib/commands/stats.ts
-function formatStatsMessage(sessionTokens, sessionSummaryTokens, sessionTools, sessionMessages, sessionDurationMs, allTime) {
+function formatStatsMessage(sessionTokens, sessionSummaryTokens, sessionTools, sessionMessages, sessionDurationMs, sessionUsage, allTime) {
   const lines = [];
   lines.push("\u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E");
   lines.push("\u2502                    DCP Statistics                         \u2502");
@@ -6607,6 +7914,16 @@ function formatStatsMessage(sessionTokens, sessionSummaryTokens, sessionTools, s
   lines.push(`  Time:             ${formatCompressionTime(sessionDurationMs)}`);
   lines.push(`  Messages:         ${sessionMessages}`);
   lines.push(`  Tools:            ${sessionTools}`);
+  lines.push(
+    `  Summary requests: ${sessionUsage.calls} (${sessionUsage.providerCalls} provider, ${sessionUsage.estimatedCalls} estimated)`
+  );
+  lines.push(
+    `  Request in|out:   ~${formatTokenCount(sessionUsage.inputTokens)} | ~${formatTokenCount(sessionUsage.outputTokens)}`
+  );
+  lines.push(
+    `  Request cache:    ~${formatTokenCount(sessionUsage.cacheReadTokens)} read | ~${formatTokenCount(sessionUsage.cacheWriteTokens)} write`
+  );
+  lines.push(`  Request reason:   ~${formatTokenCount(sessionUsage.reasoningTokens)}`);
   lines.push("");
   lines.push("All-time:");
   lines.push("\u2500".repeat(60));
@@ -6614,6 +7931,9 @@ function formatStatsMessage(sessionTokens, sessionSummaryTokens, sessionTools, s
   lines.push(`  Tools pruned:     ${allTime.totalTools}`);
   lines.push(`  Messages pruned:  ${allTime.totalMessages}`);
   lines.push(`  Sessions:         ${allTime.sessionCount}`);
+  lines.push(
+    `  Summary requests: ${allTime.compressionUsage.calls} (~${formatTokenCount(allTime.compressionUsage.inputTokens)} in | ~${formatTokenCount(allTime.compressionUsage.outputTokens)} out)`
+  );
   return lines.join("\n");
 }
 function formatCompressionRatio(inputTokens, outputTokens) {
@@ -6653,6 +7973,7 @@ async function handleStatsCommand(ctx) {
     report2.sessionTools,
     report2.sessionMessages,
     report2.sessionDurationMs,
+    report2.sessionCompressionUsage,
     report2.allTime
   );
   const params = getCurrentParams(state, messages, logger);
@@ -6663,9 +7984,11 @@ async function handleStatsCommand(ctx) {
     sessionTools: report2.sessionTools,
     sessionMessages: report2.sessionMessages,
     sessionDurationMs: report2.sessionDurationMs,
+    sessionCompressionUsage: report2.sessionCompressionUsage,
     allTimeTokens: report2.allTime.totalTokens,
     allTimeTools: report2.allTime.totalTools,
-    allTimeMessages: report2.allTime.totalMessages
+    allTimeMessages: report2.allTime.totalMessages,
+    allTimeCompressionUsage: report2.allTime.compressionUsage
   });
 }
 async function buildStatsReport(state, logger) {
@@ -6687,6 +8010,7 @@ async function buildStatsReport(state, logger) {
     }
   }
   const sessionTools = prunedToolIds.size;
+  const sessionCompressionUsage = normalizeCompressionUsageTotals(state.stats.compressionUsage);
   let sessionMessages = 0;
   for (const entry of state.prune.messages.byMessageId.values()) {
     if (entry.activeBlockIds.length > 0) {
@@ -6700,6 +8024,7 @@ async function buildStatsReport(state, logger) {
     sessionTools,
     sessionMessages,
     sessionDurationMs,
+    sessionCompressionUsage,
     allTime
   };
 }
@@ -7235,17 +8560,29 @@ function project(native, entries, session2) {
 import { tool as tool2 } from "@opencode-ai/plugin";
 var z = tool2.schema;
 var session = z.object({ sessionID: z.string() });
+var compressionUsage = z.object({
+  calls: z.number(),
+  providerCalls: z.number(),
+  estimatedCalls: z.number(),
+  inputTokens: z.number(),
+  outputTokens: z.number(),
+  cacheReadTokens: z.number(),
+  cacheWriteTokens: z.number(),
+  reasoningTokens: z.number()
+});
 var stats = z.object({
   sessionTokens: z.number(),
   sessionSummaryTokens: z.number(),
   sessionDurationMs: z.number(),
   sessionTools: z.number(),
   sessionMessages: z.number(),
+  sessionCompressionUsage: compressionUsage,
   allTime: z.object({
     totalTokens: z.number(),
     totalTools: z.number(),
     totalMessages: z.number(),
-    sessionCount: z.number()
+    sessionCount: z.number(),
+    compressionUsage
   })
 });
 var context = z.object({
@@ -7300,6 +8637,14 @@ async function setup(ctx) {
     return;
   }
   const logger = new Logger(config.debug);
+  const usageTracker = createCompressionUsageTracker();
+  const scrub = {
+    modelOutput: config.compress.scrubModelOutput,
+    messageIds: config.compress.scrubMessageIds
+  };
+  await installCompressionUsageHook(ctx, usageTracker, logger, scrub);
+  await installHttpUsageHook(ctx, usageTracker, logger);
+  await installResponseScrubHook(ctx, scrub, logger);
   const prompts = new PromptStore(
     logger,
     ctx.location.directory,
@@ -7465,7 +8810,7 @@ async function setup(ctx) {
   await ctx.session.hook("generate", (event) => {
     const own = event.messages.filter(
       (message) => Array.isArray(message.content) && message.content.some(
-        (part) => part?.type === "text" && typeof part.text === "string" && part.text.includes(RC_SUMMARY_MARKER)
+        (part) => part?.type === "text" && typeof part.text === "string" && hasSummaryMarker(part.text)
       )
     );
     if (own.length === 0) {
@@ -7475,6 +8820,25 @@ async function setup(ctx) {
     for (const name of Object.keys(event.tools ?? {})) {
       delete event.tools[name];
     }
+    const callId = own.flatMap(
+      (message) => Array.isArray(message.content) ? message.content : []
+    ).filter((part) => part?.type === "text" && typeof part.text === "string").map((part) => extractSummaryCallId(part.text)).find((id) => !!id);
+    if (callId) {
+      const texts = [];
+      for (const part of event.system ?? []) {
+        if (typeof part?.text === "string") {
+          texts.push(part.text);
+        }
+      }
+      for (const message of own) {
+        for (const part of message.content ?? []) {
+          if (part?.type === "text" && typeof part.text === "string") {
+            texts.push(part.text);
+          }
+        }
+      }
+      usageTracker.recordEstimatedInput(callId, countTokens2(texts.join("\n")));
+    }
   });
   if (config.compress.permission !== "deny") {
     const define = (state) => {
@@ -7485,8 +8849,19 @@ async function setup(ctx) {
         config,
         prompts,
         generate: async (input) => {
-          const result = await ctx.session.generate(input);
-          return result?.text ?? "";
+          try {
+            const result = await ctx.session.generate({
+              sessionID: input.sessionID,
+              prompt: input.prompt
+            });
+            const text = result?.text ?? "";
+            const usage = input.callId ? usageTracker.resolve(input.callId, text) : void 0;
+            return { text, usage };
+          } finally {
+            if (input.callId) {
+              usageTracker.discard(input.callId);
+            }
+          }
         }
       };
       return createRcCompressTool(context2);