@royalcat/opencode-dcp-rc 4.0.1 → 4.0.3

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",
@@ -1324,14 +1340,16 @@ var defaultConfig = {
     permission: "allow",
     showCompression: false,
     summaryBuffer: true,
-    maxContextLimit: 1e5,
-    minContextLimit: 5e4,
+    maxContextLimit: "80%",
+    minContextLimit: "20%",
     nudgeFrequency: 5,
     iterationNudgeThreshold: 15,
     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) {
@@ -5224,6 +5254,817 @@ 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();
@@ -5299,35 +6140,37 @@ function collectTexts(value, out, depth = 0) {
     }
   }
 }
-function wrapLanguageModel(model, tracker, logger) {
+function wrapLanguageModel(model, tracker, logger, scrub) {
   return new Proxy(model, {
     get(target, property, receiver) {
       if (property === "doStream") {
-        return (options) => trackedStream(target, options, tracker, logger);
+        return (options) => trackedStream(target, options, tracker, logger, scrub);
       }
       if (property === "doGenerate") {
-        return (options) => trackedGenerate(target, options, tracker, logger);
+        return (options) => trackedGenerate(target, options, tracker, logger, scrub);
       }
       return Reflect.get(target, property, receiver);
     }
   });
 }
-async function trackedStream(target, options, tracker, logger) {
+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 || typeof result?.stream?.pipeThrough !== "function") {
+  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 (!recorded && part?.type === "finish" && part.usage) {
+        if (callId && !recorded && part?.type === "finish" && part.usage) {
           const usage = normalizeProviderUsage(part.usage);
           if (usage) {
             recorded = true;
@@ -5336,15 +6179,24 @@ async function trackedStream(target, options, tracker, logger) {
         }
       } catch {
       }
-      controller.enqueue(part);
+      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) {
+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;
   }
@@ -5354,7 +6206,7 @@ async function trackedGenerate(target, options, tracker, logger) {
   }
   return result;
 }
-async function installCompressionUsageHook(ctx, tracker, logger) {
+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");
@@ -5378,7 +6230,7 @@ async function installCompressionUsageHook(ctx, tracker, logger) {
         if (!isModel(model)) {
           return;
         }
-        event.language = wrapLanguageModel(model, tracker, logger);
+        event.language = wrapLanguageModel(model, tracker, logger, scrub);
       } catch (error) {
         logger.debug("Compression usage hook could not wrap language model", {
           error: error?.message
@@ -5740,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;
@@ -5865,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) {
@@ -7786,8 +8638,13 @@ async function setup(ctx) {
   }
   const logger = new Logger(config.debug);
   const usageTracker = createCompressionUsageTracker();
-  await installCompressionUsageHook(ctx, usageTracker, logger);
+  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,