@superblocksteam/vite-plugin-file-sync 2.0.158 → 2.0.159-next.1

package/dist/ai-service/llm/context-v2/context.js

@@ -1,17 +1,18 @@
 import { randomUUID } from "node:crypto";
 import { performance } from "node:perf_hooks";
 import { setImmediate } from "node:timers/promises";
-import { getPrefixedLogger } from "../../../util/logger.js";
+import { getErrorMeta, getPrefixedLogger } from "../../../util/logger.js";
 import { LLMObsTracer } from "../../llmobs/tracer.js";
 import { findBreakpoints } from "./caching.js";
 import { SERVER_COMPACTION_INTERRUPTED_SUMMARY, SERVER_COMPACTION_SUMMARY, ServerSideCompactionStrategy, } from "./compaction/server-side.js";
-import { DEFAULT_CACHING, resolveContextOptionsV2 } from "./config.js";
-import { recordContextPersist, recordServerCompaction, recordTurnsSinceLastCompaction, } from "./context-metrics.js";
+import { compactionThresholdTokens, DEFAULT_CACHING, resolveContextOptionsV2, } from "./config.js";
+import { recordContextPersist, recordPreflightCompaction, recordServerCompaction, recordTurnsSinceLastCompaction, } from "./context-metrics.js";
 import { OperationQueue } from "./operation-queue.js";
 import { CLIENT_COMPACTION_MARKER } from "./storage/event-types.js";
-import { getTotalInputTokens } from "./token-tracker.js";
+import { estimateMessagesTokens, getTotalInputTokens, } from "./token-tracker.js";
 import { toStoredMessage, toSdkMessages, CACHE_BREAKPOINT_PROVIDER_OPTIONS, normalizeToolMessage, stripUndefinedFromToolOutputs, repairBrokenToolCalls, repairOrphanedToolResults, enforceToolUsePairing, normalizeReasoningProviderOptions, stripUnsignedReasoning, stripTrailingAssistantPrefill, extractTokenUsage, } from "./types.js";
 import { uniquifyFilePartFilenames } from "./uniquify-filenames.js";
+import { makeJsonSafeValue } from "./well-formed-text.js";
 const logger = getPrefixedLogger("[context-v2]");
 /**
  * Persists slower than this get a warning log with the message count.
@@ -21,6 +22,71 @@ const logger = getPrefixedLogger("[context-v2]");
  * Raise or remove once per-turn full-file rewrites are addressed.
  */
 const SLOW_PERSIST_WARN_MS = 500;
