@codingame/monaco-vscode-api 37.3.3 → 37.3.4

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

@@ -0,0 +1,183 @@
+import { Disposable } from "../../../../../base/common/lifecycle.js";
+import { URI } from "../../../../../base/common/uri.js";
+import { IFileService } from "../../../../../platform/files/common/files.service.js";
+import { ILogService } from "../../../../../platform/log/common/log.service.js";
+import { IAgentHostService } from "../../../../../platform/agentHost/common/agentService.service.js";
+import { IRemoteAgentHostService } from "../../../../../platform/agentHost/common/remoteAgentHostService.service.js";
+import { type ActionEnvelope } from "../../../../../platform/agentHost/common/state/sessionActions.js";
+import { type Customization } from "../../../../../platform/agentHost/common/state/sessionState.js";
+/**
+ * One captured Copilot `ChatUsage` action, i.e. the usage report for a single
+ * model call. Persisted as a line in the session's sidecar so per-turn/per-round
+ * token metrics survive a VS Code restart (the reduced chat state keeps only the
+ * last request's input/cache per turn, and `events.jsonl` only records
+ * `outputTokens` until `session.shutdown`).
+ */
+export interface IAgentHostUsageRecord {
+    /** Turn the model call belongs to. */
+    readonly turnId: string;
+    /** Model that served the call, if reported. */
+    readonly model?: string;
+    /** Input tokens for this single call. */
+    readonly inputTokens?: number;
+    /** Output tokens for this single call. */
+    readonly outputTokens?: number;
+    /** Cache-read tokens for this single call. */
+    readonly cacheReadTokens?: number;
+    /** Per-turn cumulative Copilot AIU (nano) at the time of this call. */
+    readonly totalNanoAiu?: number;
+    /** ISO timestamp when the client captured the action. */
+    readonly ts: string;
+}
+/** Builds the sidecar URI for a session's usage records under `baseDir`. */
+export declare function buildAgentHostUsageUri(baseDir: URI, rawSessionId: string): URI;
+/**
+ * Reads a session's usage sidecar. Returns the records in capture order,
+ * skipping blank or malformed lines. Returns an empty array when the file does
+ * not exist (e.g. a session that ran before capture shipped).
+ */
+export declare function readAgentHostUsageRecords(fileService: IFileService, uri: URI): Promise<IAgentHostUsageRecord[]>;
+/**
+ * The minimal agent-host surface the recorders observe: a stream of protocol
+ * actions plus the notifications that drive sidecar lifetime. Satisfied by
+ * {@link IAgentHostService} in production and by bare emitters in tests, so the
+ * recorders don't depend on the full service.
+ */
+type IAgentHostActionSource = Pick<IAgentHostService, "onDidAction" | "onDidNotification">;
+/**
+ * Shared client-side plumbing for recorders that observe agent-host protocol
+ * actions across the ambient (local) connection and every live remote
+ * connection, and persist derived data to a client-local sidecar. Enable
+ * gating, local/remote fan-out, and sidecar lifetime live here; subclasses
+ * implement {@link _onAction} for the action(s) they care about and
+ * {@link _sidecarUri} for the file to delete when a session goes away.
+ *
+ * Running on the client (where wire logs are captured) means every session's
+ * actions arrive through the same subscription reducers regardless of
+ * transport, so subclasses work uniformly for local and remote hosts.
+ *
+ * ## Why these sidecars are client-side
+ *
+ * The data they capture (`ChatUsage` / `SessionCustomizationsChanged`) is
+ * produced by the agent host, and the host persists its own copy of the parts
+ * it needs for correctness (see `turns.usage` in the session database, which
+ * restores the context-usage gauge and session cost). These sidecars are NOT
+ * that store and should not be confused with it — they exist because the
+ * renderer has no way to read host-side session storage: the AHP protocol is
+ * generated outside this repo, so no "read session data" RPC can be added here,
+ * and the session data directory's path is never published to clients. Until
+ * such a contract exists, a client-side capture is the only mechanism that
+ * works uniformly for local *and* remote hosts.
+ *
+ * The two stores therefore differ deliberately:
+ * - host store: per turn, always on, all providers, correctness-critical;
+ * - these sidecars: per model call, debug-gated, best-effort diagnostics.
+ *
+ * What IS unified: lifetime (both are deleted with their session — see
+ * {@link _sidecarUri}) and collection (both are included in the exported debug
+ * log bundle, so an export can explain a usage discrepancy).
+ */
+declare abstract class AgentHostActionRecorder extends Disposable {
+    protected readonly _baseDir: URI;
+    protected readonly _isEnabled: () => boolean;
+    protected readonly _fileService: IFileService;
+    protected readonly _logService: ILogService;
+    private readonly _remoteAgentHostService;
+    /** Live per-remote-connection listeners (actions + notifications), keyed by agent-host authority. */
+    private readonly _remoteListeners;
+    /**
+     * Per-session serialized file-operation queue shared by writes and cleanup,
+     * so a delete can never be overtaken by an in-flight write for the same
+     * session. Owned by the base class because deletion is driven from here.
+     */
+    private readonly _queues;
+    /**
+     * The connection object currently subscribed for each authority. Tracked so
+     * a reconnect (which replaces the connection object under the same
+     * authority) is detected and the listener re-subscribed to the live object.
+     */
+    private readonly _remoteConnections;
+    constructor(_baseDir: URI, _isEnabled: () => boolean, _fileService: IFileService, _logService: ILogService, agentHostService: IAgentHostActionSource, _remoteAgentHostService: IRemoteAgentHostService);
+    /** Gate on the enable predicate before handing the action to the subclass. */
+    private _dispatch;
+    /**
+     * Deletes a session's sidecar when the host reports the session removed, so
+     * these files don't accumulate indefinitely for sessions the user deleted
+     * (the host's own per-session storage cascades away with the session
+     * directory; without this the client-side copies would outlive it).
+     *
+     * Deliberately NOT gated on {@link _isEnabled}: toggling debug logging off
+     * must not strand the files already written while it was on.
+     */
+    private _onNotification;
+    /**
+     * Runs `operation` after any previously queued work for `rawSessionId`,
+     * keeping per-session file operations in submission order. Failures are
+     * swallowed (and traced) so one failed operation cannot break the chain.
+     */
+    protected queued(rawSessionId: string, operation: () => Promise<unknown>): Promise<void>;
+    /** Handle a single action from any (local or remote) connection. */
+    protected abstract _onAction(envelope: ActionEnvelope): void;
+    /** The sidecar file owned by this recorder for the given raw session id. */
+    protected abstract _sidecarUri(rawSessionId: string): URI;
+    /** Subscribes to each current remote connection's streams; drops stale ones. */
+    private _syncRemoteListeners;
+}
+/**
+ * Captures Copilot `ChatUsage` actions on the client and appends them to a
+ * stable, client-local per-session sidecar so token metrics survive a VS Code
+ * restart and feed accurate per-round Cache Explorer numbers.
+ *
+ * Dedup: a single model call can surface multiple `ChatUsage` actions —
+ *   1. a parent-scope emit on the session's DEFAULT chat channel, and
+ *   2. for sub-agent calls, a sub-agent-scope emit on a sub-agent chat channel
+ *      (`parseChatUri` maps both to the same session), and
+ *   3. an async re-emit carrying the same tokens plus `_meta.contextAttribution`.
+ * Capturing only actions on the default chat channel (1) that lack
+ * `contextAttribution` yields exactly one record per model call — and the
+ * parent aggregate already includes sub-agent token usage.
+ */
+export declare class AgentHostUsageRecorder extends AgentHostActionRecorder {
+    protected _sidecarUri(rawSessionId: string): URI;
+    protected _onAction(envelope: ActionEnvelope): void;
+    /**
+     * Appends a record to the session's sidecar. Uses the file system's append
+     * capability so each record is a single small write (no read-modify-write of
+     * the whole file, and no in-memory copy of the growing file) — writes are
+     * still serialized per session to keep records ordered. Records written
+     * before a restart are preserved because we append to the existing file.
+     */
+    private _append;
+}
+/** Builds the sidecar URI for a session's customization snapshot under `baseDir`. */
+export declare function buildAgentHostCustomizationsUri(baseDir: URI, rawSessionId: string): URI;
+/**
+ * Reads a session's persisted customization snapshot — the last
+ * full-replacement `SessionCustomizationsChanged` payload captured live.
+ * Returns `undefined` when the file is absent (e.g. a session that ran before
+ * capture shipped) or malformed, so callers fall back to the live session
+ * state rather than showing nothing.
+ */
+export declare function readAgentHostCustomizationsSnapshot(fileService: IFileService, uri: URI): Promise<Customization[] | undefined>;
+/**
+ * Captures each session's loaded customizations (skills/hooks/agents/MCP) to a
+ * stable client-local snapshot so the debug view can surface them even for
+ * historical/closed sessions. This is necessary because the live
+ * {@link IAgentHostCustomizationService} only knows the customizations of
+ * sessions with an active state subscription, and the SDK's `session.*_loaded`
+ * events are ephemeral (never written to `events.jsonl`).
+ *
+ * Listens for the full-replacement `SessionCustomizationsChanged` action — the
+ * canonical way a host publishes its effective customization set — on the
+ * `<provider>:/<rawId>` session channel, and overwrites the session's snapshot.
+ * The raw id derived from the channel matches the one the reader derives from
+ * the client session resource (both are the URI path), so the snapshot lines up
+ * with the session it belongs to.
+ */
+export declare class AgentHostCustomizationRecorder extends AgentHostActionRecorder {
+    protected _sidecarUri(rawSessionId: string): URI;
+    protected _onAction(envelope: ActionEnvelope): void;
+    /** Overwrites the session's snapshot, serializing writes per session. */
+    private _write;
+}
+export {};

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

