@codingame/monaco-vscode-extensions-service-override 1.83.16 → 1.85.0-next.1

package/extensions.js

@@ -44,8 +44,7 @@ import 'vscode/vscode/vs/workbench/api/browser/statusBarExtensionPoint';
 import './vscode/src/vs/workbench/api/browser/mainThreadLocalization.js';
 import './vscode/src/vs/workbench/api/browser/mainThreadBulkEdits.js';
 import './vscode/src/vs/workbench/api/browser/mainThreadChatProvider.js';
-import './vscode/src/vs/workbench/api/browser/mainThreadChatSlashCommands.js';
-import './vscode/src/vs/workbench/api/browser/mainThreadChatAgents.js';
+import './vscode/src/vs/workbench/api/browser/mainThreadChatAgents2.js';
 import './vscode/src/vs/workbench/api/browser/mainThreadChatVariables.js';
 import './vscode/src/vs/workbench/api/browser/mainThreadCodeInsets.js';
 import './vscode/src/vs/workbench/api/browser/mainThreadClipboard.js';
@@ -76,6 +75,7 @@ import './vscode/src/vs/workbench/api/browser/mainThreadQuickDiff.js';
 import './vscode/src/vs/workbench/api/browser/mainThreadQuickOpen.js';
 import './vscode/src/vs/workbench/api/browser/mainThreadRemoteConnectionData.js';
 import './vscode/src/vs/workbench/api/browser/mainThreadSaveParticipant.js';
+import './vscode/src/vs/workbench/api/browser/mainThreadSpeech.js';
 import './vscode/src/vs/workbench/api/browser/mainThreadEditSessionIdentityParticipant.js';
 import './vscode/src/vs/workbench/api/browser/mainThreadSCM.js';
 import './vscode/src/vs/workbench/api/browser/mainThreadSearch.js';

package/localExtensionHost.d.ts

@@ -27,6 +27,7 @@ declare class LocalExtensionHost implements IExtensionHost {
     extensions: ExtensionHostExtensions | null;
     private readonly _extensionHostLogsLocation;
     private _protocolPromise;
+    pid: null;
     constructor(runningLocation: LocalProcessRunningLocation, startup: ExtensionHostStartup, _initDataProvider: IWebWorkerExtensionHostDataProvider, _telemetryService: ITelemetryService, _contextService: IWorkspaceContextService, _labelService: ILabelService, _logService: ILogService, _loggerService: ILoggerService, _environmentService: IBrowserWorkbenchEnvironmentService, _productService: IProductService, _userDataProfilesService: IUserDataProfilesService);
     onExit: Event<any>;
     start(): Promise<IMessagePassingProtocol>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-extensions-service-override",
-  "version": "1.83.16",
+  "version": "1.85.0-next.1",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,9 +18,9 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@1.83.16",
-    "monaco-editor": "0.44.0",
+    "vscode": "npm:@codingame/monaco-vscode-api@1.85.0-next.1",
+    "monaco-editor": "0.45.0",
     "vscode-semver": "npm:semver@=5.5.0",
-    "@codingame/monaco-vscode-files-service-override": "1.83.16"
+    "@codingame/monaco-vscode-files-service-override": "1.85.0-next.1"
   }
 }

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

@@ -257,8 +257,10 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
                 throw new Error('User did not consent to login.');
             }
             let session;