+/**
+ * Deadline for the pre-flight oversize compaction pass.
+ *
+ * Sits just above the summarizer's own per-call budget
+ * (`DEFAULT_COMPACTION_SUMMARY_TIMEOUT_MS`, 240s) so the deadline stops firing
+ * before the work it is waiting on can even finish.
+ *
+ * Picked from production rather than from taste. Measured over the four weeks
+ * to 2026-09-01, client-side compaction
+ * (`superblocks.clark.context.server_compaction.duration_seconds`, filtered to
+ * `path:client`) ran 6,690 times with a mean of 36.8s, an hourly-worst-case p99
+ * of 238.7s, and a peak of 382.8s. The earlier 120s value sat under the p90 of
+ * the hourly maxima, so it abandoned passes that would have succeeded on
+ * exactly the largest histories, which are the ones this check exists to
+ * rescue. Even 250s does not cover the peak; a pass past it degrades to the
+ * provider rejecting the request, reported as `context_too_large`.
+ *
+ * A longer deadline is only affordable because of the latch. Without
+ * `oversizeCompactionExhausted` a doomed pass would be restarted on every
+ * prompt, so the wait would be paid per message rather than once per
+ * conversation.
+ *
+ * `compact()` accepts no abort signal, so a pass past its deadline is abandoned
+ * rather than cancelled and keeps running (and billing) in the background.
+ * `oversizeCompactionSettled` is what keeps a sibling pass out while that
+ * orphan is live; raising this value without real cancellation lengthens the
+ * orphan window it has to cover.
+ */
+export const PREFLIGHT_COMPACTION_TIMEOUT_MS = 250_000;
+/** Thrown by `withDeadline` so a slow pass can be told apart from a broken one. */
+class DeadlineExceededError extends Error {
+}
+/**
+ * Resolve `promise`, or reject once `timeoutMs` elapses.
+ *
+ * Deliberately local rather than reusing `withRpcTimeout`: that helper logs
+ * "RPC timed out", which would misdirect anyone triaging a summarizer stall.
+ */
+async function withDeadline(promise, timeoutMs) {
+    let timeoutId;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_resolve, reject) => {
+                timeoutId = setTimeout(() => reject(new DeadlineExceededError(`compaction did not settle within ${timeoutMs}ms`)), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timeoutId !== undefined) {
+            clearTimeout(timeoutId);
+        }
+    }
+}
+/**
+ * Which family a compaction strategy belongs to.
+ *
+ * Read by instance rather than from a field on the interface: there are exactly
+ * two implementations, `ServerSideCompactionStrategy` is already imported here,
+ * and a `kind` member would have to be added to every strategy and every test
+ * mock to answer the same question.
+ */
+function compactionStrategyKind(strategy) {
+    return strategy instanceof ServerSideCompactionStrategy ? "server" : "client";
+}
 /** Messages replayed between explicit event-loop yields in initializeWith. */
 const REPLAY_YIELD_INTERVAL = 100;
 /**
@@ -163,6 +229,49 @@ export class ContextV2 {
     // When disposed, this context may still be referenced by in-flight streams.
     // Keep it inert so stale generations cannot persist cleared history.
     isDisposed = false;
+    /** Shared by concurrent callers so only one oversize pass ever runs. */
+    oversizeCompactionInFlight;
+    /**
+     * Largest `extraInputTokens` any caller attached to the in-flight pass.
+     *
+     * Callers sharing a pass can have sized different tool surfaces, and the
+     * shared promise would otherwise silently decide on whichever one happened to
+     * start it. Max fails safe: under-counting skips a compaction the request
+     * needed, over-counting only runs one it could have skipped. Read when the
+     * queued callback actually runs, so anything attaching before then counts.
+     *
+     * Defensive rather than an observed bug: both callers have to be on the SAME
+     * ContextV2, and the nested one-shot path uses `context: { mode: "stateless" }`,
+     * so it never shares this instance.
+     */
+    oversizeCompactionExtraTokens = 0;
+    /**
+     * The summarizer call itself, unbounded by the deadline the caller waits on.
+     * `compactIfOversized` holds the in-flight guard until this settles, so an
+     * abandoned `compact()` cannot run alongside a fresh pass.
+     */
+    oversizeCompactionSettled;
+    /**
+     * Set once a pass has ended with the payload STILL over the threshold, for
+     * any reason: the strategy declined, the pass threw, the deadline rejected,
+     * or it ran and reclaimed too little. While set, `compactIfOversized` returns
+     * immediately and starts no new paid pass.
+     *
+     * The restore-time version of this check got the same protection for free,
+     * because `ContextManagerV2` only invoked it while a pending flag was set and
+     * a pass that tried and failed never re-flagged. Moving the check onto every
+     * `streamText` dropped that, so a summarizer that hangs would stall every
+     * later prompt for the full deadline and stack concurrent billable
+     * summarizations over the same history. The provider rejecting an oversized
+     * request takes ~130ms; this took two minutes per prompt. Worse than the
+     * wedge it exists to fix.
+     *
+     * Deliberately NOT cleared when a pass succeeds and the payload now fits, so
+     * later regrowth can still be rescued. Reset only in `setCompactionStrategy`:
+     * a different strategy is the one real change that could produce a different
+     * outcome, and New Chat resets it for free by constructing a fresh instance.
+     */
+    oversizeCompactionExhausted = false;
     // Persists currently mid-flight. A persist that has already passed the
     // dispose guard is committed to writing the snapshot, so `dispose()` alone
     // cannot stop it; `drainPersists()` lets a caller that is about to overwrite
