@codingame/monaco-vscode-katex-common 30.0.0 → 31.0.0

package/vscode/src/vs/workbench/contrib/chat/common/chatArtifactExtraction.js

@@ -0,0 +1,218 @@
+
+import { match } from '@codingame/monaco-vscode-api/vscode/vs/base/common/glob';
+import { getExtensionForMimeType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/mime';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import { basename as basename$1 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { IChatToolInvocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
+import { ChatResponseResource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel';
+import { isToolResultInputOutputDetails } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+
+const CHAT_MEMORY_FILE_SCHEME = "chat-memory-file";
+const MEMORY_TOOL_ID = "copilot_memory";
+var ChatMemoryFileResource;
+(function(ChatMemoryFileResource) {
+    function createUri(memoryPath, sessionResource) {
+        return ( URI.from({
+            scheme: CHAT_MEMORY_FILE_SCHEME,
+            path: memoryPath,
+            query: ( sessionResource.toString())
+        }));
+    }
+    ChatMemoryFileResource.createUri = createUri;
+    function isChatMemoryFileUri(uri) {
+        return uri.scheme === CHAT_MEMORY_FILE_SCHEME;
+    }
+    ChatMemoryFileResource.isChatMemoryFileUri = isChatMemoryFileUri;
+    function parse(uri) {
+        return {
+            memoryPath: uri.path,
+            sessionResource: uri.query
+        };
+    }
+    ChatMemoryFileResource.parse = parse;
+})(ChatMemoryFileResource || (ChatMemoryFileResource = {}));
+function matchMimeType(pattern, mimeType) {
+    if (pattern === mimeType) {
+        return true;
+    }
+    const [patternType, patternSubtype] = pattern.split("/");
+    const [type] = mimeType.split("/");
+    return patternSubtype === "*" && patternType === type;
+}
+function findFilePathRule(filePath, byFilePath) {
+    const fileBasename = basename(filePath);
+    for (const [pattern, config] of Object.entries(byFilePath)) {
+        if (match(pattern, filePath) || match(pattern, fileBasename)) {
+            return config;
+        }
+    }
+    return undefined;
+}
+function findMimeTypeRule(mimeType, byMimeType) {
+    for (const [pattern, config] of Object.entries(byMimeType)) {
+        if (matchMimeType(pattern, mimeType)) {
+            return config;
+        }
+    }
+    return undefined;
+}
+function isToolResultOutputDetailsSerialized(obj) {
+    return typeof obj === "object" && obj !== null && "output" in obj && typeof obj.output === "object" && obj.output?.type === "data" && typeof obj.output?.mimeType === "string";
+}
+function getMemoryPathFromParams(params) {
+    if (typeof params !== "object" || params === null) {
+        return undefined;
+    }
+    const path = params["path"];
+    return typeof path === "string" ? path : undefined;
+}
+const memoryWriteCommands = ( new Set(["create", "str_replace", "insert"]));
+function isMemoryWriteCommand(params) {
+    if (typeof params !== "object" || params === null) {
+        return false;
+    }
+    const command = params["command"];
+    return typeof command === "string" && ( memoryWriteCommands.has(command));
+}
+function extractArtifactsFromResponse(response, sessionResource, byMimeType, byFilePath, byMemoryFilePath = {}) {
+    const artifacts = [];
+    const seenUris = ( new Set());
+    for (const part of response.value) {
+        if (part.kind === "codeblockUri") {
+            const uri = part.uri;
+            const uriStr = ( uri.toString());
+            if (( seenUris.has(uriStr))) {
+                continue;
+            }
+            const rule = findFilePathRule(uri.path, byFilePath);
+            if (rule) {
+                seenUris.add(uriStr);
+                artifacts.push({
+                    label: basename$1(uri),
+                    uri: uriStr,
+                    type: "plan",
+                    groupName: rule.groupName,
+                    onlyShowGroup: rule.onlyShowGroup
+                });
+            }
+        }
+        if (part.kind === "textEditGroup") {
+            const uri = part.uri;
+            const uriStr = ( uri.toString());
+            if (( seenUris.has(uriStr))) {
+                continue;
+            }
+            const rule = findFilePathRule(uri.path, byFilePath);
+            if (rule) {
+                seenUris.add(uriStr);
+                artifacts.push({
+                    label: basename$1(uri),
+                    uri: uriStr,
+                    type: "plan",
+                    groupName: rule.groupName,
+                    onlyShowGroup: rule.onlyShowGroup
+                });
+            }
+        }
+        if (part.kind === "workspaceEdit") {
+            for (const edit of part.edits) {
+                const uri = edit.newResource ?? edit.oldResource;
+                if (!uri) {
+                    continue;
+                }
+                const uriStr = ( uri.toString());
+                if (( seenUris.has(uriStr))) {
+                    continue;
+                }
+                const rule = findFilePathRule(uri.path, byFilePath);
+                if (rule) {
+                    seenUris.add(uriStr);
+                    artifacts.push({
+                        label: basename$1(uri),
+                        uri: uriStr,
+                        type: "plan",
+                        groupName: rule.groupName,
+                        onlyShowGroup: rule.onlyShowGroup
+                    });
+                }
+            }
+        }
+        if ((part.kind === "toolInvocation" || part.kind === "toolInvocationSerialized") && part.toolId === MEMORY_TOOL_ID) {
+            const params = IChatToolInvocation.getParameters(part);
+            const memoryPath = getMemoryPathFromParams(params);
+            if (memoryPath && isMemoryWriteCommand(params)) {
+                const rule = findFilePathRule(memoryPath, byMemoryFilePath);
+                if (rule) {
+                    const key = `memory:${part.toolCallId}:${memoryPath}`;
+                    if (!( seenUris.has(key))) {
+                        seenUris.add(key);
+                        artifacts.push({
+                            label: basename(memoryPath),
+                            uri: ( ChatMemoryFileResource.createUri(memoryPath, sessionResource).toString()),
+                            type: "plan",
+                            groupName: rule.groupName,
+                            onlyShowGroup: rule.onlyShowGroup
+                        });
+                    }
+                }
+            }
+        }
+        if (part.kind === "toolInvocation" || part.kind === "toolInvocationSerialized") {
+            const details = IChatToolInvocation.resultDetails(part);
+            if (!details) {
+                continue;
+            }
+            if (isToolResultInputOutputDetails(details)) {
+                for (let i = 0; i < details.output.length; i++) {
+                    const outputPart = details.output[i];
+                    if (outputPart.type === "embed" && !outputPart.isText && outputPart.mimeType) {
+                        const rule = findMimeTypeRule(outputPart.mimeType, byMimeType);
+                        if (rule) {
+                            const key = `${part.toolCallId}:${i}`;
+                            if (!( seenUris.has(key))) {
+                                seenUris.add(key);
+                                const ext = getExtensionForMimeType(outputPart.mimeType);
+                                const permalinkBasename = ext ? `file${ext}` : "file.bin";
+                                const artifactUri = ChatResponseResource.createUri(sessionResource, part.toolCallId, i, permalinkBasename);
+                                artifacts.push({
+                                    label: outputPart.uri?.path.split("/").pop() ?? `${rule.groupName} ${i + 1}`,
+                                    uri: ( artifactUri.toString()),
+                                    toolCallId: part.toolCallId,
+                                    dataPartIndex: i,
+                                    type: "screenshot",
+                                    groupName: rule.groupName,
+                                    onlyShowGroup: rule.onlyShowGroup
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            if (isToolResultOutputDetailsSerialized(details)) {
+                const rule = findMimeTypeRule(details.output.mimeType, byMimeType);
+                if (rule) {
+                    const key = `${part.toolCallId}:0`;
+                    if (!( seenUris.has(key))) {
+                        seenUris.add(key);
+                        const ext = getExtensionForMimeType(details.output.mimeType);
+                        const permalinkBasename = ext ? `file${ext}` : "file.bin";
+                        const artifactUri = ChatResponseResource.createUri(sessionResource, part.toolCallId, 0, permalinkBasename);
+                        artifacts.push({
+                            label: `${rule.groupName}`,
+                            uri: ( artifactUri.toString()),
+                            toolCallId: part.toolCallId,
+                            dataPartIndex: 0,
+                            type: "screenshot",
+                            groupName: rule.groupName,
+                            onlyShowGroup: rule.onlyShowGroup
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return artifacts;
+}
+
+export { ChatMemoryFileResource, extractArtifactsFromResponse };

package/vscode/src/vs/workbench/contrib/chat/common/chatImageExtraction.js

@@ -26,7 +26,7 @@ async function extractImagesFromChatResponse(response, readFile) {
         }
     }
     const request = response.session.getItems().find(item => isRequestVM(item) && item.id === response.requestId);
-    const title = request ? request.messageText : ( localize(7249, "Images"));
+    const title = request ? request.messageText : ( localize(7371, "Images"));
     return {
         id: ( response.sessionResource.toString()) + "_" + response.id,
         title,
@@ -45,10 +45,10 @@ function extractImagesFromToolInvocationOutputDetails(toolInvocation, sessionRes
         images.push({
             id: `${toolInvocation.toolCallId}_${outputIndex}`,
             uri,
-            name: ( localize(7250, "Image {0}", images.length + 1)),
+            name: ( localize(7372, "Image {0}", images.length + 1)),
             mimeType,
             data,
-            source: ( localize(7251, "Tool: {0}", toolInvocation.toolId)),
+            source: ( localize(7373, "Tool: {0}", toolInvocation.toolId)),
             caption
         });
     };
@@ -93,7 +93,7 @@ async function extractImagesFromToolInvocationMessages(toolInvocation, readFile)
                 name,
                 mimeType,
                 data,
-                source: ( localize(7251, "Tool: {0}", toolInvocation.toolId)),
+                source: ( localize(7373, "Tool: {0}", toolInvocation.toolId)),
                 caption: message.value
             });
         }
@@ -131,7 +131,7 @@ async function extractImageFromInlineReference(part, readFile) {
         name,
         mimeType: mime,
         data,
-        source: ( localize(7252, "File")),
+        source: ( localize(7374, "File")),
         caption: undefined
     };
 }
@@ -152,7 +152,7 @@ function extractImagesFromChatRequest(request) {
         const uri = variable.references?.[0]?.reference;
         const imageUri = URI.isUri(uri) ? uri : ( URI.from({
             scheme: "data",
-            path: variable.name
+            path: `${variable.id}/${encodeURIComponent(variable.name)}`
         }));
         images.push({
             id: ( imageUri.toString()),
@@ -160,7 +160,7 @@ function extractImagesFromChatRequest(request) {
             name: variable.name,
             mimeType,
             data: VSBuffer.wrap(buffer),
-            source: ( localize(7253, "Attachment")),
+            source: ( localize(7375, "Attachment")),
             caption: undefined
         });
     }

package/vscode/src/vs/workbench/contrib/chat/common/widget/annotations.js

@@ -190,7 +190,12 @@ function extractCodeblockUrisFromText(text) {
     if (match) {
         const [all, isEdit,, encodedSubAgentId, uriString] = match;
         if (uriString) {
-            const result = ( URI.parse(uriString));
+            let result;
+            try {
+                result = ( URI.parse(uriString));
+            } catch {
+                return undefined;
+            }
             const textWithoutResult = text.substring(0, match.index) + text.substring(match.index + all.length);
             let subAgentInvocationId;
             if (encodedSubAgentId) {

package/vscode/src/vs/workbench/contrib/chat/common/widget/chatColors.js

@@ -18,45 +18,45 @@ registerColor("agentStatusIndicator.background", {
     light: ( Color.black.transparent(0.05)),
     hcDark: null,
     hcLight: null
-}, ( localize(7698, "Background color of the agent status indicator in the titlebar.")));
+}, ( localize(7817, "Background color of the agent status indicator in the titlebar.")));
 registerColor("chat.requestBorder", {
     dark: ( new Color(( new RGBA(255, 255, 255, 0.10)))),
     light: ( new Color(( new RGBA(0, 0, 0, 0.10)))),
     hcDark: contrastBorder,
     hcLight: contrastBorder
-}, ( localize(7699, "The border color of a chat request.")));
+}, ( localize(7818, "The border color of a chat request.")));
 const chatRequestBackground = registerColor("chat.requestBackground", {
     dark: ( transparent(editorBackground, 0.62)),
     light: ( transparent(editorBackground, 0.62)),
     hcDark: editorWidgetBackground,
     hcLight: null
-}, ( localize(7700, "The background color of a chat request.")));
+}, ( localize(7819, "The background color of a chat request.")));
 const chatSlashCommandBackground = registerColor("chat.slashCommandBackground", {
     dark: "#26477866",
     light: "#adceff7a",
     hcDark: Color.white,
     hcLight: badgeBackground
-}, ( localize(7701, "The background color of a chat slash command.")));
+}, ( localize(7820, "The background color of a chat slash command.")));
 const chatSlashCommandForeground = registerColor("chat.slashCommandForeground", {
     dark: "#85b6ff",
     light: "#26569e",
     hcDark: Color.black,
     hcLight: badgeForeground
-}, ( localize(7702, "The foreground color of a chat slash command.")));
+}, ( localize(7821, "The foreground color of a chat slash command.")));
 registerColor("chat.avatarBackground", {
     dark: "#1f1f1f",
     light: "#f2f2f2",
     hcDark: Color.black,
     hcLight: Color.white
-}, ( localize(7703, "The background color of a chat avatar.")));
-registerColor("chat.avatarForeground", foreground, ( localize(7704, "The foreground color of a chat avatar.")));
+}, ( localize(7822, "The background color of a chat avatar.")));
+registerColor("chat.avatarForeground", foreground, ( localize(7823, "The foreground color of a chat avatar.")));
 registerColor("chat.editedFileForeground", {
     light: "#895503",
     dark: "#E2C08D",
     hcDark: "#E2C08D",
     hcLight: "#895503"
 }, ( localize(
-    7705,
+    7824,
     "The foreground color of a chat edited file in the edited file list."
 )));
 registerColor("chat.requestCodeBorder", {
@@ -64,42 +64,42 @@ registerColor("chat.requestCodeBorder", {
     light: "#0e639c40",
     hcDark: null,
     hcLight: null
-}, ( localize(7706, "Border color of code blocks within the chat request bubble.")), true);
+}, ( localize(7825, "Border color of code blocks within the chat request bubble.")), true);
 registerColor("chat.requestBubbleBackground", {
     light: ( transparent(editorSelectionBackground, 0.3)),
     dark: ( transparent(editorSelectionBackground, 0.3)),
     hcDark: null,
     hcLight: null
-}, ( localize(7707, "Background color of the chat request bubble.")), true);
+}, ( localize(7826, "Background color of the chat request bubble.")), true);
 registerColor("chat.requestBubbleHoverBackground", {
     dark: ( transparent(editorSelectionBackground, 0.6)),
     light: ( transparent(editorSelectionBackground, 0.6)),
     hcDark: null,
     hcLight: null
-}, ( localize(7708, "Background color of the chat request bubble on hover.")), true);
+}, ( localize(7827, "Background color of the chat request bubble on hover.")), true);
 registerColor("chat.checkpointSeparator", {
     dark: "#585858",
     light: "#a9a9a9",
     hcDark: "#a9a9a9",
     hcLight: "#a5a5a5"
-}, ( localize(7709, "Chat checkpoint separator color.")));
+}, ( localize(7828, "Chat checkpoint separator color.")));
 registerColor("chat.linesAddedForeground", {
     dark: "#54B054",
     light: "#107C10",
     hcDark: "#54B054",
     hcLight: "#107C10"
-}, ( localize(7710, "Foreground color of lines added in chat code block pill.")), true);
+}, ( localize(7829, "Foreground color of lines added in chat code block pill.")), true);
 registerColor("chat.linesRemovedForeground", {
     dark: "#FC6A6A",
     light: "#BC2F32",
     hcDark: "#F48771",
     hcLight: "#B5200D"
-}, ( localize(7711, "Foreground color of lines removed in chat code block pill.")), true);
+}, ( localize(7830, "Foreground color of lines removed in chat code block pill.")), true);
 registerColor("chat.thinkingShimmer", {
     dark: "#ffffff",
     light: "#000000",
     hcDark: "#ffffff",
     hcLight: "#000000"
-}, ( localize(7712, "Shimmer highlight for thinking/working labels.")), true);
+}, ( localize(7831, "Shimmer highlight for thinking/working labels.")), true);
 
 export { chatRequestBackground, chatSlashCommandBackground, chatSlashCommandForeground };

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatAffordance.js

