@superblocksteam/vite-plugin-file-sync 2.0.162-next.2 → 2.0.163-next.0

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

@@ -1,16 +1,18 @@
 import { randomUUID } from "node:crypto";
 import { performance } from "node:perf_hooks";
 import { setImmediate } from "node:timers/promises";
+import { promptCostTokensFrom } from "@superblocksteam/library-shared/types";
 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 { compactionThresholdTokens, DEFAULT_CACHING, resolveContextOptionsV2, } from "./config.js";
-import { recordContextPersist, recordPreflightCompaction, recordServerCompaction, recordTurnsSinceLastCompaction, } from "./context-metrics.js";
+import { recordContextPersist, recordPostCompactionRecompute, recordPreflightCompaction, recordRetainedScreenshots, recordServerCompaction, recordTurnsSinceLastCompaction, } from "./context-metrics.js";
+import { FileReadLedger } from "./file-read-ledger.js";
 import { OperationQueue } from "./operation-queue.js";
 import { CLIENT_COMPACTION_MARKER } from "./storage/event-types.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 { toStoredMessage, toSdkMessages, CACHE_BREAKPOINT_PROVIDER_OPTIONS, normalizeToolMessage, stripUndefinedFromToolOutputs, repairBrokenToolCalls, repairOrphanedToolResults, enforceToolUsePairing, normalizeReasoningProviderOptions, stripUnsignedReasoning, stripTrailingAssistantPrefill, extractTokenUsage, SUMMARIZED_TOOL_OUTPUT_PREFIX, } from "./types.js";
 import { uniquifyFilePartFilenames } from "./uniquify-filenames.js";
 import { makeJsonSafeValue } from "./well-formed-text.js";
 const logger = getPrefixedLogger("[context-v2]");
@@ -186,6 +188,34 @@ function stripScreenshotMediaFromToolMessage(msg) {
     logger.info("Stripped screenshot media from tool message before storage");
     return { ...msg, content: strippedContent };
 }
