@codingame/monaco-vscode-extensions-service-override 25.1.2 → 26.0.1

package/vscode/src/vs/workbench/api/browser/mainThreadChatAgents2.js

@@ -1,6 +1,7 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { Disposable, DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { revive } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshalling';
@@ -19,12 +20,13 @@ import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/plat
 import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
 import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents.service';
 import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
-import { IChatEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService.service';
+import { isValidPromptType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
 import { ChatRequestAgentPart } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatParserTypes';
 import { ChatRequestParser } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatRequestParser';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
 import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
 import { ChatModeKind, ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
@@ -32,10 +34,12 @@ import { NotebookDto } from './mainThreadNotebookDto.js';
 import { addDynamicVariableActionId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/editor/chatDynamicVariablesConstant';
 
 class MainThreadChatTask {
-    get onDidAddProgress() { return this._onDidAddProgress.event; }
+    get onDidAddProgress() {
+        return this._onDidAddProgress.event;
+    }
     constructor(content) {
         this.content = content;
-        this.kind = 'progressTask';
+        this.kind = "progressTask";
         this.deferred = ( new DeferredPromise());
         this._onDidAddProgress = ( new Emitter());
         this.progress = [];
@@ -55,19 +59,31 @@ class MainThreadChatTask {
     }
     toJSON() {
         return {
-            kind: 'progressTaskSerialized',
+            kind: "progressTaskSerialized",
             content: this.content,
             progress: this.progress
         };
     }
 }
 let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
-    constructor(extHostContext, _chatAgentService, _chatSessionService, _chatService, _chatEditingService, _languageFeaturesService, _chatWidgetService, _instantiationService, _logService, _extensionService, _uriIdentityService, _promptsService) {
+    constructor(
+        extHostContext,
+        _chatAgentService,
+        _chatSessionService,
+        _chatService,
+        _languageFeaturesService,
+        _chatWidgetService,
+        _instantiationService,
+        _logService,
+        _extensionService,
+        _uriIdentityService,
+        _promptsService,
+        _languageModelToolsService
+    ) {
         super();
         this._chatAgentService = _chatAgentService;
         this._chatSessionService = _chatSessionService;
         this._chatService = _chatService;
-        this._chatEditingService = _chatEditingService;
         this._languageFeaturesService = _languageFeaturesService;
         this._chatWidgetService = _chatWidgetService;
         this._instantiationService = _instantiationService;
@@ -75,13 +91,14 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
         this._extensionService = _extensionService;
         this._uriIdentityService = _uriIdentityService;
         this._promptsService = _promptsService;
+        this._languageModelToolsService = _languageModelToolsService;
         this._agents = this._register(( new DisposableMap()));
         this._agentCompletionProviders = this._register(( new DisposableMap()));
         this._agentIdsToCompletionProviders = this._register(( new DisposableMap()));
         this._chatParticipantDetectionProviders = this._register(( new DisposableMap()));
-        this._chatRelatedFilesProviders = this._register(( new DisposableMap()));
-        this._customAgentsProviders = this._register(( new DisposableMap()));
-        this._customAgentsProviderEmitters = this._register(( new DisposableMap()));
+        this._promptFileProviders = this._register(( new DisposableMap()));
+        this._promptFileProviderEmitters = this._register(( new DisposableMap()));
+        this._promptFileContentRegistrations = this._register(( new DisposableMap()));
         this._pendingProgress = ( new Map());
         this._activeTasks = ( new Map());
         this._unresolvedAnchors = ( new Map());
@@ -92,13 +109,12 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
             }
         }));
         this._register(this._chatService.onDidPerformUserAction(e => {
-            if (typeof e.agentId === 'string') {
+            if (typeof e.agentId === "string") {
                 for (const [handle, agent] of this._agents) {
                     if (agent.id === e.agentId) {
-                        if (e.action.kind === 'vote') {
+                        if (e.action.kind === "vote") {
                             this._proxy.$acceptFeedback(handle, e.result ?? {}, e.action);
-                        }
-                        else {
+                        } else {
                             this._proxy.$acceptAction(handle, e.result || {}, e);
                         }
                         break;
@@ -106,6 +122,9 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                 }
             }
         }));
+        this._register(this._chatService.onDidReceiveQuestionCarouselAnswer(e => {
+            this._proxy.$handleQuestionCarouselAnswer(e.requestId, e.resolveId, e.answers);
+        }));
     }
     $unregisterAgent(handle) {
         this._agents.deleteAndDispose(handle);
@@ -134,14 +153,16 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
         const impl = {
             invoke: async (request, progress, history, token) => {
                 const chatSession = this._chatService.getSession(request.sessionResource);
-                this._pendingProgress.set(request.requestId, { progress, chatSession });
+                this._pendingProgress.set(request.requestId, {
+                    progress,
+                    chatSession
+                });
                 try {
                     return (await this._proxy.$invokeAgent(handle, request, {
                         history,
                         chatSessionContext: chatSession?.contributedChatSession
                     }, token)) ?? {};
-                }
-                finally {
+                } finally {
                     this._pendingProgress.delete(request.requestId);
                 }
             },
@@ -152,14 +173,16 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                 if (!this._agents.get(handle)?.hasFollowups) {
                     return [];
                 }
-                return this._proxy.$provideFollowups(request, handle, result, { history }, token);
+                return this._proxy.$provideFollowups(request, handle, result, {
+                    history
+                }, token);
             },
             provideChatTitle: (history, token) => {
                 return this._proxy.$provideChatTitle(handle, history, token);
             },
             provideChatSummary: (history, token) => {
                 return this._proxy.$provideChatSummary(handle, history, token);
-            },
+            }
         };
         if (chatSessionRegistration?.alternativeIds?.includes(id)) {
             return;
@@ -174,17 +197,16 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                 extensionId: extension,
                 extensionVersion: extensionDescription?.version,
                 extensionDisplayName: extensionDescription?.displayName ?? extension.value,
-                extensionPublisherId: extensionDescription?.publisher ?? '',
+                extensionPublisherId: extensionDescription?.publisher ?? "",
                 publisherDisplayName: dynamicProps.publisherName,
                 fullName: dynamicProps.fullName,
                 metadata: revive(metadata),
                 slashCommands: [],
                 disambiguation: [],
                 locations: [ChatAgentLocation.Chat],
-                modes: [ChatModeKind.Ask, ChatModeKind.Agent, ChatModeKind.Edit],
+                modes: [ChatModeKind.Ask, ChatModeKind.Agent, ChatModeKind.Edit]
             }, impl);
-        }
-        else {
+        } else {
             disposable = this._chatAgentService.registerAgentImplementation(id, impl);
         }
         this._agents.set(handle, {
@@ -198,7 +220,9 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
         await this._extensionService.whenInstalledExtensionsRegistered();
         const data = this._agents.get(handle);
         if (!data) {
-            this._logService.error(`MainThreadChatAgents2#$updateAgent: No agent with handle ${handle} registered`);
+            this._logService.error(
+                `MainThreadChatAgents2#$updateAgent: No agent with handle ${handle} registered`
+            );
             return;
         }
         data.hasFollowups = metadataUpdate.hasFollowups;
@@ -207,61 +231,81 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
     async $handleProgressChunk(requestId, chunks) {
         const pendingProgress = this._pendingProgress.get(requestId);
         if (!pendingProgress) {
-            this._logService.warn(`MainThreadChatAgents2#$handleProgressChunk: No pending progress for requestId ${requestId}`);
+            this._logService.warn(
+                `MainThreadChatAgents2#$handleProgressChunk: No pending progress for requestId ${requestId}`
+            );
             return;
         }
-        const { progress, chatSession } = pendingProgress;
+        const {
+            progress,
+            chatSession
+        } = pendingProgress;
         const chatProgressParts = [];
         for (const item of chunks) {
             const [progress, responsePartHandle] = Array.isArray(item) ? item : [item];
-            if (progress.kind === 'externalEdits') {
+            if (progress.kind === "externalEdits") {
                 const response = chatSession?.getRequests().at(-1)?.response;
                 if (chatSession?.editingSession && responsePartHandle !== undefined && response) {
-                    const parts = progress.start
-                        ? await chatSession.editingSession.startExternalEdits(response, responsePartHandle, revive(progress.resources), progress.undoStopId)
-                        : await chatSession.editingSession.stopExternalEdits(response, responsePartHandle);
+                    const parts = progress.start ? await chatSession.editingSession.startExternalEdits(
+                        response,
+                        responsePartHandle,
+                        revive(progress.resources),
+                        progress.undoStopId
+                    ) : await chatSession.editingSession.stopExternalEdits(response, responsePartHandle);
                     chatProgressParts.push(...parts);
                 }
                 continue;
             }
-            const revivedProgress = progress.kind === 'notebookEdit'
-                ? ChatNotebookEdit.fromChatEdit(progress)
-                : revive(progress);
-            if (revivedProgress.kind === 'notebookEdit'
-                || revivedProgress.kind === 'textEdit'
-                || revivedProgress.kind === 'codeblockUri') {
+            if (progress.kind === "beginToolInvocation") {
+                this._languageModelToolsService.beginToolCall({
+                    toolCallId: progress.toolCallId,
+                    toolId: progress.toolName,
+                    chatRequestId: requestId,
+                    sessionResource: chatSession?.sessionResource,
+                    subagentInvocationId: progress.subagentInvocationId
+                });
+                continue;
+            }
+            if (progress.kind === "updateToolInvocation") {
+                this._languageModelToolsService.updateToolStream(
+                    progress.toolCallId,
+                    progress.streamData?.partialInput,
+                    CancellationToken.None
+                );
+                continue;
+            }
+            const revivedProgress = progress.kind === "notebookEdit" ? ChatNotebookEdit.fromChatEdit(progress) : revive(progress);
+            if (revivedProgress.kind === "notebookEdit" || revivedProgress.kind === "textEdit" || revivedProgress.kind === "codeblockUri") {
                 revivedProgress.uri = this._uriIdentityService.asCanonicalUri(revivedProgress.uri);
             }
             if (responsePartHandle !== undefined) {
-                if (revivedProgress.kind === 'progressTask') {
+                if (revivedProgress.kind === "progressTask") {
                     const handle = responsePartHandle;
                     const responsePartId = `${requestId}_${handle}`;
                     const task = ( new MainThreadChatTask(revivedProgress.content));
                     this._activeTasks.set(responsePartId, task);
                     chatProgressParts.push(task);
-                }
-                else if (responsePartHandle !== undefined) {
+                } else if (responsePartHandle !== undefined) {
                     const responsePartId = `${requestId}_${responsePartHandle}`;
                     const task = this._activeTasks.get(responsePartId);
                     switch (revivedProgress.kind) {
-                        case 'progressTaskResult':
-                            if (task && revivedProgress.content) {
-                                task.complete(revivedProgress.content.value);
-                                this._activeTasks.delete(responsePartId);
-                            }
-                            else {
-                                task?.complete(undefined);
-                            }
-                            break;
-                        case 'warning':
-                        case 'reference':
-                            task?.add(revivedProgress);
-                            break;
+                    case "progressTaskResult":
+                        if (task && revivedProgress.content) {
+                            task.complete(revivedProgress.content.value);
+                            this._activeTasks.delete(responsePartId);
+                        } else {
+                            task?.complete(undefined);
+                        }
+                        break;
+                    case "warning":
+                    case "reference":
+                        task?.add(revivedProgress);
+                        break;
                     }
                 }
                 continue;
             }
-            if (revivedProgress.kind === 'inlineReference' && revivedProgress.resolveId) {
+            if (revivedProgress.kind === "inlineReference" && revivedProgress.resolveId) {
                 if (!( this._unresolvedAnchors.has(requestId))) {
                     this._unresolvedAnchors.set(requestId, ( new Map()));
                 }
@@ -285,25 +329,31 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
     $registerAgentCompletionsProvider(handle, id, triggerCharacters) {
         const provide = async (query, token) => {
             const completions = await this._proxy.$invokeCompletionProvider(handle, query, token);
-            return ( completions.map((c) => ({ ...c, icon: c.icon ? ThemeIcon.fromId(c.icon) : undefined })));
+            return ( completions.map(c => ({
+                ...c,
+                icon: c.icon ? ThemeIcon.fromId(c.icon) : undefined
+            })));
         };
         this._agentIdsToCompletionProviders.set(id, this._chatAgentService.registerAgentCompletionProvider(id, provide));
-        this._agentCompletionProviders.set(handle, this._languageFeaturesService.completionProvider.register({ scheme: Schemas.vscodeChatInput, hasAccessToAllModels: true }, {
-            _debugDisplayName: 'chatAgentCompletions:' + handle,
+        this._agentCompletionProviders.set(handle, this._languageFeaturesService.completionProvider.register({
+            scheme: Schemas.vscodeChatInput,
+            hasAccessToAllModels: true
+        }, {
+            _debugDisplayName: "chatAgentCompletions:" + handle,
             triggerCharacters,
             provideCompletionItems: async (model, position, _context, token) => {
                 const widget = this._chatWidgetService.getWidgetByInputUri(model.uri);
                 if (!widget || !widget.viewModel) {
                     return;
                 }
-                const triggerCharsPart = ( triggerCharacters.map(c => escapeRegExpCharacters(c))).join('');
-                const wordRegex = ( new RegExp(`[${triggerCharsPart}]\\S*`, 'g'));
-                const query = getWordAtText(position.column, wordRegex, model.getLineContent(position.lineNumber), 0)?.word ?? '';
+                const triggerCharsPart = ( triggerCharacters.map(c => escapeRegExpCharacters(c))).join("");
+                const wordRegex = ( new RegExp(`[${triggerCharsPart}]\\S*`, "g"));
+                const query = getWordAtText(position.column, wordRegex, model.getLineContent(position.lineNumber), 0)?.word ?? "";
                 if (query && !( triggerCharacters.some(c => query.startsWith(c)))) {
                     return;
                 }
                 const parsedRequest = this._instantiationService.createInstance(ChatRequestParser).parseChatRequest(widget.viewModel.sessionResource, model.getValue()).parts;
-                const agentPart = parsedRequest.find((part) => part instanceof ChatRequestAgentPart);
+                const agentPart = parsedRequest.find(part => part instanceof ChatRequestAgentPart);
                 const thisAgentId = this._agents.get(handle)?.id;
                 if (agentPart?.agent.id !== thisAgentId) {
                     return;
@@ -314,7 +364,7 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                 }
                 const result = await provide(query, token);
                 const variableItems = ( result.map(v => {
-                    const insertText = v.insertText ?? (typeof v.label === 'string' ? v.label : v.label.label);
+                    const insertText = v.insertText ?? (typeof v.label === "string" ? v.label : v.label.label);
                     const rangeAfterInsert = ( new Range(
                         range.insert.startLineNumber,
                         range.insert.startColumn,
@@ -324,11 +374,21 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                     return {
                         label: v.label,
                         range,
-                        insertText: insertText + ' ',
+                        insertText: insertText + " ",
                         kind: CompletionItemKind.Text,
                         detail: v.detail,
                         documentation: v.documentation,
-                        command: { id: addDynamicVariableActionId, title: '', arguments: [{ id: v.id, widget, range: rangeAfterInsert, variableData: revive(v.value), command: v.command }] }
+                        command: {
+                            id: addDynamicVariableActionId,
+                            title: "",
+                            arguments: [{
+                                id: v.id,
+                                widget,
+                                range: rangeAfterInsert,
+                                variableData: revive(v.value),
+                                command: v.command
+                            }]
+                        }
                     };
                 }));
                 return {
@@ -342,74 +402,65 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
         this._agentIdsToCompletionProviders.deleteAndDispose(id);
     }
     $registerChatParticipantDetectionProvider(handle) {
-        this._chatParticipantDetectionProviders.set(handle, this._chatAgentService.registerChatParticipantDetectionProvider(handle, {
-            provideParticipantDetection: async (request, history, options, token) => {
-                return await this._proxy.$detectChatParticipant(handle, request, { history }, options, token);
-            }
-        }));
+        this._chatParticipantDetectionProviders.set(
+            handle,
+            this._chatAgentService.registerChatParticipantDetectionProvider(handle, {
+                provideParticipantDetection: async (request, history, options, token) => {
+                    return await this._proxy.$detectChatParticipant(handle, request, {
+                        history
+                    }, options, token);
+                }
+            })
+        );
     }
     $unregisterChatParticipantDetectionProvider(handle) {
         this._chatParticipantDetectionProviders.deleteAndDispose(handle);
     }
-    $registerRelatedFilesProvider(handle, metadata) {
-        this._chatRelatedFilesProviders.set(handle, this._chatEditingService.registerRelatedFilesProvider(handle, {
-            description: metadata.description,
-            provideRelatedFiles: async (request, token) => {
-                return (await this._proxy.$provideRelatedFiles(handle, request, token))?.map((v) => ({ uri: ( URI.from(v.uri)), description: v.description })) ?? [];
-            }
-        }));
-    }
-    $unregisterRelatedFilesProvider(handle) {
-        this._chatRelatedFilesProviders.deleteAndDispose(handle);
-    }
-    async $registerCustomAgentsProvider(handle, extensionId) {
+    async $registerPromptFileProvider(handle, type, extensionId) {
         const extension = await this._extensionService.getExtension(extensionId.value);
         if (!extension) {
-            this._logService.error(`[MainThreadChatAgents2] Could not find extension for CustomAgentsProvider: ${extensionId.value}`);
+            this._logService.error(
+                `[MainThreadChatAgents2] Could not find extension for prompt file provider: ${extensionId.value}`
+            );
+            return;
+        }
+        if (!isValidPromptType(type)) {
+            this._logService.error(`[MainThreadChatAgents2] Invalid contribution type: ${type}`);
             return;
         }
         const emitter = ( new Emitter());
-        this._customAgentsProviderEmitters.set(handle, emitter);
-        const disposable = this._promptsService.registerCustomAgentsProvider(extension, {
-            onDidChangeCustomAgents: emitter.event,
-            provideCustomAgents: async (options, token) => {
-                const agents = await this._proxy.$provideCustomAgents(handle, options, token);
-                if (!agents) {
+        this._promptFileProviderEmitters.set(handle, emitter);
+        const contentRegistrations = ( new DisposableMap());
+        this._promptFileContentRegistrations.set(handle, contentRegistrations);
+        const disposable = this._promptsService.registerPromptFileProvider(extension, type, {
+            onDidChangePromptFiles: emitter.event,
+            providePromptFiles: async (context, token) => {
+                const contributions = await this._proxy.$providePromptFiles(handle, type, context, token);
+                if (!contributions) {
                     return undefined;
                 }
-                return ( agents.map(agent => ({
-                    ...agent,
-                    uri: URI.revive(agent.uri)
-                })));
+                return ( contributions.map(c => {
+                    return {
+                        uri: URI.revive(c.uri)
+                    };
+                }));
             }
         });
-        this._customAgentsProviders.set(handle, disposable);
+        this._promptFileProviders.set(handle, disposable);
     }
-    $unregisterCustomAgentsProvider(handle) {
-        this._customAgentsProviders.deleteAndDispose(handle);
-        this._customAgentsProviderEmitters.deleteAndDispose(handle);
+    $unregisterPromptFileProvider(handle) {
+        this._promptFileProviders.deleteAndDispose(handle);
+        this._promptFileProviderEmitters.deleteAndDispose(handle);
+        this._promptFileContentRegistrations.deleteAndDispose(handle);
     }
-    $onDidChangeCustomAgents(handle) {
-        const emitter = this._customAgentsProviderEmitters.get(handle);
+    $onDidChangePromptFiles(handle) {
+        const emitter = this._promptFileProviderEmitters.get(handle);
         if (emitter) {
             emitter.fire();
         }
     }
 };
-MainThreadChatAgents2 = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadChatAgents2),
-    ( __param(1, IChatAgentService)),
-    ( __param(2, IChatSessionsService)),
-    ( __param(3, IChatService)),
-    ( __param(4, IChatEditingService)),
-    ( __param(5, ILanguageFeaturesService)),
-    ( __param(6, IChatWidgetService)),
-    ( __param(7, IInstantiationService)),
-    ( __param(8, ILogService)),
-    ( __param(9, IExtensionService)),
-    ( __param(10, IUriIdentityService)),
-    ( __param(11, IPromptsService))
-], MainThreadChatAgents2);
+MainThreadChatAgents2 = __decorate([extHostNamedCustomer(MainContext.MainThreadChatAgents2), ( __param(1, IChatAgentService)), ( __param(2, IChatSessionsService)), ( __param(3, IChatService)), ( __param(4, ILanguageFeaturesService)), ( __param(5, IChatWidgetService)), ( __param(6, IInstantiationService)), ( __param(7, ILogService)), ( __param(8, IExtensionService)), ( __param(9, IUriIdentityService)), ( __param(10, IPromptsService)), ( __param(11, ILanguageModelToolsService))], MainThreadChatAgents2);
 function computeCompletionRanges(model, position, reg) {
     const varWord = getWordAtText(position.column, reg, model.getLineContent(position.lineNumber), 0);
     if (!varWord && model.getWordUntilPosition(position).word) {
@@ -419,8 +470,7 @@ function computeCompletionRanges(model, position, reg) {
     let replace;
     if (!varWord) {
         insert = replace = Range.fromPositions(position);
-    }
-    else {
+    } else {
         insert = ( new Range(
             position.lineNumber,
             varWord.startColumn,
@@ -434,13 +484,16 @@ function computeCompletionRanges(model, position, reg) {
             varWord.endColumn
         ));
     }
-    return { insert, replace };
+    return {
+        insert,
+        replace
+    };
 }
 var ChatNotebookEdit;
-(function (ChatNotebookEdit) {
+(function(ChatNotebookEdit) {
     function fromChatEdit(part) {
         return {
-            kind: 'notebookEdit',
+            kind: "notebookEdit",
             uri: URI.revive(part.uri),
             done: part.done,
             edits: ( part.edits.map(NotebookDto.fromCellEditOperationDto))

package/vscode/src/vs/workbench/api/browser/mainThreadChatCodeMapper.js

@@ -10,8 +10,12 @@ import { NotebookDto } from './mainThreadNotebookDto.js';
 
 var MainThreadChatCodemapper_1;
 let MainThreadChatCodemapper = class MainThreadChatCodemapper extends Disposable {
-    static { MainThreadChatCodemapper_1 = this; }
-    static { this._requestHandlePool = 0; }
+    static {
+        MainThreadChatCodemapper_1 = this;
+    }
+    static {
+        this._requestHandlePool = 0;
+    }
     constructor(extHostContext, codeMapperService) {
         super();
         this.codeMapperService = codeMapperService;
@@ -34,9 +38,8 @@ let MainThreadChatCodemapper = class MainThreadChatCodemapper extends Disposable
                     location: uiRequest.location
                 };
                 try {
-                    return await this._proxy.$mapCode(handle, extHostRequest, token).then((result) => result ?? undefined);
-                }
-                finally {
+                    return await this._proxy.$mapCode(handle, extHostRequest, token).then(result => result ?? undefined);
+                } finally {
                     this._responseMap.delete(requestId);
                 }
             }
@@ -54,20 +57,15 @@ let MainThreadChatCodemapper = class MainThreadChatCodemapper extends Disposable
             const resource = URI.revive(data.uri);
             if (!edits.length) {
                 response.textEdit(resource, []);
-            }
-            else if (edits.every(TextEdit.isTextEdit)) {
+            } else if (edits.every(TextEdit.isTextEdit)) {
                 response.textEdit(resource, edits);
-            }
-            else {
+            } else {
                 response.notebookEdit(resource, ( edits.map(NotebookDto.fromCellEditOperationDto)));
             }
         }
         return Promise.resolve();
     }
 };
-MainThreadChatCodemapper = MainThreadChatCodemapper_1 = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadCodeMapper),
-    ( __param(1, ICodeMapperService))
-], MainThreadChatCodemapper);
+MainThreadChatCodemapper = MainThreadChatCodemapper_1 = __decorate([extHostNamedCustomer(MainContext.MainThreadCodeMapper), ( __param(1, ICodeMapperService))], MainThreadChatCodemapper);
 
 export { MainThreadChatCodemapper };

package/vscode/src/vs/workbench/api/browser/mainThreadChatContext.d.ts

@@ -1,6 +1,5 @@
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
-import { IChatContextItem, IChatContextSupport } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/contextContrib/chatContext";
+import { IChatContextItem } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/contextContrib/chatContext";
 import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
 import { IDocumentFilterDto, MainThreadChatContextShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
 import { IChatContextService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/contextContrib/chatContextService.service";
@@ -9,9 +8,10 @@ export declare class MainThreadChatContext extends Disposable implements MainThr
     private readonly _proxy;
     private readonly _providers;
     constructor(extHostContext: IExtHostContext, _chatContextService: IChatContextService);
-    $registerChatContextProvider(handle: number, id: string, selector: IDocumentFilterDto[] | undefined, _options: {
-        icon: ThemeIcon;
-    }, support: IChatContextSupport): void;
+    $registerChatWorkspaceContextProvider(handle: number, id: string): void;
+    $registerChatExplicitContextProvider(handle: number, id: string): void;
+    $registerChatResourceContextProvider(handle: number, id: string, selector: IDocumentFilterDto[]): void;
     $unregisterChatContextProvider(handle: number): void;
     $updateWorkspaceContextItems(handle: number, items: IChatContextItem[]): void;
+    $executeChatContextItemCommand(itemHandle: number): Promise<void>;
 }