@codingame/monaco-vscode-chat-service-override 31.0.1 → 32.0.1

package/vscode/src/vs/workbench/contrib/chat/browser/chatDebug/chatDebugCacheExplorerView.js

@@ -0,0 +1,1216 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { $ as $$1, append, hide, show, clearNode, addDisposableListener, EventType, createTextNode } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Sash, Orientation, SashState } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/sash/sash';
+import { BreadcrumbsWidget } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/breadcrumbs/breadcrumbsWidget';
+import { RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { safeIntl } from '@codingame/monaco-vscode-api/vscode/vs/base/common/date';
+import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { defaultBreadcrumbsWidgetStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+import { linesDiffComputers } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/diff/linesDiffComputers';
+import { IChatDebugService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { LocalChatSessionUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+import { diffPromptSignature, appendToolsDrift, appendSystemDrift, parseInputMessages, CacheDiffKind } from './chatDebugCacheDiff.js';
+import { setupBreadcrumbKeyboardNavigation, TextBreadcrumbItem } from './chatDebugTypes.js';
+
+const $ = $$1;
+const numberFormatter = safeIntl.NumberFormat();
+const timeFormatter = safeIntl.DateTimeFormat(undefined, {
+    hour: "numeric",
+    minute: "2-digit",
+    second: "2-digit"
+});
+const RAIL_DEFAULT_WIDTH = 280;
+const RAIL_MIN_WIDTH = 180;
+const RAIL_MAX_WIDTH = 600;
+const CURRENT_CONTINUATION_DELTA_COMPONENT = "current continuation delta";
+var CacheExplorerNavigation;
+(function(CacheExplorerNavigation) {
+    CacheExplorerNavigation["Home"] = "home";
+    CacheExplorerNavigation["Overview"] = "overview";
+})(CacheExplorerNavigation || (CacheExplorerNavigation = {}));
+let ChatDebugCacheExplorerView = class ChatDebugCacheExplorerView extends Disposable {
+    constructor(parent, chatService, chatDebugService) {
+        super();
+        this.chatService = chatService;
+        this.chatDebugService = chatDebugService;
+        this._onNavigate = this._register(( new Emitter()));
+        this.onNavigate = this._onNavigate.event;
+        this.railWidth = RAIL_DEFAULT_WIDTH;
+        this.loadDisposables = this._register(( new DisposableStore()));
+        this.modelTurns = [];
+        this.selectedIndex = -1;
+        this.renderToken = 0;
+        this.resolvedCache = ( new Map());
+        this.openComponents = ( new Set(["system", "tools"]));
+        this.collapsedGroups = ( new Set());
+        this.container = append(parent, $(".chat-debug-cache"));
+        hide(this.container);
+        const breadcrumbContainer = append(this.container, $(".chat-debug-breadcrumb"));
+        this.breadcrumbWidget = this._register(( new BreadcrumbsWidget(
+            breadcrumbContainer,
+            3,
+            undefined,
+            Codicon.chevronRight,
+            defaultBreadcrumbsWidgetStyles
+        )));
+        this._register(
+            setupBreadcrumbKeyboardNavigation(breadcrumbContainer, this.breadcrumbWidget)
+        );
+        this._register(this.breadcrumbWidget.onDidSelectItem(e => {
+            if (e.type === "select" && e.item instanceof TextBreadcrumbItem) {
+                this.breadcrumbWidget.setSelection(undefined);
+                const items = this.breadcrumbWidget.getItems();
+                const idx = items.indexOf(e.item);
+                if (idx === 0) {
+                    this._onNavigate.fire(CacheExplorerNavigation.Home);
+                } else if (idx === 1) {
+                    this._onNavigate.fire(CacheExplorerNavigation.Overview);
+                }
+            }
+        }));
+        const body = append(this.container, $(".chat-debug-cache-body"));
+        this.rail = append(body, $(".chat-debug-cache-rail"));
+        this.rail.style.width = `${this.railWidth}px`;
+        this.railList = append(this.rail, $(".chat-debug-cache-rail-list"));
+        this.content = append(body, $(".chat-debug-cache-content"));
+        this.sash = this._register(( new Sash(body, {
+            getVerticalSashLeft: () => this.railWidth
+        }, {
+            orientation: Orientation.VERTICAL
+        })));
+        this.sash.state = SashState.Enabled;
+        let sashStartWidth;
+        this._register(this.sash.onDidStart(() => sashStartWidth = this.railWidth));
+        this._register(this.sash.onDidEnd(() => {
+            sashStartWidth = undefined;
+            this.sash.layout();
+        }));
+        this._register(this.sash.onDidChange(e => {
+            if (sashStartWidth === undefined) {
+                return;
+            }
+            const delta = e.currentX - e.startX;
+            const next = Math.max(RAIL_MIN_WIDTH, Math.min(RAIL_MAX_WIDTH, sashStartWidth + delta));
+            this.railWidth = next;
+            this.rail.style.width = `${next}px`;
+            this.sash.layout();
+        }));
+        this.refreshScheduler = this._register(( new RunOnceScheduler(() => this.render(), 50)));
+    }
+    setSession(sessionResource) {
+        if (!this.currentSessionResource || ( this.currentSessionResource.toString()) !== ( sessionResource.toString())) {
+            this.resolvedCache.clear();
+            this.collapsedGroups.clear();
+            this.openComponents.clear();
+            this.openComponents.add("system");
+            this.openComponents.add("tools");
+            this.selectedIndex = -1;
+        }
+        this.currentSessionResource = sessionResource;
+    }
+    show() {
+        show(this.container);
+        this.render();
+    }
+    hide() {
+        hide(this.container);
+        this.refreshScheduler.cancel();
+    }
+    refresh() {
+        if (this.container.style.display !== "none" && !this.refreshScheduler.isScheduled()) {
+            this.refreshScheduler.schedule();
+        }
+    }
+    updateBreadcrumb() {
+        if (!this.currentSessionResource) {
+            return;
+        }
+        const sessionTitle = this.chatService.getSessionTitle(this.currentSessionResource) || LocalChatSessionUri.parseLocalSessionId(this.currentSessionResource) || ( this.currentSessionResource.toString());
+        this.breadcrumbWidget.setItems([( new TextBreadcrumbItem(( localize(6018, "Agent Debug Logs")), true)), ( new TextBreadcrumbItem(sessionTitle, true)), ( new TextBreadcrumbItem(( localize(6019, "Cache Explorer"))))]);
+    }
+    async render() {
+        const token = ++this.renderToken;
+        const isCurrent = () => token === this.renderToken;
+        this.updateBreadcrumb();
+        this.loadDisposables.clear();
+        clearNode(this.railList);
+        clearNode(this.content);
+        if (!this.currentSessionResource) {
+            return;
+        }
+        const events = this.chatDebugService.getEvents(this.currentSessionResource);
+        this.modelTurns = events.filter(e => e.kind === "modelTurn");
+        const userMessages = events.filter(e => e.kind === "userMessage");
+        if (this.modelTurns.length === 0) {
+            const empty = append(this.content, $(".chat-debug-cache-empty"));
+            empty.textContent = ( localize(6020, "No model turns recorded for this session yet."));
+            return;
+        }
+        if (this.selectedIndex < 0 || this.selectedIndex >= this.modelTurns.length) {
+            this.selectedIndex = this.modelTurns.length - 1;
+        }
+        this.renderRail(buildTurnGroups(this.modelTurns, userMessages));
+        this.renderTitleRow();
+        const bEvent = this.modelTurns[this.selectedIndex];
+        const aEvent = this.selectedIndex > 0 ? this.modelTurns[this.selectedIndex - 1] : undefined;
+        if (!aEvent) {
+            const b = await this.resolveSide(bEvent);
+            if (!isCurrent()) {
+                return;
+            }
+            this.renderSingleSummary(b);
+            return;
+        }
+        const [a, b] = await Promise.all([this.resolveSide(aEvent), this.resolveSide(bEvent)]);
+        if (!isCurrent()) {
+            return;
+        }
+        const compareInputMessages = shouldCompareInputMessages(a, b);
+        const diff = compareInputMessages ? diffPromptSignature(a.inputMessages, b.inputMessages) : diffPromptSignature([], []);
+        const drift = appendToolsDrift(appendSystemDrift([...diff.drift], a.system, b.system), a.tools, b.tools);
+        this.renderSummary(a, b, diff);
+        this.renderSignature(a, b, diff, compareInputMessages);
+        this.renderRequestOptions(a, b);
+        this.renderComponents(drift, a, b, compareInputMessages);
+    }
+    async resolveSide(event) {
+        let content;
+        if (event.id) {
+            if (( this.resolvedCache.has(event.id))) {
+                content = this.resolvedCache.get(event.id);
+            } else {
+                const r = await this.chatDebugService.resolveEvent(event.id);
+                content = r && r.kind === "modelTurn" ? r : undefined;
+                this.resolvedCache.set(event.id, content);
+            }
+        }
+        const system = findSection(content?.sections, "System");
+        const tools = findSection(content?.sections, "Tools");
+        const requestShapeJson = findSection(content?.sections, "Request Shape");
+        const inputMessagesJson = findSection(content?.sections, "Input Messages");
+        const rawMessages = parseInputMessages(inputMessagesJson);
+        let stripFrom = 0;
+        if (system) {
+            while (stripFrom < rawMessages.length && rawMessages[stripFrom].role === "system") {
+                stripFrom++;
+            }
+        }
+        const inputMessages = stripFrom > 0 ? rawMessages.slice(stripFrom) : rawMessages;
+        return {
+            event,
+            content,
+            system,
+            tools,
+            inputMessages,
+            requestShape: describeRequestShape(inputMessages, requestShapeJson)
+        };
+    }
+    renderRail(groups) {
+        for (const group of groups) {
+            const collapsed = ( this.collapsedGroups.has(group.key));
+            const header = append(this.railList, $(".chat-debug-cache-group-header"));
+            if (collapsed) {
+                header.classList.add("is-collapsed");
+            }
+            header.tabIndex = 0;
+            header.setAttribute("role", "button");
+            header.setAttribute("aria-expanded", collapsed ? "false" : "true");
+            header.title = ( localize(6021, "Toggle group"));
+            const topLine = append(header, $(".chat-debug-cache-group-top"));
+            append(topLine, $("span.chat-debug-cache-group-chev"));
+            const headerLine = append(topLine, $(".chat-debug-cache-group-prompt"));
+            headerLine.textContent = group.userMessage?.message?.trim() || ( localize(6022, "(no prompt captured)"));
+            const countBadge = append(topLine, $("span.chat-debug-cache-group-count"));
+            countBadge.textContent = String(group.turns.length);
+            const headerMeta = append(header, $(".chat-debug-cache-group-meta"));
+            headerMeta.textContent = group.key;
+            headerMeta.title = ( localize(6023, "Request id: {0}", group.key));
+            const toggle = () => {
+                if (( this.collapsedGroups.has(group.key))) {
+                    this.collapsedGroups.delete(group.key);
+                } else {
+                    this.collapsedGroups.add(group.key);
+                }
+                this.refresh();
+            };
+            this.loadDisposables.add(addDisposableListener(header, EventType.CLICK, toggle));
+            this.loadDisposables.add(addDisposableListener(header, EventType.KEY_DOWN, e => {
+                if (e.key === "Enter" || e.key === " ") {
+                    e.preventDefault();
+                    toggle();
+                }
+            }));
+            if (collapsed) {
+                continue;
+            }
+            for (const {
+                turn: evt,
+                index: i
+            } of group.turns) {
+                const row = append(this.railList, $(".chat-debug-cache-turn"));
+                if (i === this.selectedIndex) {
+                    row.classList.add("is-selected");
+                }
+                const idx = append(row, $(".chat-debug-cache-turn-idx"));
+                idx.textContent = String(i).padStart(2, " ");
+                const main = append(row, $(".chat-debug-cache-turn-main"));
+                const top = append(main, $(".chat-debug-cache-turn-top"));
+                const source = append(top, $("span.chat-debug-cache-turn-source"));
+                source.textContent = evt.requestName || ( localize(6024, "Model Turn"));
+                if (evt.cachedTokens !== undefined && evt.inputTokens) {
+                    const hit = computeCacheHit(evt);
+                    const hitChip = append(top, $(
+                        "span.chat-debug-cache-turn-chip.chat-debug-cache-turn-hit",
+                        undefined,
+                        ( localize(6025, "[cache {0}%]", formatCachePctInt(hit)))
+                    ));
+                    if (hit < 90) {
+                        hitChip.classList.add("is-bad");
+                    }
+                }
+                if (evt.durationInMillis !== undefined) {
+                    append(top, $("span.chat-debug-cache-turn-chip", undefined, ( localize(
+                        6026,
+                        "[{0}ms]",
+                        numberFormatter.value.format(Math.round(evt.durationInMillis))
+                    ))));
+                }
+                append(top, $(
+                    "span.chat-debug-cache-turn-chip",
+                    undefined,
+                    `[${timeFormatter.value.format(evt.created)}]`
+                ));
+                if (evt.model) {
+                    const sub = append(main, $(".chat-debug-cache-turn-sub"));
+                    sub.textContent = evt.model;
+                }
+                row.title = ( localize(6027, "Click to compare this request against the previous one"));
+                row.tabIndex = 0;
+                row.setAttribute("role", "button");
+                row.setAttribute("aria-selected", i === this.selectedIndex ? "true" : "false");
+                row.setAttribute("aria-label", ( localize(
+                    6028,
+                    "Turn {0}: {1}",
+                    i,
+                    evt.requestName ?? evt.model ?? ( localize(6024, "Model Turn"))
+                )));
+                const select = () => {
+                    if (this.selectedIndex !== i) {
+                        this.selectedIndex = i;
+                        this.refresh();
+                    }
+                };
+                this.loadDisposables.add(addDisposableListener(row, EventType.CLICK, select));
+                this.loadDisposables.add(addDisposableListener(row, EventType.KEY_DOWN, e => {
+                    if (e.key === "Enter" || e.key === " ") {
+                        e.preventDefault();
+                        select();
+                    }
+                }));
+            }
+        }
+    }
+    renderTitleRow() {
+        const titleRow = append(this.content, $(".chat-debug-cache-title-row"));
+        const title = append(titleRow, $("h2.chat-debug-cache-title"));
+        title.textContent = ( localize(6029, "Cache Explorer — Prefix Diff"));
+    }
+    renderSummary(a, b, diff) {
+        const row = append(this.content, $(".chat-debug-cache-summary"));
+        row.appendChild(this.renderSideCard(a, ( localize(6030, "Previous request"))));
+        row.appendChild(this.renderSideCard(b, ( localize(6031, "Request"))));
+        const breakCard = append(row, $(".chat-debug-cache-card.break"));
+        append(breakCard, $(".chat-debug-cache-card-h", undefined, ( localize(6032, "Cache performance"))));
+        const hit = computeCacheHit(b.event);
+        const inputTokens = b.event.inputTokens ?? 0;
+        const cachedTokens = b.event.cachedTokens ?? 0;
+        const lostTokens = Math.max(0, inputTokens - cachedTokens);
+        const optionsDiff = computeOptionsDiff(a, b);
+        const systemChanged = (a.system ?? "") !== (b.system ?? "");
+        const toolsChanged = (a.tools ?? "") !== (b.tools ?? "");
+        const continuationComparison = b.requestShape.isContinuation;
+        const expiration = !continuationComparison && isLikelyCacheExpiration(hit, diff, optionsDiff, systemChanged, toolsChanged);
+        const headline = append(breakCard, $(".chat-debug-cache-card-headline"));
+        if (expiration) {
+            headline.textContent = ( localize(6033, "{0}% cache hit — likely cache expiration", formatCachePct(hit)));
+        } else {
+            headline.textContent = ( localize(6034, "{0}% cache hit", formatCachePct(hit)));
+        }
+        const counts = append(breakCard, $(".chat-debug-cache-card-sub"));
+        counts.textContent = ( localize(
+            6035,
+            "{0} of {1} input tokens reused",
+            numberFormatter.value.format(cachedTokens),
+            numberFormatter.value.format(inputTokens)
+        ));
+        if (b.requestShape.description) {
+            const shapeLine = append(
+                breakCard,
+                $(".chat-debug-cache-perf-line.chat-debug-cache-request-shape-note")
+            );
+            shapeLine.textContent = b.requestShape.description;
+        }
+        append(breakCard, $(".chat-debug-cache-perf-rule"));
+        append(breakCard, $(
+            ".chat-debug-cache-perf-section-h",
+            undefined,
+            continuationComparison ? ( localize(6036, "Visible wire input")) : ( localize(6037, "Where the cache broke"))
+        ));
+        const breakLine = append(breakCard, $(".chat-debug-cache-perf-line"));
+        if (expiration) {
+            breakLine.textContent = ( localize(
+                6038,
+                "The prompt prefix matches but the model still treated this as a fresh request. Most likely the cached entry expired between requests."
+            ));
+        } else if (systemChanged) {
+            breakLine.textContent = ( localize(
+                6039,
+                "System instructions changed — the cache was invalidated even though the message prefix matches."
+            ));
+        } else if (toolsChanged) {
+            breakLine.textContent = ( localize(
+                6040,
+                "Tool definitions changed — the catalog of available tools differs between requests, which invalidates the cache even though the message prefix matches."
+            ));
+            if (continuationComparison && diff.break) {
+                const deltaName = diff.break.index === 0 ? ( localize(6041, "the first message")) : `messages[${diff.break.index}]`;
+                const deltaLine = append(breakCard, $(".chat-debug-cache-perf-line"));
+                deltaLine.textContent = ( localize(
+                    6042,
+                    "The visible wire delta also changed at {0}. That is expected when comparing consecutive continuation requests of different kinds, such as tool_search_output followed by a new user input.",
+                    deltaName
+                ));
+            }
+        } else if (continuationComparison && diff.break) {
+            const componentName = diff.break.index === 0 ? ( localize(6041, "the first message")) : `messages[${diff.break.index}]`;
+            breakLine.textContent = ( localize(
+                6043,
+                "The captured wire delta changed at {0} — {1}. This is a delta-to-delta comparison between consecutive Responses API requests, not the full reconstructed prompt prefix.",
+                componentName,
+                describeBreakKind(diff.break.kind, diff, b)
+            ));
+            if (lostTokens > 0 && inputTokens > 0) {
+                const lostPct = (lostTokens / inputTokens) * 100;
+                const lossLine = append(breakCard, $(".chat-debug-cache-perf-line"));
+                lossLine.textContent = ( localize(
+                    6044,
+                    "Uncached in this request: {0} tokens ({1}% of this request)",
+                    numberFormatter.value.format(lostTokens),
+                    formatCachePct(lostPct)
+                ));
+            }
+        } else if (diff.break) {
+            const componentName = diff.break.index === 0 ? ( localize(6041, "the first message")) : `messages[${diff.break.index}]`;
+            breakLine.textContent = ( localize(
+                6045,
+                "At {0} — {1}",
+                componentName,
+                describeBreakKind(diff.break.kind, diff, b)
+            ));
+            if (lostTokens > 0 && inputTokens > 0) {
+                const lostPct = (lostTokens / inputTokens) * 100;
+                const lossLine = append(breakCard, $(".chat-debug-cache-perf-line"));
+                lossLine.textContent = ( localize(
+                    6046,
+                    "Lost: {0} tokens ({1}% of this request)",
+                    numberFormatter.value.format(lostTokens),
+                    formatCachePct(lostPct)
+                ));
+            }
+        } else if (optionsDiff.length > 0) {
+            breakLine.textContent = ( localize(
+                6047,
+                "Request options changed — the cache was invalidated even though the message prefix matches."
+            ));
+        } else if (continuationComparison) {
+            breakLine.textContent = ( localize(
+                6048,
+                "No divergence detected in the captured wire delta. The full reconstructed prompt prefix is provider-side for this continuation request."
+            ));
+        } else {
+            breakLine.textContent = ( localize(6049, "No prefix divergence detected."));
+        }
+        append(breakCard, $(".chat-debug-cache-perf-rule"));
+        append(breakCard, $(".chat-debug-cache-perf-section-h", undefined, ( localize(6050, "Diff summary"))));
+        const summaryLine = append(breakCard, $(".chat-debug-cache-perf-line"));
+        const inPlaceChanged = diff.counts.contentDrift + diff.counts.lengthChange;
+        const addedInB = diff.counts.onlyInB;
+        const droppedFromA = diff.counts.onlyInA;
+        const parts = [( localize(6051, "{0} identical", diff.counts.identical)), ( localize(6052, "{0} in-place changed", inPlaceChanged))];
+        if (addedInB > 0) {
+            parts.push(( localize(6053, "{0} added in this request", addedInB)));
+        }
+        if (droppedFromA > 0) {
+            parts.push(( localize(6054, "{0} dropped from previous", droppedFromA)));
+        }
+        summaryLine.textContent = parts.join(" · ");
+        if (optionsDiff.length > 0) {
+            const optsLine = append(this.content, $(".chat-debug-cache-options-banner"));
+            optsLine.textContent = ( localize(6055, "Options changed: {0}", ( optionsDiff.map(
+                d => `${d.key} (${formatOptionValue(d.previous)} \u2192 ${formatOptionValue(d.current)})`
+            )).join(", ")));
+        }
+    }
+    renderSideCard(data, title) {
+        const card = $(".chat-debug-cache-card");
+        if (title) {
+            append(card, $(".chat-debug-cache-card-h", undefined, title));
+        }
+        this.appendKv(card, ( localize(6056, "model")), data.event.model ?? "—");
+        this.appendKv(card, ( localize(6057, "input tok")), formatTokens(data.event.inputTokens));
+        this.appendKv(card, ( localize(6058, "cached tok")), formatTokens(data.event.cachedTokens));
+        this.appendKv(card, ( localize(6059, "cache hit")), `${formatCachePct(computeCacheHit(data.event))}%`);
+        this.appendKv(card, ( localize(6060, "shape")), data.requestShape.label);
+        const startTime = data.event.created;
+        const endTime = data.event.durationInMillis !== undefined ? ( new Date(startTime.getTime() + data.event.durationInMillis)) : undefined;
+        this.appendKv(card, ( localize(6061, "startTime")), startTime.toISOString(), true);
+        if (endTime) {
+            this.appendKv(card, ( localize(6062, "endTime")), endTime.toISOString(), true);
+        }
+        if (data.event.durationInMillis !== undefined) {
+            this.appendKv(card, ( localize(6063, "duration")), `${numberFormatter.value.format(Math.round(data.event.durationInMillis))}ms`);
+        }
+        const ttft = data.content?.timeToFirstTokenInMillis;
+        if (ttft !== undefined) {
+            this.appendKv(card, ( localize(6064, "timeToFirstToken")), `${numberFormatter.value.format(Math.round(ttft))}ms`);
+        }
+        const requestId = data.content?.requestId ?? data.event.parentEventId ?? data.event.id;
+        if (requestId) {
+            this.appendKv(card, ( localize(6065, "requestId")), requestId, true);
+        }
+        return card;
+    }
+    renderSingleSummary(b) {
+        const row = append(this.content, $(".chat-debug-cache-summary"));
+        row.appendChild(this.renderSideCard(b, ( localize(6031, "Request"))));
+        const note = append(row, $(".chat-debug-cache-card.break"));
+        append(note, $(".chat-debug-cache-card-h", undefined, ( localize(6066, "First request in session"))));
+        const headline = append(note, $(".chat-debug-cache-card-headline"));
+        headline.textContent = `${formatCachePct(computeCacheHit(b.event))}%`;
+        const sub = append(note, $(".chat-debug-cache-card-sub"));
+        sub.textContent = ( localize(
+            6067,
+            "OTel-reported cache hit. Nothing earlier in this session to diff against — the system prompt and tools may still match a previous session's cache."
+        ));
+        if (b.requestShape.description) {
+            const shapeLine = append(note, $(".chat-debug-cache-perf-line.chat-debug-cache-request-shape-note"));
+            shapeLine.textContent = b.requestShape.description;
+        }
+    }
+    appendKv(parent, key, value, copyable = false) {
+        const row = append(parent, $(".chat-debug-cache-kv"));
+        append(row, $("span.k", undefined, key));
+        const valueEl = append(row, $("span.v", undefined, value));
+        if (copyable) {
+            valueEl.classList.add("chat-debug-cache-request-id");
+            valueEl.title = value;
+        }
+    }
+    renderSignature(a, b, diff, compareInputMessages) {
+        const continuationComparison = b.requestShape.isContinuation;
+        const section = append(this.content, $(".chat-debug-cache-section"));
+        const heading = append(section, $("h3.chat-debug-cache-section-h"));
+        heading.textContent = continuationComparison ? ( localize(6068, "Visible Request Signature")) : ( localize(6069, "Prompt Signature"));
+        if (continuationComparison) {
+            const note = append(
+                section,
+                $(".chat-debug-cache-sig-summary.chat-debug-cache-request-shape-note")
+            );
+            note.textContent = ( localize(
+                6070,
+                "For Responses API continuations, this shows the captured request inputs: system instructions, tools sent on this request, and the visible input delta. Earlier conversation state is referenced by previous response id and is not expanded here."
+            ));
+        }
+        const legend = append(section, $(".chat-debug-cache-sig-legend"));
+        for (const role of ["system", "user", "assistant", "tool", "tool_search", "tools"]) {
+            const entry = append(legend, $("span.chat-debug-cache-sig-legend-entry"));
+            append(entry, $(`span.chat-debug-cache-sig-swatch.role-${roleClass(role)}`));
+            append(entry, $$1("span", undefined, role === "tools" ? ( localize(6071, "tools (catalog)")) : role === "tool_search" ? ( localize(6072, "tool search")) : role));
+        }
+        const driftEntry = append(legend, $("span.chat-debug-cache-sig-legend-entry"));
+        append(driftEntry, $("span.chat-debug-cache-sig-swatch.role-drift"));
+        append(driftEntry, $$1("span", undefined, ( localize(6073, "drift"))));
+        const toSegments = (side, isA) => {
+            const segs = [];
+            const sys = side.system;
+            if (sys) {
+                const other = isA ? b.system : a.system;
+                segs.push({
+                    role: "system",
+                    chars: sys.length,
+                    drift: sys !== (other ?? ""),
+                    label: "system",
+                    synthetic: true
+                });
+            }
+            const tools = side.tools;
+            if (tools) {
+                const other = isA ? b.tools : a.tools;
+                segs.push({
+                    role: "tools",
+                    chars: tools.length,
+                    drift: tools !== (other ?? ""),
+                    label: "tools",
+                    synthetic: true
+                });
+            }
+            side.inputMessages.forEach((m, i) => {
+                const tok = diff.signature[i];
+                const kind = tok?.kind;
+                const drift = compareInputMessages && (kind === CacheDiffKind.ContentDrift || kind === CacheDiffKind.LengthChange || (isA && kind === CacheDiffKind.OnlyInA) || (!isA && kind === CacheDiffKind.OnlyInB));
+                segs.push({
+                    role: m.role,
+                    chars: m.charLength,
+                    drift,
+                    label: m.name ? `${m.role}-${m.name}` : m.role,
+                    synthetic: false
+                });
+            });
+            return segs;
+        };
+        const aSegs = toSegments(a, true);
+        const bSegs = toSegments(b, false);
+        const totalA = aSegs.reduce((s, x) => s + x.chars, 0);
+        const totalB = bSegs.reduce((s, x) => s + x.chars, 0);
+        const max = Math.max(totalA, totalB, 1);
+        const breakCharPos = segs => {
+            if (!diff.break) {
+                return undefined;
+            }
+            let cumulative = 0;
+            let idx = 0;
+            for (const s of segs) {
+                if (s.synthetic) {
+                    cumulative += s.chars;
+                    continue;
+                }
+                if (idx === diff.break.index) {
+                    return cumulative;
+                }
+                cumulative += s.chars;
+                idx++;
+            }
+            return undefined;
+        };
+        const buildLane = (label, segs, breakPos) => {
+            const row = $(".chat-debug-cache-sig-lane-row");
+            append(row, $(".chat-debug-cache-sig-lane-label", undefined, label));
+            const bar = append(row, $(".chat-debug-cache-sig-bar"));
+            let sideTotal = 0;
+            for (const s of segs) {
+                if (s.chars <= 0) {
+                    sideTotal += s.chars;
+                    continue;
+                }
+                const widthPct = (s.chars / max) * 100;
+                const seg = append(bar, $(`span.chat-debug-cache-sig-seg.role-${roleClass(s.role)}`));
+                if (s.drift) {
+                    seg.classList.add("is-drift");
+                }
+                seg.style.width = `${widthPct}%`;
+                seg.title = `${s.label}: ${numberFormatter.value.format(s.chars)} chars` + (s.drift ? ` \u2014 drift` : "");
+                if (s.chars > max * 0.05) {
+                    seg.textContent = `${s.label}:${numberFormatter.value.format(s.chars)}`;
+                }
+                sideTotal += s.chars;
+            }
+            if (sideTotal < max) {
+                const pad = append(bar, $("span.chat-debug-cache-sig-seg.role-empty"));
+                pad.style.width = `${((max - sideTotal) / max) * 100}%`;
+            }
+            if (breakPos !== undefined && diff.break) {
+                const line = append(bar, $(".chat-debug-cache-sig-break"));
+                line.style.left = `${(breakPos / max) * 100}%`;
+                line.title = ( localize(6074, "Cache break at messages[{0}]", diff.break.index));
+            }
+            append(row, $(".chat-debug-cache-sig-lane-total", undefined, ( localize(6075, "{0} chars", numberFormatter.value.format(sideTotal)))));
+            return row;
+        };
+        const lanes = append(section, $(".chat-debug-cache-sig-lanes"));
+        lanes.appendChild(buildLane(( localize(6076, "Previous")), aSegs, breakCharPos(aSegs)));
+        lanes.appendChild(buildLane(( localize(6077, "Current")), bSegs, breakCharPos(bSegs)));
+        let shared = 0;
+        let firstDrift;
+        if (a.system || b.system) {
+            if ((a.system ?? "") === (b.system ?? "")) {
+                shared += b.system?.length ?? 0;
+            } else {
+                firstDrift = ( localize(6078, "system"));
+            }
+        }
+        if (!firstDrift && (a.tools || b.tools)) {
+            if ((a.tools ?? "") === (b.tools ?? "")) {
+                shared += b.tools?.length ?? 0;
+            } else {
+                firstDrift = ( localize(6079, "tools catalog"));
+            }
+        }
+        if (!firstDrift) {
+            for (const tok of diff.signature) {
+                if (tok.kind === CacheDiffKind.Identical) {
+                    shared += tok.bCharLength ?? 0;
+                } else {
+                    firstDrift = `messages[${tok.index}]`;
+                    break;
+                }
+            }
+        }
+        const summary = append(section, $(".chat-debug-cache-sig-summary"));
+        if (firstDrift) {
+            summary.textContent = continuationComparison ? ( localize(
+                6080,
+                "{0} of {1} captured request chars match before first captured drift: {2}",
+                numberFormatter.value.format(shared),
+                numberFormatter.value.format(totalB),
+                firstDrift
+            )) : ( localize(
+                6081,
+                "{0} of {1} chars reused · break at {2}",
+                numberFormatter.value.format(shared),
+                numberFormatter.value.format(totalB),
+                firstDrift
+            ));
+        } else {
+            summary.textContent = continuationComparison ? ( localize(
+                6082,
+                "{0} of {1} captured request chars match · no captured divergence detected",
+                numberFormatter.value.format(shared),
+                numberFormatter.value.format(totalB)
+            )) : ( localize(
+                6083,
+                "{0} of {1} chars reused · no divergence detected",
+                numberFormatter.value.format(shared),
+                numberFormatter.value.format(totalB)
+            ));
+        }
+    }
+    renderRequestOptions(a, b) {
+        const prev = sideOptions(a);
+        const curr = sideOptions(b);
+        const keys = ( new Set([...( Object.keys(prev)), ...( Object.keys(curr))]));
+        if (keys.size === 0) {
+            return;
+        }
+        const section = append(this.content, $(".chat-debug-cache-section"));
+        append(section, $("h3.chat-debug-cache-section-h", undefined, ( localize(6084, "Request Options"))));
+        const table = append(section, $(".chat-debug-cache-options-table"));
+        const head = append(table, $(".chat-debug-cache-options-row.head"));
+        append(head, $(".chat-debug-cache-options-cell.key", undefined, ( localize(6085, "Option"))));
+        append(head, $(".chat-debug-cache-options-cell", undefined, ( localize(6086, "Previous"))));
+        append(head, $(".chat-debug-cache-options-cell", undefined, ( localize(6087, "Current"))));
+        const sortedKeys = [...keys].sort((x, y) => x.localeCompare(y));
+        for (const key of sortedKeys) {
+            const row = append(table, $(".chat-debug-cache-options-row"));
+            const av = prev[key];
+            const bv = curr[key];
+            const changed = !equals(av, bv);
+            if (changed) {
+                row.classList.add("changed");
+            }
+            append(row, $(".chat-debug-cache-options-cell.key", undefined, key));
+            append(row, $(".chat-debug-cache-options-cell", undefined, formatOptionValue(av)));
+            append(row, $(".chat-debug-cache-options-cell", undefined, formatOptionValue(bv)));
+        }
+    }
+    renderComponents(drift, a, b, compareInputMessages) {
+        const section = append(this.content, $(".chat-debug-cache-section"));
+        append(section, $("h3.chat-debug-cache-section-h", undefined, ( localize(6088, "Components"))));
+        if (!compareInputMessages && b.requestShape.isContinuation) {
+            const note = append(
+                section,
+                $(".chat-debug-cache-sig-summary.chat-debug-cache-request-shape-note")
+            );
+            note.textContent = ( localize(
+                6089,
+                "This request uses previous_response_id, so input messages are not positionally diffed against the previous request. Components below show cache-key shape changes; the current continuation delta is shown separately."
+            ));
+        }
+        const acc = append(section, $(".chat-debug-cache-acc"));
+        const effectiveDrift = !compareInputMessages && b.requestShape.isContinuation && b.inputMessages.length > 0 ? [...drift, currentDeltaComponent(b)] : drift;
+        if (effectiveDrift.length === 0) {
+            const empty = append(acc, $(".chat-debug-cache-acc-empty"));
+            empty.textContent = ( localize(6090, "All components are identical between A and B."));
+            return;
+        }
+        for (const c of effectiveDrift) {
+            const item = append(acc, $(".chat-debug-cache-acc-item"));
+            item.classList.add(c.status);
+            if (( this.openComponents.has(c.name))) {
+                item.classList.add("open");
+            }
+            const head = append(item, $(".chat-debug-cache-acc-head"));
+            append(head, $("span.chat-debug-cache-chev"));
+            const name = append(head, $(".chat-debug-cache-acc-name"));
+            if (c.role) {
+                append(name, $("span.role", undefined, c.role));
+            }
+            append(name, $$1("span", undefined, c.name));
+            const badge = append(head, $(`span.chat-debug-cache-acc-badge.${c.status}`));
+            badge.textContent = badgeLabel(c.status);
+            const sizes = append(head, $("span.chat-debug-cache-acc-sizes"));
+            sizes.textContent = ( localize(6091, "{0} → {1} chars", formatTokens(c.aSize), formatTokens(c.bSize)));
+            const body = append(item, $(".chat-debug-cache-acc-body"));
+            const aText = c.name === CURRENT_CONTINUATION_DELTA_COMPONENT ? "" : textForComponent(c, a);
+            const bText = c.name === CURRENT_CONTINUATION_DELTA_COMPONENT ? continuationDeltaText(b) : textForComponent(c, b);
+            const truncationNote = describeTruncation(aText, bText);
+            if (truncationNote) {
+                const note = append(item, $(".chat-debug-cache-acc-truncated"));
+                note.textContent = truncationNote;
+                note.title = truncationNote;
+                head.title = truncationNote;
+            }
+            body.appendChild(this.renderComponentDiff(aText, bText, c.aSize, c.bSize));
+            this.loadDisposables.add(addDisposableListener(head, EventType.CLICK, () => {
+                if (( this.openComponents.has(c.name))) {
+                    this.openComponents.delete(c.name);
+                    item.classList.remove("open");
+                } else {
+                    this.openComponents.add(c.name);
+                    item.classList.add("open");
+                }
+            }));
+        }
+    }
+    renderComponentDiff(aText, bText, aSize, bSize) {
+        const grid = $(".chat-debug-cache-diff");
+        const colA = append(grid, $(".chat-debug-cache-diff-col"));
+        append(colA, $("h4", undefined, ( localize(6092, "Previous · {0} chars", numberFormatter.value.format(aSize)))));
+        const aBody = append(colA, $(".chat-debug-cache-diff-body"));
+        const colB = append(grid, $(".chat-debug-cache-diff-col"));
+        append(colB, $("h4", undefined, ( localize(6093, "Current · {0} chars", numberFormatter.value.format(bSize)))));
+        const bBody = append(colB, $(".chat-debug-cache-diff-body"));
+        if (!aText && !bText) {
+            aBody.textContent = ( localize(6094, "(not present)"));
+            bBody.textContent = ( localize(6094, "(not present)"));
+            return grid;
+        }
+        renderInlineDiff(aBody, bBody, aText, bText);
+        return grid;
+    }
+};
+ChatDebugCacheExplorerView = ( __decorate([( __param(1, IChatService)), ( __param(2, IChatDebugService))], ChatDebugCacheExplorerView));
+function findSection(sections, name) {
+    if (!sections) {
+        return undefined;
+    }
+    for (const s of sections) {
+        if (s.name === name) {
+            return s.content;
+        }
+    }
+    return undefined;
+}
+function buildTurnGroups(turns, userMessages) {
+    const userById = ( new Map());
+    for (const um of userMessages) {
+        if (!um.id) {
+            continue;
+        }
+        userById.set(um.id, um);
+        const stripped = um.id.startsWith("user-msg-") ? um.id.slice("user-msg-".length) : um.id;
+        userById.set(stripped, um);
+    }
+    const groups = ( new Map());
+    const order = [];
+    turns.forEach((turn, index) => {
+        const key = turn.parentEventId ?? turn.id ?? `turn-${index}`;
+        let entry = groups.get(key);
+        if (!entry) {
+            entry = {
+                userMessage: userById.get(key) ?? userById.get(`user-msg-${key}`),
+                turns: []
+            };
+            groups.set(key, entry);
+            order.push(key);
+        }
+        entry.turns.push({
+            turn,
+            index
+        });
+    });
+    return ( order.map(key => ({
+        key,
+        userMessage: groups.get(key).userMessage,
+        turns: groups.get(key).turns
+    })));
+}
+function textForComponent(c, side) {
+    if (c.name === "system") {
+        return side.system ?? "";
+    }
+    if (c.name === "tools") {
+        return side.tools ?? "";
+    }
+    if (c.name === CURRENT_CONTINUATION_DELTA_COMPONENT) {
+        return continuationDeltaText(side);
+    }
+    const m = /^messages\[(\d+)\]$/.exec(c.name);
+    if (m) {
+        const idx = parseInt(m[1], 10);
+        return side.inputMessages[idx]?.text ?? "";
+    }
+    return "";
+}
+function continuationDeltaText(side) {
+    return side.requestShape.isContinuation ? ( side.inputMessages.map((m, index) => `input[${index}] ${m.role}\n${m.text}`)).join("\n\n") : "";
+}
+function currentDeltaComponent(side) {
+    const size = side.inputMessages.reduce((sum, m) => sum + m.charLength, 0);
+    return {
+        name: CURRENT_CONTINUATION_DELTA_COMPONENT,
+        role: side.requestShape.inputItemTypes.join(", ") || ( side.inputMessages.map(m => m.role)).join(", ") || undefined,
+        status: CacheDiffKind.OnlyInB,
+        aSize: 0,
+        bSize: size
+    };
+}
+function badgeLabel(status) {
+    switch (status) {
+    case CacheDiffKind.Identical:
+        return localize(6095, "identical");
+    case CacheDiffKind.ContentDrift:
+        return localize(6096, "content drift");
+    case CacheDiffKind.LengthChange:
+        return localize(6097, "length change");
+    case CacheDiffKind.OnlyInA:
+        return localize(6098, "only in A");
+    case CacheDiffKind.OnlyInB:
+        return localize(6099, "only in B");
+    }
+}
+function describeTruncation(aText, bText) {
+    const re = /\.\.\.\[truncated, original (\d+) chars\]$/;
+    const aMatch = re.exec(aText);
+    const bMatch = re.exec(bText);
+    if (!aMatch && !bMatch) {
+        return undefined;
+    }
+    if (aMatch && bMatch) {
+        return localize(
+            6100,
+            "Both sides truncated by the OTel attribute cap (originals were {0} and {1} chars) — diff may be partial.",
+            numberFormatter.value.format(parseInt(aMatch[1], 10)),
+            numberFormatter.value.format(parseInt(bMatch[1], 10))
+        );
+    }
+    const match = (aMatch ?? bMatch);
+    const side = aMatch ? ( localize(6101, "Previous")) : ( localize(6102, "Current"));
+    return localize(
+        6103,
+        "{0} side truncated by the OTel attribute cap (original was {1} chars) — diff may be partial.",
+        side,
+        numberFormatter.value.format(parseInt(match[1], 10))
+    );
+}
+function describeBreakKind(kind, diff, b) {
+    const tok = diff.signature.find(t => t.index === diff.break?.index);
+    const role = tok?.bRole ?? tok?.aRole ?? "message";
+    const bMsg = b.inputMessages[diff.break?.index ?? -1];
+    const charsB = bMsg ? numberFormatter.value.format(bMsg.charLength) : undefined;
+    switch (kind) {
+    case CacheDiffKind.OnlyInB:
+        return charsB ? ( localize(6104, "added {0} message ({1} chars)", role, charsB)) : ( localize(6105, "added {0} message", role));
+    case CacheDiffKind.OnlyInA:
+        return localize(6106, "previous {0} message dropped", role);
+    case CacheDiffKind.ContentDrift:
+        return charsB ? ( localize(6107, "{0} message body changed ({1} chars)", role, charsB)) : ( localize(6108, "{0} message body changed", role));
+    case CacheDiffKind.LengthChange:
+        return charsB ? ( localize(6109, "{0} message resized to {1} chars", role, charsB)) : ( localize(6110, "{0} message size changed", role));
+    }
+}
+function computeCacheHit(event) {
+    if (!event.inputTokens || event.cachedTokens === undefined) {
+        return 0;
+    }
+    return Math.min(100, (event.cachedTokens / event.inputTokens) * 100);
+}
+function shouldCompareInputMessages(a, b) {
+    return !a.requestShape.isContinuation && !b.requestShape.isContinuation;
+}
+function describeRequestShape(inputMessages, requestShapeJson) {
+    const metadata = parseRequestShapeMetadata(requestShapeJson);
+    const inputItemTypes = Array.isArray(metadata?.inputItemTypes) ? metadata.inputItemTypes.filter(x => typeof x === "string") : [];
+    const common = {
+        api: typeof metadata?.api === "string" ? metadata.api : undefined,
+        inputItemTypes
+    };
+    const hasPreviousResponseId = metadata?.hasPreviousResponseId === true;
+    const hasToolSearchOutput = inputItemTypes.includes("tool_search_output") || ( inputMessages.some(m => m.role === "tool_search"));
+    const hasOnlyToolOutput = inputMessages.length > 0 && inputMessages.every(m => m.role === "tool");
+    if (hasPreviousResponseId && hasToolSearchOutput) {
+        return {
+            label: ( localize(6111, "tool_search_output continuation")),
+            description: ( localize(
+                6112,
+                "Responses API continuation: the displayed input is only the tool-search delta sent over the wire. The provider reconstructs prior context from the previous response id."
+            )),
+            isContinuation: true,
+            ...common
+        };
+    }
+    if (hasPreviousResponseId && hasOnlyToolOutput) {
+        return {
+            label: ( localize(6113, "tool output continuation")),
+            description: ( localize(
+                6114,
+                "Responses API continuation: the displayed input is only the tool-output delta sent over the wire. The provider reconstructs prior context from the previous response id."
+            )),
+            isContinuation: true,
+            ...common
+        };
+    }
+    if (hasPreviousResponseId) {
+        return {
+            label: ( localize(6115, "Responses API continuation")),
+            description: ( localize(
+                6116,
+                "Responses API continuation: the displayed input is only the delta sent over the wire. The provider reconstructs prior context from the previous response id."
+            )),
+            isContinuation: true,
+            ...common
+        };
+    }
+    if (hasToolSearchOutput) {
+        return {
+            label: ( localize(6117, "tool_search_output request")),
+            description: ( localize(
+                6118,
+                "This request contains a Responses API tool_search_output item. No previous-response continuation marker was captured, so the displayed input may be a full or history-sliced request rather than only a continuation delta."
+            )),
+            isContinuation: false,
+            ...common
+        };
+    }
+    if (hasOnlyToolOutput) {
+        return {
+            label: ( localize(6119, "tool output request")),
+            description: undefined,
+            isContinuation: false,
+            ...common
+        };
+    }
+    return {
+        label: ( localize(6120, "full input request")),
+        description: undefined,
+        isContinuation: false,
+        ...common
+    };
+}
+function parseRequestShapeMetadata(requestShapeJson) {
+    if (!requestShapeJson) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(requestShapeJson);
+        if (parsed && typeof parsed === "object") {
+            return parsed;
+        }
+    } catch {}
+    return undefined;
+}
+function roleClass(role) {
+    switch (role) {
+    case "system":
+    case "tools":
+    case "user":
+    case "assistant":
+    case "tool":
+        return role;
+    case "tool_search":
+        return "tool-search";
+    default:
+        return "tool";
+    }
+}
+function formatCachePct(pct) {
+    const truncated = Math.floor(pct * 100) / 100;
+    return truncated.toFixed(2);
+}
+function formatCachePctInt(pct) {
+    return String(Math.floor(pct));
+}
+function formatTokens(value) {
+    if (value === undefined) {
+        return "—";
+    }
+    return numberFormatter.value.format(value);
+}
+function sideOptions(side) {
+    const out = {};
+    if (side.event.model !== undefined) {
+        out.model = side.event.model;
+    }
+    Object.assign(out, parseOptions(side.content?.requestOptions));
+    return out;
+}
+function computeOptionsDiff(a, b) {
+    const prev = sideOptions(a);
+    const curr = sideOptions(b);
+    const keys = ( new Set([...( Object.keys(prev)), ...( Object.keys(curr))]));
+    const out = [];
+    for (const key of keys) {
+        const av = prev[key];
+        const bv = curr[key];
+        if (!equals(av, bv)) {
+            out.push({
+                key,
+                previous: av,
+                current: bv
+            });
+        }
+    }
+    out.sort((x, y) => x.key.localeCompare(y.key));
+    return out;
+}
+function parseOptions(blob) {
+    if (!blob) {
+        return {};
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(blob);
+    } catch {
+        return {};
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return {};
+    }
+    const flat = {};
+    for (const [k, v] of Object.entries(parsed)) {
+        if (v && typeof v === "object" && !Array.isArray(v)) {
+            for (const [nk, nv] of Object.entries(v)) {
+                flat[`${k}.${nk}`] = nv;
+            }
+        } else {
+            flat[k] = v;
+        }
+    }
+    return flat;
+}
+function formatOptionValue(value) {
+    if (value === undefined) {
+        return "—";
+    }
+    if (value === null) {
+        return "null";
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    try {
+        return JSON.stringify(value);
+    } catch {
+        return String(value);
+    }
+}
+function isLikelyCacheExpiration(hitPct, diff, optionsDiff, systemChanged, toolsChanged) {
+    if (hitPct >= 1) {
+        return false;
+    }
+    if (diff.break) {
+        return false;
+    }
+    if (optionsDiff.length > 0) {
+        return false;
+    }
+    if (systemChanged || toolsChanged) {
+        return false;
+    }
+    return true;
+}
+const DIFF_OPTIONS = {
+    ignoreTrimWhitespace: false,
+    maxComputationTimeMs: 200,
+    computeMoves: false
+};
+function renderInlineDiff(prevHost, currHost, prev, curr) {
+    const prevLines = prev.split(/\r?\n/);
+    const currLines = curr.split(/\r?\n/);
+    const result = linesDiffComputers.getDefault().computeDiff(prevLines, currLines, DIFF_OPTIONS);
+    let prevIdx = 0;
+    let currIdx = 0;
+    for (const change of result.changes) {
+        const origStart = change.original.startLineNumber;
+        const origEnd = change.original.endLineNumberExclusive;
+        const modStart = change.modified.startLineNumber;
+        const modEnd = change.modified.endLineNumberExclusive;
+        while (prevIdx + 1 < origStart && currIdx + 1 < modStart) {
+            appendLine(prevHost, prevLines[prevIdx], "context");
+            appendLine(currHost, currLines[currIdx], "context");
+            prevIdx++;
+            currIdx++;
+        }
+        const innerByOrig = groupInnerChangesByLine(change.innerChanges,  true);
+        const innerByMod = groupInnerChangesByLine(change.innerChanges,  false);
+        for (let line = origStart; line < origEnd; line++) {
+            const lineText = prevLines[line - 1] ?? "";
+            appendChangedLine(prevHost, lineText, innerByOrig.get(line), "remove");
+        }
+        prevIdx = origEnd - 1;
+        for (let line = modStart; line < modEnd; line++) {
+            const lineText = currLines[line - 1] ?? "";
+            appendChangedLine(currHost, lineText, innerByMod.get(line), "add");
+        }
+        currIdx = modEnd - 1;
+    }
+    while (prevIdx < prevLines.length && currIdx < currLines.length) {
+        appendLine(prevHost, prevLines[prevIdx], "context");
+        appendLine(currHost, currLines[currIdx], "context");
+        prevIdx++;
+        currIdx++;
+    }
+}
+function appendLine(host, text, kind) {
+    const line = append(host, $(`.chat-debug-cache-diff-line.${kind}`));
+    line.textContent = text === "" ? " " : text;
+}
+function appendChangedLine(host, text, ranges, kind) {
+    const line = append(host, $(`.chat-debug-cache-diff-line.${kind}`));
+    if (!ranges || ranges.length === 0) {
+        line.textContent = text === "" ? " " : text;
+        return;
+    }
+    let cursor = 1;
+    const sorted = [...ranges].sort((a, b) => a.startColumn - b.startColumn);
+    for (const r of sorted) {
+        if (r.startColumn > cursor) {
+            append(line, createTextNode(text.substring(cursor - 1, r.startColumn - 1)));
+        }
+        const span = append(line, $("span.chat-debug-cache-diff-inner"));
+        span.textContent = text.substring(r.startColumn - 1, r.endColumn - 1);
+        cursor = r.endColumn;
+    }
+    if (cursor - 1 < text.length) {
+        append(line, createTextNode(text.substring(cursor - 1)));
+    }
+}
+function groupInnerChangesByLine(innerChanges, useOriginal) {
+    const out = ( new Map());
+    if (!innerChanges) {
+        return out;
+    }
+    for (const r of innerChanges) {
+        const range = useOriginal ? r.originalRange : r.modifiedRange;
+        if (range.startLineNumber !== range.endLineNumber) {
+            continue;
+        }
+        const list = out.get(range.startLineNumber) ?? [];
+        list.push({
+            startColumn: range.startColumn,
+            endColumn: range.endColumn
+        });
+        out.set(range.startLineNumber, list);
+    }
+    return out;
+}
+
+export { CacheExplorerNavigation, ChatDebugCacheExplorerView };