+/**
+ * Return `messages` with screenshot media kept only on the newest screenshot.
+ *
+ * Pure: messages that are not rewritten come back by reference, and when
+ * nothing needs stripping the original array is returned unchanged, so the
+ * common case allocates nothing.
+ */
+function stripAllButLatestScreenshotMedia(messages) {
+    let latestKept = false;
+    let retained = 0;
+    let stripped = 0;
+    let next;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (!msg || !hasScreenshotMedia(msg)) {
+            continue;
+        }
+        retained++;
+        if (!latestKept) {
+            latestKept = true;
+            continue;
+        }
+        next ??= [...messages];
+        next[i] = stripScreenshotMediaFromToolMessage(msg);
+        stripped++;
+    }
+    return { messages: next ?? messages, retained, stripped };
+}
 export class ContextV2 {
     systemPrompt;
     messages = [];
@@ -198,6 +228,21 @@ export class ContextV2 {
     rootDir;
     skillsNeedReload = false;
     readSystemSkills = new Set();
+    /**
+     * Reads the model can still see, so `build_readFile` can stub a redundant
+     * re-read instead of re-appending the bytes.
+     *
+     * This lives here and must not be moved "up" to `AppShell` for convenience.
+     * `AppShell` is per-app/dev-server and shared across conversations, so a
+     * ledger there would answer "already in context" after a New Chat for a file
+     * the conversation has never seen. `ContextV2` owns `messages` privately, so
+     * it is the only layer that can answer whether a tool result is still
+     * visible.
+     */
+    fileReadLedger = new FileReadLedger({
+        isToolResultLive: (id) => this.isToolResultLive(id),
+        historyLength: () => this.messages.length,
+    });
     getModeState;
     /**
      * Real provider usage captured when `runCompactionIfNeeded` defers past an
@@ -226,6 +271,15 @@ export class ContextV2 {
     serverCompactionCompletedBeforeStart = false;
     completedTurnCount = 0;
     lastCompactionAtTurnIndex = 0;
+    /**
+     * Set when a compaction just committed, cleared by the next response that
+     * carries real usage. Lets {@link ingestResponse} attribute that response's
+     * input tokens to the compaction that rewrote the prefix it now has to
+     * recompute — the split between cached and fresh tokens is the actual cache
+     * cost of the compaction. A second compaction before any real usage arrives
+     * overwrites the pending path; only the latest is attributed.
+     */
+    pendingCompactionRecomputePath;
     // When disposed, this context may still be referenced by in-flight streams.
     // Keep it inert so stale generations cannot persist cleared history.
     isDisposed = false;
@@ -398,7 +452,7 @@ export class ContextV2 {
     }
     markSkillsNeedReload() {
         this.skillsNeedReload = true;
-        this.readSystemSkills.clear();
+        this.clearContextDerivedReadState();
     }
     checkAndClearSkillsNeedReload() {
         if (this.skillsNeedReload) {
@@ -413,6 +467,108 @@ export class ContextV2 {
     markSystemSkillRead(path) {
         this.readSystemSkills.add(path);
     }
+    /**
+     * Drops per-conversation state derived from what the model can currently see.
+     * Called wherever history is compacted, truncated, or reloaded, so anything
+     * keyed on "the model already has this" is dropped in one place.
+     *
+     * {@link pendingCompactionRecomputePath} is not that kind of state: it is
+     * set *by* compaction so the next real-usage response can record the
+     * rewritten prefix's cache cost. Phase 2 always requests a skills reload,
+     * so clearing the latch here would drop the metric on the path it exists
+     * to measure. Truncate/reload pass
+     * `dropPendingCompactionRecompute` because they break the prefix
+     * assumption.
+     */
+    clearContextDerivedReadState(options = {}) {
+        this.readSystemSkills.clear();
+        this.fileReadLedger.clear();
+        if (options.dropPendingCompactionRecompute) {
+            this.pendingCompactionRecomputePath = undefined;
+        }
+    }
+    evaluateFileRead(input) {
+        return this.fileReadLedger.evaluate(input);
+    }
+    recordFileRead(input) {
+        this.fileReadLedger.recordServed(input);
+    }
+    recordFileReadStub(filePath, requested) {
+        this.fileReadLedger.recordStub(filePath, requested);
+    }
+    /** Ledger entry count, for the read-file metric. */
+    fileReadLedgerSize() {
+        return this.fileReadLedger.size();
+    }
+    /**
+     * Called by the stream observer when the provider reports `clear_tool_uses`.
+     *
+     * Provider-side clearing is reported in aggregate only - no call ids - so
+     * everything keyed on "the model already has this" is dropped rather than
+     * guessing which results died.
+     */
+    onServerToolUsesCleared() {
+        // Only the ledger. Clearing skill-read state here would change behavior at
+        // the `off` flag, and it is not needed: one system-skill read puts
+        // `build_readFile` in the provider's name-scoped `excludeTools`, so skill
+        // reads survive the clear that triggered this.
+        this.fileReadLedger.clear();
+    }
+    /**
+     * Called by the stream observer when a step's messages are thrown away
+     * instead of committed.
+     *
+     * The reads that step issued are still pending in the ledger, waiting for an
+     * append that is never coming. Left alone they would read as visible on the
+     * retry, and the retried request does not carry them.
+     */
+    onStepDiscarded() {
+        this.fileReadLedger.dropPendingContributions();
+    }
+    /**
+     * Whether the model can still see the output of a tool result.
+     *
+     * Both the `[summarized] ` output prefix and the `summarized` message flag
+     * are checked because phase 1 sets both and either could move. The
+     * input-side `[summarized: do not use this as tool input] ` prefix is a
+     * different marker on tool CALLS and deliberately does not count.
+     */
+    isToolResultLive(toolCallId) {
+        return this.findLiveToolResultPart(toolCallId) !== undefined;
+    }
+    /**
+     * The live tool-result output text for `toolCallId`, for diff-based
+     * re-injection when `build_readFile` finds a changed file. Undefined when
+     * the id has no live, text-typed tool-result part - the caller falls back
+     * to serving full content rather than diffing against nothing.
+     */
+    getLiveToolResultText(toolCallId) {
+        const part = this.findLiveToolResultPart(toolCallId);
+        return part === undefined ? undefined : extractToolResultText(part);
+    }
+    /** Shared traversal behind {@link isToolResultLive} and {@link getLiveToolResultText}. */
+    findLiveToolResultPart(toolCallId) {
+        for (let i = this.messages.length - 1; i >= 0; i--) {
+            const msg = this.messages[i];
+            if (msg?.role !== "tool" || !Array.isArray(msg.content)) {
+                continue;
+            }
+            const part = msg.content.find((candidate) => typeof candidate === "object" &&
+                candidate !== null &&
+                "type" in candidate &&
+                candidate.type === "tool-result" &&
+                "toolCallId" in candidate &&
+                candidate.toolCallId === toolCallId);
+            if (!part) {
+                continue;
+            }
+            if (msg._superblocks?.summarized === true) {
+                return undefined;
+            }
+            return isSummarizedToolOutput(part) ? undefined : part;
+        }
+        return undefined;
+    }
     setAttachments(attachments) {
         this.attachments = attachments;
         void this.persist("attachments");
@@ -422,12 +578,16 @@ export class ContextV2 {
     }
     truncateAfterTimestamp(timestamp) {
         this.invalidateMessageCache();
-        this.readSystemSkills.clear();
+        this.clearContextDerivedReadState({
+            dropPendingCompactionRecompute: true,
+        });
         void this.queue.enqueue(async () => {
             const initialCount = this.messages.length;
             this.messages = this.messages.filter((msg) => !msg._superblocks?.timestamp ||
                 msg._superblocks.timestamp <= timestamp);
-            this.readSystemSkills.clear();
+            this.clearContextDerivedReadState({
+                dropPendingCompactionRecompute: true,
+            });
             this.invalidateMessageCache();
             const removed = initialCount - this.messages.length;
             logger.info(`Truncated context after timestamp ${timestamp}. Removed ${removed} messages, ${this.messages.length} remaining.`);
@@ -438,12 +598,21 @@ export class ContextV2 {
         const context = new ContextV2(options);
         context.messages = record.messages;
         context.attachments = record.attachments;
-        // Live sessions keep media on only the newest screenshot, but event-log
-        // entries are appended before that stripping happens, so a restored
-        // record can resurrect every screenshot's media. Re-stripping here keeps
-        // the restored request bytes identical to what the provider's prompt
-        // cache saw before the restart (APPS-4751) — and avoids re-sending
-        // megabytes of stale base64.
+        // A live session keeps media on EVERY screenshot until a compaction
+        // commit -- rewriting one the model has already been sent poisons the
+        // prompt-cache entry sitting on it (APPS-5709). Do not "restore symmetry"
+        // by putting this call back on `addResponses`; that is the bug.
+        //
+        // This still has to run. `toPersistedRecord` already strips `main.json`,
+        // so for a record restore it is a no-op, but the event log appends full
+        // media per message before any stripping, so a replay can resurrect every
+        // screenshot's bytes. Without this, restore re-sends megabytes of stale
+        // base64.
+        //
+        // The consequence is deliberate: a restored context holds one image where
+        // the live one held many, so its prefix differs and a mid-turn restart is
+        // a one-shot cache miss. That is the accepted trade -- restarts are rare,
+        // and the alternative was rewriting history on every capture.
         context.stripAllButLatestScreenshot();
         return context;
     }
@@ -454,6 +623,28 @@ export class ContextV2 {
             attachments: this.attachments,
         };
     }
+    /**
+     * The record written to disk: {@link toRecord} with screenshot media kept
+     * only on the newest screenshot.
+     *
+     * In-memory messages deliberately keep every image, because rewriting one
+     * the model has already been sent invalidates the prompt-cache entry sitting
+     * on it (APPS-5709). The stored record is under no such constraint -- it is
+     * only ever read back through `fromRecord` / `replayMessages`, both of which
+     * strip to the newest screenshot anyway -- so bounding it here keeps the
+     * snapshot small without touching the conversation. Without this, a long
+     * verification-heavy turn walks the record toward the >5MB warning in
+     * `LocalContextStorageV2`.
+     *
+     * The event log is intentionally left alone: it stores full media per
+     * message by design, and replay strips on the way back in.
+     */
+    toPersistedRecord() {
+        return {
+            ...this.toRecord(),
+            messages: stripAllButLatestScreenshotMedia(this.messages).messages,
+        };
+    }
     setSystemPrompt(prompt) {
         this.systemPrompt = toStoredMessage(prompt);
         this.invalidateMessageCache();
@@ -520,9 +711,7 @@ export class ContextV2 {
                     await this.appendEvent("prompt_sent", storedMessage);
                     continue;
                 }
-                const storedResponse = this.ingestResponse(message, ZERO_USAGE, {
-                    stripOlderScreenshots: false,
-                });
+                const storedResponse = this.ingestResponse(message, ZERO_USAGE);
                 const eventUsage = message.role === "assistant"
                     ? extractTokenUsage(ZERO_USAGE)
                     : undefined;
@@ -544,9 +733,7 @@ export class ContextV2 {
     async addResponse(response, usage) {
         this.invalidateMessageCache();
         await this.queue.enqueue(async () => {
-            const storedResponse = this.ingestResponse(response, usage, {
-                stripOlderScreenshots: true,
-            });
+            const storedResponse = this.ingestResponse(response, usage);
             this.invalidateMessageCache();
             if (response.role === "assistant" || response.role === "tool") {
                 const eventUsage = response.role === "assistant" ? extractTokenUsage(usage) : undefined;
@@ -574,9 +761,9 @@ export class ContextV2 {
      * message is appended to the event log (an O(1) append that carries
      * per-message durability), and the legacy full-record snapshot is deferred
      * to {@link endTurn} so the whole generation costs one rewrite instead of
-     * one per message. Screenshot-media stripping is likewise deferred to a
-     * single backward pass (mirroring {@link initializeWith}) instead of an
-     * O(history) scan per message.
+     * one per message. Committing is append-only: nothing already sent to the
+     * model is rewritten here, so the prompt-cache entries sitting on those
+     * messages stay valid (APPS-5709).
      */
     async addResponses(responses, usage) {
         if (responses.length === 0) {
@@ -585,9 +772,7 @@ export class ContextV2 {
         this.invalidateMessageCache();
         await this.queue.enqueue(async () => {
             for (const response of responses) {
-                const storedResponse = this.ingestResponse(response, usage, {
-                    stripOlderScreenshots: false,
-                });
+                const storedResponse = this.ingestResponse(response, usage);
                 if (response.role === "assistant" || response.role === "tool") {
                     const eventUsage = response.role === "assistant"
                         ? extractTokenUsage(usage)
@@ -595,7 +780,12 @@ export class ContextV2 {
                     await this.appendEvent("response_received", storedResponse, eventUsage);
                 }
             }
-            this.stripAllButLatestScreenshot();
+            // Screenshot media is deliberately NOT stripped here. Every message the
+            // model has already been sent is a position the prompt cache may hold an
+            // entry on; rewriting one in place poisons that entry permanently, and
+            // screenshot tool results always terminate their step, so they always
+            // carry the trailing breakpoint. Stripping happens where the prefix is
+            // being rebuilt anyway -- compaction and replay (APPS-5709).
             this.invalidateMessageCache();
         });
         // Compaction runs once after the step is committed. It inspects the whole
@@ -630,15 +820,16 @@ export class ContextV2 {
             await this.persist("turn_end");
         });
     }
-    recordInterCompactionTurnInterval() {
+    recordInterCompactionTurnInterval(path) {
         const turnsSince = this.completedTurnCount - this.lastCompactionAtTurnIndex;
         if (turnsSince > 0) {
             recordTurnsSinceLastCompaction(turnsSince);
         }
         this.lastCompactionAtTurnIndex = this.completedTurnCount;
+        this.pendingCompactionRecomputePath = path;
     }
     /** Store a single assistant/tool/other response message and return it. */
-    ingestResponse(response, usage, options) {
+    ingestResponse(response, usage) {
         switch (response.role) {
             case "assistant": {
                 // Total input tokens = non-cached + cached (prompt caching splits these)
@@ -648,6 +839,20 @@ export class ContextV2 {
                 // Use the higher of reported tokens or last known to maintain monotonicity.
                 const lastKnownTokens = this.getLastKnownInputTokens();
                 const cumulativeInputTokens = Math.max(reportedInputTokens, lastKnownTokens);
+                // The first response with real usage after a compaction committed is
+                // the one that resent the (now rewritten) prefix, so its cache split
+                // is that compaction's actual cost. One-shot: cleared immediately so
+                // a later unrelated response never gets attributed to it.
+                if (this.pendingCompactionRecomputePath && reportedInputTokens > 0) {
+                    const costTokens = promptCostTokensFrom(usage);
+                    recordPostCompactionRecompute({
+                        ...this.getMetricIdentity(),
+                        cachedInputTokens: costTokens.cachedReadTokens,
+                        newInputTokens: costTokens.inputTokens,
+                        path: this.pendingCompactionRecomputePath,
+                    });
+                    this.pendingCompactionRecomputePath = undefined;
+                }
                 normalizeReasoningProviderOptions(response);
                 const extraMeta = this.compaction.collectAssistantMetadata(response) ?? {};
                 const storedResponse = toStoredMessage(response, {
@@ -660,21 +865,6 @@ export class ContextV2 {
             }
             case "tool": {
                 const normalized = normalizeToolMessage(stripUndefinedFromToolOutputs(response));
-                // Strip media from older screenshots so at most one is kept in stored
-                // messages. Bulk replay defers this to a single pass at the end.
-                if (options.stripOlderScreenshots && hasScreenshotMedia(normalized)) {
-                    let strippedCount = 0;
-                    for (let i = 0; i < this.messages.length; i++) {
-                        const msg = this.messages[i];
-                        if (msg && hasScreenshotMedia(msg)) {
-                            this.messages[i] = stripScreenshotMediaFromToolMessage(msg);
-                            strippedCount++;
-                        }
-                    }
-                    if (strippedCount > 0) {
-                        logger.info(`Stripped media from ${strippedCount} older screenshot(s)`);
-                    }
-                }
                 const extraMeta = this.compaction.collectToolMetadata(normalized) ?? {};
                 const storedResponse = toStoredMessage(normalized, extraMeta);
                 this.messages.push(storedResponse);
@@ -687,24 +877,20 @@ export class ContextV2 {
             }
         }
     }
-    /** Single backwards pass keeping media on only the newest screenshot. */
+    /**
+     * Single backwards pass keeping media on only the newest screenshot.
+     *
+     * Only safe to call where the cached prefix is already being discarded --
+     * compaction commits and replay. Calling it mid-turn rewrites messages the
+     * model has already been sent, which invalidates the cache entries sitting
+     * on them (APPS-5709).
+     */
     stripAllButLatestScreenshot() {
-        let latestKept = false;
-        let strippedCount = 0;
-        for (let i = this.messages.length - 1; i >= 0; i--) {
-            const msg = this.messages[i];
-            if (!msg || !hasScreenshotMedia(msg)) {
-                continue;
-            }
-            if (!latestKept) {
-                latestKept = true;
-                continue;
-            }
-            this.messages[i] = stripScreenshotMediaFromToolMessage(msg);
-            strippedCount++;
-        }
-        if (strippedCount > 0) {
-            logger.info(`Stripped media from ${strippedCount} older screenshot(s)`);
+        const { messages, retained, stripped } = stripAllButLatestScreenshotMedia(this.messages);
+        this.messages = messages;
+        recordRetainedScreenshots(retained);
+        if (stripped > 0) {
+            logger.info(`Stripped media from ${stripped} older screenshot(s)`);
         }
     }
     /**
@@ -761,16 +947,17 @@ export class ContextV2 {
                 usage: effectiveUsage,
             });
             if (result.messages) {
-                this.recordInterCompactionTurnInterval();
+                this.recordInterCompactionTurnInterval("client");
                 // Retained assistant messages still carry pre-compaction
                 // `cumulativeInputTokens`. Mark them so the post-compaction floor
                 // resets (see `markPreCompactionBaselines` / `getLastKnownInputTokens`).
                 this.messages = this.markPreCompactionBaselines(result.messages);
+                this.stripAllButLatestScreenshot();
                 this.invalidateMessageCache();
             }
             if (result.skillsNeedReload) {
                 this.skillsNeedReload = true;
-                this.readSystemSkills.clear();
+                this.clearContextDerivedReadState();
             }
             if (result.eventLogAnchor && result.messages) {
                 // Append the marked messages so the reset survives reload from the
@@ -1070,10 +1257,11 @@ export class ContextV2 {
             }
             this.messages = candidate;
             committed = true;
+            this.stripAllButLatestScreenshot();
             this.invalidateMessageCache();
             if (result.skillsNeedReload) {
                 this.skillsNeedReload = true;
-                this.readSystemSkills.clear();
+                this.clearContextDerivedReadState();
             }
             if (result.eventLogAnchor) {
                 await this.appendCompactionWindow(this.messages);
@@ -1254,11 +1442,12 @@ export class ContextV2 {
                 : null;
             if (marked) {
                 this.messages = marked;
+                this.stripAllButLatestScreenshot();
                 this.invalidateMessageCache();
             }
             if (result.skillsNeedReload) {
                 this.skillsNeedReload = true;
-                this.readSystemSkills.clear();
+                this.clearContextDerivedReadState();
             }
             const marker = result.messages?.[0];
             const summary = typeof marker?.content === "string"
@@ -1267,7 +1456,7 @@ export class ContextV2 {
             const durationMs = this.getActiveServerCompactionDurationMs();
             const didComplete = this.completeServerCompactionMessage(summary, detectedGeneration);
             if (didComplete) {
-                this.recordInterCompactionTurnInterval();
+                this.recordInterCompactionTurnInterval("server");
                 recordServerCompaction({
                     ...this.getMetricIdentity(),
                     durationMs,
@@ -1632,7 +1821,7 @@ export class ContextV2 {
             const eluStart = performance.eventLoopUtilization();
             let persistError;
             try {
-                await onPersist(this.toRecord());
+                await onPersist(this.toPersistedRecord());
             }
             catch (err) {
                 persistError = err;
@@ -1663,4 +1852,27 @@ export class ContextV2 {
         });
     }
 }
+/**
+ * A tool-result part's output text, when it has one. Undefined for a
+ * non-text output (or not a tool-result part at all) rather than an empty
+ * string, so callers can tell "no text" from "empty text".
+ */
+function extractToolResultText(part) {
+    if (typeof part !== "object" || part === null || !("output" in part)) {
+        return undefined;
+    }
+    const output = part.output;
+    if (typeof output !== "object" || output === null || !("value" in output)) {
+        return undefined;
+    }
+    const value = output.value;
+    return typeof value === "string" ? value : undefined;
+}
+/**
+ * True when a tool-result part's output carries the phase-1 summarized
+ * prefix, meaning the model sees a summary instead of the real output.
+ */
+function isSummarizedToolOutput(part) {
+    return (extractToolResultText(part) ?? "").startsWith(SUMMARIZED_TOOL_OUTPUT_PREFIX);
+}
 //# sourceMappingURL=context.js.map