@@ -218,9 +327,23 @@ export class ContextV2 {
     setCompactionStrategy(strategy) {
         if (this.compaction === strategy)
             return;
+        const previousKind = compactionStrategyKind(this.compaction);
         this.compaction = strategy;
         this.compaction.updateConfig(this.config);
         this.compaction.setCallbacks(this.compactionCallbacks);
+        // Only a change of KIND clears the latch, not any swap.
+        //
+        // `buildCompactionStrategy` returns a fresh instance every time and the
+        // manager calls this on every managed turn, so the reference guard above
+        // never short-circuits in production. Clearing on any swap therefore
+        // cleared the latch on every single prompt, which made it do nothing and
+        // put the per-prompt stall straight back. Kind is the thing that actually
+        // changes the answer: the `ai.server-context-management.options` kill
+        // switch flipping a latched server-side context over to a client-side one
+        // is a genuine second chance, another client instance is not.
+        if (compactionStrategyKind(strategy) !== previousKind) {
+            this.oversizeCompactionExhausted = false;
+        }
     }
     setMetricIdentity(identity) {
         this.metricIdentity = identity;
@@ -669,6 +792,327 @@ export class ContextV2 {
             }
         });
     }
+    /**
+     * Compact this conversation when the request about to be sent is already too
+     * large for the model, BEFORE sending it.
+     *
+     * A long session can grow its persisted history past the model's input limit
+     * without any single live request crossing the compaction threshold: the
+     * per-request prompt stays small while storage keeps accumulating. When a
+     * dev-server restart or warm-pool recycle then restores that history in full,
+     * the first request is rejected by the provider before it reports any usage.
+     * Since `afterResponse` is the only compaction trigger and it needs
+     * provider-reported usage, compaction can never fire again, every retry
+     * replays the same oversized payload, and the app is wedged permanently
+     * (ENG-5282).
+     *
+     * Breaking that cycle needs a check that does not depend on the provider, so
+     * the size is estimated from the payload's own content. The estimate only
+     * gates the decision. The compaction pipeline, thresholds, and phase
+     * selection are the existing ones, so behavior below the threshold is
+     * unchanged.
+     *
+     * Call this from where the request is assembled, after the system prompt is
+     * set and the turn is appended: the estimate then covers the array that is
+     * actually going on the wire, the UI compaction callbacks are already
+     * attached so the user sees the summarization, and a concurrent eviction is
+     * handled by the same `isDisposed` guard as the per-response trigger.
+     *
+     * At most one pass runs at a time, and a pass that ends with the payload
+     * still over the threshold latches the context so no later turn starts
+     * another paid attempt. See `oversizeCompactionExhausted`.
+     *
+     * @param extraInputTokens tokens the request carries that are not in the
+     *   message array, principally the tool-definition schemas. The caller sizes
+     *   them because it is the layer that holds them; this class stays free of
+     *   any dependency on the agent tool types. Measured against the five
+     *   captured production sessions, the estimate reads 0.19x to 1.23x of
+     *   provider-reported usage, and tool schemas are the largest identified
+     *   part of that shortfall. Omitting this is exactly today's behavior.
+     *   Accepts a thunk so the caller's sizing work (schema conversion and
+     *   serialization of every tool) is skipped entirely when the kill switch is
+     *   off or the context is latched; a plain number is evaluated by the caller
+     *   regardless.
+     * @returns `true` only when a pass ran and the payload now fits. `false`
+     *   when it already fit (the common case), when no strategy could act, when
+     *   the pass failed or timed out, or when it ran and reclaimed too little.
+     */
+    async compactIfOversized(extraInputTokens = 0) {
+        if (this.isDisposed ||
+            this.messages.length === 0 ||
+            !this.config.preflightCompactionEnabled) {
+            return false;
+        }
+        if (this.oversizeCompactionExhausted) {
+            // The metric is anonymous by design (identity is never a label), so this
+            // line is what lets oncall find WHICH session is stuck when the `latched`
+            // count rises. One line per prompt on a wedged session is the cost.
+            logger.warn("Skipping oversize compaction: an earlier pass on this context already ended over the threshold", this.metricIdentity);
+            recordPreflightCompaction({
+                outcome: "latched",
+                durationMs: 0,
+                identity: this.metricIdentity,
+            });
+            return false;
+        }
+        const extraTokens = typeof extraInputTokens === "function"
+            ? extraInputTokens()
+            : extraInputTokens;
+        // One pass at a time, and concurrent callers share it rather than stacking
+        // paid summarizations over the same history. A later caller may have sized
+        // a larger tool surface, so the pass decides on the largest figure attached
+        // to it rather than whichever caller happened to start it.
+        if (this.oversizeCompactionInFlight) {
+            this.oversizeCompactionExtraTokens = Math.max(this.oversizeCompactionExtraTokens, extraTokens);
+            return this.oversizeCompactionInFlight;
+        }
+        // An abandoned summarizer from a timed-out pass is still running and still
+        // billing. Refuse to start a second one over the same history.
+        if (this.oversizeCompactionSettled) {
+            logger.warn("Skipping oversize compaction: a previous pass outlived its deadline and is still running", this.metricIdentity);
+            recordPreflightCompaction({
+                outcome: "skipped",
+                durationMs: 0,
+                identity: this.metricIdentity,
+            });
+            return false;
+        }
+        this.oversizeCompactionExtraTokens = extraTokens;
+        const pass = this.queue.enqueue(() => this.runOversizeCompaction(this.oversizeCompactionExtraTokens));
+        this.oversizeCompactionInFlight = pass;
+        void pass
+            .catch(() => undefined)
+            .finally(() => {
+            this.oversizeCompactionInFlight = undefined;
+        });
+        return pass;
+    }
+    async runOversizeCompaction(extraInputTokens) {
+        const startedAt = performance.now();
+        let outcome = "failed";
+        // Set once `this.messages` holds the compacted window. Anything that throws
+        // after that point (the event-log append, persist bookkeeping) happened to
+        // a pass that succeeded, so it must not latch the context.
+        let committed = false;
+        try {
+            // Estimated inside the queued callback, not before it. An earlier queued
+            // pass may already have shrunk the history, and pairing a stale
+            // pre-compaction estimate with the new messages would hand the strategy
+            // an inconsistent (messages, usage) pair and skew its phase selection.
+            //
+            // Sizes the wire payload rather than `this.messages`: `buildMessages`
+            // prepends the system prompt and strips `_superblocks`, so this is what
+            // the provider will actually receive. The estimate can throw on a
+            // malformed message (`JSON.stringify` rejects a BigInt), which the
+            // surrounding catch absorbs: this method promises never to be the reason
+            // a request fails.
+            const payload = await this.buildMessages();
+            // `extraInputTokens` is the rest of the request the provider charges for
+            // and the message array does not carry, principally the tool schemas.
+            // Folded in here rather than compared separately so the synthetic usage
+            // handed to `afterResponse` is the same total this gate decided on;
+            // passing a messages-only figure would make the strategy's own threshold
+            // check disagree with ours and decline the pass we just asked for.
+            const estimatedTokens = estimateMessagesTokens(payload) + extraInputTokens;
+            const threshold = compactionThresholdTokens(this.config);
+            if (estimatedTokens <= threshold) {
+                outcome = "fit";
+                return false;
+            }
+            logger.warn(`Request payload is oversized: ~${estimatedTokens} estimated tokens > ${threshold} threshold ` +
+                `(${this.messages.length} messages); compacting before sending`, this.metricIdentity);
+            // Input-only synthetic usage: `computeContextUsed` measures the input
+            // window, and a non-zero output count would inflate it.
+            //
+            // Bounded, because a summarizer that HANGS rather than throws would
+            // otherwise block this turn forever. `OperationQueue` is a bare promise
+            // chain with no cancellation, so it would also stall every later
+            // operation on this context. The deadline is generous: abandoning a
+            // compaction that would have worked puts us back at the wedge, so waiting
+            // is the cheaper mistake. An abandoned call may still settle in the
+            // background; it can no longer hold up the request.
+            //
+            // `buildMessages()` above primed `_cachedMessages` with the payload this
+            // pass is about to replace. `getMessages` serves that cache without
+            // joining the queue, so a reader that arrives while the summarizer runs
+            // would otherwise be handed the oversized pre-compaction snapshot. Drop
+            // it: the reader then queues behind this pass and gets the result. The
+            // common fit path returned above with the cache intact, so the request
+            // that follows still gets its cache hit.
+            this.invalidateMessageCache();
+            const settled = this.compaction.afterResponse({
+                messages: this.messages,
+                usage: {
+                    inputTokens: estimatedTokens,
+                    outputTokens: 0,
+                    totalTokens: estimatedTokens,
+                },
+                usageIsEstimate: true,
+            });
+            // Tracked separately from the deadline the caller waits on. `compact()`
+            // takes no abort signal, so a pass past its deadline is abandoned rather
+            // than cancelled and keeps running and billing; this marker is what stops
+            // the queue admitting a sibling pass alongside that orphan. It clears
+            // when the SUMMARIZER settles, whether that is before or after the
+            // deadline, so the normal path releases it without the caller waiting.
+            //
+            // The exhausted latch stops a second pass after a timeout on its own, so
+            // this covers the one case that clears the latch mid-orphan, a
+            // `setCompactionStrategy` swap. It narrows the orphan window rather than
+            // closing it; closing it needs an `abortSignal` on `compact()`.
+            this.oversizeCompactionSettled = settled;
+            // An orphan's eventual outcome is otherwise invisible: the metric already
+            // recorded `timed_out` and the request went out without it. These lines
+            // are how oncall tells "settled two minutes late" from "still running an
+            // hour later".
+            let timedOut = false;
+            void settled
+                .then(() => {
+                if (timedOut) {
+                    logger.warn(`Oversize compaction pass settled ${Math.round(performance.now() - startedAt)}ms after it started, past its deadline; its result was discarded`, this.metricIdentity);
+                }
+            }, (err) => {
+                if (timedOut) {
+                    logger.warn(`Oversize compaction pass failed after outliving its deadline: ${err}`, this.metricIdentity);
+                }
+            })
+                .finally(() => {
+                if (this.oversizeCompactionSettled === settled) {
+                    this.oversizeCompactionSettled = undefined;
+                }
+            });
+            let result;
+            try {
+                result = await withDeadline(settled, PREFLIGHT_COMPACTION_TIMEOUT_MS);
+            }
+            catch (err) {
+                if (err instanceof DeadlineExceededError) {
+                    timedOut = true;
+                    outcome = "timed_out";
+                }
+                throw err;
+            }
+            if (!result.messages) {
+                // No strategy could act, or the strategy declined. Either way the
+                // provider is left to reject the request, now labelled
+                // `context_too_large`.
+                this.oversizeCompactionExhausted = true;
+                outcome = "discarded";
+                logger.warn("Oversize compaction produced no changes; payload remains too large to send", this.metricIdentity);
+                return false;
+            }
+            // Measured BEFORE anything is mutated or written, because a compaction is
+            // irreversible once persisted and a pass can come back with the window
+            // essentially unchanged (phase 1 finds nothing prunable and phase 2
+            // declines).
+            //
+            // Three outcomes, not two. The trigger threshold is
+            // `contextLimit - maxOutputTokens - contextBufferTokens`, so 120k on a
+            // 188k model, and tool schemas are irreducible: compaction cannot shrink
+            // them, so `messages_after + extraInputTokens` can sit above the trigger
+            // threshold while being comfortably sendable. Discarding there would
+            // throw away a real shrink and send the original oversized history
+            // instead, which is strictly worse.
+            //
+            // Sendability is measured against `contextLimit - contextBufferTokens`
+            // rather than bare `contextLimit`. `maxOutputTokens` is a generation
+            // reservation, not input the provider charges against the payload, so it
+            // does not belong in a can-this-be-sent bound. The buffer does stay:
+            // against the five captured production sessions this estimator reads
+            // 0.19x to 1.23x of provider-reported usage, so a margin below the hard
+            // limit is doing real work.
+            const candidate = this.markPreCompactionBaselines(result.messages);
+            const remainingTokens = estimateMessagesTokens(await this.buildMessages(candidate)) +
+                extraInputTokens;
+            const sendableLimit = this.config.contextLimit - this.config.contextBufferTokens;
+            if (remainingTokens > sendableLimit) {
+                // Still unsendable. Keep the original history, which at least leaves
+                // the conversation recoverable, and stop paying for the same answer.
+                this.oversizeCompactionExhausted = true;
+                outcome = "discarded";
+                // `compact()` fires onCompactionStart and onCompactionComplete before
+                // it returns, so the user has already been shown "Summarized past
+                // conversation" for work we are about to throw away. Retract it, or the
+                // UI claims a summarization happened while the request goes out with
+                // the original history and gets rejected. Only phase 2 needs this:
+                // `LLMClient.createContext` drops phase-1 callbacks before they render.
+                if (result.phase2MessageId) {
+                    this.compactionCallbacks?.onCompactionCancel?.("phase2", result.phase2MessageId);
+                }
+                logger.warn(`Oversize compaction ran but the payload is still unsendable ` +
+                    `(~${remainingTokens} estimated tokens > ${sendableLimit} sendable limit, ` +
+                    `${estimatedTokens} before); discarding it and leaving the request to the provider`, this.metricIdentity);
+                return false;
+            }
+            // Over the compaction threshold but under the limit, so it will send.
+            // Persist it and do NOT latch: real progress was made, and the normal
+            // usage-driven `afterResponse` can carry on from here with the provider's
+            // own numbers instead of this estimate.
+            const underThreshold = remainingTokens <= threshold;
+            if (!underThreshold) {
+                logger.info(`Oversize compaction reduced the payload to a sendable size but not under the ` +
+                    `compaction threshold (~${remainingTokens} estimated tokens, ${estimatedTokens} before, ` +
+                    `${threshold} threshold, ${sendableLimit} sendable limit)`, this.metricIdentity);
+            }
+            // Re-checked after an await that can last the full deadline. `dispose()`
+            // marks the instance inert so stale generations cannot resurrect cleared
+            // history, and the disk paths already honour it (`runPersist` and
+            // `appendCompactionWindow` both bail on `isDisposed`), but assigning
+            // `this.messages` here would put the pre-dispose conversation back in
+            // memory on a context New Chat or a checkpoint restore just cleared.
+            if (this.isDisposed) {
+                outcome = "discarded";
+                if (result.phase2MessageId) {
+                    this.compactionCallbacks?.onCompactionCancel?.("phase2", result.phase2MessageId);
+                }
+                logger.warn("Discarding an oversize compaction result: the context was disposed while it ran", this.metricIdentity);
+                return false;
+            }
+            this.messages = candidate;
+            committed = true;
+            this.invalidateMessageCache();
+            if (result.skillsNeedReload) {
+                this.skillsNeedReload = true;
+                this.readSystemSkills.clear();
+            }
+            if (result.eventLogAnchor) {
+                await this.appendCompactionWindow(this.messages);
+            }
+            await this.persist("compaction");
+            outcome = underThreshold ? "compacted" : "progressed";
+            return underThreshold;
+        }
+        catch (err) {
+            // Never rethrown, and latched so it is never retried: a summarizer that
+            // threw or blew the deadline would stall every later request for the same
+            // deadline and fail the same way, which is worse than the wedge. Degrade
+            // to letting the provider reject the request, now labelled
+            // `context_too_large`. The estimate itself can also throw here
+            // (`JSON.stringify` rejects a BigInt), and latching that is right too:
+            // a malformed message will still be malformed next turn.
+            //
+            // Not latched once the compacted window is in memory: the pass did its
+            // job and the request goes out with the smaller history. Latching there
+            // would block the next rescue over a bookkeeping failure.
+            if (committed) {
+                logger.error(`Oversize compaction applied but its bookkeeping failed: ${err}`, { ...getErrorMeta(err), ...this.metricIdentity });
+                return false;
+            }
+            this.oversizeCompactionExhausted = true;
+            logger.error(`Failed to compact oversized payload; leaving it to the provider: ${err}`, { ...getErrorMeta(err), ...this.metricIdentity });
+            return false;
+        }
+        finally {
+            // Telemetry only: `outcome` is assigned on every path and nothing here
+            // touches control flow, so a metrics failure cannot change what the
+            // request does.
+            recordPreflightCompaction({
+                outcome,
+                durationMs: performance.now() - startedAt,
+                identity: this.metricIdentity,
+            });
+        }
+    }
     async getMessages() {
         // Fast path: return cached result when messages haven't changed.
         // This avoids re-running 10+ normalization/repair passes and avoids
@@ -677,9 +1121,23 @@ export class ContextV2 {
             logger.debug(`getMessages: cache hit (${this._cachedMessages.length} messages)`);
             return [...this._cachedMessages];
         }
-        return this.queue.enqueue(async () => {
-            // Re-check inside queue in case another enqueued op just computed it.
-            if (this._cachedMessages) {
+        return this.queue.enqueue(() => this.buildMessages());
+    }
+    /**
+     * Build the wire payload. Split out of `getMessages` so a pass already
+     * running inside the operation queue can size the real payload without
+     * re-entering the queue and deadlocking.
+     */
+    async buildMessages(source) {
+        // A `source` means "size this candidate window", not "this is the context
+        // now": the cache is neither read nor written, so a candidate the caller
+        // ends up discarding cannot leak into the next real request. Same function
+        // either way on purpose, so the before and after measurements are the same
+        // shape and a difference between them means a real difference in payload.
+        const isCandidate = source !== undefined;
+        {
+            // Re-check in case another enqueued op just computed it.
+            if (!isCandidate && this._cachedMessages) {
                 return [...this._cachedMessages];
             }
             // Strip system-role messages from the conversation array before
@@ -695,7 +1153,7 @@ export class ContextV2 {
             // marker through would put a second system-role message in the
             // middle of the `messages` array and 400 the request on the
             // first post-compaction turn.
-            const conversationMessages = this.messages.filter((msg) => msg.role !== "system");
+            const conversationMessages = (source ?? this.messages).filter((msg) => msg.role !== "system");
             const allMessages = this.systemPrompt
                 ? [this.systemPrompt, ...conversationMessages]
                 : [...conversationMessages];
@@ -753,21 +1211,27 @@ export class ContextV2 {
             // prefill), so they cannot orphan a tool_use. Cache-breakpoint application
             // below mutates providerOptions only and is safe.
             const enforced = enforceToolUsePairing(deduped);
+            // Compaction can persist a lone UTF-16 surrogate (emoji split). Bedrock
+            // then rejects the Converse body as invalid JSON. Repair on the wire
+            // only so already-poisoned chats can send without rewriting history.
+            const jsonSafe = makeJsonSafeValue(enforced);
             // Apply cache breakpoints (recompute indices after filtering since
             // the .filter() step may have removed messages, shifting positions)
             const repairedBreakpoints = findBreakpoints({
-                messages: enforced,
+                messages: jsonSafe,
                 hasSystemPrompt: this.systemPrompt !== undefined,
                 config: this.caching,
             });
             for (const idx of repairedBreakpoints) {
-                if (enforced[idx]) {
-                    enforced[idx].providerOptions = CACHE_BREAKPOINT_PROVIDER_OPTIONS;
+                if (jsonSafe[idx]) {
+                    jsonSafe[idx].providerOptions = CACHE_BREAKPOINT_PROVIDER_OPTIONS;
                 }
             }
-            this._cachedMessages = enforced;
-            return [...enforced];
-        });
+            if (!isCandidate) {
+                this._cachedMessages = jsonSafe;
+            }
+            return [...jsonSafe];
+        }
     }
     async onCompactionDetected() {
         const detectedGeneration = this.activeServerCompactionGeneration ??