@codingame/monaco-vscode-extensions-service-override 8.0.3 → 9.0.0

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

@@ -61,6 +61,7 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
         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._pendingProgress = ( new Map());
         this._responsePartHandlePool = 0;
         this._activeTasks = ( new Map());
@@ -73,7 +74,7 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                 for (const [handle, agent] of this._agents) {
                     if (agent.id === e.agentId) {
                         if (e.action.kind === 'vote') {
-                            this._proxy.$acceptFeedback(handle, e.result ?? {}, e.action.direction);
+                            this._proxy.$acceptFeedback(handle, e.result ?? {}, e.action);
                         }
                         else {
                             this._proxy.$acceptAction(handle, e.result || {}, e);
@@ -126,6 +127,9 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
             provideWelcomeMessage: (location, token) => {
                 return this._proxy.$provideWelcomeMessage(handle, location, token);
             },
+            provideChatTitle: (history, token) => {
+                return this._proxy.$provideChatTitle(handle, history, token);
+            },
             provideSampleQuestions: (location, token) => {
                 return this._proxy.$provideSampleQuestions(handle, location, token);
             }
@@ -135,7 +139,7 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
             const extensionDescription = this._extensionService.extensions.find(e => ExtensionIdentifier.equals(e.identifier, extension));
             disposable = this._chatAgentService.registerDynamicAgent({
                 id,
-                name: dynamicProps.name ?? '',
+                name: dynamicProps.name,
                 description: dynamicProps.description,
                 extensionId: extension,
                 extensionDisplayName: extensionDescription?.displayName ?? extension.value,
@@ -144,6 +148,7 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                 fullName: dynamicProps.fullName,
                 metadata: revive(metadata),
                 slashCommands: [],
+                disambiguation: [],
                 locations: [ChatAgentLocation.Panel]
             }, impl);
         }
@@ -256,6 +261,16 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
         this._agentCompletionProviders.deleteAndDispose(handle);
         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);
+            }
+        }));
+    }
+    $unregisterChatParticipantDetectionProvider(handle) {
+        this._chatParticipantDetectionProviders.deleteAndDispose(handle);
+    }
 };
 MainThreadChatAgents2 = __decorate([
     extHostNamedCustomer(MainContext.MainThreadChatAgents2),

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

@@ -156,7 +156,7 @@ class MainThreadCommentThread {
             this._contextValue = changes.contextValue === null ? undefined : changes.contextValue;
         }
         if (modified('comments')) {
-            this._comments = changes.comments;
+            this.comments = changes.comments;
         }
         if (modified('collapseState')) {
             this.initialCollapsibleState = changes.collapseState;
@@ -174,6 +174,9 @@ class MainThreadCommentThread {
             this._isTemplate = changes.isTemplate;
         }
     }
+    hasComments() {
+        return !!this.comments && this.comments.length > 0;
+    }
     dispose() {
         this._isDisposed = true;
         this._onDidChangeCollapsibleState.dispose();
@@ -416,7 +419,7 @@ class MainThreadCommentController {
         };
     }
 }
-const commentsViewIcon = registerIcon('comments-view-icon', Codicon.commentDiscussion, ( localize(4873, 'View icon of the comments view.')));
+const commentsViewIcon = registerIcon('comments-view-icon', Codicon.commentDiscussion, ( localize(4941, 'View icon of the comments view.')));
 let MainThreadComments = class MainThreadComments extends Disposable {
     constructor(extHostContext, _commentService, _viewsService, _viewDescriptorService, _uriIdentityService, _editorService) {
         super();

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

@@ -305,7 +305,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
                         return true;
                     }
                     return false;
-                })(), ( localize(9831, "Custom editor '{0}' could not be saved.", this.name)));
+                })(), ( localize(9875, "Custom editor '{0}' could not be saved.", this.name)));
             }));
         }
         if (startDirty) {
@@ -372,7 +372,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
         this._undoService.pushElement({
             type: UndoRedoElementType.Resource,
             resource: this._editorResource,
-            label: label ?? ( localize(9832, "Edit")),
+            label: label ?? ( localize(9876, "Edit")),
             code: 'undoredo.customEditorEdit',
             undo: () => this.undo(),
             redo: () => this.redo(),

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

@@ -13,7 +13,7 @@ class ExtHostEditSessionIdentityCreateParticipant {
     }
     async participate(workspaceFolder, token) {
         const p = ( (new Promise((resolve, reject) => {
-            setTimeout(() => reject(( (new Error(( localize(4865, "Aborted onWillCreateEditSessionIdentity-event after 10000ms")))))), this.timeout);
+            setTimeout(() => reject(( (new Error(( localize(4933, "Aborted onWillCreateEditSessionIdentity-event after 10000ms")))))), this.timeout);
             this._proxy.$onWillCreateEditSessionIdentity(workspaceFolder.uri, token, this.timeout).then(resolve, reject);
         })));
         return raceCancellationError(p, token);

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

@@ -90,13 +90,13 @@ let MainThreadExtensionService = class MainThreadExtensionService {
             this._notificationService.notify({
                 severity: Severity$1.Error,
                 message: ( localize(
-                    4830,
+                    4898,
                     "Cannot activate the '{0}' extension because it depends on the '{1}' extension, which is not loaded. Would you like to reload the window to load the extension?",
                     extName,
                     missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
                 )),
                 actions: {
-                    primary: [( (new Action('reload', ( localize(4831, "Reload Window")), '', true, () => this._hostService.reload())))]
+                    primary: [( (new Action('reload', ( localize(4899, "Reload Window")), '', true, () => this._hostService.reload())))]
                 }
             });
         }
@@ -106,7 +106,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity$1.Error,
                     message: ( localize(
-                        4832,
+                        4900,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is not supported in the current workspace",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -117,13 +117,13 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity$1.Error,
                     message: ( localize(
-                        4833,
+                        4901,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is not supported in Restricted Mode",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
                     )),
                     actions: {
-                        primary: [( (new Action('manageWorkspaceTrust', ( localize(4834, "Manage Workspace Trust")), '', true, () => this._commandService.executeCommand('workbench.trust.manage'))))]
+                        primary: [( (new Action('manageWorkspaceTrust', ( localize(4902, "Manage Workspace Trust")), '', true, () => this._commandService.executeCommand('workbench.trust.manage'))))]
                     }
                 });
             }
@@ -131,13 +131,13 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity$1.Error,
                     message: ( localize(
-                        4835,
+                        4903,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled. Would you like to enable the extension and reload the window?",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
                     )),
                     actions: {
-                        primary: [( (new Action('enable', ( localize(4836, "Enable and Reload")), '', true, () => this._extensionEnablementService.setEnablement([missingInstalledDependency], enablementState === EnablementState.DisabledGlobally ? EnablementState.EnabledGlobally : EnablementState.EnabledWorkspace)
+                        primary: [( (new Action('enable', ( localize(4904, "Enable and Reload")), '', true, () => this._extensionEnablementService.setEnablement([missingInstalledDependency], enablementState === EnablementState.DisabledGlobally ? EnablementState.EnabledGlobally : EnablementState.EnabledWorkspace)
                                 .then(() => this._hostService.reload(), e => this._notificationService.error(e)))))]
                     }
                 });
@@ -146,7 +146,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity$1.Error,
                     message: ( localize(
-                        4837,
+                        4905,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled.",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -167,21 +167,21 @@ let MainThreadExtensionService = class MainThreadExtensionService {
             this._notificationService.notify({
                 severity: Severity$1.Error,
                 message: ( localize(
-                    4838,
+                    4906,
                     "Cannot activate the '{0}' extension because it depends on the '{1}' extension from '{2}', which is not installed. Would you like to install the extension and reload the window?",
                     extName,
                     dependencyExtension.displayName,
                     dependencyExtension.publisherDisplayName
                 )),
                 actions: {
-                    primary: [( (new Action('install', ( localize(4839, "Install and Reload")), '', true, () => this._extensionsWorkbenchService.install(dependencyExtension)
+                    primary: [( (new Action('install', ( localize(4907, "Install and Reload")), '', true, () => this._extensionsWorkbenchService.install(dependencyExtension)
                             .then(() => this._hostService.reload(), e => this._notificationService.error(e)))))]
                 }
             });
         }
         else {
             this._notificationService.error(( localize(
-                4840,
+                4908,
                 "Cannot activate the '{0}' extension because it depends on an unknown '{1}' extension.",
                 extName,
                 missingDependency

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

@@ -81,28 +81,28 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                     if (data.extensionNames.length === 1) {
                         if (operation === FileOperation.CREATE) {
                             message = ( localize(
-                                4841,
+                                4909,
                                 "Extension '{0}' wants to make refactoring changes with this file creation",
                                 data.extensionNames[0]
                             ));
                         }
                         else if (operation === FileOperation.COPY) {
                             message = ( localize(
-                                4842,
+                                4910,
                                 "Extension '{0}' wants to make refactoring changes with this file copy",
                                 data.extensionNames[0]
                             ));
                         }
                         else if (operation === FileOperation.MOVE) {
                             message = ( localize(
-                                4843,
+                                4911,
                                 "Extension '{0}' wants to make refactoring changes with this file move",
                                 data.extensionNames[0]
                             ));
                         }
                         else  {
                             message = ( localize(
-                                4844,
+                                4912,
                                 "Extension '{0}' wants to make refactoring changes with this file deletion",
                                 data.extensionNames[0]
                             ));
@@ -111,28 +111,28 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                     else {
                         if (operation === FileOperation.CREATE) {
                             message = ( localize(
-                                4845,
+                                4913,
                                 "{0} extensions want to make refactoring changes with this file creation",
                                 data.extensionNames.length
                             ));
                         }
                         else if (operation === FileOperation.COPY) {
                             message = ( localize(
-                                4846,
+                                4914,
                                 "{0} extensions want to make refactoring changes with this file copy",
                                 data.extensionNames.length
                             ));
                         }
                         else if (operation === FileOperation.MOVE) {
                             message = ( localize(
-                                4847,
+                                4915,
                                 "{0} extensions want to make refactoring changes with this file move",
                                 data.extensionNames.length
                             ));
                         }
                         else  {
                             message = ( localize(
-                                4848,
+                                4916,
                                 "{0} extensions want to make refactoring changes with this file deletion",
                                 data.extensionNames.length
                             ));
@@ -142,8 +142,8 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                         const { confirmed } = await dialogService.confirm({
                             type: Severity$1.Info,
                             message,
-                            primaryButton: ( localize(4849, "Show &&Preview")),
-                            cancelButton: ( localize(4850, "Skip Changes"))
+                            primaryButton: ( localize(4917, "Show &&Preview")),
+                            cancelButton: ( localize(4918, "Skip Changes"))
                         });
                         showPreview = true;
                         if (!confirmed) {
@@ -162,19 +162,19 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                             message,
                             buttons: [
                                 {
-                                    label: ( localize(4851, "&&OK")),
+                                    label: ( localize(4919, "&&OK")),
                                     run: () => Choice.OK
                                 },
                                 {
-                                    label: ( localize(4849, "Show &&Preview")),
+                                    label: ( localize(4917, "Show &&Preview")),
                                     run: () => Choice.Preview
                                 }
                             ],
                             cancelButton: {
-                                label: ( localize(4850, "Skip Changes")),
+                                label: ( localize(4918, "Skip Changes")),
                                 run: () => Choice.Cancel
                             },
-                            checkbox: { label: ( localize(4852, "Do not ask me again")) }
+                            checkbox: { label: ( localize(4920, "Do not ask me again")) }
                         });
                         if (result === Choice.Cancel) {
                             return;
@@ -191,15 +191,15 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
             _progressLabel(operation) {
                 switch (operation) {
                     case FileOperation.CREATE:
-                        return ( localize(4853, "Running 'File Create' participants..."));
+                        return ( localize(4921, "Running 'File Create' participants..."));
                     case FileOperation.MOVE:
-                        return ( localize(4854, "Running 'File Rename' participants..."));
+                        return ( localize(4922, "Running 'File Rename' participants..."));
                     case FileOperation.COPY:
-                        return ( localize(4855, "Running 'File Copy' participants..."));
+                        return ( localize(4923, "Running 'File Copy' participants..."));
                     case FileOperation.DELETE:
-                        return ( localize(4856, "Running 'File Delete' participants..."));
+                        return ( localize(4924, "Running 'File Delete' participants..."));
                     case FileOperation.WRITE:
-                        return ( localize(4857, "Running 'File Write' participants..."));
+                        return ( localize(4925, "Running 'File Write' participants..."));
                 }
             }
         });
@@ -301,7 +301,7 @@ registerAction2(class ResetMemento extends Action2 {
         super({
             id: 'files.participants.resetChoice',
             title: {
-                value: ( localize(4858, "Reset choice for 'File operation needs preview'")),
+                value: ( localize(4926, "Reset choice for 'File operation needs preview'")),
                 original: `Reset choice for 'File operation needs preview'`
             },
             f1: true

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

@@ -1,5 +1,4 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { isFalsyOrEmpty } from 'vscode/vscode/vs/base/common/arrays';
 import { VSDataTransfer, createStringDataTransferItem } from 'vscode/vscode/vs/base/common/dataTransfer';
 import { CancellationError } from 'vscode/vscode/vs/base/common/errors';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
@@ -253,7 +252,7 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
             selector: selector,
             provideMultiDocumentHighlights: (model, position, otherModels, token) => {
                 return this._proxy.$provideMultiDocumentHighlights(handle, model.uri, position, ( otherModels.map(model => model.uri)), token).then(dto => {
-                    if (isFalsyOrEmpty(dto)) {
+                    if (dto === undefined || dto === null) {
                         return undefined;
                     }
                     const result = ( new ResourceMap());

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

@@ -9,19 +9,33 @@ let MainThreadLanguageModelTools = class MainThreadLanguageModelTools extends Di
         super();
         this._languageModelToolsService = _languageModelToolsService;
         this._tools = this._register(( new DisposableMap()));
+        this._countTokenCallbacks = ( new Map());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostLanguageModelTools));
-        this._register(this._languageModelToolsService.onDidChangeTools(e => this._proxy.$acceptToolDelta(e)));
+        this._register(this._languageModelToolsService.onDidChangeTools(e => this._proxy.$onDidChangeTools([...this._languageModelToolsService.getTools()])));
     }
     async $getTools() {
         return Array.from(this._languageModelToolsService.getTools());
     }
-    $invokeTool(name, parameters, token) {
-        return this._languageModelToolsService.invokeTool(name, parameters, token);
+    $invokeTool(dto, token) {
+        return this._languageModelToolsService.invokeTool(dto, (input, token) => this._proxy.$countTokensForInvocation(dto.callId, input, token), token);
+    }
+    $countTokensForInvocation(callId, input, token) {
+        const fn = this._countTokenCallbacks.get(callId);
+        if (!fn) {
+            throw ( new Error(`Tool invocation call ${callId} not found`));
+        }
+        return fn(input, token);
     }
     $registerTool(name) {
         const disposable = this._languageModelToolsService.registerToolImplementation(name, {
-            invoke: async (parameters, token) => {
-                return await this._proxy.$invokeTool(name, parameters, token);
+            invoke: async (dto, countTokens, token) => {
+                try {
+                    this._countTokenCallbacks.set(dto.callId, countTokens);
+                    return await this._proxy.$invokeTool(dto, token);
+                }
+                finally {
+                    this._countTokenCallbacks.delete(dto.callId);
+                }
             },
         });
         this._tools.set(name, disposable);

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

@@ -129,7 +129,7 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
         if (this._authenticationService.getProviderIds().includes(authProviderId)) {
             return Disposable.None;
         }
-        const accountLabel = auth.accountLabel ?? ( localize(4828, 'Language Models'));
+        const accountLabel = auth.accountLabel ?? ( localize(4896, 'Language Models'));
         const disposables = ( (new DisposableStore()));
         this._authenticationService.registerAuthenticationProvider(authProviderId, ( (new LanguageModelAccessAuthProvider(authProviderId, auth.providerLabel, accountLabel))));
         disposables.add(toDisposable(() => {

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

@@ -51,13 +51,13 @@ let MainThreadMessageService = class MainThreadMessageService {
                     };
                 }
                 if (!source) {
-                    source = ( localize(4859, "Extension"));
+                    source = ( localize(4927, "Extension"));
                 }
                 const secondaryActions = [];
                 if (options.source) {
                     secondaryActions.push(toAction({
                         id: options.source.identifier.value,
-                        label: ( localize(4860, "Manage Extension")),
+                        label: ( localize(4928, "Manage Extension")),
                         run: () => {
                             return this._commandService.executeCommand('_extensions.manage', options.source.identifier.value);
                         }
@@ -93,13 +93,13 @@ let MainThreadMessageService = class MainThreadMessageService {
         if (!cancelButton) {
             if (buttons.length > 0) {
                 cancelButton = {
-                    label: ( localize(4861, "Cancel")),
+                    label: ( localize(4929, "Cancel")),
                     run: () => undefined
                 };
             }
             else {
                 cancelButton = {
-                    label: ( localize(4862, "&&OK")),
+                    label: ( localize(4930, "&&OK")),
                     run: () => undefined
                 };
             }

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

@@ -90,20 +90,31 @@ let MainThreadNotebookDocuments = class MainThreadNotebookDocuments {
         }
     }
     async $tryCreateNotebook(options) {
-        const ref = await this._notebookEditorModelResolverService.resolve({ untitledResource: undefined }, options.viewType);
-        ref.object.notebook.onWillDispose(() => {
-            ref.dispose();
-        });
-        this._proxy.$acceptDirtyStateChanged(ref.object.resource, true);
         if (options.content) {
-            const data = NotebookDto.fromNotebookDataDto(options.content);
-            ref.object.notebook.reset(data.cells, data.metadata, ref.object.notebook.transientOptions);
+            const ref = await this._notebookEditorModelResolverService.resolve({ untitledResource: undefined }, options.viewType);
+            ref.object.notebook.onWillDispose(() => {
+                ref.dispose();
+            });
+            this._proxy.$acceptDirtyStateChanged(ref.object.resource, true);
+            if (options.content) {
+                const data = NotebookDto.fromNotebookDataDto(options.content);
+                ref.object.notebook.reset(data.cells, data.metadata, ref.object.notebook.transientOptions);
+            }
+            return ref.object.notebook.uri;
+        }
+        else {
+            const notebook = await this._notebookEditorModelResolverService.createUntitledNotebookTextModel(options.viewType);
+            return notebook.uri;
         }
-        return ref.object.resource;
     }
     async $tryOpenNotebook(uriComponents) {
         const uri = URI.revive(uriComponents);
         const ref = await this._notebookEditorModelResolverService.resolve(uri, undefined);
+        if (uriComponents.scheme === 'untitled') {
+            ref.object.notebook.onWillDispose(() => {
+                ref.dispose();
+            });
+        }
         this._modelReferenceCollection.add(uri, ref);
         return uri;
     }

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

@@ -75,6 +75,7 @@ let MainThreadNotebookEditors = class MainThreadNotebookEditors {
             preserveFocus: options.preserveFocus,
             pinned: options.pinned,
             activation: options.preserveFocus ? EditorActivation.RESTORE : undefined,
+            label: options.label,
             override: viewType
         };
         const editorPane = await this._editorService.openEditor({ resource: URI.revive(resource), options: editorOptions }, columnToEditorGroup(this._editorGroupService, this._configurationService, options.position));

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

@@ -17,7 +17,7 @@ class ExtHostNotebookDocumentSaveParticipant {
         }
         let _warningTimeout;
         const p = ( (new Promise((resolve, reject) => {
-            _warningTimeout = setTimeout(() => reject(( (new Error(( localize(4874, "Aborted onWillSaveNotebookDocument-event after 1750ms")))))), 1750);
+            _warningTimeout = setTimeout(() => reject(( (new Error(( localize(4942, "Aborted onWillSaveNotebookDocument-event after 1750ms")))))), 1750);
             this._proxy.$participateInSave(workingCopy.resource, context.reason, token).then(_ => {
                 clearTimeout(_warningTimeout);
                 return undefined;

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

@@ -31,7 +31,7 @@ let MainThreadProgress = class MainThreadProgress {
             const notificationOptions = {
                 ...options,
                 location: ProgressLocation.Notification,
-                secondaryActions: [( (new ManageExtensionAction(extensionId, ( localize(4863, "Manage Extension")), this._commandService)))]
+                secondaryActions: [( (new ManageExtensionAction(extensionId, ( localize(4931, "Manage Extension")), this._commandService)))]
             };
             options = notificationOptions;
         }

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

@@ -3,6 +3,7 @@ import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/
 import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
 
 function reviveIconPathUris(iconPath) {
     iconPath.dark = URI.revive(iconPath.dark);
@@ -18,6 +19,9 @@ let MainThreadQuickOpen = class MainThreadQuickOpen {
         this._quickInputService = quickInputService;
     }
     dispose() {
+        for (const [_id, session] of this.sessions) {
+            session.store.dispose();
+        }
     }
     $show(instance, options, token) {
         const contents = ( new Promise((resolve, reject) => {
@@ -84,34 +88,37 @@ let MainThreadQuickOpen = class MainThreadQuickOpen {
         const sessionId = params.id;
         let session = this.sessions.get(sessionId);
         if (!session) {
+            const store = ( new DisposableStore());
             const input = params.type === 'quickPick' ? this._quickInputService.createQuickPick() : this._quickInputService.createInputBox();
-            input.onDidAccept(() => {
+            store.add(input);
+            store.add(input.onDidAccept(() => {
                 this._proxy.$onDidAccept(sessionId);
-            });
-            input.onDidTriggerButton(button => {
+            }));
+            store.add(input.onDidTriggerButton(button => {
                 this._proxy.$onDidTriggerButton(sessionId, button.handle);
-            });
-            input.onDidChangeValue(value => {
+            }));
+            store.add(input.onDidChangeValue(value => {
                 this._proxy.$onDidChangeValue(sessionId, value);
-            });
-            input.onDidHide(() => {
+            }));
+            store.add(input.onDidHide(() => {
                 this._proxy.$onDidHide(sessionId);
-            });
+            }));
             if (params.type === 'quickPick') {
                 const quickpick = input;
-                quickpick.onDidChangeActive(items => {
+                store.add(quickpick.onDidChangeActive(items => {
                     this._proxy.$onDidChangeActive(sessionId, ( items.map(item => item.handle)));
-                });
-                quickpick.onDidChangeSelection(items => {
+                }));
+                store.add(quickpick.onDidChangeSelection(items => {
                     this._proxy.$onDidChangeSelection(sessionId, ( items.map(item => item.handle)));
-                });
-                quickpick.onDidTriggerItemButton((e) => {
+                }));
+                store.add(quickpick.onDidTriggerItemButton((e) => {
                     this._proxy.$onDidTriggerItemButton(sessionId, e.item.handle, e.button.handle);
-                });
+                }));
             }
             session = {
                 input,
-                handlesToItems: ( new Map())
+                handlesToItems: ( new Map()),
+                store
             };
             this.sessions.set(sessionId, session);
         }
@@ -171,7 +178,7 @@ let MainThreadQuickOpen = class MainThreadQuickOpen {
     $dispose(sessionId) {
         const session = this.sessions.get(sessionId);
         if (session) {
-            session.input.dispose();
+            session.store.dispose();
             this.sessions.delete(sessionId);
         }
         return Promise.resolve(undefined);

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

@@ -141,6 +141,9 @@ class MainThreadSCMHistoryProvider {
         this.handle = handle;
         this.currentHistoryItemGroupId = derived(this, reader => this.currentHistoryItemGroup.read(reader)?.id);
         this.currentHistoryItemGroupName = derived(this, reader => this.currentHistoryItemGroup.read(reader)?.name);
+        this.currentHistoryItemGroupRevision = derived(this, reader => this.currentHistoryItemGroup.read(reader)?.revision);
+        this.currentHistoryItemGroupRemoteId = derived(this, reader => this.currentHistoryItemGroup.read(reader)?.remote?.id);
+        this.currentHistoryItemGroupRemoteRevision = derived(this, reader => this.currentHistoryItemGroup.read(reader)?.remote?.revision);
         this._currentHistoryItemGroup = observableValueOpts({ owner: this, equalsFn: () => false }, undefined);
     }
     async resolveHistoryItemGroupCommonAncestor(historyItemGroupId1, historyItemGroupId2) {

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

@@ -16,7 +16,7 @@ class ExtHostSaveParticipant {
             return undefined;
         }
         const p = ( (new Promise((resolve, reject) => {
-            setTimeout(() => reject(( (new Error(( localize(4864, "Aborted onWillSaveTextDocument-event after 1750ms")))))), 1750);
+            setTimeout(() => reject(( (new Error(( localize(4932, "Aborted onWillSaveTextDocument-event after 1750ms")))))), 1750);
             this._proxy.$participateInSave(editorModel.resource, context.reason).then(values => {
                 if (!values.every(success => success)) {
                     return Promise.reject(( (new Error('listener failed'))));

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

@@ -377,7 +377,7 @@ var TaskDTO;
         }
         command.presentation = TaskPresentationOptionsDTO.to(task.presentationOptions);
         const source = TaskSourceDTO.to(task.source, workspace);
-        const label = ( localize(4875, '{0}: {1}', source.label, task.name));
+        const label = ( localize(4943, '{0}: {1}', source.label, task.name));
         const definition = TaskDefinitionDTO.to(task.definition, executeOnly);
         const id = (CustomExecutionDTO.is(task.execution) && task._id) ? task._id : `${task.source.extensionId}.${definition._key}`;
         const result = ( (new

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

@@ -36,7 +36,7 @@ let MainThreadTerminalShellIntegration = class MainThreadTerminalShellIntegratio
             const instanceId = e.instance.instanceId;
             this._proxy.$shellExecutionStart(instanceId, e.data.command, convertToExtHostCommandLineConfidence(e.data), e.data.isTrusted, this._convertCwdToUri(e.data.cwd));
             instanceDataListeners.get(instanceId)?.dispose();
-            instanceDataListeners.set(instanceId, Event.accumulate(e.instance.onData, 50, this._store)(events => this._proxy.$shellExecutionData(instanceId, events.join())));
+            instanceDataListeners.set(instanceId, Event.accumulate(e.instance.onData, 50, this._store)(events => this._proxy.$shellExecutionData(instanceId, events.join(''))));
         }));
         const commandDetectionEndEvent = this._store.add(this._terminalService.createOnInstanceCapabilityEvent(TerminalCapability.CommandDetection, e => e.onCommandFinished));
         this._store.add(commandDetectionEndEvent.event(e => {