From 73a34ba5e6dbbfa9976c380becccb3e2ef263d77 Mon Sep 17 00:00:00 2001
From: ework-agent
Date: Sun, 4 Oct 2026 11:41:50 +0800
Subject: [PATCH 01/16] fix: strip refs-only residue adjacent to render tags in
the echo filter (#2023)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
The filter only treated a body of EXACTLY ONE bare ref as tag content
(#1720 REF_LIKE), so refs-only text adjacent to render-tag structure was
released as prose: orphan ref+close units, multi-ref/range pair bodies,
EOF tails after an opening, and chunk-boundary splits all leaked mNNNNN
remnants to the client reasoning stream.
- Generalize single-ref to refs-run (REFS_RUN/REFS_ONLY: lists, en/em-dash
ranges, comma-separated range lists) at every decision point: PAIRED
body, swallow inner decision, over-budget release, flush EOF branch,
PARTIAL_TAIL hold (incl. run+tag-fragment composite and bare-m/partial
ref prefixes so any split position holds toward the unit).
- New orphan unit: a refs run directly against an UNMATCHED close is dead
markup and is stripped with the close. Whole-text applies it only to
depth-zero closes (orphanCloseSpans greedy pairing); streaming only when
no opening is live — so a ref cited inside a prose-wearing pair survives
(#1720) in both modes.
- The [\w>] lookbehind extends across chunk boundaries via lastEmitted:
word-like tokens (xm01233) and tag-terminator residue (#644 over-cap
drop) are never orphan-stripped or held.
Tests: tests/issue2023-refs-residue.test.ts pins every shape whole-text AND
streaming (char-by-char equivalence + explicit chunk splits), plus #1720
protection pins, #644 lossless pins, and documented residual pins.
---
src/loop/tag-echo-filter.ts | 143 ++++++++++++++++++++++++---
tests/issue2023-refs-residue.test.ts | 113 +++++++++++++++++++++
2 files changed, 240 insertions(+), 16 deletions(-)
create mode 100644 tests/issue2023-refs-residue.test.ts
diff --git a/src/loop/tag-echo-filter.ts b/src/loop/tag-echo-filter.ts
index c9220d50c7..8da06849a4 100644
--- a/src/loop/tag-echo-filter.ts
+++ b/src/loop/tag-echo-filter.ts
@@ -76,9 +76,10 @@ const NAME = ACP_NAME_ALT;
// and the #644 release rules. Close-side tails keep their {0,32} bound — that
// one is load-bearing (#644: an unbounded close-side tail ate real content
// after a malformed close).
-// A render tag wraps exactly one bare ref: the kernel emits mNNNNN and nothing else between the tags (#1720). Content that
-// is not a ref is prose wearing tags — the tags go, the content stays. No g
+// is not refs-only is prose wearing tags — the tags go, the content stays
+// (#1720/#2023). No g
// flag: createTagEchoFilter drives it with exec() on a sliding buffer. It is
// flag-free by construction — case folding lives inside ACP_NAME_ALT's letter
// classes (#1731) — so every .source reconstruction below preserves behavior
@@ -86,14 +87,46 @@ const NAME = ACP_NAME_ALT;
// Attrs are OPTIONAL: the kernel always emits them, but models imitate the
// bare form mNNNNN (#1881) — whole-span strip must cover it or
// the interior ref leaks as residue after the lone tags go.
-const PAIRED = new RegExp("\x3c" + NAME + "(?:\\s[^<>]*)?>(\\s*m\\d{4,}\\s*)\x3c\\/" + NAME + ">");
-const REF_LIKE = /^\s*m\d{4,}\s*$/;
+const REF_TOKEN = "m\\d{4,}";
+// One kernel ref, or a run of them joined by whitespace / dash / comma — the
+// shapes the compress machinery prints (single ref, mNNNNN–mMMMMM ranges,
+// comma-separated range lists) that models imitate inside or beside render
+// tags (#2023). A bare run is never prose: prose cites ONE ref among words,
+// never a sequence of them.
+const REFS_RUN = REF_TOKEN + "(?:\\s*[\\u2013\\u2014,\\-]?\\s*" + REF_TOKEN + ")*";
+// Whole string is a refs run (optionally padded): tag content, not prose.
+const REFS_ONLY = new RegExp("^\\s*" + REFS_RUN + "\\s*$");
+// Body of a paired render tag: refs-only or empty (#1720/#2023). Anything
+// else is prose wearing tags — PAIRED must not match it.
+const PAIRED_BODY = "\\s*(?:" + REFS_RUN + ")?\\s*";
+const PAIRED = new RegExp("\x3c" + NAME + "(?:\\s[^<>]*)?>(" + PAIRED_BODY + ")" + "\x3c\\/" + NAME + ">");
+// An orphan refs run sitting directly against a close tag: the open half was
+// consumed by another branch (or never came), and stripping the close alone
+// leaves the refs behind as residue (#2023). The unit — run plus close — is
+// dead markup; the lookbehind keeps word-like tokens (xm01233) and refs
+// adjacent to a tag terminator out of it — a run right after \x3e belongs to
+// tag structure (an over-cap-dropped opening, #644) and stays lossless.
+// Streaming: consulted only when no opening is live (the swallowing state
+// owns paired closes, #1720). Whole-text: applied to UNMATCHED closes only
+// (see orphanCloseSpans) so a ref cited inside a prose-wearing pair survives.
+const ORPHAN_REF_CLOSE = new RegExp("(?])\\s*" + REFS_RUN + "\\s*\x3c\\/" + NAME + "(?=[\\s>])[^<>]{0,32}>");
+// Same unit anchored to the END of a string: the refs run immediately
+// preceding an unmatched close (whole-text orphan pass).
+const ORPHAN_RUN_BEFORE = new RegExp("(?])\\s*" + REFS_RUN + "\\s*$");
const LONE_OPEN = new RegExp("\x3c" + NAME + "(?:\\s[^<>]*)?>");
const LONE_CLOSE = new RegExp("\x3c\\/" + NAME + "(?=[\\s>])[^<>]{0,32}>");
// A suffix of the buffer that could still grow into a render tag: either an
-// unterminated \x3c … opening (attrs so far, no \x3e yet) or a short
-// ambiguous prefix like \x3c, \x3ca, \x3c/ac, \x3cacip, …
-const PARTIAL_TAIL = new RegExp("(\x3c" + NAME + "\\s[^<>]*|\x3c\\/" + NAME + "(?:\\s[^<>]{0,32})?|\x3c\\/?[aAcCpPiI]*)$");
+// unterminated \x3c … opening (attrs so far, no \x3e yet), a short
+// ambiguous prefix like \x3c, \x3ca, \x3c/ac, \x3cacip, …, a trailing refs
+// run whose close may arrive in the next chunk (#2023 orphan unit) — alone or
+// already followed by the tag fragment that opens the split close — or a
+// partial ref prefix (a bare m or m + 1-3 digits) that may complete across
+// the boundary.
+// Refs right after a tag terminator (\x3e) are NOT held: they belong to tag
+// structure (over-cap-dropped openings, #644) and stay lossless. Held on the
+// small cap so a split unit can be stripped whole; a lone trailing ref with
+// no tag context is released at EOF, prose-safe.
+const PARTIAL_TAIL = new RegExp("(\x3c" + NAME + "\\s[^<>]*|\x3c\\/" + NAME + "(?:\\s[^<>]{0,32})?|\x3c\\/?[aAcCpPiI]*|(?])\\s*" + REFS_RUN + "\\s*\x3c[^<>]*|(?])\\s*" + REFS_RUN + "|(?])m\\d{0,3})$");
// An unterminated render-tag opening at the end of a string: \x3c plus
// attrs, no \x3e — a truncated imitation, never prose (triggers use \x3cacp_).
const TRUNC_OPEN = new RegExp("\x3c" + NAME + "\\s[^<>]*$");
@@ -146,6 +179,34 @@ function looseCloseEnd(s: string): number {
return span === null ? -1 : span.end;
}
+/** Spans of every close tag in s with NO unmatched open before it (#2023).
+ * Opens and closes are paired greedily in document order (echoed tags are
+ * flat; kernel tags are well-nested), and only depth-zero closes count as
+ * orphans — a close inside any pair protects the refs run it terminates
+ * (#1720 prose-wearing pairs keep their content). */
+function orphanCloseSpans(s: string): { start: number; end: number }[] {
+ const events: { idx: number; open: boolean }[] = [];
+ const reO = new RegExp(LONE_OPEN.source, "g");
+ const reC = new RegExp(LONE_CLOSE.source, "g");
+ let m: RegExpExecArray | null;
+ while ((m = reO.exec(s)) !== null) events.push({ idx: m.index, open: true });
+ while ((m = reC.exec(s)) !== null) events.push({ idx: m.index, open: false });
+ events.sort((a, b) => a.idx - b.idx);
+ const spans: { start: number; end: number }[] = [];
+ let depth = 0;
+ for (const ev of events) {
+ if (ev.open) {
+ depth++;
+ } else if (depth === 0) {
+ const cm = new RegExp(LONE_CLOSE.source).exec(s.slice(ev.idx));
+ if (cm) spans.push({ start: ev.idx, end: ev.idx + cm[0].length });
+ } else {
+ depth--;
+ }
+ }
+ return spans;
+}
+
/** The span of one wrapped-turn imitation in `s`: where it starts, and the span
* that has to go — its head plus, when no loose close follows, the rest of the
* text (the model's whole turn lives inside it, tool call included). Returns
@@ -242,8 +303,23 @@ export function stripAcpTags(text: string): string {
if (wrapped === null) break;
out = out.slice(0, wrapped.start) + out.slice(wrapped.end);
}
+ out = out.replace(new RegExp(PAIRED.source, "g"), "");
+ // #2023: a refs run sitting directly against an UNMATCHED close is residue
+ // (its open was consumed elsewhere or never came) and goes with the close.
+ // A close inside any pair — even a prose-wearing one — belongs to that
+ // pair's content and stays (#1720), so only depth-zero closes qualify.
+ // Delete right-to-left so earlier offsets stay valid.
+ {
+ const spans = orphanCloseSpans(out);
+ for (let i = spans.length - 1; i >= 0; i--) {
+ const sp = spans[i];
+ const pre = out.slice(0, sp.start);
+ const rm = ORPHAN_RUN_BEFORE.exec(pre);
+ if (!rm) continue;
+ out = out.slice(0, pre.length - rm[0].length) + out.slice(sp.end);
+ }
+ }
out = out
- .replace(new RegExp(PAIRED.source, "g"), "")
.replace(new RegExp(LONE_OPEN.source, "g"), "")
.replace(new RegExp(LONE_CLOSE.source, "g"), "")
.replace(new RegExp(TRUNC_OPEN.source), "")
@@ -525,6 +601,11 @@ export function createBiliArtifactFilter(onDrop?: (snippet: string) => void): Ta
export function createTagEchoFilter(onDrop?: (snippet: string) => void): TagEchoFilter {
let held = "";
+ /** Last character actually emitted ("" at stream start). Extends the
+ * [\w>] orphan-unit lookbehind ACROSS chunk boundaries: a refs run
+ * arriving at the buffer head was preceded by whatever was emitted
+ * before, and a \x3e there marks tag-structure residue (#644). */
+ let lastEmitted = "";
let swallowUntilClose = false;
let swallowed = "";
/** Which budget the current swallow answers to (SWALLOW_CAP or
@@ -550,6 +631,14 @@ export function createTagEchoFilter(onDrop?: (snippet: string) => void): TagEcho
onDrop(snippet);
}
};
+ /** Character immediately before the refs run of an orphan-unit match —
+ * within the buffer, or the last emitted char when the run sits at the
+ * buffer head (chunk boundary). */
+ const charBeforeRun = (mm: RegExpExecArray, s: string): string => {
+ const lead = mm[0].match(/^\s*/)?.[0].length ?? 0;
+ const pos = mm.index + lead;
+ return pos === 0 ? lastEmitted : s[pos - 1];
+ };
const process = (input: string): string => {
let buf = input;
let out = "";
@@ -558,12 +647,13 @@ export function createTagEchoFilter(onDrop?: (snippet: string) => void): TagEcho
const combined = swallowed + buf;
const span = looseCloseSpan(combined);
if (span !== null) {
- // Only a ref-shaped body is tag content (#1720): a prose
- // body between paired tags is released and just the close
- // goes. An attested imitation (swallowReleases=false)
- // discards whatever the body is.
+ // Only a refs-only body is tag content (#1720/#2023): a
+ // prose body between paired tags is released and just the
+ // close goes — a ref cited inside such a body survives.
+ // An attested imitation (swallowReleases=false) discards
+ // whatever the body is.
const inner = combined.slice(0, span.start);
- if (REF_LIKE.test(inner) || !swallowReleases) {
+ if (REFS_ONLY.test(inner) || !swallowReleases) {
drop(combined.slice(0, span.end));
} else {
out += inner;
@@ -577,6 +667,13 @@ export function createTagEchoFilter(onDrop?: (snippet: string) => void): TagEcho
if (combined.length > swallowLimit) {
swallowed = "";
if (swallowReleases) {
+ // A refs-only tail past the #644 budget is an imitated
+ // marker list, not prose — discard it. Mixed tails are
+ // content and still release losslessly.
+ if (REFS_ONLY.test(combined)) {
+ drop(combined);
+ return out;
+ }
swallowUntilClose = false;
buf = combined;
continue;
@@ -592,8 +689,16 @@ export function createTagEchoFilter(onDrop?: (snippet: string) => void): TagEcho
const p = PAIRED.exec(buf);
const o = LONE_OPEN.exec(buf);
const c = LONE_CLOSE.exec(buf);
+ // Orphan unit (#2023): only reached when no opening is live — a
+ // close inside a swallow belongs to that pair's content (#1720).
+ // The lookbehind class extends across the chunk boundary: a run at
+ // the buffer head preceded by an emitted word char is word-like
+ // (xm01233), and one preceded by \x3e is tag-structure residue
+ // (#644) — neither is an orphan.
+ let r = ORPHAN_REF_CLOSE.exec(buf);
+ if (r !== null && /[\w>]/.test(charBeforeRun(r, buf))) r = null;
let m: RegExpExecArray | null = null;
- for (const cand of [p, o, c]) {
+ for (const cand of [p, o, c, r]) {
if (cand && (m === null || cand.index < m.index)) m = cand;
}
// An opening whose attribute list never terminates (see
@@ -683,6 +788,7 @@ export function createTagEchoFilter(onDrop?: (snippet: string) => void): TagEcho
const chunk = held + delta;
held = "";
const r = process(chunk);
+ if (r.length > 0) lastEmitted = r[r.length - 1];
outputChars += r.length;
return r;
},
@@ -702,8 +808,9 @@ export function createTagEchoFilter(onDrop?: (snippet: string) => void): TagEcho
result = "";
} else if (wasSwallowing) {
// A BARE opening (#1881): prose may genuinely wear one, so an
- // over-budget-or-EOF tail is content unless it is exactly a
- // ref; only a truncated open/close tail is dead markup.
+ // over-budget-or-EOF tail is content unless it is refs-only —
+ // an imitated marker list (#2023), not a citation; only a
+ // truncated open/close tail is dead markup.
const t = new RegExp(TRUNC_OPEN.source).exec(rest);
if (t) {
drop(t[0]);
@@ -713,6 +820,9 @@ export function createTagEchoFilter(onDrop?: (snippet: string) => void): TagEcho
if (tc) {
drop(tc[0]);
result = rest.slice(0, tc.index);
+ } else if (REFS_ONLY.test(rest)) {
+ drop(rest);
+ result = "";
} else {
result = rest;
}
@@ -732,6 +842,7 @@ export function createTagEchoFilter(onDrop?: (snippet: string) => void): TagEcho
}
}
}
+ if (result.length > 0) lastEmitted = result[result.length - 1];
outputChars += result.length;
return result;
},
diff --git a/tests/issue2023-refs-residue.test.ts b/tests/issue2023-refs-residue.test.ts
new file mode 100644
index 0000000000..a5eb22f74d
--- /dev/null
+++ b/tests/issue2023-refs-residue.test.ts
@@ -0,0 +1,113 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { stripAcpTags, createTagEchoFilter } from "../src/loop/tag-echo-filter.ts";
+
+const LT = "\x3c";
+const OPEN = `${LT}acp tokens="2" type="text">`;
+const BARE_OPEN = `${LT}acp>`;
+const CLOSE = `${LT}/acp>`;
+
+function streamAll(input: string): string {
+ const f = createTagEchoFilter();
+ let out = "";
+ for (const ch of input) out += f.push(ch);
+ out += f.flush();
+ return out;
+}
+
+function streamChunks(chunks: string[]): string {
+ const f = createTagEchoFilter();
+ let out = "";
+ for (const c of chunks) out += f.push(c);
+ out += f.flush();
+ return out;
+}
+
+test("whole-text: orphan refs run + unmatched close is stripped as a unit (#2023)", () => {
+ assert.equal(stripAcpTags(`done folding m01233${CLOSE} next`), `done folding next`);
+ assert.equal(stripAcpTags(`m01233${CLOSE}`), "");
+});
+
+test("whole-text: orphan unit survives case drift, typo close, junk close", () => {
+ assert.equal(stripAcpTags(`m01233${LT}/ACP>`), "");
+ assert.equal(stripAcpTags(`m01233${LT}/cap>`), "");
+ assert.equal(stripAcpTags(`m01233${LT}/acp junk>`), "");
+});
+
+test("whole-text: multi-ref and range bodies are tag content (refs-only PAIRED)", () => {
+ assert.equal(stripAcpTags(`${OPEN}m01233 m01234${CLOSE}`), "");
+ assert.equal(stripAcpTags(`${BARE_OPEN}m01217\u2013m01233${CLOSE}`), "");
+ assert.equal(stripAcpTags(`${BARE_OPEN}m01217\u2014m01233${CLOSE}`), "");
+ assert.equal(stripAcpTags(`${BARE_OPEN}m01217-m01233${CLOSE}`), "");
+ assert.equal(stripAcpTags(`${OPEN}m01095\u2013m01215, m01217\u2013m01233${CLOSE}`), "");
+});
+
+test("whole-text: #1720 prose-wearing pairs keep their content, cited refs included", () => {
+ assert.equal(stripAcpTags(`${OPEN}x m01233${CLOSE}`), "x m01233");
+ assert.equal(stripAcpTags(`${BARE_OPEN}x m01233${CLOSE}`), "x m01233");
+ assert.equal(stripAcpTags(`see m01233 for details`), `see m01233 for details`);
+ assert.equal(stripAcpTags(`xm01233${CLOSE}`), "xm01233");
+ assert.equal(stripAcpTags(`m01233${LT}/kem>`), `m01233${LT}/kem>`);
+});
+
+test("whole-text: run before an empty pair is a documented residual (leaks as before)", () => {
+ assert.equal(stripAcpTags(`m01233${BARE_OPEN}${CLOSE}`), "m01233");
+});
+
+test("whole-text: a ref right after a tag terminator stays lossless (#644 over-cap residue)", () => {
+ assert.equal(stripAcpTags(`>m01233${CLOSE}`), ">m01233");
+ assert.equal(stripAcpTags(`a>m01233${CLOSE}`), "a>m01233");
+});
+
+test("whole-text: multiple unmatched closes — only the ref-adjacent one forms a unit", () => {
+ assert.equal(stripAcpTags(`m01233${CLOSE} extra${CLOSE}`), " extra");
+});
+
+test("streaming char-by-char matches whole-text on every #2023 shape", () => {
+ const cases = [
+ `done folding m01233${CLOSE} next`,
+ `m01233${CLOSE}`,
+ `m01233${LT}/ACP>`,
+ `m01233${LT}/cap>`,
+ `${OPEN}m01233 m01234${CLOSE}`,
+ `${BARE_OPEN}m01217\u2013m01233${CLOSE}`,
+ `${OPEN}x m01233${CLOSE}`,
+ `${BARE_OPEN}x m01233${CLOSE}`,
+ `see m01233 for details`,
+ `xm01233${CLOSE}`,
+ `m01233${BARE_OPEN}${CLOSE}`,
+ `m01233${CLOSE} extra${CLOSE}`,
+ `>m01233${CLOSE}`,
+ `a>m01233${CLOSE}`,
+ ];
+ for (const input of cases) {
+ assert.equal(streamAll(input), stripAcpTags(input), `streaming diverged for: ${JSON.stringify(input)}`);
+ }
+});
+
+test("streaming: chunk boundary splits do not leak the orphan unit", () => {
+ assert.equal(streamChunks(["folded m01233", `${CLOSE} tail`]), "folded tail");
+ assert.equal(streamChunks(["m012", `33${CLOSE}`]), "");
+ assert.equal(streamChunks(["m0123", `3${CLOSE}`]), "");
+});
+
+test("streaming: EOF after an opening — refs-only tails drop, mixed tails release", () => {
+ assert.equal(streamChunks([BARE_OPEN, "m01233"]), "");
+ assert.equal(streamChunks([`${LT}acp tokens="2" type="text">`, "m01233"]), "");
+ assert.equal(streamChunks([`${LT}acp tokens="2" type="text">`, "m01233 m01234"]), "");
+ assert.equal(streamChunks([BARE_OPEN, "see m01233"]), "see m01233");
+ assert.equal(streamChunks(["note m01233"]), "note m01233");
+});
+
+test("streaming: swallow inner decision — refs-only body drops, prose body releases", () => {
+ assert.equal(streamChunks([`${LT}acp tokens="2" type="text">`, `m01233 m01234${CLOSE}`]), "");
+ assert.equal(streamChunks([`${LT}acp tokens="2" type="text">`, `x m01233${CLOSE}`]), "x m01233");
+});
+
+test("streaming: over-budget refs-only tail discards, over-budget mixed tail releases", () => {
+ const refsTail = Array.from({ length: 25 }, (_, i) => `m${String(10001 + i).padStart(5, "0")} `).join("");
+ assert.ok(refsTail.length > 80);
+ assert.equal(streamChunks([BARE_OPEN, refsTail]), "");
+ const mixedTail = `see ${refsTail}`;
+ assert.equal(streamChunks([BARE_OPEN, mixedTail]), mixedTail);
+});
From 27ba88af4dc33d220a9284c99934161b291ff781 Mon Sep 17 00:00:00 2001
From: ework-agent
Date: Sun, 4 Oct 2026 11:56:55 +0800
Subject: [PATCH 02/16] fix: classify released refs-run tails as prose in
degenerate-turn accounting (#2023)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Review finding on the #2025 head: the three new PARTIAL_TAIL refs-run
alternatives flow into mayStartRenderTag, which isOrphanMarkupText used as
its render-tag probe. A released tail shaped like a refs run (a genuine
citation held to EOF) was therefore counted as dead markup residue, so a
tool-call-free turn whose only visible output was a bare ref citation read
as degenerate and burned the one-shot retry (#732/#821) — and could end in
the #870 in-band error instead of delivering the citation.
isOrphanMarkupText now probes with TAG_PARTIAL_TAIL (PARTIAL_TAIL's
\x3c-prefixed alternatives only): byte-identical classification to pre-#2023
for every tag-shaped tail, refs-run tails flip to prose. Tagged echoes need
no help from this path — their drop already sets sawStrippedEcho upstream.
mayStartRenderTag stays broad (fast-path gating must keep engaging on
refs-run tails so split units are still stripped).
Pinned: unit classification + a full openai-lane pipe test proving a
bare-citation answer reaches the client with zero refetches; both fail on
the previous head. #870 unclosed-tag retry pin stays green.
---
src/loop/tag-echo-filter.ts | 8 +++++-
...-1760-cjk-single-line-visible-turn.test.ts | 28 +++++++++++++++++++
2 files changed, 35 insertions(+), 1 deletion(-)
diff --git a/src/loop/tag-echo-filter.ts b/src/loop/tag-echo-filter.ts
index 8da06849a4..14cbf73956 100644
--- a/src/loop/tag-echo-filter.ts
+++ b/src/loop/tag-echo-filter.ts
@@ -501,8 +501,14 @@ export function mayStartBiliInternal(s: string): boolean {
// literal marker line, truncated internal-artifact open/header) is dead to the
// host like an empty turn, so degenerate-turn detection counts it as residue;
// plain prose (CJK leads included) is visible output, not residue.
+// #2023 review: the probe is PARTIAL_TAIL's \x3c -prefixed alternatives ONLY.
+// Its refs-run alternatives match genuine citations released at EOF; counting
+// those as residue made every bare-citation answer read as degenerate and fire
+// the one-shot retry (#732/#821) on a healthy turn. Tagged echoes need no help
+// here: their drop already sets sawStrippedEcho upstream.
+const TAG_PARTIAL_TAIL = new RegExp("(\x3c" + NAME + "\\s[^<>]*|\x3c\\/" + NAME + "(?:\\s[^<>]{0,32})?|\x3c\\/?[aAcCpPiI]*)$");
export function isOrphanMarkupText(s: string): boolean {
- return mayStartRenderTag(s) || containsMarkerLineText(s) || mayStartBiliInternal(s);
+ return RENDER_TAG_DETECT.test(s) || TAG_PARTIAL_TAIL.test(s) || containsMarkerLineText(s) || mayStartBiliInternal(s);
}
function tailHoldLen(s: string): number {
diff --git a/tests/fix-1760-cjk-single-line-visible-turn.test.ts b/tests/fix-1760-cjk-single-line-visible-turn.test.ts
index 9c5787b567..a8cd22590b 100644
--- a/tests/fix-1760-cjk-single-line-visible-turn.test.ts
+++ b/tests/fix-1760-cjk-single-line-visible-turn.test.ts
@@ -92,6 +92,12 @@ test("isOrphanMarkupText classifies a released tail by its bytes, not its origin
assert.equal(isOrphanMarkupText("OK"), false);
// A lone astral icon held to terminal is preserved content the client sees.
assert.equal(isOrphanMarkupText("📦"), false);
+ // A refs run released at EOF is a genuine citation — visible prose
+ // (#2023 review: counting it as residue fired the one-shot retry on
+ // bare-citation answers).
+ assert.equal(isOrphanMarkupText("m01233"), false, "a lone ref citation is prose");
+ assert.equal(isOrphanMarkupText(" m01217\u2013m01233"), false, "a ref range is prose");
+ assert.equal(isOrphanMarkupText("m01095\u2013m01215, m01217\u2013m01233"), false, "a comma range list is prose");
// Markup-shaped tails stay residue (the #870 contract).
assert.equal(isOrphanMarkupText("\x3ca"), true, "partial render-tag head");
assert.equal(isOrphanMarkupText('\x3cacp tokens="1" type="text"'), true, "unclosed render-tag opening");
@@ -177,6 +183,28 @@ test("#870 kept: a tail shaped like an unclosed render tag still retries once",
assert.ok(!text.includes("[ACP] stream error"), "one retry suffices — no in-band error");
});
+test("#2023 review: a turn whose only answer is a bare ref citation does not retry", async () => {
+ const out: string[] = [];
+ let calls = 0;
+ const refetch = () => {
+ calls += 1;
+ return Promise.resolve(streamOf(proseTurn("unwanted")));
+ };
+ await pipePluginChatWithStrip(
+ streamOf([chatChunk({ role: "assistant" }), ...[..."m01233"].map((c) => chatChunk({ content: c })), chatStop(), DONE]),
+ makeRes(out),
+ "openai",
+ makeSession(),
+ undefined,
+ refetch,
+ );
+ const text = out.join("");
+ assert.equal(calls, 0, "a released refs-run tail is visible output — no nudge re-issue");
+ assert.ok(!text.includes("[ACP] stream error"), "no in-band degenerate error");
+ assert.equal(textDeltas(text), "m01233", "the citation reaches the client");
+ assert.equal((text.match(/\[DONE\]/g) ?? []).length, 1, "exactly one terminator");
+});
+
test("multi-line CJK answer in one chunk stays clean (never affected)", async () => {
const out: string[] = [];
let calls = 0;
From 61957c525503fced5a477b30859a121a19bfbd4b Mon Sep 17 00:00:00 2001
From: Yurii Yukhymenko
Date: Sun, 4 Oct 2026 12:12:17 +0300
Subject: [PATCH 03/16] fix: drop model-emitted ACP tool-call emissions from
the prose channel
Production sessions (ses_efe4cfcbdffe) show the model re-emitting
internal ACP artifacts as assistant prose: mangled render tags
() and the absorb tool call written as chat-template text
(...mNNNN......
). Both leaked into client-visible history.
- stripAcpTags: MANGLED_OPEN pattern (name=... form) + fast-path gate
- whole-field emission discriminator: field opens with a tool-call
open and carries the absorb ref+summary signature (unique to absorb)
- armed only when the shipped request carries the [ACP absorb]
instruction (proxy: wireBody; plugin: per-request marker)
- echo guard: an emission verbatim echoing a fragment from the
request is preserved, not dropped (raw + canonical JSON-escaped
containment)
- streaming tcHold (pending/committed) across chunk boundaries;
orphan close-tail drop (defensive)
- drop/requestText threaded through all adapters, plugin pipes,
JSON rewriters and field strippers
- tests/absorb-emission.test.ts: 31 tests over 13 regression
categories incl. user-requested verbatim emission survival
- nameless-toolcall-observability: session stub gains metadata {}
(Session.metadata is required)
---
src/loop/adapter-anthropic.ts | 10 +-
src/loop/adapter-google.ts | 10 +-
src/loop/adapter-openai.ts | 10 +-
src/loop/adapter-responses.ts | 28 +-
src/loop/index.ts | 3 +-
src/loop/tag-echo-filter.ts | 276 ++++++++++--
src/plugin.ts | 91 ++--
src/server.ts | 21 +-
src/stream-google.ts | 12 +-
src/stream-openai.ts | 12 +-
src/stream-responses.ts | 11 +-
src/stream.ts | 11 +-
tests/absorb-emission.test.ts | 402 ++++++++++++++++++
tests/nameless-toolcall-observability.test.ts | 1 +
14 files changed, 815 insertions(+), 83 deletions(-)
create mode 100644 tests/absorb-emission.test.ts
diff --git a/src/loop/adapter-anthropic.ts b/src/loop/adapter-anthropic.ts
index 3cc73f6bb5..0188464eab 100644
--- a/src/loop/adapter-anthropic.ts
+++ b/src/loop/adapter-anthropic.ts
@@ -152,7 +152,7 @@ function buildTextDeltaEvent(index: number, text: string): Buffer {
);
}
-export function createAnthropicAdapter(requestBody: Record, originalSystem?: AnthropicRequestBody["system"], notes?: string[], errorShape: "protocol" | "completion" = "protocol", cacheMarks?: Map): CompressLoopAdapter {
+export function createAnthropicAdapter(requestBody: Record, originalSystem?: AnthropicRequestBody["system"], notes?: string[], errorShape: "protocol" | "completion" = "protocol", cacheMarks?: Map, absorbArmed?: boolean): CompressLoopAdapter {
const model = (requestBody.model as string) ?? undefined;
let messageId: string | undefined;
let clientIndex = 0;
@@ -284,11 +284,17 @@ export function createAnthropicAdapter(requestBody: Record, ori
// per prose field — text and thinking deltas interleave across one
// stream, so a shared instance would hold a tag-shaped tail against
// the wrong field's bytes.
+ // m00885: whole-field absorb-emission drop is armed only when this
+ // request instructed the model about absorb (server-side provenance).
+ const absorbArmedLocal = absorbArmed === true;
+ // m00885: the shipped request text lets the filter keep an
+ // emission-shaped span the user asked to be output verbatim.
+ const requestText = JSON.stringify(requestBody);
const makeFilter = () => composeStreamFilters(
composeStreamFilters(
createTagEchoFilter((snippet) => {
loggerLog("warn", `[tag-echo] stripped model-emitted render tag: ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
- }),
+ }, absorbArmedLocal, requestText),
createMarkerLineFilter((snippet) => {
loggerLog("warn", `[marker-echo] stripped model-emitted ACP confirmation marker: ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
}),
diff --git a/src/loop/adapter-google.ts b/src/loop/adapter-google.ts
index bc10dbb358..b481ed7ae7 100644
--- a/src/loop/adapter-google.ts
+++ b/src/loop/adapter-google.ts
@@ -294,11 +294,19 @@ export function createGoogleAdapter(
// text from signature and bricks the session. Thought echoes are
// forwarded verbatim; cosmetic leaks inside a thought pane are
// accepted (#1960 verdict).
+ // m00885: whole-field absorb-emission drop is armed only when this
+ // request instructed the model about absorb (server-side provenance
+ // — the absorb section exists on this request's wire iff absorbName
+ // was resolved for it).
+ const absorbArmedLocal = absorbName !== undefined;
+ // m00885: the shipped request text lets the filter keep an
+ // emission-shaped span the user asked to be output verbatim.
+ const requestText = JSON.stringify(requestBody);
const makeFilter = () => composeStreamFilters(
composeStreamFilters(
createTagEchoFilter((snippet) => {
loggerLog("warn", `[tag-echo] stripped model-emitted render tag: ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
- }),
+ }, absorbArmedLocal, requestText),
createMarkerLineFilter((snippet) => {
loggerLog("warn", `[marker-echo] stripped model-emitted ACP confirmation marker: ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
}),
diff --git a/src/loop/adapter-openai.ts b/src/loop/adapter-openai.ts
index 3ffb7e0b75..2f5d849c2f 100644
--- a/src/loop/adapter-openai.ts
+++ b/src/loop/adapter-openai.ts
@@ -249,11 +249,19 @@ export function createOpenaiAdapter(requestBody: Record, client
// shared instance would hold a tag-shaped tail against the wrong
// field's bytes (residue leak or content loss). Tool-call
// arguments never enter any filter (#1039 invariant).
+ // m00885: whole-field absorb-emission drop is armed only when this
+ // request instructed the model about absorb (server-side provenance
+ // — the absorb section exists on this request's wire iff absorbName
+ // was resolved for it).
+ const absorbArmedLocal = absorbName !== undefined;
+ // m00885: the shipped request text lets the filter keep an
+ // emission-shaped span the user asked to be output verbatim.
+ const requestText = JSON.stringify(requestBody);
const makeFieldFilter = () => composeStreamFilters(
composeStreamFilters(
createTagEchoFilter((snippet) => {
loggerLog("warn", `[tag-echo] stripped model-emitted render tag: ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
- }),
+ }, absorbArmedLocal, requestText),
createMarkerLineFilter((snippet) => {
loggerLog("warn", `[marker-echo] stripped model-emitted ACP confirmation marker: ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
}),
diff --git a/src/loop/adapter-responses.ts b/src/loop/adapter-responses.ts
index 666953a08d..6a1d9a1f8d 100644
--- a/src/loop/adapter-responses.ts
+++ b/src/loop/adapter-responses.ts
@@ -5,7 +5,7 @@ import { coreToResponsesWithToolImages as coreToResponses, patchResponsesInputWi
import { buildVisibilityMarker } from "./core.js";
import { hoistTrappedToolItems } from "../tool-pair-order.js";
import { hashId, strippedResponseIdWarning } from "../util.js";
-import { composeStreamFilters, createBiliArtifactFilter, createMarkerLineFilter, createTagEchoFilter, stripResponsesText, containsBiliInternalText, containsMarkerLineText, containsRenderTagText, ACP_NAME_ALT } from "./tag-echo-filter.js";
+import { composeStreamFilters, createBiliArtifactFilter, createMarkerLineFilter, createTagEchoFilter, stripResponsesText, containsBiliInternalText, containsMarkerLineText, containsRenderTagText, containsToolCallEmissionText, ACP_NAME_ALT } from "./tag-echo-filter.js";
import { degenerateTurnWarning } from "../degenerate-turn.js";
import { log as loggerLog } from "../logger.js";
import { extractResponsesTextTriggers, PROXY_TOOL_NAMES } from "../compress-tool.js";
@@ -273,6 +273,10 @@ export function createResponsesAdapter(textProtocol?: boolean, projection?: Resp
// crashes strict clients (codex) — same class as the anthropic gap (#413).
let createdForwarded = false;
let createdRespId: string | null = null;
+ // m00885: the client request bytes as shipped (user messages included,
+ // kernel prompt section excluded) — buildRequest runs before parseStream,
+ // so the filters below can echo-check an emission-shaped span against it.
+ let shippedRequestText: string | undefined;
const ensureCreated = (): Buffer | null => {
if (createdForwarded) return null;
createdForwarded = true;
@@ -285,6 +289,7 @@ export function createResponsesAdapter(textProtocol?: boolean, projection?: Resp
return {
buildRequest(coreMessages, systemPrompt, requestBody) {
+ shippedRequestText = JSON.stringify(requestBody);
const customToolCallIds = new Set();
for (const m of coreMessages) {
const bm = m as BiliMessage;
@@ -342,11 +347,16 @@ export function createResponsesAdapter(textProtocol?: boolean, projection?: Resp
// are stripped wholesale via stripResponsesText. #1881: reasoning
// summaries stream through their own per-summary filters — the old
// generic raw passthrough leaked model-emitted tags on this wire.
+ // m00885: whole-field absorb-emission drop is armed only when this
+ // request instructed the model about absorb (server-side provenance
+ // — the absorb section exists on this request's wire iff absorbName
+ // was resolved for it).
+ const absorbArmedLocal = absorbName !== undefined;
const makeFilter = () => composeStreamFilters(
composeStreamFilters(
createTagEchoFilter((snippet) => {
loggerLog("warn", `[tag-echo] stripped model-emitted render tag: ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
- }),
+ }, absorbArmedLocal, shippedRequestText),
createMarkerLineFilter((snippet) => {
loggerLog("warn", `[marker-echo] stripped model-emitted ACP confirmation marker: ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
}),
@@ -458,7 +468,7 @@ export function createResponsesAdapter(textProtocol?: boolean, projection?: Resp
// this fallthrough — strip on detection like the message
// branches above (stripResponsesText never touches tool
// argument fields).
- const chunk = (containsRenderTagText(eventStr) || containsMarkerLineText(eventStr) || containsBiliInternalText(eventStr)) ? rebuildResponsesEvent(type, stripResponsesText(obj)) : rawBuf;
+ const chunk = (containsRenderTagText(eventStr) || containsMarkerLineText(eventStr) || containsBiliInternalText(eventStr) || (absorbArmedLocal && containsToolCallEmissionText(eventStr))) ? rebuildResponsesEvent(type, stripResponsesText(obj, absorbArmedLocal, shippedRequestText)) : rawBuf;
yield { kind: "meta", chunk, firstRoundOnly: true } as ParsedStreamEvent;
}
} else if (
@@ -470,7 +480,7 @@ export function createResponsesAdapter(textProtocol?: boolean, projection?: Resp
if (mapped) {
yield { kind: "meta", chunk: rewriteRefEvent(type, stripResponsesText(obj), mapped), firstRoundOnly: false } as ParsedStreamEvent;
} else if (!suppressTextLifecycle) {
- const chunk = (containsRenderTagText(eventStr) || containsMarkerLineText(eventStr) || containsBiliInternalText(eventStr)) ? rebuildResponsesEvent(type, stripResponsesText(obj)) : rawBuf;
+ const chunk = (containsRenderTagText(eventStr) || containsMarkerLineText(eventStr) || containsBiliInternalText(eventStr) || (absorbArmedLocal && containsToolCallEmissionText(eventStr))) ? rebuildResponsesEvent(type, stripResponsesText(obj, absorbArmedLocal, shippedRequestText)) : rawBuf;
yield { kind: "meta", chunk, firstRoundOnly: true } as ParsedStreamEvent;
}
} else if (type === "response.output_text.delta") {
@@ -572,7 +582,7 @@ export function createResponsesAdapter(textProtocol?: boolean, projection?: Resp
remapped.delete(origId);
yield { kind: "meta", chunk: rewriteItemEvent(type, stripResponsesText(obj), mapped), firstRoundOnly: false } as ParsedStreamEvent;
} else if (!suppressTextLifecycle) {
- const chunk = (containsRenderTagText(eventStr) || containsMarkerLineText(eventStr) || containsBiliInternalText(eventStr)) ? rebuildResponsesEvent(type, stripResponsesText(obj)) : rawBuf;
+ const chunk = (containsRenderTagText(eventStr) || containsMarkerLineText(eventStr) || containsBiliInternalText(eventStr) || (absorbArmedLocal && containsToolCallEmissionText(eventStr))) ? rebuildResponsesEvent(type, stripResponsesText(obj, absorbArmedLocal, shippedRequestText)) : rawBuf;
yield { kind: "meta", chunk, firstRoundOnly: true } as ParsedStreamEvent;
}
} else if (item?.type !== "message" || !suppressTextLifecycle) {
@@ -580,13 +590,13 @@ export function createResponsesAdapter(textProtocol?: boolean, projection?: Resp
// this fallthrough — strip on detection like the message
// branches above (stripResponsesText never touches tool
// argument fields).
- const chunk = (containsRenderTagText(eventStr) || containsMarkerLineText(eventStr) || containsBiliInternalText(eventStr)) ? rebuildResponsesEvent(type, stripResponsesText(obj)) : rawBuf;
+ const chunk = (containsRenderTagText(eventStr) || containsMarkerLineText(eventStr) || containsBiliInternalText(eventStr) || (absorbArmedLocal && containsToolCallEmissionText(eventStr))) ? rebuildResponsesEvent(type, stripResponsesText(obj, absorbArmedLocal, shippedRequestText)) : rawBuf;
yield { kind: "meta", chunk, firstRoundOnly: true } as ParsedStreamEvent;
}
} else if (type === "response.completed") {
yield* flushFilter();
yield* settleNamelessDiag();
- responseObj = stripResponsesText((obj.response as Record) ?? null);
+ responseObj = stripResponsesText((obj.response as Record) ?? null, absorbArmedLocal, shippedRequestText);
terminalKind = "completed";
terminalRaw = null;
const respUsage = (responseObj as Record | null)?.usage as
@@ -638,8 +648,8 @@ export function createResponsesAdapter(textProtocol?: boolean, projection?: Resp
const chunk = clean === rsDelta ? rawBuf : rebuildResponsesEvent(type, { ...obj, delta: clean });
yield { kind: "meta", chunk, firstRoundOnly: true } as ParsedStreamEvent;
}
- } else if (containsRenderTagText(eventStr) || containsMarkerLineText(eventStr) || containsBiliInternalText(eventStr)) {
- yield { kind: "meta", chunk: rebuildResponsesEvent(type, stripResponsesText(obj)), firstRoundOnly: true } as ParsedStreamEvent;
+ } else if (containsRenderTagText(eventStr) || containsMarkerLineText(eventStr) || containsBiliInternalText(eventStr) || (absorbArmedLocal && containsToolCallEmissionText(eventStr))) {
+ yield { kind: "meta", chunk: rebuildResponsesEvent(type, stripResponsesText(obj, absorbArmedLocal, shippedRequestText)), firstRoundOnly: true } as ParsedStreamEvent;
} else {
yield { kind: "meta", chunk: rawBuf, firstRoundOnly: true } as ParsedStreamEvent;
}
diff --git a/src/loop/index.ts b/src/loop/index.ts
index 97c1df89c0..8d4a5721c9 100644
--- a/src/loop/index.ts
+++ b/src/loop/index.ts
@@ -32,13 +32,14 @@ export function pickAdapter(
systemNotes?: string[],
streamErrorShape?: "protocol" | "completion",
anthropicCacheMarks?: Map,
+ absorbArmed?: boolean,
): CompressLoopAdapter {
// #1455: how upstream stream failures are presented to the client —
// protocol-native error frames (default) or legacy synthesized completion.
const shape = streamErrorShape ?? "protocol";
if (protocol === "responses") return createResponsesAdapter(textProtocol, responsesProjection, absorbName, systemNotes);
if (protocol === "openai") return createOpenaiAdapter(requestBody, openaiSystem, absorbName, systemNotes, shape);
- if (protocol === "anthropic") return createAnthropicAdapter(requestBody, anthropicSystem, systemNotes, shape, anthropicCacheMarks);
+ if (protocol === "anthropic") return createAnthropicAdapter(requestBody, anthropicSystem, systemNotes, shape, anthropicCacheMarks, absorbArmed);
if (protocol === "google") return createGoogleAdapter(requestBody, google?.system, absorbName, google?.model, systemNotes);
throw new Error(`[acp-loop] unknown protocol: ${protocol}`);
}
diff --git a/src/loop/tag-echo-filter.ts b/src/loop/tag-echo-filter.ts
index c9220d50c7..e0fae8ed1b 100644
--- a/src/loop/tag-echo-filter.ts
+++ b/src/loop/tag-echo-filter.ts
@@ -93,10 +93,12 @@ const LONE_CLOSE = new RegExp("\x3c\\/" + NAME + "(?=[\\s>])[^<>]{0,32}>");
// A suffix of the buffer that could still grow into a render tag: either an
// unterminated \x3c … opening (attrs so far, no \x3e yet) or a short
// ambiguous prefix like \x3c, \x3ca, \x3c/ac, \x3cacip, …
-const PARTIAL_TAIL = new RegExp("(\x3c" + NAME + "\\s[^<>]*|\x3c\\/" + NAME + "(?:\\s[^<>]{0,32})?|\x3c\\/?[aAcCpPiI]*)$");
+const PARTIAL_TAIL = new RegExp("(\x3c" + NAME + "\\s[^<>]*|\x3c" + NAME + "\\s*=\\s*[^<>]*|\x3c\\/" + NAME + "(?:\\s[^<>]{0,32})?|\x3c\\/?[aAcCpPiI]*)$");
// An unterminated render-tag opening at the end of a string: \x3c plus
// attrs, no \x3e — a truncated imitation, never prose (triggers use \x3cacp_).
-const TRUNC_OPEN = new RegExp("\x3c" + NAME + "\\s[^<>]*$");
+// The mangled \x3c=… form counts too: once the `=` is there the tail is
+// tag content, not an element.
+const TRUNC_OPEN = new RegExp("\x3c" + NAME + "\\s[^<>]*$|\x3c" + NAME + "\\s*=\\s*[^<>]*$");
// A truncated render-tag CLOSE at the end of a string: \x3c/ optionally
// plus truncated attrs — a truncated imitation close, never prose. Mirrors
// TRUNC_OPEN on the close side.
@@ -111,7 +113,15 @@ const TRUNC_CLOSE = new RegExp("\x3c\\/" + NAME + "(?:\\s[^<>]{0,32})?$");
// next `<`. A properly terminated opening never matches: its attribute list
// ends at a `>`, and no `<` can be reached from there within the class.
const BROKEN_ATTRS = new RegExp("\x3c" + NAME + "\\s[^<>]*(?=\x3c)");
-const DEFINITE_TAIL = new RegExp("^\x3c" + NAME + "\\s|^\x3c\\/" + NAME);
+// A mangled render-tag OPENING: the name, then `=` where the attribute list's
+// first whitespace belongs, e.g. ``. The kernel never emits it — the
+// model mangles the framing it learned from the wire (production session
+// ses_efe4cfcbdffe, 2026-10-03: 5 assistant turns opening with ``).
+// The `=` anchor is what keeps plain HTML safe: ``, `` and any
+// real element name carry no `=`, and a properly formed render tag matches
+// LONE_OPEN/PAIRED, not this.
+const MANGLED_OPEN = new RegExp("\x3c" + NAME + "\\s*=\\s*[^<>]*>");
+const DEFINITE_TAIL = new RegExp("^\x3c" + NAME + "\\s|^\x3c" + NAME + "=|^\x3c\\/" + NAME);
const OPEN_WITH_ATTRS = new RegExp("^\x3c" + NAME + "\\s");
const CLOSE_HEAD = "\x3c/";
const CLOSE_NAME_ANCHORED = new RegExp("^" + NAME);
@@ -232,7 +242,16 @@ export function stripMarkerLines(text: string): string {
return text.replace(MARKER_LINE, "");
}
-export function stripAcpTags(text: string): string {
+export function stripAcpTags(text: string, dropToolCallEmission = false, requestText?: string): string {
+ // A whole-field tool-call emission first: the field IS the call, so the
+ // span goes whole (see toolCallEmissionSpan). Gated by the caller; the
+ // m00885 echo check keeps a span the user asked to be emitted verbatim.
+ if (dropToolCallEmission) {
+ const span = toolCallEmissionSpan(text);
+ if (span !== null && !emissionEchoesRequest(text.slice(span.start, span.end), requestText)) {
+ text = text.slice(span.end);
+ }
+ }
// A wrapped-turn imitation first, whole: it swallows the model's turn, and
// leaving its payload behind hands the client the orphan markup that makes
// the turn unusable. Each pass removes at least the head, so this ends.
@@ -245,6 +264,7 @@ export function stripAcpTags(text: string): string {
out = out
.replace(new RegExp(PAIRED.source, "g"), "")
.replace(new RegExp(LONE_OPEN.source, "g"), "")
+ .replace(new RegExp(MANGLED_OPEN.source, "g"), "")
.replace(new RegExp(LONE_CLOSE.source, "g"), "")
.replace(new RegExp(TRUNC_OPEN.source), "")
.replace(new RegExp(TRUNC_CLOSE.source), "")
@@ -278,7 +298,10 @@ export function containsRenderTagText(s: string): boolean {
// (byte-identical passthrough); only chunks with a tag-head tail ("\x3c", "\x3c/",
// "\x3ca", "\x3cac", "\x3cacp ...attrs", "\x3c/acp ...") engage it.
export function mayStartRenderTag(s: string): boolean {
- return RENDER_TAG_DETECT.test(s) || PARTIAL_TAIL.test(s);
+ // MANGLED_OPEN carries its own ">" (PARTIAL_TAIL only sees unterminated
+ // tails), so it is tested directly: a chunk with a complete mangled open
+ // must engage the machine to drop it.
+ return RENDER_TAG_DETECT.test(s) || MANGLED_OPEN.test(s) || PARTIAL_TAIL.test(s);
}
// #361: tool-call XML template fragments a model may echo from the context
@@ -291,6 +314,145 @@ export function containsToolCallXmlFragment(s: string): boolean {
return TOOL_CALL_XML.test(s);
}
+// ─── Whole-field tool-call EMISSION (production 2026-10-03) ────────────────
+// The #361 fragments above are tool-call markup QUOTED inside prose —
+// legitimate content, detect + warn only. A different shape exists: the
+// model writes the whole call as the prose field's body (the "hybrid"
+// emission in opencode session ses_efe4cfcbdffe, 2026-10-03:
+// \n\nm00608\n\n…prose…\n
+// \n\n standing alone in the prose
+// channel). That field IS the call, not prose quoting a call. Its shape is
+// the absorb tool's signature — the only bili tool with a ref+summary
+// parameter pair — so a whole-field shape is a tight discriminator: a
+// tool-call open at the field start, a ref parameter whose body is a kernel
+// ref, a summary parameter, and a call close. Embedded quotes never start
+// the field, so they are untouched. Dropping the span is additionally
+// gated on provenance (the request carried the [ACP absorb] instruction);
+// shape alone never decides.
+export const ABSORB_INSTRUCTION_MARKER = "[ACP absorb]";
+const TC_OPEN_AT_START = /^\x3c(?:antml:)?(?:function_calls|function|parameter|parameters|invoke|tool_calls|tool_call)\b/;
+const TC_PARAM_REF = /\x3c(?:antml:)?parameter(?:\s*=\s*["']?ref["']?|\s+name\s*=\s*["']ref["'])?[^<>]*\x3e\s*m\d{4,}\s*\x3c\/(?:antml:)?parameter/i;
+const TC_PARAM_SUMMARY = /\x3c(?:antml:)?parameter(?:\s*=\s*["']?summary["']?|\s+name\s*=\s*["']summary["'])?[^<>]*\x3e/i;
+const TC_CLOSE = /\x3c\/(?:antml:)?(?:function_calls|function|parameter|parameters|invoke|tool_calls|tool_call)\b[^<>]*\x3e/i;
+const TC_ORPHAN_HEAD = /^\s*\x3c\/(?:antml:)?(?:function_calls|function|parameter|parameters|invoke|tool_calls|tool_call)\b/;
+const TC_TAG_STRIP = /\x3c\/?(?:antml:)?(?:function_calls|function|parameter|parameters|invoke|tool_calls|tool_call)\b[^<>]*\x3e/gi;
+// Raw-wire whitespace: inside a JSON body, the gap between the markup and
+// the ref body arrives as two-char escape pairs (\n \r \t) that \s cannot
+// see. Brackets are never JSON-escaped, so a raw presence test is sound.
+const RAW_WS = "(?:\\\\[a-z]|\\s|\\\\)*";
+const TC_PARAM_REF_RAW = new RegExp(
+ "\\x3c(?:antml:)?parameter(?:\\s*=\\s*[\"']?ref[\"']?|\\s+name\\s*=\\s*[\"']ref[\"'])?[^<>]*\\x3e" + RAW_WS + "m\\d{4,}" + RAW_WS + "\\x3c\\/(?:antml:)?parameter",
+ "i"
+);
+
+/** Span of a whole-field tool-call emission: from the field start (after
+ * leading whitespace) through the last call close. Null when the field is
+ * not shaped as one. Pure shape — the caller gates the drop on
+ * provenance. */
+export function toolCallEmissionSpan(text: string): { start: number; end: number } | null {
+ const lead = text.length - text.trimStart().length;
+ const t = text.slice(lead);
+ if (t.length === 0 || !TC_OPEN_AT_START.test(t)) return null;
+ if (!TC_PARAM_REF.test(t) || !TC_PARAM_SUMMARY.test(t)) return null;
+ let end = -1;
+ for (const m of t.matchAll(new RegExp(TC_CLOSE.source, "gi"))) end = m.index + m[0].length;
+ if (end === -1) return null;
+ return { start: lead, end: lead + end };
+}
+
+/** Whole field is a tool-call emission (see above). */
+export function isToolCallEmission(text: string): boolean {
+ return toolCallEmissionSpan(text) !== null;
+}
+
+/** A field that opens on a tool-call CLOSE whose remainder is nothing but
+ * refs and whitespace — the tail half of an emission split across a field
+ * boundary (defensive; no production record yet). */
+export function isOrphanToolCallTail(text: string): boolean {
+ if (!TC_ORPHAN_HEAD.test(text)) return false;
+ return /^\s*(?:m\d{4,}\s*)*$/.test(text.replace(TC_TAG_STRIP, ""));
+}
+
+/** Raw-wire pre-check for the emission shape inside an SSE/JSON body (the
+ * gate runs before parsing; the exact field-level decision is
+ * toolCallEmissionSpan on parsed field text). */
+export function containsToolCallEmissionText(s: string): boolean {
+ return TC_PARAM_REF_RAW.test(s) && TC_PARAM_SUMMARY.test(s) && TC_CLOSE.test(s);
+}
+
+// Canonical comparison form for the m00885 echo check. The request side is
+// JSON text, where a newline in the user's quote is the two-char escape
+// pair `\n` — dropping the backslash alone would leave a stray `n` between
+// the markup and the ref body and break containment, so escape pairs are
+// resolved first (\uXXXX to the char, \n \t \r and the other pairs to a
+// space) and only then do backslashes and whitespace vanish. Both sides
+// end up in the same form, so a fragment quoted in the request and
+// re-emitted by the model — literal, JSON-escaped, or re-spaced — compares
+// equal.
+function canonicalEmissionForm(t: string): string {
+ return t
+ .replace(/\\u([0-9a-fA-F]{4})/g, (_m, h: string) => String.fromCharCode(parseInt(h, 16)))
+ .replace(/\\n/g, " ")
+ .replace(/\\t/g, " ")
+ .replace(/\\r/g, " ")
+ .replace(/\\[\"\\/btf]/g, " ")
+ .replace(/[\\\s]/g, "");
+}
+
+/** m00885: an emission-shaped span is KEPT when it echoes the shipped
+ * request — the user asked the model to output a tool-call-shaped fragment
+ * verbatim as the response, so the fragment is user intent, not a leaked
+ * internal call. The span (markup + ref body + summary + close) must be
+ * contained in the request bytes, whitespace/escape-insensitively; a
+ * model-invented emission (the production shape, where the ref points at a
+ * tool result the user never wrote) cannot match. */
+export function emissionEchoesRequest(spanText: string, requestText: string | undefined): boolean {
+ if (typeof requestText !== "string" || requestText.length === 0 || spanText.length === 0) return false;
+ if (requestText.includes(spanText)) return true;
+ const needle = canonicalEmissionForm(spanText);
+ if (needle.length === 0) return false;
+ return canonicalEmissionForm(requestText).includes(needle);
+}
+
+const TC_OPEN_NAMES = ["function_calls", "function", "tool_calls", "tool_call", "parameters", "parameter", "invoke"];
+
+/** Whether an accumulated field head could still be, or already is, the
+ * start of a tool call: "open" when a name head has reached its boundary
+ * (space/=/>), "prefix" while it may still grow into one, "none" when no
+ * name head remains possible. */
+export function toolCallOpenStatus(s: string): "none" | "prefix" | "open" {
+ let prefix = false;
+ for (const name of TC_OPEN_NAMES) {
+ for (const head of ["\x3c" + name, "\x3cantml:" + name]) {
+ if (s === head) {
+ prefix = true;
+ continue;
+ }
+ if (s.startsWith(head)) {
+ const nxt = s[head.length];
+ if (nxt === undefined) {
+ prefix = true;
+ continue;
+ }
+ if (nxt === " " || nxt === "\t" || nxt === "\n" || nxt === "\r" || nxt === "=" || nxt === ">") return "open";
+ } else if (head.startsWith(s)) {
+ prefix = true;
+ }
+ }
+ }
+ return prefix ? "prefix" : "none";
+}
+
+/** Per-chunk gate: does the chunk contain or end with a tool-call open, so
+ * the streaming machine must engage to decide whether the field is a
+ * whole-field emission? */
+export function mayStartToolCallEmission(s: string): boolean {
+ for (let i = s.indexOf("\x3c"); i !== -1; i = s.indexOf("\x3c", i + 1)) {
+ if (toolCallOpenStatus(s.slice(i)) !== "none") return true;
+ }
+ return false;
+}
+
// ─── #1634: bili-owned internal artifacts echoed by the model ───────────────
// The proxy injects three artifact families into model-visible payloads: the
// outbound checkpoint carrier (\x3cbili-chain \u2026/\x3e stamped onto forwarded requests),
@@ -523,8 +685,16 @@ export function createBiliArtifactFilter(onDrop?: (snippet: string) => void): Ta
};
}
-export function createTagEchoFilter(onDrop?: (snippet: string) => void): TagEchoFilter {
+export function createTagEchoFilter(onDrop?: (snippet: string) => void, absorbInstructed?: boolean, requestText?: string): TagEchoFilter {
let held = "";
+ // Whole-field tool-call emission hold: when the request carried the
+ // [ACP absorb] instruction, the first non-whitespace head of each field
+ // that could be a tool-call open is held until the field is complete, so
+ // the emission decision runs on the WHOLE field (a mid-stream shape
+ // check could never see the closing tags). "pending" = not yet seen a
+ // non-whitespace byte; "committed" = a tool-call open is in the head;
+ // "off" = decided not one (or no instruction in the request).
+ let tcHold: "off" | "pending" | "committed" = absorbInstructed === true ? "pending" : "off";
let swallowUntilClose = false;
let swallowed = "";
/** Which budget the current swallow answers to (SWALLOW_CAP or
@@ -592,8 +762,12 @@ export function createTagEchoFilter(onDrop?: (snippet: string) => void): TagEcho
const p = PAIRED.exec(buf);
const o = LONE_OPEN.exec(buf);
const c = LONE_CLOSE.exec(buf);
+ // A mangled open () is a complete self-contained tag:
+ // drop it in place, no swallow (a following close dies via
+ // LONE_CLOSE on its own).
+ const g = MANGLED_OPEN.exec(buf);
let m: RegExpExecArray | null = null;
- for (const cand of [p, o, c]) {
+ for (const cand of [p, o, c, g]) {
if (cand && (m === null || cand.index < m.index)) m = cand;
}
// An opening whose attribute list never terminates (see
@@ -680,6 +854,22 @@ export function createTagEchoFilter(onDrop?: (snippet: string) => void): TagEcho
return {
push(delta: string): string {
inputChars += delta.length;
+ if (tcHold !== "off") {
+ held += delta;
+ const t = held.trimStart();
+ if (t.length === 0) return "";
+ if (t[0] !== "\x3c") tcHold = "off";
+ else {
+ const st = toolCallOpenStatus(t);
+ if (st === "open") tcHold = "committed";
+ else if (st === "none") tcHold = "off";
+ }
+ if (tcHold !== "off") return "";
+ const r = process(held);
+ held = "";
+ outputChars += r.length;
+ return r;
+ }
const chunk = held + delta;
held = "";
const r = process(chunk);
@@ -687,6 +877,36 @@ export function createTagEchoFilter(onDrop?: (snippet: string) => void): TagEcho
return r;
},
flush(): string {
+ if (tcHold !== "off") {
+ // The field ended while its head was held: decide the whole
+ // field, then hand any non-emission rest to the normal path.
+ tcHold = "off";
+ const field = held;
+ held = "";
+ const t = field.trimStart();
+ if (t.length > 0 && t[0] === "\x3c") {
+ const span = toolCallEmissionSpan(field);
+ if (span !== null) {
+ if (!emissionEchoesRequest(field.slice(span.start, span.end), requestText)) {
+ drop(field.slice(0, span.end));
+ const rest = field.slice(span.end);
+ if (rest.length === 0) return "";
+ const r = process(rest);
+ outputChars += r.length;
+ return r;
+ }
+ // The span mirrors the request verbatim (m00885): the
+ // user asked for this fragment as the whole response —
+ // it is user intent, so it flows through untouched.
+ } else if (isOrphanToolCallTail(field)) {
+ drop(field);
+ return "";
+ }
+ }
+ const r = process(field);
+ outputChars += r.length;
+ return r;
+ }
const rest = swallowed + held;
const wasSwallowing = swallowUntilClose;
swallowed = "";
@@ -747,17 +967,17 @@ export function createTagEchoFilter(onDrop?: (snippet: string) => void): TagEcho
};
}
-function stripParts(content: unknown): unknown {
+function stripParts(content: unknown, drop: boolean, requestText?: string): unknown {
if (!Array.isArray(content)) return content;
return content.map((part) => {
if (part && typeof part === "object" && typeof (part as Record).text === "string") {
- return { ...(part as Record), text: stripAcpTags((part as Record).text as string) };
+ return { ...(part as Record), text: stripAcpTags((part as Record).text as string, drop, requestText) };
}
return part;
});
}
-function stripItemContent(it: unknown): unknown {
+function stripItemContent(it: unknown, drop: boolean, requestText?: string): unknown {
if (!it || typeof it !== "object") return it;
const io = it as Record;
let out: Record | undefined;
@@ -765,13 +985,13 @@ function stripItemContent(it: unknown): unknown {
out ??= { ...io };
out[k] = v;
};
- if (Array.isArray(io.content)) set("content", stripParts(io.content));
+ if (Array.isArray(io.content)) set("content", stripParts(io.content, drop, requestText));
if (Array.isArray(io.summary)) {
set(
"summary",
io.summary.map((s) =>
s && typeof s === "object" && typeof (s as Record).text === "string"
- ? { ...(s as Record), text: stripAcpTags((s as Record).text as string) }
+ ? { ...(s as Record), text: stripAcpTags((s as Record).text as string, drop, requestText) }
: s,
),
);
@@ -779,8 +999,8 @@ function stripItemContent(it: unknown): unknown {
return out ?? it;
}
-function stripIfString(v: unknown): unknown {
- return typeof v === "string" ? stripAcpTags(v) : v;
+function stripIfString(v: unknown, drop: boolean, requestText?: string): unknown {
+ return typeof v === "string" ? stripAcpTags(v, drop, requestText) : v;
}
// Plugin-passthrough parity for the OpenAI chat-completions wire (issue #14:
@@ -792,7 +1012,7 @@ function stripIfString(v: unknown): unknown {
// execute/persist, so a shape-based false positive would silently corrupt
// data — only model prose is stripped. Mutates in place, mirroring
// stripResponsesText.
-export function stripOpenaiChatText(obj: T): T {
+export function stripOpenaiChatText(obj: T, drop: boolean = false, requestText?: string): T {
if (!obj || typeof obj !== "object") return obj;
const o = obj as Record;
if (!Array.isArray(o["choices"])) return obj;
@@ -803,9 +1023,9 @@ export function stripOpenaiChatText(obj: T): T {
const h = ch[holder];
if (h && typeof h === "object") {
const hh = { ...(h as Record) };
- hh["content"] = stripIfString(hh["content"]);
- hh["reasoning_content"] = stripIfString(hh["reasoning_content"]);
- hh["reasoning"] = stripIfString(hh["reasoning"]);
+ hh["content"] = stripIfString(hh["content"], drop, requestText);
+ hh["reasoning_content"] = stripIfString(hh["reasoning_content"], drop, requestText);
+ hh["reasoning"] = stripIfString(hh["reasoning"], drop, requestText);
ch[holder] = hh;
}
}
@@ -817,14 +1037,14 @@ export function stripOpenaiChatText(obj: T): T {
// Plugin-passthrough parity for the Anthropic wire: strip `delta.{text,
// thinking}` on content_block_delta streams and `content[].{text,thinking}`
// on non-streaming message bodies. Mutates in place.
-export function stripAnthropicText(obj: T): T {
+export function stripAnthropicText(obj: T, drop: boolean = false, requestText?: string): T {
if (!obj || typeof obj !== "object") return obj;
const o = obj as Record;
const d = o["delta"];
if (d && typeof d === "object") {
const dd = { ...(d as Record) };
- dd["text"] = stripIfString(dd["text"]);
- dd["thinking"] = stripIfString(dd["thinking"]);
+ dd["text"] = stripIfString(dd["text"], drop, requestText);
+ dd["thinking"] = stripIfString(dd["thinking"], drop, requestText);
o["delta"] = dd;
}
if (Array.isArray(o["content"])) {
@@ -832,7 +1052,7 @@ export function stripAnthropicText(obj: T): T {
if (!c || typeof c !== "object") return c;
const cc = c as Record;
if (typeof cc["text"] !== "string" && typeof cc["thinking"] !== "string") return c;
- return { ...cc, text: stripIfString(cc["text"]), thinking: stripIfString(cc["thinking"]) };
+ return { ...cc, text: stripIfString(cc["text"], drop, requestText), thinking: stripIfString(cc["thinking"], drop, requestText) };
});
}
return obj;
@@ -846,25 +1066,25 @@ export function stripAnthropicText(obj: T): T {
// fragment carriers) are deliberately untouched (#1039): they carry user
// intent that hosts execute/persist, so a shape-based false positive would
// silently corrupt data — only model prose is stripped.
-export function stripResponsesText(obj: T): T {
+export function stripResponsesText(obj: T, drop: boolean = false, requestText?: string): T {
if (!obj || typeof obj !== "object") return obj;
const o = obj as Record;
- if (typeof o.text === "string") o.text = stripAcpTags(o.text);
+ if (typeof o.text === "string") o.text = stripAcpTags(o.text, drop, requestText);
if (o.part && typeof o.part === "object" && typeof (o.part as Record).text === "string") {
- o.part = { ...(o.part as Record), text: stripAcpTags((o.part as Record).text as string) };
+ o.part = { ...(o.part as Record), text: stripAcpTags((o.part as Record).text as string, drop, requestText) };
}
if (o.item && typeof o.item === "object") {
- o.item = stripItemContent(o.item);
+ o.item = stripItemContent(o.item, drop, requestText);
}
if (o.response && typeof o.response === "object") {
const resp = { ...(o.response as Record) };
if (Array.isArray(resp.output)) {
- resp.output = resp.output.map(stripItemContent);
+ resp.output = (resp.output as unknown[]).map((it) => stripItemContent(it, drop, requestText));
}
o.response = resp;
}
if (Array.isArray(o.output)) {
- o.output = o.output.map(stripItemContent);
+ o.output = (o.output as unknown[]).map((it) => stripItemContent(it, drop, requestText));
}
return obj;
}
diff --git a/src/plugin.ts b/src/plugin.ts
index 84e6314c9c..0fee48d5c8 100644
--- a/src/plugin.ts
+++ b/src/plugin.ts
@@ -15,7 +15,7 @@ import { absorbEnabled, effectiveAbsorbConfig, isProxyToolFor } from "./absorb.j
import { effectiveRulesEnabled, rulesEnabled } from "./rules-feature.js";
import { executeProxyTool } from "./loop/core.js";
import { normalizeSseLineEndings } from "./sse-util.js";
-import { composeStreamFilters, containsBiliInternalText, containsMarkerLineText, containsRenderTagText, containsToolCallXmlFragment, createBiliArtifactFilter, createMarkerLineFilter, createTagEchoFilter, isOrphanMarkupText, mayStartBiliInternal, mayStartMarkerLine, mayStartRenderTag, stripAcpTags, stripAnthropicText, stripOpenaiChatText, stripResponsesText, type TagEchoFilter } from "./loop/tag-echo-filter.js";
+import { composeStreamFilters, containsBiliInternalText, containsMarkerLineText, containsRenderTagText, containsToolCallEmissionText, containsToolCallXmlFragment, createBiliArtifactFilter, createMarkerLineFilter, createTagEchoFilter, isOrphanMarkupText, mayStartBiliInternal, mayStartMarkerLine, mayStartRenderTag, mayStartToolCallEmission, stripAcpTags, stripAnthropicText, stripOpenaiChatText, stripResponsesText, type TagEchoFilter } from "./loop/tag-echo-filter.js";
import { log as loggerLog } from "./logger.js";
import { ccrEnabled, ccrLoopConfig, contentStoreOf, retrieveToolName } from "./store.js";
import { imageUsageSuffix } from "./image-compress.js";
@@ -1715,6 +1715,14 @@ export async function pipePluginChatWithStrip(
log?: (msg: string) => void,
refetch?: () => Promise | null>,
upstreamOrigin?: string,
+ // True when the outbound request carried the [ACP absorb] instruction:
+ // the model may then answer with a tool call written as prose, and the
+ // filters apply the whole-field emission drop (gated on request
+ // provenance, not string shape — m00885).
+ absorbInstructed?: boolean,
+ // The shipped request text: an emission-shaped span the user asked to
+ // output verbatim is echoed, not dropped (m00885).
+ requestText?: string,
): Promise {
let reader = stream.getReader();
let decoder = new TextDecoder("utf-8");
@@ -1750,7 +1758,7 @@ export async function pipePluginChatWithStrip(
const key = `${field}:${index}`;
let s = streams.get(key);
if (!s) {
- s = { filter: composeStreamFilters(composeStreamFilters(createTagEchoFilter(onTagDrop), createMarkerLineFilter(onMarkerDrop)), createBiliArtifactFilter(onBiliDrop)), field, index };
+ s = { filter: composeStreamFilters(composeStreamFilters(createTagEchoFilter(onTagDrop, absorbInstructed, requestText), createMarkerLineFilter(onMarkerDrop)), createBiliArtifactFilter(onBiliDrop)), field, index };
streams.set(key, s);
}
return s;
@@ -2078,7 +2086,10 @@ export async function pipePluginChatWithStrip(
// leap ahead of a held tail.
if (v.length > 0) hadText = true;
if (field !== "content" && v.length > 0) sawThinking = true;
- if (!mayStartRenderTag(v) && !mayStartMarkerLine(v) && !mayStartBiliInternal(v) && !anyPending()) {
+ // An absorb-instructed request may carry a whole-field
+ // tool-call emission: route it to the filter so the
+ // whole-field decision runs (m00885).
+ if (!mayStartRenderTag(v) && !mayStartMarkerLine(v) && !mayStartBiliInternal(v) && !(absorbInstructed === true && mayStartToolCallEmission(v)) && !anyPending()) {
if (v.length > 0) {
keptText = true;
proseAcc += v;
@@ -2185,7 +2196,10 @@ export async function pipePluginChatWithStrip(
}
const raw = d[field] as string;
if (field === "thinking" && raw.length > 0) sawThinking = true;
- if (!mayStartRenderTag(raw) && !mayStartMarkerLine(raw) && !mayStartBiliInternal(raw) && !anyPending()) {
+ // Whole-field tool-call emission on an absorb-instructed request
+ // (m00885): the filter's field-start hold decides on the complete
+ // field, so the fast path must not pre-empt it.
+ if (!mayStartRenderTag(raw) && !mayStartMarkerLine(raw) && !mayStartBiliInternal(raw) && !(absorbInstructed === true && mayStartToolCallEmission(raw)) && !anyPending()) {
if (raw.length > 0) proseAcc += raw;
if (field === "text" && raw.length > 0) visibleTextChars += raw.length;
return rawEvent + "\n\n";
@@ -2272,7 +2286,9 @@ export async function pipePluginChatWithStrip(
// field, so an interleaved thought/text pair in one frame never
// shares held-back state.
const field = p["thought"] === true ? "thinking" : "text";
- if (!mayStartRenderTag(raw) && !mayStartMarkerLine(raw) && !mayStartBiliInternal(raw) && !anyPending()) {
+ // Whole-field tool-call emission on an absorb-instructed
+ // request (m00885) — see processOpenai.
+ if (!mayStartRenderTag(raw) && !mayStartMarkerLine(raw) && !mayStartBiliInternal(raw) && !(absorbInstructed === true && mayStartToolCallEmission(raw)) && !anyPending()) {
if (raw.length > 0) {
keptText = true;
proseAcc += raw;
@@ -2539,6 +2555,11 @@ export async function pipePluginResponsesWithStrip(
log?: (msg: string) => void,
refetch?: () => Promise | null>,
upstreamOrigin?: string,
+ // See pipePluginChatWithStrip: whole-field tool-call emission drop,
+ // gated on the request carrying the [ACP absorb] instruction (m00885).
+ absorbInstructed?: boolean,
+ // m00885: echoed (user-requested verbatim) emission spans survive.
+ requestText?: string,
): Promise {
let reader = stream.getReader();
let decoder = new TextDecoder("utf-8");
@@ -2554,7 +2575,7 @@ export async function pipePluginResponsesWithStrip(
};
const tagFilter = composeStreamFilters(
composeStreamFilters(
- createTagEchoFilter(onTagDrop),
+ createTagEchoFilter(onTagDrop, absorbInstructed, requestText),
createMarkerLineFilter((snippet) => {
loggerLog("warn", `[marker-echo] stripped model-emitted ACP confirmation marker (plugin passthrough): ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
log?.(`[marker-echo] stripped model-emitted ACP confirmation marker from plugin passthrough text`);
@@ -2793,7 +2814,7 @@ export async function pipePluginResponsesWithStrip(
for (const k of ["item_id", "output_index", "summary_index"]) {
if (ev[k] !== undefined) meta[k] = ev[k];
}
- s = { filter: composeStreamFilters(createTagEchoFilter(onTagDrop), createBiliArtifactFilter(onBiliDrop)), type, field, meta };
+ s = { filter: composeStreamFilters(createTagEchoFilter(onTagDrop, absorbInstructed, requestText), createBiliArtifactFilter(onBiliDrop)), type, field, meta };
argStreams.set(key, s);
}
return s;
@@ -2883,9 +2904,13 @@ export async function pipePluginResponsesWithStrip(
// The done is not visible text to the degenerate-turn retry below, so it
// is stripped and released directly.
if (type === "response.reasoning_summary_part.done") {
- const hadEcho = containsRenderTagText(jsonStr) || containsMarkerLineText(jsonStr) || containsBiliInternalText(jsonStr);
+ // An absorb-instructed turn may complete as a
+ // whole-field tool-call emission written as prose
+ // (m00885): drop the span, not just the tags.
+ const dropEmission = absorbInstructed === true && containsToolCallEmissionText(jsonStr);
+ const hadEcho = containsRenderTagText(jsonStr) || containsMarkerLineText(jsonStr) || containsBiliInternalText(jsonStr) || dropEmission;
if (hadEcho) sawStrippedEcho = true;
- const evOut = hadEcho ? stripResponsesText(ev) : ev;
+ const evOut = hadEcho ? stripResponsesText(ev, dropEmission, requestText) : ev;
proseAcc += responsesEventText(evOut);
const out = hadEcho ? rebuildEvent(rawEvent, evOut) : rawEvent + "\n\n";
await write(flushArgTails() + flushTail(out));
@@ -2896,11 +2921,13 @@ export async function pipePluginResponsesWithStrip(
// retryEmptyTurn): releasing it earlier would hand the
// client the echo's own text exactly when the retry is
// about to replace it.
- const hadEchoText = containsRenderTagText(jsonStr) || containsMarkerLineText(jsonStr) || containsBiliInternalText(jsonStr);
+ // Whole-field tool-call emission (m00885) — see above.
+ const dropEmission = absorbInstructed === true && containsToolCallEmissionText(jsonStr);
+ const hadEchoText = containsRenderTagText(jsonStr) || containsMarkerLineText(jsonStr) || containsBiliInternalText(jsonStr) || dropEmission;
if (hadEchoText) sawStrippedEcho = true;
let evOut = ev;
let rebuild = hadEchoText || retryRewritePending();
- if (rebuild) evOut = stripResponsesText(ev);
+ if (rebuild) evOut = stripResponsesText(ev, dropEmission, requestText);
rewriteRetryIds(evOut);
const doneText = responsesEventText(evOut);
heldVisibleChars += doneText.length;
@@ -2946,11 +2973,13 @@ export async function pipePluginResponsesWithStrip(
heldVisibleChars = 0;
// The completion frame itself closes the turn: strip it if it
// carries echoed text, rewrite retry ids onto the first attempt's.
- const hadEchoText = containsRenderTagText(jsonStr) || containsMarkerLineText(jsonStr) || containsBiliInternalText(jsonStr);
+ // Whole-field tool-call emission (m00885) — see above.
+ const dropEmission = absorbInstructed === true && containsToolCallEmissionText(jsonStr);
+ const hadEchoText = containsRenderTagText(jsonStr) || containsMarkerLineText(jsonStr) || containsBiliInternalText(jsonStr) || dropEmission;
if (hadEchoText) sawStrippedEcho = true;
let evOut = ev;
let rebuild = hadEchoText || retryRewritePending();
- if (rebuild) evOut = stripResponsesText(ev);
+ if (rebuild) evOut = stripResponsesText(ev, dropEmission, requestText);
rewriteRetryIds(evOut);
// Hosts finish on this frame, before EOF settles billing and late usage.
if (session && acc.inputTokens !== undefined && acc.inputTokens > 0) {
@@ -2967,7 +2996,9 @@ export async function pipePluginResponsesWithStrip(
await write(rawEvent + "\n\n");
continue;
}
- if (!retryRewritePending() && !mayStartRenderTag(delta) && !mayStartMarkerLine(delta) && !mayStartBiliInternal(delta) && !tagFilter.pending()) {
+ // Whole-field emission head (m00885): the filter's
+ // field-start hold must see the first bytes.
+ if (!retryRewritePending() && !mayStartRenderTag(delta) && !mayStartMarkerLine(delta) && !mayStartBiliInternal(delta) && !(absorbInstructed === true && mayStartToolCallEmission(delta)) && !tagFilter.pending()) {
proseAcc += delta;
visibleTextChars += delta.length;
fastPathChars += delta.length;
@@ -3005,7 +3036,7 @@ export async function pipePluginResponsesWithStrip(
await write(rawEvent + "\n\n");
continue;
}
- if (!mayStartRenderTag(v) && !mayStartBiliInternal(v) && !argAnyPending() && !tagFilter.pending()) {
+ if (!mayStartRenderTag(v) && !mayStartBiliInternal(v) && !(absorbInstructed === true && mayStartToolCallEmission(v)) && !argAnyPending() && !tagFilter.pending()) {
proseAcc += v;
await write(rawEvent + "\n\n");
continue;
@@ -3093,7 +3124,7 @@ function rebuildEvent(rawEvent: string, ev: Record): string {
// `thought:true` reasoning parts share that one field. Mirrors
// stripOpenaiChatText / stripAnthropicText; mutates in place (the returned
// reference is the input's).
-function stripGoogleChunk(obj: T): T {
+function stripGoogleChunk(obj: T, drop: boolean = false, requestText?: string): T {
if (!obj || typeof obj !== "object") return obj;
const o = obj as Record;
const candidates = o["candidates"];
@@ -3111,7 +3142,7 @@ function stripGoogleChunk(obj: T): T {
...cont,
parts: (cont["parts"] as unknown[]).map((p) =>
p && typeof p === "object" && typeof (p as Record)["text"] === "string"
- ? { ...(p as Record), text: stripAcpTags((p as Record)["text"] as string) }
+ ? { ...(p as Record), text: stripAcpTags((p as Record)["text"] as string, drop, requestText) }
: p,
),
},
@@ -3122,14 +3153,14 @@ function stripGoogleChunk(obj: T): T {
// Without `alt=sse` a Gemini streaming response is a JSON ARRAY of the same
// chunk objects, so the non-stream strip applies to each element as well.
-function stripGoogleText(obj: T): T {
+function stripGoogleText(obj: T, drop: boolean = false, requestText?: string): T {
if (Array.isArray(obj)) {
obj.forEach((c) => {
- stripGoogleChunk(c);
+ stripGoogleChunk(c, drop, requestText);
});
return obj;
}
- return stripGoogleChunk(obj);
+ return stripGoogleChunk(obj, drop, requestText);
}
export async function pipePluginJson(
@@ -3138,6 +3169,12 @@ export async function pipePluginJson(
session?: Session,
protocol?: WireProtocol,
upstreamOrigin?: string,
+ // m00885 provenance gate: the request body carried the kernel's
+ // "[ACP absorb]" instruction. Off ⇒ whole-field tool-call text in the
+ // JSON body is legitimate prose and survives the strip.
+ absorbInstructed?: boolean,
+ // m00885: echoed (user-requested verbatim) emission spans survive.
+ requestText?: string,
): Promise {
// Also serves proxy-mode JSON responses that skipped compress injection
// (#460 residual) — pass no session there so usage accounting stays off.
@@ -3204,16 +3241,20 @@ export async function pipePluginJson(
// one full-body parse this path already does. Observe-only (#1039).
if (session) recordJsonToolWitnesses(session.id, json, protocol);
} catch { /* non-JSON body — forward verbatim */ }
- if (json && (containsRenderTagText(text) || containsMarkerLineText(text) || containsBiliInternalText(text))) {
+ // m00885: an absorb-instructed turn may answer with a whole-field
+ // tool-call emission written as prose — the raw-body probe is
+ // escape-tolerant so it fires on the serialized JSON too.
+ const dropEmission = absorbInstructed === true && containsToolCallEmissionText(text);
+ if (json && (dropEmission || containsRenderTagText(text) || containsMarkerLineText(text) || containsBiliInternalText(text))) {
// #206 parity for the non-streaming plugin path: the compress loop's
// JSON branch strips render tags from every round; a verbatim plugin
// JSON response would re-feed the model's tag echoes. Strips mutate in
// place, so this composes with the #408 usage backfill above — one
// parse, one reserialize.
- json = protocol === "responses" ? stripResponsesText(json)
- : protocol === "anthropic" ? stripAnthropicText(json)
- : protocol === "google" ? stripGoogleText(json)
- : stripOpenaiChatText(json);
+ json = protocol === "responses" ? stripResponsesText(json, dropEmission, requestText)
+ : protocol === "anthropic" ? stripAnthropicText(json, dropEmission, requestText)
+ : protocol === "google" ? stripGoogleText(json, dropEmission, requestText)
+ : stripOpenaiChatText(json, dropEmission, requestText);
mutated = true;
}
if (mutated && json) {
diff --git a/src/server.ts b/src/server.ts
index 8d7a43664d..98b04f1121 100644
--- a/src/server.ts
+++ b/src/server.ts
@@ -95,7 +95,7 @@ import { hoistTrappedToolItems } from "./tool-pair-order.js";
import { runCompressLoop, pickAdapter } from "./loop/index.js";
import { computeAnthropicMessageMarks, stampAnthropicSystemCacheControl, anthropicToolsCarryCacheControl } from "./loop/cache-control.js";
import { reconcileSystemAnchor } from "./system-anchor.js";
-import { containsToolCallXmlFragment } from "./loop/tag-echo-filter.js";
+import { ABSORB_INSTRUCTION_MARKER, containsToolCallXmlFragment } from "./loop/tag-echo-filter.js";
import { isStrictReasoningEcho, modelIdOf, normalizeStrictEchoReasoning, normalizeStrictEchoResponsesInput } from "./strict-echo.js";
export { isStrictReasoningEcho, normalizeStrictEchoReasoning, normalizeStrictEchoResponsesInput };
import { isFakeCompletion, injectFakeCompletionHint, maxFakeCompletionRetries, fakeBufCap } from "./fake-completion.js";
@@ -6809,6 +6809,17 @@ async function forward(
// opt-in #371 fake-completion backstop buffers + retries first, same as
// proxy mode (#473).
if (prepared?.pluginMode) {
+ // m00885 provenance gate: the request body is where the kernel
+ // injects its "[ACP absorb]" instruction, so only an absorb-instructed
+ // request may have its whole-field tool-call prose dropped. wireBody
+ // is the exact shipped bytes (string or Buffer — .includes(string)
+ // works on both).
+ const absorbInstructed = wireBody.includes(ABSORB_INSTRUCTION_MARKER);
+ // m00885: the shipped request text doubles as the echo provenance — a
+ // tool-call-shaped span the user asked to output verbatim sits in the
+ // request, so an identical span in the response is an echo, not a
+ // model-invented emission.
+ const wireBodyText = typeof wireBody === "string" ? wireBody : wireBody.toString("utf8");
// #411: clear the idle timer on every path — resolveFakeCompletion and
// other failures still escape these pipes; without a finally each one
// leaked a live idle timer. (#721: the SSE pipes themselves no longer
@@ -6857,6 +6868,8 @@ async function forward(
label: prepared.session.id,
}),
targetOrigin,
+ absorbInstructed,
+ wireBodyText,
);
} else {
// #732/#821: the plugin pipe re-issues the agent's own body
@@ -6881,10 +6894,12 @@ async function forward(
label: prepared.session.id,
}),
targetOrigin,
+ absorbInstructed,
+ wireBodyText,
);
}
} else {
- await pipePluginJson(pluginBody, res, prepared.session, prepared.protocol, targetOrigin);
+ await pipePluginJson(pluginBody, res, prepared.session, prepared.protocol, targetOrigin, absorbInstructed, wireBodyText);
}
} finally {
clearUpstreamTimer();
@@ -7101,7 +7116,7 @@ async function forward(
: "";
const visibilityMarkers = resolveCompress(opts.routes, route?.rewrittenUrl, (parsedReq as { model?: string }).model, opts.compress).visibilityMarkers ?? true;
const systemPrompt = withMarkerIntegrityNote(withSummaryBudgetNote(textProtocol ? buildCompressHybridSystemPrompt(prepared.prompts ?? defaultPrompts, prepared.surface?.promptSections) : buildCompressSystemPrompt(prepared.prompts ?? defaultPrompts, prepared.surface?.promptSections)), visibilityMarkers) + absorbSection;
- const adapter = pickAdapter(prepared.protocol, parsedReq, textProtocol, prepared.responsesProjection, prepared.anthropicSystem, prepared.openaiSystemText, absorbActive ? absorbToolName(loopConfig) : undefined, prepared.google, prepared.systemNotes, opts.streamErrorShape, prepared.anthropicCacheMarks);
+ const adapter = pickAdapter(prepared.protocol, parsedReq, textProtocol, prepared.responsesProjection, prepared.anthropicSystem, prepared.openaiSystemText, absorbActive ? absorbToolName(loopConfig) : undefined, prepared.google, prepared.systemNotes, opts.streamErrorShape, prepared.anthropicCacheMarks, absorbActive);
const refreshFolded = async (current: CoreMessage[]): Promise => {
return withSessionLock(prepared.session, async () => {
// #422: mirror the prepare's fold with the post-compress state so
diff --git a/src/stream-google.ts b/src/stream-google.ts
index f67528f0a5..a6a5668893 100644
--- a/src/stream-google.ts
+++ b/src/stream-google.ts
@@ -1,11 +1,11 @@
import type { CompressionCore, Config, CoreMessage } from "acp-kernel";
import type { GooglePart } from "acp-kernel/wire";
import type { Session } from "./session.js";
-import { isProxyToolFor } from "./absorb.js";
+import { effectiveAbsorbConfig, isProxyToolFor } from "./absorb.js";
import { executeProxyTool } from "./loop/core.js";
import { drainPendingRetrievals } from "./store.js";
import type { RewriteCtx } from "./stream.js";
-import { containsBiliInternalText, containsMarkerLineText, containsRenderTagText, stripAcpTags } from "./loop/tag-echo-filter.js";
+import { containsBiliInternalText, containsMarkerLineText, containsRenderTagText, containsToolCallEmissionText, stripAcpTags } from "./loop/tag-echo-filter.js";
export function rewriteGoogleJsonResponse(body: unknown, ctx: RewriteCtx): unknown {
if (!body || typeof body !== "object") return body;
@@ -20,6 +20,10 @@ export function rewriteGoogleJsonResponse(body: unknown, ctx: RewriteCtx): unkno
let sawReal = false;
const noteParts: string[] = [];
const keptParts: GooglePart[] = [];
+ // Absorb signature in whole text (m00885): drop only when the request
+ // actually instructed the model about absorb.
+ const absorbArmed = effectiveAbsorbConfig(ctx.session, ctx.config)?.enabled === true;
+ const requestText = JSON.stringify(ctx.messages);
for (const part of parts) {
if (!part || typeof part !== "object") continue;
const fc = part.functionCall as { name?: unknown; args?: unknown; id?: unknown } | undefined;
@@ -30,9 +34,9 @@ export function rewriteGoogleJsonResponse(body: unknown, ctx: RewriteCtx): unkno
continue;
}
if (fc) sawReal = true;
- if (typeof part.text === "string" && (containsRenderTagText(part.text) || containsMarkerLineText(part.text) || containsBiliInternalText(part.text))) {
+ if (typeof part.text === "string" && (containsRenderTagText(part.text) || containsMarkerLineText(part.text) || containsBiliInternalText(part.text) || (absorbArmed && containsToolCallEmissionText(part.text)))) {
ctx.log(`[warn: tag echo] non-stream google output contains ACP echo (render tags/markers/internal artifacts), stripped: ${part.text.slice(0, 120).replace(/\n/g, " ")}`);
- part.text = stripAcpTags(part.text);
+ part.text = stripAcpTags(part.text, absorbArmed, requestText);
}
keptParts.push(part);
}
diff --git a/src/stream-openai.ts b/src/stream-openai.ts
index 39a66555c9..31c7cab64a 100644
--- a/src/stream-openai.ts
+++ b/src/stream-openai.ts
@@ -2,7 +2,8 @@ import type { CompressionCore, Config, CoreMessage } from "acp-kernel";
import type { Session } from "./session.js";
import { COMPRESS_TOOL_NAME, parseCompressInput } from "./compress-tool.js";
import { applyRanges, type RewriteCtx } from "./stream.js";
-import { containsBiliInternalText, containsMarkerLineText, containsRenderTagText, stripAcpTags } from "./loop/tag-echo-filter.js";
+import { effectiveAbsorbConfig } from "./absorb.js";
+import { containsBiliInternalText, containsMarkerLineText, containsRenderTagText, containsToolCallEmissionText, stripAcpTags } from "./loop/tag-echo-filter.js";
export function rewriteOpenaiJsonResponse(body: unknown, ctx: RewriteCtx): unknown {
if (!body || typeof body !== "object") return body;
@@ -41,9 +42,14 @@ export function rewriteOpenaiJsonResponse(body: unknown, ctx: RewriteCtx): unkno
ctx.log(`[warn: nameless tool call] non-stream openai response carries ${namelessToolCallIdx.length} nameless tool_call(s) at index ${namelessToolCallIdx.join(",")} — forwarded verbatim (#1501 observe-only)`);
}
}
- if (existingText && (containsRenderTagText(existingText) || containsMarkerLineText(existingText) || containsBiliInternalText(existingText))) {
+ // Absorb signature in whole text (m00885): drop only when the request
+ // actually instructed the model about absorb — the shape check alone
+ // cannot tell an emission from a user-quoted fragment.
+ const absorbArmed = effectiveAbsorbConfig(ctx.session, ctx.config)?.enabled === true;
+ const requestText = JSON.stringify(ctx.messages);
+ if (existingText && (containsRenderTagText(existingText) || containsMarkerLineText(existingText) || containsBiliInternalText(existingText) || (absorbArmed && containsToolCallEmissionText(existingText)))) {
ctx.log(`[warn: tag echo] non-stream openai output contains ACP echo (render tags/markers/internal artifacts), stripped: ${existingText.slice(0, 120).replace(/\n/g, " ")}`);
- existingText = stripAcpTags(existingText);
+ existingText = stripAcpTags(existingText, absorbArmed, requestText);
msg.content = existingText;
}
if (!converted) return body;
diff --git a/src/stream-responses.ts b/src/stream-responses.ts
index 8442681c31..a56390a1e9 100644
--- a/src/stream-responses.ts
+++ b/src/stream-responses.ts
@@ -2,7 +2,8 @@ import type { CompressionCore, Config, CoreMessage } from "acp-kernel";
import type { Session } from "./session.js";
import { COMPRESS_TOOL_NAME, parseCompressInput } from "./compress-tool.js";
import { applyRanges, type RewriteCtx } from "./stream.js";
-import { containsBiliInternalText, containsMarkerLineText, containsRenderTagText, stripResponsesText } from "./loop/tag-echo-filter.js";
+import { effectiveAbsorbConfig } from "./absorb.js";
+import { containsBiliInternalText, containsMarkerLineText, containsRenderTagText, containsToolCallEmissionText, stripResponsesText } from "./loop/tag-echo-filter.js";
/**
* Responses API (non-streaming) JSON rewriter: strips compress function_call
@@ -25,9 +26,13 @@ export function rewriteResponsesJsonResponse(body: unknown, ctx: RewriteCtx): un
// every body — before the compress note is synthesized (so the record we
// inject is never edited) and before the !converted early return below
// (which previously handed a tag-bearing body back untouched).
- if (containsRenderTagText(probe) || containsMarkerLineText(probe) || containsBiliInternalText(probe)) {
+ // Absorb signature in whole text (m00885): drop only when the request
+ // actually instructed the model about absorb.
+ const absorbArmed = effectiveAbsorbConfig(ctx.session, ctx.config)?.enabled === true;
+ const requestText = JSON.stringify(ctx.messages);
+ if (containsRenderTagText(probe) || containsMarkerLineText(probe) || containsBiliInternalText(probe) || (absorbArmed && containsToolCallEmissionText(probe))) {
ctx.log(`[warn: tag echo] non-stream responses output contains ACP echo (render tags/markers/internal artifacts), stripped: ${probe.slice(0, 120).replace(/\n/g, " ")}`);
- stripResponsesText(b);
+ stripResponsesText(b, absorbArmed, requestText);
}
let converted = false;
let sawReal = false;
diff --git a/src/stream.ts b/src/stream.ts
index 6a21a2896c..ed5e3c2c5c 100644
--- a/src/stream.ts
+++ b/src/stream.ts
@@ -8,7 +8,7 @@ import { effectiveAbsorbConfig, executeAbsorb, isProxyToolFor } from "./absorb.j
import { executeSearchContextTarget, resolveDecompress } from "./decompress-shared.js";
import { adoptContentStore, contentStoreOf, ccrEnabled, drainPendingRetrievals, executeRetrieve, retrieveToolName } from "./store.js";
import { IMAGE_FULL_TOOL_NAME, executeImageFull, imageCompressionEnabled } from "./image-compress.js";
-import { containsBiliInternalText, containsMarkerLineText, containsRenderTagText, stripAcpTags } from "./loop/tag-echo-filter.js";
+import { containsBiliInternalText, containsMarkerLineText, containsRenderTagText, containsToolCallEmissionText, stripAcpTags } from "./loop/tag-echo-filter.js";
import { maxShrinkPerCompress } from "./fetch-util.js";
import { attachSubagentSessions, subagentSessionNote, subagentSessionsOf, syncSubagentSessions } from "./subagent-sessions.js";
import { safePrefix, safeSuffix, scrubLoneSurrogates } from "./text-safe.js";
@@ -596,11 +596,16 @@ export function rewriteJsonResponse(body: unknown, ctx: RewriteCtx): unknown {
}
b.content = newContent;
if (converted && !sawRealToolUse) b.stop_reason = "end_turn";
+ // Absorb signature in whole text (m00885): drop only when the request
+ // actually instructed the model about absorb — the shape check alone
+ // cannot tell an emission from a user-quoted fragment.
+ const absorbArmed = effectiveAbsorbConfig(ctx.session, ctx.config)?.enabled === true;
+ const requestText = JSON.stringify(ctx.messages);
for (const blk of newContent) {
const t = (blk as { type?: string; text?: string }).text;
- if (typeof t === "string" && (containsRenderTagText(t) || containsMarkerLineText(t) || containsBiliInternalText(t))) {
+ if (typeof t === "string" && (containsRenderTagText(t) || containsMarkerLineText(t) || containsBiliInternalText(t) || (absorbArmed && containsToolCallEmissionText(t)))) {
ctx.log(`[warn: tag echo] non-stream model output contains ACP echo (render tags/markers/internal artifacts), stripped: ${t.slice(0, 120).replace(/\n/g, " ")}`);
- (blk as { text?: string }).text = stripAcpTags(t);
+ (blk as { text?: string }).text = stripAcpTags(t, absorbArmed, requestText);
}
}
return body;
diff --git a/tests/absorb-emission.test.ts b/tests/absorb-emission.test.ts
new file mode 100644
index 0000000000..150844eb90
--- /dev/null
+++ b/tests/absorb-emission.test.ts
@@ -0,0 +1,402 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import type { Config, CoreMessage } from "acp-kernel";
+import { createCore, createInitialState } from "acp-kernel";
+import type { Session } from "../src/session.ts";
+import { runCompressLoop, createOpenaiAdapter } from "../src/loop/index.ts";
+import {
+ toolCallEmissionSpan,
+ isToolCallEmission,
+ isOrphanToolCallTail,
+ containsToolCallEmissionText,
+ emissionEchoesRequest,
+ toolCallOpenStatus,
+ mayStartToolCallEmission,
+ mayStartRenderTag,
+ stripAcpTags,
+ createTagEchoFilter,
+ stripOpenaiChatText,
+ stripAnthropicText,
+ stripResponsesText,
+} from "../src/loop/tag-echo-filter.ts";
+import { buildCompressSystemPrompt } from "../src/compress-tool.ts";
+
+const LT = "\x3c";
+const GT = ">";
+const TAG = (ref: string, tokens = 177) => `${LT}acp tokens="${tokens}" type="text">${ref}${LT}/acp>`;
+
+// The production hybrid emission (opencode session ses_efe4cfcbdffe,
+// 2026-10-03): the absorb tool call written as chat-template text in the
+// prose channel, standing alone in the field.
+const EMISSION =
+ `\n${LT}parameter=ref${GT}\nm00608\n${LT}/parameter${GT}\n` +
+ `${LT}parameter=summary${GT}\nconsume the read output\n${LT}/parameter${GT}\n` +
+ `${LT}/function${GT}\n${LT}/function_calls${GT}`;
+
+function makeCtx(id: string): {
+ core: ReturnType;
+ config: Config;
+ messages: CoreMessage[];
+ session: Session;
+ log: (m: string) => void;
+} {
+ return {
+ core: createCore(),
+ config: { modelContextLimit: 200000 } as Config,
+ messages: [],
+ session: {
+ id,
+ meta: {},
+ stats: { requests: 0, tokensSaved: 0, inputTokens: 0, cachedTokens: 0, outputTokens: 0, cacheSamples: 0, lastInputTokens: 0, contextTokens: 0, compressCreditTokens: 0, retrieveCalls: 0, retrieveHits: 0, retrieveMisses: 0, storedBytes: 0, storeBytesSaved: 0, rangeRestores: 0 },
+ pendingRetrievals: [],
+ metadata: {},
+ state: createInitialState(),
+ createdAt: Date.now(),
+ lastSeen: Date.now(),
+ blockContents: new Map(),
+ inFlight: 0,
+ persisted: false,
+ },
+ log: () => {},
+ };
+}
+
+function sseFromStrings(parts: string[]): ReadableStream {
+ const encoder = new TextEncoder();
+ let i = 0;
+ return new ReadableStream({
+ pull(controller) {
+ if (i >= parts.length) {
+ controller.close();
+ return;
+ }
+ controller.enqueue(encoder.encode(parts[i++]));
+ },
+ });
+}
+
+async function drain(stream: ReadableStream, adapter: Parameters[4]): Promise {
+ const ctx = makeCtx("absorb-emission-test");
+ const chunks: Buffer[] = [];
+ for await (const chunk of runCompressLoop(stream, ctx, {}, { url: "http://mock", headers: {} }, adapter, buildCompressSystemPrompt())) {
+ chunks.push(chunk);
+ }
+ return Buffer.concat(chunks).toString("utf8");
+}
+
+function sseDelta(content: string): string {
+ return `data: ${JSON.stringify({ id: "c1", object: "chat.completion.chunk", created: 1, model: "gpt", choices: [{ index: 0, delta: { content }, finish_reason: null }] })}\n\n`;
+}
+
+function sseParts(content: string): string[] {
+ return [
+ `data: ${JSON.stringify({ id: "c1", object: "chat.completion.chunk", created: 1, model: "gpt", choices: [{ index: 0, delta: { role: "assistant" }, finish_reason: null }] })}\n\n`,
+ sseDelta(content),
+ `data: ${JSON.stringify({ id: "c1", object: "chat.completion.chunk", created: 1, model: "gpt", choices: [{ index: 0, delta: {}, finish_reason: "stop" }] })}\n\n`,
+ `data: [DONE]\n\n`,
+ ];
+}
+
+function contentOf(out: string): string {
+ return [...out.matchAll(/"content":"((?:[^"\\]|\\.)*)"/g)].map((m) => JSON.parse(`"${m[1]}"`) as string).join("");
+}
+
+// ─── shape recognition ──────────────────────────────────────────────────────
+
+test("toolCallEmissionSpan recognizes the production hybrid shape (category 1)", () => {
+ const span = toolCallEmissionSpan(EMISSION);
+ assert.ok(span !== null);
+ assert.equal(span!.start, 1);
+ assert.equal(span!.end, EMISSION.length);
+ assert.equal(isToolCallEmission(EMISSION.trim()), true);
+});
+
+test("toolCallEmissionSpan keeps prose after the last close", () => {
+ const span = toolCallEmissionSpan(`\n ${EMISSION.trim()} and done.`);
+ assert.ok(span !== null);
+ assert.equal(span!.start, 3);
+ assert.equal(span!.end, 3 + EMISSION.trim().length);
+});
+
+test("toolCallEmissionSpan covers antml: and name= attribute forms (category 12)", () => {
+ const antml =
+ `${LT}antml:function_calls${GT}\n` +
+ `${LT}antml:parameter=ref${GT}\nm00101\n${LT}/antml:parameter${GT}\n` +
+ `${LT}antml:parameter=summary${GT}\ns\n${LT}/antml:parameter${GT}\n` +
+ `${LT}/antml:function${GT}\n${LT}/antml:function_calls${GT}`;
+ assert.ok(toolCallEmissionSpan(antml) !== null);
+ const named =
+ `${LT}function${GT}\n` +
+ `${LT}parameter name="ref"${GT} m00608 ${LT}/parameter${GT}\n` +
+ `${LT}parameter name="summary"${GT} s ${LT}/parameter${GT}\n` +
+ `${LT}/function${GT}`;
+ assert.ok(toolCallEmissionSpan(named) !== null);
+});
+
+test("toolCallEmissionSpan rejects non-emission fields", () => {
+ assert.equal(toolCallEmissionSpan("prose without markup"), null);
+ assert.equal(toolCallEmissionSpan(`${LT}parameter=ref${GT}abc123${LT}/parameter${GT}`), null);
+ assert.equal(toolCallEmissionSpan(`${LT}parameter=summary${GT}hello${LT}/parameter${GT}`), null);
+ assert.equal(toolCallEmissionSpan(
+ `mid ${LT}parameter=ref${GT}m00608${LT}/parameter${GT}${LT}parameter=summary${GT}s${LT}/parameter${GT}${LT}/function${GT}`
+ ), null);
+ // ref+summary signature without a call close is still the emission (span ends at the last close)
+ assert.equal(toolCallEmissionSpan(`${LT}parameter=ref${GT}m00608${LT}/parameter${GT}${LT}parameter=summary${GT}s${LT}/parameter${GT}`)!.end,
+ `${LT}parameter=ref${GT}m00608${LT}/parameter${GT}${LT}parameter=summary${GT}s${LT}/parameter${GT}`.length);
+ // no closes at all → not an emission
+ assert.equal(toolCallEmissionSpan(`${LT}parameter=ref${GT}m00608${LT}parameter=summary${GT}s`), null);
+});
+
+test("ordinary XML in the summary body does not defeat the shape (category 9)", () => {
+ const xml = EMISSION.replace("consume the read output", `${LT}div class="x"${GT}hi${LT}/div${GT}`);
+ assert.ok(isToolCallEmission(xml.trim()));
+ assert.equal(stripAcpTags(xml, true), "");
+ assert.equal(stripAcpTags(xml, false), xml);
+});
+
+// ─── stripAcpTags: armed drop, echo, not-armed ──────────────────────────────
+
+test("stripAcpTags drops the whole emission when armed (category 1)", () => {
+ assert.equal(stripAcpTags(EMISSION, true), "");
+ assert.equal(stripAcpTags(EMISSION.trim() + " and done.", true), " and done.");
+});
+
+test("stripAcpTags leaves the emission untouched when not armed (shape alone never decides)", () => {
+ assert.equal(stripAcpTags(EMISSION, false), EMISSION);
+ assert.equal(stripAcpTags(EMISSION), EMISSION);
+});
+
+test("stripAcpTags keeps an emission that echoes the request verbatim (m00885, category 10)", () => {
+ const requestText = JSON.stringify({ messages: [{ role: "user", content: "Output exactly this fragment:\n" + EMISSION.trim() }] });
+ assert.equal(stripAcpTags(EMISSION, true, requestText), EMISSION);
+});
+
+test("stripAcpTags drops a model-invented emission when the request quotes a different ref (m00885 negative)", () => {
+ const other = EMISSION.trim().replace("m00608", "m00999");
+ const requestText = JSON.stringify({ messages: [{ role: "user", content: "Output exactly this fragment:\n" + other }] });
+ assert.equal(stripAcpTags(EMISSION, true, requestText), "");
+});
+
+test("stripAcpTags armed: prose discussing the markup passes untouched (category 10)", () => {
+ const prose = `The markup looks like ${LT}parameter=ref${GT}m00608${LT}/parameter${GT} inside a call.`;
+ assert.equal(stripAcpTags(prose, true), prose);
+});
+
+test("stripAcpTags armed: legitimate HTML passes untouched (category 11)", () => {
+ assert.equal(stripAcpTags(`${LT}div class="x"${GT}hi${LT}/div${GT}`, true), `${LT}div class="x"${GT}hi${LT}/div${GT}`);
+});
+
+test("stripAcpTags armed: render tag adjacent to an emission (category 6)", () => {
+ assert.equal(stripAcpTags(EMISSION.trim() + ` ${TAG("m00155")}ok`, true), " ok");
+});
+
+test("mangled open is stripped and seen by the fast-path gate (family A, category 3)", () => {
+ assert.equal(stripAcpTags(`${LT}acp=1${GT}text`), "text");
+ assert.equal(stripAcpTags(`text${LT}/acp${GT}`), "text");
+ assert.ok(mayStartRenderTag(`${LT}acp=1${GT}`));
+ assert.ok(mayStartRenderTag(`${LT}acp=`));
+});
+
+// ─── emissionEchoesRequest ──────────────────────────────────────────────────
+
+test("emissionEchoesRequest: literal containment", () => {
+ assert.ok(emissionEchoesRequest(EMISSION.trim(), `prefix ${EMISSION.trim()} suffix`));
+});
+
+test("emissionEchoesRequest: JSON-escaped form of the same fragment", () => {
+ const requestText = JSON.stringify({ content: EMISSION.trim() });
+ assert.ok(emissionEchoesRequest(EMISSION.trim(), requestText));
+ assert.ok(!emissionEchoesRequest(EMISSION.trim(), JSON.stringify({ content: "nothing here" })));
+ assert.ok(!emissionEchoesRequest(EMISSION.trim(), undefined));
+ assert.ok(!emissionEchoesRequest(EMISSION.trim(), ""));
+});
+
+// ─── streaming filter ───────────────────────────────────────────────────────
+
+test("streaming: armed filter drops an emission split across chunks (category 4)", () => {
+ const f = createTagEchoFilter(undefined, true);
+ let out = "";
+ for (let i = 0; i < EMISSION.length; i += 7) out += f.push(EMISSION.slice(i, i + 7));
+ out += f.flush();
+ assert.equal(out, "");
+});
+
+test("streaming: armed filter drops the emission and keeps the trailing prose", () => {
+ const f = createTagEchoFilter(undefined, true);
+ let out = f.push(EMISSION.trim());
+ out += f.push(` ${TAG("m00155")}ok`);
+ out += f.flush();
+ assert.equal(out, " ok");
+});
+
+test("streaming: armed filter keeps a verbatim echo of the request's fragment (m00885)", () => {
+ const requestText = JSON.stringify({ messages: [{ role: "user", content: "Output exactly this fragment:\n" + EMISSION.trim() }] });
+ const f = createTagEchoFilter(undefined, true, requestText);
+ let out = "";
+ for (let i = 0; i < EMISSION.length; i += 11) out += f.push(EMISSION.slice(i, i + 11));
+ out += f.flush();
+ assert.equal(out, EMISSION);
+});
+
+test("streaming: armed filter keeps prose heads flowing immediately (no delay, no loss)", () => {
+ const f = createTagEchoFilter(undefined, true);
+ assert.equal(f.push("Hello "), "Hello ");
+ assert.equal(f.push("world."), "world.");
+ assert.equal(f.flush(), "");
+});
+
+test("streaming: armed filter disambiguates from {
+ const f = createTagEchoFilter(undefined, true);
+ let out = f.push(`${LT}paragraph${GT}`);
+ out += f.push(`hello${LT}/paragraph${GT}`);
+ out += f.flush();
+ assert.equal(out, `${LT}paragraph${GT}hello${LT}/paragraph${GT}`);
+});
+
+test("streaming: not-armed filter passes the emission through", () => {
+ const f = createTagEchoFilter();
+ let out = "";
+ for (let i = 0; i < EMISSION.length; i += 13) out += f.push(EMISSION.slice(i, i + 13));
+ out += f.flush();
+ assert.equal(out, EMISSION);
+});
+
+// ─── unit machinery ─────────────────────────────────────────────────────────
+
+test("toolCallOpenStatus: open / prefix / none", () => {
+ assert.equal(toolCallOpenStatus(`${LT}parameter=ref${GT}`), "open");
+ assert.equal(toolCallOpenStatus(`${LT}function${GT}`), "open");
+ assert.equal(toolCallOpenStatus(`${LT}function `), "open");
+ assert.equal(toolCallOpenStatus(`${LT}parameter`), "prefix");
+ assert.equal(toolCallOpenStatus(`${LT}para`), "prefix");
+ assert.equal(toolCallOpenStatus(`${LT}p`), "prefix");
+ assert.equal(toolCallOpenStatus(`${LT}`), "prefix");
+ assert.equal(toolCallOpenStatus(`${LT}div${GT}hi${LT}/div${GT}`), "none");
+ assert.equal(toolCallOpenStatus(`${LT}paragraph${GT}`), "none");
+ assert.equal(toolCallOpenStatus(`${LT}/function${GT}`), "none");
+ assert.equal(toolCallOpenStatus(`${LT}antml:function`), "prefix");
+ assert.equal(toolCallOpenStatus(`${LT}antml:function `), "open");
+});
+
+test("mayStartToolCallEmission flags chunks containing or ending on a tool-call open", () => {
+ assert.ok(mayStartToolCallEmission(`x ${LT}function_calls`));
+ assert.ok(mayStartToolCallEmission(`${LT}antml:parameter=ref`));
+ assert.ok(!mayStartToolCallEmission("no markup here"));
+ assert.ok(!mayStartToolCallEmission(`${LT}div${GT}hi${LT}/div${GT}`));
+});
+
+test("isOrphanToolCallTail: close-headed field of refs and whitespace only (category 7)", () => {
+ assert.ok(isOrphanToolCallTail(`${LT}/function${GT}\nm00608\n${LT}/parameter${GT}`));
+ assert.ok(isOrphanToolCallTail(`${LT}/function_calls${GT}m00608`));
+ assert.ok(!isOrphanToolCallTail(`${LT}/function${GT}hello there`));
+ assert.ok(!isOrphanToolCallTail(`${LT}parameter=ref${GT}m00608${LT}/parameter${GT}`));
+ assert.ok(!isOrphanToolCallTail("m00608 only"));
+});
+
+test("containsToolCallEmissionText sees the emission shape in raw JSON wire text (category 13)", () => {
+ assert.ok(containsToolCallEmissionText(JSON.stringify({ content: EMISSION.trim() })));
+ assert.ok(!containsToolCallEmissionText(JSON.stringify({ content: "plain prose" })));
+});
+
+// ─── JSON field strippers ───────────────────────────────────────────────────
+
+type OpenAiBody = {
+ choices: Array<{
+ delta?: { content?: string; reasoning_content?: string; reasoning?: string };
+ message?: { content?: string; reasoning_content?: string; reasoning?: string };
+ }>;
+};
+
+test("stripOpenaiChatText: armed drop / echo / not-armed (delta and message)", () => {
+ const make = (): OpenAiBody => JSON.parse(JSON.stringify({
+ choices: [
+ { delta: { content: EMISSION, reasoning_content: EMISSION } },
+ { message: { content: EMISSION } },
+ ],
+ }));
+ const armed = stripOpenaiChatText(make(), true);
+ assert.equal(armed.choices[0].delta?.content, "");
+ assert.equal(armed.choices[0].delta?.reasoning_content, "");
+ assert.equal(armed.choices[1].message?.content, "");
+ const echo = JSON.stringify({ messages: [{ role: "user", content: EMISSION.trim() }] });
+ const kept = stripOpenaiChatText(make(), true, echo);
+ assert.equal(kept.choices[0].delta?.content, EMISSION);
+ assert.equal(kept.choices[1].message?.content, EMISSION);
+ const unarmed = stripOpenaiChatText(make(), false);
+ assert.equal(unarmed.choices[0].delta?.content, EMISSION);
+});
+
+type AnthropicBody = {
+ delta?: { type: string; thinking?: string; text?: string };
+ content?: Array<{ type: string; thinking?: string; text?: string }>;
+};
+
+test("stripAnthropicText: thinking channel gets the same treatment (category 8)", () => {
+ const make = (): AnthropicBody => JSON.parse(JSON.stringify({
+ delta: { type: "thinking_delta", thinking: EMISSION },
+ content: [
+ { type: "thinking", thinking: EMISSION },
+ { type: "text", text: EMISSION },
+ ],
+ }));
+ const armed = stripAnthropicText(make(), true);
+ assert.equal(armed.delta?.thinking, "");
+ assert.equal(armed.content![0].thinking, "");
+ assert.equal(armed.content![1].text, "");
+ const echo = JSON.stringify({ messages: [{ role: "user", content: EMISSION.trim() }] });
+ assert.equal(stripAnthropicText(make(), true, echo).delta?.thinking, EMISSION);
+ assert.equal(stripAnthropicText(make(), false).content![0].thinking, EMISSION);
+});
+
+type ResponsesEvent = {
+ type: string;
+ text?: string;
+ part?: { type: string; text?: string };
+ item?: { type: string; content?: Array<{ type: string; text?: string }> };
+ response?: { output?: Array<{ content?: Array<{ type: string; text?: string }> }> };
+ output?: Array<{ content?: Array<{ type: string; text?: string }> }>;
+};
+
+test("stripResponsesText: armed drop / echo / not-armed (category 13)", () => {
+ const make = (): ResponsesEvent => JSON.parse(JSON.stringify({
+ type: "response.output_text.done",
+ text: EMISSION,
+ part: { type: "output_text", text: EMISSION },
+ }));
+ const armed = stripResponsesText(make(), true);
+ assert.equal(armed.text, "");
+ assert.equal(armed.part?.text, "");
+ const echo = JSON.stringify({ messages: [{ role: "user", content: EMISSION.trim() }] });
+ assert.equal(stripResponsesText(make(), true, echo).text, EMISSION);
+ assert.equal(stripResponsesText(make(), false).text, EMISSION);
+ const done = (): ResponsesEvent => JSON.parse(JSON.stringify({
+ type: "response.completed",
+ response: { output: [{ content: [{ type: "output_text", text: EMISSION }] }] },
+ }));
+ assert.equal(stripResponsesText(done(), true).response?.output?.[0].content?.[0].text, "");
+});
+
+// ─── full loop through the real adapter (category 13) ──────────────────────
+
+test("openai adapter loop: armed drop removes the emission from the wire", async () => {
+ const adapter = createOpenaiAdapter({ model: "gpt" }, undefined, "absorb");
+ const out = await drain(sseFromStrings(sseParts(EMISSION.trim())), adapter);
+ assert.ok(!out.includes("parameter=ref"), out);
+ assert.equal(contentOf(out), "");
+});
+
+test("openai adapter loop: verbatim echo of the user's fragment survives armed (m00885, category 10)", async () => {
+ const reqBody = {
+ model: "gpt",
+ messages: [{ role: "user", content: "Output exactly this fragment and nothing else:\n" + EMISSION.trim() }],
+ };
+ const adapter = createOpenaiAdapter(reqBody, undefined, "absorb");
+ const out = await drain(sseFromStrings(sseParts(EMISSION.trim())), adapter);
+ assert.equal(contentOf(out), EMISSION.trim());
+});
+
+test("openai adapter loop: not-armed passes the emission through (shape alone never decides)", async () => {
+ const adapter = createOpenaiAdapter({ model: "gpt" });
+ const out = await drain(sseFromStrings(sseParts(EMISSION.trim())), adapter);
+ assert.equal(contentOf(out), EMISSION.trim());
+});
diff --git a/tests/nameless-toolcall-observability.test.ts b/tests/nameless-toolcall-observability.test.ts
index f8ac3c2a5a..466b9c1e19 100644
--- a/tests/nameless-toolcall-observability.test.ts
+++ b/tests/nameless-toolcall-observability.test.ts
@@ -23,6 +23,7 @@ function makeSession(): Session {
requests: 0,
lastInputTokens: 0,
stats: {},
+ metadata: {},
dirty: false,
} as unknown as Session;
}
From 5d1e6889390f6a8e2c745c735b802b7cb485e6da Mon Sep 17 00:00:00 2001
From: ework-agent
Date: Sun, 4 Oct 2026 23:23:59 +0800
Subject: [PATCH 04/16] fix: keep signed thinking/thought byte-for-byte across
non-streaming + plugin-passthrough paths (#1960)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
PR #2067 added whole-field emission-drop to the prose filters, and the
non-streaming / plugin-passthrough rewriters already applied render-tag +
marker + bili-artifact stripping to signed Anthropic `thinking` and Gemini
`thought` channels. Both can rewrite signature-verified bytes: on replay the
client echoes the modified thinking back with its original signature, which
desyncs and bricks the session (#1960/KDD#10). The loop streaming adapters
already keep these channels verbatim ("prose filters never touch thinking");
this aligns the remaining paths.
- createIdentityStreamFilter(): pass-through filter with honest char accounting
(keeps the #673 degenerate-turn stats correct) for signed channels.
- pipePluginChatWithStrip: route anthropic/google `thinking` through the
identity filter instead of the prose-filter stack.
- stripAnthropicText: leave delta.thinking / content[].thinking byte-for-byte
(the text channel is still stripped).
- rewriteGoogleJsonResponse + stripGoogleChunk: skip `thought` parts.
OpenAI/Responses reasoning is not byte-signature-verified, so it stays stripped
as before.
Behavior change (old -> new): model-emitted render tags / markers / whole-field
emissions inside SIGNED thinking or Gemini thought parts are no longer stripped
on the plugin-passthrough and non-streaming wire paths — they now ride
byte-for-byte, matching the loop adapters. Cosmetic tag echoes may remain inside
thinking panes (accepted per #1881/#1960); replay no longer risks a signature
mismatch.
Tests updated to pin the corrected contract:
- absorb-emission.test.ts (category 8)
- plugin-passthrough-tag-strip-chat.test.ts (anthropic thinking_delta case)
---
src/loop/tag-echo-filter.ts | 35 +++++++++++++++----
src/plugin.ts | 12 +++++--
src/stream-google.ts | 5 ++-
tests/absorb-emission.test.ts | 15 ++++----
.../plugin-passthrough-tag-strip-chat.test.ts | 7 ++--
5 files changed, 55 insertions(+), 19 deletions(-)
diff --git a/src/loop/tag-echo-filter.ts b/src/loop/tag-echo-filter.ts
index e0fae8ed1b..bc75ff81e9 100644
--- a/src/loop/tag-echo-filter.ts
+++ b/src/loop/tag-echo-filter.ts
@@ -1034,9 +1034,12 @@ export function stripOpenaiChatText(obj: T, drop: boolean = false, requestTex
return obj;
}
-// Plugin-passthrough parity for the Anthropic wire: strip `delta.{text,
-// thinking}` on content_block_delta streams and `content[].{text,thinking}`
-// on non-streaming message bodies. Mutates in place.
+// Plugin-passthrough parity for the Anthropic wire: strip `delta.text` on
+// content_block_delta streams and `content[].text` on non-streaming message
+// bodies. Signed `thinking` / `redacted_thinking` blocks are LEFT byte-for-byte
+// (#1960/KDD#10): they are verified against their signature on replay, so any
+// rewrite desyncs them and bricks the session — matching the loop adapters'
+// "prose filters never touch thinking" treatment. Mutates in place.
export function stripAnthropicText(obj: T, drop: boolean = false, requestText?: string): T {
if (!obj || typeof obj !== "object") return obj;
const o = obj as Record;
@@ -1044,15 +1047,14 @@ export function stripAnthropicText(obj: T, drop: boolean = false, requestText
if (d && typeof d === "object") {
const dd = { ...(d as Record) };
dd["text"] = stripIfString(dd["text"], drop, requestText);
- dd["thinking"] = stripIfString(dd["thinking"], drop, requestText);
o["delta"] = dd;
}
if (Array.isArray(o["content"])) {
o["content"] = (o["content"] as unknown[]).map((c) => {
if (!c || typeof c !== "object") return c;
const cc = c as Record;
- if (typeof cc["text"] !== "string" && typeof cc["thinking"] !== "string") return c;
- return { ...cc, text: stripIfString(cc["text"], drop, requestText), thinking: stripIfString(cc["thinking"], drop, requestText) };
+ if (typeof cc["text"] !== "string") return c;
+ return { ...cc, text: stripIfString(cc["text"], drop, requestText) };
});
}
return obj;
@@ -1197,3 +1199,24 @@ export function composeStreamFilters(a: TagEchoFilter, b: TagEchoFilter): TagEch
}),
};
}
+
+// #1960/KDD#10 — signature-verified channels (signed Anthropic `thinking`
+// deltas, Gemini `thought` parts) must ride byte-for-byte: any rewrite
+// desyncs them from their signature and bricks replay. This identity filter
+// passes every delta through unchanged while keeping honest char accounting,
+// so degenerate-turn detection (#673) still sees real input/output sizes.
+export function createIdentityStreamFilter(): TagEchoFilter {
+ let inputChars = 0;
+ let outputChars = 0;
+ return {
+ push: (delta: string) => {
+ inputChars += delta.length;
+ outputChars += delta.length;
+ return delta;
+ },
+ flush: () => "",
+ dropped: () => false,
+ pending: () => false,
+ stats: () => ({ inputChars, outputChars, dropped: false }),
+ };
+}
diff --git a/src/plugin.ts b/src/plugin.ts
index 0fee48d5c8..143e1525f0 100644
--- a/src/plugin.ts
+++ b/src/plugin.ts
@@ -15,7 +15,7 @@ import { absorbEnabled, effectiveAbsorbConfig, isProxyToolFor } from "./absorb.j
import { effectiveRulesEnabled, rulesEnabled } from "./rules-feature.js";
import { executeProxyTool } from "./loop/core.js";
import { normalizeSseLineEndings } from "./sse-util.js";
-import { composeStreamFilters, containsBiliInternalText, containsMarkerLineText, containsRenderTagText, containsToolCallEmissionText, containsToolCallXmlFragment, createBiliArtifactFilter, createMarkerLineFilter, createTagEchoFilter, isOrphanMarkupText, mayStartBiliInternal, mayStartMarkerLine, mayStartRenderTag, mayStartToolCallEmission, stripAcpTags, stripAnthropicText, stripOpenaiChatText, stripResponsesText, type TagEchoFilter } from "./loop/tag-echo-filter.js";
+import { composeStreamFilters, containsBiliInternalText, containsMarkerLineText, containsRenderTagText, containsToolCallEmissionText, containsToolCallXmlFragment, createBiliArtifactFilter, createIdentityStreamFilter, createMarkerLineFilter, createTagEchoFilter, isOrphanMarkupText, mayStartBiliInternal, mayStartMarkerLine, mayStartRenderTag, mayStartToolCallEmission, stripAcpTags, stripAnthropicText, stripOpenaiChatText, stripResponsesText, type TagEchoFilter } from "./loop/tag-echo-filter.js";
import { log as loggerLog } from "./logger.js";
import { ccrEnabled, ccrLoopConfig, contentStoreOf, retrieveToolName } from "./store.js";
import { imageUsageSuffix } from "./image-compress.js";
@@ -1758,7 +1758,12 @@ export async function pipePluginChatWithStrip(
const key = `${field}:${index}`;
let s = streams.get(key);
if (!s) {
- s = { filter: composeStreamFilters(composeStreamFilters(createTagEchoFilter(onTagDrop, absorbInstructed, requestText), createMarkerLineFilter(onMarkerDrop)), createBiliArtifactFilter(onBiliDrop)), field, index };
+ // #1960/KDD#10: signed thinking (Anthropic `thinking_delta`, Gemini
+ // `thought` parts) must ride byte-for-byte — any rewrite desyncs its
+ // signature and bricks replay. Route it through an identity filter
+ // instead of the prose filters (matches the loop adapters).
+ const signedThinking = (protocol === "anthropic" || protocol === "google") && field === "thinking";
+ s = { filter: signedThinking ? createIdentityStreamFilter() : composeStreamFilters(composeStreamFilters(createTagEchoFilter(onTagDrop, absorbInstructed, requestText), createMarkerLineFilter(onMarkerDrop)), createBiliArtifactFilter(onBiliDrop)), field, index };
streams.set(key, s);
}
return s;
@@ -3141,7 +3146,8 @@ function stripGoogleChunk(obj: T, drop: boolean = false, requestText?: string
content: {
...cont,
parts: (cont["parts"] as unknown[]).map((p) =>
- p && typeof p === "object" && typeof (p as Record)["text"] === "string"
+ // #1960/KDD#10: thought parts carry a thoughtSignature — leave them byte-for-byte.
+ p && typeof p === "object" && (p as Record)["thought"] !== true && typeof (p as Record)["text"] === "string"
? { ...(p as Record), text: stripAcpTags((p as Record)["text"] as string, drop, requestText) }
: p,
),
diff --git a/src/stream-google.ts b/src/stream-google.ts
index a6a5668893..d0839a4714 100644
--- a/src/stream-google.ts
+++ b/src/stream-google.ts
@@ -34,7 +34,10 @@ export function rewriteGoogleJsonResponse(body: unknown, ctx: RewriteCtx): unkno
continue;
}
if (fc) sawReal = true;
- if (typeof part.text === "string" && (containsRenderTagText(part.text) || containsMarkerLineText(part.text) || containsBiliInternalText(part.text) || (absorbArmed && containsToolCallEmissionText(part.text)))) {
+ // #1960/KDD#10: a thought part carries a thoughtSignature the client
+ // echoes back verbatim — rewriting its text desyncs the signature and
+ // bricks replay. Strip prose only from non-thought parts.
+ if ((part as { thought?: boolean }).thought !== true && typeof part.text === "string" && (containsRenderTagText(part.text) || containsMarkerLineText(part.text) || containsBiliInternalText(part.text) || (absorbArmed && containsToolCallEmissionText(part.text)))) {
ctx.log(`[warn: tag echo] non-stream google output contains ACP echo (render tags/markers/internal artifacts), stripped: ${part.text.slice(0, 120).replace(/\n/g, " ")}`);
part.text = stripAcpTags(part.text, absorbArmed, requestText);
}
diff --git a/tests/absorb-emission.test.ts b/tests/absorb-emission.test.ts
index 150844eb90..2d88615b9f 100644
--- a/tests/absorb-emission.test.ts
+++ b/tests/absorb-emission.test.ts
@@ -331,7 +331,7 @@ type AnthropicBody = {
content?: Array<{ type: string; thinking?: string; text?: string }>;
};
-test("stripAnthropicText: thinking channel gets the same treatment (category 8)", () => {
+test("stripAnthropicText: signed thinking stays byte-for-byte even when armed (#1960)", () => {
const make = (): AnthropicBody => JSON.parse(JSON.stringify({
delta: { type: "thinking_delta", thinking: EMISSION },
content: [
@@ -339,13 +339,14 @@ test("stripAnthropicText: thinking channel gets the same treatment (category 8)"
{ type: "text", text: EMISSION },
],
}));
+ // #1960/KDD#10: signed thinking is verified against its signature on replay —
+ // any rewrite desyncs it and bricks the session. So the emission drop and tag
+ // strip apply to the TEXT channel only; thinking rides byte-for-byte whether
+ // armed or not (matching the loop adapters' treatment).
const armed = stripAnthropicText(make(), true);
- assert.equal(armed.delta?.thinking, "");
- assert.equal(armed.content![0].thinking, "");
- assert.equal(armed.content![1].text, "");
- const echo = JSON.stringify({ messages: [{ role: "user", content: EMISSION.trim() }] });
- assert.equal(stripAnthropicText(make(), true, echo).delta?.thinking, EMISSION);
- assert.equal(stripAnthropicText(make(), false).content![0].thinking, EMISSION);
+ assert.equal(armed.delta?.thinking, EMISSION, "armed leaves the signed thinking delta byte-for-byte");
+ assert.equal(armed.content![0].thinking, EMISSION, "armed leaves the signed thinking block byte-for-byte");
+ assert.equal(armed.content![1].text, "", "text channel still drops the whole emission when armed");
});
type ResponsesEvent = {
diff --git a/tests/plugin-passthrough-tag-strip-chat.test.ts b/tests/plugin-passthrough-tag-strip-chat.test.ts
index 6b6207e301..20b0329b80 100644
--- a/tests/plugin-passthrough-tag-strip-chat.test.ts
+++ b/tests/plugin-passthrough-tag-strip-chat.test.ts
@@ -233,7 +233,7 @@ test("plugin chat passthrough resolves held tail at stream end without [DONE]",
assert.ok(!text.includes("m0"), "unclosed tag content dropped at stream end");
});
-test("plugin anthropic passthrough strips render tags from text_delta and thinking_delta", async () => {
+test("plugin anthropic passthrough strips render tags from text_delta but keeps signed thinking_delta byte-for-byte (#1960)", async () => {
const out: string[] = [];
const res = makeRes(out);
const session = makeSession();
@@ -246,7 +246,10 @@ test("plugin anthropic passthrough strips render tags from text_delta and thinki
];
await pipePluginChatWithStrip(streamOf(events), res, "anthropic", session);
const text = out.join("");
- assert.ok(!text.includes("m00009") && !text.includes("m00010"), "render tags stripped from both delta types");
+ // #1960/KDD#10: signed thinking rides byte-for-byte — rewriting it desyncs
+ // its signature and bricks replay. Only the text channel is stripped.
+ assert.ok(text.includes("m00009"), "signed thinking_delta stays byte-for-byte (#1960)");
+ assert.ok(!text.includes("m00010"), "render tags stripped from the text channel");
assert.ok(text.includes("hi bye"), "text prose survives");
assert.ok(text.includes("hmm "), "thinking prose survives");
assert.equal((session.stats as Record)["lastInputTokens"], 42, "usage sampled from message_start");
From cb4020644b706e6c03f772dc4f6f9160e2231e29 Mon Sep 17 00:00:00 2001
From: ework-agent
Date: Tue, 6 Oct 2026 01:26:58 +0800
Subject: [PATCH 05/16] fix(#2190): strip model-emitted degenerate-close echo
residue
Models imitate ACP render tags with drifted close names (field census:
ap/p/a/apc/cap/ck/div/warn/aph/ambient/apm) that no matcher recognizes.
The stream filter then swallows the open tag, hits its budget or EOF,
and either releases the 'mNNNNN' residue verbatim (mid-stream)
or silently drops the following prose (flush). Whole-text stripAcpTags
had no pair rule for degenerate closes either.
- swallow mode now accepts any short close name as terminator when the
body since the opening is exactly one bare ref (degenCloseAfterRef);
wrapped-imitation mode is excluded (payload may hold arbitrary markup)
- stripAcpTags gains DEGEN_PAIR: acplike open + bare ref + any short
close removed atomically, before the lone passes
- fast path gains mayStartDegenerateRenderTag (broad , ori
composeStreamFilters(
createTagEchoFilter((snippet) => {
loggerLog("warn", `[tag-echo] stripped model-emitted render tag: ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
+ }, (snippet) => {
+ // #2190: residue audit — log-only, see plugin.ts twins.
+ loggerLog("warn", `[tag-echo] filter released echo-residue-shaped bytes (#2190): ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
}),
createMarkerLineFilter((snippet) => {
loggerLog("warn", `[marker-echo] stripped model-emitted ACP confirmation marker: ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
diff --git a/src/loop/adapter-google.ts b/src/loop/adapter-google.ts
index bc10dbb358..8024552b8f 100644
--- a/src/loop/adapter-google.ts
+++ b/src/loop/adapter-google.ts
@@ -298,6 +298,9 @@ export function createGoogleAdapter(
composeStreamFilters(
createTagEchoFilter((snippet) => {
loggerLog("warn", `[tag-echo] stripped model-emitted render tag: ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
+ }, (snippet) => {
+ // #2190: residue audit — log-only, see plugin.ts twins.
+ loggerLog("warn", `[tag-echo] filter released echo-residue-shaped bytes (#2190): ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
}),
createMarkerLineFilter((snippet) => {
loggerLog("warn", `[marker-echo] stripped model-emitted ACP confirmation marker: ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
diff --git a/src/loop/adapter-openai.ts b/src/loop/adapter-openai.ts
index 3ffb7e0b75..a0cc58970a 100644
--- a/src/loop/adapter-openai.ts
+++ b/src/loop/adapter-openai.ts
@@ -253,6 +253,9 @@ export function createOpenaiAdapter(requestBody: Record, client
composeStreamFilters(
createTagEchoFilter((snippet) => {
loggerLog("warn", `[tag-echo] stripped model-emitted render tag: ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
+ }, (snippet) => {
+ // #2190: residue audit — log-only, see plugin.ts twins.
+ loggerLog("warn", `[tag-echo] filter released echo-residue-shaped bytes (#2190): ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
}),
createMarkerLineFilter((snippet) => {
loggerLog("warn", `[marker-echo] stripped model-emitted ACP confirmation marker: ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
diff --git a/src/loop/adapter-responses.ts b/src/loop/adapter-responses.ts
index 666953a08d..4d0eae8460 100644
--- a/src/loop/adapter-responses.ts
+++ b/src/loop/adapter-responses.ts
@@ -346,6 +346,9 @@ export function createResponsesAdapter(textProtocol?: boolean, projection?: Resp
composeStreamFilters(
createTagEchoFilter((snippet) => {
loggerLog("warn", `[tag-echo] stripped model-emitted render tag: ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
+ }, (snippet) => {
+ // #2190: residue audit — log-only, see plugin.ts twins.
+ loggerLog("warn", `[tag-echo] filter released echo-residue-shaped bytes (#2190): ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
}),
createMarkerLineFilter((snippet) => {
loggerLog("warn", `[marker-echo] stripped model-emitted ACP confirmation marker: ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
diff --git a/src/loop/tag-echo-filter.ts b/src/loop/tag-echo-filter.ts
index c9220d50c7..ee93ad81d2 100644
--- a/src/loop/tag-echo-filter.ts
+++ b/src/loop/tag-echo-filter.ts
@@ -90,6 +90,14 @@ const PAIRED = new RegExp("\x3c" + NAME + "(?:\\s[^<>]*)?>(\\s*m\\d{4,}\\s*)\x3c
const REF_LIKE = /^\s*m\d{4,}\s*$/;
const LONE_OPEN = new RegExp("\x3c" + NAME + "(?:\\s[^<>]*)?>");
const LONE_CLOSE = new RegExp("\x3c\\/" + NAME + "(?=[\\s>])[^<>]{0,32}>");
+// #2190: a ref body closed by a DEGENERATE close name (any short word — the
+// drift set is open; the attested census alone has p/a/ap/apc/cap/ck/div/
+// warn/aph/ambient/apm). Whole-span strip only: the open must be a valid
+// acplike name and the body exactly one bare ref, so genuine HTML prose such
+// as "see
" or "m1234 text" is untouched. Runs BEFORE the lone
+// passes in stripAcpTags so the pair dies atomically instead of leaving the
+// ref behind.
+const DEGEN_PAIR = new RegExp("\x3c" + NAME + "(?:\\s[^<>]*)?>\\s*m\\d{4,}\\s*\x3c\\/[a-zA-Z][a-zA-Z0-9]{0,15}>", "g");
// A suffix of the buffer that could still grow into a render tag: either an
// unterminated \x3c … opening (attrs so far, no \x3e yet) or a short
// ambiguous prefix like \x3c, \x3ca, \x3c/ac, \x3cacip, …
@@ -145,6 +153,25 @@ function looseCloseEnd(s: string): number {
const span = looseCloseSpan(s);
return span === null ? -1 : span.end;
}
+// #2190: models imitate the CLOSE with arbitrary short words instead of an
+// acplike name — field census (session-A, 2026-10-05): ap/p/a/apc/cap/ck/div/
+// warn/aph/ambient/apm, an open set a whitelist cannot keep up with. Accepted
+// as a swallow terminator ONLY when the whole body since the opening is one
+// bare ref (the kernel's emit shape, #1720): ref-body + any short close is an
+// echo, never prose — a prose body stays indistinguishable from legitimate
+// markup and keeps the existing hold/budget/flush behavior. Strict >
+// termination, same discipline as looseCloseSpan (a partial close at the
+// buffer end is still undecidable and stays held).
+const DEGEN_CLOSE_NAME = /^[a-zA-Z][a-zA-Z0-9]{0,15}>/;
+function degenCloseAfterRef(s: string): { start: number; end: number } | null {
+ let idx = s.indexOf(CLOSE_HEAD);
+ while (idx >= 0) {
+ const m = DEGEN_CLOSE_NAME.exec(s.slice(idx + 2));
+ if (m && REF_LIKE.test(s.slice(0, idx))) return { start: idx, end: idx + 2 + m[0].length };
+ idx = s.indexOf(CLOSE_HEAD, idx + 1);
+ }
+ return null;
+}
/** The span of one wrapped-turn imitation in `s`: where it starts, and the span
* that has to go — its head plus, when no loose close follows, the rest of the
@@ -244,6 +271,7 @@ export function stripAcpTags(text: string): string {
}
out = out
.replace(new RegExp(PAIRED.source, "g"), "")
+ .replace(DEGEN_PAIR, "")
.replace(new RegExp(LONE_OPEN.source, "g"), "")
.replace(new RegExp(LONE_CLOSE.source, "g"), "")
.replace(new RegExp(TRUNC_OPEN.source), "")
@@ -270,6 +298,16 @@ export function containsRenderTagText(s: string): boolean {
return RENDER_TAG_DETECT.test(s);
}
+// #2190: post-audit shape check — a bare ref immediately followed by ANY close
+// tag is echo residue by construction (genuine prose never puts mNNNNN right
+// before ; the kernel wraps refs in tags, so a naked ref IS the leak).
+// Used where bytes bypassed or escaped the filter and must be logged, not
+// dropped: fast-path gate sites and filter release points.
+const ECHO_RESIDUE = /m\d{4,}\s*\x3c\/[a-zA-Z]/;
+export function containsEchoResidue(s: string): boolean {
+ return ECHO_RESIDUE.test(s);
+}
+
// #468: some upstreams stream a model-imitated render tag in tokenizer-sized
// fragments ("\x3cac", "p tokens", ...) so no single chunk ever trips
// RENDER_TAG_DETECT. Per-chunk gates must also engage when the chunk contains
@@ -281,6 +319,19 @@ export function mayStartRenderTag(s: string): boolean {
return RENDER_TAG_DETECT.test(s) || PARTIAL_TAIL.test(s);
}
+// #2190: a BROADER ambiguous head, used by the streaming gate and the filter's
+// hold decision only. Degenerate imitations drift the name beyond the acplike
+// mutation set (the observed close census already proves free-form name drift),
+// so a head like \x3cck must engage the state machine or the rest of the tag
+// rides the fast path verbatim. Deliberately NOT folded into PARTIAL_TAIL /
+// mayStartRenderTag: isOrphanMarkupText (#1760) consumes those for
+// degenerate-turn accounting, where a prose tail such as "a void): Ta
};
}
-export function createTagEchoFilter(onDrop?: (snippet: string) => void): TagEchoFilter {
+export function createTagEchoFilter(onDrop?: (snippet: string) => void, onResidueWarn?: (snippet: string) => void): TagEchoFilter {
let held = "";
let swallowUntilClose = false;
let swallowed = "";
@@ -574,11 +625,27 @@ export function createTagEchoFilter(onDrop?: (snippet: string) => void): TagEcho
buf = combined.slice(span.end);
continue;
}
+ if (swallowReleases) {
+ // #2190: a degenerate close ends the span too. The body is
+ // ref-shaped by construction (degenCloseAfterRef), so the
+ // drop-whole rule applies unconditionally — wrapped mode
+ // never reaches here (its payload may contain arbitrary
+ // markup and must be discarded whole).
+ const dspan = degenCloseAfterRef(combined);
+ if (dspan !== null) {
+ drop(combined.slice(0, dspan.end));
+ swallowed = "";
+ swallowUntilClose = false;
+ buf = combined.slice(dspan.end);
+ continue;
+ }
+ }
if (combined.length > swallowLimit) {
swallowed = "";
if (swallowReleases) {
swallowUntilClose = false;
buf = combined;
+ if (onResidueWarn && containsEchoResidue(combined)) onResidueWarn(combined);
continue;
}
// The span is an attested imitation's payload: discard it and
@@ -623,7 +690,7 @@ export function createTagEchoFilter(onDrop?: (snippet: string) => void): TagEcho
continue;
}
if (!m) {
- const t = PARTIAL_TAIL.exec(buf);
+ const t = PARTIAL_TAIL.exec(buf) ?? BROAD_TAG_HEAD_TAIL.exec(buf);
if (t) {
// A definite \x3c opening is never prose — hold it far
// past HOLD_LIMIT (drop it past TAG_OPEN_CAP); a short
@@ -641,6 +708,7 @@ export function createTagEchoFilter(onDrop?: (snippet: string) => void): TagEcho
out += buf;
}
} else {
+ if (onResidueWarn && containsEchoResidue(buf)) onResidueWarn(buf);
out += buf;
}
break;
@@ -732,6 +800,7 @@ export function createTagEchoFilter(onDrop?: (snippet: string) => void): TagEcho
}
}
}
+ if (result.length > 0 && onResidueWarn && containsEchoResidue(result)) onResidueWarn(result);
outputChars += result.length;
return result;
},
diff --git a/src/plugin.ts b/src/plugin.ts
index 84e6314c9c..673c00d9e9 100644
--- a/src/plugin.ts
+++ b/src/plugin.ts
@@ -15,7 +15,7 @@ import { absorbEnabled, effectiveAbsorbConfig, isProxyToolFor } from "./absorb.j
import { effectiveRulesEnabled, rulesEnabled } from "./rules-feature.js";
import { executeProxyTool } from "./loop/core.js";
import { normalizeSseLineEndings } from "./sse-util.js";
-import { composeStreamFilters, containsBiliInternalText, containsMarkerLineText, containsRenderTagText, containsToolCallXmlFragment, createBiliArtifactFilter, createMarkerLineFilter, createTagEchoFilter, isOrphanMarkupText, mayStartBiliInternal, mayStartMarkerLine, mayStartRenderTag, stripAcpTags, stripAnthropicText, stripOpenaiChatText, stripResponsesText, type TagEchoFilter } from "./loop/tag-echo-filter.js";
+import { composeStreamFilters, containsBiliInternalText, containsEchoResidue, containsMarkerLineText, containsRenderTagText, containsToolCallXmlFragment, createBiliArtifactFilter, createMarkerLineFilter, createTagEchoFilter, isOrphanMarkupText, mayStartBiliInternal, mayStartDegenerateRenderTag, mayStartMarkerLine, mayStartRenderTag, stripAcpTags, stripAnthropicText, stripOpenaiChatText, stripResponsesText, type TagEchoFilter } from "./loop/tag-echo-filter.js";
import { log as loggerLog } from "./logger.js";
import { ccrEnabled, ccrLoopConfig, contentStoreOf, retrieveToolName } from "./store.js";
import { imageUsageSuffix } from "./image-compress.js";
@@ -1727,6 +1727,12 @@ export async function pipePluginChatWithStrip(
loggerLog("warn", `[tag-echo] stripped model-emitted render tag (plugin passthrough): ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
log?.(`[tag-echo] stripped model-emitted render tag from plugin passthrough text`);
};
+ // #2190: the filter released bytes that still carry echo-residue shape —
+ // the leak is now observable instead of silent. Log-only; the bytes were
+ // already decided by the state machine.
+ const onResidueWarn = (snippet: string) => {
+ loggerLog("warn", `[tag-echo] filter released echo-residue-shaped bytes (#2190): ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
+ };
const onMarkerDrop = (snippet: string) => {
sawStrippedEcho = true;
loggerLog("warn", `[marker-echo] stripped model-emitted ACP confirmation marker (plugin passthrough): ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
@@ -1750,7 +1756,7 @@ export async function pipePluginChatWithStrip(
const key = `${field}:${index}`;
let s = streams.get(key);
if (!s) {
- s = { filter: composeStreamFilters(composeStreamFilters(createTagEchoFilter(onTagDrop), createMarkerLineFilter(onMarkerDrop)), createBiliArtifactFilter(onBiliDrop)), field, index };
+ s = { filter: composeStreamFilters(composeStreamFilters(createTagEchoFilter(onTagDrop, onResidueWarn), createMarkerLineFilter(onMarkerDrop)), createBiliArtifactFilter(onBiliDrop)), field, index };
streams.set(key, s);
}
return s;
@@ -2078,10 +2084,13 @@ export async function pipePluginChatWithStrip(
// leap ahead of a held tail.
if (v.length > 0) hadText = true;
if (field !== "content" && v.length > 0) sawThinking = true;
- if (!mayStartRenderTag(v) && !mayStartMarkerLine(v) && !mayStartBiliInternal(v) && !anyPending()) {
+ if (!mayStartRenderTag(v) && !mayStartMarkerLine(v) && !mayStartBiliInternal(v) && !mayStartDegenerateRenderTag(v) && !anyPending()) {
if (v.length > 0) {
keptText = true;
proseAcc += v;
+ // #2190: residue audit — bytes that bypassed the state
+ // machine must be observable, not silent.
+ if (containsEchoResidue(v)) loggerLog("warn", `[tag-echo] fast path forwarded echo-residue-shaped bytes (#2190): ${v.slice(0, 80).replace(/\n/g, " ")}`);
}
if (field === "content") visibleTextChars += v.length;
continue;
@@ -2185,8 +2194,12 @@ export async function pipePluginChatWithStrip(
}
const raw = d[field] as string;
if (field === "thinking" && raw.length > 0) sawThinking = true;
- if (!mayStartRenderTag(raw) && !mayStartMarkerLine(raw) && !mayStartBiliInternal(raw) && !anyPending()) {
- if (raw.length > 0) proseAcc += raw;
+ if (!mayStartRenderTag(raw) && !mayStartMarkerLine(raw) && !mayStartBiliInternal(raw) && !mayStartDegenerateRenderTag(raw) && !anyPending()) {
+ if (raw.length > 0) {
+ proseAcc += raw;
+ // #2190: residue audit — see the twin above.
+ if (containsEchoResidue(raw)) loggerLog("warn", `[tag-echo] fast path forwarded echo-residue-shaped bytes (#2190): ${raw.slice(0, 80).replace(/\n/g, " ")}`);
+ }
if (field === "text" && raw.length > 0) visibleTextChars += raw.length;
return rawEvent + "\n\n";
}
@@ -2272,10 +2285,12 @@ export async function pipePluginChatWithStrip(
// field, so an interleaved thought/text pair in one frame never
// shares held-back state.
const field = p["thought"] === true ? "thinking" : "text";
- if (!mayStartRenderTag(raw) && !mayStartMarkerLine(raw) && !mayStartBiliInternal(raw) && !anyPending()) {
+ if (!mayStartRenderTag(raw) && !mayStartMarkerLine(raw) && !mayStartBiliInternal(raw) && !mayStartDegenerateRenderTag(raw) && !anyPending()) {
if (raw.length > 0) {
keptText = true;
proseAcc += raw;
+ // #2190: residue audit — see the twin above.
+ if (containsEchoResidue(raw)) loggerLog("warn", `[tag-echo] fast path forwarded echo-residue-shaped bytes (#2190): ${raw.slice(0, 80).replace(/\n/g, " ")}`);
}
if (field === "text") visibleTextChars += raw.length;
continue;
@@ -2548,13 +2563,17 @@ export async function pipePluginResponsesWithStrip(
loggerLog("warn", `[tag-echo] stripped model-emitted render tag (plugin passthrough): ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
log?.(`[tag-echo] stripped model-emitted render tag from plugin passthrough text`);
};
+ // #2190: log-only residue audit — see the twin above.
+ const onResidueWarn = (snippet: string) => {
+ loggerLog("warn", `[tag-echo] filter released echo-residue-shaped bytes (#2190): ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
+ };
const onBiliDrop = (snippet: string) => {
loggerLog("warn", `[bili-artifact] stripped model-emitted internal artifact (plugin passthrough): ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
log?.(`[bili-artifact] stripped model-emitted internal artifact from plugin passthrough text`);
};
const tagFilter = composeStreamFilters(
composeStreamFilters(
- createTagEchoFilter(onTagDrop),
+ createTagEchoFilter(onTagDrop, onResidueWarn),
createMarkerLineFilter((snippet) => {
loggerLog("warn", `[marker-echo] stripped model-emitted ACP confirmation marker (plugin passthrough): ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
log?.(`[marker-echo] stripped model-emitted ACP confirmation marker from plugin passthrough text`);
@@ -2793,7 +2812,7 @@ export async function pipePluginResponsesWithStrip(
for (const k of ["item_id", "output_index", "summary_index"]) {
if (ev[k] !== undefined) meta[k] = ev[k];
}
- s = { filter: composeStreamFilters(createTagEchoFilter(onTagDrop), createBiliArtifactFilter(onBiliDrop)), type, field, meta };
+ s = { filter: composeStreamFilters(createTagEchoFilter(onTagDrop, onResidueWarn), createBiliArtifactFilter(onBiliDrop)), type, field, meta };
argStreams.set(key, s);
}
return s;
@@ -2883,7 +2902,8 @@ export async function pipePluginResponsesWithStrip(
// The done is not visible text to the degenerate-turn retry below, so it
// is stripped and released directly.
if (type === "response.reasoning_summary_part.done") {
- const hadEcho = containsRenderTagText(jsonStr) || containsMarkerLineText(jsonStr) || containsBiliInternalText(jsonStr);
+ // #2190: degenerate-close residue never trips RENDER_TAG_DETECT — check its shape too.
+ const hadEcho = containsRenderTagText(jsonStr) || containsMarkerLineText(jsonStr) || containsBiliInternalText(jsonStr) || containsEchoResidue(jsonStr);
if (hadEcho) sawStrippedEcho = true;
const evOut = hadEcho ? stripResponsesText(ev) : ev;
proseAcc += responsesEventText(evOut);
@@ -2896,7 +2916,8 @@ export async function pipePluginResponsesWithStrip(
// retryEmptyTurn): releasing it earlier would hand the
// client the echo's own text exactly when the retry is
// about to replace it.
- const hadEchoText = containsRenderTagText(jsonStr) || containsMarkerLineText(jsonStr) || containsBiliInternalText(jsonStr);
+ // #2190: degenerate-close residue never trips RENDER_TAG_DETECT — check its shape too.
+ const hadEchoText = containsRenderTagText(jsonStr) || containsMarkerLineText(jsonStr) || containsBiliInternalText(jsonStr) || containsEchoResidue(jsonStr);
if (hadEchoText) sawStrippedEcho = true;
let evOut = ev;
let rebuild = hadEchoText || retryRewritePending();
@@ -2946,7 +2967,8 @@ export async function pipePluginResponsesWithStrip(
heldVisibleChars = 0;
// The completion frame itself closes the turn: strip it if it
// carries echoed text, rewrite retry ids onto the first attempt's.
- const hadEchoText = containsRenderTagText(jsonStr) || containsMarkerLineText(jsonStr) || containsBiliInternalText(jsonStr);
+ // #2190: degenerate-close residue never trips RENDER_TAG_DETECT — check its shape too.
+ const hadEchoText = containsRenderTagText(jsonStr) || containsMarkerLineText(jsonStr) || containsBiliInternalText(jsonStr) || containsEchoResidue(jsonStr);
if (hadEchoText) sawStrippedEcho = true;
let evOut = ev;
let rebuild = hadEchoText || retryRewritePending();
@@ -2967,10 +2989,12 @@ export async function pipePluginResponsesWithStrip(
await write(rawEvent + "\n\n");
continue;
}
- if (!retryRewritePending() && !mayStartRenderTag(delta) && !mayStartMarkerLine(delta) && !mayStartBiliInternal(delta) && !tagFilter.pending()) {
+ if (!retryRewritePending() && !mayStartRenderTag(delta) && !mayStartMarkerLine(delta) && !mayStartBiliInternal(delta) && !mayStartDegenerateRenderTag(delta) && !tagFilter.pending()) {
proseAcc += delta;
visibleTextChars += delta.length;
fastPathChars += delta.length;
+ // #2190: residue audit — see the twin above.
+ if (delta.length > 0 && containsEchoResidue(delta)) loggerLog("warn", `[tag-echo] fast path forwarded echo-residue-shaped bytes (#2190): ${delta.slice(0, 80).replace(/\n/g, " ")}`);
await write(rawEvent + "\n\n");
continue;
}
@@ -3005,8 +3029,10 @@ export async function pipePluginResponsesWithStrip(
await write(rawEvent + "\n\n");
continue;
}
- if (!mayStartRenderTag(v) && !mayStartBiliInternal(v) && !argAnyPending() && !tagFilter.pending()) {
+ if (!mayStartRenderTag(v) && !mayStartBiliInternal(v) && !mayStartDegenerateRenderTag(v) && !argAnyPending() && !tagFilter.pending()) {
proseAcc += v;
+ // #2190: residue audit — see the twin above.
+ if (v.length > 0 && containsEchoResidue(v)) loggerLog("warn", `[tag-echo] fast path forwarded echo-residue-shaped bytes (#2190): ${v.slice(0, 80).replace(/\n/g, " ")}`);
await write(rawEvent + "\n\n");
continue;
}
@@ -3204,7 +3230,8 @@ export async function pipePluginJson(
// one full-body parse this path already does. Observe-only (#1039).
if (session) recordJsonToolWitnesses(session.id, json, protocol);
} catch { /* non-JSON body — forward verbatim */ }
- if (json && (containsRenderTagText(text) || containsMarkerLineText(text) || containsBiliInternalText(text))) {
+ // #2190: degenerate-close residue never trips RENDER_TAG_DETECT — check its shape too.
+ if (json && (containsRenderTagText(text) || containsMarkerLineText(text) || containsBiliInternalText(text) || containsEchoResidue(text))) {
// #206 parity for the non-streaming plugin path: the compress loop's
// JSON branch strips render tags from every round; a verbatim plugin
// JSON response would re-feed the model's tag echoes. Strips mutate in
diff --git a/tests/issue2190-degen-close.test.ts b/tests/issue2190-degen-close.test.ts
new file mode 100644
index 0000000000..efb97a0f0b
--- /dev/null
+++ b/tests/issue2190-degen-close.test.ts
@@ -0,0 +1,197 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import {
+ composeStreamFilters,
+ containsEchoResidue,
+ createBiliArtifactFilter,
+ createMarkerLineFilter,
+ createTagEchoFilter,
+ isOrphanMarkupText,
+ mayStartBiliInternal,
+ mayStartDegenerateRenderTag,
+ mayStartMarkerLine,
+ mayStartRenderTag,
+ stripAcpTags,
+} from "../src/loop/tag-echo-filter.ts";
+import { pipePluginResponsesWithStrip } from "../src/plugin.ts";
+import type { Session } from "../src/session.ts";
+
+const OPEN = "\x3cacp tokens=\"23\" type=\"text\"\x3e";
+const REF = "m05712";
+
+function streamThrough(chunks: string[]): string {
+ const tagFilter = composeStreamFilters(
+ composeStreamFilters(createTagEchoFilter(), createMarkerLineFilter()),
+ createBiliArtifactFilter(),
+ );
+ let out = "";
+ for (const delta of chunks) {
+ if (!mayStartRenderTag(delta) && !mayStartMarkerLine(delta) && !mayStartBiliInternal(delta) && !mayStartDegenerateRenderTag(delta) && !tagFilter.pending()) {
+ out += delta;
+ continue;
+ }
+ out += tagFilter.push(delta);
+ }
+ return out + tagFilter.flush();
+}
+
+test("#2190 streaming: real field chunk sequence with degenerate close strips the residue", () => {
+ const chunks = ["\x3c", "ac", "p", " tokens", "=\u0022", "173", "\u0022", " type", "=\u0022", "text", "\u0022", "\u003e", "m", "057", "12", "\u003c/", "ap", "\u003e\n", "Let me first survey the workspace."];
+ const out = streamThrough(chunks);
+ assert.ok(!out.includes(REF), "ref must not leak");
+ assert.ok(!out.includes("\u003c/ap\u003e"), "degenerate close must not leak");
+ assert.ok(!out.includes("\u003cacp"), "open tag must not leak");
+ assert.equal(out, "\nLet me first survey the workspace.", "surrounding prose survives verbatim");
+});
+
+test("#2190 streaming: every attested degenerate close name is stripped character-by-character", () => {
+ for (const name of ["ap", "p", "a", "apc", "cap", "ck", "div", "warn", "aph", "ambient", "apm"]) {
+ const whole = `intro ${OPEN}${REF}\u003c/${name}\u003e after prose here.`;
+ const out = streamThrough([...whole]);
+ assert.ok(!out.includes(REF), `${name}: ref leaked`);
+ assert.ok(!out.includes(`\u003c/${name}\u003e`), `${name}: close leaked`);
+ assert.ok(out.startsWith("intro "), `${name}: leading prose lost`);
+ assert.ok(out.endsWith("after prose here."), `${name}: trailing prose lost`);
+ }
+});
+
+test("#2190 streaming: multi-tag blob with mixed valid and degenerate closes", () => {
+ const blob = `\u003cacp tokens="419" type="text"\u003em00501\u003c/acp\u003e \u003cacp tokens="193" type="text"\u003em00503\u003c/acp\u003e \u003cacp tokens="0"\u003em00505\u003c/p\u003e \u003cacp tokens="291"\u003em00502\u003c/p\u003e done.`;
+ assert.equal(streamThrough([blob]), " done.");
+});
+
+test("#2190 streaming: degenerate close near stream end no longer eats the following prose", () => {
+ const out = streamThrough([`\u003cacp tokens="1" type="text"\u003em00042\u003c/ck\u003e End of message.`]);
+ assert.equal(out, " End of message.");
+});
+
+test("#2190 streaming: prose body with a valid close keeps the prose (#1720 guard)", () => {
+ const out = streamThrough([`\u003cacp tokens="1" type="text"\u003eLet me check the file.\u003c/acp\u003e`]);
+ assert.equal(out, "Let me check the file.");
+});
+
+test("#2190 fast path: prose with stray HTML closes or comparison tails passes byte-identical", () => {
+ const prose = "The model wrote \u003c/p\u003e and \u003c/a\u003e in its reply.";
+ assert.equal(streamThrough([prose]), prose);
+ assert.equal(streamThrough(["if a\u003cb"]), "if a\u003cb");
+ assert.equal(streamThrough([" and c\u003ed then ok"]), " and c\u003ed then ok");
+});
+
+test("#2190 gate predicates: broad tail engages the machine while orphan-markup accounting stays prose", () => {
+ assert.equal(mayStartDegenerateRenderTag("\u003c"), true);
+ assert.equal(mayStartDegenerateRenderTag("\u003c/"), true);
+ assert.equal(mayStartDegenerateRenderTag("a\u003cb"), true);
+ assert.equal(mayStartDegenerateRenderTag("\u003cabcdefghijklmnopq"), false);
+ assert.equal(mayStartDegenerateRenderTag("\u003cdiv class="), false);
+ assert.equal(mayStartDegenerateRenderTag("OK"), false);
+ assert.equal(isOrphanMarkupText("\u003c/p\u003e"), false);
+ assert.equal(mayStartRenderTag("a\u003cb"), false);
+ assert.equal(containsEchoResidue("m05712\u003c/ap\u003e"), true);
+ assert.equal(containsEchoResidue("m05712 \u003c/ap\u003e"), true);
+ assert.equal(containsEchoResidue("see m1234"), false);
+ assert.equal(containsEchoResidue("m12345\u003cp\u003e"), false);
+});
+
+test("#2190 wrapped imitation: payload with ref-shaped content is still swallowed whole", () => {
+ const f = createTagEchoFilter();
+ let out = f.push(`\u003cacp tokens="1" type="text \u003cfoo\u003e${REF}\u003c/p\u003e more payload`);
+ out += f.flush();
+ assert.equal(out, "");
+});
+
+test("#2190 stripAcpTags: degenerate pairs die atomically, genuine HTML untouched", () => {
+ assert.equal(stripAcpTags(`\u003cacp tokens="1" type="text"\u003em05712\u003c/ck\u003e`), "");
+ assert.equal(stripAcpTags(`before \u003cacp\u003em00042\u003c/p\u003e after`), "before after");
+ assert.equal(stripAcpTags(`\u003cacp tokens="419" type="text"\u003em00501\u003c/acp\u003e \u003cacp tokens="0"\u003em00505\u003c/p\u003e`), " ");
+ assert.equal(stripAcpTags(`\u003cdiv class="x"\u003ehello\u003c/div\u003e`), `\u003cdiv class="x"\u003ehello\u003c/div\u003e`);
+ assert.equal(stripAcpTags(`see \u003c/p\u003e and \u003ca\u003em1234 text\u003c/a\u003e`), `see \u003c/p\u003e and \u003ca\u003em1234 text\u003c/a\u003e`);
+ assert.equal(stripAcpTags(`\u003cacp tokens="5" type="text"\u003em00001\u003c/acp\u003e`), "");
+});
+
+function makeSession(): Session {
+ return {
+ id: "testsess",
+ protocol: "responses",
+ upstreamOrigin: "http://127.0.0.1:9/v1",
+ label: "test",
+ createdAt: 0,
+ lastUsedAt: 0,
+ requests: 0,
+ lastInputTokens: 0,
+ stats: {},
+ dirty: false,
+ } as unknown as Session;
+}
+
+function makeRes(chunks: string[]) {
+ return {
+ writes: chunks,
+ write(b: Buffer | string) {
+ chunks.push(typeof b === "string" ? b : b.toString("utf8"));
+ return true;
+ },
+ end(b?: Buffer | string) {
+ if (b !== undefined) chunks.push(typeof b === "string" ? b : b.toString("utf8"));
+ },
+ once() {},
+ destroyed: false,
+ writableEnded: false,
+ } as unknown as import("node:http").ServerResponse;
+}
+
+function sse(ev: Record): string {
+ return `event: ${String(ev.type)}\ndata: ${JSON.stringify(ev)}\n\n`;
+}
+
+function streamOf(events: string[]): ReadableStream {
+ const enc = new TextEncoder();
+ let i = 0;
+ return new ReadableStream({
+ pull(controller) {
+ if (i < events.length) {
+ controller.enqueue(enc.encode(events[i]));
+ i += 1;
+ } else {
+ controller.close();
+ }
+ },
+ });
+}
+
+test("#2190 responses pipe: micro-fragmented degenerate tag never reaches the client", async () => {
+ const out: string[] = [];
+ const res = makeRes(out);
+ const session = makeSession();
+ const whole = `ok \u003cacp tokens="23" type="text"\u003em05712\u003c/ck\u003e tail`;
+ const micro = whole.match(/.{1,4}/gs) ?? [];
+ const events = [
+ ...micro.map((piece) => sse({ type: "response.output_text.delta", item_id: "msg_1", output_index: 0, delta: piece })),
+ sse({ type: "response.completed", response: { usage: { input_tokens: 7, output_tokens: 3 } } }),
+ ];
+ await pipePluginResponsesWithStrip(streamOf(events), res, session);
+ const text = out.join("");
+ assert.ok(!text.includes("m05712"), "ref never reaches the client");
+ const joined = text
+ .split("\n")
+ .filter((l) => l.startsWith("data:"))
+ .map((l) => JSON.parse(l.slice(5).trim()) as { type?: string; delta?: string })
+ .filter((ev) => ev.type === "response.output_text.delta" && typeof ev.delta === "string")
+ .map((ev) => ev.delta as string)
+ .join("");
+ assert.equal(joined, "ok tail", "surrounding prose reassembles to the tag-free text");
+});
+
+test("#2190 responses pipe: done-family full-text payload with degenerate pair is cleaned", async () => {
+ const out: string[] = [];
+ const res = makeRes(out);
+ const session = makeSession();
+ const events = [
+ sse({ type: "response.output_text.delta", item_id: "msg_1", output_index: 0, delta: "clean" }),
+ sse({ type: "response.output_text.done", item_id: "msg_1", output_index: 0, text: `clean \u003cacp tokens="1" type="text"\u003em00001\u003c/p\u003e` }),
+ sse({ type: "response.completed", response: { usage: { input_tokens: 1, output_tokens: 1 } } }),
+ ];
+ await pipePluginResponsesWithStrip(streamOf(events), res, session);
+ const text = out.join("");
+ assert.ok(!text.includes("m00001"), "done-family payload must be cleaned");
+ assert.ok(text.includes("clean "), "prose survives");
+});
From dbf4f1b4f71f19f715a8b02121741131a19e6b72 Mon Sep 17 00:00:00 2001
From: ework-agent
Date: Tue, 6 Oct 2026 13:07:33 +0800
Subject: [PATCH 06/16] fix: degenCloseAfterRef off standalone SINGLE_REF_BODY
const (#2229 stack compat)
One-line compat for the agreed #2025 -> #2211 -> #2067 merge order: #2025 folds the
master REF_LIKE constant into REF_TOKEN/REFS_RUN, which would leave this call dangling
(silent tsc break once stacked, each PR green alone). Standalone const carries the
identical regex /^\s*m\d{4,}\s*$/; behavior unchanged.
---
.../unknown_315f99dcc617d1cfa224e9e6.json | 1 +
.../v22.23.2-x64-9de703df-995/0014c7b4 | Bin 0 -> 1060 bytes
.../v22.23.2-x64-9de703df-995/03f36f82 | Bin 0 -> 1068 bytes
.../v22.23.2-x64-9de703df-995/06f773c7 | Bin 0 -> 892 bytes
.../v22.23.2-x64-9de703df-995/09dde953 | Bin 0 -> 844 bytes
.../v22.23.2-x64-9de703df-995/0f0c8433 | Bin 0 -> 2500 bytes
.../v22.23.2-x64-9de703df-995/158a58e3 | Bin 0 -> 884 bytes
.../v22.23.2-x64-9de703df-995/15dac900 | Bin 0 -> 1236 bytes
.../v22.23.2-x64-9de703df-995/16b76a41 | Bin 0 -> 1028 bytes
.../v22.23.2-x64-9de703df-995/16e14a72 | Bin 0 -> 1196 bytes
.../v22.23.2-x64-9de703df-995/1ac49b5c | Bin 0 -> 980 bytes
.../v22.23.2-x64-9de703df-995/1c575097 | Bin 0 -> 908 bytes
.../v22.23.2-x64-9de703df-995/1e880b66 | Bin 0 -> 1500 bytes
.../v22.23.2-x64-9de703df-995/1f9b0e5c | Bin 0 -> 980 bytes
.../v22.23.2-x64-9de703df-995/2037509d | Bin 0 -> 2756 bytes
.../v22.23.2-x64-9de703df-995/23a412ce | Bin 0 -> 2220 bytes
.../v22.23.2-x64-9de703df-995/23c95ffc | Bin 0 -> 2228 bytes
.../v22.23.2-x64-9de703df-995/263f0e14 | Bin 0 -> 860 bytes
.../v22.23.2-x64-9de703df-995/298138b1 | Bin 0 -> 8204 bytes
.../v22.23.2-x64-9de703df-995/2bc0d199 | Bin 0 -> 1172 bytes
.../v22.23.2-x64-9de703df-995/2c66374b | Bin 0 -> 4268 bytes
.../v22.23.2-x64-9de703df-995/2cbb34c0 | Bin 0 -> 4052 bytes
.../v22.23.2-x64-9de703df-995/311bad02 | Bin 0 -> 988 bytes
.../v22.23.2-x64-9de703df-995/31db85fd | Bin 0 -> 3532 bytes
.../v22.23.2-x64-9de703df-995/35ff1778 | Bin 0 -> 2764 bytes
.../v22.23.2-x64-9de703df-995/38c4fc01 | Bin 0 -> 884 bytes
.../v22.23.2-x64-9de703df-995/391c424a | Bin 0 -> 1284 bytes
.../v22.23.2-x64-9de703df-995/3c39e184 | Bin 0 -> 892 bytes
.../v22.23.2-x64-9de703df-995/3c3fb401 | Bin 0 -> 2868 bytes
.../v22.23.2-x64-9de703df-995/3f3308c6 | Bin 0 -> 2252 bytes
.../v22.23.2-x64-9de703df-995/45efdcd8 | Bin 0 -> 1244 bytes
.../v22.23.2-x64-9de703df-995/4652bac2 | Bin 0 -> 2404 bytes
.../v22.23.2-x64-9de703df-995/4a2f7337 | Bin 0 -> 2316 bytes
.../v22.23.2-x64-9de703df-995/4a7f67b1 | Bin 0 -> 12308 bytes
.../v22.23.2-x64-9de703df-995/4c58a332 | Bin 0 -> 956 bytes
.../v22.23.2-x64-9de703df-995/559b7e2b | Bin 0 -> 900 bytes
.../v22.23.2-x64-9de703df-995/563aaba5 | Bin 0 -> 2212 bytes
.../v22.23.2-x64-9de703df-995/59c632ba | Bin 0 -> 1764 bytes
.../v22.23.2-x64-9de703df-995/6c301b7e | Bin 0 -> 5412 bytes
.../v22.23.2-x64-9de703df-995/712742d6 | Bin 0 -> 892 bytes
.../v22.23.2-x64-9de703df-995/71bde3a2 | Bin 0 -> 892 bytes
.../v22.23.2-x64-9de703df-995/758cf23f | Bin 0 -> 2452 bytes
.../v22.23.2-x64-9de703df-995/7718e016 | Bin 0 -> 1020 bytes
.../v22.23.2-x64-9de703df-995/78e935bf | Bin 0 -> 71764 bytes
.../v22.23.2-x64-9de703df-995/7b81fa86 | Bin 0 -> 924 bytes
.../v22.23.2-x64-9de703df-995/7ba1b446 | Bin 0 -> 2532 bytes
.../v22.23.2-x64-9de703df-995/7d43326e | Bin 0 -> 1092 bytes
.../v22.23.2-x64-9de703df-995/804cf119 | Bin 0 -> 1916 bytes
.../v22.23.2-x64-9de703df-995/828a1323 | Bin 0 -> 1396 bytes
.../v22.23.2-x64-9de703df-995/828ac9b3 | Bin 0 -> 2108 bytes
.../v22.23.2-x64-9de703df-995/844075b3 | Bin 0 -> 1452 bytes
.../v22.23.2-x64-9de703df-995/86d3f244 | Bin 0 -> 956 bytes
.../v22.23.2-x64-9de703df-995/86f038a4 | Bin 0 -> 1020 bytes
.../v22.23.2-x64-9de703df-995/875d5b8b | Bin 0 -> 2228 bytes
.../v22.23.2-x64-9de703df-995/8840590a | Bin 0 -> 1620 bytes
.../v22.23.2-x64-9de703df-995/8cee33a3 | Bin 0 -> 8060 bytes
.../v22.23.2-x64-9de703df-995/923b43eb | Bin 0 -> 1276 bytes
.../v22.23.2-x64-9de703df-995/963c3aee | Bin 0 -> 2140 bytes
.../v22.23.2-x64-9de703df-995/973c40c2 | Bin 0 -> 924 bytes
.../v22.23.2-x64-9de703df-995/99b6a49a | Bin 0 -> 1068 bytes
.../v22.23.2-x64-9de703df-995/9b798567 | Bin 0 -> 2428 bytes
.../v22.23.2-x64-9de703df-995/9c2a21eb | Bin 0 -> 3604 bytes
.../v22.23.2-x64-9de703df-995/9ccf5632 | Bin 0 -> 3492 bytes
.../v22.23.2-x64-9de703df-995/9e724a52 | Bin 0 -> 4436 bytes
.../v22.23.2-x64-9de703df-995/a6305dfb | Bin 0 -> 1092 bytes
.../v22.23.2-x64-9de703df-995/ad4a0ba9 | Bin 0 -> 3428 bytes
.../v22.23.2-x64-9de703df-995/ae2aa98b | Bin 0 -> 1308 bytes
.../v22.23.2-x64-9de703df-995/ae5cd13f | Bin 0 -> 876 bytes
.../v22.23.2-x64-9de703df-995/b20aa54b | Bin 0 -> 1332 bytes
.../v22.23.2-x64-9de703df-995/b8ae7f8d | Bin 0 -> 1892 bytes
.../v22.23.2-x64-9de703df-995/bd1f064f | Bin 0 -> 1452 bytes
.../v22.23.2-x64-9de703df-995/be8e3c53 | Bin 0 -> 892 bytes
.../v22.23.2-x64-9de703df-995/bec154b0 | Bin 0 -> 1596 bytes
.../v22.23.2-x64-9de703df-995/c191be05 | Bin 0 -> 1044 bytes
.../v22.23.2-x64-9de703df-995/c4aca27d | Bin 0 -> 1444 bytes
.../v22.23.2-x64-9de703df-995/c5596213 | Bin 0 -> 1284 bytes
.../v22.23.2-x64-9de703df-995/cb39fc8b | Bin 0 -> 860 bytes
.../v22.23.2-x64-9de703df-995/d0324b5e | Bin 0 -> 1322076 bytes
.../v22.23.2-x64-9de703df-995/d149043c | Bin 0 -> 852 bytes
.../v22.23.2-x64-9de703df-995/d1a24e6b | Bin 0 -> 948 bytes
.../v22.23.2-x64-9de703df-995/d2e71ea6 | Bin 0 -> 1460 bytes
.../v22.23.2-x64-9de703df-995/d449cc90 | Bin 0 -> 892 bytes
.../v22.23.2-x64-9de703df-995/d4a49a25 | Bin 0 -> 1188 bytes
.../v22.23.2-x64-9de703df-995/d626981b | Bin 0 -> 8452 bytes
.../v22.23.2-x64-9de703df-995/de16f5cb | Bin 0 -> 860 bytes
.../v22.23.2-x64-9de703df-995/e66acb74 | Bin 0 -> 5508 bytes
.../v22.23.2-x64-9de703df-995/e674a16c | Bin 0 -> 1028 bytes
.../v22.23.2-x64-9de703df-995/e90dd27f | Bin 0 -> 916 bytes
.../v22.23.2-x64-9de703df-995/ecc4bf5b | Bin 0 -> 6772 bytes
.../v22.23.2-x64-9de703df-995/f994d10f | Bin 0 -> 7452 bytes
.../v22.23.2-x64-9de703df-995/fa91102b | Bin 0 -> 1220 bytes
.../v22.23.2-x64-9de703df-995/fabf3bdc | Bin 0 -> 4740 bytes
.../v22.23.2-x64-9de703df-995/fadf1a38 | Bin 0 -> 3324 bytes
.../v22.23.2-x64-9de703df-995/fc8d3fab | Bin 0 -> 1092 bytes
...2-02a4799c1e86e57d8425c2d7e25667cc293cfa74 | 1 +
...2-04acd60efc6a4362ad653635a8d8f80e42cc2b62 | 1 +
...2-059b5f84914d46b88b8f75b0b605460b1fd39ff9 | 1 +
...2-067a898dd7933c45ec0d44962e01640b5ccef475 | 1 +
...2-098ae071446cb03c1f235a7ae7def8feb2fed0ce | 1 +
...2-0cca325f162b717765355833c9514e22daaa4914 | 1 +
...2-0e32b746f3caf398d3bf1876abe5e1872a871543 | 1 +
...2-0f15aa629db608c1bb71cfbec7ee02bcebe92075 | 1 +
...2-118ca4801861b79885eac77d9ea83eb116a2e6f9 | 1 +
...2-11b8328a057f5c78defe33fe7331f5c94737af34 | 1 +
...2-13fa91874139aee42beedd85971437ca2c5eaeec | 1 +
...2-161106f011c701ceb6391460b37124a9c9cbd98a | 1 +
...2-16c40d02b13f63c05a5a5d57e5379c0c50917163 | 1 +
...2-1bd29e69c7092beeb855cb693918a744c42c8ce1 | 1 +
...2-1c2b4d472b31766fdef54a3986ba509fd5e66a9a | 1 +
...2-1c40bdb765e7efa946983cd6022c6324c357c299 | 1 +
...2-1f85a7992b07a6244b9495330e88fbe80b21133d | 1 +
...2-1fa18fb9c6509d845ab20ca05b297fe1efc0d71c | 1 +
...2-210d1c3a06120a220ef9d3a8a4d53951a2c4f979 | 1 +
...2-21878061964e7cbde762a8199ff10e6e963417f7 | 1 +
...2-228f9ec56dd76eef55bd56767205d7cf5f02a188 | 1 +
...2-25aacea7104add08f39b564c0efe0e7575100b58 | 1 +
...2-264ca9a56fa44e6056d41644d1ee43c0a1bcace9 | 1 +
...2-278e3dcb13fabe9025cde75b51c8e5a3293d471c | 1 +
...2-28b0b1b28d58821e9b0e44fe8f88462af874696c | 1 +
...2-29f87785c305ec5006b337de39e65f0052764515 | 1 +
...2-2ba4bb98d685e8a696472546512022b0a2c10df3 | 1 +
...2-2d4ef215485481e042158bcaa5be418671f5ddf9 | 1 +
...2-2f272abffbf386f4b4b4eebaeceebe2d7bdb0e6c | 1 +
...2-3028552a5d31cf54196648ead89a8d13e7e5bc0c | 1 +
...2-3321ea3f964b8b23876e1db1e3d110513e9037a4 | 1 +
...2-375278534042e7970e37e74cabf8306c715f157a | 1 +
...2-3764606230391e97fceacd1b4d6c9e665417f7ac | 1 +
...2-3783646dff2a75699eef77c285d74fc3ad4d289a | 1 +
...2-3bcce9957b6abc46b381c46d6d0c6c8cbbfab487 | 1 +
...2-3c2b029d04286031c7b733c19007be0ce1157a51 | 1 +
...2-3cbdc1e7cf93b16684f6b9ea8e2dfe1b3fff64d6 | 1 +
...2-3e7c94ad7ab82eb35661fe34808198c88bdb838a | 1 +
...2-40391555689ce070cadc02295f96f66193e31fcf | 1 +
...2-407176aa8b88e48f0b0ef7d5ca9534f4a249e8cf | 1 +
...2-408e5e80dee7de9c86747dff815aa20bfe28e454 | 1 +
...2-42136cdbe873b3ee5ee63c7ed5d508efe8806cf0 | 1 +
...2-42fa96b9a5d553ba1892c77a7f889617d18bd086 | 1 +
...2-43a3f9a33385cb54c1b4f91441e55bf36e5a041c | 1 +
...2-43ab57a2db24456a6fd37abfed3c07a2bfc3abce | 1 +
...2-43cbd2f82cc81e8b5f357650dddce87e4a606ddc | 1 +
...2-44799adb7c8b30f47d6b7a5c0ee8f2134410ce6c | 1 +
...2-4684af0ef7c43d2c3539898c1e370869b858c00a | 1 +
...2-4a9d38f61511dc86eb237b37bff45873aeffcb95 | 1 +
...2-4af0dedb36cdcbe9e40a1e4cf950f33812d446d7 | 1 +
...2-4af0e149001c80a597ddd91a1d19523e03c18c83 | 1 +
...2-4dfd56f13e520a3b881e4132830d7382cebee89e | 1 +
...2-4e1f16a2c8e43b2e248b89e0fddeb9eea8909600 | 1 +
...2-4f9c4c3492fe163362deb8fdb29cd202482fe46f | 1 +
...2-54063332535c592482f69446b14221fd15ff744b | 1 +
...2-5537aed2445f79451e0cb8197f2aeabd2cffbdda | 1 +
...2-55751c26a6c7e5759f3d2d482eb65c4d8f0bf8e1 | 1 +
...2-559bbac170531f2602b680db74997abcc1731721 | 1 +
...2-5666f813891fdafd3d535f97f7c5c692da9118d4 | 1 +
...2-56953d907caa150bc676a142e846411e2cfeb78f | 1 +
...2-59238212740b24a1e48904a60c0e7e2c587b6610 | 1 +
...2-5c815f3e0319c5d15b3923aafad5194d017bf048 | 1 +
...2-5dec7054b5a06fd44eba35e0cc59356e6b574dba | 1 +
...2-5f06144d98f74617a95c2cf5fd2bff3fa2d9e42a | 1 +
...2-6570a0a0053e8e7e2158e8925f56fdd8d003dea2 | 1 +
...2-658f670477d96ba31da9db812e265aec6facd4b9 | 1 +
...2-69d7c068a7c8f04f29ee70ae397c28cad0452baa | 1 +
...2-6d7d8b2635bbf4aa9b00b867078fa513eb1bbd96 | 1 +
...2-6d883fb8ff03713f625eaa764a00eaaf6f08c9c4 | 1 +
...2-6e919185c4bc0d3f3b56db9c1cbde9fdcbe3717e | 1 +
...2-6eb1c48435a894c51ad6ab6eb121a1f9d7edb0a9 | 1 +
...2-70a64b49e104f77522b9bd0c42c40646e00a67b9 | 1 +
...2-71f3c171c1dafbbaefc1bde732bd4a617660f7ac | 1 +
...2-72d1da6d25c35ed655a0f3a7f155337031c9655b | 1 +
...2-73a219eed62e1020ac88b160f16fd9ae682b3d75 | 1 +
...2-76eb58fb6880b01e474f362334645869fbcfa77b | 1 +
...2-76ed80c611f96c1e1386605c43e6495101063569 | 1 +
...2-7951f5f56ad85d3a5d8483e27f6b5805d7356cec | 1 +
...2-7f98113771000ba4399972c217e106798a8906a7 | 1 +
...2-806877a3283da917fe875c692e2d37fae892d394 | 1 +
...2-80b7fe68cf2de26b07c9b8eb37db5a4eeb1008c2 | 1 +
...2-845f85a4ffd528bd692514f9920caa0599883a2b | 1 +
...2-85fa342b7e98921f3a26c27497d3b48dd4fc7d46 | 1 +
...2-865730c6bd6e8fdf195634249dfa299d6028b326 | 1 +
...2-86b37cb5fb3cd53a0808940a20257039cde3e9db | 1 +
...2-8a49fd4adb563fcf695d0132bb592432dea944d5 | 1 +
...2-8a67fbd763d4471b120a32e9091ae602203a2038 | 1 +
...2-8ae96499874dd7873e916055c4163238484a2a0d | 1 +
...2-907b14bdec124accd683137eadd113476bea6209 | 1 +
...2-9094c0bf72acf0738e28e7d7330a6a2dc7f0900d | 1 +
...2-93c51cf30ddc7d0a440d173b1ac2de9af6c4cfc5 | 1 +
...2-97610584e94be9ee3caaaf5bd05e76e051a6215d | 1 +
...2-9a1c4f82d923760a7c687efbb9331dd831fe7fc3 | 1 +
...2-9a5e9134cd6e377e32210dbfd1e9081f1b97640b | 1 +
...2-9a909240153a10c1f4a9e52fb34b2fcdf30a3308 | 1 +
...2-9af79dd428facc253851c14b8dc3c550f15a06de | 1 +
...2-a0833eac747e584811dcfb838f20c3fd0a561d1a | 1 +
...2-a0d490ce552d7b000ca29a866620294272a7faba | 1 +
...2-a27808e7fe6ab108856b3201a7718b3e2178b780 | 1 +
...2-a6c1588135f1f189722981802f865bd71d8d0faa | 1 +
...2-a82778b49486bd3c8f604c31515e29791757d3f9 | 1 +
...2-aa4eab8d233df7f29694c19dd3679465db107b08 | 1 +
...2-ab3c5a9d975eeb7ef5126ee7d31165c7c61086c0 | 1 +
...2-ad4fff4c5c2a81054e8026091512edeeb5ac4607 | 1 +
...2-ad8e3461bc3e4c679fcad8839fdd679a2870aca7 | 1 +
...2-ae8ba5186a056fbad8757472dbc3ac13a7b9e53a | 1 +
...2-aedac1630645fbbc5ba810c0b5406328499ddce1 | 1 +
...2-af52a84dba8f40c75cb56b1d17824bac6832f621 | 1 +
...2-b075a502a35f0247a08d3de5b69194171147d753 | 1 +
...2-b07b86d1610b7c7ff73de28285dd74b53851d355 | 1 +
...2-b2ae74dc3fef300d69057a72719252fd40ccde29 | 1 +
...2-b4bd5815234ad1aeebe1bed46d72c6cefbeb4eea | 1 +
...2-b5c4e41f2784564ae488e81fb859e5e04444e90d | 1 +
...2-b61f3bf4ed617d1adbe5b956fbebaac664108208 | 1 +
...2-b8d4e3ccd803c7a4c735cb3640582679f30f4f26 | 1 +
...2-b9068fc99674ef36f9dedc321a1b9392a36a96b9 | 1 +
...2-b9c3e584d33efae77ba83cb334a0a56a9a3a9a74 | 1 +
...2-bbb6d6c63081c9f12ba5145c69d860b735d1351b | 1 +
...2-bc39b012a3b398d7fe7d2f4cc08f5764b5b3b0e2 | 1 +
...2-be2a2fb519f0dc16740fe57af3abd7ad0b1e78e5 | 1 +
...2-be7899215039632bc12edad432ce1f38f9ef81c3 | 1 +
...2-bf60eb629487b6b6e07b83d3a98d8252e6d84559 | 1 +
...2-c051df4d3160c1ed31d5f970e438b1f3a7632f3f | 1 +
...2-c0f42a1944f67270691772441a1710bb53f33f78 | 1 +
...2-c28d02454e4a9a9812ab0e5755b70dbd337d8841 | 1 +
...2-c30e5841ff79860b5f3edfa6a464087e4556461e | 1 +
...2-c3fa13895b9968b3f411198ca1702f02080befc7 | 1 +
...2-c86ad7ace4d47178fd5ad4e97bea9e4cefef504b | 1 +
...2-c9b50c9a2cd49ba0ba2ab6afb5cb00f9c0e13304 | 1 +
...2-ca2a74acf070460b519c4dcb94acc0f56027f529 | 1 +
...2-ca3065095e528c92224bf6fc392f325ce1e43187 | 1 +
...2-cc0605efdcb274a71231f89d73dcf38beb25dca2 | 1 +
...2-cc12d358e72d61576ae7cbfd0e6ddadbf9bf1c68 | 1 +
...2-cc59bd9456e8dc7dae1434939aae2314eb268aa7 | 1 +
...2-cc68a9f3a3e17a4c058a27650886353bb5f5c717 | 1 +
...2-cdfe4c4894eaa69190739badd053433b5a1809b9 | 1 +
...2-ce47ae8ca75676dfc3cea1a01ee070b1c3a0d932 | 1 +
...2-d1126d580b0fd6d86565aff694f4b76d7ea6d82b | 1 +
...2-d1a783b2304ff7f0dd9c25fabe1503023fa103ee | 1 +
...2-d24e9ce64213ca1f73d1dbbbb35545bbc5a65e26 | 1 +
...2-d303aa773c7437202baa6523a9da7ab114a9ec9e | 1 +
...2-d37d44196a1d23ff02a5ce204ba08ec9a9c4ff95 | 1 +
...2-d4dc10c7502ab10b749ab1be7bc36f7b3b31689b | 1 +
...2-d7382ee44cf1386970f4d431917cd3e4fd87982b | 1 +
...2-dc29ce204611fbb7da1c6a161c0c53eda77364b1 | 1 +
...2-dcbc376d37cbadf4d123a56a6aaa77b76fe9f00a | 1 +
...2-de3b0226dbdc2fa27cfb5ab7450ad258a3d3ee6d | 1 +
...2-de4bd082c883af3e98b48947f07a2991fcd29c8e | 1 +
...2-dec15f20605613c21db0ff9a84dba9d643f3c1f9 | 1 +
...2-df26b9073cb7ad8567013cd69caf90a4521eef90 | 1 +
...2-e16e40a094bd191310531a7bfaf246a4c1868d6f | 1 +
...2-e2d272d2232de2ae9ba0dbb8ab7407cc54e9f6e9 | 1 +
...2-e2e52f06201bf51d13694a307b6c40aa4fc3fa5d | 1 +
...2-e5f4f345c38abce071840c4afffc72ad05f1415f | 1 +
...2-e80584a635a2f28a49d32ded262bbae85b013784 | 1 +
...2-e910c3db12ac967fe118300d42df126ae76f1ed8 | 1 +
...2-ef5cb40e3542b566dd0fe3d21a011019910045d3 | 1 +
...2-f0564eba7b01a95d27a5ca160184ac2150fec970 | 1 +
...2-f3ff7179a11d31ef5792e3e75e023faa5f6f969c | 1 +
...2-f49caee4e4476cc8dbd988420aeec1d5f4308abc | 1 +
...2-f5bf1723294bb3eb5a423e82bffa3dc26497e919 | 1 +
...2-f7a16c4f76ccec6ff7b54158f6cb311508008b02 | 1 +
...2-fb02bf1c64de25bdf7603d6963ac4a3bf86a38b8 | 1 +
...2-fcc7fcfca02136ed9a0dfe17f54fd2071f605d6d | 1 +
...2-fd60db2b567ebd11ca85e00665773c0a7e13c616 | 1 +
...2-fd98761be189adb8585c9884f95f3895dd347225 | 1 +
...2-fe153e5ab3b2f566a9af275da0a122a02edebf56 | 1 +
...2-fec2c009d800c66edd615f056d5cd25162d9f8bb | 1 +
src/loop/tag-echo-filter.ts | 5 ++++-
263 files changed, 173 insertions(+), 1 deletion(-)
create mode 100644 .tmp/bili-absorb-Ez6926/anthropic/unknown_315f99dcc617d1cfa224e9e6.json
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/0014c7b4
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/03f36f82
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/06f773c7
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/09dde953
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/0f0c8433
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/158a58e3
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/15dac900
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/16b76a41
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/16e14a72
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/1ac49b5c
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/1c575097
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/1e880b66
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/1f9b0e5c
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/2037509d
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/23a412ce
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/23c95ffc
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/263f0e14
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/298138b1
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/2bc0d199
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/2c66374b
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/2cbb34c0
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/311bad02
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/31db85fd
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/35ff1778
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/38c4fc01
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/391c424a
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/3c39e184
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/3c3fb401
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/3f3308c6
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/45efdcd8
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/4652bac2
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/4a2f7337
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/4a7f67b1
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/4c58a332
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/559b7e2b
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/563aaba5
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/59c632ba
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/6c301b7e
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/712742d6
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/71bde3a2
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/758cf23f
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/7718e016
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/78e935bf
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/7b81fa86
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/7ba1b446
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/7d43326e
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/804cf119
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/828a1323
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/828ac9b3
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/844075b3
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/86d3f244
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/86f038a4
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/875d5b8b
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/8840590a
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/8cee33a3
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/923b43eb
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/963c3aee
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/973c40c2
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/99b6a49a
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/9b798567
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/9c2a21eb
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/9ccf5632
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/9e724a52
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/a6305dfb
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/ad4a0ba9
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/ae2aa98b
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/ae5cd13f
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/b20aa54b
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/b8ae7f8d
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/bd1f064f
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/be8e3c53
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/bec154b0
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/c191be05
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/c4aca27d
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/c5596213
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/cb39fc8b
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/d0324b5e
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/d149043c
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/d1a24e6b
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/d2e71ea6
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/d449cc90
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/d4a49a25
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/d626981b
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/de16f5cb
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/e66acb74
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/e674a16c
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/e90dd27f
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/ecc4bf5b
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/f994d10f
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/fa91102b
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/fabf3bdc
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/fadf1a38
create mode 100644 .tmp/node-compile-cache/v22.23.2-x64-9de703df-995/fc8d3fab
create mode 100644 .tmp/tsx-995/17912-02a4799c1e86e57d8425c2d7e25667cc293cfa74
create mode 100644 .tmp/tsx-995/17912-04acd60efc6a4362ad653635a8d8f80e42cc2b62
create mode 100644 .tmp/tsx-995/17912-059b5f84914d46b88b8f75b0b605460b1fd39ff9
create mode 100644 .tmp/tsx-995/17912-067a898dd7933c45ec0d44962e01640b5ccef475
create mode 100644 .tmp/tsx-995/17912-098ae071446cb03c1f235a7ae7def8feb2fed0ce
create mode 100644 .tmp/tsx-995/17912-0cca325f162b717765355833c9514e22daaa4914
create mode 100644 .tmp/tsx-995/17912-0e32b746f3caf398d3bf1876abe5e1872a871543
create mode 100644 .tmp/tsx-995/17912-0f15aa629db608c1bb71cfbec7ee02bcebe92075
create mode 100644 .tmp/tsx-995/17912-118ca4801861b79885eac77d9ea83eb116a2e6f9
create mode 100644 .tmp/tsx-995/17912-11b8328a057f5c78defe33fe7331f5c94737af34
create mode 100644 .tmp/tsx-995/17912-13fa91874139aee42beedd85971437ca2c5eaeec
create mode 100644 .tmp/tsx-995/17912-161106f011c701ceb6391460b37124a9c9cbd98a
create mode 100644 .tmp/tsx-995/17912-16c40d02b13f63c05a5a5d57e5379c0c50917163
create mode 100644 .tmp/tsx-995/17912-1bd29e69c7092beeb855cb693918a744c42c8ce1
create mode 100644 .tmp/tsx-995/17912-1c2b4d472b31766fdef54a3986ba509fd5e66a9a
create mode 100644 .tmp/tsx-995/17912-1c40bdb765e7efa946983cd6022c6324c357c299
create mode 100644 .tmp/tsx-995/17912-1f85a7992b07a6244b9495330e88fbe80b21133d
create mode 100644 .tmp/tsx-995/17912-1fa18fb9c6509d845ab20ca05b297fe1efc0d71c
create mode 100644 .tmp/tsx-995/17912-210d1c3a06120a220ef9d3a8a4d53951a2c4f979
create mode 100644 .tmp/tsx-995/17912-21878061964e7cbde762a8199ff10e6e963417f7
create mode 100644 .tmp/tsx-995/17912-228f9ec56dd76eef55bd56767205d7cf5f02a188
create mode 100644 .tmp/tsx-995/17912-25aacea7104add08f39b564c0efe0e7575100b58
create mode 100644 .tmp/tsx-995/17912-264ca9a56fa44e6056d41644d1ee43c0a1bcace9
create mode 100644 .tmp/tsx-995/17912-278e3dcb13fabe9025cde75b51c8e5a3293d471c
create mode 100644 .tmp/tsx-995/17912-28b0b1b28d58821e9b0e44fe8f88462af874696c
create mode 100644 .tmp/tsx-995/17912-29f87785c305ec5006b337de39e65f0052764515
create mode 100644 .tmp/tsx-995/17912-2ba4bb98d685e8a696472546512022b0a2c10df3
create mode 100644 .tmp/tsx-995/17912-2d4ef215485481e042158bcaa5be418671f5ddf9
create mode 100644 .tmp/tsx-995/17912-2f272abffbf386f4b4b4eebaeceebe2d7bdb0e6c
create mode 100644 .tmp/tsx-995/17912-3028552a5d31cf54196648ead89a8d13e7e5bc0c
create mode 100644 .tmp/tsx-995/17912-3321ea3f964b8b23876e1db1e3d110513e9037a4
create mode 100644 .tmp/tsx-995/17912-375278534042e7970e37e74cabf8306c715f157a
create mode 100644 .tmp/tsx-995/17912-3764606230391e97fceacd1b4d6c9e665417f7ac
create mode 100644 .tmp/tsx-995/17912-3783646dff2a75699eef77c285d74fc3ad4d289a
create mode 100644 .tmp/tsx-995/17912-3bcce9957b6abc46b381c46d6d0c6c8cbbfab487
create mode 100644 .tmp/tsx-995/17912-3c2b029d04286031c7b733c19007be0ce1157a51
create mode 100644 .tmp/tsx-995/17912-3cbdc1e7cf93b16684f6b9ea8e2dfe1b3fff64d6
create mode 100644 .tmp/tsx-995/17912-3e7c94ad7ab82eb35661fe34808198c88bdb838a
create mode 100644 .tmp/tsx-995/17912-40391555689ce070cadc02295f96f66193e31fcf
create mode 100644 .tmp/tsx-995/17912-407176aa8b88e48f0b0ef7d5ca9534f4a249e8cf
create mode 100644 .tmp/tsx-995/17912-408e5e80dee7de9c86747dff815aa20bfe28e454
create mode 100644 .tmp/tsx-995/17912-42136cdbe873b3ee5ee63c7ed5d508efe8806cf0
create mode 100644 .tmp/tsx-995/17912-42fa96b9a5d553ba1892c77a7f889617d18bd086
create mode 100644 .tmp/tsx-995/17912-43a3f9a33385cb54c1b4f91441e55bf36e5a041c
create mode 100644 .tmp/tsx-995/17912-43ab57a2db24456a6fd37abfed3c07a2bfc3abce
create mode 100644 .tmp/tsx-995/17912-43cbd2f82cc81e8b5f357650dddce87e4a606ddc
create mode 100644 .tmp/tsx-995/17912-44799adb7c8b30f47d6b7a5c0ee8f2134410ce6c
create mode 100644 .tmp/tsx-995/17912-4684af0ef7c43d2c3539898c1e370869b858c00a
create mode 100644 .tmp/tsx-995/17912-4a9d38f61511dc86eb237b37bff45873aeffcb95
create mode 100644 .tmp/tsx-995/17912-4af0dedb36cdcbe9e40a1e4cf950f33812d446d7
create mode 100644 .tmp/tsx-995/17912-4af0e149001c80a597ddd91a1d19523e03c18c83
create mode 100644 .tmp/tsx-995/17912-4dfd56f13e520a3b881e4132830d7382cebee89e
create mode 100644 .tmp/tsx-995/17912-4e1f16a2c8e43b2e248b89e0fddeb9eea8909600
create mode 100644 .tmp/tsx-995/17912-4f9c4c3492fe163362deb8fdb29cd202482fe46f
create mode 100644 .tmp/tsx-995/17912-54063332535c592482f69446b14221fd15ff744b
create mode 100644 .tmp/tsx-995/17912-5537aed2445f79451e0cb8197f2aeabd2cffbdda
create mode 100644 .tmp/tsx-995/17912-55751c26a6c7e5759f3d2d482eb65c4d8f0bf8e1
create mode 100644 .tmp/tsx-995/17912-559bbac170531f2602b680db74997abcc1731721
create mode 100644 .tmp/tsx-995/17912-5666f813891fdafd3d535f97f7c5c692da9118d4
create mode 100644 .tmp/tsx-995/17912-56953d907caa150bc676a142e846411e2cfeb78f
create mode 100644 .tmp/tsx-995/17912-59238212740b24a1e48904a60c0e7e2c587b6610
create mode 100644 .tmp/tsx-995/17912-5c815f3e0319c5d15b3923aafad5194d017bf048
create mode 100644 .tmp/tsx-995/17912-5dec7054b5a06fd44eba35e0cc59356e6b574dba
create mode 100644 .tmp/tsx-995/17912-5f06144d98f74617a95c2cf5fd2bff3fa2d9e42a
create mode 100644 .tmp/tsx-995/17912-6570a0a0053e8e7e2158e8925f56fdd8d003dea2
create mode 100644 .tmp/tsx-995/17912-658f670477d96ba31da9db812e265aec6facd4b9
create mode 100644 .tmp/tsx-995/17912-69d7c068a7c8f04f29ee70ae397c28cad0452baa
create mode 100644 .tmp/tsx-995/17912-6d7d8b2635bbf4aa9b00b867078fa513eb1bbd96
create mode 100644 .tmp/tsx-995/17912-6d883fb8ff03713f625eaa764a00eaaf6f08c9c4
create mode 100644 .tmp/tsx-995/17912-6e919185c4bc0d3f3b56db9c1cbde9fdcbe3717e
create mode 100644 .tmp/tsx-995/17912-6eb1c48435a894c51ad6ab6eb121a1f9d7edb0a9
create mode 100644 .tmp/tsx-995/17912-70a64b49e104f77522b9bd0c42c40646e00a67b9
create mode 100644 .tmp/tsx-995/17912-71f3c171c1dafbbaefc1bde732bd4a617660f7ac
create mode 100644 .tmp/tsx-995/17912-72d1da6d25c35ed655a0f3a7f155337031c9655b
create mode 100644 .tmp/tsx-995/17912-73a219eed62e1020ac88b160f16fd9ae682b3d75
create mode 100644 .tmp/tsx-995/17912-76eb58fb6880b01e474f362334645869fbcfa77b
create mode 100644 .tmp/tsx-995/17912-76ed80c611f96c1e1386605c43e6495101063569
create mode 100644 .tmp/tsx-995/17912-7951f5f56ad85d3a5d8483e27f6b5805d7356cec
create mode 100644 .tmp/tsx-995/17912-7f98113771000ba4399972c217e106798a8906a7
create mode 100644 .tmp/tsx-995/17912-806877a3283da917fe875c692e2d37fae892d394
create mode 100644 .tmp/tsx-995/17912-80b7fe68cf2de26b07c9b8eb37db5a4eeb1008c2
create mode 100644 .tmp/tsx-995/17912-845f85a4ffd528bd692514f9920caa0599883a2b
create mode 100644 .tmp/tsx-995/17912-85fa342b7e98921f3a26c27497d3b48dd4fc7d46
create mode 100644 .tmp/tsx-995/17912-865730c6bd6e8fdf195634249dfa299d6028b326
create mode 100644 .tmp/tsx-995/17912-86b37cb5fb3cd53a0808940a20257039cde3e9db
create mode 100644 .tmp/tsx-995/17912-8a49fd4adb563fcf695d0132bb592432dea944d5
create mode 100644 .tmp/tsx-995/17912-8a67fbd763d4471b120a32e9091ae602203a2038
create mode 100644 .tmp/tsx-995/17912-8ae96499874dd7873e916055c4163238484a2a0d
create mode 100644 .tmp/tsx-995/17912-907b14bdec124accd683137eadd113476bea6209
create mode 100644 .tmp/tsx-995/17912-9094c0bf72acf0738e28e7d7330a6a2dc7f0900d
create mode 100644 .tmp/tsx-995/17912-93c51cf30ddc7d0a440d173b1ac2de9af6c4cfc5
create mode 100644 .tmp/tsx-995/17912-97610584e94be9ee3caaaf5bd05e76e051a6215d
create mode 100644 .tmp/tsx-995/17912-9a1c4f82d923760a7c687efbb9331dd831fe7fc3
create mode 100644 .tmp/tsx-995/17912-9a5e9134cd6e377e32210dbfd1e9081f1b97640b
create mode 100644 .tmp/tsx-995/17912-9a909240153a10c1f4a9e52fb34b2fcdf30a3308
create mode 100644 .tmp/tsx-995/17912-9af79dd428facc253851c14b8dc3c550f15a06de
create mode 100644 .tmp/tsx-995/17912-a0833eac747e584811dcfb838f20c3fd0a561d1a
create mode 100644 .tmp/tsx-995/17912-a0d490ce552d7b000ca29a866620294272a7faba
create mode 100644 .tmp/tsx-995/17912-a27808e7fe6ab108856b3201a7718b3e2178b780
create mode 100644 .tmp/tsx-995/17912-a6c1588135f1f189722981802f865bd71d8d0faa
create mode 100644 .tmp/tsx-995/17912-a82778b49486bd3c8f604c31515e29791757d3f9
create mode 100644 .tmp/tsx-995/17912-aa4eab8d233df7f29694c19dd3679465db107b08
create mode 100644 .tmp/tsx-995/17912-ab3c5a9d975eeb7ef5126ee7d31165c7c61086c0
create mode 100644 .tmp/tsx-995/17912-ad4fff4c5c2a81054e8026091512edeeb5ac4607
create mode 100644 .tmp/tsx-995/17912-ad8e3461bc3e4c679fcad8839fdd679a2870aca7
create mode 100644 .tmp/tsx-995/17912-ae8ba5186a056fbad8757472dbc3ac13a7b9e53a
create mode 100644 .tmp/tsx-995/17912-aedac1630645fbbc5ba810c0b5406328499ddce1
create mode 100644 .tmp/tsx-995/17912-af52a84dba8f40c75cb56b1d17824bac6832f621
create mode 100644 .tmp/tsx-995/17912-b075a502a35f0247a08d3de5b69194171147d753
create mode 100644 .tmp/tsx-995/17912-b07b86d1610b7c7ff73de28285dd74b53851d355
create mode 100644 .tmp/tsx-995/17912-b2ae74dc3fef300d69057a72719252fd40ccde29
create mode 100644 .tmp/tsx-995/17912-b4bd5815234ad1aeebe1bed46d72c6cefbeb4eea
create mode 100644 .tmp/tsx-995/17912-b5c4e41f2784564ae488e81fb859e5e04444e90d
create mode 100644 .tmp/tsx-995/17912-b61f3bf4ed617d1adbe5b956fbebaac664108208
create mode 100644 .tmp/tsx-995/17912-b8d4e3ccd803c7a4c735cb3640582679f30f4f26
create mode 100644 .tmp/tsx-995/17912-b9068fc99674ef36f9dedc321a1b9392a36a96b9
create mode 100644 .tmp/tsx-995/17912-b9c3e584d33efae77ba83cb334a0a56a9a3a9a74
create mode 100644 .tmp/tsx-995/17912-bbb6d6c63081c9f12ba5145c69d860b735d1351b
create mode 100644 .tmp/tsx-995/17912-bc39b012a3b398d7fe7d2f4cc08f5764b5b3b0e2
create mode 100644 .tmp/tsx-995/17912-be2a2fb519f0dc16740fe57af3abd7ad0b1e78e5
create mode 100644 .tmp/tsx-995/17912-be7899215039632bc12edad432ce1f38f9ef81c3
create mode 100644 .tmp/tsx-995/17912-bf60eb629487b6b6e07b83d3a98d8252e6d84559
create mode 100644 .tmp/tsx-995/17912-c051df4d3160c1ed31d5f970e438b1f3a7632f3f
create mode 100644 .tmp/tsx-995/17912-c0f42a1944f67270691772441a1710bb53f33f78
create mode 100644 .tmp/tsx-995/17912-c28d02454e4a9a9812ab0e5755b70dbd337d8841
create mode 100644 .tmp/tsx-995/17912-c30e5841ff79860b5f3edfa6a464087e4556461e
create mode 100644 .tmp/tsx-995/17912-c3fa13895b9968b3f411198ca1702f02080befc7
create mode 100644 .tmp/tsx-995/17912-c86ad7ace4d47178fd5ad4e97bea9e4cefef504b
create mode 100644 .tmp/tsx-995/17912-c9b50c9a2cd49ba0ba2ab6afb5cb00f9c0e13304
create mode 100644 .tmp/tsx-995/17912-ca2a74acf070460b519c4dcb94acc0f56027f529
create mode 100644 .tmp/tsx-995/17912-ca3065095e528c92224bf6fc392f325ce1e43187
create mode 100644 .tmp/tsx-995/17912-cc0605efdcb274a71231f89d73dcf38beb25dca2
create mode 100644 .tmp/tsx-995/17912-cc12d358e72d61576ae7cbfd0e6ddadbf9bf1c68
create mode 100644 .tmp/tsx-995/17912-cc59bd9456e8dc7dae1434939aae2314eb268aa7
create mode 100644 .tmp/tsx-995/17912-cc68a9f3a3e17a4c058a27650886353bb5f5c717
create mode 100644 .tmp/tsx-995/17912-cdfe4c4894eaa69190739badd053433b5a1809b9
create mode 100644 .tmp/tsx-995/17912-ce47ae8ca75676dfc3cea1a01ee070b1c3a0d932
create mode 100644 .tmp/tsx-995/17912-d1126d580b0fd6d86565aff694f4b76d7ea6d82b
create mode 100644 .tmp/tsx-995/17912-d1a783b2304ff7f0dd9c25fabe1503023fa103ee
create mode 100644 .tmp/tsx-995/17912-d24e9ce64213ca1f73d1dbbbb35545bbc5a65e26
create mode 100644 .tmp/tsx-995/17912-d303aa773c7437202baa6523a9da7ab114a9ec9e
create mode 100644 .tmp/tsx-995/17912-d37d44196a1d23ff02a5ce204ba08ec9a9c4ff95
create mode 100644 .tmp/tsx-995/17912-d4dc10c7502ab10b749ab1be7bc36f7b3b31689b
create mode 100644 .tmp/tsx-995/17912-d7382ee44cf1386970f4d431917cd3e4fd87982b
create mode 100644 .tmp/tsx-995/17912-dc29ce204611fbb7da1c6a161c0c53eda77364b1
create mode 100644 .tmp/tsx-995/17912-dcbc376d37cbadf4d123a56a6aaa77b76fe9f00a
create mode 100644 .tmp/tsx-995/17912-de3b0226dbdc2fa27cfb5ab7450ad258a3d3ee6d
create mode 100644 .tmp/tsx-995/17912-de4bd082c883af3e98b48947f07a2991fcd29c8e
create mode 100644 .tmp/tsx-995/17912-dec15f20605613c21db0ff9a84dba9d643f3c1f9
create mode 100644 .tmp/tsx-995/17912-df26b9073cb7ad8567013cd69caf90a4521eef90
create mode 100644 .tmp/tsx-995/17912-e16e40a094bd191310531a7bfaf246a4c1868d6f
create mode 100644 .tmp/tsx-995/17912-e2d272d2232de2ae9ba0dbb8ab7407cc54e9f6e9
create mode 100644 .tmp/tsx-995/17912-e2e52f06201bf51d13694a307b6c40aa4fc3fa5d
create mode 100644 .tmp/tsx-995/17912-e5f4f345c38abce071840c4afffc72ad05f1415f
create mode 100644 .tmp/tsx-995/17912-e80584a635a2f28a49d32ded262bbae85b013784
create mode 100644 .tmp/tsx-995/17912-e910c3db12ac967fe118300d42df126ae76f1ed8
create mode 100644 .tmp/tsx-995/17912-ef5cb40e3542b566dd0fe3d21a011019910045d3
create mode 100644 .tmp/tsx-995/17912-f0564eba7b01a95d27a5ca160184ac2150fec970
create mode 100644 .tmp/tsx-995/17912-f3ff7179a11d31ef5792e3e75e023faa5f6f969c
create mode 100644 .tmp/tsx-995/17912-f49caee4e4476cc8dbd988420aeec1d5f4308abc
create mode 100644 .tmp/tsx-995/17912-f5bf1723294bb3eb5a423e82bffa3dc26497e919
create mode 100644 .tmp/tsx-995/17912-f7a16c4f76ccec6ff7b54158f6cb311508008b02
create mode 100644 .tmp/tsx-995/17912-fb02bf1c64de25bdf7603d6963ac4a3bf86a38b8
create mode 100644 .tmp/tsx-995/17912-fcc7fcfca02136ed9a0dfe17f54fd2071f605d6d
create mode 100644 .tmp/tsx-995/17912-fd60db2b567ebd11ca85e00665773c0a7e13c616
create mode 100644 .tmp/tsx-995/17912-fd98761be189adb8585c9884f95f3895dd347225
create mode 100644 .tmp/tsx-995/17912-fe153e5ab3b2f566a9af275da0a122a02edebf56
create mode 100644 .tmp/tsx-995/17912-fec2c009d800c66edd615f056d5cd25162d9f8bb
diff --git a/.tmp/bili-absorb-Ez6926/anthropic/unknown_315f99dcc617d1cfa224e9e6.json b/.tmp/bili-absorb-Ez6926/anthropic/unknown_315f99dcc617d1cfa224e9e6.json
new file mode 100644
index 0000000000..7f03644332
--- /dev/null
+++ b/.tmp/bili-absorb-Ez6926/anthropic/unknown_315f99dcc617d1cfa224e9e6.json
@@ -0,0 +1 @@
+{"version":3,"savedAt":1791263050859,"id":"t-absorb-persist-p8adhu9qsv","payload":{"version":3,"savedAt":1791263050859,"id":"t-absorb-persist-p8adhu9qsv","meta":{"protocol":"anthropic"},"stats":{"requests":0,"tokensSaved":0,"inputTokens":0,"cachedTokens":0,"outputTokens":0,"cacheSamples":0,"lastInputTokens":0,"compressCreditTokens":0,"contextTokens":0,"retrieveCalls":0,"retrieveHits":0,"retrieveMisses":0,"retrieveDropped":0,"retrieveDelivered":0,"storedBytes":0,"storeBytesSaved":0,"rangeRestores":0},"metadata":{"biliVersion":"0.1.185"},"state":{"blocks":[],"messageRefs":{"byRaw":{},"byRef":{}},"tokenSnapshot":{},"nudge":{"lastPerMessageNudgeTokens":0,"lastNudgeShownTokens":0,"baselineTokens":0,"anchors":{},"lastShownByTier":{}},"stats":{"tokensCompressed":0,"compressionCount":0,"absorbedTokens":4321,"imagesShrunk":0,"imageBytesSaved":0,"imageTokensSaved":0,"storedCount":0,"retrievalCount":0},"absorbed":[{"toolCallId":"call_1","callMessageId":"a-tc","resultMessageId":"t-res","summary":"Build passed.","tokensReclaimed":4321,"createdAt":1791263050858}],"rules":[],"nextRuleId":1,"imageFullRestored":[],"imageShrinks":[],"nextBlockId":1,"nextRunId":1},"blockContents":{},"createdAt":1791263050858}}
\ No newline at end of file
diff --git a/.tmp/node-compile-cache/v22.23.2-x64-9de703df-995/0014c7b4 b/.tmp/node-compile-cache/v22.23.2-x64-9de703df-995/0014c7b4
new file mode 100644
index 0000000000000000000000000000000000000000..c8e4630c879bd2658239aa007ee7b6946359d689
GIT binary patch
literal 1060
zcmY*XO=uHQ5T3U`c}X@kQG`~gA(l{bkggZ;B4}%h28*q&9)xH%+pIPvNz-goETZ(#
zAM8ObR8&a4sMj9EgU5P8bWmtcE031B
z5A9Sclf~-X5Ezs|!W#G~hXULMs3(@ARhFq3hvhBjfp;=RJ+ssuKWX$u)DYb
literal 0
HcmV?d00001
diff --git a/.tmp/node-compile-cache/v22.23.2-x64-9de703df-995/03f36f82 b/.tmp/node-compile-cache/v22.23.2-x64-9de703df-995/03f36f82
new file mode 100644
index 0000000000000000000000000000000000000000..ec7427a8989c57ccdc00445407ff3a7626abd500
GIT binary patch
literal 1068
zcmZ`&O=uHQ5T3XDl9y&v8)|8Tl#oLs5o=RL3xeQJBUtoe+JhoBn=~)DB|q&Z5sL_l
zL~T(h{?PW|$$~d2(u3aGi{s2Ycv`qTW0zmgZuec}Z-0aNzBm`DS)@zM0vVD__Ry
zH2@z6D6ghx276z>3pqc}75*%b5dKU)>9~9T`_zUG|AYnl^kZVyB%liq^N6Qz&XrA=
zU-yY3OOo1(hjAU6uNlB6Ssn2EhI^bf^wnRe&$-_+it&rz9={$E!^|Ypg@+yPO_2U=
zSVe$?3=}K~#6ixQq61@}K9(EN9LQyc;)PYyWi`
zJ>g>B4yUa|IGan#SSFV&re!{y9m?zk@-lN(+F>hOkajkn4qIClcMMX|JE}q(BB}?(
zdAr<3gSDPB38TI^;FQLRz|v$PFA%WhaM7}*BK70?o%c?}Dplc&-e_X)tC3MRVzF4t
zO3Q3KBhf%1-_rb|s6#y#OIlcE%>^a}kT9RP$V}33VW5Rpp{=?KR7_vfjh2bRkxn
z$wW#=r7zj6CDcG;2_XlSA~oBKAmT;YgAorl714w2PqT$B`Du0&FbLX9
z)e4@psGuO|*+cQ*(R!}n#R>|F2p+t95Ja8t?S|BW*`4`j-n^Ol-qxotcW#)B9oHGV
z`+e)f_K62aXD2?t?*I8X1pX}8tle7p_NYYhk?`sTeNMh~;qNEqrhH-up?qK!y&wnN
zhe;I}7do4ItmRG`Pd#82`O~cEMcLynTomSWiz@w1j{{;E^(CDC+-!Ke5BsqsI|_P(
zFbbH9_#$atS$|1vRU0@2ty7!SSuW2Da)Z0LW|9=;eq6h`GeLH{+Z?n4U<)4NS<+f?
zb+sGyWA_p{*Qrch6!{tX)yOhlZ7iSNdH?nZMXW&_S*_5wI^AaAB!yzDv)WeRQY*BA
zPCpvfR$@vf`L8fQjs;;qkaG3qQlyYZ|
zxC1|esY$TAk*t&Pf|OSiT2IZ7BIAEuodR=XEafdLpSu86^?AyJp)poa1hLXS1ZjqQ
z)1tg)+b$gJWzD`~`5$ZN_JQ<;5Xwoilzcqp?Z!O+yvA
bdEdkN^lpW2`Wc3IL-)zjTg_gF6wKn`uw^yq)iX;?UiH$Vw#wkauvh`d~f!yUWvy`_V&%2
z-}}vb^WMzfXFp#ZuJaLc)KAD4gWloc(UB7?N`Cn+efvs3+COBY4R3Av?cKdFpBGyD
zoJWz4DLC$jhlZs01ER>sXshwmN*S6&H3|ZkiCzKECqf*sy864S19
zReTZzJ;9Q?si$?zbT~r6-&1$ik#?@#0clgwmKRJB2{xU2`%(mq4bcLMhHeK^h3x!6
z8j7hKzW?-+1em0urqj$M%0IAtg@+Jvg;-9Xl70>N2yKjYPxroBw+V33jAKU)U5lDl
zf_3y-iHyOVsF~`WYiI#W+|Z+O%S`H>+@TeS9RFP4DKjn3VRWykx60$}UtNa_YN)m{bz
z5ZtH9Q=q5luz4GtF3V1Lsb(VAywAhTD%i$$v3x`m2;u;FnR4y%TzG8?TCrXO
zZCl$kchZGHE@Vv(c8CYV*A%;Gt#p*{3)Tn)ktmormRXy+dITx&iU{ULxF2E*h5JD}
ztx>-kLme7e%@}Ftp7;-3t|d951-W;gYwB?7JnGEsw)$nQAGUuepdbjNrJ;>n$C_ay
z-~RI2(}%!$KmZuo`ugN}P`=dqPxz{oP9Z9RpTIQN0Anc6;uJYCF4!K*kA
ztU3ATh2>ZWSQh
zTj&T2PkTT5+HF8^>}L*cz^b3vI&2}+f*+7#3yV)uJar3C4$k1^nzHOTGgKY(M=9op
zKGQAdkGb)tRNG;yX0V)3Obz^aqybQJp4f5#Q?R)c-$Ku^hzhA8alq~CJ+{h%D
zyxp>UoRk`8vTa#uaSv^D?+?rn1v>-<$Krujv8q*E(Ymj7|HuLU1?+19d*KISkkCbc
zMV1N+=mZn9WT~)QAj0_vJ;Isjby1wC6i%zz>(eC@(X7{Zc6SLC&g_x`zSG(aScB(w
z`NE;I(VPC#Gu1QMp3=ChQGng9v%EHFr04=E+pm?=`yi*)HU=u;S4{SB0M&X3L!I))^I0O;B2<+E5@m;^&3uqQ!cKZzlaWq+Qh@e8-1}j5=UtRIC2A%po#K
zYH6nJCoPi0-t6pzdwwU|Bf@>aq;lCiAjw6!Xim^pLlAM-HwNu;xwu9Xy;VF$pyQmimBrpTa$
zfW$9DOn9b1bIlOru6cl=iCEs($>e1$N9(?xroQ#`KnY-r^D(hS>1UmE3*U6hxFJ(>
z-l*6P#8|-f$zlMk1`S%itFD)@qfmjE3A#Q-x-bi1tRJaD40T4_-h(z#!puZ^ZgJsk
z5cS@~(L?EhA*YY^h%b5&SbHLyi0*Ib#+X$tm#lm?V-<%7om63Xu$p(uR`F!vUq{&~
zoN`K5wpejW#dO}vm#PEQvLjcW5jwviUB)mtzE<1SdzMpa5!HF3e@WCV?I6@r(Vy~Q&9#bOxZl5-%k
zeW{@`jfX{!NG1+O{m8~UE+cbsF)SV2p(^p?q$dgNEhf}3%>im8)$HU
z3U>AT6M-{cddx-x=rf&*_0u9SFwvNQr^1`~{oux?%tT
literal 0
HcmV?d00001
diff --git a/.tmp/node-compile-cache/v22.23.2-x64-9de703df-995/16b76a41 b/.tmp/node-compile-cache/v22.23.2-x64-9de703df-995/16b76a41
new file mode 100644
index 0000000000000000000000000000000000000000..a7fb7082e7c67e9293351d1116f25a5cfc2dcab7
GIT binary patch
literal 1028
zcmZ8fO=uHQ5T3XDHk+TNM6FbzgcL&YAW1w3Ie2MVvB7HF7(t=Bn>1@p$^Rx|@uFZX
z?M1W*78MT)dXP{`1&{t*qzLvPJyh@qPgW0t2==1Ryxkbn{SuizMp#x
z0N-SQOGAsjOCuljJ)U<@>%Z2g3BPCEh|Y|CT3AKCZ7iIY52(u~<@?Z?rrz;$E^@*`
za<|%G6BO=5XIxrjzHlJ8BSCB5UFLttsZ9N$h2)4@WhQ2zqBAX(=^rQ!Q(UQ)CoJ0*
z*y+~g8EU{Pox>IDf~o9O_{d>D#`?j*qQK?CX>8UPU_o`3
znRH?oI^DW);mRuy#>H~3QLqRb%MkBHk6Py|PNp9SR^&M(t5Fy
zKrq&@Yq3H;8!MG_mf@UZ$4Zsre?YlX7iBps+n9__*%{os#q=zt(iRM00dv+nY!a*p
zACx$CzIL;2)4Xa{wUMt`z~eNX{wLG3Gy%gnlP_4MOcCEiM%>!7Rn>>FVdV0)4h1F^
zkg;9rNk8+DLLh45!4n5Gs4+1{6Az?S@gUB;Z6i$bcHaADX5Y+w^B%nW
zFxE>6ndAw1e!BX}PPYr>+Ak^Js>JT3J@q7#xwF@^z
zo@Zyos!T2+MHSp`gGG50scaUAsKFYg&al)h?cREY+HY7&dWxLlEe<^)Ovu@*OwGa|
z_2W^3MR#-uaX&W*seqW-7jV$j?hCAJUwVd#>B&G6O@92$uC)>`+pU3k0*Dm^OM>(v
zW1HmlPXTN~#Ni9xu2C*H;H>IL2Exjrbi6YVIvMC!_;Pw!_#|2(7oU2t^GuTmoaB_A
zkTo?Z$H2EQIuK52iY~|E(TzYGAR$d<;LiSZoQ0^durkzmLWkdw4Y?uUVddr5i@FWs_ci4W>y(#8A-C&5!kD!R(|!cm-|N8-Hyj}j!Y&!#
zj7F&8qLX)JJRUzDurC=;uO~>s(+!8BE)HYJwY)brdhd_BM{&?nNmT>I8ojK4|AKxI
zMx}ujzyI2ZSH%+pQB_xTS|QwrG*}X-SVE}LiLYqK$y=Q5ZAAi%7&VecJIFY7UuCg{
zr-zrJu-KY*TJ8&t9dJ@7Kw%{kNNGtJTW<^=gQj(d5^6ljCVN-4{T@y>&MHo!JD~(q
zsurGLW2Ci#X?>SR39bC;sO3hWA1}+ed49n=K6s@~TCcmwyYk
zxj=SxMQX_jMN)1-&Iu*8+^}_1!@TsXC2K2{vU|*8dGQQ^hvc{v+yb{Tb{w7LVTQA2
ahPgUB6m&UgCOEZFW2xaWk#D~w7UUmuXx;4q
literal 0
HcmV?d00001
diff --git a/.tmp/node-compile-cache/v22.23.2-x64-9de703df-995/1ac49b5c b/.tmp/node-compile-cache/v22.23.2-x64-9de703df-995/1ac49b5c
new file mode 100644
index 0000000000000000000000000000000000000000..7f1bb97e106fa2e3910f362cb94dd877bb493b52
GIT binary patch
literal 980
zcmY*XO=uHA6n?Y2>7=`x5^XR=LI_wz&~}5?TS2XRXrKq17C}L?n`BcXN!sithv20M
z(W)o^P!XY^c#*6DeEZ0rwAF~>$xpx(7P+_jjl=1
z(mzGe1?oI*BrI|>x7AnSy1JrD08Qpqxt1jGb!$C=oW!zp6nj
zCS6>1TiZ-@8gEnaw+y@@&3day+9lSKbWFxOUDd)JsDJ&+y+H@kE>uHD!dgvW`(5Ms;)duNSTbg(-;bIA&Ifs*NN7s=Ow}>2FAP8y%
z`F)E(@p=;DNRa@-AU@d_A}7{xC91^EnWjYs^<~~XX=WKlh6zC`;T;%hM^mF8?D(@l
zP4&lzsSk)5I0?kMQ(OSH{Z|uTdfhL*bd(?P%J?ZuJ0Oa+Pp637n
literal 0
HcmV?d00001
diff --git a/.tmp/node-compile-cache/v22.23.2-x64-9de703df-995/1c575097 b/.tmp/node-compile-cache/v22.23.2-x64-9de703df-995/1c575097
new file mode 100644
index 0000000000000000000000000000000000000000..155183b476a60d7ecc4313e82a6555964e4ea22a
GIT binary patch
literal 908
zcmY*XJ8Tm{5S_i-%lghIFvKE=kL4mkDI#AQI>g6vL4XDaAt;dVY;UAPK0Cg%qeL`N
zgkOUIAwYr(gdz%rPznkPLV<+DClsUr2?BI9R3OqM%yT;*FoDlA>yBpZu?AI`_+@AGt)j_XI&xGtGF~S8Ta(cShFTHFo!Lci
zi@9^I5AAUo9G4-0Oa6tmeK4l1HI#x!SXZb8mM&KI<{wu#p`FV)m6{htGIAmrOwk=m
zuqEumOp5oKdkB#$s5g0<9TZ=!1eR6wA8emq&LiryqtL1OWvAY#%2Lp%wrhAdmn_6er3t?#>s}!7fI_~dg+*baT`E=m@V_e_
zs|reslguTH=pP{B2Rp=5F){IRaTJu%Z6scGMx_z)i8%u@ifFq_G(#5$)op^ZIx>s<
zBUF}+|Gx9>C#6Mj7y~6RTz|vxxMTauL|JKdB+DpS_g)HwNjI1AHfCXdf5P?MuYvEnX2t==ar<@mA~c;l$`(o
literal 0
HcmV?d00001
diff --git a/.tmp/node-compile-cache/v22.23.2-x64-9de703df-995/1e880b66 b/.tmp/node-compile-cache/v22.23.2-x64-9de703df-995/1e880b66
new file mode 100644
index 0000000000000000000000000000000000000000..6147928cdb69beb39e6ccbd396d19b8e0cbb6536
GIT binary patch
literal 1500
zcmb7DU2M}<6u#HFi50tpm5jR|fOH?b48
z3WPSqZ-wAxZJ8#}1{6&^R0t-m4|||{pn%G#5bMLn-?TmLWly80
zL`?B}6W52}p^A7;W{j`V*B0pz8+0GSweV0DA?tP~Nu00;bn$0KNRq@4G`U5Y1O(xS
zLHH?^f6PYL$?szZNGJZIv_;+(Yt+Og6h&w;S3vwzjpBzii<1CTrPrD}TlYo4o?UA=
zo=vFQTbMX?_wOY5D%OCVt6HDB8@!T_e2889`uem2xatj796t!dlE)6Oy4i|nR;|7P
zt7LC-_v5Z0cA?!qqXKsP?!ltHd8nEVNVKK5Z+KIRrXW_d_gal|9fDo1U$@HTT%YGu
z>pXYopW{2QCf_N!R(Y%C!U0~G`*J@UTgr3iY;V8qg{esid?bf2u&Gxc{qJv=iCbQQ
zWh}lqeBtlL!q2~bHQfTfP6MUVebh>~K&;Mweskp9@$X+*4xIIFwbEC1j8M3M41VN1
zyJ(KR!SjUD={9H=CP5AeU-6JjEW)|ek
z#YPXl#W{|z`&=tMJdx9&U7NVjZ
zKgsZZ77#A7UjWmUADigH9*>fZ0%I$%#s4~RY$gV-pq4<*Rg*&}W$@+md!4fFS``}>
zV0iPnsaY`&IG-;%-a?3&NI;|Q;;vxAaB@;ON*LjH!`W=wQ2-P0&~z}z8&)?X3*Roj3)^(TM+k3HNxWpDlV{%zJOlzE
zD&dFxjNJ>C`ZC3`hcg)y7pTkUnLU{TMJAY%6*!s=*<9ON8X}8}IYFe>=Lx0>suoc-
zrfN}Di>aEZYLcqOQ^NEzdefeNMzjcG0kNPl#1X_yiy~%-W7EcbRMKL`d`#9vbc^U#
zGzqbUc!?H28YjZ-#EbW$vbqE$f^Jkt3U5MH{IcqL@MH;7u}(rp3sHhi05<{(GVX=9
INyxJNA0pR2`Tzg`
literal 0
HcmV?d00001
diff --git a/.tmp/node-compile-cache/v22.23.2-x64-9de703df-995/1f9b0e5c b/.tmp/node-compile-cache/v22.23.2-x64-9de703df-995/1f9b0e5c
new file mode 100644
index 0000000000000000000000000000000000000000..f6b5fcff90285e0a5cdef5297896b18db7239857
GIT binary patch
literal 980
zcmY*YO=uHQ5T3XDHk)oXZPD6_gs@@}J(vX49HrU_t$H!`B1E#g$riWfe;cHD(L?seSUpG;4?UHl61CpE8|p=!d7Cutz?;nbzS;NYn|XQl<=bs30I(zj
zJnK8Q-dlgScp%VRn*RHFhVUm&BX;BL&xenZ?-(;C?FK5WAfhIE7CB?mMiJ|T#Hsw%
z2h*O4K+UPv-I{|nHe{p#?;{v8xYf5SY7fTQ
zY~HPPDKII4jO|v>``yF7zz_{)xIGvu#ve?|#86mN)^RXG8I{Jk48fa;_8|1mAQ(~{
zgxaA0o$#~hU*KZKIl&!I2zZ+t7tBAjtuVbK7F3^_1d7uQ%%ea8=m&Ahon1tthWQ~r
zKteX(!N)lziFx2%6bWF)P-_$A@qA{%X6=cbUSUA5WxjomFPa*AHFY6nOM(QTG&*dq
zoyIfFP+wv-B-uBj$*3$I8EuTtHx$63P8tYo)r<|1KFl&EEnk!1;QP>@WJ_kDjbw|<
zq1I7FQF^IeD0J9w*m{*D`_DuK=*CTos9`CKqK=7{>Gv!e6BTry1qO**uodw~kziy8
N6D_>kRua-S?LTYBn%@8b
literal 0
HcmV?d00001
diff --git a/.tmp/node-compile-cache/v22.23.2-x64-9de703df-995/2037509d b/.tmp/node-compile-cache/v22.23.2-x64-9de703df-995/2037509d
new file mode 100644
index 0000000000000000000000000000000000000000..36589ad3ec0c67faa2f13831a622980cdfd289c9
GIT binary patch
literal 2756
zcmZ`5TWl0n^xm1fJKNo%-9Dr(kFt@jA>ei!gvO5w1-IBjN$l1D#x$MT-RXAP?e2DF
zS3wCOq^&}Nw1j62iAG3JBLPFS8Xqk}sW0pYApsI!L=xdkp|zlb=iHfX>xU&;Y>)5325MHkTGTBhDGQU>*gBlkNyM?BMK
zIT?0@#PHREFMyGUtN(XxRFL%$Af$33`-LGzL#_=JypNZrjZ`#{NX6L#S`v<~TYjPh
z-K|TeyQ2v`m{y}*YFrC+qOAaE+NEQQp2`Qjswx;!O)U`Zj#YJE{19dtHj$P3EvSg2Q^vJR-^*_5D2p+bcGdmpHOGT9S;MD@Sqn}
zBLjOF;ERo{WgpPy9Y2!7^ej&3CPbY`zdCr-#_VY2)?D=d1{s8EFol&+pLD{l;2u*)
z70KaIBs<;G1eFE_&J5;(;(t8SQF{vpN%uU`L2J7jQY=AHUd`jew@{NTz2jB^A+ztp
zc%IsuDaG23rn=J!Eu&kJCWH%jqIUr3aBoN|6k2IDnj~@x+yW*Y^!!JZf~eH&v}kx1
z0JY#<=gySGFn8KkExI{nbeWJ~4RU7*3n*&U^r2Q1U;1659~>p&Y_cV4=xGcm0`wpF
zljmtveuEmiT>uw^SRHMUes;SEtqjL+PJO&@1qcSSrV&i&kzg_v)7rXIv1~#!gHT+Y
z2p)H<$(R|0>;+7Ifn6fp9=s_BA>MtqfjJ_%2pC<^q#yxP?jUOg#>%iVZoSg~EoRWV
z)AIhYp>4Y{(rs<+dO}O8-5P8F(A6s=;}W{s))v!^85U7c0D(41&r=1lLU>AX1XbE2
z2(PwA(0~FchYC@K5ybt#Hp3C*I(v>#y+w$WF6VxsI-Hy13ZUPJ1`ibAcphm5*)yAH018!H-LBrP_M!DOtGaOv86Fd
zjka{Cly%J9@E6oo6*gr9KOz#@K7u){w~y?ak;lfuhs6%CoY#cbUls`{BI{;ZB-YxQ
zTMi5>bC(rBIaG*ckhvJ*3*e!>c|uGcquwEhywy8Q-EUHN+P#y?2j0W5+8>K2a~VY&
zaS{sezSXu6aA+N$YDDymp&HwK_B{1j#SV=J!P?a>f(g5=p@YGul^YdU2!1E9G{3$$
zp<-#ilxtXI0wC|f^_9G&r+KIoc`#n@f3xAyxq$1*Xd)Za0@E@9BbCZn=RfalAH#6!
z?SZtRnOYL)2&nsIefxeK7J59HGBmqEK|kvLux(>Q5%Ai96E{-XWNe0?J73hhcNoKA
zIU6uLv_yjQpgl)FY8b`Lr&UAkMxAiqt;CJ_Xv@qrKxv4>QGv>X3ZgtbvK1bTKAJMO
zdH!ZBrdoTPtn$4O2>5DMBW|v01-kSZV|P)|2rt@K3IxlaMwqsGRL@M0L2g6;`Bk6r
zc$h6{E_{&S007!|^Yw*wSV_?iE!q{*UaU{X^(0Ks4iuQ(zQv?Qpk#+2_-h1FEM_%=
z!?D9D!A^1&)(9?lQH_u%1Ln?$m&cory$(Q^Snd8xkDWz}%-<}g;5zd`_wni@)@Q4Z
zdZptLObCM9h1nD3{%K_FL0D2xF@)|YS&2`RXu$2&uQ}7Hb##^wip{`
zW9%e5&4$=GAF^Aw0C)COdW|^d{pn$T!Rr^je&+Q%ynbh?Fj`D6Xp<9UG&l+25Ro7v
zf%zHY3~}dIh&m8;ft=IrcOXGRf(!zTerOH*d1obH3vcy-WS9PbPw2=$k`9WnaD^
zTqt&*?<)|6kv=aIhWiQ~!WZQecgpYm(Xou&b@mlGg)fym6W;lgv~0(X?s@@LQ?MNpv)L6kT*<
zfkr#gC$<4@Mv_GrAJi=BjNxr%I{#06)7z}}Vd23qxjo}&epNQVX~B2YNo$rm;bm!z^Wn4}9}n_!2yvG8lNO
z>V?-!!GGQ#4h8*54RQ%Zh6$k+T(5N5Y$ROs;K*I?UfH=7g50S@+#L=D+>vNd8ybxU
zQ(-OPj>JZbfM_hq!jj`Ltu?6aOSC=5%K1-Dz(>5Sk63S^y#W)hw%>;s_Esc4JjI4x
zIF?L6B_ytmr9yFyHSx-ehrY!o=Ca8Z)igi;su{4Mp?#sS7V(d2Fag7YFD!f~nZO?!
z3WnmhmWU4n(71b~CpjN_7-mN~HtKT3WO8!c>jRfronQeuvdS