@@ -0,0 +1,218 @@
+
+import { VSBuffer } from '../../../../../base/common/buffer.js';
+import { Disposable, DisposableMap, DisposableStore } from '../../../../../base/common/lifecycle.js';
+import { joinPath } from '../../../../../base/common/resources.js';
+import { URI } from '../../../../../base/common/uri.js';
+import { toErrorMessage } from '../../../../../base/common/errorMessage.js';
+import { agentHostAuthority } from '../../../../../platform/agentHost/common/agentHostUri.js';
+import { NotificationType } from '../../../../../platform/agentHost/common/state/sessionActions.js';
+import { isDefaultChatUri, readUsageInfoMeta, parseChatUri } from '../../../../../platform/agentHost/common/state/sessionState.js';
+import { getCopilotCliSessionRawId } from '../copilotCliEventsUri.js';
+import { ActionType } from '../../../../../platform/agentHost/common/state/protocol/common/actions.js';
+
+const USAGE_DIR = "agentHostUsage";
+function buildAgentHostUsageUri(baseDir, rawSessionId) {
+    return joinPath(baseDir, USAGE_DIR, `${sanitizeSessionId(rawSessionId)}.jsonl`);
+}
+function sanitizeSessionId(rawSessionId) {
+    return rawSessionId.replace(/[^\w.-]/g, "_");
+}
+async function readAgentHostUsageRecords(fileService, uri) {
+    let text;
+    try {
+        const content = await fileService.readFile(uri);
+        text = ( content.value.toString());
+    } catch {
+        return [];
+    }
+    const records = [];
+    for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed && typeof parsed.turnId === "string" && typeof parsed.ts === "string") {
+                records.push(parsed);
+            }
+        } catch {}
+    }
+    return records;
+}
+class AgentHostActionRecorder extends Disposable {
+    constructor(
+        _baseDir,
+        _isEnabled,
+        _fileService,
+        _logService,
+        agentHostService,
+        _remoteAgentHostService
+    ) {
+        super();
+        this._baseDir = _baseDir;
+        this._isEnabled = _isEnabled;
+        this._fileService = _fileService;
+        this._logService = _logService;
+        this._remoteAgentHostService = _remoteAgentHostService;
+        this._remoteListeners = this._register(( new DisposableMap()));
+        this._queues = ( new Map());
+        this._remoteConnections = ( new Map());
+        this._register(agentHostService.onDidAction(envelope => this._dispatch(envelope)));
+        this._register(
+            agentHostService.onDidNotification(notification => this._onNotification(notification))
+        );
+        this._register(
+            this._remoteAgentHostService.onDidChangeConnections(() => this._syncRemoteListeners())
+        );
+        this._syncRemoteListeners();
+    }
+    _dispatch(envelope) {
+        if (!this._isEnabled()) {
+            return;
+        }
+        this._onAction(envelope);
+    }
+    _onNotification(notification) {
+        if (notification.type !== NotificationType.SessionRemoved) {
+            return;
+        }
+        const rawId = getCopilotCliSessionRawId(( URI.parse(notification.session)));
+        if (!rawId) {
+            return;
+        }
+        const uri = this._sidecarUri(rawId);
+        const pending = this.queued(rawId, () => this._fileService.del(uri));
+        void pending.finally(() => {
+            if (this._queues.get(rawId) === pending) {
+                this._queues.delete(rawId);
+            }
+        });
+    }
+    queued(rawSessionId, operation) {
+        const previous = this._queues.get(rawSessionId) ?? Promise.resolve();
+        const next = previous.then(operation).then(() => undefined).catch(err => {
+            this._logService.trace(
+                `[${this.constructor.name}] sidecar operation failed for ${rawSessionId}: ${toErrorMessage(err)}`
+            );
+        });
+        this._queues.set(rawSessionId, next);
+        return next;
+    }
+    _syncRemoteListeners() {
+        const seen = ( new Set());
+        for (const info of this._remoteAgentHostService.connections) {
+            const authority = agentHostAuthority(info.address);
+            seen.add(authority);
+            const connection = this._remoteAgentHostService.getConnectionByAuthority(authority);
+            if (!connection) {
+                continue;
+            }
+            if (this._remoteConnections.get(authority) === connection) {
+                continue;
+            }
+            this._remoteConnections.set(authority, connection);
+            const store = ( new DisposableStore());
+            store.add(connection.onDidAction(envelope => this._dispatch(envelope)));
+            store.add(
+                connection.onDidNotification(notification => this._onNotification(notification))
+            );
+            this._remoteListeners.set(authority, store);
+        }
+        for (const authority of [...( this._remoteListeners.keys())]) {
+            if (!( seen.has(authority))) {
+                this._remoteListeners.deleteAndDispose(authority);
+                this._remoteConnections.delete(authority);
+            }
+        }
+    }
+}
+class AgentHostUsageRecorder extends AgentHostActionRecorder {
+    _sidecarUri(rawSessionId) {
+        return buildAgentHostUsageUri(this._baseDir, rawSessionId);
+    }
+    _onAction(envelope) {
+        const action = envelope.action;
+        if (action.type !== ActionType.ChatUsage) {
+            return;
+        }
+        if (!isDefaultChatUri(envelope.channel)) {
+            return;
+        }
+        const usage = action.usage;
+        const meta = readUsageInfoMeta(usage);
+        if (meta.contextAttribution) {
+            return;
+        }
+        const session = parseChatUri(envelope.channel)?.session;
+        if (!session) {
+            return;
+        }
+        const rawId = getCopilotCliSessionRawId(( URI.parse(session)));
+        if (!rawId) {
+            return;
+        }
+        const record = {
+            turnId: action.turnId,
+            model: usage.model,
+            inputTokens: usage.inputTokens,
+            outputTokens: usage.outputTokens,
+            cacheReadTokens: usage.cacheReadTokens,
+            totalNanoAiu: meta.copilotUsage?.totalNanoAiu,
+            ts: ( new Date()).toISOString()
+        };
+        this._append(rawId, record);
+    }
+    _append(rawId, record) {
+        const uri = this._sidecarUri(rawId);
+        const line = JSON.stringify(record) + "\n";
+        void this.queued(rawId, () => this._fileService.writeFile(uri, VSBuffer.fromString(line), {
+            append: true
+        }));
+    }
+}
+const CUSTOMIZATIONS_DIR = "agentHostCustomizations";
+function buildAgentHostCustomizationsUri(baseDir, rawSessionId) {
+    return joinPath(baseDir, CUSTOMIZATIONS_DIR, `${sanitizeSessionId(rawSessionId)}.json`);
+}
+async function readAgentHostCustomizationsSnapshot(fileService, uri) {
+    let text;
+    try {
+        const content = await fileService.readFile(uri);
+        text = ( content.value.toString());
+    } catch {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(text);
+        if (Array.isArray(parsed)) {
+            return parsed;
+        }
+    } catch {}
+    return undefined;
+}
+class AgentHostCustomizationRecorder extends AgentHostActionRecorder {
+    _sidecarUri(rawSessionId) {
+        return buildAgentHostCustomizationsUri(this._baseDir, rawSessionId);
+    }
+    _onAction(envelope) {
+        if (envelope.action.type !== ActionType.SessionCustomizationsChanged) {
+            return;
+        }
+        const rawId = getCopilotCliSessionRawId(( URI.parse(envelope.channel)));
+        if (!rawId) {
+            return;
+        }
+        this._write(rawId, envelope.action.customizations);
+    }
+    _write(rawId, customizations) {
+        const uri = this._sidecarUri(rawId);
+        const content = JSON.stringify(customizations);
+        void this.queued(
+            rawId,
+            () => this._fileService.writeFile(uri, VSBuffer.fromString(content))
+        );
+    }
+}
+
+export { AgentHostCustomizationRecorder, AgentHostUsageRecorder, buildAgentHostCustomizationsUri, buildAgentHostUsageUri, readAgentHostCustomizationsSnapshot, readAgentHostUsageRecords };

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingActions.js