@@ -10,7 +10,6 @@ import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/pl
 import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
 import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
 import { InlineChatEditorAffordance } from './inlineChatEditorAffordance.js';
-import { InlineChatGutterAffordance } from './inlineChatGutterAffordance.js';
 import { SelectionDirection } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/selection';
 import { assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { CursorChangeReason } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/cursorEvents';
@@ -18,7 +17,6 @@ import { IInlineChatSessionService } from '@codingame/monaco-vscode-api/vscode/v
 import { CodeActionController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/codeAction/browser/codeActionController';
 import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
 import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
-import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
 import { debouncedObservable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/utils';
@@ -73,7 +71,7 @@ let InlineChatAffordance = class InlineChatAffordance extends Disposable {
             }
             affordanceId = generateUuid();
             const mode = affordance.read(undefined);
-            if (mode === "gutter" || mode === "editor") {
+            if (mode === "editor") {
                 telemetryService.publicLog2("inlineChatAffordance/shown", {
                     mode,
                     id: affordanceId,
@@ -108,33 +106,26 @@ let InlineChatAffordance = class InlineChatAffordance extends Disposable {
         this._store.add(autorun(r => {
             const sel = selectionData.read(r);
             const mode = affordance.read(r);
-            ctxAffordanceVisible.set(sel !== undefined && (mode === "editor" || mode === "gutter"));
+            ctxAffordanceVisible.set(sel !== undefined && mode === "editor");
         }));
-        const gutterAffordance = this._store.add(this.#instantiationService.createInstance(
-            InlineChatGutterAffordance,
-            editorObs,
-            derived(r => affordance.read(r) === "gutter" ? selectionData.read(r) : undefined)
-        ));
         const editorAffordance = this.#instantiationService.createInstance(
             InlineChatEditorAffordance,
             this.#editor,
             derived(r => affordance.read(r) === "editor" ? selectionData.read(r) : undefined)
         );
         this._store.add(editorAffordance);
-        this._store.add(
-            Event.any(editorAffordance.onDidRunAction, gutterAffordance.onDidRunAction)(commandId => {
-                if (affordanceId) {
-                    telemetryService.publicLog2("inlineChatAffordance/selected", {
-                        mode: affordance.get(),
-                        id: affordanceId,
-                        commandId
-                    });
-                }
-            })
-        );
+        this._store.add(editorAffordance.onDidRunAction(commandId => {
+            if (affordanceId) {
+                telemetryService.publicLog2("inlineChatAffordance/selected", {
+                    mode: affordance.get(),
+                    id: affordanceId,
+                    commandId
+                });
+            }
+        }));
         this._store.add(autorun(r => {
             const mode = affordance.read(r);
-            const hideWithSelection = mode === "editor" || mode === "gutter";
+            const hideWithSelection = mode === "editor";
             const controller = CodeActionController.get(this.#editor);
             if (controller) {
                 controller.onlyLightBulbWithEmptySelection = hideWithSelection;

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatController.d.ts

@@ -41,38 +41,14 @@ export declare abstract class InlineChatRunOptions {
     static isInlineChatRunOptions(options: unknown): options is InlineChatRunOptions;
 }
 export declare class InlineChatController implements IEditorContribution {
-    private readonly _editor;
-    private readonly _instaService;
-    private readonly _notebookEditorService;
-    private readonly _inlineChatSessionService;
-    private readonly _configurationService;
-    private readonly _webContentExtractorService;
-    private readonly _fileService;
-    private readonly _chatAttachmentResolveService;
-    private readonly _editorService;
-    private readonly _markerDecorationsService;
-    private readonly _languageModelService;
-    private readonly _logService;
-    private readonly _chatEditingService;
-    private readonly _chatService;
+    #private;
     static readonly ID = "editor.contrib.inlineChatController";
     static get(editor: ICodeEditor): InlineChatController | undefined;
-    /**
-     * Stores the user's explicitly chosen model (qualified name) from a previous inline chat request in the same session.
-     * When set, this takes priority over the inlineChat.defaultModel setting.
-     */
-    private static _userSelectedModel;
-    private readonly _store;
-    private readonly _isActiveController;
-    private readonly _renderMode;
-    private readonly _zone;
     readonly inputOverlayWidget: InlineChatAffordance;
-    private readonly _inputWidget;
-    private readonly _currentSession;
     get widget(): EditorBasedInlineChatWidget;
     get isActive(): boolean;
     get inputWidget(): InlineChatInputWidget;
-    constructor(_editor: ICodeEditor, _instaService: IInstantiationService, _notebookEditorService: INotebookEditorService, _inlineChatSessionService: IInlineChatSessionService, codeEditorService: ICodeEditorService, contextKeyService: IContextKeyService, _configurationService: IConfigurationService, _webContentExtractorService: ISharedWebContentExtractorService, _fileService: IFileService, _chatAttachmentResolveService: IChatAttachmentResolveService, _editorService: IEditorService, _markerDecorationsService: IMarkerDecorationsService, _languageModelService: ILanguageModelsService, _logService: ILogService, _chatEditingService: IChatEditingService, _chatService: IChatService);
+    constructor(editor: ICodeEditor, instaService: IInstantiationService, notebookEditorService: INotebookEditorService, inlineChatSessionService: IInlineChatSessionService, codeEditorService: ICodeEditorService, contextKeyService: IContextKeyService, configurationService: IConfigurationService, webContentExtractorService: ISharedWebContentExtractorService, fileService: IFileService, chatAttachmentResolveService: IChatAttachmentResolveService, editorService: IEditorService, markerDecorationsService: IMarkerDecorationsService, languageModelService: ILanguageModelsService, logService: ILogService, chatEditingService: IChatEditingService, chatService: IChatService);
     dispose(): void;
     getWidgetPosition(): Position | undefined;
     focus(): void;
@@ -81,12 +57,6 @@ export declare class InlineChatController implements IEditorContribution {
     rejectSession(): Promise<void>;
     continueSessionInChat(): Promise<void>;
     rephraseSession(): Promise<void>;
-    private _selectVendorDefaultModel;
-    /**
-     * Applies model defaults based on settings and tracks user model changes.
-     * Prioritization: user session choice > inlineChat.defaultModel setting > vendor default
-     */
-    private _applyModelDefaults;
     createImageAttachment(attachment: URI): Promise<IChatRequestVariableEntry | undefined>;
 }
 export declare function reviewEdits(accessor: ServicesAccessor, editor: ICodeEditor, stream: AsyncIterable<TextEdit[]>, token: CancellationToken, applyCodeBlockSuggestionId: EditSuggestionId | undefined): Promise<boolean>;