-            if (sessions?.length && !options.forceNewSession && supportsMultipleAccounts) {
-                session = await this.authenticationService.selectSession(providerId, extensionId, extensionName, scopes, sessions);
+            if (sessions?.length && !options.forceNewSession) {
+                session = supportsMultipleAccounts
+                    ? await this.authenticationService.selectSession(providerId, extensionId, extensionName, scopes, sessions)
+                    : sessions[0];
             }
             else {
                 let sessionToRecreate;

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

@@ -1,13 +1,10 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { DeferredPromise } from 'monaco-editor/esm/vs/base/common/async.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Disposable, DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat';
 import { IChatContributionService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContributionService';
-import { isCompleteInteractiveProgressTreeData } from '../../contrib/chat/common/chatModel.js';
 import { IChatService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 
@@ -18,13 +15,12 @@ let MainThreadChat = class MainThreadChat extends Disposable {
         this._chatWidgetService = _chatWidgetService;
         this.chatContribService = chatContribService;
         this._providerRegistrations = this._register(( new DisposableMap()));
-        this._activeRequestProgressCallbacks = ( new Map());
         this._stateEmitters = ( new Map());
-        this._responsePartHandlePool = 0;
-        this._activeResponsePartPromises = ( new Map());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChat));
         this._register(this._chatService.onDidPerformUserAction(e => {
-            this._proxy.$onDidPerformUserAction(e);
+            if (!e.agentId) {
+                this._proxy.$onDidPerformUserAction(e);
+            }
         }));
     }
     $transferChatSession(sessionId, toWorkspace) {
@@ -44,14 +40,13 @@ let MainThreadChat = class MainThreadChat extends Disposable {
         const unreg = this._chatService.registerProvider({
             id,
             displayName: registration.label,
-            prepareSession: async (initialState, token) => {
-                const session = await this._proxy.$prepareChat(handle, initialState, token);
+            prepareSession: async (token) => {
+                const session = await this._proxy.$prepareChat(handle, token);
                 if (!session) {
                     return undefined;
                 }
-                const responderAvatarIconUri = session.responderAvatarIconUri ?
-                    URI.revive(session.responderAvatarIconUri) :
-                    registration.extensionIcon;
+                const responderAvatarIconUri = session.responderAvatarIconUri &&
+                    URI.revive(session.responderAvatarIconUri);
                 const emitter = ( new Emitter());
                 this._stateEmitters.set(session.id, emitter);
                 return {
@@ -61,7 +56,6 @@ let MainThreadChat = class MainThreadChat extends Disposable {
                     responderUsername: session.responderUsername,
                     responderAvatarIconUri,
                     inputPlaceholder: session.inputPlaceholder,
-                    onDidChangeState: emitter.event,
                     dispose: () => {
                         emitter.dispose();
                         this._stateEmitters.delete(session.id);
@@ -69,91 +63,18 @@ let MainThreadChat = class MainThreadChat extends Disposable {
                     }
                 };
             },
-            resolveRequest: async (session, context, token) => {
-                const dto = await this._proxy.$resolveRequest(handle, session.id, context, token);
-                return {
-                    session,
-                    ...dto
-                };
-            },
-            provideReply: async (request, progress, token) => {
-                const id = `${handle}_${request.session.id}`;
-                this._activeRequestProgressCallbacks.set(id, progress);
-                try {
-                    const requestDto = {
-                        message: request.message,
-                        variables: request.variables
-                    };
-                    const dto = await this._proxy.$provideReply(handle, request.session.id, requestDto, token);
-                    return {
-                        session: request.session,
-                        ...dto
-                    };
-                }
-                finally {
-                    this._activeRequestProgressCallbacks.delete(id);
-                }
-            },
             provideWelcomeMessage: (token) => {
                 return this._proxy.$provideWelcomeMessage(handle, token);
             },
-            provideSlashCommands: (session, token) => {
-                return this._proxy.$provideSlashCommands(handle, session.id, token);
+            provideSampleQuestions: (token) => {
+                return this._proxy.$provideSampleQuestions(handle, token);
             },
-            provideFollowups: (session, token) => {
-                return this._proxy.$provideFollowups(handle, session.id, token);
-            },
-            removeRequest: (session, requestId) => {
-                return this._proxy.$removeRequest(handle, session.id, requestId);
-            }
         });
         this._providerRegistrations.set(handle, unreg);
     }
-    async $acceptResponseProgress(handle, sessionId, progress, responsePartHandle) {
-        const id = `${handle}_${sessionId}`;
-        if ('placeholder' in progress) {
-            const responsePartId = `${id}_${++this._responsePartHandlePool}`;
-            const deferredContentPromise = ( new DeferredPromise());
-            this._activeResponsePartPromises.set(responsePartId, deferredContentPromise);
-            this._activeRequestProgressCallbacks.get(id)?.({ ...progress, resolvedContent: deferredContentPromise.p });
-            return this._responsePartHandlePool;
-        }
-        else if (responsePartHandle) {
-            const responsePartId = `${id}_${responsePartHandle}`;
-            const deferredContentPromise = this._activeResponsePartPromises.get(responsePartId);
-            if (deferredContentPromise && isCompleteInteractiveProgressTreeData(progress)) {
-                const withRevivedUris = revive(progress);
-                deferredContentPromise.complete(withRevivedUris);
-                this._activeResponsePartPromises.delete(responsePartId);
-            }
-            else if (deferredContentPromise && 'content' in progress) {
-                deferredContentPromise.complete(progress.content);
-                this._activeResponsePartPromises.delete(responsePartId);
-            }
-            return;
-        }
-        if (isCompleteInteractiveProgressTreeData(progress)) {
-            return;
-        }
-        if ('documents' in progress) {
-            const usedContext = {
-                documents: ( progress.documents.map(({ uri, version, ranges }) => ({
-                    uri: URI.revive(uri),
-                    version,
-                    ranges,
-                }))),
-            };
-            this._activeRequestProgressCallbacks.get(id)?.(usedContext);
-            return;
-        }
-        this._activeRequestProgressCallbacks.get(id)?.(progress);
-    }
     async $acceptChatState(sessionId, state) {
         this._stateEmitters.get(sessionId)?.fire(state);
     }
-    $addRequest(context) {
-        this._chatService.addRequest(context);
-    }
     async $sendRequestToProvider(providerId, message) {
         const widget = await this._chatWidgetService.revealViewForProvider(providerId);
         if (widget && widget.viewModel) {

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

@@ -0,0 +1,216 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { DeferredPromise } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Disposable, DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
+import { escapeRegExpCharacters } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { getWordAtText } from 'monaco-editor/esm/vs/editor/common/core/wordHelper.js';
+import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat';
+import { ChatInputPart } from '../../contrib/chat/browser/chatInputPart.js';
+import { AddDynamicVariableAction } from '../../contrib/chat/browser/contrib/chatDynamicVariables.js';
+import { IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
+import { ChatRequestAgentPart } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
+import { ChatRequestParser } from '../../contrib/chat/common/chatRequestParser.js';
+import { IChatService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
+    constructor(extHostContext, _chatAgentService, _chatService, _languageFeaturesService, _chatWidgetService, _instantiationService) {
+        super();
+        this._chatAgentService = _chatAgentService;
+        this._chatService = _chatService;
+        this._languageFeaturesService = _languageFeaturesService;
+        this._chatWidgetService = _chatWidgetService;
+        this._instantiationService = _instantiationService;
+        this._agents = this._register(( new DisposableMap()));
+        this._agentCompletionProviders = this._register(( new DisposableMap()));
+        this._pendingProgress = ( new Map());
+        this._responsePartHandlePool = 0;
+        this._activeResponsePartPromises = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatAgents2));
+        this._register(this._chatService.onDidDisposeSession(e => {
+            this._proxy.$releaseSession(e.sessionId);
+        }));
+        this._register(this._chatService.onDidPerformUserAction(e => {
+            if (typeof e.agentId === 'string') {
+                for (const [handle, agent] of this._agents) {
+                    if (agent.name === e.agentId) {
+                        if (e.action.kind === 'vote') {
+                            this._proxy.$acceptFeedback(handle, e.sessionId, e.requestId, e.action.direction);
+                        }
+                        else {
+                            this._proxy.$acceptAction(handle, e.sessionId, e.requestId, e);
+                        }
+                        break;
+                    }
+                }
+            }
+        }));
+    }
+    $unregisterAgent(handle) {
+        this._agents.deleteAndDispose(handle);
+    }
+    $registerAgent(handle, name, metadata) {
+        const d = this._chatAgentService.registerAgent({
+            id: name,
+            metadata: revive(metadata),
+            invoke: async (request, progress, history, token) => {
+                this._pendingProgress.set(request.requestId, progress);
+                try {
+                    return (await this._proxy.$invokeAgent(handle, request.sessionId, request.requestId, request, { history }, token)) ?? {};
+                }
+                finally {
+                    this._pendingProgress.delete(request.requestId);
+                }
+            },
+            provideFollowups: async (sessionId, token) => {
+                if (!this._agents.get(handle)?.hasFollowups) {
+                    return [];
+                }
+                return this._proxy.$provideFollowups(handle, sessionId, token);
+            },
+            provideSlashCommands: async (token) => {
+                if (!this._agents.get(handle)?.hasSlashCommands) {
+                    return [];
+                }
+                return this._proxy.$provideSlashCommands(handle, token);
+            }
+        });
+        this._agents.set(handle, {
+            name,
+            dispose: d.dispose,
+            hasSlashCommands: metadata.hasSlashCommands,
+            hasFollowups: metadata.hasFollowups
+        });
+    }
+    $updateAgent(handle, metadataUpdate) {
+        const data = this._agents.get(handle);
+        if (!data) {
+            throw new Error(`No agent with handle ${handle} registered`);
+        }
+        data.hasSlashCommands = metadataUpdate.hasSlashCommands;
+        data.hasFollowups = metadataUpdate.hasFollowups;
+        this._chatAgentService.updateAgent(data.name, revive(metadataUpdate));
+    }
+    async $handleProgressChunk(requestId, progress, responsePartHandle) {
+        if (progress.kind === 'asyncContent') {
+            const handle = ++this._responsePartHandlePool;
+            const responsePartId = `${requestId}_${handle}`;
+            const deferredContentPromise = ( new DeferredPromise());
+            this._activeResponsePartPromises.set(responsePartId, deferredContentPromise);
+            this._pendingProgress.get(requestId)?.({ ...progress, resolvedContent: deferredContentPromise.p });
+            return handle;
+        }
+        else if (typeof responsePartHandle === 'number') {
+            const responsePartId = `${requestId}_${responsePartHandle}`;
+            const deferredContentPromise = this._activeResponsePartPromises.get(responsePartId);
+            if (deferredContentPromise && progress.kind === 'treeData') {
+                const withRevivedUris = revive(progress);
+                deferredContentPromise.complete(withRevivedUris);
+                this._activeResponsePartPromises.delete(responsePartId);
+            }
+            else if (deferredContentPromise && progress.kind === 'content') {
+                deferredContentPromise.complete(progress.content);
+                this._activeResponsePartPromises.delete(responsePartId);
+            }
+            return responsePartHandle;
+        }
+        if (progress.kind === 'treeData') {
+            return;
+        }
+        const revivedProgress = revive(progress);
+        this._pendingProgress.get(requestId)?.(revivedProgress);
+    }
+    $registerAgentCompletionsProvider(handle, triggerCharacters) {
+        this._agentCompletionProviders.set(handle, this._languageFeaturesService.completionProvider.register({ scheme: ChatInputPart.INPUT_SCHEME, 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 ?? '';
+                if (query && !( triggerCharacters.some(c => query.startsWith(c)))) {
+                    return;
+                }
+                const parsedRequest = (await this._instantiationService.createInstance(ChatRequestParser).parseChatRequest(widget.viewModel.sessionId, model.getValue())).parts;
+                const agentPart = parsedRequest.find((part) => part instanceof ChatRequestAgentPart);
+                const thisAgentName = this._agents.get(handle)?.name;
+                if (agentPart?.agent.id !== thisAgentName) {
+                    return;
+                }
+                const range = computeCompletionRanges(model, position, wordRegex);
+                if (!range) {
+                    return null;
+                }
+                const result = await this._proxy.$invokeCompletionProvider(handle, query, token);
+                const variableItems = ( result.map(v => {
+                    const insertText = v.insertText ?? (typeof v.label === 'string' ? v.label : v.label.label);
+                    const rangeAfterInsert = ( new Range(
+                        range.insert.startLineNumber,
+                        range.insert.startColumn,
+                        range.insert.endLineNumber,
+                        range.insert.startColumn + insertText.length
+                    ));
+                    return {
+                        label: v.label,
+                        range,
+                        insertText: insertText + ' ',
+                        kind: 18 ,
+                        detail: v.detail,
+                        documentation: v.documentation,
+                        command: { id: AddDynamicVariableAction.ID, title: '', arguments: [{ widget, range: rangeAfterInsert, variableData: v.values }] }
+                    };
+                }));
+                return {
+                    suggestions: variableItems
+                };
+            }
+        }));
+    }
+    $unregisterAgentCompletionsProvider(handle) {
+        this._agentCompletionProviders.deleteAndDispose(handle);
+    }
+};
+MainThreadChatAgents2 = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadChatAgents2),
+    ( __param(1, IChatAgentService)),
+    ( __param(2, IChatService)),
+    ( __param(3, ILanguageFeaturesService)),
+    ( __param(4, IChatWidgetService)),
+    ( __param(5, IInstantiationService))
+], MainThreadChatAgents2);
+function computeCompletionRanges(model, position, reg) {
+    const varWord = getWordAtText(position.column, reg, model.getLineContent(position.lineNumber), 0);
+    if (!varWord && model.getWordUntilPosition(position).word) {
+        return;
+    }
+    let insert;
+    let replace;
+    if (!varWord) {
+        insert = replace = Range.fromPositions(position);
+    }
+    else {
+        insert = ( new Range(
+            position.lineNumber,
+            varWord.startColumn,
+            position.lineNumber,
+            position.column
+        ));
+        replace = ( new Range(
+            position.lineNumber,
+            varWord.startColumn,
+            position.lineNumber,
+            varWord.endColumn
+        ));
+    }
+    return { insert, replace };
+}
+
+export { MainThreadChatAgents2 };

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

@@ -39,6 +39,9 @@ let MainThreadChatProvider = class MainThreadChatProvider {
     $unregisterProvider(handle) {
         this._providerRegistrations.deleteAndDispose(handle);
     }
+    async $prepareChatAccess(providerId) {
+        return this._chatProviderService.lookupChatResponseProvider(providerId);
+    }
     async $fetchResponse(extension, providerId, requestId, messages, options, token) {
         this._logService.debug('[CHAT] extension request STARTED', extension.value, requestId);
         const task = this._chatProviderService.fetchChatResponse(providerId, messages, options, ( new Progress(value => {

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

@@ -1,10 +1,11 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { IChatVariablesService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatVariables';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 
-let MainThreadChatSlashCommands = class MainThreadChatSlashCommands {
+let MainThreadChatVariables = class MainThreadChatVariables {
     constructor(extHostContext, _chatVariablesService) {
         this._chatVariablesService = _chatVariablesService;
         this._variables = ( new DisposableMap());
@@ -14,8 +15,8 @@ let MainThreadChatSlashCommands = class MainThreadChatSlashCommands {
         this._variables.clearAndDisposeAll();
     }
     $registerVariable(handle, data) {
-        const registration = this._chatVariablesService.registerVariable(data, (messageText, _arg, _model, token) => {
-            return this._proxy.$resolveVariable(handle, messageText, token);
+        const registration = this._chatVariablesService.registerVariable(data, async (messageText, _arg, _model, token) => {
+            return revive(await this._proxy.$resolveVariable(handle, messageText, token));
         });
         this._variables.set(handle, registration);
     }
@@ -23,9 +24,9 @@ let MainThreadChatSlashCommands = class MainThreadChatSlashCommands {
         this._variables.deleteAndDispose(handle);
     }
 };
-MainThreadChatSlashCommands = __decorate([
+MainThreadChatVariables = __decorate([
     extHostNamedCustomer(MainContext.MainThreadChatVariables),
     ( __param(1, IChatVariablesService))
-], MainThreadChatSlashCommands);
+], MainThreadChatVariables);
 
-export { MainThreadChatSlashCommands };
+export { MainThreadChatVariables };

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

@@ -6,6 +6,7 @@ import { extHostNamedCustomer } from '../../services/extensions/common/extHostCu
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
 import { SerializableObjectWithBuffers } from 'vscode/vscode/vs/workbench/services/extensions/common/proxyIdentifier';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { isString } from 'monaco-editor/esm/vs/base/common/types.js';
 
 let MainThreadCommands = class MainThreadCommands {
     constructor(extHostContext, _commandService, _extensionService) {
@@ -20,11 +21,11 @@ let MainThreadCommands = class MainThreadCommands {
         this._generateCommandsDocumentationRegistration.dispose();
     }
     async _generateCommandsDocumentation() {
-        const result = await this._proxy.$getContributedCommandHandlerDescriptions();
+        const result = await this._proxy.$getContributedCommandMetadata();
         const commands = CommandsRegistry.getCommands();
         for (const [id, command] of commands) {
-            if (command.description) {
-                result[id] = command.description;
+            if (command.metadata) {
+                result[id] = command.metadata;
             }
         }
         const all = [];
@@ -76,7 +77,10 @@ function _generateMarkdown(description) {
         return description;
     }
     else {
-        const parts = [description.description];
+        const descriptionString = isString(description.description)
+            ? description.description
+            : description.description.original;
+        const parts = [descriptionString];
         parts.push('\n\n');
         if (description.args) {
             for (const arg of description.args) {

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

@@ -8,7 +8,7 @@ import { extHostNamedCustomer } from '../../services/extensions/common/extHostCu
 import { ICommentService } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentService';
 import { CommentsPanel } from '../../contrib/comments/browser/commentsView.js';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { COMMENTS_VIEW_ID, COMMENTS_VIEW_TITLE, COMMENTS_VIEW_ORIGINAL_TITLE, COMMENTS_VIEW_STORAGE_ID } from '../../contrib/comments/browser/commentsTreeViewer.js';
+import { COMMENTS_VIEW_ID, COMMENTS_VIEW_TITLE, COMMENTS_VIEW_STORAGE_ID } from '../../contrib/comments/browser/commentsTreeViewer.js';
 import { IViewsService, IViewDescriptorService, Extensions } from 'vscode/vscode/vs/workbench/common/views';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 import { ViewPaneContainer } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
@@ -358,7 +358,7 @@ class MainThreadCommentController {
         return ret;
     }
     createCommentThreadTemplate(resource, range) {
-        this._proxy.$createCommentThreadTemplate(this.handle, resource, range);
+        return this._proxy.$createCommentThreadTemplate(this.handle, resource, range);
     }
     async updateCommentThreadTemplate(threadHandle, range) {
         await this._proxy.$updateCommentThreadTemplate(this.handle, threadHandle, range);
@@ -399,7 +399,7 @@ let MainThreadComments = class MainThreadComments extends Disposable {
         }));
     }
     $registerCommentController(handle, id, label, extensionId) {
-        const providerId = `${label}-${extensionId}`;
+        const providerId = `${id}-${extensionId}`;
         this._handlers.set(handle, providerId);
         const provider = ( new MainThreadCommentController(this._proxy, this._commentService, handle, providerId, id, label, {}));
         this._commentService.registerCommentController(providerId, provider);
@@ -461,7 +461,7 @@ let MainThreadComments = class MainThreadComments extends Disposable {
         if (!commentsViewAlreadyRegistered) {
             const VIEW_CONTAINER = ( Registry.as(Extensions.ViewContainersRegistry)).registerViewContainer({
                 id: COMMENTS_VIEW_ID,
-                title: { value: COMMENTS_VIEW_TITLE, original: COMMENTS_VIEW_ORIGINAL_TITLE },
+                title: COMMENTS_VIEW_TITLE,
                 ctorDescriptor: ( new SyncDescriptor(
                     ViewPaneContainer,
                     [COMMENTS_VIEW_ID, { mergeViewWithContainerWhenSingleView: true }]

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

@@ -13,7 +13,7 @@ import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/service
 import { extUri, toLocalResource } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService';
 import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { IPathService } from 'vscode/vscode/vs/workbench/services/path/common/pathService';
 import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
 import { ErrorNoTelemetry } from 'monaco-editor/esm/vs/base/common/errors.js';
@@ -222,15 +222,19 @@ let MainThreadDocuments = class MainThreadDocuments extends Disposable {
         return await this._doCreateUntitled(Boolean(uri.path) ? uri : undefined);
     }
     async _doCreateUntitled(associatedResource, languageId, initialValue) {
-        const model = await this._textFileService.untitled.resolve({
+        const model = this._textFileService.untitled.create({
             associatedResource,
             languageId,
             initialValue
         });
         const resource = model.resource;
+        const ref = await this._textModelResolverService.createModelReference(resource);
         if (!( this._modelTrackers.has(resource))) {
+            ref.dispose();
             throw new Error(`expected URI ${resource.toString()} to have come to LIFE`);
         }
+        this._modelReferenceCollection.add(resource, ref, ref.object.textEditorModel.getValueLength());
+        Event.once(model.onDidRevert)(() => this._modelReferenceCollection.remove(resource));
         this._proxy.$acceptDirtyStateChanged(resource, true);
         return resource;
     }