@@ -82,7 +82,7 @@ registerAction2(class OpenFileInDiffAction extends WorkingSetAction {
     constructor() {
         super({
             id: "chatEditing.openFileInDiff",
-            title: ( localize2(10158, "Open Changes in Diff Editor")),
+            title: ( localize2(10277, "Open Changes in Diff Editor")),
             icon: Codicon.diffSingle,
             menu: [{
                 id: MenuId.ChatEditingWidgetModifiedFilesToolbar,
@@ -110,7 +110,7 @@ registerAction2(class AcceptAction extends WorkingSetAction {
     constructor() {
         super({
             id: "chatEditing.acceptFile",
-            title: ( localize2(10159, "Keep")),
+            title: ( localize2(10278, "Keep")),
             icon: Codicon.check,
             menu: [{
                 when: ( ContextKeyExpr.and(( ContextKeyExpr.equals("resourceScheme", CHAT_EDITING_MULTI_DIFF_SOURCE_RESOLVER_SCHEME)), ContextKeyExpr.notIn(
@@ -136,7 +136,7 @@ registerAction2(class DiscardAction extends WorkingSetAction {
     constructor() {
         super({
             id: "chatEditing.discardFile",
-            title: ( localize2(10160, "Undo")),
+            title: ( localize2(10279, "Undo")),
             icon: Codicon.discard,
             menu: [{
                 when: ( ContextKeyExpr.and(( ContextKeyExpr.equals("resourceScheme", CHAT_EDITING_MULTI_DIFF_SOURCE_RESOLVER_SCHEME)), ContextKeyExpr.notIn(
@@ -162,9 +162,9 @@ class ChatEditingAcceptAllAction extends EditingSessionAction {
     constructor() {
         super({
             id: "chatEditing.acceptAllFiles",
-            title: ( localize(10161, "Keep")),
+            title: ( localize(10280, "Keep")),
             icon: Codicon.check,
-            tooltip: ( localize(10162, "Keep All Edits")),
+            tooltip: ( localize(10281, "Keep All Edits")),
             precondition: hasUndecidedChatEditingResourceContextKey,
             keybinding: {
                 primary: KeyMod$1.CtrlCmd | KeyCode.Enter,
@@ -188,9 +188,9 @@ class ChatEditingDiscardAllAction extends EditingSessionAction {
     constructor() {
         super({
             id: "chatEditing.discardAllFiles",
-            title: ( localize(10163, "Undo")),
+            title: ( localize(10282, "Undo")),
             icon: Codicon.discard,
-            tooltip: ( localize(10164, "Undo All Edits")),
+            tooltip: ( localize(10283, "Undo All Edits")),
             precondition: hasUndecidedChatEditingResourceContextKey,
             menu: [{
                 id: MenuId.ChatEditingWidgetToolbar,
@@ -221,8 +221,8 @@ class ToggleExplanationWidgetAction extends EditingSessionAction {
     constructor() {
         super({
             id: ToggleExplanationWidgetAction.ID,
-            title: ( localize(10165, "Explain")),
-            tooltip: ( localize(10166, "Toggle Change Explanations")),
+            title: ( localize(10284, "Explain")),
+            tooltip: ( localize(10285, "Toggle Change Explanations")),
             precondition: hasUndecidedChatEditingResourceContextKey,
             menu: [{
                 id: MenuId.ChatEditingWidgetToolbar,
@@ -246,17 +246,17 @@ async function discardAllEditsWithConfirmation(accessor, currentEditingSession)
     const entries = currentEditingSession.entries.get().filter(e => e.state.get() === ModifiedFileEntryState.Modified);
     if (entries.length > 0) {
         const confirmation = await dialogService.confirm({
-            title: ( localize(10167, "Undo all edits?")),
+            title: ( localize(10286, "Undo all edits?")),
             message: entries.length === 1 ? ( localize(
-                10168,
+                10287,
                 "This will undo changes made in {0}. Do you want to proceed?",
                 basename(entries[0].modifiedURI)
             )) : ( localize(
-                10169,
+                10288,
                 "This will undo changes made in {0} files. Do you want to proceed?",
                 entries.length
             )),
-            primaryButton: ( localize(10170, "Yes")),
+            primaryButton: ( localize(10289, "Yes")),
             type: "info"
         });
         if (!confirmation.confirmed) {
@@ -271,7 +271,7 @@ class ChatEditingShowChangesAction extends EditingSessionAction {
         this.ID = "chatEditing.viewChanges";
     }
     static {
-        this.LABEL = ( localize(10171, "View All Edits"));
+        this.LABEL = ( localize(10290, "View All Edits"));
     }
     constructor() {
         super({
@@ -345,13 +345,13 @@ async function restoreSnapshotWithConfirmationByRequestId(accessor, sessionResou
     if (editsToUndo === 1) {
         if (entriesModifiedInRequestsToRemove.length === 1) {
             message = ( localize(
-                10172,
+                10291,
                 "This will remove your last request and undo the edits made to {0}. Do you want to proceed?",
                 basename(entriesModifiedInRequestsToRemove[0].modifiedURI)
             ));
         } else {
             message = ( localize(
-                10173,
+                10292,
                 "This will remove your last request and undo edits made to {0} files in your working set. Do you want to proceed?",
                 entriesModifiedInRequestsToRemove.length
             ));
@@ -359,24 +359,24 @@ async function restoreSnapshotWithConfirmationByRequestId(accessor, sessionResou
     } else {
         if (entriesModifiedInRequestsToRemove.length === 1) {
             message = ( localize(
-                10174,
+                10293,
                 "This will remove all subsequent requests and undo edits made to {0}. Do you want to proceed?",
                 basename(entriesModifiedInRequestsToRemove[0].modifiedURI)
             ));
         } else {
             message = ( localize(
-                10175,
+                10294,
                 "This will remove all subsequent requests and undo edits made to {0} files in your working set. Do you want to proceed?",
                 entriesModifiedInRequestsToRemove.length
             ));
         }
     }
     const confirmation = shouldPrompt ? await dialogService.confirm({
-        title: editsToUndo === 1 ? ( localize(10176, "Do you want to undo your last edit?")) : ( localize(10177, "Do you want to undo {0} edits?", editsToUndo)),
+        title: editsToUndo === 1 ? ( localize(10295, "Do you want to undo your last edit?")) : ( localize(10296, "Do you want to undo {0} edits?", editsToUndo)),
         message: message,
-        primaryButton: ( localize(10178, "Yes")),
+        primaryButton: ( localize(10297, "Yes")),
         checkbox: {
-            label: ( localize(10179, "Don't ask again")),
+            label: ( localize(10298, "Don't ask again")),
             checked: false
         },
         type: "info"
@@ -406,7 +406,7 @@ registerAction2(class RemoveAction extends Action2 {
     constructor() {
         super({
             id: "workbench.action.chat.undoEdits",
-            title: ( localize2(10180, "Undo Requests")),
+            title: ( localize2(10299, "Undo Requests")),
             f1: false,
             category: CHAT_CATEGORY,
             icon: Codicon.discard,
@@ -453,8 +453,8 @@ registerAction2(class RestoreCheckpointAction extends Action2 {
     constructor() {
         super({
             id: RestoreCheckpointActionId,
-            title: ( localize2(10181, "Restore Checkpoint")),
-            tooltip: ( localize2(10182, "Restores workspace and chat to this point")),
+            title: ( localize2(10300, "Restore Checkpoint")),
+            tooltip: ( localize2(10301, "Restores workspace and chat to this point")),
             f1: false,
             category: CHAT_CATEGORY,
             keybinding: {
@@ -499,8 +499,8 @@ registerAction2(class StartOverAction extends Action2 {
     constructor() {
         super({
             id: StartOverActionId,
-            title: ( localize2(10183, "Start Over")),
-            tooltip: ( localize2(10184, "Clears the chat and undoes all changes")),
+            title: ( localize2(10302, "Start Over")),
+            tooltip: ( localize2(10303, "Clears the chat and undoes all changes")),
             f1: false,
             category: CHAT_CATEGORY,
             menu: [{
@@ -536,7 +536,7 @@ registerAction2(class RestoreLastCheckpoint extends Action2 {
     constructor() {
         super({
             id: "workbench.action.chat.restoreLastCheckpoint",
-            title: ( localize2(10185, "Restore to Last Checkpoint")),
+            title: ( localize2(10304, "Restore to Last Checkpoint")),
             f1: true,
             category: CHAT_CATEGORY,
             icon: Codicon.discard,
@@ -561,7 +561,7 @@ registerAction2(class RestoreLastCheckpoint extends Action2 {
         }
         const checkpointRequest = chatModel.checkpoint;
         if (!checkpointRequest) {
-            alert(( localize(10186, "There is no checkpoint to restore.")));
+            alert(( localize(10305, "There is no checkpoint to restore.")));
             return;
         }
         widget?.viewModel?.model.setCheckpoint(checkpointRequest.id);
@@ -574,7 +574,7 @@ registerAction2(class EditAction extends Action2 {
     constructor() {
         super({
             id: "workbench.action.chat.editRequests",
-            title: ( localize2(10187, "Edit Request")),
+            title: ( localize2(10306, "Edit Request")),
             f1: false,
             category: CHAT_CATEGORY,
             icon: Codicon.edit,
@@ -613,7 +613,7 @@ registerAction2(class OpenWorkingSetHistoryAction extends Action2 {
     constructor() {
         super({
             id: OpenWorkingSetHistoryAction.id,
-            title: ( localize(10188, "Open File")),
+            title: ( localize(10307, "Open File")),
             menu: [{
                 id: MenuId.ChatEditingCodeBlockContext,
                 group: "navigation",
@@ -639,7 +639,7 @@ registerAction2(class OpenWorkingSetHistoryAction extends Action2 {
     constructor() {
         super({
             id: OpenWorkingSetHistoryAction.id,
-            title: ( localize(10189, "Open File Snapshot")),
+            title: ( localize(10308, "Open File Snapshot")),
             menu: [{
                 id: MenuId.ChatEditingCodeBlockContext,
                 group: "navigation",
@@ -663,7 +663,7 @@ registerAction2(class OpenWorkingSetHistoryAction extends Action2 {
         if (snapshot) {
             const editor = await editorService.openEditor({
                 resource: snapshot,
-                label: ( localize(10190, "{0} (Snapshot)", basename(context.uri))),
+                label: ( localize(10309, "{0} (Snapshot)", basename(context.uri))),
                 options: {
                     activation: EditorActivation.ACTIVATE
                 }
@@ -680,7 +680,7 @@ registerAction2(class ResolveSymbolsContextAction extends EditingSessionAction {
     constructor() {
         super({
             id: "workbench.action.edits.addFilesFromReferences",
-            title: ( localize2(10191, "Add Files From References")),
+            title: ( localize2(10310, "Add Files From References")),
             f1: false,
             category: CHAT_CATEGORY,
             menu: {
@@ -748,7 +748,7 @@ class ViewPreviousEditsAction extends EditingSessionAction {
         this.Id = "chatEditing.viewPreviousEdits";
     }
     static {
-        this.Label = ( localize(10192, "View Previous Edits"));
+        this.Label = ( localize(10311, "View Previous Edits"));
     }
     constructor() {
         super({

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingEditorContextKeys.js

@@ -17,16 +17,16 @@ import { autorun } from '../../../../../base/common/observableInternal/reactions
 import { derived } from '../../../../../base/common/observableInternal/observables/derived.js';
 import { constObservable } from '../../../../../base/common/observableInternal/observables/constObservable.js';
 
-const ctxIsGlobalEditingSession = new RawContextKey("chatEdits.isGlobalEditingSession", undefined, ( localize(10215, "The current editor is part of the global edit session")));
-const ctxHasEditorModification = new RawContextKey("chatEdits.hasEditorModifications", undefined, ( localize(10216, "The current editor contains chat modifications")));
-const ctxIsCurrentlyBeingModified = new RawContextKey("chatEdits.isCurrentlyBeingModified", undefined, ( localize(10217, "The current editor is currently being modified")));
-const ctxReviewModeEnabled = new RawContextKey("chatEdits.isReviewModeEnabled", true, ( localize(10218, "Review mode for chat changes is enabled")));
+const ctxIsGlobalEditingSession = new RawContextKey("chatEdits.isGlobalEditingSession", undefined, ( localize(10334, "The current editor is part of the global edit session")));
+const ctxHasEditorModification = new RawContextKey("chatEdits.hasEditorModifications", undefined, ( localize(10335, "The current editor contains chat modifications")));
+const ctxIsCurrentlyBeingModified = new RawContextKey("chatEdits.isCurrentlyBeingModified", undefined, ( localize(10336, "The current editor is currently being modified")));
+const ctxReviewModeEnabled = new RawContextKey("chatEdits.isReviewModeEnabled", true, ( localize(10337, "Review mode for chat changes is enabled")));
 const ctxHasRequestInProgress = new RawContextKey("chatEdits.isRequestInProgress", false, ( localize(
-    10219,
+    10338,
     "The current editor shows a file from an edit session which is still in progress"
 )));
-const ctxRequestCount = new RawContextKey("chatEdits.requestCount", 0, ( localize(10220, "The number of turns the editing session in this editor has")));
-const ctxCursorInChangeRange = new RawContextKey("chatEdits.cursorInChangeRange", false, ( localize(10221, "The cursor is inside a change range made by chat editing.")));
+const ctxRequestCount = new RawContextKey("chatEdits.requestCount", 0, ( localize(10339, "The number of turns the editing session in this editor has")));
+const ctxCursorInChangeRange = new RawContextKey("chatEdits.cursorInChangeRange", false, ( localize(10340, "The cursor is inside a change range made by chat editing.")));
 let ChatEditingEditorContextKeys = class ChatEditingEditorContextKeys {
     static {
         this.ID = "chat.edits.editorContextKeys";