@codingame/monaco-vscode-chat-service-override 27.0.0 → 28.0.1

package/vscode/src/vs/sessions/contrib/fileTreeView/browser/githubFileSystemProvider.js

@@ -0,0 +1,263 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { FileSystemProviderCapabilities, createFileSystemProviderError, FileSystemProviderErrorCode, FileType } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+import { asJson } from '@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request';
+import { IRequestService } from '@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request.service';
+import { IAuthenticationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/authentication.service';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+
+var GitHubFileSystemProvider_1;
+const GITHUB_REMOTE_FILE_SCHEME = "github-remote-file";
+let GitHubFileSystemProvider = class GitHubFileSystemProvider extends Disposable {
+    static {
+        GitHubFileSystemProvider_1 = this;
+    }
+    static {
+        this.CACHE_TTL_MS = 5 * 60 * 1000;
+    }
+    static {
+        this.NOT_FOUND_CACHE_TTL_MS = 60 * 1000;
+    }
+    constructor(requestService, authenticationService, logService) {
+        super();
+        this.requestService = requestService;
+        this.authenticationService = authenticationService;
+        this.logService = logService;
+        this._onDidChangeCapabilities = this._register(( new Emitter()));
+        this.onDidChangeCapabilities = this._onDidChangeCapabilities.event;
+        this.capabilities = FileSystemProviderCapabilities.Readonly | FileSystemProviderCapabilities.FileReadWrite | FileSystemProviderCapabilities.PathCaseSensitive;
+        this._onDidChangeFile = this._register(( new Emitter()));
+        this.onDidChangeFile = this._onDidChangeFile.event;
+        this.treeCache = ( new Map());
+        this.notFoundCache = ( new Map());
+        this.pendingFetches = ( new Map());
+    }
+    parseUri(resource) {
+        const parts = resource.path.split("/").filter(Boolean);
+        if (parts.length < 3) {
+            throw createFileSystemProviderError(
+                "Invalid github-remote-file URI: expected /{owner}/{repo}/{ref}/...",
+                FileSystemProviderErrorCode.FileNotFound
+            );
+        }
+        const owner = decodeURIComponent(parts[0]);
+        const repo = decodeURIComponent(parts[1]);
+        const ref = decodeURIComponent(parts[2]);
+        const path = ( parts.slice(3).map(decodeURIComponent)).join("/");
+        return {
+            owner,
+            repo,
+            ref,
+            path
+        };
+    }
+    getCacheKey(owner, repo, ref) {
+        return `${owner}/${repo}/${ref}`;
+    }
+    async getAuthToken() {
+        const sessions = (await this.authenticationService.getSessions("github", ["repo"], {
+            silent: true
+        })) ?? (await this.authenticationService.getSessions("github", ["repo"], {
+            createIfNone: true
+        }));
+        return sessions[0].accessToken ?? "";
+    }
+    fetchTree(owner, repo, ref) {
+        const cacheKey = this.getCacheKey(owner, repo, ref);
+        const cached = this.treeCache.get(cacheKey);
+        if (cached && (Date.now() - cached.fetchedAt) < GitHubFileSystemProvider_1.CACHE_TTL_MS) {
+            return Promise.resolve(cached);
+        }
+        const notFoundAt = this.notFoundCache.get(cacheKey);
+        if (notFoundAt !== undefined && (Date.now() - notFoundAt) < GitHubFileSystemProvider_1.NOT_FOUND_CACHE_TTL_MS) {
+            return Promise.reject(createFileSystemProviderError(
+                `Tree not found for ${owner}/${repo}@${ref}`,
+                FileSystemProviderErrorCode.FileNotFound
+            ));
+        }
+        const pending = this.pendingFetches.get(cacheKey);
+        if (pending) {
+            return pending;
+        }
+        const promise = this.doFetchTree(owner, repo, ref, cacheKey).finally(() => {
+            this.pendingFetches.delete(cacheKey);
+        });
+        this.pendingFetches.set(cacheKey, promise);
+        return promise;
+    }
+    async doFetchTree(owner, repo, ref, cacheKey) {
+        this.logService.info(`[SessionRepoFS] Fetching tree for ${owner}/${repo}@${ref}`);
+        const token = await this.getAuthToken();
+        const url = `https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/git/trees/${encodeURIComponent(ref)}?recursive=1`;
+        const response = await this.requestService.request({
+            type: "GET",
+            url,
+            headers: {
+                "Authorization": `token ${token}`,
+                "Accept": "application/vnd.github.v3+json",
+                "User-Agent": "VSCode-SessionRepoFS"
+            }
+        }, CancellationToken.None);
+        if (response.res.statusCode === 404) {
+            this.notFoundCache.set(cacheKey, Date.now());
+            throw createFileSystemProviderError(
+                `Tree not found for ${owner}/${repo}@${ref}`,
+                FileSystemProviderErrorCode.FileNotFound
+            );
+        }
+        const data = await asJson(response);
+        if (!data) {
+            throw createFileSystemProviderError(
+                `Failed to fetch tree for ${owner}/${repo}@${ref}`,
+                FileSystemProviderErrorCode.Unavailable
+            );
+        }
+        const entries = ( new Map());
+        entries.set("", {
+            type: FileType.Directory,
+            size: 0,
+            sha: data.sha
+        });
+        const dirs = ( new Set());
+        for (const entry of data.tree) {
+            const fileType = entry.type === "tree" ? FileType.Directory : FileType.File;
+            entries.set(entry.path, {
+                type: fileType,
+                size: entry.size ?? 0,
+                sha: entry.sha
+            });
+            if (fileType === FileType.Directory) {
+                dirs.add(entry.path);
+            }
+            const pathParts = entry.path.split("/");
+            for (let i = 1; i < pathParts.length; i++) {
+                const parentPath = pathParts.slice(0, i).join("/");
+                if (!( dirs.has(parentPath))) {
+                    dirs.add(parentPath);
+                    if (!( entries.has(parentPath))) {
+                        entries.set(parentPath, {
+                            type: FileType.Directory,
+                            size: 0,
+                            sha: ""
+                        });
+                    }
+                }
+            }
+        }
+        const cacheEntry = {
+            entries,
+            fetchedAt: Date.now()
+        };
+        this.treeCache.set(cacheKey, cacheEntry);
+        return cacheEntry;
+    }
+    async stat(resource) {
+        const {
+            owner,
+            repo,
+            ref,
+            path
+        } = this.parseUri(resource);
+        const tree = await this.fetchTree(owner, repo, ref);
+        const entry = tree.entries.get(path);
+        if (!entry) {
+            throw createFileSystemProviderError("File not found", FileSystemProviderErrorCode.FileNotFound);
+        }
+        return {
+            type: entry.type,
+            ctime: 0,
+            mtime: 0,
+            size: entry.size
+        };
+    }
+    async readdir(resource) {
+        const {
+            owner,
+            repo,
+            ref,
+            path
+        } = this.parseUri(resource);
+        const tree = await this.fetchTree(owner, repo, ref);
+        const prefix = path ? path + "/" : "";
+        const result = [];
+        for (const [entryPath, entry] of tree.entries) {
+            if (!entryPath.startsWith(prefix)) {
+                continue;
+            }
+            const relativePath = entryPath.slice(prefix.length);
+            if (relativePath && !relativePath.includes("/")) {
+                result.push([relativePath, entry.type]);
+            }
+        }
+        return result;
+    }
+    async readFile(resource) {
+        const {
+            owner,
+            repo,
+            ref,
+            path
+        } = this.parseUri(resource);
+        const tree = await this.fetchTree(owner, repo, ref);
+        const entry = tree.entries.get(path);
+        if (!entry || entry.type === FileType.Directory) {
+            throw createFileSystemProviderError("File not found", FileSystemProviderErrorCode.FileNotFound);
+        }
+        const token = await this.getAuthToken();
+        const url = `https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/git/blobs/${encodeURIComponent(entry.sha)}`;
+        const response = await this.requestService.request({
+            type: "GET",
+            url,
+            headers: {
+                "Authorization": `token ${token}`,
+                "Accept": "application/vnd.github.v3+json",
+                "User-Agent": "VSCode-SessionRepoFS"
+            }
+        }, CancellationToken.None);
+        const data = await asJson(response);
+        if (!data) {
+            throw createFileSystemProviderError(`Failed to read file ${path}`, FileSystemProviderErrorCode.Unavailable);
+        }
+        if (data.encoding === "base64") {
+            const binaryString = atob(data.content.replace(/\n/g, ""));
+            const bytes = ( new Uint8Array(binaryString.length));
+            for (let i = 0; i < binaryString.length; i++) {
+                bytes[i] = binaryString.charCodeAt(i);
+            }
+            return bytes;
+        }
+        return ( new TextEncoder()).encode(data.content);
+    }
+    watch() {
+        return Disposable.None;
+    }
+    async writeFile(_resource, _content, _opts) {
+        throw createFileSystemProviderError("Operation not supported", FileSystemProviderErrorCode.NoPermissions);
+    }
+    async mkdir(_resource) {
+        throw createFileSystemProviderError("Operation not supported", FileSystemProviderErrorCode.NoPermissions);
+    }
+    async delete(_resource, _opts) {
+        throw createFileSystemProviderError("Operation not supported", FileSystemProviderErrorCode.NoPermissions);
+    }
+    async rename(_from, _to, _opts) {
+        throw createFileSystemProviderError("Operation not supported", FileSystemProviderErrorCode.NoPermissions);
+    }
+    invalidateCache(owner, repo, ref) {
+        const cacheKey = this.getCacheKey(owner, repo, ref);
+        this.treeCache.delete(cacheKey);
+        this.notFoundCache.delete(cacheKey);
+    }
+    dispose() {
+        this.treeCache.clear();
+        this.notFoundCache.clear();
+        this.pendingFetches.clear();
+        super.dispose();
+    }
+};
+GitHubFileSystemProvider = GitHubFileSystemProvider_1 = ( __decorate([( __param(0, IRequestService)), ( __param(1, IAuthenticationService)), ( __param(2, ILogService))], GitHubFileSystemProvider));
+
+export { GITHUB_REMOTE_FILE_SCHEME, GitHubFileSystemProvider };

package/vscode/src/vs/sessions/contrib/sessions/browser/sessionsManagementService.d.ts

@@ -18,6 +18,11 @@ import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/plat
 import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
 import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/sessionsManagementService.service";
 export declare const IsNewChatSessionContext: RawContextKey<boolean>;
+/**
+ * True when the active session uses the Background provider type (copilotcli).
+ * Used to gate actions that require a local worktree (run script, open in VS Code, terminal).
+ */
+export declare const IsActiveSessionBackgroundProviderContext: RawContextKey<boolean>;
 /**
  * An active session item extends IChatSessionItem with repository information.
  * - For agent session items: repository is the workingDirectory from metadata
@@ -49,6 +54,7 @@ export declare class SessionsManagementService extends Disposable implements ISe
     private readonly _newSession;
     private lastSelectedSession;
     private readonly isNewChatSessionContext;
+    private readonly _isBackgroundProvider;
     constructor(storageService: IStorageService, uriIdentityService: IUriIdentityService, agentSessionsService: IAgentSessionsService, chatSessionsService: IChatSessionsService, chatWidgetService: IChatWidgetService, chatService: IChatService, instantiationService: IInstantiationService, logService: ILogService, contextKeyService: IContextKeyService, commandService: ICommandService, languageModelsService: ILanguageModelsService);
     private refreshActiveSessionFromModel;
     private showNextSession;

package/vscode/src/vs/sessions/contrib/sessions/browser/sessionsManagementService.js

@@ -4,6 +4,7 @@ import { Disposable, DisposableStore, MutableDisposable } from '@codingame/monac
 import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { RawContextKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
 import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
@@ -23,9 +24,11 @@ import { AgentSessionProviders } from '@codingame/monaco-vscode-api/vscode/vs/wo
 import { LocalNewSession, RemoteNewSession } from '../../chat/browser/newSession.js';
 import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
 import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
+import { GITHUB_REMOTE_FILE_SCHEME } from '../../fileTreeView/browser/githubFileSystemProvider.js';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
 
 const IsNewChatSessionContext = ( new RawContextKey("isNewChatSession", true));
+const IsActiveSessionBackgroundProviderContext = ( new RawContextKey("isActiveSessionBackgroundProvider", false, ( localize(2519, "Whether the active session uses the background agent provider"))));
 const LAST_SELECTED_SESSION_KEY = "agentSessions.lastSelectedSession";
 const repositoryOptionId = "repository";
 let SessionsManagementService = class SessionsManagementService extends Disposable {
@@ -58,6 +61,7 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
         this._newActiveSessionDisposables = this._register(( new DisposableStore()));
         this._newSession = this._register(( new MutableDisposable()));
         this.isNewChatSessionContext = IsNewChatSessionContext.bindTo(contextKeyService);
+        this._isBackgroundProvider = IsActiveSessionBackgroundProviderContext.bindTo(contextKeyService);
         this.lastSelectedSession = this.loadLastSelectedSession();
         this._register(this.storageService.onWillSaveState(() => this.saveLastSelectedSession()));
         this._register(
@@ -104,10 +108,24 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
             this.openNewSessionView();
         }
     }
-    getRepositoryFromMetadata(metadata) {
+    getRepositoryFromMetadata(session) {
+        const metadata = session.metadata;
         if (!metadata) {
             return [undefined, undefined];
         }
+        if (session.providerType === AgentSessionProviders.Cloud) {
+            const branch = typeof metadata.branch === "string" ? metadata.branch : "HEAD";
+            const repositoryUri = ( URI.from({
+                scheme: GITHUB_REMOTE_FILE_SCHEME,
+                authority: "github",
+                path: `/${metadata.owner}/${metadata.name}/${encodeURIComponent(branch)}`
+            }));
+            return [repositoryUri, undefined];
+        }
+        const workingDirectoryPath = metadata?.workingDirectoryPath;
+        if (workingDirectoryPath) {
+            return [URI.file(workingDirectoryPath), undefined];
+        }
         const repositoryPath = metadata?.repositoryPath;
         const repositoryPathUri = typeof repositoryPath === "string" ? URI.file(repositoryPath) : undefined;
         const worktreePath = metadata?.worktreePath;
@@ -149,7 +167,7 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
             this.isNewChatSessionContext.set(true);
         }
         let newSession;
-        if (target === AgentSessionProviders.Background || target === AgentSessionProviders.Local) {
+        if (target === AgentSessionProviders.Background) {
             newSession = this.instantiationService.createInstance(LocalNewSession, sessionResource, defaultRepoUri);
         } else {
             newSession = this.instantiationService.createInstance(RemoteNewSession, sessionResource, target);
@@ -277,15 +295,15 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
         if (this.isNewChatSessionContext.get()) {
             return;
         }
-        this.isNewChatSessionContext.set(true);
         this.setActiveSession(undefined);
+        this.isNewChatSessionContext.set(true);
     }
     setActiveSession(session) {
         let activeSessionItem;
         if (session) {
             if (isAgentSession(session)) {
                 this.lastSelectedSession = session.resource;
-                const [repository, worktree] = this.getRepositoryFromMetadata(session.metadata);
+                const [repository, worktree] = this.getRepositoryFromMetadata(session);
                 activeSessionItem = {
                     isUntitled: this.chatService.getSession(session.resource)?.contributedChatSession?.isUntitled ?? true,
                     label: session.label,
@@ -332,6 +350,7 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
         } else {
             this.logService.trace("[ActiveSessionService] Active session cleared");
         }
+        this._isBackgroundProvider.set(activeSessionItem?.providerType === AgentSessionProviders.Background);
         this._activeSession.set(activeSessionItem, undefined);
     }
     equalsSessionItem(a, b) {
@@ -341,7 +360,7 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
         if (!a || !b) {
             return false;
         }
-        return (a.label === b.label && ( a.resource.toString()) === ( b.resource.toString()) && a.repository?.toString() === b.repository?.toString() && a.worktree?.toString() === b.worktree?.toString());
+        return (a.label === b.label && ( a.resource.toString()) === ( b.resource.toString()) && a.repository?.toString() === b.repository?.toString() && a.worktree?.toString() === b.worktree?.toString() && a.providerType === b.providerType);
     }
     async commitWorktreeFiles(session, fileUris) {
         const worktreeUri = session.worktree;
@@ -375,4 +394,4 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
 };
 SessionsManagementService = ( __decorate([( __param(0, IStorageService)), ( __param(1, IUriIdentityService)), ( __param(2, IAgentSessionsService)), ( __param(3, IChatSessionsService)), ( __param(4, IChatWidgetService)), ( __param(5, IChatService)), ( __param(6, IInstantiationService)), ( __param(7, ILogService)), ( __param(8, IContextKeyService)), ( __param(9, ICommandService)), ( __param(10, ILanguageModelsService))], SessionsManagementService));
 
-export { IsNewChatSessionContext, SessionsManagementService };
+export { IsActiveSessionBackgroundProviderContext, IsNewChatSessionContext, SessionsManagementService };

package/vscode/src/vs/workbench/contrib/chat/browser/accessibility/chatAccessibilityService.js

@@ -117,7 +117,7 @@ let ChatAccessibilityService = class ChatAccessibilityService extends Disposable
             });
         }
         this.toasts.clearAndDisposeAll();
-        const title = widget?.viewModel?.model.title ? ( localize(4685, "Chat: {0}", widget.viewModel.model.title)) : ( localize(4686, "Untitled Chat"));
+        const title = widget?.viewModel?.model.title ? ( localize(4690, "Chat: {0}", widget.viewModel.model.title)) : ( localize(4691, "Untitled Chat"));
         const cts = ( new CancellationTokenSource());
         const disposable = toDisposable(() => cts.dispose(true));
         this.toasts.add(disposable);
@@ -125,7 +125,7 @@ let ChatAccessibilityService = class ChatAccessibilityService extends Disposable
             clicked
         } = await this._hostService.showToast({
             title,
-            body: ( localize(4687, "New chat response."))
+            body: ( localize(4692, "New chat response."))
         }, cts.token);
         this.toasts.deleteAndDispose(disposable);
         if (clicked) {

package/vscode/src/vs/workbench/contrib/chat/browser/accessibility/chatResponseAccessibleView.js

@@ -76,29 +76,29 @@ function getToolSpecificDataDescription(toolSpecificData) {
         {
             const parts = [];
             if (toolSpecificData.agentName) {
-                parts.push(( localize(4688, "Agent: {0}", toolSpecificData.agentName)));
+                parts.push(( localize(4693, "Agent: {0}", toolSpecificData.agentName)));
             }
             if (toolSpecificData.description) {
                 parts.push(toolSpecificData.description);
             }
             if (toolSpecificData.prompt) {
-                parts.push(( localize(4689, "Task: {0}", toolSpecificData.prompt)));
+                parts.push(( localize(4694, "Task: {0}", toolSpecificData.prompt)));
             }
             return parts.join(". ") || "";
         }
     case "extensions":
-        return toolSpecificData.extensions.length > 0 ? ( localize(4690, "Extensions: {0}", toolSpecificData.extensions.join(", "))) : "";
+        return toolSpecificData.extensions.length > 0 ? ( localize(4695, "Extensions: {0}", toolSpecificData.extensions.join(", "))) : "";
     case "todoList":
         {
             const todos = toolSpecificData.todoList;
             if (todos.length === 0) {
                 return "";
             }
-            const todoDescriptions = ( todos.map(t => ( localize(4691, "{0} ({1})", t.title, t.status))));
-            return localize(4692, "{0} items: {1}", todos.length, todoDescriptions.join("; "));
+            const todoDescriptions = ( todos.map(t => ( localize(4696, "{0} ({1})", t.title, t.status))));
+            return localize(4697, "{0} items: {1}", todos.length, todoDescriptions.join("; "));
         }
     case "pullRequest":
-        return localize(4693, "PR: {0} by {1}", toolSpecificData.title, toolSpecificData.author);
+        return localize(4698, "PR: {0} by {1}", toolSpecificData.title, toolSpecificData.author);
     case "input":
         return typeof toolSpecificData.rawInput === "string" ? toolSpecificData.rawInput : JSON.stringify(toolSpecificData.rawInput);
     case "resources":
@@ -114,13 +114,13 @@ function getToolSpecificDataDescription(toolSpecificData) {
                     return v.fsPath || v.path;
                 }
             })).join(", ");
-            return localize(4694, "Resources: {0}", paths);
+            return localize(4699, "Resources: {0}", paths);
         }
     case "simpleToolInvocation":
         {
             const inputText = toolSpecificData.input;
             const outputText = toolSpecificData.output;
-            return localize(4695, "Input: {0}, Output: {1}", inputText, outputText);
+            return localize(4700, "Input: {0}, Output: {1}", inputText, outputText);
         }
     default:
         return "";
@@ -149,12 +149,12 @@ function getResultDetailsDescription(resultDetails) {
     }
     if (isOutputDetailsSerialized(resultDetails)) {
         return {
-            input: ( localize(4696, "{0} data", resultDetails.output.mimeType))
+            input: ( localize(4701, "{0} data", resultDetails.output.mimeType))
         };
     }
     if (isToolResultOutputDetails(resultDetails)) {
         return {
-            input: ( localize(4696, "{0} data", resultDetails.output.mimeType))
+            input: ( localize(4701, "{0} data", resultDetails.output.mimeType))
         };
     }
     return {};
@@ -178,13 +178,13 @@ function getToolInvocationA11yDescription(
     if (isComplete && resultDetails) {
         const details = getResultDetailsDescription(resultDetails);
         if (details.isError) {
-            parts.unshift(( localize(4697, "Errored")));
+            parts.unshift(( localize(4702, "Errored")));
         }
         if (details.input && !toolDataDesc) {
-            parts.push(( localize(4698, "Input: {0}", details.input)));
+            parts.push(( localize(4703, "Input: {0}", details.input)));
         }
         if (details.files && details.files.length > 0) {
-            parts.push(( localize(4699, "Files: {0}", details.files.join(", "))));
+            parts.push(( localize(4704, "Files: {0}", details.files.join(", "))));
         }
     }
     return parts.join(". ");
@@ -246,7 +246,7 @@ class ChatResponseAccessibleProvider extends Disposable {
                     const thinkingValue = Array.isArray(part.value) ? part.value.join("") : (part.value || "");
                     const trimmed = thinkingValue.trim();
                     if (trimmed) {
-                        contentParts.push(( localize(4700, "Thinking: {0}", trimmed)));
+                        contentParts.push(( localize(4705, "Thinking: {0}", trimmed)));
                     }
                     break;
                 }
@@ -303,7 +303,7 @@ class ChatResponseAccessibleProvider extends Disposable {
                         contentParts.push(toolContent);
                     } else if (state.type === IChatToolInvocation.StateKind.WaitingForPostApproval) {
                         const postApprovalDetails = isToolResultInputOutputDetails(state.resultDetails) ? state.resultDetails.input : isToolResultOutputDetails(state.resultDetails) ? undefined : toolContentToA11yString(state.contentForModel);
-                        contentParts.push(( localize(4701, "Approve results of {0}? Result: ", part.toolId)) + (postApprovalDetails ?? ""));
+                        contentParts.push(( localize(4706, "Approve results of {0}? Result: ", part.toolId)) + (postApprovalDetails ?? ""));
                     } else {
                         const resultDetails = IChatToolInvocation.resultDetails(part);
                         const isComplete = IChatToolInvocation.isComplete(part);

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatAccessibilityActions.js

@@ -22,11 +22,11 @@ class AnnounceChatConfirmationAction extends Action2 {
         super({
             id: ACTION_ID_FOCUS_CHAT_CONFIRMATION,
             title: {
-                value: ( localize(4702, "Focus Chat Confirmation")),
+                value: ( localize(4707, "Focus Chat Confirmation")),
                 original: "Focus Chat Confirmation"
             },
             category: {
-                value: ( localize(4703, "Chat")),
+                value: ( localize(4708, "Chat")),
                 original: "Chat"
             },
             precondition: ChatContextKeys.enabled,
@@ -42,12 +42,12 @@ class AnnounceChatConfirmationAction extends Action2 {
         const chatWidgetService = accessor.get(IChatWidgetService);
         const pendingWidget = chatWidgetService.getAllWidgets().find(widget => widget.viewModel?.model.requestNeedsInput.get());
         if (!pendingWidget) {
-            alert(( localize(4704, "No active chat session found.")));
+            alert(( localize(4709, "No active chat session found.")));
             return;
         }
         const viewModel = pendingWidget.viewModel;
         if (!viewModel) {
-            alert(( localize(4705, "Chat interface not ready.")));
+            alert(( localize(4710, "Chat interface not ready.")));
             return;
         }
         let firstConfirmationElement;
@@ -65,7 +65,7 @@ class AnnounceChatConfirmationAction extends Action2 {
                 firstConfirmationElement.focus();
             }
         } else {
-            alert(( localize(4706, "No chat confirmation required")));
+            alert(( localize(4711, "No chat confirmation required")));
         }
     }
 }
@@ -74,11 +74,11 @@ class ToggleThinkingContentAccessibleViewAction extends Action2 {
         super({
             id: ACTION_ID_TOGGLE_THINKING_CONTENT_ACCESSIBLE_VIEW,
             title: {
-                value: ( localize(4707, "Toggle Thinking Content in Accessible View")),
+                value: ( localize(4712, "Toggle Thinking Content in Accessible View")),
                 original: "Toggle Thinking Content in Accessible View"
             },
             category: {
-                value: ( localize(4703, "Chat")),
+                value: ( localize(4708, "Chat")),
                 original: "Chat"
             },
             precondition: ChatContextKeys.enabled,
@@ -100,7 +100,7 @@ class ToggleThinkingContentAccessibleViewAction extends Action2 {
             StorageScope.PROFILE,
             StorageTarget.USER
         );
-        alert(updatedValue ? ( localize(4708, "Thinking content will be included in the accessible view.")) : ( localize(4709, "Thinking content will be hidden from the accessible view.")));
+        alert(updatedValue ? ( localize(4713, "Thinking content will be included in the accessible view.")) : ( localize(4714, "Thinking content will be hidden from the accessible view.")));
     }
 }
 function registerChatAccessibilityActions() {