@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

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

@@ -75,31 +75,31 @@ function describeStringDivergence(d) {
     switch (d.shape) {
     case StringDivergenceShape.TrailingAdded:
         return localize(
-            6678,
+            7738,
             "{0} chars appended — the previous content survives as a shared prefix",
             fmt(d.bLength - d.aLength)
         );
     case StringDivergenceShape.TrailingRemoved:
         return localize(
-            6679,
+            7739,
             "last {0} chars removed — the remaining content still matches the previous bytes",
             fmt(d.aLength - d.bLength)
         );
     case StringDivergenceShape.LeadingAdded:
         return localize(
-            6680,
+            7740,
             "{0} chars prepended — this block no longer starts with the same bytes",
             fmt(d.bLength - d.aLength)
         );
     case StringDivergenceShape.LeadingRemoved:
         return localize(
-            6681,
+            7741,
             "first {0} chars removed — this block no longer starts with the same bytes",
             fmt(d.aLength - d.bLength)
         );
     case StringDivergenceShape.InnerEdit:
         return localize(
-            6682,
+            7742,
             "edited in place — first difference at char {0} ({1} leading and {2} trailing chars unchanged)",
             fmt(d.commonPrefix),
             fmt(d.commonPrefix),
@@ -156,11 +156,11 @@ function detectVolatileValueAround(a, b, dv) {
 function volatileValueLabel(kind) {
     switch (kind) {
     case VolatileValueKind.Timestamp:
-        return localize(6683, "timestamp");
+        return localize(7743, "timestamp");
     case VolatileValueKind.Uuid:
-        return localize(6684, "unique id (UUID)");
+        return localize(7744, "unique id (UUID)");
     case VolatileValueKind.Counter:
-        return localize(6685, "large changing number");
+        return localize(7745, "large changing number");
     }
 }
 function parseToolList(toolsJson) {
@@ -251,10 +251,10 @@ function computeCacheInsights(input) {
     if (modelChanged) {
         out.push({
             severity: CacheInsightSeverity.Critical,
-            title: ( localize(6686, "Model changed")),
-            detail: ( localize(6687, "{0} → {1}", input.aModel ?? "—", input.bModel ?? "—")),
+            title: ( localize(7746, "Model changed")),
+            detail: ( localize(7747, "{0} → {1}", input.aModel ?? "—", input.bModel ?? "—")),
             hint: ( localize(
-                6688,
+                7748,
                 "Prompt caches are scoped to a model — switching models recomputes the entire prompt. Route sub-tasks that need a different model through a separate request chain so the main loop keeps its cache."
             )),
             category: CacheBreakCategory.Model
@@ -269,10 +269,10 @@ function computeCacheInsights(input) {
     if (input.optionsDiff.length > 0) {
         out.push({
             severity: CacheInsightSeverity.Warning,
-            title: ( localize(6689, "Request options changed")),
+            title: ( localize(7749, "Request options changed")),
             detail: ( input.optionsDiff.map(d => `${d.key}: ${d.previousLabel} → ${d.currentLabel}`)).join(" · "),
             hint: ( localize(
-                6690,
+                7750,
                 "Options are part of the cache key on most providers. Keep per-request options stable when cache reuse matters."
             )),
             category: CacheBreakCategory.Options
@@ -286,9 +286,9 @@ function computeCacheInsights(input) {
     } else if (input.isContinuation) {
         out.push({
             severity: CacheInsightSeverity.Info,
-            title: ( localize(6691, "Responses API continuation")),
+            title: ( localize(7751, "Responses API continuation")),
             detail: ( localize(
-                6692,
+                7752,
                 "Only the wire delta is captured for this request; prior context is referenced by previous_response_id and reconstructed provider-side. Analysis is limited to system, tools, and request options."
             )),
             category: CacheBreakCategory.Unknown
@@ -296,9 +296,9 @@ function computeCacheInsights(input) {
     } else if (input.previousIsContinuation) {
         out.push({
             severity: CacheInsightSeverity.Info,
-            title: ( localize(6693, "Message comparison suppressed")),
+            title: ( localize(7753, "Message comparison suppressed")),
             detail: ( localize(
-                6694,
+                7754,
                 "The previous request was a Responses API continuation (delta-only wire input); positionally diffing this full request against it would be misleading."
             )),
             category: CacheBreakCategory.Unknown
@@ -312,14 +312,14 @@ function toolsInsight(aTools, bTools) {
     if (delta?.reorderedOnly) {
         return {
             severity: CacheInsightSeverity.Critical,
-            title: ( localize(6695, "Tool definitions reordered")),
+            title: ( localize(7755, "Tool definitions reordered")),
             detail: ( localize(
-                6696,
+                7756,
                 "Same {0} tools with identical definitions, sent in a different order.",
                 fmt(delta.bCount)
             )),
             hint: ( localize(
-                6697,
+                7757,
                 "Tools render at the very start of the prompt — a pure reorder still changes the bytes and invalidates the entire cache. Serialize the tool list deterministically (e.g. sort by name)."
             )),
             component,
@@ -329,25 +329,25 @@ function toolsInsight(aTools, bTools) {
     if (delta && (delta.added.length > 0 || delta.removed.length > 0)) {
         const parts = [];
         if (delta.added.length > 0) {
-            parts.push(( localize(6698, "added: {0}", delta.added.join(", "))));
+            parts.push(( localize(7758, "added: {0}", delta.added.join(", "))));
         }
         if (delta.removed.length > 0) {
-            parts.push(( localize(6699, "removed: {0}", delta.removed.join(", "))));
+            parts.push(( localize(7759, "removed: {0}", delta.removed.join(", "))));
         }
         if (delta.modified.length > 0) {
-            parts.push(( localize(6700, "modified: {0}", delta.modified.join(", "))));
+            parts.push(( localize(7760, "modified: {0}", delta.modified.join(", "))));
         }
         return {
             severity: CacheInsightSeverity.Critical,
             title: ( localize(
-                6701,
+                7761,
                 "Tool catalog changed ({0} → {1} tools)",
                 fmt(delta.aCount),
                 fmt(delta.bCount)
             )),
             detail: parts.join(" · "),
             hint: ( localize(
-                6702,
+                7762,
                 "Tool definitions render before everything else, so adding or removing a tool mid-session invalidates the whole prompt. Keep the tool set stable for the life of a session, or use deferred/appended tool loading instead of swapping the catalog."
             )),
             component,
@@ -357,10 +357,10 @@ function toolsInsight(aTools, bTools) {
     if (delta && delta.modified.length > 0) {
         return {
             severity: CacheInsightSeverity.Critical,
-            title: ( localize(6703, "Tool definitions modified")),
-            detail: ( localize(6704, "changed: {0}", delta.modified.join(", "))),
+            title: ( localize(7763, "Tool definitions modified")),
+            detail: ( localize(7764, "changed: {0}", delta.modified.join(", "))),
             hint: ( localize(
-                6705,
+                7765,
                 "A changed tool description or schema rewrites the prompt from the tools block onward. Check for dynamic content (counts, paths, timestamps) inside tool descriptions."
             )),
             component,
@@ -370,10 +370,10 @@ function toolsInsight(aTools, bTools) {
     const dv = analyzeStringDivergence(aTools ?? "", bTools ?? "");
     return {
         severity: CacheInsightSeverity.Critical,
-        title: ( localize(6706, "Tool catalog changed")),
+        title: ( localize(7766, "Tool catalog changed")),
         detail: dv ? describeStringDivergence(dv) : undefined,
         hint: ( localize(
-            6707,
+            7767,
             "The tool catalog is the first block of the prompt — any byte change here invalidates the entire cache."
         )),
         component,
@@ -385,20 +385,20 @@ function systemInsight(aSystem, bSystem) {
     const volatile = dv ? detectVolatileValueAround(aSystem ?? "", bSystem ?? "", dv) : undefined;
     return {
         severity: CacheInsightSeverity.Critical,
-        title: ( localize(6708, "System prompt changed")),
+        title: ( localize(7768, "System prompt changed")),
         detail: dv ? ( localize(
-            6709,
+            7769,
             "{0} → {1} chars · {2}",
             fmt(dv.aLength),
             fmt(dv.bLength),
             describeStringDivergence(dv)
         )) : undefined,
         hint: volatile ? ( localize(
-            6710,
+            7770,
             "The changed region looks like a {0} — volatile values interpolated into the system prompt break the cache on every request. Move dynamic content after the conversation history or drop it.",
             volatileValueLabel(volatile)
         )) : ( localize(
-            6711,
+            7771,
             "A system prompt change invalidates everything after the tools block. Keep the system prompt byte-stable for the life of a session and inject per-turn context into the newest message instead."
         )),
         component: "system",
@@ -419,9 +419,9 @@ function messageInsights(input, hasEarlierBreak) {
     if (diff.break.kind === CacheDiffKind.OnlyInB) {
         out.push({
             severity: hasEarlierBreak ? CacheInsightSeverity.Info : CacheInsightSeverity.Ok,
-            title: ( localize(6712, "New messages appended — expected growth")),
+            title: ( localize(7772, "New messages appended — expected growth")),
             detail: ( localize(
-                6713,
+                7773,
                 "{0} new message(s) after {1} unchanged — the shared prefix was extended, not broken. The uncached tokens are the new suffix being written to the cache for the next request.",
                 fmt(counts.onlyInB),
                 fmt(counts.identical)
@@ -433,17 +433,17 @@ function messageInsights(input, hasEarlierBreak) {
             out.push({
                 severity: CacheInsightSeverity.Warning,
                 title: ( localize(
-                    6714,
+                    7774,
                     "{0} blocks appended — beyond the typical cache lookback window",
                     fmt(counts.onlyInB)
                 )),
                 detail: ( localize(
-                    6715,
+                    7775,
                     "Providers typically look back ~{0} content blocks for a prior cache entry; a turn that appends more can silently miss it even though the prefix matches.",
                     LOOKBACK_WINDOW_BLOCKS
                 )),
                 hint: ( localize(
-                    6716,
+                    7776,
                     "During long tool loops, place intermediate cache breakpoints every ~15 blocks so the next request can still find a cache entry."
                 ))
             });
@@ -453,14 +453,14 @@ function messageInsights(input, hasEarlierBreak) {
     if (diff.break.kind === CacheDiffKind.OnlyInA) {
         out.push({
             severity: CacheInsightSeverity.Critical,
-            title: ( localize(6717, "History truncated at messages[{0}]", idx)),
+            title: ( localize(7777, "History truncated at messages[{0}]", idx)),
             detail: ( localize(
-                6718,
+                7778,
                 "{0} message(s) present in the previous request are missing from this one.",
                 fmt(counts.onlyInA)
             )),
             hint: ( localize(
-                6719,
+                7779,
                 "History slicing or compaction shortens the prefix — the cache can only match up to the cut, and everything after it is recomputed."
             )),
             component,
@@ -477,7 +477,7 @@ function messageInsights(input, hasEarlierBreak) {
     const detailParts = [];
     if (aMsg && bMsg) {
         detailParts.push(( localize(
-            6720,
+            7780,
             "{0} message, {1} → {2} chars",
             role,
             fmt(aMsg.charLength),
@@ -489,14 +489,14 @@ function messageInsights(input, hasEarlierBreak) {
     }
     out.push({
         severity: CacheInsightSeverity.Critical,
-        title: ( localize(6721, "History rewritten at messages[{0}]", idx)),
+        title: ( localize(7781, "History rewritten at messages[{0}]", idx)),
         detail: detailParts.join(" · "),
         hint: volatile ? ( localize(
-            6722,
+            7782,
             "The changed region looks like a {0} — a volatile value re-rendered into the conversation history breaks the prefix on every request.",
             volatileValueLabel(volatile)
         )) : ( localize(
-            6723,
+            7783,
             "Conversation history must be byte-identical between requests to reuse the cached prefix. A re-serialized {0} turn — trimmed whitespace, dropped reasoning or preamble text, reformatted tool calls — silently invalidates everything after it.",
             role
         )),
@@ -508,12 +508,12 @@ function messageInsights(input, hasEarlierBreak) {
         out.push({
             severity: CacheInsightSeverity.Info,
             title: ( localize(
-                6724,
+                7784,
                 "{0} more changed position(s) after the break",
                 fmt(changedAfterBreak)
             )),
             detail: ( localize(
-                6725,
+                7785,
                 "Once the prefix breaks at messages[{0}], everything after it is recomputed regardless — fix the first break first.",
                 idx
             ))
@@ -526,14 +526,14 @@ function stablePrefixInsight(input) {
         if (input.inputTokens > 0 && input.inputTokens < MIN_CACHEABLE_TOKENS) {
             return {
                 severity: CacheInsightSeverity.Warning,
-                title: ( localize(6726, "Prompt may be below the minimum cacheable size")),
+                title: ( localize(7786, "Prompt may be below the minimum cacheable size")),
                 detail: ( localize(
-                    6727,
+                    7787,
                     "{0} input tokens — providers only cache prompts above a minimum prefix size (roughly 1,024-4,096 tokens depending on model), and smaller prompts silently never cache.",
                     fmt(input.inputTokens)
                 )),
                 hint: ( localize(
-                    6728,
+                    7788,
                     "Small utility requests (titles, summaries) often sit below the threshold; a 0% hit on them is normal and not worth optimizing."
                 )),
                 category: CacheBreakCategory.Expiration
@@ -541,21 +541,21 @@ function stablePrefixInsight(input) {
         }
         const minutes = input.minutesSincePrevious;
         const gap = minutes !== undefined && minutes >= 1 ? ( localize(
-            6729,
+            7789,
             " {0} minute(s) elapsed since the previous request.",
             fmt(Math.round(minutes))
         )) : "";
         return {
             severity: CacheInsightSeverity.Warning,
-            title: ( localize(6730, "Likely cache expiration")),
+            title: ( localize(7790, "Likely cache expiration")),
             detail: ( localize(
-                6731,
+                7791,
                 "The prompt is byte-identical to the previous request but only {0}% was served from cache.{1}",
                 input.hitPct.toFixed(2),
                 gap
             )),
             hint: ( localize(
-                6732,
+                7792,
                 "Provider prompt caches expire after a few minutes of inactivity (typically ~{0} min). Long gaps between requests recompute the full prompt even when nothing changed.",
                 TYPICAL_TTL_MINUTES
             )),
@@ -564,9 +564,9 @@ function stablePrefixInsight(input) {
     }
     return {
         severity: CacheInsightSeverity.Ok,
-        title: ( localize(6733, "Prompt prefix fully stable")),
+        title: ( localize(7793, "Prompt prefix fully stable")),
         detail: ( localize(
-            6734,
+            7794,
             "No divergence detected — {0}% of input tokens were served from cache.",
             input.hitPct.toFixed(2)
         )),
@@ -588,21 +588,21 @@ function categorizeCacheBreak(insights) {
 function cacheBreakCategoryLabel(category) {
     switch (category) {
     case CacheBreakCategory.Healthy:
-        return localize(6735, "healthy growth");
+        return localize(7795, "healthy growth");
     case CacheBreakCategory.Expiration:
-        return localize(6736, "expiration / not cacheable");
+        return localize(7796, "expiration / not cacheable");
     case CacheBreakCategory.Model:
-        return localize(6737, "model changed");
+        return localize(7797, "model changed");
     case CacheBreakCategory.Tools:
-        return localize(6738, "tool catalog changed");
+        return localize(7798, "tool catalog changed");
     case CacheBreakCategory.System:
-        return localize(6739, "system prompt changed");
+        return localize(7799, "system prompt changed");
     case CacheBreakCategory.Options:
-        return localize(6740, "request options changed");
+        return localize(7800, "request options changed");
     case CacheBreakCategory.History:
-        return localize(6741, "history rewritten");
+        return localize(7801, "history rewritten");
     case CacheBreakCategory.Unknown:
-        return localize(6742, "not classified");
+        return localize(7802, "not classified");
     }
 }
 const AVOIDABLE_CATEGORIES = [
@@ -665,14 +665,14 @@ function buildSessionCacheReport(pairs, turnTokens = []) {
             findings.push({
                 severity: CacheInsightSeverity.Critical,
                 title: ( localize(
-                    6743,
+                    7803,
                     "Recurring invalidator: {0} in {1} of {2} request pairs",
                     cacheBreakCategoryLabel(stat.category),
                     fmt(stat.count),
                     fmt(pairs.length)
                 )),
                 detail: ( localize(
-                    6744,
+                    7804,
                     "~{0} tokens recomputed across those requests. A break that repeats is systemic — look for the same root cause on every occurrence.",
                     fmt(stat.lostTokens)
                 )),
@@ -681,14 +681,14 @@ function buildSessionCacheReport(pairs, turnTokens = []) {
         } else if (stat.category === CacheBreakCategory.Expiration) {
             findings.push({
                 severity: CacheInsightSeverity.Warning,
-                title: ( localize(6745, "Cache likely expired {0} times", fmt(stat.count))),
+                title: ( localize(7805, "Cache likely expired {0} times", fmt(stat.count))),
                 detail: ( localize(
-                    6746,
+                    7806,
                     "~{0} tokens recomputed after idle gaps or on prompts below the cacheable minimum.",
                     fmt(stat.lostTokens)
                 )),
                 hint: ( localize(
-                    6747,
+                    7807,
                     "If long gaps are inherent to the workflow, consider a longer-TTL cache or pre-warming before the user returns."
                 )),
                 category: stat.category
@@ -698,9 +698,9 @@ function buildSessionCacheReport(pairs, turnTokens = []) {
     if (findings.length === 0 && pairs.length > 0 && healthyCount === pairs.length) {
         findings.push({
             severity: CacheInsightSeverity.Ok,
-            title: ( localize(6748, "All request pairs grew the prefix cleanly")),
+            title: ( localize(7808, "All request pairs grew the prefix cleanly")),
             detail: ( localize(
-                6749,
+                7809,
                 "Every request either appended new messages or matched the previous prompt exactly — no avoidable cache breaks in this session."
             )),
             category: CacheBreakCategory.Healthy

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

@@ -125,8 +125,8 @@ let ChatDebugDetailPanel = class ChatDebugDetailPanel extends Disposable {
         this.headerElement = header;
         this.element.appendChild(this.scrollable.getDomNode());
         const fullScreenButton = this.detailDisposables.add(( new Button(header, {
-            ariaLabel: ( localize(6750, "Open in Editor")),
-            title: ( localize(6750, "Open in Editor"))
+            ariaLabel: ( localize(7810, "Open in Editor")),
+            title: ( localize(7810, "Open in Editor"))
         })));
         fullScreenButton.element.classList.add("chat-debug-detail-button");
         fullScreenButton.icon = Codicon.goToFile;
@@ -138,8 +138,8 @@ let ChatDebugDetailPanel = class ChatDebugDetailPanel extends Disposable {
             });
         }));
         const copyButton = this.detailDisposables.add(( new Button(header, {
-            ariaLabel: ( localize(6751, "Copy")),
-            title: ( localize(6751, "Copy"))
+            ariaLabel: ( localize(7811, "Copy")),
+            title: ( localize(7811, "Copy"))
         })));
         copyButton.element.classList.add("chat-debug-detail-button");
         copyButton.icon = Codicon.copy;
@@ -147,11 +147,11 @@ let ChatDebugDetailPanel = class ChatDebugDetailPanel extends Disposable {
             this.clipboardService.writeText(this.currentDetailText);
         }));
         const closeButton = this.detailDisposables.add(( new Button(header, {
-            ariaLabel: ( localize(6752, "Close")),
-            title: ( localize(6752, "Close"))
+            ariaLabel: ( localize(7812, "Close")),
+            title: ( localize(7812, "Close"))
         })));
         closeButton.element.classList.add("chat-debug-detail-button");
-        closeButton.icon = Codicon.close;
+        closeButton.icon = Codicon.closeSmall;
         this.detailDisposables.add(closeButton.onDidClick(() => {
             this.hide();
         }));

package/vscode/src/vs/workbench/contrib/chat/browser/chatDebug/chatDebugEditor.d.ts

@@ -12,6 +12,7 @@ import { EditorPane } from "@codingame/monaco-vscode-api/vscode/vs/workbench/bro
 import { IEditorOpenContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor";
 import { EditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorInput";
 import { IEditorGroup } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService";
+import { IPreferencesService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/preferences/common/preferences.service";
 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 { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
@@ -23,6 +24,7 @@ export declare class ChatDebugEditor extends EditorPane {
     private readonly chatService;
     private readonly contextKeyService;
     private readonly configurationService;
+    private readonly preferencesService;
     static readonly ID: string;
     private container;
     private currentDimension;
@@ -32,7 +34,16 @@ export declare class ChatDebugEditor extends EditorPane {
     private logsView;
     private flowChartView;
     private cacheExplorerView;
+    private wireLogView;
     private filterState;
+    private _scopedContextKeyService;
+    /**
+     * Shared overlay shown in place of a session sub-view (Logs, Flow Chart,
+     * Cache Explorer) when agent debug logging is disabled for the session.
+     */
+    private disabledOverlay;
+    private readonly disabledOverlayDisposables;
+    get scopedContextKeyService(): IContextKeyService | undefined;
     private readonly sessionModelListener;
     private readonly modelChangeListeners;
     /**
@@ -41,14 +52,23 @@ export declare class ChatDebugEditor extends EditorPane {
      * when the editor becomes hidden.
      */
     private endActiveSession;
-    constructor(group: IEditorGroup, telemetryService: ITelemetryService, themeService: IThemeService, storageService: IStorageService, instantiationService: IInstantiationService, chatDebugService: IChatDebugService, chatWidgetService: IChatWidgetService, chatService: IChatService, contextKeyService: IContextKeyService, configurationService: IConfigurationService);
+    constructor(group: IEditorGroup, telemetryService: ITelemetryService, themeService: IThemeService, storageService: IStorageService, instantiationService: IInstantiationService, chatDebugService: IChatDebugService, chatWidgetService: IChatWidgetService, chatService: IChatService, contextKeyService: IContextKeyService, configurationService: IConfigurationService, preferencesService: IPreferencesService);
     protected createEditor(parent: HTMLElement): void;
     private showView;
-    navigateToSession(sessionResource: URI, view?: "logs" | "overview" | "flowchart" | "cache"): void;
+    private displayView;
+    private updateDisabledOverlay;
+    navigateToSession(sessionResource: URI, view?: "logs" | "overview" | "flowchart" | "cache" | "wirelog"): void;
     private trackSessionModelChanges;
     focus(): void;
+    clearInput(): void;
     setInput(input: EditorInput, options: IEditorOptions | undefined, context: IEditorOpenContext, token: CancellationToken): Promise<void>;
     setOptions(options: IChatDebugEditorOptions | undefined): void;
+    /**
+     * The panel is enabled when either local file logging or agent-host (Copilot
+     * CLI) debug logging is on. Each provider self-gates on its own setting, so
+     * this only decides whether to fall back to the home view.
+     */
+    private _isDebugEnabled;
     protected setEditorVisible(visible: boolean): void;
     private _applyNavigationOptions;
     layout(dimension: Dimension): void;